diff --git a/.changeset/config.json b/.changeset/config.json
index cc95104ae..3cc2d41b1 100644
--- a/.changeset/config.json
+++ b/.changeset/config.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
+  "$schema": "https://unpkg.com/@changesets/config@3.1.2/schema.json",
   "changelog": [
     "@svitejs/changesets-changelog-github-compact",
     { "repo": "TanStack/db" }
@@ -10,5 +10,8 @@
   "updateInternalDependencies": "patch",
   "fixed": [],
   "linked": [],
-  "ignore": []
+  "ignore": [],
+  "___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH": {
+    "onlyUpdatePeerDependentsWhenOutOfRange": true
+  }
 }
diff --git a/.changeset/in-memory-fallback-for-ssr.md b/.changeset/in-memory-fallback-for-ssr.md
deleted file mode 100644
index 5afb61018..000000000
--- a/.changeset/in-memory-fallback-for-ssr.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-"@tanstack/db": patch
----
-
-Add in-memory fallback for localStorage collections in SSR environments
-
-Prevents errors when localStorage collections are imported on the server by automatically falling back to an in-memory store. This allows isomorphic JavaScript applications to safely import localStorage collection modules without errors during module initialization.
-
-When localStorage is not available (e.g., in server-side rendering environments), the collection automatically uses an in-memory storage implementation. Data will not persist across page reloads or be shared across tabs when using the in-memory fallback, but the collection will function normally otherwise.
-
-Fixes #691
diff --git a/.claude/settings.local.json b/.claude/settings.local.json
new file mode 100644
index 000000000..f3509559e
--- /dev/null
+++ b/.claude/settings.local.json
@@ -0,0 +1,5 @@
+{
+  "permissions": {
+    "allow": ["Bash(git checkout:*)", "Bash(npx sherif:*)"]
+  }
+}
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 8fbf8f760..b39f31408 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,9 +1,9 @@
 ---
 name: 🐛 Bug Report
 about: Create a report to help us improve
-title: ""
-labels: ""
-assignees: ""
+title: ''
+labels: ''
+assignees: ''
 ---
 
 - [ ] I've validated the bug against the latest version of DB packages
diff --git a/.github/workflows/autofix.yml b/.github/workflows/autofix.yml
index 933a6edc4..e98a12985 100644
--- a/.github/workflows/autofix.yml
+++ b/.github/workflows/autofix.yml
@@ -18,14 +18,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5.0.0
+        uses: actions/checkout@v6.0.1
         with:
           fetch-depth: 0
       - name: Setup Tools
         uses: tanstack/config/.github/setup@main
       - name: Fix formatting
-        run: pnpm prettier --ignore-unknown . --check
+        run: pnpm format
       - name: Apply fixes
         uses: autofix-ci/action@635ffb0c9798bd160680f18fd73371e355b85f27
         with:
-          commit-message: "ci: apply automated fixes"
+          commit-message: 'ci: apply automated fixes'
diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml
new file mode 100644
index 000000000..c4bb5e220
--- /dev/null
+++ b/.github/workflows/claude.yml
@@ -0,0 +1,27 @@
+name: Claude Code
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude') && (github.event.comment.user.login == 'kevin-dp' || github.event.comment.user.login == 'KyleAMathews' || github.event.comment.user.login == 'samwillis')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude') && (github.event.comment.user.login == 'kevin-dp' || github.event.comment.user.login == 'KyleAMathews' || github.event.comment.user.login == 'samwillis'))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6.0.1
+        with:
+          fetch-depth: 0 # required for Claude Code
+      - uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          # Responds to @claude mentions in comments
diff --git a/.github/workflows/e2e-tests.yml b/.github/workflows/e2e-tests.yml
new file mode 100644
index 000000000..386636175
--- /dev/null
+++ b/.github/workflows/e2e-tests.yml
@@ -0,0 +1,77 @@
+name: E2E Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  e2e-tests:
+    name: Run E2E Tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6.0.1
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10.27.0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'pnpm'
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Start Docker services
+        run: |
+          cd packages/db-collection-e2e/docker
+          docker compose up -d
+          echo "Waiting for services to be healthy..."
+          timeout 60 bash -c 'until docker compose ps | grep -q "healthy"; do sleep 2; done'
+
+      - name: Build packages
+        run: |
+          pnpm --filter @tanstack/db-ivm build
+          pnpm --filter @tanstack/db build
+          pnpm --filter @tanstack/electric-db-collection build
+          pnpm --filter @tanstack/query-db-collection build
+
+      - name: Run Electric E2E tests
+        run: |
+          cd packages/electric-db-collection
+          pnpm test:e2e
+        env:
+          ELECTRIC_URL: http://localhost:3000
+          POSTGRES_HOST: localhost
+          POSTGRES_PORT: 54321
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: password
+          POSTGRES_DB: e2e_test
+
+      - name: Run Query E2E tests
+        run: |
+          cd packages/query-db-collection
+          pnpm test:e2e
+        env:
+          ELECTRIC_URL: http://localhost:3000
+
+      - name: Stop Docker services
+        if: always()
+        run: |
+          cd packages/db-collection-e2e/docker
+          docker compose down -v
+
+      - name: Upload test results
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results
+          path: packages/db-collection-e2e/junit/
+          retention-days: 7
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index 472b8ec28..64525c50b 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -23,23 +23,37 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5.0.0
+        uses: actions/checkout@v6.0.1
         with:
           fetch-depth: 0
       - name: Setup Tools
         uses: tanstack/config/.github/setup@main
       - name: Get base and head commits for `nx affected`
-        uses: nrwl/nx-set-shas@v4.3.3
+        uses: nrwl/nx-set-shas@v4.4.0
         with:
           main-branch-name: main
       - name: Run Checks
-        run: pnpm run lint && pnpm run build && pnpm run test
+        run: pnpm run build && pnpm run test
+      - name: Check dependency versions
+        run: |
+          if ! pnpm run test:sherif; then
+            echo ""
+            echo "=========================================="
+            echo "❌ Sherif found dependency version mismatches"
+            echo ""
+            echo "To fix this locally, run:"
+            echo "  pnpm exec sherif --fix -i zod"
+            echo ""
+            echo "Then commit the changes to package.json files."
+            echo "=========================================="
+            exit 1
+          fi
   preview:
     name: Preview
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5.0.0
+        uses: actions/checkout@v6.0.1
         with:
           fetch-depth: 0
       - name: Setup Tools
@@ -51,21 +65,23 @@ jobs:
       - name: Compressed Size Action - DB Package
         uses: preactjs/compressed-size-action@v2
         with:
-          repo-token: "${{ secrets.GITHUB_TOKEN }}"
-          pattern: "./packages/db/dist/**/*.{js,mjs}"
-          comment-key: "db-package-size"
+          repo-token: '${{ secrets.GITHUB_TOKEN }}'
+          pattern: './packages/db/dist/**/*.{js,mjs}'
+          comment-key: 'db-package-size'
+          build-script: 'build:minified'
       - name: Compressed Size Action - React DB Package
         uses: preactjs/compressed-size-action@v2
         with:
-          repo-token: "${{ secrets.GITHUB_TOKEN }}"
-          pattern: "./packages/react-db/dist/**/*.{js,mjs}"
-          comment-key: "react-db-package-size"
+          repo-token: '${{ secrets.GITHUB_TOKEN }}'
+          pattern: './packages/react-db/dist/**/*.{js,mjs}'
+          comment-key: 'react-db-package-size'
+          build-script: 'build:minified'
   build-example:
     name: Build Example Site
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5.0.0
+        uses: actions/checkout@v6.0.1
       - name: Setup Tools
         uses: tanstack/config/.github/setup@main
       - name: Build Packages
@@ -79,7 +95,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5.0.0
+        uses: actions/checkout@v6.0.1
       - name: Setup Tools
         uses: tanstack/config/.github/setup@main
       - name: Build Packages
@@ -87,4 +103,5 @@ jobs:
       - name: Build Starter Site
         run: |
           cd examples/react/projects
+          cp .env.example .env
           pnpm build
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 155b5ae7d..2e49cf139 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -23,7 +23,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5.0.0
+        uses: actions/checkout@v6.0.1
         with:
           fetch-depth: 0
       - name: Setup Tools
@@ -36,11 +36,36 @@ jobs:
         with:
           version: pnpm run changeset:version
           publish: pnpm run changeset:publish
-          commit: "ci: Version Packages"
-          title: "ci: Version Packages"
+          commit: 'ci: Version Packages'
+          title: 'ci: Version Packages'
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Generate Docs
+        if: steps.changesets.outputs.published == 'true'
+        run: pnpm generate-docs
+      - name: Commit Generated Docs
+        if: steps.changesets.outputs.published == 'true'
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            git config user.name "github-actions[bot]"
+            git config user.email "github-actions[bot]@users.noreply.github.com"
+
+            BRANCH="docs/auto-update-$(date +%s)"
+            git checkout -b "$BRANCH"
+            git add docs/
+            git commit -m "docs: regenerate API documentation"
+            git push origin "$BRANCH"
+
+            gh pr create \
+              --title "docs: regenerate API documentation" \
+              --body "Automated documentation update from release" \
+              --base main \
+              --head "$BRANCH"
+          else
+            echo "No changes in generated docs"
+          fi
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - name: Comment on PRs about release
         if: steps.changesets.outputs.published == 'true'
         uses: tanstack/config/.github/comment-on-release@main
diff --git a/.github/workflows/reproduce-and-fix-issue-claude.yml b/.github/workflows/reproduce-and-fix-issue-claude.yml
new file mode 100644
index 000000000..b4d810756
--- /dev/null
+++ b/.github/workflows/reproduce-and-fix-issue-claude.yml
@@ -0,0 +1,147 @@
+name: Claude Auto Issue Fix
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  claude_auto_issue_fix:
+    # Only run when a maintainer comments with /reproduce on an issue
+    # Exclude Claude's own comments to prevent recursive triggers
+    if: |
+      github.event.issue != null &&
+      github.actor != 'claude[bot]' &&
+      contains(github.event.comment.body, '/reproduce') &&
+      (github.event.comment.user.login == 'kevin-dp' || github.event.comment.user.login == 'KyleAMathews' || github.event.comment.user.login == 'samwillis')
+    runs-on: ubuntu-latest
+    # Prevent multiple runs for the same issue
+    concurrency:
+      group: claude-auto-issue-${{ github.repository }}-${{ github.event.issue.number }}
+      cancel-in-progress: false
+
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+      id-token: write
+      actions: read
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6.0.1
+        with:
+          fetch-depth: 0
+
+      - name: Run Claude Code (auto issue handler)
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          claude_args: |
+            --model claude-opus-4-5
+            --allowedTools Bash,Edit,Read,Write
+          prompt: |
+            You are an autonomous coding agent running in CI for this repository.
+            This workflow runs when a maintainer requests issue analysis by commenting "/reproduce" on an issue.
+
+            === Context ===
+            REPO: ${{ github.repository }}
+            ISSUE NUMBER: ${{ github.event.issue.number }}
+            ISSUE TITLE: ${{ github.event.issue.title }}
+            ISSUE URL: ${{ github.event.issue.html_url }}
+
+            ISSUE BODY:
+            ${{ github.event.issue.body }}
+
+            === Goal ===
+            Apply a strict “repro test → fix” methodology. Produce exactly ONE of these outcomes:
+            1) Repro PR + Fix PR (preferred for actionable bugs)
+            2) Repro PR only (if reproducible but cannot fix)
+            3) Comment-only “Needs info / Not actionable / Question answer draft”
+            No other outcomes.
+
+            === Hard rules (non-negotiable) ===
+            - Never claim reproduction unless a test fails due to a concrete behavioral assertion.
+            - Never use "does not throw / does not crash" as the primary assertion unless:
+              (a) the issue explicitly says throwing is the bug, AND
+              (b) the correct behavior is explicitly "should not throw".
+            - Never "fix" by skipping, swallowing, or ignoring the problematic case
+              (e.g. guard clauses / try-catch that hides the error) unless the issue explicitly says that is correct.
+              Any conditional handling must still implement the intended behavior.
+            - Do not weaken tests to make them pass. Do not remove assertions. Do not skip tests. Do not mark flaky.
+            - Keep changes minimal and scoped. No refactors. No drive-by formatting.
+            - If expected behavior is unclear or not testable, STOP and request the minimum missing info.
+            - NEVER add issue references (e.g. "issue #1152", "#1152", "Issue 1152") in the codebase itself.
+              This includes test names, code comments, variable names, or any other code artifacts.
+              Issue references are ONLY allowed in: branch names, commit messages, PR titles, PR bodies, and GitHub comments.
+              Test names and code comments should be purely descriptive of current behavior, no description of old behavior and do not reference where the bug was reported.
+
+            === Step 0: Determine actionability ===
+            From the issue, extract:
+            - Expected behavior (must be explicit & testable)
+            - Actual behavior
+            - Repro steps / minimal example
+            If you cannot extract a testable expected behavior:
+            - Post a GitHub comment requesting the minimum missing details (inputs, expected outputs, versions, etc.)
+            - Stop (no PRs)
+
+            === Step 1: Reproduction test (behavioral oracle) ===
+            Create a minimal unit/integration test that asserts the expected behavior:
+            - Test name must describe the intended behavior only (e.g. "updates cache entry when using computed query key").
+              Do NOT include issue numbers or references in test names (BAD: "fixes issue #1152", "issue 1152 regression").
+            - Assert concrete outcomes: returned values, state transitions, emitted events, persisted data, etc.
+            - Add at least one "anti-noop" assertion that would fail if the code simply "does nothing"
+              (e.g. verify a state change, returned value, side effect).
+            - If the issue involves an error, prefer asserting correct error type/message or correct recovery/result.
+            - Do NOT add comments in the test code referencing the issue number.
+
+            === Step 2: Prove it reproduces on base ===
+            Run tests on base:
+            - Confirm the new test FAILS due to assertion mismatch (not due to broken test setup).
+            If the test passes on base:
+            - Do NOT fake a repro by weakening assertions.
+            - If the issue seems intermittent, attempt to make repro deterministic; otherwise comment “not reproducible” and stop.
+
+            Commit repro and open PR:
+            - Branch: ai/issue-${{ github.event.issue.number }}-repro
+            - Commit message: test: assert <expected behavior> (issue #${{ github.event.issue.number }})
+            - PR title: [repro] <short behavior> (issue #${{ github.event.issue.number }})
+            - PR body: link issue + what test asserts + how to run + observed failure
+
+            === Step 3: Fix (stacked on repro) ===
+            Create fix branch from repro branch:
+            - Branch: ai/issue-${{ github.event.issue.number }}-fix
+            Implement the minimal fix.
+            Validation:
+            - Previously failing test MUST now pass.
+            - Fix must not be a no-op.
+            - If you add guards/conditionals, justify why it's correct behavior (not hiding bug),
+              and ensure intended work still occurs.
+            - Code comments should explain the "why" of the fix, NOT reference the issue number.
+              BAD: "Issue #1152: Fixed cache lookup"
+              GOOD: "Use the actual query key for cache lookup, not just the base key"
+
+            Commit fix and open stacked PR:
+            - Commit message: fix: <short behavior> (issue #${{ github.event.issue.number }})
+            - PR title: [fix] <short behavior> (issue #${{ github.event.issue.number }})
+            - PR body: link issue + link repro PR + root cause + fix explanation + how to test
+
+            === If stuck ===
+            If you cannot fix without derailing:
+            - Still open the repro PR if it's valid (high value).
+            - Post a comment summarizing findings and blockers.
+            - Do NOT force a “fix” that silences symptoms.
+
+            === Quality checklist (must satisfy before marking fixed) ===
+            - [ ] Expected behavior asserted (not "no throw" unless truly correct)
+            - [ ] Test fails on base for the right reason
+            - [ ] Fix makes test pass without weakening assertions
+            - [ ] Fix is not "skip/swallow/ignore"
+            - [ ] Changes minimal and scoped
+
+            === Final comment ===
+            After completing your work, always post a comment on the original issue summarizing what you did:
+            - If you opened PRs: link to the repro PR and fix PR (if created)
+            - Briefly describe what the test asserts and what the fix does
+            - If you couldn't complete the task: explain what you found and what's blocking progress
+
+            Proceed now.
diff --git a/.github/workflows/review-pr-claude.yml b/.github/workflows/review-pr-claude.yml
new file mode 100644
index 000000000..e40e97580
--- /dev/null
+++ b/.github/workflows/review-pr-claude.yml
@@ -0,0 +1,80 @@
+name: Claude PR Review
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  claude_pr_review:
+    # Only run when a maintainer comments with /review on a PR
+    # Exclude Claude's own comments to prevent recursive triggers
+    if: |
+      github.event.issue.pull_request != null &&
+      github.actor != 'claude[bot]' &&
+      contains(github.event.comment.body, '/review') &&
+      (github.event.comment.user.login == 'kevin-dp' || github.event.comment.user.login == 'KyleAMathews' || github.event.comment.user.login == 'samwillis')
+    runs-on: ubuntu-latest
+    # Prevent multiple concurrent reviews for the same PR
+    concurrency:
+      group: claude-pr-review-${{ github.repository }}-${{ github.event.issue.number }}
+      cancel-in-progress: false
+
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+      id-token: write
+      actions: read
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6.0.1
+        with:
+          fetch-depth: 0
+
+      - name: Get PR branch
+        id: pr-info
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          PR_DATA=$(gh pr view ${{ github.event.issue.number }} --json headRefName,baseRefName)
+          echo "head_ref=$(echo $PR_DATA | jq -r '.headRefName')" >> $GITHUB_OUTPUT
+          echo "base_ref=$(echo $PR_DATA | jq -r '.baseRefName')" >> $GITHUB_OUTPUT
+
+      - name: Checkout PR branch
+        run: git checkout ${{ steps.pr-info.outputs.head_ref }}
+
+      - name: Run Claude Code (PR review)
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
+          plugins: 'pr-review-toolkit'
+          claude_args: |
+            --model claude-opus-4-5
+            --allowedTools Bash,Read,Glob,Grep,Task,Skill
+          prompt: |
+            You are an autonomous PR review agent running in CI for this repository.
+
+            === Context ===
+            REPO: ${{ github.repository }}
+            PR NUMBER: ${{ github.event.issue.number }}
+            PR TITLE: ${{ github.event.issue.title }}
+            PR URL: ${{ github.event.issue.html_url }}
+            BASE BRANCH: ${{ steps.pr-info.outputs.base_ref }}
+            HEAD BRANCH: ${{ steps.pr-info.outputs.head_ref }}
+
+            COMMENT (may specify review aspects like "/review tests" or "/review errors code"):
+            ${{ github.event.comment.body }}
+
+            === Task ===
+            Run the /pr-review-toolkit:review-pr skill to perform a comprehensive multi-agent code review.
+
+            Parse any review aspects from the comment (e.g., "tests", "errors", "code", "types", "comments", "simplify", "all").
+            Pass these as arguments to the skill. Default to "all" if none specified.
+
+            After the review completes, post the findings as a comment on PR #${{ github.event.issue.number }} using `gh pr comment`.
+
+            This is a read-only review. Do NOT make any edits or commits.
+
+            Proceed now.
diff --git a/.gitignore b/.gitignore
index 528e53f21..1cbcf6ed2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,153 +1,45 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-lerna-debug.log*
-.pnpm-debug.log*
-
-# Diagnostic reports (https://nodejs.org/api/report.html)
-report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
 
-# Runtime data
-pids
-*.pid
-*.seed
-*.pid.lock
+# See https://help.github.com/ignore-files/ for more about ignoring files.
 
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
+# dependencies
+node_modules
+package-lock.json
+yarn.lock
 
-# Coverage directory used by tools like istanbul
+# builds
+build
 coverage
-*.lcov
-
-# nyc test coverage
-.nyc_output
-
-# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# Bower dependency directory (https://bower.io/)
-bower_components
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (https://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-node_modules/
-jspm_packages/
-
-# Snowpack dependency directory (https://snowpack.dev/)
-web_modules/
-
-# TypeScript cache
-*.tsbuildinfo
-
-# Optional npm cache directory
-.npm
-
-# Optional eslint cache
-.eslintcache
-
-# Optional stylelint cache
-.stylelintcache
-
-# Microbundle cache
-.rpt2_cache/
-.rts2_cache_cjs/
-.rts2_cache_es/
-.rts2_cache_umd/
-
-# Optional REPL history
-.node_repl_history
-
-# Output of 'npm pack'
-*.tgz
-
-# Yarn Integrity file
-.yarn-integrity
+dist
 
-# dotenv environment variable files
+# misc
+.DS_Store
 .env
+.env.local
 .env.development.local
 .env.test.local
 .env.production.local
-.env.local
-
-# parcel-bundler cache (https://parceljs.org/)
-.cache
-.parcel-cache
-
-# Next.js build output
 .next
-out
 
-# Nuxt.js build / generate output
-.nuxt
-dist
-
-# Gatsby files
-.cache/
-# Comment in the public line in if your project uses Gatsby and not Next.js
-# https://nextjs.org/blog/next-9-1#public-directory-support
-# public
-
-# vuepress build output
-.vuepress/dist
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.history
+size-plugin.json
+stats-hydration.json
+stats.json
+stats.html
+.vscode/settings.json
 
-# vuepress v2.x temp and cache directory
-.temp
+*.log
 .cache
-
-# Docusaurus cache and generated files
-.docusaurus
-
-# Serverless directories
-.serverless/
-
-# FuseBox cache
-.fusebox/
-
-# DynamoDB Local files
-.dynamodb/
-
-# TernJS port file
-.tern-port
-
-# Stores VSCode versions used for testing VSCode extensions
-.vscode-test
-
-# yarn v2
-.yarn/cache
-.yarn/unplugged
-.yarn/build-state.yml
-.yarn/install-state.gz
-.pnp.*
-.DS_Store
-
-# Added by Task Master AI
-dev-debug.log
-# Environment variables
-# Editor directories and files
 .idea
-.vscode
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?
-# OS specific
-# Task files
-tasks.json
-tasks/ 
-
-## Tanstack Start
-.nitro
-.output
-.tanstack
-.claude
+.nx/cache
+.nx/workspace-data
+.pnpm-store
+.tsup
+.svelte-kit
+.expo
+
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
+tsconfig.vitest-temp.json
diff --git a/.husky/pre-commit b/.husky/pre-commit
index a5a29d9f7..cb2c84d5c 100755
--- a/.husky/pre-commit
+++ b/.husky/pre-commit
@@ -1,4 +1 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
 pnpm lint-staged
diff --git a/.prettierrc b/.prettierrc
deleted file mode 100644
index eaff0359c..000000000
--- a/.prettierrc
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "trailingComma": "es5",
-  "semi": false,
-  "tabWidth": 2
-}
diff --git a/.tool-versions b/.tool-versions
new file mode 100644
index 000000000..0bfe39ff1
--- /dev/null
+++ b/.tool-versions
@@ -0,0 +1,2 @@
+pnpm 10.26.0
+nodejs 22.13.1
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 000000000..6654f89bf
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,647 @@
+# Agent Coding Guidelines for TanStack DB
+
+This guide provides principles and patterns for AI agents contributing to the TanStack DB codebase. These guidelines are derived from PR review patterns and reflect the quality standards expected in this project.
+
+## Table of Contents
+
+1. [Type Safety](#type-safety)
+2. [Code Organization](#code-organization)
+3. [Algorithm Efficiency](#algorithm-efficiency)
+4. [Semantic Correctness](#semantic-correctness)
+5. [Abstraction Design](#abstraction-design)
+6. [Code Clarity](#code-clarity)
+7. [Testing Requirements](#testing-requirements)
+8. [Function Design](#function-design)
+9. [Modern JavaScript Patterns](#modern-javascript-patterns)
+10. [Edge Cases and Corner Cases](#edge-cases-and-corner-cases)
+
+## Type Safety
+
+### Avoid `any` Types
+
+**❌ Bad:**
+
+```typescript
+function processData(data: any) {
+  return data.value
+}
+
+const result: any = someOperation()
+```
+
+**✅ Good:**
+
+```typescript
+function processData(data: unknown) {
+  if (isDataObject(data)) {
+    return data.value
+  }
+  throw new Error('Invalid data')
+}
+
+const result: TQueryData = someOperation()
+```
+
+**Key Principles:**
+
+- Use `unknown` instead of `any` when the type is truly unknown
+- Provide proper type annotations for return values
+- Use type guards to narrow `unknown` types safely
+- If you find yourself using `any`, question whether there's a better type
+
+## Code Organization
+
+### Extract Common Logic
+
+**❌ Bad:**
+
+```typescript
+// Duplicated logic in multiple places
+function processA() {
+  const key = typeof value === 'number' ? `__number__${value}` : String(value)
+  // ...
+}
+
+function processB() {
+  const key = typeof value === 'number' ? `__number__${value}` : String(value)
+  // ...
+}
+```
+
+**✅ Good:**
+
+```typescript
+function serializeKey(value: string | number): string {
+  return typeof value === 'number' ? `__number__${value}` : String(value)
+}
+
+function processA() {
+  const key = serializeKey(value)
+  // ...
+}
+
+function processB() {
+  const key = serializeKey(value)
+  // ...
+}
+```
+
+### Organize Utilities
+
+**Key Principles:**
+
+- Extract serialization/deserialization logic into utility files
+- When you see identical or near-identical code blocks, extract to a helper function
+- Prefer small, focused utility functions over large inline implementations
+- Move reusable logic into utility modules (e.g., `utils/`, `helpers/`)
+
+### Function Size and Complexity
+
+**❌ Bad:**
+
+```typescript
+function syncData() {
+  // 200+ lines of logic handling multiple concerns
+  // - snapshot phase
+  // - buffering
+  // - sync state management
+  // - error handling
+  // all inline...
+}
+```
+
+**✅ Good:**
+
+```typescript
+function syncData() {
+  handleSnapshotPhase()
+  manageBuffering()
+  updateSyncState()
+  handleErrors()
+}
+
+function handleSnapshotPhase() {
+  // Focused logic for snapshot phase
+}
+```
+
+**Key Principle:** If a function is massive, extract logical sections into separate functions. This improves readability and maintainability.
+
+## Algorithm Efficiency
+
+### Be Mindful of Time Complexity
+
+**❌ Bad: O(n²) Queue Processing:**
+
+```typescript
+// Processes elements in queue, but elements may need multiple passes
+while (queue.length > 0) {
+  const job = queue.shift()
+  if (hasUnmetDependencies(job)) {
+    queue.push(job) // Re-queue, causing O(n²) behavior
+  } else {
+    processJob(job)
+  }
+}
+```
+
+**✅ Good: Dependency-Aware Processing:**
+
+```typescript
+// Use a data structure that respects dependencies
+// Process only jobs with no unmet dependencies
+// Consider topological sort for DAG-like structures
+const readyJobs = jobs.filter((job) => !hasUnmetDependencies(job))
+readyJobs.forEach(processJob)
+```
+
+### Use Appropriate Data Structures
+
+**❌ Bad:**
+
+```typescript
+// O(n) lookup for each check
+const items = ['foo', 'bar', 'baz' /* hundreds more */]
+if (items.includes(searchValue)) {
+  // ...
+}
+```
+
+**✅ Good:**
+
+```typescript
+// O(1) lookup
+const items = new Set(['foo', 'bar', 'baz' /* hundreds more */])
+if (items.has(searchValue)) {
+  // ...
+}
+```
+
+**Key Principles:**
+
+- For membership checks on large collections, use `Set` instead of `Array.includes()`
+- Be aware of nested loops and their complexity implications
+- Consider the worst-case scenario, especially for operations that could process many items
+- Use appropriate data structures (Set for lookups, Map for key-value, etc.)
+
+## Semantic Correctness
+
+### Ensure Logic Matches Intent
+
+**❌ Bad:**
+
+```typescript
+// Intending to check if subset limit is more restrictive than superset
+function isLimitSubset(
+  subset: number | undefined,
+  superset: number | undefined,
+) {
+  return subset === undefined || superset === undefined || subset <= superset
+}
+
+// Problem: If subset has no limit but superset does, returns true (incorrect)
+```
+
+**✅ Good:**
+
+```typescript
+function isLimitSubset(
+  subset: number | undefined,
+  superset: number | undefined,
+) {
+  // Subset with no limit cannot be a subset of one with a limit
+  return superset === undefined || (subset !== undefined && subset <= superset)
+}
+```
+
+### Validate Intersections and Unions
+
+When merging predicates or combining queries, ensure the semantics are correct:
+
+**Example Problem:**
+
+```sql
+-- Query 1: WHERE age >= 18 LIMIT 1
+-- Query 2: WHERE age >= 20 LIMIT 3
+-- Naive intersection: WHERE age >= 20 LIMIT 1
+-- Problem: This may not return the actual intersection of results
+```
+
+**Key Principle:** Think carefully about what operations like intersection, union, and subset mean for your specific use case. Consider edge cases with limits, ordering, and predicates.
+
+## Abstraction Design
+
+### Avoid Leaky Abstractions
+
+**❌ Bad:**
+
+```typescript
+class Collection {
+  getViewKey(key: TKey): string {
+    // Caller needs to know internal representation
+    return `${this._state.viewKeyPrefix}${key}`
+  }
+}
+
+// Usage exposes internals
+const viewKey = collection.getViewKey(key)
+if (viewKey.startsWith(PREFIX)) {
+  /* ... */
+}
+```
+
+**✅ Good:**
+
+```typescript
+class Collection {
+  getViewKey(key: TKey): string {
+    // Delegate to state manager, hiding implementation
+    return this._state.getViewKey(key)
+  }
+}
+
+class CollectionStateManager {
+  getViewKey(key: TKey): string {
+    return `${this.viewKeyPrefix}${key}`
+  }
+}
+```
+
+**Key Principles:**
+
+- Encapsulate implementation details within the responsible class
+- Don't expose internal data structures or representations
+- Use delegation to maintain clean boundaries between components
+- Keep internal properties private when possible
+
+### Proper Encapsulation
+
+**Key Principle:** If you need to access a property or method from outside a class, add a public method that delegates to the internal implementation rather than exposing the internal property directly.
+
+## Code Clarity
+
+### Prefer Positive Predicates
+
+**❌ Bad:**
+
+```typescript
+if (!refs.some((ref) => ref.path[0] === outerAlias)) {
+  // treat as safe
+}
+```
+
+**✅ Good:**
+
+```typescript
+if (refs.every((ref) => ref.path[0] !== outerAlias)) {
+  // treat as safe
+}
+```
+
+**Key Principle:** Positive conditions (every, all) are generally easier to understand than negated conditions (not some).
+
+### Simplify Complex Conditions
+
+**❌ Bad:**
+
+```typescript
+const isLoadingNow = this.pendingLoadSubsetPromises.size > 0
+if (isLoadingNow && !isLoadingNow) {
+  // Confusing logic
+}
+```
+
+**✅ Good:**
+
+```typescript
+const wasLoading = this.pendingLoadSubsetPromises.size > 0
+this.pendingLoadSubsetPromises.add(promise)
+const isLoadingNow = this.pendingLoadSubsetPromises.size === 1
+
+if (isLoadingNow) {
+  // Started loading
+}
+```
+
+### Use Descriptive Names
+
+**❌ Bad:**
+
+```typescript
+const viewKeysMap = new Map() // Type in name is redundant
+const dependencyBuilders = [] // Sounds like functions that build
+```
+
+**✅ Good:**
+
+```typescript
+const viewKeys = new Map() // Data structure not in name
+const dependentBuilders = [] // Accurately describes dependents
+```
+
+**Key Principles:**
+
+- Avoid Hungarian notation (encoding type in variable name)
+- Use names that describe the role or purpose, not the data structure
+- Choose names that make the code read like prose
+- Prefer `dependentBuilders` over `dependencyBuilders` when referring to things that depend on something
+
+## Testing Requirements
+
+### Always Add Tests for Bugs
+
+**Key Principle:** If you're fixing a bug, add a unit test that reproduces the bug before fixing it. This ensures:
+
+- The bug is actually fixed
+- The bug doesn't regress in the future
+- The fix is validated
+
+**Example:**
+
+```typescript
+// Found a bug with fetchSnapshot resolving after up-to-date message
+// Should add a test:
+test('ignores snapshot that resolves after up-to-date message', async () => {
+  // Reproduce the corner case
+  // Verify it's handled correctly
+})
+```
+
+### Test Corner Cases
+
+Common corner cases to consider:
+
+- Empty arrays or sets
+- Single-element collections
+- `undefined` vs `null` values
+- Operations on already-resolved promises
+- Race conditions between async operations
+- Limit/offset edge cases (0, 1, very large numbers)
+- IN predicates with 0 or 1 elements
+
+## Function Design
+
+### Prefer Explicit Parameters Over Closures
+
+**❌ Bad:**
+
+```typescript
+function outer() {
+  const config = getConfig()
+  const state = getState()
+
+  const updateFn = () => {
+    // Closes over config and state
+    applyUpdate(config, state)
+  }
+
+  scheduler.schedule(updateFn)
+}
+```
+
+**✅ Good:**
+
+```typescript
+function updateEntry(entry: Entry, config: Config, state: State) {
+  applyUpdate(entry, config, state)
+}
+
+function outer() {
+  const config = getConfig()
+  const state = getState()
+
+  scheduler.schedule({
+    config,
+    state,
+    update: updateEntry,
+  })
+}
+```
+
+**Key Principles:**
+
+- Functions that take dependencies as arguments are easier to test
+- Explicit parameters make data flow clearer
+- Closures can hide dependencies and make code harder to follow
+- Use closures when they genuinely simplify the code, but be intentional
+
+### Return Type Precision
+
+**❌ Bad:**
+
+```typescript
+function serializeKey(key: string | number): unknown {
+  return String(key)
+}
+```
+
+**✅ Good:**
+
+```typescript
+function serializeKey(key: string | number): string {
+  return String(key)
+}
+```
+
+**Key Principle:** Always provide the most precise return type. Avoid `unknown` or `any` return types unless truly necessary.
+
+## Modern JavaScript Patterns
+
+### Use Modern Operators
+
+**❌ Bad:**
+
+```typescript
+if (firstError === undefined) {
+  firstError = error
+}
+
+const value = cached !== null && cached !== undefined ? cached : defaultValue
+
+if (obj[key] === undefined) {
+  obj[key] = value
+}
+```
+
+**✅ Good:**
+
+```typescript
+firstError ??= error
+
+const value = cached ?? defaultValue
+
+obj[key] ??= value
+```
+
+### Use Spread Operator
+
+**❌ Bad:**
+
+```typescript
+const combined = []
+for (const item of currentItems) {
+  combined.push(item)
+}
+for (const item of newItems) {
+  combined.push(item)
+}
+```
+
+**✅ Good:**
+
+```typescript
+const combined = [...currentItems, ...newItems]
+```
+
+### Simplify Array Operations
+
+**❌ Bad:**
+
+```typescript
+const filtered = []
+for (const item of items) {
+  if (item.value > 0) {
+    filtered.push(item)
+  }
+}
+```
+
+**✅ Good:**
+
+```typescript
+const filtered = items.filter((item) => item.value > 0)
+```
+
+## Edge Cases and Corner Cases
+
+### Common Patterns to Consider
+
+1. **Key Encoding**: When converting keys to strings, ensure no collisions
+
+   ```typescript
+   // ❌ Bad: numeric 1 and string "__number__1" collide
+   const key = typeof val === 'number' ? `__number__${val}` : String(val)
+
+   // ✅ Good: proper encoding with type prefix
+   const key = `${typeof val}_${String(val)}`
+   ```
+
+2. **Subset/Superset Logic**: Consider all cases
+
+   ```typescript
+   // Consider: IN with 0, 1, or many elements
+   // Consider: EQ vs IN predicates
+   // Consider: Range predicates (>=, <=) vs equality
+   ```
+
+3. **Limit and Offset**: Handle undefined, 0, and edge values
+
+   ```typescript
+   // What happens when limit is 0?
+   // What happens when offset exceeds data length?
+   // What happens when limit is undefined?
+   ```
+
+4. **Optional vs Required**: Be explicit about optionality
+
+   ```typescript
+   // ❌ Why is this optional?
+   interface Config {
+     collection?: Collection
+   }
+
+   // ✅ Document or make required if always needed
+   interface Config {
+     collection: Collection // Always required for query collections
+   }
+   ```
+
+5. **Race Conditions**: Async operations may resolve in unexpected order
+   ```typescript
+   // Request snapshot before receiving up-to-date
+   // But snapshot resolves after up-to-date arrives
+   // Should ignore the stale snapshot
+   ```
+
+## Package Versioning
+
+### Understand Semantic Versioning
+
+**Common Mistake:**
+
+```json
+{
+  "dependencies": {
+    "package": "^0.0.0"
+  }
+}
+```
+
+**Problem:** `^0.0.0` restricts to exactly `0.0.0`, not "latest 0.0.x" as you might expect.
+
+From [npm semver docs](https://github.com/npm/node-semver):
+
+> Caret Ranges allow changes that do not modify the left-most non-zero element. For versions `0.0.X`, this means no updates.
+
+**Solutions:**
+
+- Use `*` for any version
+- Use `latest` for the latest version
+- Use a proper range like `^0.1.0` if that's what you mean
+
+## Documentation and Comments
+
+### Keep Useful Comments
+
+**Good Comment:**
+
+```typescript
+// Returning false signals that callers should schedule another pass
+return allDone
+```
+
+**Good Comment:**
+
+```typescript
+// This step is necessary because the query function has captured
+// the old subscription instance in its closure
+```
+
+### Remove Outdated Comments
+
+**Key Principle:** When refactoring code, update or remove comments that reference old function names or outdated logic.
+
+## General Principles
+
+1. **Question Optionality**: If a property is optional, understand why. Often it should be required.
+
+2. **Consider Performance**: Before implementing, think about time complexity, especially for operations that might process many items.
+
+3. **Validate Semantics**: Ensure that your implementation actually does what you think it does. Consider edge cases.
+
+4. **Avoid Premature Complexity**: Don't add ternaries, special cases, or checks for things that can't happen.
+
+5. **Test First for Bugs**: Reproduce bugs in tests before fixing them.
+
+6. **Be Consistent**: Follow naming conventions and patterns used elsewhere in the codebase.
+
+7. **Simplify**: Modern JavaScript provides many concise operators and methods. Use them.
+
+8. **Encapsulate**: Hide implementation details. Use delegation and proper abstraction boundaries.
+
+9. **Type Precisely**: Use the most specific type possible. Avoid `any`.
+
+10. **Extract When Duplicating**: If you're writing the same logic twice, extract it.
+
+## When in Doubt
+
+If you're unsure about an implementation decision:
+
+1. Look for similar patterns in the existing codebase
+2. Consider the worst-case scenario for performance
+3. Think about edge cases and corner cases
+4. Ask: "Does this abstraction leak implementation details?"
+5. Ask: "Would this be easy to test?"
+6. Ask: "Is this as simple as it could be?"
+
+Remember: Simple, well-typed, well-tested code with clear abstractions is the goal. We raise the standard of code quality—not through complexity, but through clarity and correctness.
diff --git a/README.md b/README.md
index 075d8f756..9b12f0958 100644
--- a/README.md
+++ b/README.md
@@ -37,12 +37,15 @@
 
 > Tanstack DB is currently in BETA. See [the release post](https://tanstack.com/blog/tanstack-db-0.1-the-embedded-client-database-for-tanstack-query) for more details.
 
-A reactive client store that lets you build fast, sync‑driven apps with a backend‑agnostic real‑time data layer:
+The reactive client store for your API.
 
-- Blazing‑fast query engine for sub‑millisecond live queries, joins & aggregates
-- Fine‑grained reactivity to minimize component re‑rendering
-- Robust transaction primitives for optimistic mutations with sync & lifecycle support
-- Normalized data model that keeps backends simple and consistent
+TanStack DB solves the problems of building fast, modern apps, helping you:
+
+- Avoid endpoint sprawl and network waterfalls by loading data into normalized collections
+- Optimise client performance with sub-millisecond live queries and real-time reactivity
+- Take the network off the interaction path with instant optimistic writes
+
+Data loading is optimized. Interactions feel instantaneous. Your backend stays simple and your app stays blazing fast. No matter how much data you load.
 
 <a href="https://tanstack.com/db" style="font-weight:bold" >Read the docs →</a>
 <br />
diff --git a/docs/collections/local-only-collection.md b/docs/collections/local-only-collection.md
new file mode 100644
index 000000000..17bf51ef4
--- /dev/null
+++ b/docs/collections/local-only-collection.md
@@ -0,0 +1,324 @@
+---
+title: LocalOnly Collection
+---
+
+# LocalOnly Collection
+
+LocalOnly collections are designed for in-memory client data or UI state that doesn't need to persist across browser sessions or sync across tabs.
+
+## Overview
+
+The `localOnlyCollectionOptions` allows you to create collections that:
+- Store data only in memory (no persistence)
+- Support optimistic updates with automatic rollback on errors
+- Provide optional initial data
+- Work perfectly for temporary UI state and session-only data
+- Automatically manage the transition from optimistic to confirmed state
+
+## Installation
+
+LocalOnly collections are included in the core TanStack DB package:
+
+```bash
+npm install @tanstack/react-db
+```
+
+## Basic Usage
+
+```typescript
+import { createCollection } from '@tanstack/react-db'
+import { localOnlyCollectionOptions } from '@tanstack/react-db'
+
+const uiStateCollection = createCollection(
+  localOnlyCollectionOptions({
+    id: 'ui-state',
+    getKey: (item) => item.id,
+  })
+)
+```
+
+### Direct Local Mutations
+
+**Important:** LocalOnly collections work differently than server-synced collections. With LocalOnly collections, you **directly mutate state** by calling methods like `collection.insert()`, `collection.update()`, and `collection.delete()` — that's all you need to do. The changes are immediately applied to your local in-memory data.
+
+This is different from collections that sync with a server (like Query Collection), where mutation handlers send data to a backend. With LocalOnly collections, everything stays local:
+
+```typescript
+// Just call the methods directly - no server sync involved
+uiStateCollection.insert({ id: 'theme', mode: 'dark' })
+uiStateCollection.update('theme', (draft) => { draft.mode = 'light' })
+uiStateCollection.delete('theme')
+```
+
+## Configuration Options
+
+The `localOnlyCollectionOptions` function accepts the following options:
+
+### Required Options
+
+- `id`: Unique identifier for the collection
+- `getKey`: Function to extract the unique key from an item
+
+### Optional Options
+
+- `schema`: [Standard Schema](https://standardschema.dev) compatible schema (e.g., Zod, Effect) for client-side validation
+- `initialData`: Array of items to populate the collection with on creation
+- `onInsert`: Optional handler function called before confirming inserts
+- `onUpdate`: Optional handler function called before confirming updates
+- `onDelete`: Optional handler function called before confirming deletes
+
+## Initial Data
+
+Populate the collection with initial data on creation:
+
+```typescript
+const uiStateCollection = createCollection(
+  localOnlyCollectionOptions({
+    id: 'ui-state',
+    getKey: (item) => item.id,
+    initialData: [
+      { id: 'sidebar', isOpen: false },
+      { id: 'theme', mode: 'light' },
+      { id: 'modal', visible: false },
+    ],
+  })
+)
+```
+
+## Mutation Handlers
+
+Mutation handlers are **completely optional**. When provided, they are called before the optimistic state is confirmed:
+
+```typescript
+const tempDataCollection = createCollection(
+  localOnlyCollectionOptions({
+    id: 'temp-data',
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      // Custom logic before confirming the insert
+      console.log('Inserting:', transaction.mutations[0].modified)
+    },
+    onUpdate: async ({ transaction }) => {
+      // Custom logic before confirming the update
+      const { original, modified } = transaction.mutations[0]
+      console.log('Updating from', original, 'to', modified)
+    },
+    onDelete: async ({ transaction }) => {
+      // Custom logic before confirming the delete
+      console.log('Deleting:', transaction.mutations[0].original)
+    },
+  })
+)
+```
+
+## Manual Transactions
+
+When using LocalOnly collections with manual transactions (created via `createTransaction`), you must call `utils.acceptMutations()` to persist the changes:
+
+```typescript
+import { createTransaction } from '@tanstack/react-db'
+
+const localData = createCollection(
+  localOnlyCollectionOptions({
+    id: 'form-draft',
+    getKey: (item) => item.id,
+  })
+)
+
+const serverCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['items'],
+    queryFn: async () => api.items.getAll(),
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      await api.items.create(transaction.mutations[0].modified)
+    },
+  })
+)
+
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle server collection mutations explicitly in mutationFn
+    await Promise.all(
+      transaction.mutations
+        .filter((m) => m.collection === serverCollection)
+        .map((m) => api.items.create(m.modified))
+    )
+
+    // After server mutations succeed, accept local collection mutations
+    localData.utils.acceptMutations(transaction)
+  },
+})
+
+// Apply mutations to both collections in one transaction
+tx.mutate(() => {
+  localData.insert({ id: 'draft-1', data: '...' })
+  serverCollection.insert({ id: '1', name: 'Item' })
+})
+
+await tx.commit()
+```
+
+## Complete Example: Modal State Management
+
+```typescript
+import { createCollection, eq } from '@tanstack/react-db'
+import { localOnlyCollectionOptions } from '@tanstack/react-db'
+import { useLiveQuery } from '@tanstack/react-db'
+import { z } from 'zod'
+
+// Define schema
+const modalStateSchema = z.object({
+  id: z.string(),
+  isOpen: z.boolean(),
+  data: z.any().optional(),
+})
+
+type ModalState = z.infer<typeof modalStateSchema>
+
+// Create collection
+export const modalStateCollection = createCollection(
+  localOnlyCollectionOptions({
+    id: 'modal-state',
+    getKey: (item) => item.id,
+    schema: modalStateSchema,
+    initialData: [
+      { id: 'user-profile', isOpen: false },
+      { id: 'settings', isOpen: false },
+      { id: 'confirm-delete', isOpen: false },
+    ],
+  })
+)
+
+// Use in component
+function UserProfileModal() {
+  const { data: modals } = useLiveQuery((q) =>
+    q.from({ modal: modalStateCollection })
+      .where(({ modal }) => eq(modal.id, 'user-profile'))
+  )
+
+  const modalState = modals[0]
+
+  const openModal = (data?: any) => {
+    modalStateCollection.update('user-profile', (draft) => {
+      draft.isOpen = true
+      draft.data = data
+    })
+  }
+
+  const closeModal = () => {
+    modalStateCollection.update('user-profile', (draft) => {
+      draft.isOpen = false
+      draft.data = undefined
+    })
+  }
+
+  if (!modalState?.isOpen) return null
+
+  return (
+    <div className="modal">
+      <h2>User Profile</h2>
+      <pre>{JSON.stringify(modalState.data, null, 2)}</pre>
+      <button onClick={closeModal}>Close</button>
+    </div>
+  )
+}
+```
+
+## Complete Example: Form Draft State
+
+```typescript
+import { createCollection, eq } from '@tanstack/react-db'
+import { localOnlyCollectionOptions } from '@tanstack/react-db'
+import { useLiveQuery } from '@tanstack/react-db'
+
+type FormDraft = {
+  id: string
+  formData: Record<string, any>
+  lastModified: Date
+}
+
+// Create collection for form drafts
+export const formDraftsCollection = createCollection(
+  localOnlyCollectionOptions({
+    id: 'form-drafts',
+    getKey: (item) => item.id,
+  })
+)
+
+// Use in component
+function CreatePostForm() {
+  const { data: drafts } = useLiveQuery((q) =>
+    q.from({ draft: formDraftsCollection })
+      .where(({ draft }) => eq(draft.id, 'new-post'))
+  )
+
+  const currentDraft = drafts[0]
+
+  const updateDraft = (field: string, value: any) => {
+    if (currentDraft) {
+      formDraftsCollection.update('new-post', (draft) => {
+        draft.formData[field] = value
+        draft.lastModified = new Date()
+      })
+    } else {
+      formDraftsCollection.insert({
+        id: 'new-post',
+        formData: { [field]: value },
+        lastModified: new Date(),
+      })
+    }
+  }
+
+  const clearDraft = () => {
+    if (currentDraft) {
+      formDraftsCollection.delete('new-post')
+    }
+  }
+
+  const submitForm = async () => {
+    if (!currentDraft) return
+
+    await api.posts.create(currentDraft.formData)
+    clearDraft()
+  }
+
+  return (
+    <form onSubmit={(e) => { e.preventDefault(); submitForm() }}>
+      <input
+        value={currentDraft?.formData.title || ''}
+        onChange={(e) => updateDraft('title', e.target.value)}
+      />
+      <button type="submit">Publish</button>
+      <button type="button" onClick={clearDraft}>Clear Draft</button>
+    </form>
+  )
+}
+```
+
+## Use Cases
+
+LocalOnly collections are perfect for:
+- Temporary UI state (modals, sidebars, tooltips)
+- Form draft data during the current session
+- Client-side computed or derived data
+- Wizard/multi-step form state
+- Temporary filters or search state
+- In-memory caches
+
+## Comparison with LocalStorageCollection
+
+| Feature | LocalOnly | LocalStorage |
+|---------|-----------|--------------|
+| Persistence | None (in-memory only) | localStorage |
+| Cross-tab sync | No | Yes |
+| Survives page reload | No | Yes |
+| Performance | Fastest | Fast |
+| Size limits | Memory limits | ~5-10MB |
+| Best for | Temporary UI state | User preferences |
+
+## Learn More
+
+- [Optimistic Mutations](../guides/mutations.md)
+- [Live Queries](../guides/live-queries.md)
+- [LocalStorage Collection](./local-storage-collection.md)
diff --git a/docs/collections/local-storage-collection.md b/docs/collections/local-storage-collection.md
new file mode 100644
index 000000000..171e5cb9b
--- /dev/null
+++ b/docs/collections/local-storage-collection.md
@@ -0,0 +1,312 @@
+---
+title: LocalStorage Collection
+---
+
+# LocalStorage Collection
+
+LocalStorage collections store small amounts of local-only state that persists across browser sessions and syncs across browser tabs in real-time.
+
+## Overview
+
+The `localStorageCollectionOptions` allows you to create collections that:
+- Persist data to localStorage (or sessionStorage)
+- Automatically sync across browser tabs using storage events
+- Support optimistic updates with automatic rollback on errors
+- Store all data under a single localStorage key
+- Work with any storage API that matches the localStorage interface
+
+## Installation
+
+LocalStorage collections are included in the core TanStack DB package:
+
+```bash
+npm install @tanstack/react-db
+```
+
+## Basic Usage
+
+```typescript
+import { createCollection } from '@tanstack/react-db'
+import { localStorageCollectionOptions } from '@tanstack/react-db'
+
+const userPreferencesCollection = createCollection(
+  localStorageCollectionOptions({
+    id: 'user-preferences',
+    storageKey: 'app-user-prefs',
+    getKey: (item) => item.id,
+  })
+)
+```
+
+### Direct Local Mutations
+
+**Important:** LocalStorage collections work differently than server-synced collections. With LocalStorage collections, you **directly mutate state** by calling methods like `collection.insert()`, `collection.update()`, and `collection.delete()` — that's all you need to do. The changes are immediately applied to your local data and automatically persisted to localStorage.
+
+This is different from collections that sync with a server (like Query Collection), where mutation handlers send data to a backend. With LocalStorage collections, everything stays local:
+
+```typescript
+// Just call the methods directly - automatically persisted to localStorage
+userPreferencesCollection.insert({ id: 'theme', mode: 'dark' })
+userPreferencesCollection.update('theme', (draft) => { draft.mode = 'light' })
+userPreferencesCollection.delete('theme')
+```
+
+## Configuration Options
+
+The `localStorageCollectionOptions` function accepts the following options:
+
+### Required Options
+
+- `id`: Unique identifier for the collection
+- `storageKey`: The localStorage key where all collection data is stored
+- `getKey`: Function to extract the unique key from an item
+
+### Optional Options
+
+- `schema`: [Standard Schema](https://standardschema.dev) compatible schema (e.g., Zod, Effect) for client-side validation
+- `storage`: Custom storage implementation (defaults to `localStorage`). Can be `sessionStorage` or any object with the localStorage API
+- `storageEventApi`: Event API for subscribing to storage events (defaults to `window`). Enables custom cross-tab, cross-window, or cross-process synchronization
+- `onInsert`: Optional handler function called when items are inserted
+- `onUpdate`: Optional handler function called when items are updated
+- `onDelete`: Optional handler function called when items are deleted
+
+## Cross-Tab Synchronization
+
+LocalStorage collections automatically sync across browser tabs in real-time:
+
+```typescript
+const settingsCollection = createCollection(
+  localStorageCollectionOptions({
+    id: 'settings',
+    storageKey: 'app-settings',
+    getKey: (item) => item.id,
+  })
+)
+
+// Changes in one tab are automatically reflected in all other tabs
+// This works automatically via storage events
+```
+
+## Using SessionStorage
+
+You can use `sessionStorage` instead of `localStorage` for session-only persistence:
+
+```typescript
+const sessionCollection = createCollection(
+  localStorageCollectionOptions({
+    id: 'session-data',
+    storageKey: 'session-key',
+    storage: sessionStorage, // Use sessionStorage instead
+    getKey: (item) => item.id,
+  })
+)
+```
+
+## Custom Storage Backend
+
+Provide any storage implementation that matches the localStorage API:
+
+```typescript
+// Example: Custom storage wrapper with encryption
+const encryptedStorage = {
+  getItem(key: string) {
+    const encrypted = localStorage.getItem(key)
+    return encrypted ? decrypt(encrypted) : null
+  },
+  setItem(key: string, value: string) {
+    localStorage.setItem(key, encrypt(value))
+  },
+  removeItem(key: string) {
+    localStorage.removeItem(key)
+  },
+}
+
+const secureCollection = createCollection(
+  localStorageCollectionOptions({
+    id: 'secure-data',
+    storageKey: 'encrypted-key',
+    storage: encryptedStorage,
+    getKey: (item) => item.id,
+  })
+)
+```
+
+### Cross-Tab Sync with Custom Storage
+
+The `storageEventApi` option (defaults to `window`) allows the collection to subscribe to storage events for cross-tab synchronization. A custom storage implementation can provide this API to enable custom cross-tab, cross-window, or cross-process sync:
+
+```typescript
+// Example: Custom storage event API for cross-process sync
+const customStorageEventApi = {
+  addEventListener(event: string, handler: (e: StorageEvent) => void) {
+    // Custom event subscription logic
+    // Could be IPC, WebSocket, or any other mechanism
+    myCustomEventBus.on('storage-change', handler)
+  },
+  removeEventListener(event: string, handler: (e: StorageEvent) => void) {
+    myCustomEventBus.off('storage-change', handler)
+  },
+}
+
+const syncedCollection = createCollection(
+  localStorageCollectionOptions({
+    id: 'synced-data',
+    storageKey: 'data-key',
+    storage: customStorage,
+    storageEventApi: customStorageEventApi, // Custom event API
+    getKey: (item) => item.id,
+  })
+)
+```
+
+This enables synchronization across different contexts beyond just browser tabs, such as:
+- Cross-process communication in Electron apps
+- WebSocket-based sync across multiple browser windows
+- Custom IPC mechanisms in desktop applications
+
+## Mutation Handlers
+
+Mutation handlers are **completely optional**. Data will persist to localStorage whether or not you provide handlers:
+
+```typescript
+const preferencesCollection = createCollection(
+  localStorageCollectionOptions({
+    id: 'preferences',
+    storageKey: 'user-prefs',
+    getKey: (item) => item.id,
+    // Optional: Add custom logic when preferences are updated
+    onUpdate: async ({ transaction }) => {
+      const { modified } = transaction.mutations[0]
+      console.log('Preference updated:', modified)
+      // Maybe send analytics or trigger other side effects
+    },
+  })
+)
+```
+
+## Manual Transactions
+
+When using LocalStorage collections with manual transactions (created via `createTransaction`), you must call `utils.acceptMutations()` to persist the changes:
+
+```typescript
+import { createTransaction } from '@tanstack/react-db'
+
+const localData = createCollection(
+  localStorageCollectionOptions({
+    id: 'form-draft',
+    storageKey: 'draft-data',
+    getKey: (item) => item.id,
+  })
+)
+
+const serverCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['items'],
+    queryFn: async () => api.items.getAll(),
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      await api.items.create(transaction.mutations[0].modified)
+    },
+  })
+)
+
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle server collection mutations explicitly in mutationFn
+    await Promise.all(
+      transaction.mutations
+        .filter((m) => m.collection === serverCollection)
+        .map((m) => api.items.create(m.modified))
+    )
+
+    // After server mutations succeed, persist local collection mutations
+    localData.utils.acceptMutations(transaction)
+  },
+})
+
+// Apply mutations to both collections in one transaction
+tx.mutate(() => {
+  localData.insert({ id: 'draft-1', data: '...' })
+  serverCollection.insert({ id: '1', name: 'Item' })
+})
+
+await tx.commit()
+```
+
+## Complete Example
+
+```typescript
+import { createCollection, eq } from '@tanstack/react-db'
+import { localStorageCollectionOptions } from '@tanstack/react-db'
+import { useLiveQuery } from '@tanstack/react-db'
+import { z } from 'zod'
+
+// Define schema
+const userPrefsSchema = z.object({
+  id: z.string(),
+  theme: z.enum(['light', 'dark', 'auto']),
+  language: z.string(),
+  notifications: z.boolean(),
+})
+
+type UserPrefs = z.infer<typeof userPrefsSchema>
+
+// Create collection
+export const userPreferencesCollection = createCollection(
+  localStorageCollectionOptions({
+    id: 'user-preferences',
+    storageKey: 'app-user-prefs',
+    getKey: (item) => item.id,
+    schema: userPrefsSchema,
+  })
+)
+
+// Use in component
+function SettingsPanel() {
+  const { data: prefs } = useLiveQuery((q) =>
+    q.from({ pref: userPreferencesCollection })
+      .where(({ pref }) => eq(pref.id, 'current-user'))
+  )
+
+  const currentPrefs = prefs[0]
+
+  const updateTheme = (theme: 'light' | 'dark' | 'auto') => {
+    if (currentPrefs) {
+      userPreferencesCollection.update(currentPrefs.id, (draft) => {
+        draft.theme = theme
+      })
+    } else {
+      userPreferencesCollection.insert({
+        id: 'current-user',
+        theme,
+        language: 'en',
+        notifications: true,
+      })
+    }
+  }
+
+  return (
+    <div>
+      <h2>Theme: {currentPrefs?.theme}</h2>
+      <button onClick={() => updateTheme('dark')}>Dark Mode</button>
+      <button onClick={() => updateTheme('light')}>Light Mode</button>
+    </div>
+  )
+}
+```
+
+## Use Cases
+
+LocalStorage collections are perfect for:
+- User preferences and settings
+- UI state that should persist across sessions
+- Form drafts
+- Recently viewed items
+- User-specific configurations
+- Small amounts of cached data
+
+## Learn More
+
+- [Optimistic Mutations](../guides/mutations.md)
+- [Live Queries](../guides/live-queries.md)
+- [LocalOnly Collection](./local-only-collection.md)
diff --git a/docs/collections/powersync-collection.md b/docs/collections/powersync-collection.md
new file mode 100644
index 000000000..36c2d8be2
--- /dev/null
+++ b/docs/collections/powersync-collection.md
@@ -0,0 +1,578 @@
+---
+title: PowerSync Collection
+---
+
+# PowerSync Collection
+
+PowerSync collections provide seamless integration between TanStack DB and [PowerSync](https://powersync.com), enabling automatic synchronization between your in-memory TanStack DB collections and PowerSync's SQLite database. This gives you offline-ready persistence, real-time sync capabilities, and powerful conflict resolution.
+
+## Overview
+
+The `@tanstack/powersync-db-collection` package allows you to create collections that:
+
+- Automatically mirror the state of an underlying PowerSync SQLite database
+- Reactively update when PowerSync records change
+- Support optimistic mutations with rollback on error
+- Provide persistence handlers to keep PowerSync in sync with TanStack DB transactions
+- Use PowerSync's efficient SQLite-based storage engine
+- Work with PowerSync's real-time sync features for offline-first scenarios
+- Leverage PowerSync's built-in conflict resolution and data consistency guarantees
+- Enable real-time synchronization with PostgreSQL, MongoDB and MySQL backends
+
+## 1. Installation
+
+Install the PowerSync collection package along with your preferred framework integration.
+PowerSync currently works with Web, React Native and Node.js. The examples below use the Web SDK.
+See the PowerSync quickstart [docs](https://docs.powersync.com/installation/quickstart-guide) for more details.
+
+```bash
+npm install @tanstack/powersync-db-collection @powersync/web @journeyapps/wa-sqlite
+```
+
+### 2. Create a PowerSync Database and Schema
+
+```ts
+import { Schema, Table, column } from "@powersync/web"
+
+// Define your schema
+const APP_SCHEMA = new Schema({
+  documents: new Table({
+    name: column.text,
+    author: column.text,
+    created_at: column.text,
+    archived: column.integer,
+  }),
+})
+
+// Initialize PowerSync database
+const db = new PowerSyncDatabase({
+  database: {
+    dbFilename: "app.sqlite",
+  },
+  schema: APP_SCHEMA,
+})
+```
+
+### 3. (optional) Configure Sync with a Backend
+
+```ts
+import {
+  AbstractPowerSyncDatabase,
+  PowerSyncBackendConnector,
+  PowerSyncCredentials,
+} from "@powersync/web"
+
+// TODO implement your logic here
+class Connector implements PowerSyncBackendConnector {
+  fetchCredentials: () => Promise<PowerSyncCredentials | null>
+
+  /** Upload local changes to the app backend.
+   *
+   * Use {@link AbstractPowerSyncDatabase.getCrudBatch} to get a batch of changes to upload.
+   *
+   * Any thrown errors will result in a retry after the configured wait period (default: 5 seconds).
+   */
+  uploadData: (database: AbstractPowerSyncDatabase) => Promise<void>
+}
+
+// Configure the client to connect to a PowerSync service and your backend
+db.connect(new Connector())
+```
+
+### 4. Create a TanStack DB Collection
+
+There are two main ways to create a collection: using type inference or using schema validation. Type inference will infer collection types from the underlying PowerSync SQLite tables. Schema validation can be used for additional input/output validations and type transforms.
+
+#### Option 1: Using Table Type Inference
+
+The collection types are automatically inferred from the PowerSync schema table definition. The table is used to construct a default standard schema validator which is used internally to validate collection operations.
+
+Collection mutations accept SQLite types and queries report data with SQLite types.
+
+```ts
+import { createCollection } from "@tanstack/react-db"
+import { powerSyncCollectionOptions } from "@tanstack/powersync-db-collection"
+
+const documentsCollection = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.documents,
+  })
+)
+
+/** Note: The types for input and output are defined as this */
+// Used for mutations like `insert` or `update`
+type DocumentCollectionInput = {
+  id: string
+  name: string | null
+  author: string | null
+  created_at: string | null // SQLite TEXT
+  archived: number | null // SQLite integer
+}
+// The type of query/data results
+type DocumentCollectionOutput = DocumentCollectionInput
+```
+
+The standard PowerSync SQLite types map to these TypeScript types:
+
+| PowerSync Column Type | TypeScript Type  | Description                                                          |
+| --------------------- | ---------------- | -------------------------------------------------------------------- |
+| `column.text`         | `string \| null` | Text values, commonly used for strings, JSON, dates (as ISO strings) |
+| `column.integer`      | `number \| null` | Integer values, also used for booleans (0/1)                         |
+| `column.real`         | `number \| null` | Floating point numbers                                               |
+
+Note: All PowerSync column types are nullable by default.
+
+#### Option 2: SQLite Types with Schema Validation
+
+Additional validations for collection mutations can be performed with a custom schema. The Schema below asserts that
+the `name`, `author` and `created_at` fields are required as input. `name` also has an additional string length check.
+
+Note: The input and output types specified in this example still satisfy the underlying SQLite types. An additional `deserializationSchema` is required if the typing differs. See the examples below for more details.
+
+The application logic (including the backend) should enforce that all incoming synced data passes validation with the `schema`. Failing to validate data will result in inconsistency of the collection data. This is a fatal error! An `onDeserializationError` handler must be provided to react to this case.
+
+```ts
+import { createCollection } from "@tanstack/react-db"
+import { powerSyncCollectionOptions } from "@tanstack/powersync-db-collection"
+import { z } from "zod"
+
+// Schema validates SQLite types but adds constraints
+const schema = z.object({
+  id: z.string(),
+  name: z.string().min(3, { message: "Should be at least 3 characters" }),
+  author: z.string(),
+  created_at: z.string(), // SQLite TEXT for dates
+  archived: z.number(),
+})
+
+const documentsCollection = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.documents,
+    schema,
+    onDeserializationError: (error) => {
+      // Present fatal error
+    },
+  })
+)
+
+/** Note: The types for input and output are defined as this */
+// Used for mutations like `insert` or `update`
+type DocumentCollectionInput = {
+  id: string
+  name: string
+  author: string
+  created_at: string // SQLite TEXT
+  archived: number // SQLite integer
+}
+// The type of query/data results
+type DocumentCollectionOutput = DocumentCollectionInput
+```
+
+#### Option 3: Transform SQLite Input Types to Rich Output Types
+
+You can transform SQLite types to richer types (like Date objects) while keeping SQLite-compatible input types:
+
+Note: The Transformed types are provided by TanStackDB to the PowerSync SQLite persister. These types need to be serialized in
+order to be persisted to SQLite. Most types are converted by default. For custom types, override the serialization by providing a
+`serializer` param.
+
+The example below uses `nullable` columns, this is not a requirement.
+
+The application logic (including the backend) should enforce that all incoming synced data passes validation with the `schema`. Failing to validate data will result in inconsistency of the collection data. This is a fatal error! An `onDeserializationError` handler must be provided to react to this case.
+
+```ts
+const schema = z.object({
+  id: z.string(),
+  name: z.string().nullable(),
+  created_at: z
+    .string()
+    .nullable()
+    .transform((val) => (val ? new Date(val) : null)), // Transform SQLite TEXT to Date
+  archived: z
+    .number()
+    .nullable()
+    .transform((val) => (val != null ? val > 0 : null)), // Transform SQLite INTEGER to boolean
+})
+
+const documentsCollection = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.documents,
+    schema,
+    onDeserializationError: (error) => {
+      // Present fatal error
+    },
+    // Optional: custom column serialization
+    serializer: {
+      // Dates are serialized by default, this is just an example
+      created_at: (value) => (value ? value.toISOString() : null),
+    },
+  })
+)
+
+/** Note: The types for input and output are defined as this */
+// Used for mutations like `insert` or `update`
+type DocumentCollectionInput = {
+  id: string
+  name: string | null
+  author: string | null
+  created_at: string | null // SQLite TEXT
+  archived: number | null
+}
+// The type of query/data results
+type DocumentCollectionOutput = {
+  id: string
+  name: string | null
+  author: string | null
+  created_at: Date | null // JS Date instance
+  archived: boolean | null // JS boolean
+}
+```
+
+#### Option 4: Custom Input/Output Types with Deserialization
+
+The input and output types can be completely decoupled from the internal SQLite types. This can be used to accept rich values for input mutations.
+We require an additional `deserializationSchema` in order to validate and transform incoming synced (SQLite) updates. This schema should convert the incoming SQLite update to the output type.
+
+The application logic (including the backend) should enforce that all incoming synced data passes validation with the `deserializationSchema`. Failing to validate data will result in inconsistency of the collection data. This is a fatal error! An `onDeserializationError` handler must be provided to react to this case.
+
+```ts
+// Our input/output types use Date and boolean
+const schema = z.object({
+  id: z.string(),
+  name: z.string(),
+  author: z.string(),
+  created_at: z.date(), // Accept Date objects as input
+  archived: z.boolean(), // Accept Booleans as input
+})
+
+// Schema to transform from SQLite types to our output types
+const deserializationSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  author: z.string(),
+  created_at: z
+    .string()
+    .transform((val) => (new Date(val))), // SQLite TEXT to Date
+  archived: z
+    .number()
+    .transform((val) => (val > 0), // SQLite INTEGER to Boolean
+})
+
+const documentsCollection = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.documents,
+    schema,
+    deserializationSchema,
+    onDeserializationError: (error) => {
+      // Present fatal error
+    },
+  })
+)
+
+/** Note: The types for input and output are defined as this */
+// Used for mutations like `insert` or `update`
+type DocumentCollectionInput = {
+  id: string
+  name: string
+  author: string
+  created_at: Date
+  archived: boolean
+}
+// The type of query/data results
+type DocumentCollectionOutput = DocumentCollectionInput
+```
+
+## Features
+
+### Offline-First
+
+PowerSync collections are offline-first by default. All data is stored locally in a SQLite database, allowing your app to work without an internet connection. Changes are automatically synced when connectivity is restored.
+
+### Real-Time Sync
+
+When connected to a PowerSync backend, changes are automatically synchronized in real-time across all connected clients. The sync process handles:
+
+- Bi-directional sync with the server
+- Conflict resolution
+- Queue management for offline changes
+- Automatic retries on connection loss
+
+### Working with Rich JavaScript Types
+
+PowerSync collections support rich JavaScript types like `Date`, `Boolean`, and custom objects while maintaining SQLite compatibility. The collection handles serialization and deserialization automatically:
+
+```typescript
+import { z } from "zod"
+import { Schema, Table, column } from "@powersync/web"
+import { createCollection } from "@tanstack/react-db"
+import { powerSyncCollectionOptions } from "@tanstack/powersync-db-collection"
+
+// Define PowerSync SQLite schema
+const APP_SCHEMA = new Schema({
+  tasks: new Table({
+    title: column.text,
+    due_date: column.text, // Stored as ISO string in SQLite
+    completed: column.integer, // Stored as 0/1 in SQLite
+    metadata: column.text, // Stored as JSON string in SQLite
+  }),
+})
+
+// Define rich types schema
+const taskSchema = z.object({
+  id: z.string(),
+  title: z.string().nullable(),
+  due_date: z
+    .string()
+    .nullable()
+    .transform((val) => (val ? new Date(val) : null)), // Convert to Date
+  completed: z
+    .number()
+    .nullable()
+    .transform((val) => (val != null ? val > 0 : null)), // Convert to boolean
+  metadata: z
+    .string()
+    .nullable()
+    .transform((val) => (val ? JSON.parse(val) : null)), // Parse JSON
+})
+
+// Create collection with rich types
+const tasksCollection = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.tasks,
+    schema: taskSchema,
+  })
+)
+
+// Work with rich types in your code
+await tasksCollection.insert({
+  id: crypto.randomUUID(),
+  title: "Review PR",
+  due_date: "2025-10-30T10:00:00Z", // String input is automatically converted to Date
+  completed: 0, // Number input is automatically converted to boolean
+  metadata: JSON.stringify({ priority: "high" }),
+})
+
+// Query returns rich types
+const task = tasksCollection.get("task-1")
+console.log(task.due_date instanceof Date) // true
+console.log(typeof task.completed) // "boolean"
+console.log(task.metadata.priority) // "high"
+```
+
+### Type Safety with Rich Types
+
+The collection maintains type safety throughout:
+
+```typescript
+type TaskInput = {
+  id: string
+  title: string | null
+  due_date: string | null // Accept ISO string for mutations
+  completed: number | null // Accept 0/1 for mutations
+  metadata: string | null // Accept JSON string for mutations
+}
+
+type TaskOutput = {
+  id: string
+  title: string | null
+  due_date: Date | null // Get Date object in queries
+  completed: boolean | null // Get boolean in queries
+  metadata: {
+    priority: string
+    [key: string]: any
+  } | null
+}
+
+// TypeScript enforces correct types:
+tasksCollection.insert({
+  due_date: new Date(), // Error: Type 'Date' is not assignable to type 'string'
+})
+
+const task = tasksCollection.get("task-1")
+task.due_date.getTime() // OK - TypeScript knows this is a Date
+```
+
+### Optimistic Updates
+
+Updates to the collection are applied optimistically to the local state first, then synchronized with PowerSync and the backend. If an error occurs during sync, the changes are automatically rolled back.
+
+### Metadata Tracking
+
+Metadata tracking allows attaching custom metadata to collection operations (insert, update, delete). This metadata is persisted alongside the operation and available in PowerSync `CrudEntry` records during upload processing. This is useful for passing additional context about mutations to the backend, such as audit information, operation sources, or custom processing hints.
+
+#### Enabling Metadata Tracking
+
+Metadata tracking must be enabled on the PowerSync table:
+
+```typescript
+const APP_SCHEMA = new Schema({
+  documents: new Table(
+    {
+      name: column.text,
+      author: column.text,
+    },
+    {
+      // Enable metadata tracking on this table
+      trackMetadata: true,
+    }
+  ),
+})
+```
+
+#### Using Metadata in Operations
+
+Once enabled, metadata can be passed to any collection operation:
+
+```typescript
+const documents = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.documents,
+  })
+)
+
+// Insert with metadata
+await documents.insert(
+  {
+    id: crypto.randomUUID(),
+    name: "Report Q4",
+    author: "Jane Smith",
+  },
+  {
+    metadata: {
+      source: "web-app",
+      userId: "user-123",
+      timestamp: Date.now(),
+    },
+  }
+).isPersisted.promise
+
+// Update with metadata
+await documents.update(
+  docId,
+  { metadata: { reason: "typo-fix", editor: "user-456" } },
+  (doc) => {
+    doc.name = "Report Q4 (Updated)"
+  }
+).isPersisted.promise
+
+// Delete with metadata
+await documents.delete(docId, {
+  metadata: { deletedBy: "user-789", reason: "duplicate" },
+}).isPersisted.promise
+```
+
+#### Accessing Metadata During Upload
+
+The metadata is available in PowerSync `CrudEntry` records when processing uploads in the connector:
+
+```typescript
+import { CrudEntry } from "@powersync/web"
+
+class Connector implements PowerSyncBackendConnector {
+  // ...
+
+  async uploadData(database: AbstractPowerSyncDatabase) {
+    const batch = await database.getCrudBatch()
+    if (!batch) return
+
+    for (const entry of batch.crud) {
+      console.log("Operation:", entry.op) // PUT, PATCH, DELETE
+      console.log("Table:", entry.table)
+      console.log("Data:", entry.opData)
+      console.log("Metadata:", entry.metadata) // Custom metadata (stringified)
+
+      // Parse metadata if needed
+      if (entry.metadata) {
+        const meta = JSON.parse(entry.metadata)
+        console.log("Source:", meta.source)
+        console.log("User ID:", meta.userId)
+      }
+
+      // Process the operation with the backend...
+    }
+
+    await batch.complete()
+  }
+}
+```
+
+**Note**: If metadata is provided to an operation but the table doesn't have `trackMetadata: true`, a warning will be logged and the metadata will be ignored.
+
+## Configuration Options
+
+The `powerSyncCollectionOptions` function accepts the following options:
+
+```ts
+interface PowerSyncCollectionConfig<TTable extends Table, TSchema> {
+  // Required options
+  database: PowerSyncDatabase
+  table: Table
+
+  // Schema validation and type transformation
+  schema?: StandardSchemaV1
+  deserializationSchema?: StandardSchemaV1 // Required for custom input types
+  onDeserializationError?: (error: StandardSchemaV1.FailureResult) => void // Required for custom input types
+
+  // Optional Custom serialization
+  serializer?: {
+    [Key in keyof TOutput]?: (value: TOutput[Key]) => SQLiteCompatibleType
+  }
+
+  // Performance tuning
+  syncBatchSize?: number // Control batch size for initial sync, defaults to 1000
+}
+```
+
+## Advanced Transactions
+
+When you need more control over transaction handling, such as batching multiple operations or handling complex transaction scenarios, you can use PowerSync's transaction system directly with TanStack DB transactions.
+
+```ts
+import { createTransaction } from "@tanstack/react-db"
+import { PowerSyncTransactor } from "@tanstack/powersync-db-collection"
+
+// Create a transaction that won't auto-commit
+const batchTx = createTransaction({
+  autoCommit: false,
+  mutationFn: async ({ transaction }) => {
+    // Use PowerSyncTransactor to apply the transaction to PowerSync
+    await new PowerSyncTransactor({ database: db }).applyTransaction(
+      transaction
+    )
+  },
+})
+
+// Perform multiple operations in the transaction
+batchTx.mutate(() => {
+  // Add multiple documents in a single transaction
+  for (let i = 0; i < 5; i++) {
+    documentsCollection.insert({
+      id: crypto.randomUUID(),
+      name: `Document ${i}`,
+      content: `Content ${i}`,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    })
+  }
+})
+
+// Commit the transaction
+await batchTx.commit()
+
+// Wait for the changes to be persisted
+await batchTx.isPersisted.promise
+```
+
+This approach allows you to:
+
+- Batch multiple operations into a single transaction
+- Control when the transaction is committed
+- Ensure all operations are atomic
+- Wait for persistence confirmation
+- Handle complex transaction scenarios
diff --git a/docs/collections/query-collection.md b/docs/collections/query-collection.md
index cd4e7eedc..cf13291a8 100644
--- a/docs/collections/query-collection.md
+++ b/docs/collections/query-collection.md
@@ -9,7 +9,8 @@ Query collections provide seamless integration between TanStack DB and TanStack
 ## Overview
 
 The `@tanstack/query-db-collection` package allows you to create collections that:
-- Automatically sync with remote data via TanStack Query
+
+- Automatically fetch remote data via TanStack Query
 - Support optimistic updates with automatic rollback on errors
 - Handle persistence through customizable mutation handlers
 - Provide direct write capabilities for directly writing to the sync store
@@ -23,17 +24,17 @@ npm install @tanstack/query-db-collection @tanstack/query-core @tanstack/db
 ## Basic Usage
 
 ```typescript
-import { QueryClient } from '@tanstack/query-core'
-import { createCollection } from '@tanstack/db'
-import { queryCollectionOptions } from '@tanstack/query-db-collection'
+import { QueryClient } from "@tanstack/query-core"
+import { createCollection } from "@tanstack/db"
+import { queryCollectionOptions } from "@tanstack/query-db-collection"
 
 const queryClient = new QueryClient()
 
 const todosCollection = createCollection(
   queryCollectionOptions({
-    queryKey: ['todos'],
+    queryKey: ["todos"],
     queryFn: async () => {
-      const response = await fetch('/api/todos')
+      const response = await fetch("/api/todos")
       return response.json()
     },
     queryClient,
@@ -55,9 +56,9 @@ The `queryCollectionOptions` function accepts the following options:
 
 ### Query Options
 
-- `select`: Function that lets extract array items when they’re wrapped with metadata
+- `select`: Function that lets extract array items when they're wrapped with metadata
 - `enabled`: Whether the query should automatically run (default: `true`)
-- `refetchInterval`: Refetch interval in milliseconds
+- `refetchInterval`: Refetch interval in milliseconds (default: 0 — set an interval to enable polling refetching)
 - `retry`: Retry configuration for failed queries
 - `retryDelay`: Delay between retries
 - `staleTime`: How long data is considered fresh
@@ -76,6 +77,126 @@ The `queryCollectionOptions` function accepts the following options:
 - `onUpdate`: Handler called before update operations
 - `onDelete`: Handler called before delete operations
 
+## Extending Meta with Custom Properties
+
+The `meta` option allows you to pass additional metadata to your query function. By default, Query Collections automatically include `loadSubsetOptions` in the meta object, which contains filtering, sorting, and pagination options for on-demand queries.
+
+### Type-Safe Meta Access
+
+The `ctx.meta.loadSubsetOptions` property is automatically typed as `LoadSubsetOptions` without requiring any additional imports or type assertions:
+
+```typescript
+import { parseLoadSubsetOptions } from "@tanstack/query-db-collection"
+
+const collection = createCollection(
+  queryCollectionOptions({
+    queryKey: ["products"],
+    syncMode: "on-demand",
+    queryFn: async (ctx) => {
+      // ✅ Type-safe access - no @ts-ignore needed!
+      const options = parseLoadSubsetOptions(ctx.meta?.loadSubsetOptions)
+
+      // Use the parsed options to fetch only what you need
+      return api.getProducts(options)
+    },
+    queryClient,
+    getKey: (item) => item.id,
+  })
+)
+```
+
+### Adding Custom Meta Properties
+
+You can extend the meta type to include your own custom properties using TypeScript's module augmentation:
+
+```typescript
+// In a global type definition file (e.g., types.d.ts or global.d.ts)
+declare module "@tanstack/query-db-collection" {
+  interface QueryCollectionMeta {
+    // Add your custom properties here
+    userId?: string
+    includeDeleted?: boolean
+    cacheTTL?: number
+  }
+}
+```
+
+Once you've extended the interface, your custom properties are fully typed throughout your application:
+
+```typescript
+const collection = createCollection(
+  queryCollectionOptions({
+    queryKey: ["todos"],
+    queryFn: async (ctx) => {
+      // ✅ Both loadSubsetOptions and custom properties are typed
+      const { loadSubsetOptions, userId, includeDeleted } = ctx.meta
+
+      return api.getTodos({
+        ...parseLoadSubsetOptions(loadSubsetOptions),
+        userId,
+        includeDeleted,
+      })
+    },
+    queryClient,
+    getKey: (item) => item.id,
+    // Pass custom meta alongside Query Collection defaults
+    meta: {
+      userId: "user-123",
+      includeDeleted: false,
+    },
+  })
+)
+```
+
+### Important Notes
+
+- The module augmentation pattern follows TanStack Query's official approach for typing meta
+- `QueryCollectionMeta` is an interface (not a type alias), enabling proper TypeScript declaration merging
+- Your custom properties are merged with the base `loadSubsetOptions` property
+- All meta properties must be compatible with `Record<string, unknown>`
+- The augmentation should be done in a file that's included in your TypeScript compilation
+
+### Example: API Request Context
+
+A common use case is passing request context to your query function:
+
+```typescript
+// types.d.ts
+declare module "@tanstack/query-db-collection" {
+  interface QueryCollectionMeta {
+    authToken?: string
+    locale?: string
+    version?: string
+  }
+}
+
+// collections.ts
+const productsCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ["products"],
+    queryFn: async (ctx) => {
+      const { loadSubsetOptions, authToken, locale, version } = ctx.meta
+
+      return api.getProducts({
+        ...parseLoadSubsetOptions(loadSubsetOptions),
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+          "Accept-Language": locale,
+          "API-Version": version,
+        },
+      })
+    },
+    queryClient,
+    getKey: (item) => item.id,
+    meta: {
+      authToken: session.token,
+      locale: "en-US",
+      version: "v1",
+    },
+  })
+)
+```
+
 ## Persistence Handlers
 
 You can define handlers that are called when mutations occur. These handlers can persist changes to your backend and control whether the query should refetch after the operation:
@@ -83,30 +204,30 @@ You can define handlers that are called when mutations occur. These handlers can
 ```typescript
 const todosCollection = createCollection(
   queryCollectionOptions({
-    queryKey: ['todos'],
+    queryKey: ["todos"],
     queryFn: fetchTodos,
     queryClient,
     getKey: (item) => item.id,
-    
+
     onInsert: async ({ transaction }) => {
-      const newItems = transaction.mutations.map(m => m.modified)
+      const newItems = transaction.mutations.map((m) => m.modified)
       await api.createTodos(newItems)
       // Returning nothing or { refetch: true } will trigger a refetch
       // Return { refetch: false } to skip automatic refetch
     },
-    
+
     onUpdate: async ({ transaction }) => {
-      const updates = transaction.mutations.map(m => ({
+      const updates = transaction.mutations.map((m) => ({
         id: m.key,
-        changes: m.changes
+        changes: m.changes,
       }))
       await api.updateTodos(updates)
     },
-    
+
     onDelete: async ({ transaction }) => {
-      const ids = transaction.mutations.map(m => m.key)
+      const ids = transaction.mutations.map((m) => m.key)
       await api.deleteTodos(ids)
-    }
+    },
   })
 )
 ```
@@ -119,14 +240,15 @@ You can control this behavior by returning an object with a `refetch` property:
 
 ```typescript
 onInsert: async ({ transaction }) => {
-  await api.createTodos(transaction.mutations.map(m => m.modified))
-  
+  await api.createTodos(transaction.mutations.map((m) => m.modified))
+
   // Skip the automatic refetch
   return { refetch: false }
 }
 ```
 
 This is useful when:
+
 - You're confident the server state matches what you sent
 - You want to avoid unnecessary network requests
 - You're handling state updates through other mechanisms (like WebSockets)
@@ -135,7 +257,10 @@ This is useful when:
 
 The collection provides these utility methods via `collection.utils`:
 
-- `refetch()`: Manually trigger a refetch of the query
+- `refetch(opts?)`: Manually trigger a refetch of the query
+  - `opts.throwOnError`: Whether to throw an error if the refetch fails (default: `false`)
+  - Bypasses `enabled: false` to support imperative/manual refetching patterns (similar to hook `refetch()` behavior)
+  - Returns `QueryObserverResult` for inspecting the result
 
 ## Direct Writes
 
@@ -144,10 +269,12 @@ Direct writes are intended for scenarios where the normal query/mutation flow do
 ### Understanding the Data Stores
 
 Query Collections maintain two data stores:
+
 1. **Synced Data Store** - The authoritative state synchronized with the server via `queryFn`
 2. **Optimistic Mutations Store** - Temporary changes that are applied optimistically before server confirmation
 
 Normal collection operations (insert, update, delete) create optimistic mutations that are:
+
 - Applied immediately to the UI
 - Sent to the server via persistence handlers
 - Rolled back automatically if the server request fails
@@ -158,6 +285,7 @@ Direct writes bypass this system entirely and write directly to the synced data
 ### When to Use Direct Writes
 
 Direct writes should be used when:
+
 - You need to sync real-time updates from WebSockets or server-sent events
 - You're dealing with large datasets where refetching everything is too expensive
 - You receive incremental updates or server-computed field updates
@@ -167,19 +295,28 @@ Direct writes should be used when:
 
 ```typescript
 // Insert a new item directly to the synced data store
-todosCollection.utils.writeInsert({ id: '1', text: 'Buy milk', completed: false })
+todosCollection.utils.writeInsert({
+  id: "1",
+  text: "Buy milk",
+  completed: false,
+})
 
 // Update an existing item in the synced data store
-todosCollection.utils.writeUpdate({ id: '1', completed: true })
+todosCollection.utils.writeUpdate({ id: "1", completed: true })
 
 // Delete an item from the synced data store
-todosCollection.utils.writeDelete('1')
+todosCollection.utils.writeDelete("1")
 
 // Upsert (insert or update) in the synced data store
-todosCollection.utils.writeUpsert({ id: '1', text: 'Buy milk', completed: false })
+todosCollection.utils.writeUpsert({
+  id: "1",
+  text: "Buy milk",
+  completed: false,
+})
 ```
 
 These operations:
+
 - Write directly to the synced data store
 - Do NOT create optimistic mutations
 - Do NOT trigger automatic query refetches
@@ -192,10 +329,10 @@ The `writeBatch` method allows you to perform multiple operations atomically. An
 
 ```typescript
 todosCollection.utils.writeBatch(() => {
-  todosCollection.utils.writeInsert({ id: '1', text: 'Buy milk' })
-  todosCollection.utils.writeInsert({ id: '2', text: 'Walk dog' })
-  todosCollection.utils.writeUpdate({ id: '3', completed: true })
-  todosCollection.utils.writeDelete('4')
+  todosCollection.utils.writeInsert({ id: "1", text: "Buy milk" })
+  todosCollection.utils.writeInsert({ id: "2", text: "Walk dog" })
+  todosCollection.utils.writeUpdate({ id: "3", completed: true })
+  todosCollection.utils.writeDelete("4")
 })
 ```
 
@@ -203,17 +340,17 @@ todosCollection.utils.writeBatch(() => {
 
 ```typescript
 // Handle real-time updates from WebSocket without triggering full refetches
-ws.on('todos:update', (changes) => {
+ws.on("todos:update", (changes) => {
   todosCollection.utils.writeBatch(() => {
-    changes.forEach(change => {
+    changes.forEach((change) => {
       switch (change.type) {
-        case 'insert':
+        case "insert":
           todosCollection.utils.writeInsert(change.data)
           break
-        case 'update':
+        case "update":
           todosCollection.utils.writeUpdate(change.data)
           break
-        case 'delete':
+        case "delete":
           todosCollection.utils.writeDelete(change.id)
           break
       }
@@ -229,13 +366,13 @@ When the server returns computed fields (like server-generated IDs or timestamps
 ```typescript
 const todosCollection = createCollection(
   queryCollectionOptions({
-    queryKey: ['todos'],
+    queryKey: ["todos"],
     queryFn: fetchTodos,
     queryClient,
     getKey: (item) => item.id,
 
     onInsert: async ({ transaction }) => {
-      const newItems = transaction.mutations.map(m => m.modified)
+      const newItems = transaction.mutations.map((m) => m.modified)
 
       // Send to server and get back items with server-computed fields
       const serverItems = await api.createTodos(newItems)
@@ -243,7 +380,7 @@ const todosCollection = createCollection(
       // Sync server-computed fields (like server-generated IDs, timestamps, etc.)
       // to the collection's synced data store
       todosCollection.utils.writeBatch(() => {
-        serverItems.forEach(serverItem => {
+        serverItems.forEach((serverItem) => {
           todosCollection.utils.writeInsert(serverItem)
         })
       })
@@ -254,26 +391,26 @@ const todosCollection = createCollection(
     },
 
     onUpdate: async ({ transaction }) => {
-      const updates = transaction.mutations.map(m => ({
+      const updates = transaction.mutations.map((m) => ({
         id: m.key,
-        changes: m.changes
+        changes: m.changes,
       }))
       const serverItems = await api.updateTodos(updates)
 
       // Sync server-computed fields from the update response
       todosCollection.utils.writeBatch(() => {
-        serverItems.forEach(serverItem => {
+        serverItems.forEach((serverItem) => {
           todosCollection.utils.writeUpdate(serverItem)
         })
       })
 
       return { refetch: false }
-    }
+    },
   })
 )
 
 // Usage is just like a regular collection
-todosCollection.insert({ text: 'Buy milk', completed: false })
+todosCollection.insert({ text: "Buy milk", completed: false })
 ```
 
 ### Example: Large Dataset Pagination
@@ -282,10 +419,10 @@ todosCollection.insert({ text: 'Buy milk', completed: false })
 // Load additional pages without refetching existing data
 const loadMoreTodos = async (page) => {
   const newTodos = await api.getTodos({ page, limit: 50 })
-  
+
   // Add new items without affecting existing ones
   todosCollection.utils.writeBatch(() => {
-    newTodos.forEach(todo => {
+    newTodos.forEach((todo) => {
       todosCollection.utils.writeInsert(todo)
     })
   })
@@ -318,31 +455,33 @@ Since the query collection expects `queryFn` to return the complete state, you c
 ```typescript
 const todosCollection = createCollection(
   queryCollectionOptions({
-    queryKey: ['todos'],
+    queryKey: ["todos"],
     queryFn: async ({ queryKey }) => {
       // Get existing data from cache
       const existingData = queryClient.getQueryData(queryKey) || []
-      
+
       // Fetch only new/updated items (e.g., changes since last sync)
-      const lastSyncTime = localStorage.getItem('todos-last-sync')
-      const newData = await fetch(`/api/todos?since=${lastSyncTime}`).then(r => r.json())
-      
+      const lastSyncTime = localStorage.getItem("todos-last-sync")
+      const newData = await fetch(`/api/todos?since=${lastSyncTime}`).then(
+        (r) => r.json()
+      )
+
       // Merge new data with existing data
-      const existingMap = new Map(existingData.map(item => [item.id, item]))
-      
+      const existingMap = new Map(existingData.map((item) => [item.id, item]))
+
       // Apply updates and additions
-      newData.forEach(item => {
+      newData.forEach((item) => {
         existingMap.set(item.id, item)
       })
-      
+
       // Handle deletions if your API provides them
       if (newData.deletions) {
-        newData.deletions.forEach(id => existingMap.delete(id))
+        newData.deletions.forEach((id) => existingMap.delete(id))
       }
-      
+
       // Update sync time
-      localStorage.setItem('todos-last-sync', new Date().toISOString())
-      
+      localStorage.setItem("todos-last-sync", new Date().toISOString())
+
       // Return the complete merged state
       return Array.from(existingMap.values())
     },
@@ -353,6 +492,7 @@ const todosCollection = createCollection(
 ```
 
 This pattern allows you to:
+
 - Fetch only incremental changes from your API
 - Merge those changes with existing data
 - Return the complete state that the collection expects
@@ -363,6 +503,7 @@ This pattern allows you to:
 Direct writes update the collection immediately and also update the TanStack Query cache. However, they do not prevent the normal query sync behavior. If your `queryFn` returns data that conflicts with your direct writes, the query data will take precedence.
 
 To handle this properly:
+
 1. Use `{ refetch: false }` in your persistence handlers when using direct writes
 2. Set appropriate `staleTime` to prevent unnecessary refetches
 3. Design your `queryFn` to be aware of incremental updates (e.g., only fetch new data)
@@ -376,4 +517,321 @@ All direct write methods are available on `collection.utils`:
 - `writeDelete(keys)`: Delete one or more items directly
 - `writeUpsert(data)`: Insert or update one or more items directly
 - `writeBatch(callback)`: Perform multiple operations atomically
-- `refetch()`: Manually trigger a refetch of the query
+- `refetch(opts?)`: Manually trigger a refetch of the query
+
+## QueryFn and Predicate Push-Down
+
+When using `syncMode: 'on-demand'`, the collection automatically pushes down query predicates (where clauses, orderBy, limit, and offset) to your `queryFn`. This allows you to fetch only the data needed for each specific query, rather than fetching the entire dataset.
+
+### How LoadSubsetOptions Are Passed
+
+LoadSubsetOptions are passed to your `queryFn` via the query context's `meta` property:
+
+```typescript
+queryFn: async (ctx) => {
+  // Extract LoadSubsetOptions from the context
+  const { limit, offset, where, orderBy } = ctx.meta.loadSubsetOptions
+
+  // Use these to fetch only the data you need
+  // - where: filter expression (AST)
+  // - orderBy: sort expression (AST)
+  // - limit: maximum number of rows
+  // - offset: number of rows to skip (for pagination)
+  // ...
+}
+```
+
+The `where` and `orderBy` fields are expression trees (AST - Abstract Syntax Tree) that need to be parsed. TanStack DB provides helper functions to make this easy.
+
+### Expression Helpers
+
+```typescript
+import {
+  parseWhereExpression,
+  parseOrderByExpression,
+  extractSimpleComparisons,
+  parseLoadSubsetOptions,
+} from '@tanstack/db'
+// Or from '@tanstack/query-db-collection' (re-exported for convenience)
+```
+
+These helpers allow you to parse expression trees without manually traversing complex AST structures.
+
+### Quick Start: Simple REST API
+
+```typescript
+import { createCollection } from '@tanstack/react-db'
+import { queryCollectionOptions } from '@tanstack/query-db-collection'
+import { parseLoadSubsetOptions } from '@tanstack/db'
+import { QueryClient } from '@tanstack/query-core'
+
+const queryClient = new QueryClient()
+
+const productsCollection = createCollection(
+  queryCollectionOptions({
+    id: 'products',
+    queryKey: ['products'],
+    queryClient,
+    getKey: (item) => item.id,
+    syncMode: 'on-demand', // Enable predicate push-down
+
+    queryFn: async (ctx) => {
+      const { limit, offset, where, orderBy } = ctx.meta.loadSubsetOptions
+
+      // Parse the expressions into simple format
+      const parsed = parseLoadSubsetOptions({ where, orderBy, limit })
+
+      // Build query parameters from parsed filters
+      const params = new URLSearchParams()
+
+      // Add filters
+      parsed.filters.forEach(({ field, operator, value }) => {
+        const fieldName = field.join('.')
+        if (operator === 'eq') {
+          params.set(fieldName, String(value))
+        } else if (operator === 'lt') {
+          params.set(`${fieldName}_lt`, String(value))
+        } else if (operator === 'gt') {
+          params.set(`${fieldName}_gt`, String(value))
+        }
+      })
+
+      // Add sorting
+      if (parsed.sorts.length > 0) {
+        const sortParam = parsed.sorts
+          .map(s => `${s.field.join('.')}:${s.direction}`)
+          .join(',')
+        params.set('sort', sortParam)
+      }
+
+      // Add limit
+      if (parsed.limit) {
+        params.set('limit', String(parsed.limit))
+      }
+
+      // Add offset for pagination
+      if (offset) {
+        params.set('offset', String(offset))
+      }
+
+      const response = await fetch(`/api/products?${params}`)
+      return response.json()
+    },
+  })
+)
+
+// Usage with live queries
+import { createLiveQueryCollection } from '@tanstack/react-db'
+import { eq, lt, and } from '@tanstack/db'
+
+const affordableElectronics = createLiveQueryCollection({
+  query: (q) =>
+    q.from({ product: productsCollection })
+     .where(({ product }) => and(
+       eq(product.category, 'electronics'),
+       lt(product.price, 100)
+     ))
+     .orderBy(({ product }) => product.price, 'asc')
+     .limit(10)
+     .select(({ product }) => product)
+})
+
+// This triggers a queryFn call with:
+// GET /api/products?category=electronics&price_lt=100&sort=price:asc&limit=10
+// When paginating, offset is included: &offset=20
+```
+
+### Custom Handlers for Complex APIs
+
+For APIs with specific formats, use custom handlers:
+
+```typescript
+queryFn: async (ctx) => {
+  const { where, orderBy, limit } = ctx.meta.loadSubsetOptions
+
+  // Use custom handlers to match your API's format
+  const filters = parseWhereExpression(where, {
+    handlers: {
+      eq: (field, value) => ({
+        field: field.join('.'),
+        op: 'equals',
+        value
+      }),
+      lt: (field, value) => ({
+        field: field.join('.'),
+        op: 'lessThan',
+        value
+      }),
+      and: (...conditions) => ({
+        operator: 'AND',
+        conditions
+      }),
+      or: (...conditions) => ({
+        operator: 'OR',
+        conditions
+      }),
+    }
+  })
+
+  const sorts = parseOrderByExpression(orderBy)
+
+  return api.query({
+    filters,
+    sort: sorts.map(s => ({
+      field: s.field.join('.'),
+      order: s.direction.toUpperCase()
+    })),
+    limit
+  })
+}
+```
+
+### GraphQL Example
+
+```typescript
+queryFn: async (ctx) => {
+  const { where, orderBy, limit } = ctx.meta.loadSubsetOptions
+
+  // Convert to a GraphQL where clause format
+  const whereClause = parseWhereExpression(where, {
+    handlers: {
+      eq: (field, value) => ({
+        [field.join('_')]: { _eq: value }
+      }),
+      lt: (field, value) => ({
+        [field.join('_')]: { _lt: value }
+      }),
+      and: (...conditions) => ({ _and: conditions }),
+      or: (...conditions) => ({ _or: conditions }),
+    }
+  })
+
+  // Convert to a GraphQL order_by format
+  const sorts = parseOrderByExpression(orderBy)
+  const orderByClause = sorts.map(s => ({
+    [s.field.join('_')]: s.direction
+  }))
+
+  const { data } = await graphqlClient.query({
+    query: gql`
+      query GetProducts($where: product_bool_exp, $orderBy: [product_order_by!], $limit: Int) {
+        product(where: $where, order_by: $orderBy, limit: $limit) {
+          id
+          name
+          category
+          price
+        }
+      }
+    `,
+    variables: {
+      where: whereClause,
+      orderBy: orderByClause,
+      limit
+    }
+  })
+
+  return data.product
+}
+```
+
+### Expression Helper API Reference
+
+#### `parseLoadSubsetOptions(options)`
+
+Convenience function that parses all LoadSubsetOptions at once. Good for simple use cases.
+
+```typescript
+const { filters, sorts, limit, offset } = parseLoadSubsetOptions(ctx.meta?.loadSubsetOptions)
+// filters: [{ field: ['category'], operator: 'eq', value: 'electronics' }]
+// sorts: [{ field: ['price'], direction: 'asc', nulls: 'last' }]
+// limit: 10
+// offset: 20 (for pagination)
+```
+
+#### `parseWhereExpression(expr, options)`
+
+Parses a WHERE expression using custom handlers for each operator. Use this for complete control over the output format.
+
+```typescript
+const filters = parseWhereExpression(where, {
+  handlers: {
+    eq: (field, value) => ({ [field.join('.')]: value }),
+    lt: (field, value) => ({ [`${field.join('.')}_lt`]: value }),
+    and: (...filters) => Object.assign({}, ...filters)
+  },
+  onUnknownOperator: (operator, args) => {
+    console.warn(`Unsupported operator: ${operator}`)
+    return null
+  }
+})
+```
+
+#### `parseOrderByExpression(orderBy)`
+
+Parses an ORDER BY expression into a simple array.
+
+```typescript
+const sorts = parseOrderByExpression(orderBy)
+// Returns: [{ field: ['price'], direction: 'asc', nulls: 'last' }]
+```
+
+#### `extractSimpleComparisons(expr)`
+
+Extracts simple AND-ed comparisons from a WHERE expression. Note: Only works for simple AND conditions.
+
+```typescript
+const comparisons = extractSimpleComparisons(where)
+// Returns: [
+//   { field: ['category'], operator: 'eq', value: 'electronics' },
+//   { field: ['price'], operator: 'lt', value: 100 }
+// ]
+```
+
+### Supported Operators
+
+- `eq` - Equality (=)
+- `gt` - Greater than (>)
+- `gte` - Greater than or equal (>=)
+- `lt` - Less than (<)
+- `lte` - Less than or equal (<=)
+- `and` - Logical AND
+- `or` - Logical OR
+- `in` - IN clause
+
+### Using Query Key Builders
+
+Create different cache entries for different filter combinations:
+
+```typescript
+const productsCollection = createCollection(
+  queryCollectionOptions({
+    id: 'products',
+    // Dynamic query key based on filters
+    queryKey: (opts) => {
+      const parsed = parseLoadSubsetOptions(opts)
+      const cacheKey = ['products']
+
+      parsed.filters.forEach(f => {
+        cacheKey.push(`${f.field.join('.')}-${f.operator}-${f.value}`)
+      })
+
+      if (parsed.limit) {
+        cacheKey.push(`limit-${parsed.limit}`)
+      }
+
+      return cacheKey
+    },
+    queryClient,
+    getKey: (item) => item.id,
+    syncMode: 'on-demand',
+    queryFn: async (ctx) => { /* ... */ },
+  })
+)
+```
+
+### Tips
+
+1. **Start with `parseLoadSubsetOptions`** for simple use cases
+2. **Use custom handlers** via `parseWhereExpression` for APIs with specific formats
+3. **Handle unsupported operators** with the `onUnknownOperator` callback
+4. **Log parsed results** during development to verify correctness
diff --git a/docs/collections/rxdb-collection.md b/docs/collections/rxdb-collection.md
index 71ea3ffed..d139ddc7f 100644
--- a/docs/collections/rxdb-collection.md
+++ b/docs/collections/rxdb-collection.md
@@ -20,9 +20,9 @@ The `@tanstack/rxdb-db-collection` package allows you to create collections that
 - Leverage RxDB's [replication plugins](https://rxdb.info/replication.html) to sync with CouchDB, MongoDB, Supabase, REST APIs, GraphQL, WebRTC (P2P) and more.
 
 
-## 1. Installation
+### 1. Installation
 
-Install the RXDB collection packages along with your preferred framework integration.
+Install the RxDB collection packages along with your preferred framework integration.
 
 ```bash
 npm install @tanstack/rxdb-db-collection rxdb @tanstack/react-db
@@ -35,8 +35,8 @@ npm install @tanstack/rxdb-db-collection rxdb @tanstack/react-db
 import { createRxDatabase, addRxPlugin } from 'rxdb/plugins/core'
 
 /**
- * Here we use the localstorage based storage for RxDB.
- * RxDB has a wide range of storages based on Dexie.js, IndexedDB, SQLite and more.
+ * Here we use the localStorage based storage for RxDB.
+ * RxDB has a wide range of storages based on Dexie.js, IndexedDB, SQLite, and more.
  */
 import { getRxStorageLocalstorage } from 'rxdb/plugins/storage-localstorage'
 
@@ -93,7 +93,7 @@ import { rxdbCollectionOptions } from '@tanstack/rxdb-db-collection'
 
 const todosCollection = createCollection(
   rxdbCollectionOptions({
-    rxCollection: myDatabase.todos,
+    rxCollection: db.todos,
     startSync: true, // start ingesting RxDB data immediately
   })
 )
@@ -118,7 +118,7 @@ The `rxdbCollectionOptions` function accepts the following options:
 ### Optional
 
 - `id`: Unique identifier for the collection
-- `schema`: Schema for validating items. RxDB already has schema validation but having additional validation on the TanStack DB side can help to unify error handling between different tanstack collections.
+- `schema`: Schema for validating items. RxDB already has schema validation but having additional validation on the TanStack DB side can help to unify error handling between different TanStack collections.
 - `startSync`: Whether to start syncing immediately (default: true)
 - `onInsert, onUpdate, onDelete`: Override default persistence handlers. By default, TanStack DB writes are persisted to RxDB using bulkUpsert, patch, and bulkRemove.
 - `syncBatchSize`: The maximum number of documents fetched per batch during the initial sync from RxDB into TanStack DB (default: 1000). Larger values reduce round trips but use more memory; smaller values are lighter but may increase query calls. Note that this only affects the initial sync. Ongoing live updates are streamed one by one via RxDB's change feed.
@@ -132,3 +132,36 @@ Replication and sync in RxDB run independently of TanStack DB. You set up replic
 When replication runs, it pulls and pushes changes to the backend and applies them to the RxDB collection. Since the TanStack DB integration subscribes to the RxDB change stream, any changes applied by replication are automatically reflected in your TanStack DB collection.
 
 This separation of concerns means you configure replication entirely in RxDB, and TanStack DB automatically benefits: your TanStack collections always stay up to date with whatever sync strategy you choose.
+
+
+## FAQ
+
+### Do I still need RxDB schema indexes if I only query TanStack DB?
+
+Usually not, at least for TanStack DB queries themselves. TanStack DB queries run entirely in memory, so RxDB schema indexes do not affect the performance of TanStack DB's live queries. However, RxDB indexes may still be important if:
+- You run queries directly against RxDB (e.g. `rxCollection.find(...)`).
+- Your replication setup uses filtered queries or selectors.
+- You rely on RxDB to selectively load subsets of data instead of hydrating everything into memory.
+
+### Is data duplicated between RxDB and TanStack DB?
+
+Yes, intentionally. RxDB stores data durably on disk. TanStack DB stores data in memory for fast queries and reactivity. This duplication enables high-performance UI queries while retaining [local-first](https://rxdb.info/articles/local-first-future.html) persistence and sync.
+
+### How does backend ↔ RxDB ↔ TanStack DB synchronization work?
+
+Synchronization follows a clear separation of responsibilities between RxDB and TanStack DB.
+
+**RxDB** is responsible for persistence and networking. It stores data durably using a local storage engine (IndexedDB, SQLite, etc.) and handles all replication logic. Replication is configured directly on the RxDB collection and runs independently of TanStack DB. RxDB pulls changes from the backend, applies them locally, resolves conflicts, and pushes local changes back to the backend.
+
+**TanStack DB** sits on top as an in-memory, reactive query layer. It does not talk to the backend directly and does not participate in replication. Instead, it mirrors the current state of the RxDB collection in memory and provides fast live queries and optimistic mutations for the UI.
+
+This design intentionally forms two independent loops:
+- A durability and sync loop managed entirely by RxDB (backend to RxDB).
+- A reactive UI loop managed by TanStack DB (RxDB change stream to in-memory collections to live queries).
+
+## Learn More
+
+- [RxDB Documentation](https://rxdb.info/overview.html)
+- [RxDB Sync Engine](https://rxdb.info/replication.html)
+- [Tanstack DB Live Queries](https://tanstack.com/db/latest/docs/guides/live-queries)
+
diff --git a/docs/collections/trailbase-collection.md b/docs/collections/trailbase-collection.md
new file mode 100644
index 000000000..1b1d60d42
--- /dev/null
+++ b/docs/collections/trailbase-collection.md
@@ -0,0 +1,226 @@
+---
+title: TrailBase Collection
+---
+
+# TrailBase Collection
+
+TrailBase collections provide seamless integration between TanStack DB and [TrailBase](https://trailbase.io), enabling real-time data synchronization with TrailBase's self-hosted application backend.
+
+## Overview
+
+[TrailBase](https://trailbase.io) is an easy-to-self-host, single-executable application backend with built-in SQLite, a V8 JS runtime, auth, admin UIs and sync functionality.
+
+The `@tanstack/trailbase-db-collection` package allows you to create collections that:
+- Automatically sync data from TrailBase Record APIs
+- Support real-time subscriptions when `enable_subscriptions` is enabled
+- Handle optimistic updates with automatic rollback on errors
+- Provide parse/serialize functions for data transformation
+
+## Installation
+
+```bash
+npm install @tanstack/trailbase-db-collection @tanstack/react-db trailbase
+```
+
+## Basic Usage
+
+```typescript
+import { createCollection } from '@tanstack/react-db'
+import { trailBaseCollectionOptions } from '@tanstack/trailbase-db-collection'
+import { initClient } from 'trailbase'
+
+const trailBaseClient = initClient(`https://your-trailbase-instance.com`)
+
+const todosCollection = createCollection(
+  trailBaseCollectionOptions({
+    id: 'todos',
+    recordApi: trailBaseClient.records('todos'),
+    getKey: (item) => item.id,
+  })
+)
+```
+
+## Configuration Options
+
+The `trailBaseCollectionOptions` function accepts the following options:
+
+### Required Options
+
+- `id`: Unique identifier for the collection
+- `recordApi`: TrailBase Record API instance created via `trailBaseClient.records()`
+- `getKey`: Function to extract the unique key from an item
+
+### Optional Options
+
+- `schema`: [Standard Schema](https://standardschema.dev) compatible schema (e.g., Zod, Effect) for client-side validation
+- `parse`: Object mapping field names to parsing functions that transform data coming from TrailBase
+- `serialize`: Object mapping field names to serialization functions that transform data going to TrailBase
+- `onInsert`: Handler function called when items are inserted
+- `onUpdate`: Handler function called when items are updated
+- `onDelete`: Handler function called when items are deleted
+
+## Data Transformation
+
+TrailBase uses different data formats for storage (e.g., Unix timestamps). Use `parse` and `serialize` to handle these transformations:
+
+```typescript
+type SelectTodo = {
+  id: string
+  text: string
+  created_at: number // Unix timestamp from TrailBase
+  completed: boolean
+}
+
+type Todo = {
+  id: string
+  text: string
+  created_at: Date // JavaScript Date for app usage
+  completed: boolean
+}
+
+const todosCollection = createCollection<SelectTodo, Todo>(
+  trailBaseCollectionOptions({
+    id: 'todos',
+    recordApi: trailBaseClient.records('todos'),
+    getKey: (item) => item.id,
+    schema: todoSchema,
+    // Transform TrailBase data to application format
+    parse: {
+      created_at: (ts) => new Date(ts * 1000),
+    },
+    // Transform application data to TrailBase format
+    serialize: {
+      created_at: (date) => Math.floor(date.valueOf() / 1000),
+    },
+  })
+)
+```
+
+## Real-time Subscriptions
+
+TrailBase supports real-time subscriptions when enabled on the server. The collection automatically subscribes to changes and updates in real-time:
+
+```typescript
+const todosCollection = createCollection(
+  trailBaseCollectionOptions({
+    id: 'todos',
+    recordApi: trailBaseClient.records('todos'),
+    getKey: (item) => item.id,
+    // Real-time updates work automatically when
+    // enable_subscriptions is set in TrailBase config
+  })
+)
+
+// Changes from other clients will automatically update
+// the collection in real-time
+```
+
+## Mutation Handlers
+
+Handle inserts, updates, and deletes by providing mutation handlers:
+
+```typescript
+const todosCollection = createCollection(
+  trailBaseCollectionOptions({
+    id: 'todos',
+    recordApi: trailBaseClient.records('todos'),
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      const newTodo = transaction.mutations[0].modified
+      // TrailBase handles the persistence automatically
+      // Add custom logic here if needed
+    },
+    onUpdate: async ({ transaction }) => {
+      const { original, modified } = transaction.mutations[0]
+      // TrailBase handles the persistence automatically
+      // Add custom logic here if needed
+    },
+    onDelete: async ({ transaction }) => {
+      const deletedTodo = transaction.mutations[0].original
+      // TrailBase handles the persistence automatically
+      // Add custom logic here if needed
+    },
+  })
+)
+```
+
+## Complete Example
+
+```typescript
+import { createCollection } from '@tanstack/react-db'
+import { trailBaseCollectionOptions } from '@tanstack/trailbase-db-collection'
+import { initClient } from 'trailbase'
+import { z } from 'zod'
+
+const trailBaseClient = initClient(`https://your-trailbase-instance.com`)
+
+// Define schema
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  completed: z.boolean(),
+  created_at: z.date(),
+})
+
+type SelectTodo = {
+  id: string
+  text: string
+  completed: boolean
+  created_at: number
+}
+
+type Todo = z.infer<typeof todoSchema>
+
+// Create collection
+export const todosCollection = createCollection<SelectTodo, Todo>(
+  trailBaseCollectionOptions({
+    id: 'todos',
+    recordApi: trailBaseClient.records('todos'),
+    getKey: (item) => item.id,
+    schema: todoSchema,
+    parse: {
+      created_at: (ts) => new Date(ts * 1000),
+    },
+    serialize: {
+      created_at: (date) => Math.floor(date.valueOf() / 1000),
+    },
+    onInsert: async ({ transaction }) => {
+      const newTodo = transaction.mutations[0].modified
+      console.log('Todo created:', newTodo)
+    },
+  })
+)
+
+// Use in component
+function TodoList() {
+  const { data: todos } = useLiveQuery((q) =>
+    q.from({ todo: todosCollection })
+      .where(({ todo }) => !todo.completed)
+      .orderBy(({ todo }) => todo.created_at, 'desc')
+  )
+
+  const addTodo = (text: string) => {
+    todosCollection.insert({
+      id: crypto.randomUUID(),
+      text,
+      completed: false,
+      created_at: new Date(),
+    })
+  }
+
+  return (
+    <div>
+      {todos.map((todo) => (
+        <div key={todo.id}>{todo.text}</div>
+      ))}
+    </div>
+  )
+}
+```
+
+## Learn More
+
+- [TrailBase Documentation](https://trailbase.io/documentation/)
+- [TrailBase Record APIs](https://trailbase.io/documentation/apis_record/)
+- [Optimistic Mutations](../guides/mutations.md)
+- [Live Queries](../guides/live-queries.md)
diff --git a/docs/config.json b/docs/config.json
index b16df7560..09ca7c62b 100644
--- a/docs/config.json
+++ b/docs/config.json
@@ -21,53 +21,6 @@
           "label": "Installation",
           "to": "installation"
         }
-      ],
-      "frameworks": [
-        {
-          "label": "react",
-          "children": [
-            {
-              "label": "React Adapter",
-              "to": "framework/react/adapter"
-            }
-          ]
-        },
-        {
-          "label": "solid",
-          "children": [
-            {
-              "label": "Solid Adapter",
-              "to": "framework/solid/adapter"
-            }
-          ]
-        },
-        {
-          "label": "vue",
-          "children": [
-            {
-              "label": "Vue Adapter",
-              "to": "framework/vue/adapter"
-            }
-          ]
-        },
-        {
-          "label": "svelte",
-          "children": [
-            {
-              "label": "Svelte Adapter",
-              "to": "framework/svelte/adapter"
-            }
-          ]
-        },
-        {
-          "label": "angular",
-          "children": [
-            {
-              "label": "Angular Adapter",
-              "to": "framework/angular/adapter"
-            }
-          ]
-        }
       ]
     },
     {
@@ -81,6 +34,10 @@
           "label": "Mutations",
           "to": "guides/mutations"
         },
+        {
+          "label": "Schemas",
+          "to": "guides/schemas"
+        },
         {
           "label": "Error Handling",
           "to": "guides/error-handling"
@@ -102,9 +59,50 @@
           "label": "Electric Collection",
           "to": "collections/electric-collection"
         },
+        {
+          "label": "TrailBase Collection",
+          "to": "collections/trailbase-collection"
+        },
         {
           "label": "RxDB Collection",
           "to": "collections/rxdb-collection"
+        },
+        {
+          "label": "PowerSync Collection",
+          "to": "collections/powersync-collection"
+        },
+        {
+          "label": "LocalStorage Collection",
+          "to": "collections/local-storage-collection"
+        },
+        {
+          "label": "LocalOnly Collection",
+          "to": "collections/local-only-collection"
+        }
+      ]
+    },
+    {
+      "label": "Frameworks",
+      "children": [
+        {
+          "label": "React",
+          "to": "framework/react/overview"
+        },
+        {
+          "label": "Vue",
+          "to": "framework/vue/overview"
+        },
+        {
+          "label": "Angular",
+          "to": "framework/angular/overview"
+        },
+        {
+          "label": "Solid",
+          "to": "framework/solid/overview"
+        },
+        {
+          "label": "Svelte",
+          "to": "framework/svelte/overview"
         }
       ]
     },
@@ -126,27 +124,27 @@
         },
         {
           "label": "Collection",
-          "to": "reference/interfaces/collection"
+          "to": "reference/interfaces/Collection"
         },
         {
           "label": "createCollection",
-          "to": "reference/functions/createcollection"
+          "to": "reference/functions/createCollection"
         },
         {
           "label": "liveQueryCollectionOptions",
-          "to": "reference/functions/livequerycollectionoptions"
+          "to": "reference/functions/liveQueryCollectionOptions"
         },
         {
           "label": "createLiveQueryCollection",
-          "to": "reference/functions/createlivequerycollection"
+          "to": "reference/functions/createLiveQueryCollection"
         },
         {
           "label": "createOptimisticAction",
-          "to": "reference/functions/createoptimisticaction"
+          "to": "reference/functions/createOptimisticAction"
         },
         {
           "label": "createTransaction",
-          "to": "reference/functions/createtransaction"
+          "to": "reference/functions/createTransaction"
         },
         {
           "label": "Electric DB Collection",
@@ -154,7 +152,7 @@
         },
         {
           "label": "electricCollectionOptions",
-          "to": "reference/electric-db-collection/functions/electriccollectionoptions"
+          "to": "reference/electric-db-collection/functions/electricCollectionOptions"
         },
         {
           "label": "Query DB Collection",
@@ -162,7 +160,7 @@
         },
         {
           "label": "queryCollectionOptions",
-          "to": "reference/query-db-collection/functions/querycollectionoptions"
+          "to": "reference/query-db-collection/functions/queryCollectionOptions"
         },
         {
           "label": "RxDB DB Collection",
@@ -170,7 +168,15 @@
         },
         {
           "label": "rxdbCollectionOptions",
-          "to": "reference/rxdb-db-collection/functions/rxdbcollectionoptions"
+          "to": "reference/rxdb-db-collection/functions/rxdbCollectionOptions"
+        },
+        {
+          "label": "PowerSync Collection",
+          "to": "reference/powersync-db-collection/index"
+        },
+        {
+          "label": "powerSyncCollectionOptions",
+          "to": "reference/powersync-db-collection/functions/powerSyncCollectionOptions"
         }
       ],
       "frameworks": [
@@ -183,7 +189,7 @@
             },
             {
               "label": "useLiveQuery",
-              "to": "framework/react/reference/functions/uselivequery"
+              "to": "framework/react/reference/functions/useLiveQuery"
             }
           ]
         },
@@ -196,7 +202,7 @@
             },
             {
               "label": "useLiveQuery",
-              "to": "framework/solid/reference/functions/uselivequery"
+              "to": "framework/solid/reference/functions/useLiveQuery"
             }
           ]
         },
@@ -209,15 +215,15 @@
             },
             {
               "label": "useLiveQuery",
-              "to": "framework/vue/reference/functions/uselivequery"
+              "to": "framework/vue/reference/functions/useLiveQuery"
             },
             {
               "label": "UseLiveQueryReturn",
-              "to": "framework/vue/reference/interfaces/uselivequeryreturn"
+              "to": "framework/vue/reference/interfaces/UseLiveQueryReturn"
             },
             {
               "label": "UseLiveQueryReturnWithCollection",
-              "to": "framework/vue/reference/interfaces/uselivequeryreturnwithcollection"
+              "to": "framework/vue/reference/interfaces/UseLiveQueryReturnWithCollection"
             }
           ]
         },
@@ -230,7 +236,7 @@
             },
             {
               "label": "injectLiveQuery",
-              "to": "framework/angular/reference/functions/injectlivequery"
+              "to": "framework/angular/reference/functions/injectLiveQuery"
             }
           ]
         }
diff --git a/docs/framework/angular/adapter.md b/docs/framework/angular/adapter.md
deleted file mode 100644
index d4b911614..000000000
--- a/docs/framework/angular/adapter.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: TanStack DB Angular Adapter
-id: adapter
----
-
-## Installation
-
-```sh
-npm install @tanstack/angular-db
-```
-
-## Angular inject function
-
-See the [Angular Functions Reference](../reference/index.md) to see the full list of functions available in the Angular Adapter.
-
-## Basic Usage
diff --git a/docs/framework/angular/overview.md b/docs/framework/angular/overview.md
new file mode 100644
index 000000000..916262313
--- /dev/null
+++ b/docs/framework/angular/overview.md
@@ -0,0 +1,212 @@
+---
+title: TanStack DB Angular Adapter
+id: adapter
+---
+
+## Installation
+
+```sh
+npm install @tanstack/angular-db
+```
+
+## Angular inject function
+
+See the [Angular Functions Reference](./reference/index.md) to see the full list of functions available in the Angular Adapter.
+
+For comprehensive documentation on writing queries (filtering, joins, aggregations, etc.), see the [Live Queries Guide](../../guides/live-queries).
+
+## Basic Usage
+
+### injectLiveQuery
+
+The `injectLiveQuery` function creates a live query that automatically updates your component when data changes. It returns an object containing Angular signals for reactive state management:
+
+```typescript
+import { Component } from '@angular/core'
+import { injectLiveQuery } from '@tanstack/angular-db'
+import { eq } from '@tanstack/db'
+
+@Component({
+  selector: 'app-todo-list',
+  standalone: true,
+  template: `
+    @if (query.isLoading()) {
+      <div>Loading...</div>
+    } @else {
+      <ul>
+        @for (todo of query.data(); track todo.id) {
+          <li>{{ todo.text }}</li>
+        }
+      </ul>
+    }
+  `
+})
+export class TodoListComponent {
+  query = injectLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.completed, false))
+     .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+  )
+}
+```
+
+**Note:** All return values (`data`, `isLoading`, `status`, etc.) are Angular signals, so call them with `()` in your template: `query.data()`, `query.isLoading()`.
+
+> **Template Syntax:** Examples use Angular 17+ control flow (`@if`, `@for`). For Angular 16, use `*ngIf` and `*ngFor` instead.
+
+### Reactive Parameters
+
+For queries that depend on reactive values, use the `params` option to re-run the query when those values change:
+
+```typescript
+import { Component, signal } from '@angular/core'
+import { injectLiveQuery } from '@tanstack/angular-db'
+import { gt } from '@tanstack/db'
+
+@Component({
+  selector: 'app-filtered-todos',
+  standalone: true,
+  template: `
+    <div>{{ query.data().length }} high-priority todos</div>
+  `
+})
+export class FilteredTodosComponent {
+  minPriority = signal(5)
+
+  query = injectLiveQuery({
+    params: () => ({ minPriority: this.minPriority() }),
+    query: ({ params, q }) =>
+      q.from({ todos: todosCollection })
+       .where(({ todos }) => gt(todos.priority, params.minPriority))
+  })
+}
+```
+
+#### When to Use Reactive Parameters
+
+Use the reactive `params` option when your query depends on:
+- Component signals
+- Input properties
+- Computed values
+- Other reactive state
+
+When any reactive value accessed in the `params` function changes, the query is recreated and re-executed.
+
+#### What Happens When Parameters Change
+
+When a parameter value changes:
+1. The previous live-query collection is disposed
+2. A new query is created with the updated parameter values
+3. `status()`/`isLoading()` reflect the new query's lifecycle
+4. `data()` updates automatically when the new results arrive
+
+#### Best Practices
+
+**Use reactive params for dynamic queries:**
+
+```typescript
+import { Component, Input, signal } from '@angular/core'
+import { injectLiveQuery } from '@tanstack/angular-db'
+import { eq, and } from '@tanstack/db'
+
+@Component({
+  selector: 'app-todo-list',
+  standalone: true,
+  template: `<div>{{ query.data().length }} todos</div>`
+})
+export class TodoListComponent {
+  // Angular 16+ compatible input
+  @Input({ required: true }) userId!: number
+  status = signal('active')
+
+  // Good - reactive params track all dependencies
+  query = injectLiveQuery({
+    params: () => ({
+      userId: this.userId,
+      status: this.status()
+    }),
+    query: ({ params, q }) =>
+      q.from({ todos: todosCollection })
+       .where(({ todos }) => and(
+         eq(todos.userId, params.userId),
+         eq(todos.status, params.status)
+       ))
+  })
+}
+```
+
+**Using Angular 17+ signal inputs:**
+
+```typescript
+import { Component, input, signal } from '@angular/core'
+import { injectLiveQuery } from '@tanstack/angular-db'
+import { eq, and } from '@tanstack/db'
+
+@Component({
+  selector: 'app-todo-list',
+  standalone: true,
+  template: `<div>{{ query.data().length }} todos</div>`
+})
+export class TodoListComponent {
+  // Angular 17+ signal-based input
+  userId = input.required<number>()
+  status = signal('active')
+
+  query = injectLiveQuery({
+    params: () => ({
+      userId: this.userId(),
+      status: this.status()
+    }),
+    query: ({ params, q }) =>
+      q.from({ todos: todosCollection })
+       .where(({ todos }) => and(
+         eq(todos.userId, params.userId),
+         eq(todos.status, params.status)
+       ))
+  })
+}
+```
+
+**Static queries don't need params:**
+
+```typescript
+import { Component } from '@angular/core'
+import { injectLiveQuery } from '@tanstack/angular-db'
+
+@Component({
+  selector: 'app-all-todos',
+  standalone: true,
+  template: `<div>{{ query.data().length }} todos</div>`
+})
+export class AllTodosComponent {
+  // No reactive dependencies - query never changes
+  query = injectLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+  )
+}
+```
+
+**Access multiple signals in template:**
+
+```typescript
+import { Component } from '@angular/core'
+import { injectLiveQuery } from '@tanstack/angular-db'
+import { eq } from '@tanstack/db'
+
+@Component({
+  selector: 'app-todos',
+  standalone: true,
+  template: `
+    <div>Status: {{ query.status() }}</div>
+    <div>Loading: {{ query.isLoading() }}</div>
+    <div>Ready: {{ query.isReady() }}</div>
+    <div>Total: {{ query.data().length }}</div>
+  `
+})
+export class TodosComponent {
+  query = injectLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.completed, false))
+  )
+}
+```
diff --git a/docs/framework/angular/reference/functions/injectLiveQuery.md b/docs/framework/angular/reference/functions/injectLiveQuery.md
new file mode 100644
index 000000000..46a9a35fb
--- /dev/null
+++ b/docs/framework/angular/reference/functions/injectLiveQuery.md
@@ -0,0 +1,178 @@
+---
+id: injectLiveQuery
+title: injectLiveQuery
+---
+
+# Function: injectLiveQuery()
+
+## Call Signature
+
+```ts
+function injectLiveQuery<TContext, TParams>(options): InjectLiveQueryResult<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
+```
+
+Defined in: [index.ts:51](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L51)
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+#### TParams
+
+`TParams` *extends* `unknown`
+
+### Parameters
+
+#### options
+
+##### params
+
+() => `TParams`
+
+##### query
+
+(`args`) => `QueryBuilder`\<`TContext`\>
+
+### Returns
+
+[`InjectLiveQueryResult`](../interfaces/InjectLiveQueryResult.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}\>
+
+## Call Signature
+
+```ts
+function injectLiveQuery<TContext, TParams>(options): InjectLiveQueryResult<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
+```
+
+Defined in: [index.ts:61](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L61)
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+#### TParams
+
+`TParams` *extends* `unknown`
+
+### Parameters
+
+#### options
+
+##### params
+
+() => `TParams`
+
+##### query
+
+(`args`) => `QueryBuilder`\<`TContext`\> \| `null` \| `undefined`
+
+### Returns
+
+[`InjectLiveQueryResult`](../interfaces/InjectLiveQueryResult.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}\>
+
+## Call Signature
+
+```ts
+function injectLiveQuery<TContext>(queryFn): InjectLiveQueryResult<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
+```
+
+Defined in: [index.ts:71](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L71)
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\>
+
+### Returns
+
+[`InjectLiveQueryResult`](../interfaces/InjectLiveQueryResult.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}\>
+
+## Call Signature
+
+```ts
+function injectLiveQuery<TContext>(queryFn): InjectLiveQueryResult<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
+```
+
+Defined in: [index.ts:74](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L74)
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\> \| `null` \| `undefined`
+
+### Returns
+
+[`InjectLiveQueryResult`](../interfaces/InjectLiveQueryResult.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}\>
+
+## Call Signature
+
+```ts
+function injectLiveQuery<TContext>(config): InjectLiveQueryResult<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
+```
+
+Defined in: [index.ts:79](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L79)
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### config
+
+`LiveQueryCollectionConfig`\<`TContext`\>
+
+### Returns
+
+[`InjectLiveQueryResult`](../interfaces/InjectLiveQueryResult.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}\>
+
+## Call Signature
+
+```ts
+function injectLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): InjectLiveQueryResult<TResult, TKey, TUtils>;
+```
+
+Defined in: [index.ts:82](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L82)
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`Collection`\<`TResult`, `TKey`, `TUtils`\>
+
+### Returns
+
+[`InjectLiveQueryResult`](../interfaces/InjectLiveQueryResult.md)\<`TResult`, `TKey`, `TUtils`\>
diff --git a/docs/framework/angular/reference/index.md b/docs/framework/angular/reference/index.md
new file mode 100644
index 000000000..1321a5528
--- /dev/null
+++ b/docs/framework/angular/reference/index.md
@@ -0,0 +1,14 @@
+---
+id: "@tanstack/angular-db"
+title: "@tanstack/angular-db"
+---
+
+# @tanstack/angular-db
+
+## Interfaces
+
+- [InjectLiveQueryResult](interfaces/InjectLiveQueryResult.md)
+
+## Functions
+
+- [injectLiveQuery](functions/injectLiveQuery.md)
diff --git a/docs/framework/angular/reference/interfaces/InjectLiveQueryResult.md b/docs/framework/angular/reference/interfaces/InjectLiveQueryResult.md
new file mode 100644
index 000000000..2e00287c2
--- /dev/null
+++ b/docs/framework/angular/reference/interfaces/InjectLiveQueryResult.md
@@ -0,0 +1,136 @@
+---
+id: InjectLiveQueryResult
+title: InjectLiveQueryResult
+---
+
+# Interface: InjectLiveQueryResult\<TResult, TKey, TUtils\>
+
+Defined in: [index.ts:26](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L26)
+
+The result of calling `injectLiveQuery`.
+Contains reactive signals for the query state and data.
+
+## Type Parameters
+
+### TResult
+
+`TResult` *extends* `object` = `any`
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\> = \{
+\}
+
+## Properties
+
+### collection
+
+```ts
+collection: Signal<
+  | Collection<TResult, TKey, TUtils, StandardSchemaV1<unknown, unknown>, TResult>
+| null>;
+```
+
+Defined in: [index.ts:36](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L36)
+
+A signal containing the underlying collection instance (null for disabled queries)
+
+***
+
+### data
+
+```ts
+data: Signal<TResult[]>;
+```
+
+Defined in: [index.ts:34](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L34)
+
+A signal containing the results as an array
+
+***
+
+### isCleanedUp
+
+```ts
+isCleanedUp: Signal<boolean>;
+```
+
+Defined in: [index.ts:48](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L48)
+
+A signal indicating whether the collection has been cleaned up
+
+***
+
+### isError
+
+```ts
+isError: Signal<boolean>;
+```
+
+Defined in: [index.ts:46](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L46)
+
+A signal indicating whether the collection has an error
+
+***
+
+### isIdle
+
+```ts
+isIdle: Signal<boolean>;
+```
+
+Defined in: [index.ts:44](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L44)
+
+A signal indicating whether the collection is idle
+
+***
+
+### isLoading
+
+```ts
+isLoading: Signal<boolean>;
+```
+
+Defined in: [index.ts:40](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L40)
+
+A signal indicating whether the collection is currently loading
+
+***
+
+### isReady
+
+```ts
+isReady: Signal<boolean>;
+```
+
+Defined in: [index.ts:42](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L42)
+
+A signal indicating whether the collection is ready
+
+***
+
+### state
+
+```ts
+state: Signal<Map<TKey, TResult>>;
+```
+
+Defined in: [index.ts:32](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L32)
+
+A signal containing the complete state map of results keyed by their ID
+
+***
+
+### status
+
+```ts
+status: Signal<CollectionStatus | "disabled">;
+```
+
+Defined in: [index.ts:38](https://github.com/TanStack/db/blob/main/packages/angular-db/src/index.ts#L38)
+
+A signal containing the current status of the collection
diff --git a/docs/framework/react/adapter.md b/docs/framework/react/adapter.md
deleted file mode 100644
index 7a3b17c60..000000000
--- a/docs/framework/react/adapter.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: TanStack DB React Adapter
-id: adapter
----
-
-## Installation
-
-```sh
-npm install @tanstack/react-db
-```
-
-## React Hooks
-
-See the [React Functions Reference](../reference/index.md) to see the full list of hooks available in the React Adapter.
-
-## Basic Usage
diff --git a/docs/framework/react/overview.md b/docs/framework/react/overview.md
new file mode 100644
index 000000000..ed96a7506
--- /dev/null
+++ b/docs/framework/react/overview.md
@@ -0,0 +1,163 @@
+---
+title: TanStack DB React Adapter
+id: adapter
+---
+
+## Installation
+
+```sh
+npm install @tanstack/react-db
+```
+
+## React Hooks
+
+See the [React Functions Reference](./reference/index.md) to see the full list of hooks available in the React Adapter.
+
+For comprehensive documentation on writing queries (filtering, joins, aggregations, etc.), see the [Live Queries Guide](../../guides/live-queries).
+
+## Basic Usage
+
+### useLiveQuery
+
+The `useLiveQuery` hook creates a live query that automatically updates your component when data changes:
+
+```tsx
+import { useLiveQuery } from '@tanstack/react-db'
+
+function TodoList() {
+  const { data, isLoading } = useLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.completed, false))
+     .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+  )
+
+  if (isLoading) return <div>Loading...</div>
+
+  return (
+    <ul>
+      {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+    </ul>
+  )
+}
+```
+
+### Dependency Arrays
+
+All query hooks (`useLiveQuery`, `useLiveInfiniteQuery`, `useLiveSuspenseQuery`) accept an optional dependency array as their last parameter. This array works similarly to React's `useEffect` dependencies - when any value in the array changes, the query is recreated and re-executed.
+
+#### When to Use Dependency Arrays
+
+Use dependency arrays when your query depends on external reactive values (props, state, or other hooks):
+
+```tsx
+function FilteredTodos({ minPriority }: { minPriority: number }) {
+  const { data } = useLiveQuery(
+    (q) => q.from({ todos: todosCollection })
+           .where(({ todos }) => gt(todos.priority, minPriority)),
+    [minPriority] // Re-run when minPriority changes
+  )
+
+  return <div>{data.length} high-priority todos</div>
+}
+```
+
+#### What Happens When Dependencies Change
+
+When a dependency value changes:
+1. The previous live query collection is cleaned up
+2. A new query is created with the updated values
+3. The component re-renders with the new data
+4. The hook suspends (for `useLiveSuspenseQuery`) or shows loading state
+
+#### Best Practices
+
+**Include all external values used in the query:**
+
+```tsx
+// Good - all external values in deps
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => and(
+           eq(todos.userId, userId),
+           eq(todos.status, status)
+         )),
+  [userId, status]
+)
+
+// Bad - missing dependencies
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.userId, userId)),
+  [] // Missing userId!
+)
+```
+
+**Empty array for static queries:**
+
+```tsx
+// No external dependencies - query never changes
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection }),
+  []
+)
+```
+
+**Omit the array for queries with no external dependencies:**
+
+```tsx
+// Same as above - no deps needed
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+)
+```
+
+### useLiveInfiniteQuery
+
+For paginated data with live updates, use `useLiveInfiniteQuery`:
+
+```tsx
+const { data, pages, fetchNextPage, hasNextPage } = useLiveInfiniteQuery(
+  (q) => q
+    .from({ posts: postsCollection })
+    .where(({ posts }) => eq(posts.category, category))
+    .orderBy(({ posts }) => posts.createdAt, 'desc'),
+  {
+    pageSize: 20,
+    getNextPageParam: (lastPage, allPages) =>
+      lastPage.length === 20 ? allPages.length : undefined
+  },
+  [category] // Re-run when category changes
+)
+```
+
+**Note:** The dependency array is only available when using the query function variant, not when passing a pre-created collection.
+
+### useLiveSuspenseQuery
+
+For React Suspense integration, use `useLiveSuspenseQuery`:
+
+```tsx
+function TodoList({ filter }: { filter: string }) {
+  const { data } = useLiveSuspenseQuery(
+    (q) => q.from({ todos: todosCollection })
+           .where(({ todos }) => eq(todos.filter, filter)),
+    [filter] // Re-suspends when filter changes
+  )
+
+  return (
+    <ul>
+      {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+    </ul>
+  )
+}
+
+function App() {
+  return (
+    <Suspense fallback={<div>Loading...</div>}>
+      <TodoList filter="active" />
+    </Suspense>
+  )
+}
+```
+
+When dependencies change, `useLiveSuspenseQuery` will re-suspend, showing your Suspense fallback until the new data is ready.
diff --git a/docs/framework/react/reference/functions/useLiveInfiniteQuery.md b/docs/framework/react/reference/functions/useLiveInfiniteQuery.md
new file mode 100644
index 000000000..8fe91f730
--- /dev/null
+++ b/docs/framework/react/reference/functions/useLiveInfiniteQuery.md
@@ -0,0 +1,217 @@
+---
+id: useLiveInfiniteQuery
+title: useLiveInfiniteQuery
+---
+
+# Function: useLiveInfiniteQuery()
+
+## Call Signature
+
+```ts
+function useLiveInfiniteQuery<TResult, TKey, TUtils>(liveQueryCollection, config): UseLiveInfiniteQueryReturn<any>;
+```
+
+Defined in: [useLiveInfiniteQuery.ts:113](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveInfiniteQuery.ts#L113)
+
+Create an infinite query using a query function with live updates
+
+Uses `utils.setWindow()` to dynamically adjust the limit/offset window
+without recreating the live query collection on each page change.
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\> & `NonSingleResult`
+
+#### config
+
+[`UseLiveInfiniteQueryConfig`](../type-aliases/UseLiveInfiniteQueryConfig.md)\<`any`\>
+
+Configuration including pageSize and getNextPageParam
+
+### Returns
+
+[`UseLiveInfiniteQueryReturn`](../type-aliases/UseLiveInfiniteQueryReturn.md)\<`any`\>
+
+Object with pages, data, and pagination controls
+
+### Examples
+
+```ts
+// Basic infinite query
+const { data, pages, fetchNextPage, hasNextPage } = useLiveInfiniteQuery(
+  (q) => q
+    .from({ posts: postsCollection })
+    .orderBy(({ posts }) => posts.createdAt, 'desc')
+    .select(({ posts }) => ({
+      id: posts.id,
+      title: posts.title
+    })),
+  {
+    pageSize: 20,
+    getNextPageParam: (lastPage, allPages) =>
+      lastPage.length === 20 ? allPages.length : undefined
+  }
+)
+```
+
+```ts
+// With dependencies
+const { pages, fetchNextPage } = useLiveInfiniteQuery(
+  (q) => q
+    .from({ posts: postsCollection })
+    .where(({ posts }) => eq(posts.category, category))
+    .orderBy(({ posts }) => posts.createdAt, 'desc'),
+  {
+    pageSize: 10,
+    getNextPageParam: (lastPage) =>
+      lastPage.length === 10 ? lastPage.length : undefined
+  },
+  [category]
+)
+```
+
+```ts
+// Router loader pattern with pre-created collection
+// In loader:
+const postsQuery = createLiveQueryCollection({
+  query: (q) => q
+    .from({ posts: postsCollection })
+    .orderBy(({ posts }) => posts.createdAt, 'desc')
+    .limit(20)
+})
+await postsQuery.preload()
+return { postsQuery }
+
+// In component:
+const { postsQuery } = useLoaderData()
+const { data, fetchNextPage, hasNextPage } = useLiveInfiniteQuery(
+  postsQuery,
+  {
+    pageSize: 20,
+    getNextPageParam: (lastPage) => lastPage.length === 20 ? lastPage.length : undefined
+  }
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveInfiniteQuery<TContext>(
+   queryFn, 
+   config, 
+deps?): UseLiveInfiniteQueryReturn<TContext>;
+```
+
+Defined in: [useLiveInfiniteQuery.ts:123](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveInfiniteQuery.ts#L123)
+
+Create an infinite query using a query function with live updates
+
+Uses `utils.setWindow()` to dynamically adjust the limit/offset window
+without recreating the live query collection on each page change.
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\>
+
+Query function that defines what data to fetch. Must include `.orderBy()` for setWindow to work.
+
+#### config
+
+[`UseLiveInfiniteQueryConfig`](../type-aliases/UseLiveInfiniteQueryConfig.md)\<`TContext`\>
+
+Configuration including pageSize and getNextPageParam
+
+#### deps?
+
+`unknown`[]
+
+Array of dependencies that trigger query re-execution when changed
+
+### Returns
+
+[`UseLiveInfiniteQueryReturn`](../type-aliases/UseLiveInfiniteQueryReturn.md)\<`TContext`\>
+
+Object with pages, data, and pagination controls
+
+### Examples
+
+```ts
+// Basic infinite query
+const { data, pages, fetchNextPage, hasNextPage } = useLiveInfiniteQuery(
+  (q) => q
+    .from({ posts: postsCollection })
+    .orderBy(({ posts }) => posts.createdAt, 'desc')
+    .select(({ posts }) => ({
+      id: posts.id,
+      title: posts.title
+    })),
+  {
+    pageSize: 20,
+    getNextPageParam: (lastPage, allPages) =>
+      lastPage.length === 20 ? allPages.length : undefined
+  }
+)
+```
+
+```ts
+// With dependencies
+const { pages, fetchNextPage } = useLiveInfiniteQuery(
+  (q) => q
+    .from({ posts: postsCollection })
+    .where(({ posts }) => eq(posts.category, category))
+    .orderBy(({ posts }) => posts.createdAt, 'desc'),
+  {
+    pageSize: 10,
+    getNextPageParam: (lastPage) =>
+      lastPage.length === 10 ? lastPage.length : undefined
+  },
+  [category]
+)
+```
+
+```ts
+// Router loader pattern with pre-created collection
+// In loader:
+const postsQuery = createLiveQueryCollection({
+  query: (q) => q
+    .from({ posts: postsCollection })
+    .orderBy(({ posts }) => posts.createdAt, 'desc')
+    .limit(20)
+})
+await postsQuery.preload()
+return { postsQuery }
+
+// In component:
+const { postsQuery } = useLoaderData()
+const { data, fetchNextPage, hasNextPage } = useLiveInfiniteQuery(
+  postsQuery,
+  {
+    pageSize: 20,
+    getNextPageParam: (lastPage) => lastPage.length === 20 ? lastPage.length : undefined
+  }
+)
+```
diff --git a/docs/framework/react/reference/functions/useLiveQuery.md b/docs/framework/react/reference/functions/useLiveQuery.md
new file mode 100644
index 000000000..84162b674
--- /dev/null
+++ b/docs/framework/react/reference/functions/useLiveQuery.md
@@ -0,0 +1,1251 @@
+---
+id: useLiveQuery
+title: useLiveQuery
+---
+
+# Function: useLiveQuery()
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(queryFn, deps?): object;
+```
+
+Defined in: [useLiveQuery.ts:84](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L84)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\>
+
+Query function that defines what data to fetch
+
+#### deps?
+
+`unknown`[]
+
+Array of dependencies that trigger query re-execution when changed
+
+### Returns
+
+`object`
+
+Object with reactive data, state, and status information
+
+#### collection
+
+```ts
+collection: Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {
+}>;
+```
+
+#### data
+
+```ts
+data: InferResultType<TContext>;
+```
+
+#### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+#### isEnabled
+
+```ts
+isEnabled: true;
+```
+
+#### isError
+
+```ts
+isError: boolean;
+```
+
+#### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+#### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+#### isReady
+
+```ts
+isReady: boolean;
+```
+
+#### state
+
+```ts
+state: Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
+```
+
+#### status
+
+```ts
+status: CollectionStatus;
+```
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// Single result query
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+```
+
+```ts
+// With dependencies that trigger re-execution
+const { data, state } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Join pattern
+const { data } = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states
+const { data, isLoading, isError, status } = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+if (isLoading) return <div>Loading...</div>
+if (isError) return <div>Error: {status}</div>
+
+return (
+  <ul>
+    {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+  </ul>
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(queryFn, deps?): object;
+```
+
+Defined in: [useLiveQuery.ts:101](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L101)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\> \| `null` \| `undefined`
+
+Query function that defines what data to fetch
+
+#### deps?
+
+`unknown`[]
+
+Array of dependencies that trigger query re-execution when changed
+
+### Returns
+
+`object`
+
+Object with reactive data, state, and status information
+
+#### collection
+
+```ts
+collection: 
+  | Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {
+}, StandardSchemaV1<unknown, unknown>, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>
+  | undefined;
+```
+
+#### data
+
+```ts
+data: InferResultType<TContext> | undefined;
+```
+
+#### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+#### isEnabled
+
+```ts
+isEnabled: boolean;
+```
+
+#### isError
+
+```ts
+isError: boolean;
+```
+
+#### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+#### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+#### isReady
+
+```ts
+isReady: boolean;
+```
+
+#### state
+
+```ts
+state: 
+  | Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>
+  | undefined;
+```
+
+#### status
+
+```ts
+status: UseLiveQueryStatus;
+```
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// Single result query
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+```
+
+```ts
+// With dependencies that trigger re-execution
+const { data, state } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Join pattern
+const { data } = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states
+const { data, isLoading, isError, status } = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+if (isLoading) return <div>Loading...</div>
+if (isError) return <div>Error: {status}</div>
+
+return (
+  <ul>
+    {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+  </ul>
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(queryFn, deps?): object;
+```
+
+Defined in: [useLiveQuery.ts:120](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L120)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => 
+  \| `LiveQueryCollectionConfig`\<`TContext`, \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \} & `object`\>
+  \| `null`
+  \| `undefined`
+
+Query function that defines what data to fetch
+
+#### deps?
+
+`unknown`[]
+
+Array of dependencies that trigger query re-execution when changed
+
+### Returns
+
+`object`
+
+Object with reactive data, state, and status information
+
+#### collection
+
+```ts
+collection: 
+  | Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {
+}, StandardSchemaV1<unknown, unknown>, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>
+  | undefined;
+```
+
+#### data
+
+```ts
+data: InferResultType<TContext> | undefined;
+```
+
+#### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+#### isEnabled
+
+```ts
+isEnabled: boolean;
+```
+
+#### isError
+
+```ts
+isError: boolean;
+```
+
+#### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+#### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+#### isReady
+
+```ts
+isReady: boolean;
+```
+
+#### state
+
+```ts
+state: 
+  | Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>
+  | undefined;
+```
+
+#### status
+
+```ts
+status: UseLiveQueryStatus;
+```
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// Single result query
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+```
+
+```ts
+// With dependencies that trigger re-execution
+const { data, state } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Join pattern
+const { data } = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states
+const { data, isLoading, isError, status } = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+if (isLoading) return <div>Loading...</div>
+if (isError) return <div>Error: {status}</div>
+
+return (
+  <ul>
+    {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+  </ul>
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TResult, TKey, TUtils>(queryFn, deps?): object;
+```
+
+Defined in: [useLiveQuery.ts:139](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L139)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### queryFn
+
+(`q`) => 
+  \| `Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\>
+  \| `null`
+  \| `undefined`
+
+Query function that defines what data to fetch
+
+#### deps?
+
+`unknown`[]
+
+Array of dependencies that trigger query re-execution when changed
+
+### Returns
+
+`object`
+
+Object with reactive data, state, and status information
+
+#### collection
+
+```ts
+collection: 
+  | Collection<TResult, TKey, TUtils, StandardSchemaV1<unknown, unknown>, TResult>
+  | undefined;
+```
+
+#### data
+
+```ts
+data: TResult[] | undefined;
+```
+
+#### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+#### isEnabled
+
+```ts
+isEnabled: boolean;
+```
+
+#### isError
+
+```ts
+isError: boolean;
+```
+
+#### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+#### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+#### isReady
+
+```ts
+isReady: boolean;
+```
+
+#### state
+
+```ts
+state: Map<TKey, TResult> | undefined;
+```
+
+#### status
+
+```ts
+status: UseLiveQueryStatus;
+```
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// Single result query
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+```
+
+```ts
+// With dependencies that trigger re-execution
+const { data, state } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Join pattern
+const { data } = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states
+const { data, isLoading, isError, status } = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+if (isLoading) return <div>Loading...</div>
+if (isError) return <div>Error: {status}</div>
+
+return (
+  <ul>
+    {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+  </ul>
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext, TResult, TKey, TUtils>(queryFn, deps?): object;
+```
+
+Defined in: [useLiveQuery.ts:162](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L162)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### queryFn
+
+(`q`) => 
+  \| `QueryBuilder`\<`TContext`\>
+  \| `LiveQueryCollectionConfig`\<`TContext`, \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \} & `object`\>
+  \| `Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\>
+  \| `null`
+  \| `undefined`
+
+Query function that defines what data to fetch
+
+#### deps?
+
+`unknown`[]
+
+Array of dependencies that trigger query re-execution when changed
+
+### Returns
+
+`object`
+
+Object with reactive data, state, and status information
+
+#### collection
+
+```ts
+collection: 
+  | Collection<TResult, TKey, TUtils, StandardSchemaV1<unknown, unknown>, TResult>
+  | Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {
+}, StandardSchemaV1<unknown, unknown>, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>
+  | undefined;
+```
+
+#### data
+
+```ts
+data: InferResultType<TContext> | TResult[] | undefined;
+```
+
+#### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+#### isEnabled
+
+```ts
+isEnabled: boolean;
+```
+
+#### isError
+
+```ts
+isError: boolean;
+```
+
+#### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+#### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+#### isReady
+
+```ts
+isReady: boolean;
+```
+
+#### state
+
+```ts
+state: 
+  | Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>
+  | Map<TKey, TResult>
+  | undefined;
+```
+
+#### status
+
+```ts
+status: UseLiveQueryStatus;
+```
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// Single result query
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+```
+
+```ts
+// With dependencies that trigger re-execution
+const { data, state } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Join pattern
+const { data } = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states
+const { data, isLoading, isError, status } = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+if (isLoading) return <div>Loading...</div>
+if (isError) return <div>Error: {status}</div>
+
+return (
+  <ul>
+    {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+  </ul>
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(config, deps?): object;
+```
+
+Defined in: [useLiveQuery.ts:230](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L230)
+
+Create a live query using configuration object
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### config
+
+`LiveQueryCollectionConfig`\<`TContext`\>
+
+Configuration object with query and options
+
+#### deps?
+
+`unknown`[]
+
+Array of dependencies that trigger query re-execution when changed
+
+### Returns
+
+`object`
+
+Object with reactive data, state, and status information
+
+#### collection
+
+```ts
+collection: Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {
+}>;
+```
+
+#### data
+
+```ts
+data: InferResultType<TContext>;
+```
+
+#### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+#### isEnabled
+
+```ts
+isEnabled: true;
+```
+
+#### isError
+
+```ts
+isError: boolean;
+```
+
+#### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+#### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+#### isReady
+
+```ts
+isReady: boolean;
+```
+
+#### state
+
+```ts
+state: Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
+```
+
+#### status
+
+```ts
+status: CollectionStatus;
+```
+
+### Examples
+
+```ts
+// Basic config object usage
+const { data, status } = useLiveQuery({
+  query: (q) => q.from({ todos: todosCollection }),
+  gcTime: 60000
+})
+```
+
+```ts
+// With query builder and options
+const queryBuilder = new Query()
+  .from({ persons: collection })
+  .where(({ persons }) => gt(persons.age, 30))
+  .select(({ persons }) => ({ id: persons.id, name: persons.name }))
+
+const { data, isReady } = useLiveQuery({ query: queryBuilder })
+```
+
+```ts
+// Handle all states uniformly
+const { data, isLoading, isReady, isError } = useLiveQuery({
+  query: (q) => q.from({ items: itemCollection })
+})
+
+if (isLoading) return <div>Loading...</div>
+if (isError) return <div>Something went wrong</div>
+if (!isReady) return <div>Preparing...</div>
+
+return <div>{data.length} items loaded</div>
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): object;
+```
+
+Defined in: [useLiveQuery.ts:276](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L276)
+
+Subscribe to an existing live query collection
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\> & `NonSingleResult`
+
+Pre-created live query collection to subscribe to
+
+### Returns
+
+`object`
+
+Object with reactive data, state, and status information
+
+#### collection
+
+```ts
+collection: Collection<TResult, TKey, TUtils>;
+```
+
+#### data
+
+```ts
+data: TResult[];
+```
+
+#### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+#### isEnabled
+
+```ts
+isEnabled: true;
+```
+
+#### isError
+
+```ts
+isError: boolean;
+```
+
+#### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+#### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+#### isReady
+
+```ts
+isReady: boolean;
+```
+
+#### state
+
+```ts
+state: Map<TKey, TResult>;
+```
+
+#### status
+
+```ts
+status: CollectionStatus;
+```
+
+### Examples
+
+```ts
+// Using pre-created live query collection
+const myLiveQuery = createLiveQueryCollection((q) =>
+  q.from({ todos: todosCollection }).where(({ todos }) => eq(todos.active, true))
+)
+const { data, collection } = useLiveQuery(myLiveQuery)
+```
+
+```ts
+// Access collection methods directly
+const { data, collection, isReady } = useLiveQuery(existingCollection)
+
+// Use collection for mutations
+const handleToggle = (id) => {
+  collection.update(id, draft => { draft.completed = !draft.completed })
+}
+```
+
+```ts
+// Handle states consistently
+const { data, isLoading, isError } = useLiveQuery(sharedCollection)
+
+if (isLoading) return <div>Loading...</div>
+if (isError) return <div>Error loading data</div>
+
+return <div>{data.map(item => <Item key={item.id} {...item} />)}</div>
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): object;
+```
+
+Defined in: [useLiveQuery.ts:296](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L296)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\> & `SingleResult`
+
+### Returns
+
+`object`
+
+Object with reactive data, state, and status information
+
+#### collection
+
+```ts
+collection: Collection<TResult, TKey, TUtils, StandardSchemaV1<unknown, unknown>, TResult> & SingleResult;
+```
+
+#### data
+
+```ts
+data: TResult | undefined;
+```
+
+#### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+#### isEnabled
+
+```ts
+isEnabled: true;
+```
+
+#### isError
+
+```ts
+isError: boolean;
+```
+
+#### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+#### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+#### isReady
+
+```ts
+isReady: boolean;
+```
+
+#### state
+
+```ts
+state: Map<TKey, TResult>;
+```
+
+#### status
+
+```ts
+status: CollectionStatus;
+```
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// Single result query
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+```
+
+```ts
+// With dependencies that trigger re-execution
+const { data, state } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Join pattern
+const { data } = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states
+const { data, isLoading, isError, status } = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+if (isLoading) return <div>Loading...</div>
+if (isError) return <div>Error: {status}</div>
+
+return (
+  <ul>
+    {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+  </ul>
+)
+```
diff --git a/docs/framework/react/reference/functions/useLiveSuspenseQuery.md b/docs/framework/react/reference/functions/useLiveSuspenseQuery.md
new file mode 100644
index 000000000..94c00a9fd
--- /dev/null
+++ b/docs/framework/react/reference/functions/useLiveSuspenseQuery.md
@@ -0,0 +1,626 @@
+---
+id: useLiveSuspenseQuery
+title: useLiveSuspenseQuery
+---
+
+# Function: useLiveSuspenseQuery()
+
+## Call Signature
+
+```ts
+function useLiveSuspenseQuery<TContext>(queryFn, deps?): object;
+```
+
+Defined in: [useLiveSuspenseQuery.ts:109](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveSuspenseQuery.ts#L109)
+
+Create a live query with React Suspense support
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\>
+
+Query function that defines what data to fetch
+
+#### deps?
+
+`unknown`[]
+
+Array of dependencies that trigger query re-execution when changed
+
+### Returns
+
+`object`
+
+Object with reactive data and state - data is guaranteed to be defined
+
+#### collection
+
+```ts
+collection: Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {
+}>;
+```
+
+#### data
+
+```ts
+data: InferResultType<TContext>;
+```
+
+#### state
+
+```ts
+state: Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
+```
+
+### Throws
+
+Promise when data is loading (caught by Suspense boundary)
+
+### Throws
+
+Error when collection fails (caught by Error boundary)
+
+### Examples
+
+```ts
+// Basic usage with Suspense
+function TodoList() {
+  const { data } = useLiveSuspenseQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.completed, false))
+     .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+  )
+
+  return (
+    <ul>
+      {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+    </ul>
+  )
+}
+
+function App() {
+  return (
+    <Suspense fallback={<div>Loading...</div>}>
+      <TodoList />
+    </Suspense>
+  )
+}
+```
+
+```ts
+// Single result query
+const { data } = useLiveSuspenseQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+// data is guaranteed to be the single item (or undefined if not found)
+```
+
+```ts
+// With dependencies that trigger re-suspension
+const { data } = useLiveSuspenseQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-suspends when minPriority changes
+)
+```
+
+```ts
+// With Error boundary
+function App() {
+  return (
+    <ErrorBoundary fallback={<div>Error loading data</div>}>
+      <Suspense fallback={<div>Loading...</div>}>
+        <TodoList />
+      </Suspense>
+    </ErrorBoundary>
+  )
+}
+```
+
+### Remarks
+
+**Important:** This hook does NOT support disabled queries (returning undefined/null).
+Following TanStack Query's useSuspenseQuery design, the query callback must always
+return a valid query, collection, or config object.
+
+❌ **This will cause a type error:**
+```ts
+useLiveSuspenseQuery(
+  (q) => userId ? q.from({ users }) : undefined  // ❌ Error!
+)
+```
+
+✅ **Use conditional rendering instead:**
+```ts
+function Profile({ userId }: { userId: string }) {
+  const { data } = useLiveSuspenseQuery(
+    (q) => q.from({ users }).where(({ users }) => eq(users.id, userId))
+  )
+  return <div>{data.name}</div>
+}
+
+// In parent component:
+{userId ? <Profile userId={userId} /> : <div>No user</div>}
+```
+
+✅ **Or use useLiveQuery for conditional queries:**
+```ts
+const { data, isEnabled } = useLiveQuery(
+  (q) => userId ? q.from({ users }) : undefined,  // ✅ Supported!
+  [userId]
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveSuspenseQuery<TContext>(config, deps?): object;
+```
+
+Defined in: [useLiveSuspenseQuery.ts:119](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveSuspenseQuery.ts#L119)
+
+Create a live query with React Suspense support
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### config
+
+`LiveQueryCollectionConfig`\<`TContext`\>
+
+#### deps?
+
+`unknown`[]
+
+Array of dependencies that trigger query re-execution when changed
+
+### Returns
+
+`object`
+
+Object with reactive data and state - data is guaranteed to be defined
+
+#### collection
+
+```ts
+collection: Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {
+}>;
+```
+
+#### data
+
+```ts
+data: InferResultType<TContext>;
+```
+
+#### state
+
+```ts
+state: Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
+```
+
+### Throws
+
+Promise when data is loading (caught by Suspense boundary)
+
+### Throws
+
+Error when collection fails (caught by Error boundary)
+
+### Examples
+
+```ts
+// Basic usage with Suspense
+function TodoList() {
+  const { data } = useLiveSuspenseQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.completed, false))
+     .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+  )
+
+  return (
+    <ul>
+      {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+    </ul>
+  )
+}
+
+function App() {
+  return (
+    <Suspense fallback={<div>Loading...</div>}>
+      <TodoList />
+    </Suspense>
+  )
+}
+```
+
+```ts
+// Single result query
+const { data } = useLiveSuspenseQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+// data is guaranteed to be the single item (or undefined if not found)
+```
+
+```ts
+// With dependencies that trigger re-suspension
+const { data } = useLiveSuspenseQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-suspends when minPriority changes
+)
+```
+
+```ts
+// With Error boundary
+function App() {
+  return (
+    <ErrorBoundary fallback={<div>Error loading data</div>}>
+      <Suspense fallback={<div>Loading...</div>}>
+        <TodoList />
+      </Suspense>
+    </ErrorBoundary>
+  )
+}
+```
+
+### Remarks
+
+**Important:** This hook does NOT support disabled queries (returning undefined/null).
+Following TanStack Query's useSuspenseQuery design, the query callback must always
+return a valid query, collection, or config object.
+
+❌ **This will cause a type error:**
+```ts
+useLiveSuspenseQuery(
+  (q) => userId ? q.from({ users }) : undefined  // ❌ Error!
+)
+```
+
+✅ **Use conditional rendering instead:**
+```ts
+function Profile({ userId }: { userId: string }) {
+  const { data } = useLiveSuspenseQuery(
+    (q) => q.from({ users }).where(({ users }) => eq(users.id, userId))
+  )
+  return <div>{data.name}</div>
+}
+
+// In parent component:
+{userId ? <Profile userId={userId} /> : <div>No user</div>}
+```
+
+✅ **Or use useLiveQuery for conditional queries:**
+```ts
+const { data, isEnabled } = useLiveQuery(
+  (q) => userId ? q.from({ users }) : undefined,  // ✅ Supported!
+  [userId]
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveSuspenseQuery<TResult, TKey, TUtils>(liveQueryCollection): object;
+```
+
+Defined in: [useLiveSuspenseQuery.ts:129](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveSuspenseQuery.ts#L129)
+
+Create a live query with React Suspense support
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\> & `NonSingleResult`
+
+### Returns
+
+`object`
+
+Object with reactive data and state - data is guaranteed to be defined
+
+#### collection
+
+```ts
+collection: Collection<TResult, TKey, TUtils>;
+```
+
+#### data
+
+```ts
+data: TResult[];
+```
+
+#### state
+
+```ts
+state: Map<TKey, TResult>;
+```
+
+### Throws
+
+Promise when data is loading (caught by Suspense boundary)
+
+### Throws
+
+Error when collection fails (caught by Error boundary)
+
+### Examples
+
+```ts
+// Basic usage with Suspense
+function TodoList() {
+  const { data } = useLiveSuspenseQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.completed, false))
+     .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+  )
+
+  return (
+    <ul>
+      {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+    </ul>
+  )
+}
+
+function App() {
+  return (
+    <Suspense fallback={<div>Loading...</div>}>
+      <TodoList />
+    </Suspense>
+  )
+}
+```
+
+```ts
+// Single result query
+const { data } = useLiveSuspenseQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+// data is guaranteed to be the single item (or undefined if not found)
+```
+
+```ts
+// With dependencies that trigger re-suspension
+const { data } = useLiveSuspenseQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-suspends when minPriority changes
+)
+```
+
+```ts
+// With Error boundary
+function App() {
+  return (
+    <ErrorBoundary fallback={<div>Error loading data</div>}>
+      <Suspense fallback={<div>Loading...</div>}>
+        <TodoList />
+      </Suspense>
+    </ErrorBoundary>
+  )
+}
+```
+
+### Remarks
+
+**Important:** This hook does NOT support disabled queries (returning undefined/null).
+Following TanStack Query's useSuspenseQuery design, the query callback must always
+return a valid query, collection, or config object.
+
+❌ **This will cause a type error:**
+```ts
+useLiveSuspenseQuery(
+  (q) => userId ? q.from({ users }) : undefined  // ❌ Error!
+)
+```
+
+✅ **Use conditional rendering instead:**
+```ts
+function Profile({ userId }: { userId: string }) {
+  const { data } = useLiveSuspenseQuery(
+    (q) => q.from({ users }).where(({ users }) => eq(users.id, userId))
+  )
+  return <div>{data.name}</div>
+}
+
+// In parent component:
+{userId ? <Profile userId={userId} /> : <div>No user</div>}
+```
+
+✅ **Or use useLiveQuery for conditional queries:**
+```ts
+const { data, isEnabled } = useLiveQuery(
+  (q) => userId ? q.from({ users }) : undefined,  // ✅ Supported!
+  [userId]
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveSuspenseQuery<TResult, TKey, TUtils>(liveQueryCollection): object;
+```
+
+Defined in: [useLiveSuspenseQuery.ts:142](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveSuspenseQuery.ts#L142)
+
+Create a live query with React Suspense support
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\> & `SingleResult`
+
+### Returns
+
+`object`
+
+Object with reactive data and state - data is guaranteed to be defined
+
+#### collection
+
+```ts
+collection: Collection<TResult, TKey, TUtils, StandardSchemaV1<unknown, unknown>, TResult> & SingleResult;
+```
+
+#### data
+
+```ts
+data: TResult | undefined;
+```
+
+#### state
+
+```ts
+state: Map<TKey, TResult>;
+```
+
+### Throws
+
+Promise when data is loading (caught by Suspense boundary)
+
+### Throws
+
+Error when collection fails (caught by Error boundary)
+
+### Examples
+
+```ts
+// Basic usage with Suspense
+function TodoList() {
+  const { data } = useLiveSuspenseQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.completed, false))
+     .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+  )
+
+  return (
+    <ul>
+      {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+    </ul>
+  )
+}
+
+function App() {
+  return (
+    <Suspense fallback={<div>Loading...</div>}>
+      <TodoList />
+    </Suspense>
+  )
+}
+```
+
+```ts
+// Single result query
+const { data } = useLiveSuspenseQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.id, 1))
+         .findOne()
+)
+// data is guaranteed to be the single item (or undefined if not found)
+```
+
+```ts
+// With dependencies that trigger re-suspension
+const { data } = useLiveSuspenseQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [minPriority] // Re-suspends when minPriority changes
+)
+```
+
+```ts
+// With Error boundary
+function App() {
+  return (
+    <ErrorBoundary fallback={<div>Error loading data</div>}>
+      <Suspense fallback={<div>Loading...</div>}>
+        <TodoList />
+      </Suspense>
+    </ErrorBoundary>
+  )
+}
+```
+
+### Remarks
+
+**Important:** This hook does NOT support disabled queries (returning undefined/null).
+Following TanStack Query's useSuspenseQuery design, the query callback must always
+return a valid query, collection, or config object.
+
+❌ **This will cause a type error:**
+```ts
+useLiveSuspenseQuery(
+  (q) => userId ? q.from({ users }) : undefined  // ❌ Error!
+)
+```
+
+✅ **Use conditional rendering instead:**
+```ts
+function Profile({ userId }: { userId: string }) {
+  const { data } = useLiveSuspenseQuery(
+    (q) => q.from({ users }).where(({ users }) => eq(users.id, userId))
+  )
+  return <div>{data.name}</div>
+}
+
+// In parent component:
+{userId ? <Profile userId={userId} /> : <div>No user</div>}
+```
+
+✅ **Or use useLiveQuery for conditional queries:**
+```ts
+const { data, isEnabled } = useLiveQuery(
+  (q) => userId ? q.from({ users }) : undefined,  // ✅ Supported!
+  [userId]
+)
+```
diff --git a/docs/framework/react/reference/functions/usePacedMutations.md b/docs/framework/react/reference/functions/usePacedMutations.md
new file mode 100644
index 000000000..4f50b0411
--- /dev/null
+++ b/docs/framework/react/reference/functions/usePacedMutations.md
@@ -0,0 +1,131 @@
+---
+id: usePacedMutations
+title: usePacedMutations
+---
+
+# Function: usePacedMutations()
+
+```ts
+function usePacedMutations<TVariables, T>(config): (variables) => Transaction<T>;
+```
+
+Defined in: [usePacedMutations.ts:93](https://github.com/TanStack/db/blob/main/packages/react-db/src/usePacedMutations.ts#L93)
+
+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.
+
+## Type Parameters
+
+### TVariables
+
+`TVariables` = `unknown`
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+## Parameters
+
+### config
+
+`PacedMutationsConfig`\<`TVariables`, `T`\>
+
+Configuration including onMutate, mutationFn and strategy
+
+## Returns
+
+A mutate function that accepts variables and returns Transaction objects
+
+```ts
+(variables): Transaction<T>;
+```
+
+### Parameters
+
+#### variables
+
+`TVariables`
+
+### Returns
+
+`Transaction`\<`T`\>
+
+## Examples
+
+```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)} />
+}
+```
+
+```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)} />
+}
+```
+
+```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)}
+    />
+  )
+}
+```
diff --git a/docs/framework/react/reference/functions/uselivequery.md b/docs/framework/react/reference/functions/uselivequery.md
deleted file mode 100644
index 9a2f6448d..000000000
--- a/docs/framework/react/reference/functions/uselivequery.md
+++ /dev/null
@@ -1,384 +0,0 @@
----
-id: useLiveQuery
-title: useLiveQuery
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: useLiveQuery()
-
-## Call Signature
-
-```ts
-function useLiveQuery<TContext>(queryFn, deps?): object
-```
-
-Defined in: [useLiveQuery.ts:64](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L64)
-
-Create a live query using a query function
-
-### Type Parameters
-
-• **TContext** *extends* `Context`
-
-### Parameters
-
-#### queryFn
-
-(`q`) => `QueryBuilder`\<`TContext`\>
-
-Query function that defines what data to fetch
-
-#### deps?
-
-`unknown`[]
-
-Array of dependencies that trigger query re-execution when changed
-
-### Returns
-
-`object`
-
-Object with reactive data, state, and status information
-
-#### collection
-
-```ts
-collection: Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {}>;
-```
-
-#### data
-
-```ts
-data: { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }[];
-```
-
-#### isCleanedUp
-
-```ts
-isCleanedUp: boolean;
-```
-
-#### isError
-
-```ts
-isError: boolean;
-```
-
-#### isIdle
-
-```ts
-isIdle: boolean;
-```
-
-#### isLoading
-
-```ts
-isLoading: boolean;
-```
-
-#### isReady
-
-```ts
-isReady: boolean;
-```
-
-#### state
-
-```ts
-state: Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
-```
-
-#### status
-
-```ts
-status: CollectionStatus;
-```
-
-### Examples
-
-```ts
-// Basic query with object syntax
-const { data, isLoading } = useLiveQuery((q) =>
-  q.from({ todos: todosCollection })
-   .where(({ todos }) => eq(todos.completed, false))
-   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
-)
-```
-
-```ts
-// With dependencies that trigger re-execution
-const { data, state } = useLiveQuery(
-  (q) => q.from({ todos: todosCollection })
-         .where(({ todos }) => gt(todos.priority, minPriority)),
-  [minPriority] // Re-run when minPriority changes
-)
-```
-
-```ts
-// Join pattern
-const { data } = useLiveQuery((q) =>
-  q.from({ issues: issueCollection })
-   .join({ persons: personCollection }, ({ issues, persons }) =>
-     eq(issues.userId, persons.id)
-   )
-   .select(({ issues, persons }) => ({
-     id: issues.id,
-     title: issues.title,
-     userName: persons.name
-   }))
-)
-```
-
-```ts
-// Handle loading and error states
-const { data, isLoading, isError, status } = useLiveQuery((q) =>
-  q.from({ todos: todoCollection })
-)
-
-if (isLoading) return <div>Loading...</div>
-if (isError) return <div>Error: {status}</div>
-
-return (
-  <ul>
-    {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
-  </ul>
-)
-```
-
-## Call Signature
-
-```ts
-function useLiveQuery<TContext>(config, deps?): object
-```
-
-Defined in: [useLiveQuery.ts:113](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L113)
-
-Create a live query using configuration object
-
-### Type Parameters
-
-• **TContext** *extends* `Context`
-
-### Parameters
-
-#### config
-
-`LiveQueryCollectionConfig`\<`TContext`\>
-
-Configuration object with query and options
-
-#### deps?
-
-`unknown`[]
-
-Array of dependencies that trigger query re-execution when changed
-
-### Returns
-
-`object`
-
-Object with reactive data, state, and status information
-
-#### collection
-
-```ts
-collection: Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {}>;
-```
-
-#### data
-
-```ts
-data: { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }[];
-```
-
-#### isCleanedUp
-
-```ts
-isCleanedUp: boolean;
-```
-
-#### isError
-
-```ts
-isError: boolean;
-```
-
-#### isIdle
-
-```ts
-isIdle: boolean;
-```
-
-#### isLoading
-
-```ts
-isLoading: boolean;
-```
-
-#### isReady
-
-```ts
-isReady: boolean;
-```
-
-#### state
-
-```ts
-state: Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
-```
-
-#### status
-
-```ts
-status: CollectionStatus;
-```
-
-### Examples
-
-```ts
-// Basic config object usage
-const { data, status } = useLiveQuery({
-  query: (q) => q.from({ todos: todosCollection }),
-  gcTime: 60000
-})
-```
-
-```ts
-// With query builder and options
-const queryBuilder = new Query()
-  .from({ persons: collection })
-  .where(({ persons }) => gt(persons.age, 30))
-  .select(({ persons }) => ({ id: persons.id, name: persons.name }))
-
-const { data, isReady } = useLiveQuery({ query: queryBuilder })
-```
-
-```ts
-// Handle all states uniformly
-const { data, isLoading, isReady, isError } = useLiveQuery({
-  query: (q) => q.from({ items: itemCollection })
-})
-
-if (isLoading) return <div>Loading...</div>
-if (isError) return <div>Something went wrong</div>
-if (!isReady) return <div>Preparing...</div>
-
-return <div>{data.length} items loaded</div>
-```
-
-## Call Signature
-
-```ts
-function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): object
-```
-
-Defined in: [useLiveQuery.ts:158](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L158)
-
-Subscribe to an existing live query collection
-
-### Type Parameters
-
-• **TResult** *extends* `object`
-
-• **TKey** *extends* `string` \| `number`
-
-• **TUtils** *extends* `Record`\<`string`, `any`\>
-
-### Parameters
-
-#### liveQueryCollection
-
-`Collection`\<`TResult`, `TKey`, `TUtils`\>
-
-Pre-created live query collection to subscribe to
-
-### Returns
-
-`object`
-
-Object with reactive data, state, and status information
-
-#### collection
-
-```ts
-collection: Collection<TResult, TKey, TUtils>;
-```
-
-#### data
-
-```ts
-data: TResult[];
-```
-
-#### isCleanedUp
-
-```ts
-isCleanedUp: boolean;
-```
-
-#### isError
-
-```ts
-isError: boolean;
-```
-
-#### isIdle
-
-```ts
-isIdle: boolean;
-```
-
-#### isLoading
-
-```ts
-isLoading: boolean;
-```
-
-#### isReady
-
-```ts
-isReady: boolean;
-```
-
-#### state
-
-```ts
-state: Map<TKey, TResult>;
-```
-
-#### status
-
-```ts
-status: CollectionStatus;
-```
-
-### Examples
-
-```ts
-// Using pre-created live query collection
-const myLiveQuery = createLiveQueryCollection((q) =>
-  q.from({ todos: todosCollection }).where(({ todos }) => eq(todos.active, true))
-)
-const { data, collection } = useLiveQuery(myLiveQuery)
-```
-
-```ts
-// Access collection methods directly
-const { data, collection, isReady } = useLiveQuery(existingCollection)
-
-// Use collection for mutations
-const handleToggle = (id) => {
-  collection.update(id, draft => { draft.completed = !draft.completed })
-}
-```
-
-```ts
-// Handle states consistently
-const { data, isLoading, isError } = useLiveQuery(sharedCollection)
-
-if (isLoading) return <div>Loading...</div>
-if (isError) return <div>Error loading data</div>
-
-return <div>{data.map(item => <Item key={item.id} {...item} />)}</div>
-```
diff --git a/docs/framework/react/reference/index.md b/docs/framework/react/reference/index.md
index e28f47122..a35d6af9f 100644
--- a/docs/framework/react/reference/index.md
+++ b/docs/framework/react/reference/index.md
@@ -3,10 +3,17 @@ id: "@tanstack/react-db"
 title: "@tanstack/react-db"
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # @tanstack/react-db
 
+## Type Aliases
+
+- [UseLiveInfiniteQueryConfig](type-aliases/UseLiveInfiniteQueryConfig.md)
+- [UseLiveInfiniteQueryReturn](type-aliases/UseLiveInfiniteQueryReturn.md)
+- [UseLiveQueryStatus](type-aliases/UseLiveQueryStatus.md)
+
 ## Functions
 
-- [useLiveQuery](../functions/uselivequery.md)
+- [useLiveInfiniteQuery](functions/useLiveInfiniteQuery.md)
+- [useLiveQuery](functions/useLiveQuery.md)
+- [useLiveSuspenseQuery](functions/useLiveSuspenseQuery.md)
+- [usePacedMutations](functions/usePacedMutations.md)
diff --git a/docs/framework/react/reference/type-aliases/UseLiveInfiniteQueryConfig.md b/docs/framework/react/reference/type-aliases/UseLiveInfiniteQueryConfig.md
new file mode 100644
index 000000000..c0a4ad638
--- /dev/null
+++ b/docs/framework/react/reference/type-aliases/UseLiveInfiniteQueryConfig.md
@@ -0,0 +1,70 @@
+---
+id: UseLiveInfiniteQueryConfig
+title: UseLiveInfiniteQueryConfig
+---
+
+# Type Alias: UseLiveInfiniteQueryConfig\<TContext\>
+
+```ts
+type UseLiveInfiniteQueryConfig<TContext> = object;
+```
+
+Defined in: [useLiveInfiniteQuery.ts:23](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveInfiniteQuery.ts#L23)
+
+## Type Parameters
+
+### TContext
+
+`TContext` *extends* `Context`
+
+## Properties
+
+### getNextPageParam()
+
+```ts
+getNextPageParam: (lastPage, allPages, lastPageParam, allPageParams) => number | undefined;
+```
+
+Defined in: [useLiveInfiniteQuery.ts:26](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveInfiniteQuery.ts#L26)
+
+#### Parameters
+
+##### lastPage
+
+`InferResultType`\<`TContext`\>\[`number`\][]
+
+##### allPages
+
+`InferResultType`\<`TContext`\>\[`number`\][][]
+
+##### lastPageParam
+
+`number`
+
+##### allPageParams
+
+`number`[]
+
+#### Returns
+
+`number` \| `undefined`
+
+***
+
+### initialPageParam?
+
+```ts
+optional initialPageParam: number;
+```
+
+Defined in: [useLiveInfiniteQuery.ts:25](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveInfiniteQuery.ts#L25)
+
+***
+
+### pageSize?
+
+```ts
+optional pageSize: number;
+```
+
+Defined in: [useLiveInfiniteQuery.ts:24](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveInfiniteQuery.ts#L24)
diff --git a/docs/framework/react/reference/type-aliases/UseLiveInfiniteQueryReturn.md b/docs/framework/react/reference/type-aliases/UseLiveInfiniteQueryReturn.md
new file mode 100644
index 000000000..b7d68849d
--- /dev/null
+++ b/docs/framework/react/reference/type-aliases/UseLiveInfiniteQueryReturn.md
@@ -0,0 +1,60 @@
+---
+id: UseLiveInfiniteQueryReturn
+title: UseLiveInfiniteQueryReturn
+---
+
+# Type Alias: UseLiveInfiniteQueryReturn\<TContext\>
+
+```ts
+type UseLiveInfiniteQueryReturn<TContext> = Omit<ReturnType<typeof useLiveQuery>, "data"> & object;
+```
+
+Defined in: [useLiveInfiniteQuery.ts:34](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveInfiniteQuery.ts#L34)
+
+## Type Declaration
+
+### data
+
+```ts
+data: InferResultType<TContext>;
+```
+
+### fetchNextPage()
+
+```ts
+fetchNextPage: () => void;
+```
+
+#### Returns
+
+`void`
+
+### hasNextPage
+
+```ts
+hasNextPage: boolean;
+```
+
+### isFetchingNextPage
+
+```ts
+isFetchingNextPage: boolean;
+```
+
+### pageParams
+
+```ts
+pageParams: number[];
+```
+
+### pages
+
+```ts
+pages: InferResultType<TContext>[number][][];
+```
+
+## Type Parameters
+
+### TContext
+
+`TContext` *extends* `Context`
diff --git a/docs/framework/react/reference/type-aliases/UseLiveQueryStatus.md b/docs/framework/react/reference/type-aliases/UseLiveQueryStatus.md
new file mode 100644
index 000000000..93bbcd634
--- /dev/null
+++ b/docs/framework/react/reference/type-aliases/UseLiveQueryStatus.md
@@ -0,0 +1,12 @@
+---
+id: UseLiveQueryStatus
+title: UseLiveQueryStatus
+---
+
+# Type Alias: UseLiveQueryStatus
+
+```ts
+type UseLiveQueryStatus = CollectionStatus | "disabled";
+```
+
+Defined in: [useLiveQuery.ts:23](https://github.com/TanStack/db/blob/main/packages/react-db/src/useLiveQuery.ts#L23)
diff --git a/docs/framework/solid/adapter.md b/docs/framework/solid/adapter.md
deleted file mode 100644
index c5cde978a..000000000
--- a/docs/framework/solid/adapter.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-title: TanStack DB Solid Adapter
-ref: docs/framework/react/adapter.md
-replace: { "React": "Solid", "react": "solid" }
----
diff --git a/docs/framework/solid/overview.md b/docs/framework/solid/overview.md
new file mode 100644
index 000000000..d69a75b75
--- /dev/null
+++ b/docs/framework/solid/overview.md
@@ -0,0 +1,189 @@
+---
+title: TanStack DB Solid Adapter
+id: adapter
+---
+
+## Installation
+
+```sh
+npm install @tanstack/solid-db
+```
+
+## Solid Primitives
+
+See the [Solid Functions Reference](./reference/index.md) to see the full list of primitives available in the Solid Adapter.
+
+For comprehensive documentation on writing queries (filtering, joins, aggregations, etc.), see the [Live Queries Guide](../../guides/live-queries).
+
+## Basic Usage
+
+### useLiveQuery
+
+The `useLiveQuery` primitive creates a live query that automatically updates your component when data changes. It returns an object where `data` is a plain array and status fields (e.g. `isLoading()`, `status()`) are accessors:
+
+```tsx
+import { useLiveQuery } from '@tanstack/solid-db'
+import { eq } from '@tanstack/db'
+import { Show, For } from 'solid-js'
+
+function TodoList() {
+  const query = useLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.completed, false))
+     .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+  )
+
+  return (
+    <Show when={!query.isLoading()} fallback={<div>Loading...</div>}>
+      <ul>
+        <For each={query.data}>
+          {(todo) => <li>{todo.text}</li>}
+        </For>
+      </ul>
+    </Show>
+  )
+}
+```
+
+**Note:** `query.data` returns an array directly (not a function), but status fields like `isLoading()`, `status()`, etc. are accessor functions.
+
+### Reactive Queries with Signals
+
+Solid uses fine-grained reactivity, which means queries automatically track and respond to signal changes. Simply call signals inside your query function, and Solid will automatically recompute when they change:
+
+```tsx
+import { createSignal } from 'solid-js'
+import { useLiveQuery } from '@tanstack/solid-db'
+import { gt } from '@tanstack/db'
+
+function FilteredTodos(props: { minPriority: number }) {
+  const query = useLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => gt(todos.priority, props.minPriority))
+  )
+
+  return <div>{query.data.length} high-priority todos</div>
+}
+```
+
+When `props.minPriority` changes, Solid's reactivity system automatically:
+1. Detects the prop access inside the query function
+2. Cleans up the previous live query collection
+3. Creates a new query with the updated value
+4. Updates the component with the new data
+
+#### Using Signals from Component State
+
+```tsx
+import { createSignal } from 'solid-js'
+import { useLiveQuery } from '@tanstack/solid-db'
+import { eq, and } from '@tanstack/db'
+
+function TodoList() {
+  const [userId, setUserId] = createSignal(1)
+  const [status, setStatus] = createSignal('active')
+
+  // Solid automatically tracks userId() and status() calls
+  const query = useLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => and(
+       eq(todos.userId, userId()),
+       eq(todos.status, status())
+     ))
+  )
+
+  return (
+    <div>
+      <select onChange={(e) => setStatus(e.currentTarget.value)}>
+        <option value="active">Active</option>
+        <option value="completed">Completed</option>
+      </select>
+      <div>{query.data.length} todos</div>
+    </div>
+  )
+}
+```
+
+**Key Point:** Unlike React, you don't need dependency arrays. Solid's reactive system automatically tracks any signals, props, or stores accessed during query execution.
+
+#### Best Practices
+
+**Access signals inside the query function:**
+
+```tsx
+import { createSignal } from 'solid-js'
+import { useLiveQuery } from '@tanstack/solid-db'
+import { gt } from '@tanstack/db'
+
+function TodoList() {
+  const [minPriority, setMinPriority] = createSignal(5)
+
+  // Good - signal accessed inside query function
+  const query = useLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => gt(todos.priority, minPriority()))
+  )
+
+  // Solid automatically tracks minPriority() and recomputes when it changes
+  return <div>{query.data.length} todos</div>
+}
+```
+
+**Don't read signals outside the query function:**
+
+```tsx
+import { createSignal } from 'solid-js'
+import { useLiveQuery } from '@tanstack/solid-db'
+import { gt } from '@tanstack/db'
+
+function TodoList() {
+  const [minPriority, setMinPriority] = createSignal(5)
+
+  // Bad - reading signal outside query function
+  const currentPriority = minPriority()
+  const query = useLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => gt(todos.priority, currentPriority))
+  )
+  // Won't update when minPriority changes!
+
+  return <div>{query.data.length} todos</div>
+}
+```
+
+**Static queries need no special handling:**
+
+```tsx
+import { useLiveQuery } from '@tanstack/solid-db'
+
+function AllTodos() {
+  // No signals accessed - query never changes
+  const query = useLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+  )
+
+  return <div>{query.data.length} todos</div>
+}
+```
+
+### Using Pre-created Collections
+
+You can also pass an existing collection to `useLiveQuery`. This is useful for sharing queries across components:
+
+```tsx
+import { createLiveQueryCollection } from '@tanstack/db'
+import { useLiveQuery } from '@tanstack/solid-db'
+
+// Create collection outside component
+const todosQuery = createLiveQueryCollection((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.active, true))
+)
+
+function TodoList() {
+  // Pass existing collection
+  const query = useLiveQuery(() => todosQuery)
+
+  return <div>{query.data.length} todos</div>
+}
+```
diff --git a/docs/framework/solid/reference/functions/useLiveQuery.md b/docs/framework/solid/reference/functions/useLiveQuery.md
new file mode 100644
index 000000000..74044531d
--- /dev/null
+++ b/docs/framework/solid/reference/functions/useLiveQuery.md
@@ -0,0 +1,347 @@
+---
+id: useLiveQuery
+title: useLiveQuery
+---
+
+# Function: useLiveQuery()
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(queryFn): Accessor<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }[]> & object;
+```
+
+Defined in: [useLiveQuery.ts:98](https://github.com/TanStack/db/blob/main/packages/solid-db/src/useLiveQuery.ts#L98)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\>
+
+Query function that defines what data to fetch
+
+### Returns
+
+Accessor that returns data with Suspense support, with state and status information as properties
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// With dependencies that trigger re-execution
+const todosQuery = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority())),
+)
+```
+
+```ts
+// Join pattern
+const personIssues = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+return (
+  <Switch>
+    <Match when={todosQuery.isLoading}>
+      <div>Loading...</div>
+    </Match>
+    <Match when={todosQuery.isError}>
+      <div>Error: {todosQuery.status}</div>
+    </Match>
+    <Match when={todosQuery.isReady}>
+      <For each={todosQuery()}>
+        {(todo) => <li key={todo.id}>{todo.text}</li>}
+      </For>
+    </Match>
+  </Switch>
+)
+```
+
+```ts
+// Use Suspense boundaries
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+return (
+  <Suspense fallback={<div>Loading...</div>}>
+    <For each={todosQuery()}>
+      {(todo) => <li key={todo.id}>{todo.text}</li>}
+    </For>
+  </Suspense>
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(queryFn): Accessor<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }[]> & object;
+```
+
+Defined in: [useLiveQuery.ts:117](https://github.com/TanStack/db/blob/main/packages/solid-db/src/useLiveQuery.ts#L117)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\> \| `null` \| `undefined`
+
+Query function that defines what data to fetch
+
+### Returns
+
+Accessor that returns data with Suspense support, with state and status information as properties
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// With dependencies that trigger re-execution
+const todosQuery = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority())),
+)
+```
+
+```ts
+// Join pattern
+const personIssues = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+return (
+  <Switch>
+    <Match when={todosQuery.isLoading}>
+      <div>Loading...</div>
+    </Match>
+    <Match when={todosQuery.isError}>
+      <div>Error: {todosQuery.status}</div>
+    </Match>
+    <Match when={todosQuery.isReady}>
+      <For each={todosQuery()}>
+        {(todo) => <li key={todo.id}>{todo.text}</li>}
+      </For>
+    </Match>
+  </Switch>
+)
+```
+
+```ts
+// Use Suspense boundaries
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+return (
+  <Suspense fallback={<div>Loading...</div>}>
+    <For each={todosQuery()}>
+      {(todo) => <li key={todo.id}>{todo.text}</li>}
+    </For>
+  </Suspense>
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(config): Accessor<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }[]> & object;
+```
+
+Defined in: [useLiveQuery.ts:178](https://github.com/TanStack/db/blob/main/packages/solid-db/src/useLiveQuery.ts#L178)
+
+Create a live query using configuration object
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### config
+
+`Accessor`\<`LiveQueryCollectionConfig`\<`TContext`, \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \} & `object`\>\>
+
+Configuration object with query and options
+
+### Returns
+
+Accessor that returns data with Suspense support, with state and status information as properties
+
+### Examples
+
+```ts
+// Basic config object usage
+const todosQuery = useLiveQuery(() => ({
+  query: (q) => q.from({ todos: todosCollection }),
+  gcTime: 60000
+}))
+```
+
+```ts
+// With query builder and options
+const queryBuilder = new Query()
+  .from({ persons: collection })
+  .where(({ persons }) => gt(persons.age, 30))
+  .select(({ persons }) => ({ id: persons.id, name: persons.name }))
+
+const personsQuery = useLiveQuery(() => ({ query: queryBuilder }))
+```
+
+```ts
+// Handle all states uniformly
+const itemsQuery = useLiveQuery(() => ({
+  query: (q) => q.from({ items: itemCollection })
+}))
+
+return (
+  <Switch fallback={<div>{itemsQuery().length} items loaded</div>}>
+    <Match when={itemsQuery.isLoading}>
+      <div>Loading...</div>
+    </Match>
+    <Match when={itemsQuery.isError}>
+      <div>Something went wrong</div>
+    </Match>
+    <Match when={!itemsQuery.isReady}>
+      <div>Preparing...</div>
+    </Match>
+  </Switch>
+)
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): Accessor<TResult[]> & object;
+```
+
+Defined in: [useLiveQuery.ts:232](https://github.com/TanStack/db/blob/main/packages/solid-db/src/useLiveQuery.ts#L232)
+
+Subscribe to an existing live query collection
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`Accessor`\<`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\>\>
+
+Pre-created live query collection to subscribe to
+
+### Returns
+
+Accessor that returns data with Suspense support, with state and status information as properties
+
+### Examples
+
+```ts
+// Using pre-created live query collection
+const myLiveQuery = createLiveQueryCollection((q) =>
+  q.from({ todos: todosCollection }).where(({ todos }) => eq(todos.active, true))
+)
+const todosQuery = useLiveQuery(() => myLiveQuery)
+```
+
+```ts
+// Access collection methods directly
+const existingQuery = useLiveQuery(() => existingCollection)
+
+// Use collection for mutations
+const handleToggle = (id) => {
+  existingQuery.collection.update(id, draft => { draft.completed = !draft.completed })
+}
+```
+
+```ts
+// Handle states consistently
+const sharedQuery = useLiveQuery(() => sharedCollection)
+
+return (
+ <Switch fallback={<div><For each={sharedQuery()}>{(item) => <Item key={item.id} {...item} />}</For></div>}>
+   <Match when={sharedQuery.isLoading}>
+     <div>Loading...</div>
+   </Match>
+   <Match when={sharedQuery.isError}>
+     <div>Error loading data</div>
+   </Match>
+ </Switch>
+)
+```
diff --git a/docs/framework/solid/reference/functions/uselivequery.md b/docs/framework/solid/reference/functions/uselivequery.md
deleted file mode 100644
index 40ff5f631..000000000
--- a/docs/framework/solid/reference/functions/uselivequery.md
+++ /dev/null
@@ -1,392 +0,0 @@
----
-id: useLiveQuery
-title: useLiveQuery
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: useLiveQuery()
-
-## Call Signature
-
-```ts
-function useLiveQuery<TContext>(queryFn): object
-```
-
-Defined in: [useLiveQuery.ts:80](https://github.com/TanStack/db/blob/main/packages/solid-db/src/useLiveQuery.ts#L80)
-
-Create a live query using a query function
-
-### Type Parameters
-
-• **TContext** *extends* `Context`
-
-### Parameters
-
-#### queryFn
-
-(`q`) => `QueryBuilder`\<`TContext`\>
-
-Query function that defines what data to fetch
-
-### Returns
-
-`object`
-
-Object with reactive data, state, and status information
-
-#### collection
-
-```ts
-collection: Accessor<Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {}, StandardSchemaV1<unknown, unknown>, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>>;
-```
-
-#### data
-
-```ts
-data: { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }[];
-```
-
-#### isCleanedUp
-
-```ts
-isCleanedUp: Accessor<boolean>;
-```
-
-#### isError
-
-```ts
-isError: Accessor<boolean>;
-```
-
-#### isIdle
-
-```ts
-isIdle: Accessor<boolean>;
-```
-
-#### isLoading
-
-```ts
-isLoading: Accessor<boolean>;
-```
-
-#### isReady
-
-```ts
-isReady: Accessor<boolean>;
-```
-
-#### state
-
-```ts
-state: ReactiveMap<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
-```
-
-#### status
-
-```ts
-status: Accessor<CollectionStatus>;
-```
-
-### Examples
-
-```ts
-// Basic query with object syntax
-const todosQuery = useLiveQuery((q) =>
-  q.from({ todos: todosCollection })
-   .where(({ todos }) => eq(todos.completed, false))
-   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
-)
-```
-
-```ts
-// With dependencies that trigger re-execution
-const todosQuery = useLiveQuery(
-  (q) => q.from({ todos: todosCollection })
-         .where(({ todos }) => gt(todos.priority, minPriority())),
-)
-```
-
-```ts
-// Join pattern
-const personIssues = useLiveQuery((q) =>
-  q.from({ issues: issueCollection })
-   .join({ persons: personCollection }, ({ issues, persons }) =>
-     eq(issues.userId, persons.id)
-   )
-   .select(({ issues, persons }) => ({
-     id: issues.id,
-     title: issues.title,
-     userName: persons.name
-   }))
-)
-```
-
-```ts
-// Handle loading and error states
-const todosQuery = useLiveQuery((q) =>
-  q.from({ todos: todoCollection })
-)
-
-return (
-  <Switch>
-    <Match when={todosQuery.isLoading()}>
-      <div>Loading...</div>
-    </Match>
-    <Match when={todosQuery.isError()}>
-      <div>Error: {todosQuery.status()}</div>
-    </Match>
-    <Match when={todosQuery.isReady()}>
-      <For each={todosQuery.data()}>
-        {(todo) => <li key={todo.id}>{todo.text}</li>}
-      </For>
-    </Match>
-  </Switch>
-)
-```
-
-## Call Signature
-
-```ts
-function useLiveQuery<TContext>(config): object
-```
-
-Defined in: [useLiveQuery.ts:135](https://github.com/TanStack/db/blob/main/packages/solid-db/src/useLiveQuery.ts#L135)
-
-Create a live query using configuration object
-
-### Type Parameters
-
-• **TContext** *extends* `Context`
-
-### Parameters
-
-#### config
-
-`Accessor`\<`LiveQueryCollectionConfig`\<`TContext`, \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \} & `object`\>\>
-
-Configuration object with query and options
-
-### Returns
-
-`object`
-
-Object with reactive data, state, and status information
-
-#### collection
-
-```ts
-collection: Accessor<Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {}, StandardSchemaV1<unknown, unknown>, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>>;
-```
-
-#### data
-
-```ts
-data: { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }[];
-```
-
-#### isCleanedUp
-
-```ts
-isCleanedUp: Accessor<boolean>;
-```
-
-#### isError
-
-```ts
-isError: Accessor<boolean>;
-```
-
-#### isIdle
-
-```ts
-isIdle: Accessor<boolean>;
-```
-
-#### isLoading
-
-```ts
-isLoading: Accessor<boolean>;
-```
-
-#### isReady
-
-```ts
-isReady: Accessor<boolean>;
-```
-
-#### state
-
-```ts
-state: ReactiveMap<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>;
-```
-
-#### status
-
-```ts
-status: Accessor<CollectionStatus>;
-```
-
-### Examples
-
-```ts
-// Basic config object usage
-const todosQuery = useLiveQuery(() => ({
-  query: (q) => q.from({ todos: todosCollection }),
-  gcTime: 60000
-}))
-```
-
-```ts
-// With query builder and options
-const queryBuilder = new Query()
-  .from({ persons: collection })
-  .where(({ persons }) => gt(persons.age, 30))
-  .select(({ persons }) => ({ id: persons.id, name: persons.name }))
-
-const personsQuery = useLiveQuery(() => ({ query: queryBuilder }))
-```
-
-```ts
-// Handle all states uniformly
-const itemsQuery = useLiveQuery(() => ({
-  query: (q) => q.from({ items: itemCollection })
-}))
-
-return (
-  <Switch fallback={<div>{itemsQuery.data.length} items loaded</div>}>
-    <Match when={itemsQuery.isLoading()}>
-      <div>Loading...</div>
-    </Match>
-    <Match when={itemsQuery.isError()}>
-      <div>Something went wrong</div>
-    </Match>
-    <Match when={!itemsQuery.isReady()}>
-      <div>Preparing...</div>
-    </Match>
-  </Switch>
-)
-```
-
-## Call Signature
-
-```ts
-function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): object
-```
-
-Defined in: [useLiveQuery.ts:185](https://github.com/TanStack/db/blob/main/packages/solid-db/src/useLiveQuery.ts#L185)
-
-Subscribe to an existing live query collection
-
-### Type Parameters
-
-• **TResult** *extends* `object`
-
-• **TKey** *extends* `string` \| `number`
-
-• **TUtils** *extends* `Record`\<`string`, `any`\>
-
-### Parameters
-
-#### liveQueryCollection
-
-`Accessor`\<`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\>\>
-
-Pre-created live query collection to subscribe to
-
-### Returns
-
-`object`
-
-Object with reactive data, state, and status information
-
-#### collection
-
-```ts
-collection: Accessor<Collection<TResult, TKey, TUtils, StandardSchemaV1<unknown, unknown>, TResult>>;
-```
-
-#### data
-
-```ts
-data: TResult[];
-```
-
-#### isCleanedUp
-
-```ts
-isCleanedUp: Accessor<boolean>;
-```
-
-#### isError
-
-```ts
-isError: Accessor<boolean>;
-```
-
-#### isIdle
-
-```ts
-isIdle: Accessor<boolean>;
-```
-
-#### isLoading
-
-```ts
-isLoading: Accessor<boolean>;
-```
-
-#### isReady
-
-```ts
-isReady: Accessor<boolean>;
-```
-
-#### state
-
-```ts
-state: ReactiveMap<TKey, TResult>;
-```
-
-#### status
-
-```ts
-status: Accessor<CollectionStatus>;
-```
-
-### Examples
-
-```ts
-// Using pre-created live query collection
-const myLiveQuery = createLiveQueryCollection((q) =>
-  q.from({ todos: todosCollection }).where(({ todos }) => eq(todos.active, true))
-)
-const todosQuery = useLiveQuery(() => myLiveQuery)
-```
-
-```ts
-// Access collection methods directly
-const existingQuery = useLiveQuery(() => existingCollection)
-
-// Use collection for mutations
-const handleToggle = (id) => {
-  existingQuery.collection().update(id, draft => { draft.completed = !draft.completed })
-}
-```
-
-```ts
-// Handle states consistently
-const sharedQuery = useLiveQuery(() => sharedCollection)
-
-return (
- <Switch fallback={<div><For each={sharedQuery.data()}>{(item) => <Item key={item.id} {...item} />}</For></div>}>
-   <Match when={sharedQuery.isLoading()}>
-     <div>Loading...</div>
-   </Match>
-   <Match when={sharedQuery.isError()}>
-     <div>Error loading data</div>
-   </Match>
- </Switch>
-)
-```
diff --git a/docs/framework/solid/reference/index.md b/docs/framework/solid/reference/index.md
index 4043a7294..da2d0de79 100644
--- a/docs/framework/solid/reference/index.md
+++ b/docs/framework/solid/reference/index.md
@@ -3,10 +3,8 @@ id: "@tanstack/solid-db"
 title: "@tanstack/solid-db"
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # @tanstack/solid-db
 
 ## Functions
 
-- [useLiveQuery](../functions/uselivequery.md)
+- [useLiveQuery](functions/useLiveQuery.md)
diff --git a/docs/framework/svelte/adapter.md b/docs/framework/svelte/adapter.md
deleted file mode 100644
index 079ec6d9b..000000000
--- a/docs/framework/svelte/adapter.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-title: TanStack DB Svelte Adapter
-ref: docs/framework/react/adapter.md
-replace: { "React": "Svelte", "react": "svelte" }
----
diff --git a/docs/framework/svelte/overview.md b/docs/framework/svelte/overview.md
new file mode 100644
index 000000000..f7497d0e7
--- /dev/null
+++ b/docs/framework/svelte/overview.md
@@ -0,0 +1,169 @@
+---
+title: TanStack DB Svelte Adapter
+id: adapter
+---
+
+## Installation
+
+```sh
+npm install @tanstack/svelte-db
+```
+
+## Svelte Utilities
+
+See the [Svelte Functions Reference](./reference/index.md) to see the full list of utilities available in the Svelte Adapter.
+
+For comprehensive documentation on writing queries (filtering, joins, aggregations, etc.), see the [Live Queries Guide](../../guides/live-queries).
+
+## Basic Usage
+
+### useLiveQuery
+
+The `useLiveQuery` utility creates a live query that automatically updates your component when data changes. It returns reactive values powered by Svelte 5 runes:
+
+```svelte
+<script>
+  import { useLiveQuery } from '@tanstack/svelte-db'
+  import { eq } from '@tanstack/db'
+
+  const query = useLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.completed, false))
+     .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+  )
+</script>
+
+{#if query.isLoading}
+  <div>Loading...</div>
+{:else}
+  <ul>
+    {#each query.data as todo (todo.id)}
+      <li>{todo.text}</li>
+    {/each}
+  </ul>
+{/if}
+```
+
+**Note:** With Svelte 5, `useLiveQuery` returns reactive values through getters. Access `query.data` and `query.isLoading` directly (no `$` prefix needed).
+
+### Dependency Arrays
+
+The `useLiveQuery` utility accepts an optional dependency array as its last parameter. When any value in the array changes, the query is recreated and re-executed.
+
+#### When to Use Dependency Arrays
+
+Use dependency arrays when your query depends on external reactive values (props or state):
+
+```svelte
+<script>
+  import { useLiveQuery } from '@tanstack/svelte-db'
+  import { gt } from '@tanstack/db'
+
+  let { minPriority } = $props()
+
+  const query = useLiveQuery(
+    (q) => q.from({ todos: todosCollection })
+           .where(({ todos }) => gt(todos.priority, minPriority)),
+    [() => minPriority] // Re-run when minPriority changes
+  )
+</script>
+
+<div>{query.data.length} high-priority todos</div>
+```
+
+**Note:** When using props or reactive state in the query, wrap them in a function for the dependency array.
+
+#### What Happens When Dependencies Change
+
+When a dependency value changes:
+1. The previous live query collection is cleaned up
+2. A new query is created with the updated values
+3. The component re-renders with the new data
+4. The utility shows loading state again
+
+#### Best Practices
+
+**Include all external values used in the query:**
+
+```svelte
+<script>
+  import { useLiveQuery } from '@tanstack/svelte-db'
+  import { eq, and } from '@tanstack/db'
+
+  let userId = $state(1)
+  let status = $state('active')
+
+  // Good - all external values in deps
+  const query = useLiveQuery(
+    (q) => q.from({ todos: todosCollection })
+           .where(({ todos }) => and(
+             eq(todos.userId, userId),
+             eq(todos.status, status)
+           )),
+    [() => userId, () => status]
+  )
+
+  // Bad - missing dependencies
+  const badQuery = useLiveQuery(
+    (q) => q.from({ todos: todosCollection })
+           .where(({ todos }) => eq(todos.userId, userId)),
+    [] // Missing userId!
+  )
+</script>
+
+<div>{query.data.length} todos</div>
+```
+
+**Empty array for static queries:**
+
+```svelte
+<script>
+  import { useLiveQuery } from '@tanstack/svelte-db'
+
+  // No external dependencies - query never changes
+  const query = useLiveQuery(
+    (q) => q.from({ todos: todosCollection }),
+    []
+  )
+</script>
+
+<div>{query.data.length} todos</div>
+```
+
+**Omit the array for queries with no external dependencies:**
+
+```svelte
+<script>
+  import { useLiveQuery } from '@tanstack/svelte-db'
+
+  // Same as above - no deps needed
+  const query = useLiveQuery(
+    (q) => q.from({ todos: todosCollection })
+  )
+</script>
+
+<div>{query.data.length} todos</div>
+```
+
+### Accessing Multiple Properties
+
+You can access all status properties directly on the query result:
+
+```svelte
+<script>
+  import { useLiveQuery } from '@tanstack/svelte-db'
+  import { eq } from '@tanstack/db'
+
+  const query = useLiveQuery((q) =>
+    q.from({ todos: todosCollection })
+     .where(({ todos }) => eq(todos.active, true))
+  )
+</script>
+
+<div>
+  <div>Status: {query.status}</div>
+  <div>Loading: {query.isLoading}</div>
+  <div>Ready: {query.isReady}</div>
+  <div>Total: {query.data.length}</div>
+</div>
+```
diff --git a/docs/framework/svelte/reference/functions/useLiveQuery.md b/docs/framework/svelte/reference/functions/useLiveQuery.md
new file mode 100644
index 000000000..74b6534f4
--- /dev/null
+++ b/docs/framework/svelte/reference/functions/useLiveQuery.md
@@ -0,0 +1,540 @@
+---
+id: useLiveQuery
+title: useLiveQuery
+---
+
+# Function: useLiveQuery()
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(queryFn, deps?): UseLiveQueryReturn<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, InferResultType<TContext>>;
+```
+
+Defined in: [useLiveQuery.svelte.ts:160](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L160)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\>
+
+Query function that defines what data to fetch
+
+#### deps?
+
+() => `unknown`[]
+
+Array of reactive dependencies that trigger query re-execution when changed
+
+### Returns
+
+[`UseLiveQueryReturn`](../interfaces/UseLiveQueryReturn.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}, `InferResultType`\<`TContext`\>\>
+
+Reactive object with query data, state, and status information
+
+### Remarks
+
+**IMPORTANT - Destructuring in Svelte 5:**
+Direct destructuring breaks reactivity. To destructure, wrap with `$derived`:
+
+❌ **Incorrect** - Loses reactivity:
+```ts
+const { data, isLoading } = useLiveQuery(...)
+```
+
+✅ **Correct** - Maintains reactivity:
+```ts
+// Option 1: Use dot notation (recommended)
+const query = useLiveQuery(...)
+// Access: query.data, query.isLoading
+
+// Option 2: Wrap with $derived for destructuring
+const query = useLiveQuery(...)
+const { data, isLoading } = $derived(query)
+```
+
+This is a fundamental Svelte 5 limitation, not a library bug. See:
+https://github.com/sveltejs/svelte/issues/11002
+
+### Examples
+
+```ts
+// Basic query with object syntax (recommended pattern)
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+// Access via: todosQuery.data, todosQuery.isLoading, etc.
+```
+
+```ts
+// With reactive dependencies
+let minPriority = $state(5)
+const todosQuery = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [() => minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Destructuring with $derived (if needed)
+const query = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+)
+const { data, isLoading, isError } = $derived(query)
+// Now data, isLoading, and isError maintain reactivity
+```
+
+```ts
+// Join pattern
+const issuesQuery = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states in template
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+// In template:
+// {#if todosQuery.isLoading}
+//   <div>Loading...</div>
+// {:else if todosQuery.isError}
+//   <div>Error: {todosQuery.status}</div>
+// {:else}
+//   <ul>
+//     {#each todosQuery.data as todo (todo.id)}
+//       <li>{todo.text}</li>
+//     {/each}
+//   </ul>
+// {/if}
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(queryFn, deps?): UseLiveQueryReturn<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, InferResultType<TContext> | undefined>;
+```
+
+Defined in: [useLiveQuery.svelte.ts:166](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L166)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\> \| `null` \| `undefined`
+
+Query function that defines what data to fetch
+
+#### deps?
+
+() => `unknown`[]
+
+Array of reactive dependencies that trigger query re-execution when changed
+
+### Returns
+
+[`UseLiveQueryReturn`](../interfaces/UseLiveQueryReturn.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}, `InferResultType`\<`TContext`\> \| `undefined`\>
+
+Reactive object with query data, state, and status information
+
+### Remarks
+
+**IMPORTANT - Destructuring in Svelte 5:**
+Direct destructuring breaks reactivity. To destructure, wrap with `$derived`:
+
+❌ **Incorrect** - Loses reactivity:
+```ts
+const { data, isLoading } = useLiveQuery(...)
+```
+
+✅ **Correct** - Maintains reactivity:
+```ts
+// Option 1: Use dot notation (recommended)
+const query = useLiveQuery(...)
+// Access: query.data, query.isLoading
+
+// Option 2: Wrap with $derived for destructuring
+const query = useLiveQuery(...)
+const { data, isLoading } = $derived(query)
+```
+
+This is a fundamental Svelte 5 limitation, not a library bug. See:
+https://github.com/sveltejs/svelte/issues/11002
+
+### Examples
+
+```ts
+// Basic query with object syntax (recommended pattern)
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+// Access via: todosQuery.data, todosQuery.isLoading, etc.
+```
+
+```ts
+// With reactive dependencies
+let minPriority = $state(5)
+const todosQuery = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [() => minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Destructuring with $derived (if needed)
+const query = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+)
+const { data, isLoading, isError } = $derived(query)
+// Now data, isLoading, and isError maintain reactivity
+```
+
+```ts
+// Join pattern
+const issuesQuery = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states in template
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+// In template:
+// {#if todosQuery.isLoading}
+//   <div>Loading...</div>
+// {:else if todosQuery.isError}
+//   <div>Error: {todosQuery.status}</div>
+// {:else}
+//   <ul>
+//     {#each todosQuery.data as todo (todo.id)}
+//       <li>{todo.text}</li>
+//     {/each}
+//   </ul>
+// {/if}
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(config, deps?): UseLiveQueryReturn<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, InferResultType<TContext>>;
+```
+
+Defined in: [useLiveQuery.svelte.ts:214](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L214)
+
+Create a live query using configuration object
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### config
+
+`LiveQueryCollectionConfig`\<`TContext`\>
+
+Configuration object with query and options
+
+#### deps?
+
+() => `unknown`[]
+
+Array of reactive dependencies that trigger query re-execution when changed
+
+### Returns
+
+[`UseLiveQueryReturn`](../interfaces/UseLiveQueryReturn.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}, `InferResultType`\<`TContext`\>\>
+
+Reactive object with query data, state, and status information
+
+### Examples
+
+```ts
+// Basic config object usage
+const todosQuery = useLiveQuery({
+  query: (q) => q.from({ todos: todosCollection }),
+  gcTime: 60000
+})
+```
+
+```ts
+// With reactive dependencies
+let filter = $state('active')
+const todosQuery = useLiveQuery({
+  query: (q) => q.from({ todos: todosCollection })
+                 .where(({ todos }) => eq(todos.status, filter))
+}, [() => filter])
+```
+
+```ts
+// Handle all states uniformly
+const itemsQuery = useLiveQuery({
+  query: (q) => q.from({ items: itemCollection })
+})
+
+// In template:
+// {#if itemsQuery.isLoading}
+//   <div>Loading...</div>
+// {:else if itemsQuery.isError}
+//   <div>Something went wrong</div>
+// {:else if !itemsQuery.isReady}
+//   <div>Preparing...</div>
+// {:else}
+//   <div>{itemsQuery.data.length} items loaded</div>
+// {/if}
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): UseLiveQueryReturnWithCollection<TResult, TKey, TUtils, TResult[]>;
+```
+
+Defined in: [useLiveQuery.svelte.ts:263](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L263)
+
+Subscribe to an existing query collection (can be reactive)
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`MaybeGetter`\<`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\> & `NonSingleResult`\>
+
+Pre-created query collection to subscribe to (can be a getter)
+
+### Returns
+
+[`UseLiveQueryReturnWithCollection`](../interfaces/UseLiveQueryReturnWithCollection.md)\<`TResult`, `TKey`, `TUtils`, `TResult`[]\>
+
+Reactive object with query data, state, and status information
+
+### Examples
+
+```ts
+// Using pre-created query collection
+const myLiveQuery = createLiveQueryCollection((q) =>
+  q.from({ todos: todosCollection }).where(({ todos }) => eq(todos.active, true))
+)
+const queryResult = useLiveQuery(myLiveQuery)
+```
+
+```ts
+// Reactive query collection reference
+let selectedQuery = $state(todosQuery)
+const queryResult = useLiveQuery(() => selectedQuery)
+
+// Switch queries reactively
+selectedQuery = archiveQuery
+```
+
+```ts
+// Access query collection methods directly
+const queryResult = useLiveQuery(existingQuery)
+
+// Use underlying collection for mutations
+const handleToggle = (id) => {
+  queryResult.collection.update(id, draft => { draft.completed = !draft.completed })
+}
+```
+
+```ts
+// Handle states consistently
+const queryResult = useLiveQuery(sharedQuery)
+
+// In template:
+// {#if queryResult.isLoading}
+//   <div>Loading...</div>
+// {:else if queryResult.isError}
+//   <div>Error loading data</div>
+// {:else}
+//   {#each queryResult.data as item (item.id)}
+//     <Item {...item} />
+//   {/each}
+// {/if}
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): UseLiveQueryReturnWithCollection<TResult, TKey, TUtils, TResult | undefined>;
+```
+
+Defined in: [useLiveQuery.svelte.ts:274](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L274)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`MaybeGetter`\<`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\> & `SingleResult`\>
+
+### Returns
+
+[`UseLiveQueryReturnWithCollection`](../interfaces/UseLiveQueryReturnWithCollection.md)\<`TResult`, `TKey`, `TUtils`, `TResult` \| `undefined`\>
+
+Reactive object with query data, state, and status information
+
+### Remarks
+
+**IMPORTANT - Destructuring in Svelte 5:**
+Direct destructuring breaks reactivity. To destructure, wrap with `$derived`:
+
+❌ **Incorrect** - Loses reactivity:
+```ts
+const { data, isLoading } = useLiveQuery(...)
+```
+
+✅ **Correct** - Maintains reactivity:
+```ts
+// Option 1: Use dot notation (recommended)
+const query = useLiveQuery(...)
+// Access: query.data, query.isLoading
+
+// Option 2: Wrap with $derived for destructuring
+const query = useLiveQuery(...)
+const { data, isLoading } = $derived(query)
+```
+
+This is a fundamental Svelte 5 limitation, not a library bug. See:
+https://github.com/sveltejs/svelte/issues/11002
+
+### Examples
+
+```ts
+// Basic query with object syntax (recommended pattern)
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+// Access via: todosQuery.data, todosQuery.isLoading, etc.
+```
+
+```ts
+// With reactive dependencies
+let minPriority = $state(5)
+const todosQuery = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority)),
+  [() => minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Destructuring with $derived (if needed)
+const query = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+)
+const { data, isLoading, isError } = $derived(query)
+// Now data, isLoading, and isError maintain reactivity
+```
+
+```ts
+// Join pattern
+const issuesQuery = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states in template
+const todosQuery = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+// In template:
+// {#if todosQuery.isLoading}
+//   <div>Loading...</div>
+// {:else if todosQuery.isError}
+//   <div>Error: {todosQuery.status}</div>
+// {:else}
+//   <ul>
+//     {#each todosQuery.data as todo (todo.id)}
+//       <li>{todo.text}</li>
+//     {/each}
+//   </ul>
+// {/if}
+```
diff --git a/docs/framework/svelte/reference/index.md b/docs/framework/svelte/reference/index.md
new file mode 100644
index 000000000..152862d59
--- /dev/null
+++ b/docs/framework/svelte/reference/index.md
@@ -0,0 +1,15 @@
+---
+id: "@tanstack/svelte-db"
+title: "@tanstack/svelte-db"
+---
+
+# @tanstack/svelte-db
+
+## Interfaces
+
+- [UseLiveQueryReturn](interfaces/UseLiveQueryReturn.md)
+- [UseLiveQueryReturnWithCollection](interfaces/UseLiveQueryReturnWithCollection.md)
+
+## Functions
+
+- [useLiveQuery](functions/useLiveQuery.md)
diff --git a/docs/framework/svelte/reference/interfaces/UseLiveQueryReturn.md b/docs/framework/svelte/reference/interfaces/UseLiveQueryReturn.md
new file mode 100644
index 000000000..714736f4b
--- /dev/null
+++ b/docs/framework/svelte/reference/interfaces/UseLiveQueryReturn.md
@@ -0,0 +1,129 @@
+---
+id: UseLiveQueryReturn
+title: UseLiveQueryReturn
+---
+
+# Interface: UseLiveQueryReturn\<T, TData\>
+
+Defined in: [useLiveQuery.svelte.ts:33](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L33)
+
+Return type for useLiveQuery hook
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object`
+
+### TData
+
+`TData` = `T`[]
+
+## Properties
+
+### collection
+
+```ts
+collection: Collection<T, string | number, {
+}>;
+```
+
+Defined in: [useLiveQuery.svelte.ts:36](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L36)
+
+The underlying query collection instance
+
+***
+
+### data
+
+```ts
+data: TData;
+```
+
+Defined in: [useLiveQuery.svelte.ts:35](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L35)
+
+Reactive array of query results in order, or single item when using findOne()
+
+***
+
+### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:42](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L42)
+
+True when query has been cleaned up
+
+***
+
+### isError
+
+```ts
+isError: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:41](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L41)
+
+True when query encountered an error
+
+***
+
+### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:40](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L40)
+
+True when query hasn't started yet
+
+***
+
+### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:38](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L38)
+
+True while initial query data is loading
+
+***
+
+### isReady
+
+```ts
+isReady: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:39](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L39)
+
+True when query has received first data and is ready
+
+***
+
+### state
+
+```ts
+state: Map<string | number, T>;
+```
+
+Defined in: [useLiveQuery.svelte.ts:34](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L34)
+
+Reactive Map of query results (key → item)
+
+***
+
+### status
+
+```ts
+status: CollectionStatus;
+```
+
+Defined in: [useLiveQuery.svelte.ts:37](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L37)
+
+Current query status
diff --git a/docs/framework/svelte/reference/interfaces/UseLiveQueryReturnWithCollection.md b/docs/framework/svelte/reference/interfaces/UseLiveQueryReturnWithCollection.md
new file mode 100644
index 000000000..0d62c7ae8
--- /dev/null
+++ b/docs/framework/svelte/reference/interfaces/UseLiveQueryReturnWithCollection.md
@@ -0,0 +1,116 @@
+---
+id: UseLiveQueryReturnWithCollection
+title: UseLiveQueryReturnWithCollection
+---
+
+# Interface: UseLiveQueryReturnWithCollection\<T, TKey, TUtils, TData\>
+
+Defined in: [useLiveQuery.svelte.ts:45](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L45)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object`
+
+### TKey
+
+`TKey` *extends* `string` \| `number`
+
+### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### TData
+
+`TData` = `T`[]
+
+## Properties
+
+### collection
+
+```ts
+collection: Collection<T, TKey, TUtils>;
+```
+
+Defined in: [useLiveQuery.svelte.ts:53](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L53)
+
+***
+
+### data
+
+```ts
+data: TData;
+```
+
+Defined in: [useLiveQuery.svelte.ts:52](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L52)
+
+***
+
+### isCleanedUp
+
+```ts
+isCleanedUp: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:59](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L59)
+
+***
+
+### isError
+
+```ts
+isError: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:58](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L58)
+
+***
+
+### isIdle
+
+```ts
+isIdle: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:57](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L57)
+
+***
+
+### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:55](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L55)
+
+***
+
+### isReady
+
+```ts
+isReady: boolean;
+```
+
+Defined in: [useLiveQuery.svelte.ts:56](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L56)
+
+***
+
+### state
+
+```ts
+state: Map<TKey, T>;
+```
+
+Defined in: [useLiveQuery.svelte.ts:51](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L51)
+
+***
+
+### status
+
+```ts
+status: CollectionStatus;
+```
+
+Defined in: [useLiveQuery.svelte.ts:54](https://github.com/TanStack/db/blob/main/packages/svelte-db/src/useLiveQuery.svelte.ts#L54)
diff --git a/docs/framework/vue/adapter.md b/docs/framework/vue/adapter.md
deleted file mode 100644
index 533fc7a2e..000000000
--- a/docs/framework/vue/adapter.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-title: TanStack DB Vue Adapter
-ref: docs/framework/react/adapter.md
-replace: { "React": "Vue", "react": "vue" }
----
diff --git a/docs/framework/vue/overview.md b/docs/framework/vue/overview.md
new file mode 100644
index 000000000..eb78d370f
--- /dev/null
+++ b/docs/framework/vue/overview.md
@@ -0,0 +1,215 @@
+---
+title: TanStack DB Vue Adapter
+id: adapter
+---
+
+## Installation
+
+```sh
+npm install @tanstack/vue-db
+```
+
+## Vue Composables
+
+See the [Vue Functions Reference](./reference/index.md) to see the full list of composables available in the Vue Adapter.
+
+For comprehensive documentation on writing queries (filtering, joins, aggregations, etc.), see the [Live Queries Guide](../../guides/live-queries).
+
+## Basic Usage
+
+### useLiveQuery
+
+The `useLiveQuery` composable creates a live query that automatically updates your component when data changes. It returns reactive computed refs:
+
+```vue
+<script setup>
+import { useLiveQuery } from '@tanstack/vue-db'
+import { eq } from '@tanstack/db'
+
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+</script>
+
+<template>
+  <div v-if="isLoading">Loading...</div>
+  <ul v-else>
+    <li v-for="todo in data" :key="todo.id">{{ todo.text }}</li>
+  </ul>
+</template>
+```
+
+**Note:** All return values (`data`, `isLoading`, `status`, etc.) are computed refs, so access them with `.value` in `<script>` but directly in `<template>`.
+
+### Dependency Arrays
+
+The `useLiveQuery` composable accepts an optional dependency array as its last parameter. When any reactive value in the array changes, the query is recreated and re-executed.
+
+#### When to Use Dependency Arrays
+
+Use dependency arrays when your query depends on external reactive values (refs, props, or reactive objects):
+
+```vue
+<script setup>
+import { ref } from 'vue'
+import { useLiveQuery } from '@tanstack/vue-db'
+import { gt } from '@tanstack/db'
+
+const minPriority = ref(5)
+
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority.value)),
+  [minPriority] // Pass the ref directly, it will be unwrapped automatically
+)
+</script>
+
+<template>
+  <div>{{ data.length }} high-priority todos</div>
+</template>
+```
+
+**Important:** Pass refs directly in the dependency array, not as functions. Vue will automatically track them.
+
+#### What Happens When Dependencies Change
+
+When a dependency value changes:
+1. The previous live query collection is cleaned up
+2. A new query is created with the updated values
+3. The component re-renders with the new data
+4. The composable shows loading state again
+
+#### Best Practices
+
+**Include all external refs used in the query:**
+
+```vue
+<script setup>
+import { ref } from 'vue'
+import { useLiveQuery } from '@tanstack/vue-db'
+import { eq, and } from '@tanstack/db'
+
+const userId = ref(1)
+const status = ref('active')
+
+// Good - all refs in deps array
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => and(
+           eq(todos.userId, userId.value),
+           eq(todos.status, status.value)
+         )),
+  [userId, status] // Pass refs directly
+)
+
+// Bad - missing dependencies
+const { data: badData } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.userId, userId.value)),
+  [] // Missing userId!
+)
+</script>
+
+<template>
+  <div>{{ data.length }} todos</div>
+</template>
+```
+
+**Using with props:**
+
+```vue
+<script setup>
+import { toRef } from 'vue'
+import { useLiveQuery } from '@tanstack/vue-db'
+import { eq } from '@tanstack/db'
+
+const props = defineProps<{ userId: number }>()
+
+// Option 1: Convert prop to ref
+const userIdRef = toRef(props, 'userId')
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.userId, userIdRef.value)),
+  [userIdRef]
+)
+
+// Option 2: Use a getter function for the prop
+const { data: data2 } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => eq(todos.userId, props.userId)),
+  [() => props.userId] // Getter function for non-ref values
+)
+</script>
+
+<template>
+  <div>{{ data.length }} todos</div>
+</template>
+```
+
+**Empty array for static queries:**
+
+```vue
+<script setup>
+import { useLiveQuery } from '@tanstack/vue-db'
+
+// No external dependencies - query never changes
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection }),
+  []
+)
+</script>
+
+<template>
+  <div>{{ data.length }} todos</div>
+</template>
+```
+
+**Omit the array for queries with no external dependencies:**
+
+```vue
+<script setup>
+import { useLiveQuery } from '@tanstack/vue-db'
+
+// Same as above - no deps needed
+const { data } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+)
+</script>
+
+<template>
+  <div>{{ data.length }} todos</div>
+</template>
+```
+
+### Using Pre-created Collections
+
+You can also pass an existing collection to `useLiveQuery`. This is useful for sharing queries across components:
+
+```vue
+<script setup>
+import { ref } from 'vue'
+import { createLiveQueryCollection } from '@tanstack/db'
+import { useLiveQuery } from '@tanstack/vue-db'
+import { eq } from '@tanstack/db'
+
+// Create collection outside component or in a composable
+const todosQuery = createLiveQueryCollection({
+  query: (q) => q.from({ todos: todosCollection })
+               .where(({ todos }) => eq(todos.active, true)),
+  startSync: true
+})
+
+// Use the pre-created collection
+const { data, collection } = useLiveQuery(todosQuery)
+
+// Or use a reactive ref to switch between collections
+const currentQuery = ref(todosQuery)
+const { data: reactiveData } = useLiveQuery(currentQuery)
+</script>
+
+<template>
+  <div>{{ data.length }} todos</div>
+</template>
+```
diff --git a/docs/framework/vue/reference/functions/useLiveQuery.md b/docs/framework/vue/reference/functions/useLiveQuery.md
new file mode 100644
index 000000000..71c717e54
--- /dev/null
+++ b/docs/framework/vue/reference/functions/useLiveQuery.md
@@ -0,0 +1,411 @@
+---
+id: useLiveQuery
+title: useLiveQuery
+---
+
+# Function: useLiveQuery()
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(queryFn, deps?): UseLiveQueryReturn<TContext>;
+```
+
+Defined in: [useLiveQuery.ts:134](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L134)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\>
+
+Query function that defines what data to fetch
+
+#### deps?
+
+`unknown`[]
+
+Array of reactive dependencies that trigger query re-execution when changed
+
+### Returns
+
+[`UseLiveQueryReturn`](../interfaces/UseLiveQueryReturn.md)\<`TContext`\>
+
+Reactive object with query data, state, and status information
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// With reactive dependencies
+const minPriority = ref(5)
+const { data, state } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority.value)),
+  [minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Join pattern
+const { data } = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states in template
+const { data, isLoading, isError, status } = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+// In template:
+// <div v-if="isLoading">Loading...</div>
+// <div v-else-if="isError">Error: {{ status }}</div>
+// <ul v-else>
+//   <li v-for="todo in data" :key="todo.id">{{ todo.text }}</li>
+// </ul>
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(queryFn, deps?): UseLiveQueryReturn<TContext>;
+```
+
+Defined in: [useLiveQuery.ts:140](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L140)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### queryFn
+
+(`q`) => `QueryBuilder`\<`TContext`\> \| `null` \| `undefined`
+
+Query function that defines what data to fetch
+
+#### deps?
+
+`unknown`[]
+
+Array of reactive dependencies that trigger query re-execution when changed
+
+### Returns
+
+[`UseLiveQueryReturn`](../interfaces/UseLiveQueryReturn.md)\<`TContext`\>
+
+Reactive object with query data, state, and status information
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// With reactive dependencies
+const minPriority = ref(5)
+const { data, state } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority.value)),
+  [minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Join pattern
+const { data } = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states in template
+const { data, isLoading, isError, status } = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+// In template:
+// <div v-if="isLoading">Loading...</div>
+// <div v-else-if="isError">Error: {{ status }}</div>
+// <ul v-else>
+//   <li v-for="todo in data" :key="todo.id">{{ todo.text }}</li>
+// </ul>
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TContext>(config, deps?): UseLiveQueryReturn<TContext>;
+```
+
+Defined in: [useLiveQuery.ts:180](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L180)
+
+Create a live query using configuration object
+
+### Type Parameters
+
+#### TContext
+
+`TContext` *extends* `Context`
+
+### Parameters
+
+#### config
+
+`LiveQueryCollectionConfig`\<`TContext`\>
+
+Configuration object with query and options
+
+#### deps?
+
+`unknown`[]
+
+Array of reactive dependencies that trigger query re-execution when changed
+
+### Returns
+
+[`UseLiveQueryReturn`](../interfaces/UseLiveQueryReturn.md)\<`TContext`\>
+
+Reactive object with query data, state, and status information
+
+### Examples
+
+```ts
+// Basic config object usage
+const { data, status } = useLiveQuery({
+  query: (q) => q.from({ todos: todosCollection }),
+  gcTime: 60000
+})
+```
+
+```ts
+// With reactive dependencies
+const filter = ref('active')
+const { data, isReady } = useLiveQuery({
+  query: (q) => q.from({ todos: todosCollection })
+                 .where(({ todos }) => eq(todos.status, filter.value))
+}, [filter])
+```
+
+```ts
+// Handle all states uniformly
+const { data, isLoading, isReady, isError } = useLiveQuery({
+  query: (q) => q.from({ items: itemCollection })
+})
+
+// In template:
+// <div v-if="isLoading">Loading...</div>
+// <div v-else-if="isError">Something went wrong</div>
+// <div v-else-if="!isReady">Preparing...</div>
+// <div v-else>{{ data.length }} items loaded</div>
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): UseLiveQueryReturnWithCollection<TResult, TKey, TUtils>;
+```
+
+Defined in: [useLiveQuery.ts:225](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L225)
+
+Subscribe to an existing query collection (can be reactive)
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`MaybeRefOrGetter`\<`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\> & `NonSingleResult`\>
+
+Pre-created query collection to subscribe to (can be a ref)
+
+### Returns
+
+[`UseLiveQueryReturnWithCollection`](../interfaces/UseLiveQueryReturnWithCollection.md)\<`TResult`, `TKey`, `TUtils`\>
+
+Reactive object with query data, state, and status information
+
+### Examples
+
+```ts
+// Using pre-created query collection
+const myLiveQuery = createLiveQueryCollection((q) =>
+  q.from({ todos: todosCollection }).where(({ todos }) => eq(todos.active, true))
+)
+const { data, collection } = useLiveQuery(myLiveQuery)
+```
+
+```ts
+// Reactive query collection reference
+const selectedQuery = ref(todosQuery)
+const { data, collection } = useLiveQuery(selectedQuery)
+
+// Switch queries reactively
+selectedQuery.value = archiveQuery
+```
+
+```ts
+// Access query collection methods directly
+const { data, collection, isReady } = useLiveQuery(existingQuery)
+
+// Use underlying collection for mutations
+const handleToggle = (id) => {
+  collection.value.update(id, draft => { draft.completed = !draft.completed })
+}
+```
+
+```ts
+// Handle states consistently
+const { data, isLoading, isError } = useLiveQuery(sharedQuery)
+
+// In template:
+// <div v-if="isLoading">Loading...</div>
+// <div v-else-if="isError">Error loading data</div>
+// <div v-else>
+//   <Item v-for="item in data" :key="item.id" v-bind="item" />
+// </div>
+```
+
+## Call Signature
+
+```ts
+function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): UseLiveQueryReturnWithSingleResultCollection<TResult, TKey, TUtils>;
+```
+
+Defined in: [useLiveQuery.ts:236](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L236)
+
+Create a live query using a query function
+
+### Type Parameters
+
+#### TResult
+
+`TResult` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+#### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+### Parameters
+
+#### liveQueryCollection
+
+`MaybeRefOrGetter`\<`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\> & `SingleResult`\>
+
+### Returns
+
+[`UseLiveQueryReturnWithSingleResultCollection`](../interfaces/UseLiveQueryReturnWithSingleResultCollection.md)\<`TResult`, `TKey`, `TUtils`\>
+
+Reactive object with query data, state, and status information
+
+### Examples
+
+```ts
+// Basic query with object syntax
+const { data, isLoading } = useLiveQuery((q) =>
+  q.from({ todos: todosCollection })
+   .where(({ todos }) => eq(todos.completed, false))
+   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+)
+```
+
+```ts
+// With reactive dependencies
+const minPriority = ref(5)
+const { data, state } = useLiveQuery(
+  (q) => q.from({ todos: todosCollection })
+         .where(({ todos }) => gt(todos.priority, minPriority.value)),
+  [minPriority] // Re-run when minPriority changes
+)
+```
+
+```ts
+// Join pattern
+const { data } = useLiveQuery((q) =>
+  q.from({ issues: issueCollection })
+   .join({ persons: personCollection }, ({ issues, persons }) =>
+     eq(issues.userId, persons.id)
+   )
+   .select(({ issues, persons }) => ({
+     id: issues.id,
+     title: issues.title,
+     userName: persons.name
+   }))
+)
+```
+
+```ts
+// Handle loading and error states in template
+const { data, isLoading, isError, status } = useLiveQuery((q) =>
+  q.from({ todos: todoCollection })
+)
+
+// In template:
+// <div v-if="isLoading">Loading...</div>
+// <div v-else-if="isError">Error: {{ status }}</div>
+// <ul v-else>
+//   <li v-for="todo in data" :key="todo.id">{{ todo.text }}</li>
+// </ul>
+```
diff --git a/docs/framework/vue/reference/functions/uselivequery.md b/docs/framework/vue/reference/functions/uselivequery.md
deleted file mode 100644
index 3dc3a2a2c..000000000
--- a/docs/framework/vue/reference/functions/uselivequery.md
+++ /dev/null
@@ -1,231 +0,0 @@
----
-id: useLiveQuery
-title: useLiveQuery
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: useLiveQuery()
-
-## Call Signature
-
-```ts
-function useLiveQuery<TContext>(queryFn, deps?): UseLiveQueryReturn<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>
-```
-
-Defined in: [useLiveQuery.ts:113](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L113)
-
-Create a live query using a query function
-
-### Type Parameters
-
-• **TContext** *extends* `Context`
-
-### Parameters
-
-#### queryFn
-
-(`q`) => `QueryBuilder`\<`TContext`\>
-
-Query function that defines what data to fetch
-
-#### deps?
-
-`unknown`[]
-
-Array of reactive dependencies that trigger query re-execution when changed
-
-### Returns
-
-[`UseLiveQueryReturn`](../../interfaces/uselivequeryreturn.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}\>
-
-Reactive object with query data, state, and status information
-
-### Examples
-
-```ts
-// Basic query with object syntax
-const { data, isLoading } = useLiveQuery((q) =>
-  q.from({ todos: todosCollection })
-   .where(({ todos }) => eq(todos.completed, false))
-   .select(({ todos }) => ({ id: todos.id, text: todos.text }))
-)
-```
-
-```ts
-// With reactive dependencies
-const minPriority = ref(5)
-const { data, state } = useLiveQuery(
-  (q) => q.from({ todos: todosCollection })
-         .where(({ todos }) => gt(todos.priority, minPriority.value)),
-  [minPriority] // Re-run when minPriority changes
-)
-```
-
-```ts
-// Join pattern
-const { data } = useLiveQuery((q) =>
-  q.from({ issues: issueCollection })
-   .join({ persons: personCollection }, ({ issues, persons }) =>
-     eq(issues.userId, persons.id)
-   )
-   .select(({ issues, persons }) => ({
-     id: issues.id,
-     title: issues.title,
-     userName: persons.name
-   }))
-)
-```
-
-```ts
-// Handle loading and error states in template
-const { data, isLoading, isError, status } = useLiveQuery((q) =>
-  q.from({ todos: todoCollection })
-)
-
-// In template:
-// <div v-if="isLoading">Loading...</div>
-// <div v-else-if="isError">Error: {{ status }}</div>
-// <ul v-else>
-//   <li v-for="todo in data" :key="todo.id">{{ todo.text }}</li>
-// </ul>
-```
-
-## Call Signature
-
-```ts
-function useLiveQuery<TContext>(config, deps?): UseLiveQueryReturn<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>
-```
-
-Defined in: [useLiveQuery.ts:151](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L151)
-
-Create a live query using configuration object
-
-### Type Parameters
-
-• **TContext** *extends* `Context`
-
-### Parameters
-
-#### config
-
-`LiveQueryCollectionConfig`\<`TContext`\>
-
-Configuration object with query and options
-
-#### deps?
-
-`unknown`[]
-
-Array of reactive dependencies that trigger query re-execution when changed
-
-### Returns
-
-[`UseLiveQueryReturn`](../../interfaces/uselivequeryreturn.md)\<\{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}\>
-
-Reactive object with query data, state, and status information
-
-### Examples
-
-```ts
-// Basic config object usage
-const { data, status } = useLiveQuery({
-  query: (q) => q.from({ todos: todosCollection }),
-  gcTime: 60000
-})
-```
-
-```ts
-// With reactive dependencies
-const filter = ref('active')
-const { data, isReady } = useLiveQuery({
-  query: (q) => q.from({ todos: todosCollection })
-                 .where(({ todos }) => eq(todos.status, filter.value))
-}, [filter])
-```
-
-```ts
-// Handle all states uniformly
-const { data, isLoading, isReady, isError } = useLiveQuery({
-  query: (q) => q.from({ items: itemCollection })
-})
-
-// In template:
-// <div v-if="isLoading">Loading...</div>
-// <div v-else-if="isError">Something went wrong</div>
-// <div v-else-if="!isReady">Preparing...</div>
-// <div v-else>{{ data.length }} items loaded</div>
-```
-
-## Call Signature
-
-```ts
-function useLiveQuery<TResult, TKey, TUtils>(liveQueryCollection): UseLiveQueryReturnWithCollection<TResult, TKey, TUtils>
-```
-
-Defined in: [useLiveQuery.ts:196](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L196)
-
-Subscribe to an existing query collection (can be reactive)
-
-### Type Parameters
-
-• **TResult** *extends* `object`
-
-• **TKey** *extends* `string` \| `number`
-
-• **TUtils** *extends* `Record`\<`string`, `any`\>
-
-### Parameters
-
-#### liveQueryCollection
-
-`MaybeRefOrGetter`\<`Collection`\<`TResult`, `TKey`, `TUtils`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TResult`\>\>
-
-Pre-created query collection to subscribe to (can be a ref)
-
-### Returns
-
-[`UseLiveQueryReturnWithCollection`](../../interfaces/uselivequeryreturnwithcollection.md)\<`TResult`, `TKey`, `TUtils`\>
-
-Reactive object with query data, state, and status information
-
-### Examples
-
-```ts
-// Using pre-created query collection
-const myLiveQuery = createLiveQueryCollection((q) =>
-  q.from({ todos: todosCollection }).where(({ todos }) => eq(todos.active, true))
-)
-const { data, collection } = useLiveQuery(myLiveQuery)
-```
-
-```ts
-// Reactive query collection reference
-const selectedQuery = ref(todosQuery)
-const { data, collection } = useLiveQuery(selectedQuery)
-
-// Switch queries reactively
-selectedQuery.value = archiveQuery
-```
-
-```ts
-// Access query collection methods directly
-const { data, collection, isReady } = useLiveQuery(existingQuery)
-
-// Use underlying collection for mutations
-const handleToggle = (id) => {
-  collection.value.update(id, draft => { draft.completed = !draft.completed })
-}
-```
-
-```ts
-// Handle states consistently
-const { data, isLoading, isError } = useLiveQuery(sharedQuery)
-
-// In template:
-// <div v-if="isLoading">Loading...</div>
-// <div v-else-if="isError">Error loading data</div>
-// <div v-else>
-//   <Item v-for="item in data" :key="item.id" v-bind="item" />
-// </div>
-```
diff --git a/docs/framework/vue/reference/index.md b/docs/framework/vue/reference/index.md
index c3861ad0e..fb22a159e 100644
--- a/docs/framework/vue/reference/index.md
+++ b/docs/framework/vue/reference/index.md
@@ -3,15 +3,14 @@ id: "@tanstack/vue-db"
 title: "@tanstack/vue-db"
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # @tanstack/vue-db
 
 ## Interfaces
 
-- [UseLiveQueryReturn](../interfaces/uselivequeryreturn.md)
-- [UseLiveQueryReturnWithCollection](../interfaces/uselivequeryreturnwithcollection.md)
+- [UseLiveQueryReturn](interfaces/UseLiveQueryReturn.md)
+- [UseLiveQueryReturnWithCollection](interfaces/UseLiveQueryReturnWithCollection.md)
+- [UseLiveQueryReturnWithSingleResultCollection](interfaces/UseLiveQueryReturnWithSingleResultCollection.md)
 
 ## Functions
 
-- [useLiveQuery](../functions/uselivequery.md)
+- [useLiveQuery](functions/useLiveQuery.md)
diff --git a/docs/framework/vue/reference/interfaces/UseLiveQueryReturn.md b/docs/framework/vue/reference/interfaces/UseLiveQueryReturn.md
new file mode 100644
index 000000000..90a8e7299
--- /dev/null
+++ b/docs/framework/vue/reference/interfaces/UseLiveQueryReturn.md
@@ -0,0 +1,125 @@
+---
+id: UseLiveQueryReturn
+title: UseLiveQueryReturn
+---
+
+# Interface: UseLiveQueryReturn\<TContext\>
+
+Defined in: [useLiveQuery.ts:40](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L40)
+
+Return type for useLiveQuery hook
+
+## Type Parameters
+
+### TContext
+
+`TContext` *extends* `Context`
+
+## Properties
+
+### collection
+
+```ts
+collection: ComputedRef<Collection<{ [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }, string | number, {
+}, StandardSchemaV1<unknown, unknown>, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>>;
+```
+
+Defined in: [useLiveQuery.ts:43](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L43)
+
+The underlying query collection instance
+
+***
+
+### data
+
+```ts
+data: ComputedRef<InferResultType<TContext>>;
+```
+
+Defined in: [useLiveQuery.ts:42](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L42)
+
+Reactive array of query results in order, or single result for findOne queries
+
+***
+
+### isCleanedUp
+
+```ts
+isCleanedUp: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:49](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L49)
+
+True when query has been cleaned up
+
+***
+
+### isError
+
+```ts
+isError: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:48](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L48)
+
+True when query encountered an error
+
+***
+
+### isIdle
+
+```ts
+isIdle: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:47](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L47)
+
+True when query hasn't started yet
+
+***
+
+### isLoading
+
+```ts
+isLoading: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:45](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L45)
+
+True while initial query data is loading
+
+***
+
+### isReady
+
+```ts
+isReady: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:46](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L46)
+
+True when query has received first data and is ready
+
+***
+
+### state
+
+```ts
+state: ComputedRef<Map<string | number, { [K in string | number | symbol]: (TContext["result"] extends object ? any[any] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]])[K] }>>;
+```
+
+Defined in: [useLiveQuery.ts:41](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L41)
+
+Reactive Map of query results (key → item)
+
+***
+
+### status
+
+```ts
+status: ComputedRef<CollectionStatus>;
+```
+
+Defined in: [useLiveQuery.ts:44](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L44)
+
+Current query status
diff --git a/docs/framework/vue/reference/interfaces/uselivequeryreturnwithcollection.md b/docs/framework/vue/reference/interfaces/UseLiveQueryReturnWithCollection.md
similarity index 64%
rename from docs/framework/vue/reference/interfaces/uselivequeryreturnwithcollection.md
rename to docs/framework/vue/reference/interfaces/UseLiveQueryReturnWithCollection.md
index 89e292516..8f63d9314 100644
--- a/docs/framework/vue/reference/interfaces/uselivequeryreturnwithcollection.md
+++ b/docs/framework/vue/reference/interfaces/UseLiveQueryReturnWithCollection.md
@@ -3,19 +3,23 @@ id: UseLiveQueryReturnWithCollection
 title: UseLiveQueryReturnWithCollection
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Interface: UseLiveQueryReturnWithCollection\<T, TKey, TUtils\>
 
-Defined in: [useLiveQuery.ts:47](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L47)
+Defined in: [useLiveQuery.ts:52](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L52)
 
 ## Type Parameters
 
-• **T** *extends* `object`
+### T
+
+`T` *extends* `object`
+
+### TKey
 
-• **TKey** *extends* `string` \| `number`
+`TKey` *extends* `string` \| `number`
 
-• **TUtils** *extends* `Record`\<`string`, `any`\>
+### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
 
 ## Properties
 
@@ -25,7 +29,7 @@ Defined in: [useLiveQuery.ts:47](https://github.com/TanStack/db/blob/main/packag
 collection: ComputedRef<Collection<T, TKey, TUtils, StandardSchemaV1<unknown, unknown>, T>>;
 ```
 
-Defined in: [useLiveQuery.ts:54](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L54)
+Defined in: [useLiveQuery.ts:59](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L59)
 
 ***
 
@@ -35,7 +39,7 @@ Defined in: [useLiveQuery.ts:54](https://github.com/TanStack/db/blob/main/packag
 data: ComputedRef<T[]>;
 ```
 
-Defined in: [useLiveQuery.ts:53](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L53)
+Defined in: [useLiveQuery.ts:58](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L58)
 
 ***
 
@@ -45,7 +49,7 @@ Defined in: [useLiveQuery.ts:53](https://github.com/TanStack/db/blob/main/packag
 isCleanedUp: ComputedRef<boolean>;
 ```
 
-Defined in: [useLiveQuery.ts:60](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L60)
+Defined in: [useLiveQuery.ts:65](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L65)
 
 ***
 
@@ -55,7 +59,7 @@ Defined in: [useLiveQuery.ts:60](https://github.com/TanStack/db/blob/main/packag
 isError: ComputedRef<boolean>;
 ```
 
-Defined in: [useLiveQuery.ts:59](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L59)
+Defined in: [useLiveQuery.ts:64](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L64)
 
 ***
 
@@ -65,7 +69,7 @@ Defined in: [useLiveQuery.ts:59](https://github.com/TanStack/db/blob/main/packag
 isIdle: ComputedRef<boolean>;
 ```
 
-Defined in: [useLiveQuery.ts:58](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L58)
+Defined in: [useLiveQuery.ts:63](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L63)
 
 ***
 
@@ -75,7 +79,7 @@ Defined in: [useLiveQuery.ts:58](https://github.com/TanStack/db/blob/main/packag
 isLoading: ComputedRef<boolean>;
 ```
 
-Defined in: [useLiveQuery.ts:56](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L56)
+Defined in: [useLiveQuery.ts:61](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L61)
 
 ***
 
@@ -85,7 +89,7 @@ Defined in: [useLiveQuery.ts:56](https://github.com/TanStack/db/blob/main/packag
 isReady: ComputedRef<boolean>;
 ```
 
-Defined in: [useLiveQuery.ts:57](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L57)
+Defined in: [useLiveQuery.ts:62](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L62)
 
 ***
 
@@ -95,7 +99,7 @@ Defined in: [useLiveQuery.ts:57](https://github.com/TanStack/db/blob/main/packag
 state: ComputedRef<Map<TKey, T>>;
 ```
 
-Defined in: [useLiveQuery.ts:52](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L52)
+Defined in: [useLiveQuery.ts:57](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L57)
 
 ***
 
@@ -105,4 +109,4 @@ Defined in: [useLiveQuery.ts:52](https://github.com/TanStack/db/blob/main/packag
 status: ComputedRef<CollectionStatus>;
 ```
 
-Defined in: [useLiveQuery.ts:55](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L55)
+Defined in: [useLiveQuery.ts:60](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L60)
diff --git a/docs/framework/vue/reference/interfaces/UseLiveQueryReturnWithSingleResultCollection.md b/docs/framework/vue/reference/interfaces/UseLiveQueryReturnWithSingleResultCollection.md
new file mode 100644
index 000000000..5b9502a97
--- /dev/null
+++ b/docs/framework/vue/reference/interfaces/UseLiveQueryReturnWithSingleResultCollection.md
@@ -0,0 +1,112 @@
+---
+id: UseLiveQueryReturnWithSingleResultCollection
+title: UseLiveQueryReturnWithSingleResultCollection
+---
+
+# Interface: UseLiveQueryReturnWithSingleResultCollection\<T, TKey, TUtils\>
+
+Defined in: [useLiveQuery.ts:68](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L68)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object`
+
+### TKey
+
+`TKey` *extends* `string` \| `number`
+
+### TUtils
+
+`TUtils` *extends* `Record`\<`string`, `any`\>
+
+## Properties
+
+### collection
+
+```ts
+collection: ComputedRef<Collection<T, TKey, TUtils, StandardSchemaV1<unknown, unknown>, T> & SingleResult>;
+```
+
+Defined in: [useLiveQuery.ts:75](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L75)
+
+***
+
+### data
+
+```ts
+data: ComputedRef<T | undefined>;
+```
+
+Defined in: [useLiveQuery.ts:74](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L74)
+
+***
+
+### isCleanedUp
+
+```ts
+isCleanedUp: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:81](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L81)
+
+***
+
+### isError
+
+```ts
+isError: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:80](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L80)
+
+***
+
+### isIdle
+
+```ts
+isIdle: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:79](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L79)
+
+***
+
+### isLoading
+
+```ts
+isLoading: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:77](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L77)
+
+***
+
+### isReady
+
+```ts
+isReady: ComputedRef<boolean>;
+```
+
+Defined in: [useLiveQuery.ts:78](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L78)
+
+***
+
+### state
+
+```ts
+state: ComputedRef<Map<TKey, T>>;
+```
+
+Defined in: [useLiveQuery.ts:73](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L73)
+
+***
+
+### status
+
+```ts
+status: ComputedRef<CollectionStatus>;
+```
+
+Defined in: [useLiveQuery.ts:76](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L76)
diff --git a/docs/framework/vue/reference/interfaces/uselivequeryreturn.md b/docs/framework/vue/reference/interfaces/uselivequeryreturn.md
deleted file mode 100644
index a058b9f61..000000000
--- a/docs/framework/vue/reference/interfaces/uselivequeryreturn.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-id: UseLiveQueryReturn
-title: UseLiveQueryReturn
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: UseLiveQueryReturn\<T\>
-
-Defined in: [useLiveQuery.ts:35](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L35)
-
-Return type for useLiveQuery hook
-
-## Type Parameters
-
-• **T** *extends* `object`
-
-## Properties
-
-### collection
-
-```ts
-collection: ComputedRef<Collection<T, string | number, {}, StandardSchemaV1<unknown, unknown>, T>>;
-```
-
-Defined in: [useLiveQuery.ts:38](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L38)
-
-The underlying query collection instance
-
-***
-
-### data
-
-```ts
-data: ComputedRef<T[]>;
-```
-
-Defined in: [useLiveQuery.ts:37](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L37)
-
-Reactive array of query results in order
-
-***
-
-### isCleanedUp
-
-```ts
-isCleanedUp: ComputedRef<boolean>;
-```
-
-Defined in: [useLiveQuery.ts:44](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L44)
-
-True when query has been cleaned up
-
-***
-
-### isError
-
-```ts
-isError: ComputedRef<boolean>;
-```
-
-Defined in: [useLiveQuery.ts:43](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L43)
-
-True when query encountered an error
-
-***
-
-### isIdle
-
-```ts
-isIdle: ComputedRef<boolean>;
-```
-
-Defined in: [useLiveQuery.ts:42](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L42)
-
-True when query hasn't started yet
-
-***
-
-### isLoading
-
-```ts
-isLoading: ComputedRef<boolean>;
-```
-
-Defined in: [useLiveQuery.ts:40](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L40)
-
-True while initial query data is loading
-
-***
-
-### isReady
-
-```ts
-isReady: ComputedRef<boolean>;
-```
-
-Defined in: [useLiveQuery.ts:41](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L41)
-
-True when query has received first data and is ready
-
-***
-
-### state
-
-```ts
-state: ComputedRef<Map<string | number, T>>;
-```
-
-Defined in: [useLiveQuery.ts:36](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L36)
-
-Reactive Map of query results (key → item)
-
-***
-
-### status
-
-```ts
-status: ComputedRef<CollectionStatus>;
-```
-
-Defined in: [useLiveQuery.ts:39](https://github.com/TanStack/db/blob/main/packages/vue-db/src/useLiveQuery.ts#L39)
-
-Current query status
diff --git a/docs/guides/collection-options-creator.md b/docs/guides/collection-options-creator.md
index 058bb7b2c..d1f4d55c4 100644
--- a/docs/guides/collection-options-creator.md
+++ b/docs/guides/collection-options-creator.md
@@ -219,7 +219,124 @@ parse: {
 }
 ```
 
-### 5. Mutation Handler Patterns
+### 5. Schemas and Type Transformations
+
+When building a custom collection, you need to decide how to handle the relationship between your backend's storage format and the client-side types users work with in their collections.
+
+#### Two Separate Concerns
+
+**Backend Format** - The types your storage layer uses (SQLite, Postgres, Firebase, etc.)
+- Examples: Unix timestamps, ISO strings, JSON strings, PostGIS geometries
+
+**Client Format** - The types users work with in their TanStack DB collections
+- Examples: Date objects, parsed JSON, GeoJSON
+
+Schemas in TanStack DB define the **client format** (TInput/TOutput for mutations). How you bridge between backend and client format depends on your integration design.
+
+#### Approach 1: Integration Provides Parse/Serialize Helpers
+
+For backends with specific storage formats, provide `parse`/`serialize` options that users configure:
+
+```typescript
+// TrailBase example: User specifies field conversions
+export function trailbaseCollectionOptions(config) {
+  return {
+    parse: config.parse,      // User provides field conversions
+    serialize: config.serialize,
+
+    onInsert: async ({ transaction }) => {
+      const serialized = transaction.mutations.map(m =>
+        serializeFields(m.modified, config.serialize)
+      )
+      await config.recordApi.createBulk(serialized)
+    }
+  }
+}
+
+// User explicitly configures conversions
+const collection = createCollection(
+  trailbaseCollectionOptions({
+    schema: todoSchema,
+    parse: {
+      created_at: (ts: number) => new Date(ts * 1000)  // Unix → Date
+    },
+    serialize: {
+      created_at: (date: Date) => Math.floor(date.valueOf() / 1000)  // Date → Unix
+    }
+  })
+)
+```
+
+**Benefits:** Explicit control over type conversions. Integration handles applying them consistently.
+
+#### Approach 2: User Handles Everything in QueryFn/Handlers
+
+For simple APIs or when users want full control, they handle parsing/serialization themselves:
+
+```typescript
+// Query Collection: User handles all transformations
+const collection = createCollection(
+  queryCollectionOptions({
+    schema: todoSchema,
+    queryFn: async () => {
+      const response = await fetch('/api/todos')
+      const todos = await response.json()
+      // User manually parses to match their schema's TOutput
+      return todos.map(todo => ({
+        ...todo,
+        created_at: new Date(todo.created_at)  // ISO string → Date
+      }))
+    },
+    onInsert: async ({ transaction }) => {
+      // User manually serializes for their backend
+      await fetch('/api/todos', {
+        method: 'POST',
+        body: JSON.stringify({
+          ...transaction.mutations[0].modified,
+          created_at: transaction.mutations[0].modified.created_at.toISOString()  // Date → ISO string
+        })
+      })
+    }
+  })
+)
+```
+
+**Benefits:** Maximum flexibility, no abstraction overhead. Users see exactly what's happening.
+
+#### Approach 3: Automatic Serialization in Handlers
+
+If your backend has well-defined types, you can automatically serialize in mutation handlers:
+
+```typescript
+export function myCollectionOptions(config) {
+  return {
+    onInsert: async ({ transaction }) => {
+      // Automatically serialize known types for your backend
+      const serialized = transaction.mutations.map(m => ({
+        ...m.modified,
+        // Date objects → Unix timestamps for your backend
+        created_at: m.modified.created_at instanceof Date
+          ? Math.floor(m.modified.created_at.valueOf() / 1000)
+          : m.modified.created_at
+      }))
+      await backend.insert(serialized)
+    }
+  }
+}
+```
+
+**Benefits:** Least configuration for users. Integration handles backend format automatically.
+
+#### Key Design Principles
+
+1. **Schemas validate client mutations only** - They don't affect how backend data is parsed during sync
+2. **TOutput is the application-facing type** - This is what users work with in their app
+3. **Choose your approach based on backend constraints** - Fixed types → automatic serialization; varying types → user configuration
+4. **Document your backend format clearly** - Explain what types your storage uses and how to handle them
+
+For more on schemas from a user perspective, see the [Schemas guide](./schemas.md).
+
+### 6. Mutation Handler Patterns
 
 There are two distinct patterns for handling mutations in collection options creators:
 
diff --git a/docs/guides/error-handling.md b/docs/guides/error-handling.md
index 7661c240b..dfd4fa0b8 100644
--- a/docs/guides/error-handling.md
+++ b/docs/guides/error-handling.md
@@ -45,6 +45,32 @@ The error includes:
 - `issues`: Array of validation issues with messages and paths
 - `message`: A formatted error message listing all issues
 
+**When schema validation occurs:**
+
+Schema validation happens only for **client mutations** - when you explicitly insert or update data:
+
+1. **During inserts** - When `collection.insert()` is called
+2. **During updates** - When `collection.update()` is called
+
+Schemas do **not** validate data coming from your server or sync layer. That data is assumed to already be valid.
+
+```typescript
+const schema = z.object({
+  id: z.string(),
+  created_at: z.string().transform(val => new Date(val))
+  // TInput: string, TOutput: Date
+})
+
+// Validation happens here ✓
+collection.insert({
+  id: "1",
+  created_at: "2024-01-01"  // TInput: string
+})
+// If successful, stores: { created_at: Date }  // TOutput: Date
+```
+
+For more details on schema validation and type transformations, see the [Schemas guide](./schemas.md).
+
 ## Query Collection Error Tracking
 
 Query collections provide enhanced error tracking utilities through the `utils` object. These methods expose error state information and provide recovery mechanisms for failed queries:
@@ -66,8 +92,8 @@ const syncedCollection = createCollection(
 // Component can check error state
 function DataList() {
   const { data } = useLiveQuery((q) => q.from({ item: syncedCollection }))
-  const isError = syncedCollection.utils.isError()
-  const errorCount = syncedCollection.utils.errorCount()
+  const isError = syncedCollection.utils.isError
+  const errorCount = syncedCollection.utils.errorCount
   
   return (
     <>
@@ -86,9 +112,9 @@ function DataList() {
 ```
 
 Error tracking methods:
-- **`lastError()`**: Returns the most recent error encountered by the query, or `undefined` if no errors have occurred:
-- **`isError()`**: Returns a boolean indicating whether the collection is currently in an error state:
-- **`errorCount()`**: Returns the number of consecutive sync failures. This counter is incremented only when queries fail completely (not per retry attempt) and is reset on successful queries:
+- **`lastError`**: Returns the most recent error encountered by the query, or `undefined` if no errors have occurred:
+- **`isError`**: Returns a boolean indicating whether the collection is currently in an error state:
+- **`errorCount`**: Returns the number of consecutive sync failures. This counter is incremented only when queries fail completely (not per retry attempt) and is reset on successful queries:
 - **`clearError()`**: Clears the error state and triggers a refetch of the query. This method resets both `lastError` and `errorCount`:
 
 ## Collection Status and Error States
@@ -123,6 +149,36 @@ Collection status values:
 - `error` - In error state
 - `cleaned-up` - Cleaned up and no longer usable
 
+### Using Suspense and Error Boundaries (React)
+
+For React applications, you can handle loading and error states with `useLiveSuspenseQuery`, React Suspense, and Error Boundaries:
+
+```tsx
+import { useLiveSuspenseQuery } from "@tanstack/react-db"
+import { Suspense } from "react"
+import { ErrorBoundary } from "react-error-boundary"
+
+const TodoList = () => {
+  // No need to check status - Suspense and ErrorBoundary handle it
+  const { data } = useLiveSuspenseQuery(
+    (query) => query.from({ todos: todoCollection })
+  )
+
+  // data is always defined here
+  return <div>{data.map(todo => <div key={todo.id}>{todo.text}</div>)}</div>
+}
+
+const App = () => (
+  <ErrorBoundary fallback={<div>Failed to load todos</div>}>
+    <Suspense fallback={<div>Loading...</div>}>
+      <TodoList />
+    </Suspense>
+  </ErrorBoundary>
+)
+```
+
+With this approach, loading states are handled by `<Suspense>` and error states are handled by `<ErrorBoundary>` instead of within your component logic. See the [React Suspense section in Live Queries](./live-queries#using-with-react-suspense) for more details.
+
 ## Transaction Error Handling
 
 When mutations fail, TanStack DB automatically rolls back optimistic updates:
@@ -258,9 +314,11 @@ todoCollection.insert(newTodo)
 // Error: Collection.insert called directly (not within an explicit transaction) but no 'onInsert' handler is configured
 ```
 
-### Duplicate Key Errors
+### Insert Operation Errors
 
-Inserting items with existing keys will throw:
+#### DuplicateKeyError
+
+Thrown when inserting items with existing keys:
 
 ```ts
 import { DuplicateKeyError } from "@tanstack/db"
@@ -270,28 +328,90 @@ try {
 } catch (error) {
   if (error instanceof DuplicateKeyError) {
     console.log(`Duplicate key: ${error.message}`)
+    // Consider using update() instead, or check if item exists first
   }
 }
 ```
 
-### Schema Validation Errors
+#### UndefinedKeyError
 
-Schema validation must be synchronous:
+Thrown when an object is created without a defined key:
 
 ```ts
-const todoCollection = createCollection({
+import { UndefinedKeyError } from "@tanstack/db"
+
+const collection = createCollection({
   id: "todos",
-  getKey: (todo) => todo.id,
-  schema: {
-    "~standard": {
-      validate: async (data) => { // Async validation not allowed
-        // ...
-      }
-    }
-  }
+  getKey: (item) => item.id,
 })
 
-// Will throw: Schema validation must be synchronous
+try {
+  collection.insert({ text: "Todo" }) // Missing 'id' field
+} catch (error) {
+  if (error instanceof UndefinedKeyError) {
+    console.log("Item is missing required key field")
+    // Ensure your items have the key field defined by getKey
+  }
+}
+```
+
+### Update Operation Errors
+
+#### UpdateKeyNotFoundError
+
+Thrown when trying to update a key that doesn't exist in the collection:
+
+```ts
+import { UpdateKeyNotFoundError } from "@tanstack/db"
+
+try {
+  todoCollection.update("nonexistent-key", draft => {
+    draft.completed = true
+  })
+} catch (error) {
+  if (error instanceof UpdateKeyNotFoundError) {
+    console.log("Key not found - item may have been deleted")
+    // Consider using insert() if the item doesn't exist
+  }
+}
+```
+
+#### KeyUpdateNotAllowedError
+
+Thrown when attempting to change an item's key (not allowed - delete and re-insert instead):
+
+```ts
+import { KeyUpdateNotAllowedError } from "@tanstack/db"
+
+try {
+  todoCollection.update("todo-1", draft => {
+    draft.id = "todo-2" // Not allowed!
+  })
+} catch (error) {
+  if (error instanceof KeyUpdateNotAllowedError) {
+    console.log("Cannot change item keys")
+    // Instead, delete the old item and insert a new one
+  }
+}
+```
+
+### Delete Operation Errors
+
+#### DeleteKeyNotFoundError
+
+Thrown when trying to delete a key that doesn't exist:
+
+```ts
+import { DeleteKeyNotFoundError } from "@tanstack/db"
+
+try {
+  todoCollection.delete("nonexistent-key")
+} catch (error) {
+  if (error instanceof DeleteKeyNotFoundError) {
+    console.log("Key not found - item may have already been deleted")
+    // This may be acceptable in some scenarios (idempotent deletes)
+  }
+}
 ```
 
 ## Sync Error Handling
@@ -432,22 +552,139 @@ tx2.mutate(() => collection.update("1", draft => { draft.value = "B" })) // Same
 tx1.rollback() // tx2 is automatically rolled back
 ```
 
-### Handling Invalid State Errors
+### Transaction Lifecycle Errors
+
+Transactions validate their state before operations to prevent misuse. Here are the specific errors you may encounter:
+
+#### MissingMutationFunctionError
+
+Thrown when creating a transaction without a required `mutationFn`:
+
+```ts
+import { MissingMutationFunctionError } from "@tanstack/db"
+
+try {
+  const tx = createTransaction({}) // Missing mutationFn
+} catch (error) {
+  if (error instanceof MissingMutationFunctionError) {
+    console.log("mutationFn is required when creating a transaction")
+  }
+}
+```
+
+#### TransactionNotPendingMutateError
+
+Thrown when calling `mutate()` after a transaction is no longer pending:
+
+```ts
+import { TransactionNotPendingMutateError } from "@tanstack/db"
+
+const tx = createTransaction({ mutationFn: async () => {} })
+
+await tx.commit()
+
+try {
+  tx.mutate(() => {
+    collection.insert({ id: "1", text: "Item" })
+  })
+} catch (error) {
+  if (error instanceof TransactionNotPendingMutateError) {
+    console.log("Cannot mutate - transaction is no longer pending")
+  }
+}
+```
+
+#### TransactionNotPendingCommitError
 
-Transactions validate their state before operations:
+Thrown when calling `commit()` after a transaction is no longer pending:
 
 ```ts
+import { TransactionNotPendingCommitError } from "@tanstack/db"
+
 const tx = createTransaction({ mutationFn: async () => {} })
+tx.mutate(() => collection.insert({ id: "1", text: "Item" }))
 
-// Complete the transaction
 await tx.commit()
 
-// These will throw:
-tx.mutate(() => {}) // Error: You can no longer call .mutate() as the transaction is no longer pending
-tx.commit() // Error: You can no longer call .commit() as the transaction is no longer pending
-tx.rollback() // Error: You can no longer call .rollback() as the transaction is already completed
+try {
+  await tx.commit() // Trying to commit again
+} catch (error) {
+  if (error instanceof TransactionNotPendingCommitError) {
+    console.log("Transaction already committed")
+  }
+}
 ```
 
+#### TransactionAlreadyCompletedRollbackError
+
+Thrown when calling `rollback()` on a transaction that's already completed:
+
+```ts
+import { TransactionAlreadyCompletedRollbackError } from "@tanstack/db"
+
+const tx = createTransaction({ mutationFn: async () => {} })
+tx.mutate(() => collection.insert({ id: "1", text: "Item" }))
+
+await tx.commit()
+
+try {
+  tx.rollback() // Can't rollback after commit
+} catch (error) {
+  if (error instanceof TransactionAlreadyCompletedRollbackError) {
+    console.log("Cannot rollback - transaction already completed")
+  }
+}
+```
+
+### Sync Transaction Errors
+
+When working with sync transactions, these errors can occur:
+
+#### NoPendingSyncTransactionWriteError
+
+Thrown when calling `write()` without an active sync transaction:
+
+```ts
+const collection = createCollection({
+  id: "todos",
+  sync: {
+    sync: ({ write }) => {
+      // Calling write without begin() first
+      write({ type: "insert", value: { id: "1", text: "Todo" } })
+      // Error: No pending sync transaction to write to
+    }
+  }
+})
+```
+
+#### SyncTransactionAlreadyCommittedWriteError
+
+Thrown when calling `write()` after the sync transaction is already committed:
+
+```ts
+const collection = createCollection({
+  id: "todos",
+  sync: {
+    sync: ({ begin, write, commit }) => {
+      begin()
+      commit()
+
+      // Trying to write after commit
+      write({ type: "insert", value: { id: "1", text: "Todo" } })
+      // Error: The pending sync transaction is already committed
+    }
+  }
+})
+```
+
+#### NoPendingSyncTransactionCommitError
+
+Thrown when calling `commit()` without an active sync transaction.
+
+#### SyncTransactionAlreadyCommittedError
+
+Thrown when calling `commit()` on a sync transaction that's already committed.
+
 ## Best Practices
 
 1. **Use instanceof checks** - Use `instanceof` instead of string matching for error handling:
@@ -471,10 +708,13 @@ tx.rollback() // Error: You can no longer call .rollback() as the transaction is
 ## Example: Complete Error Handling
 
 ```tsx
-import { 
-  createCollection, 
+import {
+  createCollection,
   SchemaValidationError,
   DuplicateKeyError,
+  UpdateKeyNotFoundError,
+  DeleteKeyNotFoundError,
+  TransactionNotPendingCommitError,
   createTransaction
 } from "@tanstack/db"
 import { useLiveQuery } from "@tanstack/react-db"
@@ -570,6 +810,6 @@ const TodoApp = () => {
 
 ## See Also
 
-- [API Reference](../../overview.md#api-reference) - Detailed API documentation
-- [Mutations Guide](../../overview.md#making-optimistic-mutations) - Learn about optimistic updates and rollbacks
+- [API Reference](../overview.md#api-reference) - Detailed API documentation
+- [Mutations Guide](../overview.md#making-optimistic-mutations) - Learn about optimistic updates and rollbacks
 - [TanStack Query Error Handling](https://tanstack.com/query/latest/docs/react/guides/error-handling) - Query-specific error handling
diff --git a/docs/guides/live-queries.md b/docs/guides/live-queries.md
index 5b1664b20..b69689e16 100644
--- a/docs/guides/live-queries.md
+++ b/docs/guides/live-queries.md
@@ -38,6 +38,7 @@ The result types are automatically inferred from your query structure, providing
 - [Joins](#joins)
 - [Subqueries](#subqueries)
 - [groupBy and Aggregations](#groupby-and-aggregations)
+- [findOne](#findone)
 - [Distinct](#distinct)
 - [Order By, Limit, and Offset](#order-by-limit-and-offset)
 - [Composable Queries](#composable-queries)
@@ -160,7 +161,184 @@ export class UserListComponent {
 }
 ```
 
-For more details on framework integration, see the [React](../../framework/react/adapter), [Vue](../../framework/vue/adapter), and [Angular](../../framework/angular/adapter) adapter documentation.
+> **Note:** React hooks (`useLiveQuery`, `useLiveInfiniteQuery`, `useLiveSuspenseQuery`) accept an optional dependency array parameter to re-execute queries when values change, similar to React's `useEffect`. See the [React Adapter documentation](../framework/react/overview#dependency-arrays) for details on when and how to use dependency arrays.
+
+For more details on framework integration, see the [React](../framework/react/overview), [Vue](../framework/vue/overview), and [Angular](../framework/angular/overview) adapter documentation.
+
+### Using with React Suspense
+
+For React applications, you can use the `useLiveSuspenseQuery` hook to integrate with React Suspense boundaries. This hook suspends rendering while data loads initially, then streams updates without re-suspending.
+
+```tsx
+import { useLiveSuspenseQuery } from '@tanstack/react-db'
+import { Suspense } from 'react'
+
+function UserList() {
+  // This will suspend until data is ready
+  const { data } = useLiveSuspenseQuery((q) =>
+    q
+      .from({ user: usersCollection })
+      .where(({ user }) => eq(user.active, true))
+  )
+
+  // data is always defined - no need for optional chaining
+  return (
+    <ul>
+      {data.map(user => (
+        <li key={user.id}>{user.name}</li>
+      ))}
+    </ul>
+  )
+}
+
+function App() {
+  return (
+    <Suspense fallback={<div>Loading users...</div>}>
+      <UserList />
+    </Suspense>
+  )
+}
+```
+
+#### Type Safety
+
+The key difference from `useLiveQuery` is that `data` is always defined (never `undefined`). The hook suspends during initial load, so by the time your component renders, data is guaranteed to be available:
+
+```tsx
+function UserStats() {
+  const { data } = useLiveSuspenseQuery((q) =>
+    q.from({ user: usersCollection })
+  )
+
+  // TypeScript knows data is Array<User>, not Array<User> | undefined
+  return <div>Total users: {data.length}</div>
+}
+```
+
+#### Error Handling
+
+Combine with Error Boundaries to handle loading errors:
+
+```tsx
+import { ErrorBoundary } from 'react-error-boundary'
+
+function App() {
+  return (
+    <ErrorBoundary fallback={<div>Failed to load users</div>}>
+      <Suspense fallback={<div>Loading users...</div>}>
+        <UserList />
+      </Suspense>
+    </ErrorBoundary>
+  )
+}
+```
+
+#### Reactive Updates
+
+After the initial load, data updates stream in without re-suspending:
+
+```tsx
+function UserList() {
+  const { data } = useLiveSuspenseQuery((q) =>
+    q.from({ user: usersCollection })
+  )
+
+  // Suspends once during initial load
+  // After that, data updates automatically when users change
+  // UI never re-suspends for live updates
+  return (
+    <ul>
+      {data.map(user => (
+        <li key={user.id}>{user.name}</li>
+      ))}
+    </ul>
+  )
+}
+```
+
+#### Re-suspending on Dependency Changes
+
+When dependencies change, the hook re-suspends to load new data:
+
+```tsx
+function FilteredUsers({ minAge }: { minAge: number }) {
+  const { data } = useLiveSuspenseQuery(
+    (q) =>
+      q
+        .from({ user: usersCollection })
+        .where(({ user }) => gt(user.age, minAge)),
+    [minAge] // Re-suspend when minAge changes
+  )
+
+  return (
+    <ul>
+      {data.map(user => (
+        <li key={user.id}>{user.name} - {user.age}</li>
+      ))}
+    </ul>
+  )
+}
+```
+
+#### When to Use Which Hook
+
+- **Use `useLiveSuspenseQuery`** when:
+  - You want to use React Suspense for loading states
+  - You prefer handling loading/error states with `<Suspense>` and `<ErrorBoundary>` components
+  - You want guaranteed non-undefined data types
+  - The query always needs to run (not conditional)
+
+- **Use `useLiveQuery`** when:
+  - You need conditional/disabled queries
+  - You prefer handling loading/error states within your component
+  - You want to show loading states inline without Suspense
+  - You need access to `status` and `isLoading` flags
+  - **You're using a router with loaders** (React Router, TanStack Router, etc.) - preload in the loader and use `useLiveQuery` in the component
+
+```tsx
+// useLiveQuery - handle states in component
+function UserList() {
+  const { data, status, isLoading } = useLiveQuery((q) =>
+    q.from({ user: usersCollection })
+  )
+
+  if (isLoading) return <div>Loading...</div>
+  if (status === 'error') return <div>Error loading users</div>
+
+  return <ul>{data?.map(user => <li key={user.id}>{user.name}</li>)}</ul>
+}
+
+// useLiveSuspenseQuery - handle states with Suspense/ErrorBoundary
+function UserList() {
+  const { data } = useLiveSuspenseQuery((q) =>
+    q.from({ user: usersCollection })
+  )
+
+  return <ul>{data.map(user => <li key={user.id}>{user.name}</li>)}</ul>
+}
+
+// useLiveQuery with router loader - recommended pattern
+// In your route configuration:
+const route = {
+  path: '/users',
+  loader: async () => {
+    // Preload the collection in the loader
+    await usersCollection.preload()
+    return null
+  },
+  component: UserList,
+}
+
+// In your component:
+function UserList() {
+  // Collection is already loaded, so data is immediately available
+  const { data } = useLiveQuery((q) =>
+    q.from({ user: usersCollection })
+  )
+
+  return <ul>{data?.map(user => <li key={user.id}>{user.name}</li>)}</ul>
+}
+```
 
 ### Conditional Queries
 
@@ -930,10 +1108,19 @@ having(
 ```
 
 **Parameters:**
-- `condition` - A callback function that receives the aggregated row object and returns a boolean expression
+- `condition` - A callback function that receives table references (and `$selected` if the query contains a `select()` clause) and returns a boolean expression
 
 ```ts
+// Using aggregate functions directly
 const highValueCustomers = createLiveQueryCollection((q) =>
+  q
+    .from({ order: ordersCollection })
+    .groupBy(({ order }) => order.customerId)
+    .having(({ order }) => gt(sum(order.amount), 1000))
+)
+
+// Using SELECT fields via $selected (recommended when select() is used)
+const highValueCustomersWithSelect = createLiveQueryCollection((q) =>
   q
     .from({ order: ordersCollection })
     .groupBy(({ order }) => order.customerId)
@@ -942,7 +1129,7 @@ const highValueCustomers = createLiveQueryCollection((q) =>
       totalSpent: sum(order.amount),
       orderCount: count(order.id),
     }))
-    .having(({ order }) => gt(sum(order.amount), 1000))
+    .having(({ $selected }) => gt($selected.totalSpent, 1000))
 )
 ```
 
@@ -988,6 +1175,106 @@ const engineeringStats = deptStats.get(1)
 > - **Single column grouping**: Keyed by the actual value (e.g., `deptStats.get(1)`)
 > - **Multiple column grouping**: Keyed by a JSON string of the grouped values (e.g., `userStats.get('[1,"admin"]')`)
 
+## findOne
+
+Use `findOne` to return a single result instead of an array. This is useful when you expect to find at most one matching record, such as when querying by a unique identifier.
+
+The `findOne` method changes the return type from an array to a single object or `undefined`. When no matching record is found, the result is `undefined`.
+
+### Method Signature
+
+```ts
+findOne(): Query
+```
+
+### Basic Usage
+
+Find a specific user by ID:
+
+```ts
+const user = createLiveQueryCollection((q) =>
+  q
+    .from({ users: usersCollection })
+    .where(({ users }) => eq(users.id, 1))
+    .findOne()
+)
+
+// Result type: User | undefined
+// If user with id=1 exists: { id: 1, name: 'John', ... }
+// If not found: undefined
+```
+
+### With React Hooks
+
+Use `findOne` with `useLiveQuery` to get a single record:
+
+```tsx
+import { useLiveQuery } from '@tanstack/react-db'
+import { eq } from '@tanstack/db'
+
+function UserProfile({ userId }: { userId: string }) {
+  const { data: user, isLoading } = useLiveQuery((q) =>
+    q
+      .from({ users: usersCollection })
+      .where(({ users }) => eq(users.id, userId))
+      .findOne()
+  , [userId])
+
+  if (isLoading) return <div>Loading...</div>
+  if (!user) return <div>User not found</div>
+
+  return <div>{user.name}</div>
+}
+```
+
+### With Select
+
+Combine `findOne` with `select` to project specific fields:
+
+```ts
+const userEmail = createLiveQueryCollection((q) =>
+  q
+    .from({ users: usersCollection })
+    .where(({ users }) => eq(users.id, 1))
+    .select(({ users }) => ({
+      id: users.id,
+      email: users.email,
+    }))
+    .findOne()
+)
+
+// Result type: { id: number, email: string } | undefined
+```
+
+### Return Type Behavior
+
+The return type changes based on whether `findOne` is used:
+
+```ts
+// Without findOne - returns array
+const users = createLiveQueryCollection((q) =>
+  q.from({ users: usersCollection })
+)
+// Type: Array<User>
+
+// With findOne - returns single object or undefined
+const user = createLiveQueryCollection((q) =>
+  q.from({ users: usersCollection }).findOne()
+)
+// Type: User | undefined
+```
+
+### Best Practices
+
+**Use when:**
+- Querying by unique identifiers (ID, email, etc.)
+- You expect at most one result
+- You want type-safe single-record access without array indexing
+
+**Avoid when:**
+- You might have multiple matching records (use regular queries instead)
+- You need to iterate over results
+
 ## Distinct
 
 Use `distinct` to remove duplicate rows from your query results based on the selected columns. The `distinct` operator ensures that each unique combination of selected values appears only once in the result set.
@@ -1110,6 +1397,26 @@ const sortedUsers = createLiveQueryCollection((q) =>
 )
 ```
 
+### Ordering by SELECT Fields
+
+When you use `select()` with aggregates or computed values, you can order by those fields using the `$selected` namespace:
+
+```ts
+const topCustomers = createLiveQueryCollection((q) =>
+  q
+    .from({ order: ordersCollection })
+    .groupBy(({ order }) => order.customerId)
+    .select(({ order }) => ({
+      customerId: order.customerId,
+      totalSpent: sum(order.amount),
+      orderCount: count(order.id),
+      latestOrder: max(order.createdAt),
+    }))
+    .orderBy(({ $selected }) => $selected.totalSpent, 'desc')
+    .limit(10)
+)
+```
+
 ### Descending Order
 
 Use `desc` for descending order:
@@ -1234,21 +1541,33 @@ const userPosts = createLiveQueryCollection((q) =>
 
 ### Reusable Callback Functions
 
-Use `Ref<MyType>` to create reusable callback functions:
+Creating reusable query logic is a common pattern that improves code organization and maintainability. The recommended approach is to use callback functions with the `Ref<T>` type rather than trying to type `QueryBuilder` instances directly.
+
+#### The Recommended Pattern
+
+Use `Ref<MyType>` to create reusable filter and transform functions:
 
 ```ts
-import { Ref, eq, gt, and } from '@tanstack/db'
+import type { Ref } from '@tanstack/db'
+import { eq, gt, and } from '@tanstack/db'
 
-// Create reusable callbacks
-const isActiveUser = (user: Ref<User>) => eq(user.active, true)
-const isAdultUser = (user: Ref<User>) => gt(user.age, 18)
+// Create reusable filter callbacks
+const isActiveUser = ({ user }: { user: Ref<User> }) =>
+  eq(user.active, true)
 
-// Use them in queries
+const isAdultUser = ({ user }: { user: Ref<User> }) =>
+  gt(user.age, 18)
+
+const isActiveAdult = ({ user }: { user: Ref<User> }) =>
+  and(isActiveUser({ user }), isAdultUser({ user }))
+
+// Use them in queries - they work seamlessly with .where()
 const activeAdults = createCollection(liveQueryCollectionOptions({
   query: (q) =>
     q
       .from({ user: usersCollection })
-      .where(({ user }) => and(isActiveUser(user), isAdultUser(user)))
+      .where(isActiveUser)
+      .where(isAdultUser)
       .select(({ user }) => ({
         id: user.id,
         name: user.name,
@@ -1257,19 +1576,62 @@ const activeAdults = createCollection(liveQueryCollectionOptions({
 }))
 ```
 
-You can also create callbacks that take the whole row and pass them directly to `where`:
+The callback signature `({ user }: { user: Ref<User> }) => Expression` matches exactly what `.where()` expects, making it type-safe and composable.
+
+#### Chaining Multiple Filters
+
+You can chain multiple reusable filters:
+
+```tsx
+import { useLiveQuery } from '@tanstack/react-db'
+
+const { data } = useLiveQuery((q) => {
+  return q
+    .from({ item: itemsCollection })
+    .where(({ item }) => eq(item.id, 1))
+    .where(activeItemFilter)      // Reusable filter 1
+    .where(verifiedItemFilter)     // Reusable filter 2
+    .select(({ item }) => ({ ...item }))
+}, [])
+```
+
+#### Using with Different Aliases
+
+The pattern works with any table alias:
+
+```ts
+const activeFilter = ({ item }: { item: Ref<Item> }) =>
+  eq(item.active, true)
+
+// Works with any alias name
+const query1 = new Query()
+  .from({ item: itemsCollection })
+  .where(activeFilter)
+
+const query2 = new Query()
+  .from({ i: itemsCollection })
+  .where(({ i }) => activeFilter({ item: i }))  // Map the alias
+```
+
+#### Callbacks with Multiple Tables
+
+For queries with joins, create callbacks that accept multiple refs:
 
 ```ts
-// Callback that takes the whole row
-const isHighValueCustomer = (row: { user: User; order: Order }) => 
-  row.user.active && row.order.amount > 1000
+const isHighValueCustomer = ({ user, order }: {
+  user: Ref<User>
+  order: Ref<Order>
+}) => and(
+  eq(user.active, true),
+  gt(order.amount, 1000)
+)
 
 // Use directly in where clause
 const highValueCustomers = createCollection(liveQueryCollectionOptions({
   query: (q) =>
     q
       .from({ user: usersCollection })
-      .join({ order: ordersCollection }, ({ user, order }) => 
+      .join({ order: ordersCollection }, ({ user, order }) =>
         eq(user.id, order.userId)
       )
       .where(isHighValueCustomer)
@@ -1280,7 +1642,50 @@ const highValueCustomers = createCollection(liveQueryCollectionOptions({
 }))
 ```
 
-This approach makes your query logic more modular and testable.
+#### Why Not Type QueryBuilder?
+
+You might be tempted to create functions that accept and return `QueryBuilder`:
+
+```ts
+// ❌ Not recommended - overly complex typing
+const applyFilters = <T extends QueryBuilder<unknown>>(query: T): T => {
+  return query.where(({ item }) => eq(item.active, true))
+}
+```
+
+This approach has several issues:
+
+1. **Complex Types**: `QueryBuilder<T>` generic represents the entire query context including base schema, current schema, joins, result types, etc.
+2. **Type Inference**: The type changes with every method call, making it impractical to type manually
+3. **Limited Flexibility**: Hard to compose multiple filters or use with different table aliases
+
+Instead, use callback functions that work with the `.where()`, `.select()`, and other query methods directly.
+
+#### Reusable Select Transformations
+
+You can also create reusable select projections:
+
+```ts
+const basicUserInfo = ({ user }: { user: Ref<User> }) => ({
+  id: user.id,
+  name: user.name,
+  email: user.email,
+})
+
+const userWithStats = ({ user }: { user: Ref<User> }) => ({
+  ...basicUserInfo({ user }),
+  isAdult: gt(user.age, 18),
+  isActive: eq(user.active, true),
+})
+
+const users = createLiveQueryCollection((q) =>
+  q
+    .from({ user: usersCollection })
+    .select(userWithStats)
+)
+```
+
+This approach makes your query logic more modular, testable, and reusable across your application.
 
 ## Expression Functions Reference
 
@@ -1532,8 +1937,8 @@ const highValueCustomers = createLiveQueryCollection((q) =>
       totalSpent: sum(order.amount),
       orderCount: count(order.id),
     }))
-    .fn.having((row) => {
-      return row.totalSpent > 1000 && row.orderCount >= 3
+    .fn.having(({ $selected }) => {
+      return $selected.totalSpent > 1000 && $selected.orderCount >= 3
     })
 )
 ```
diff --git a/docs/guides/mutations.md b/docs/guides/mutations.md
index 24e8aba92..b3f698084 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)
@@ -159,7 +160,7 @@ onUpdate: async ({ transaction }) => {
 
 ### Intent-Based Mutations with Custom Actions
 
-For more complex scenarios, use `createOptimisticAction` or `createTransaction` to create **intent-based mutations** that capture specific user actions.
+For more complex scenarios, use `createOptimisticAction` to create **intent-based mutations** that capture specific user actions.
 
 ```tsx
 // Intent: "like this post"
@@ -196,7 +197,45 @@ Custom actions provide the cleanest way to capture specific types of mutations a
 
 - **Collection-level mutations** (`collection.update`): Simple CRUD operations on a single collection
 - **`createOptimisticAction`**: Intent-based operations, multi-collection mutations, immediately committed
-- **`createTransaction`**: Fully custom transactions, delayed commits, multi-step workflows
+- **Bypass the mutation system**: Use your existing mutation logic without rewriting
+
+### Bypass the Mutation System
+
+If you already have mutation logic in an existing system and don't want to rewrite it, you can **completely bypass** TanStack DB's mutation system and use your existing patterns.
+
+With this approach, you write to the server like normal using your existing logic, then use your collection's mechanism for refetching or syncing data to await the server write. After the sync completes, the collection will have the updated server data and you can render the new state, hide loading indicators, show success messages, navigate to a new page, etc.
+
+```tsx
+// Call your backend directly with your existing logic
+const handleUpdateTodo = async (todoId, changes) => {
+  await api.todos.update(todoId, changes)
+
+  // Wait for the server change to load into the collection
+  await todoCollection.utils.refetch()
+
+  // Now you know the new data is loaded and can render it or hide loaders
+}
+
+// With Electric
+const handleUpdateTodo = async (todoId, changes) => {
+  const { txid } = await api.todos.update(todoId, changes)
+
+  // Wait for this specific transaction to sync into the collection
+  await todoCollection.utils.awaitTxId(txid)
+
+  // Now the server change is loaded and you can update UI accordingly
+}
+```
+
+Use this approach when:
+- You have existing mutation logic you don't want to rewrite
+- You're comfortable with your current mutation patterns
+- You want to use TanStack DB only for queries and state management
+
+How to sync changes back:
+- **QueryCollection**: Manually refetch with `collection.utils.refetch()` to reload data from the server
+- **ElectricCollection**: Use `collection.utils.awaitTxId(txid)` to wait for a specific transaction to sync
+- **Other sync systems**: Wait for your sync mechanism to update the collection
 
 ## Mutation Lifecycle
 
@@ -447,6 +486,49 @@ const todoCollection = createCollection({
 })
 ```
 
+### Schema Validation in Mutation Handlers
+
+When a schema is configured for a collection, TanStack DB automatically validates and transforms data during mutations. The mutation handlers receive the **transformed data** (TOutput), not the raw input.
+
+```typescript
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  created_at: z.string().transform(val => new Date(val))  // TInput: string, TOutput: Date
+})
+
+const collection = createCollection({
+  schema: todoSchema,
+  onInsert: async ({ transaction }) => {
+    const item = transaction.mutations[0].modified
+
+    // item.created_at is already a Date object (TOutput)
+    console.log(item.created_at instanceof Date)  // true
+
+    // If your API needs a string, serialize it
+    await api.todos.create({
+      ...item,
+      created_at: item.created_at.toISOString()  // Date → string
+    })
+  }
+})
+
+// User provides string (TInput)
+collection.insert({
+  id: "1",
+  text: "Task",
+  created_at: "2024-01-01T00:00:00Z"
+})
+```
+
+**Key points:**
+- Schema validation happens **before** mutation handlers are called
+- Handlers receive **TOutput** (transformed data)
+- If your backend needs a different format, serialize in the handler
+- Schema validation errors throw `SchemaValidationError` before handlers run
+
+For comprehensive documentation on schema validation and transformations, see the [Schemas guide](./schemas.md).
+
 ## Creating Custom Actions
 
 For more complex mutation patterns, use `createOptimisticAction` to create custom actions with full control over the mutation lifecycle.
@@ -814,8 +896,12 @@ const userProfile = createCollection(
 
 const tx = createTransaction({
   mutationFn: async ({ transaction }) => {
-    // Server collection mutations are handled by their onUpdate handler automatically
-    // (onUpdate will be called and awaited first)
+    // Handle server collection mutations explicitly in mutationFn
+    await Promise.all(
+      transaction.mutations
+        .filter((m) => m.collection === userProfile)
+        .map((m) => api.profile.update(m.modified))
+    )
 
     // After server mutations succeed, accept local collection mutations
     localSettings.utils.acceptMutations(transaction)
@@ -892,6 +978,338 @@ 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({ formId }: { formId: string }) {
+  const mutate = usePacedMutations<{ field: string; value: string }>({
+    onMutate: ({ field, value }) => {
+      // Apply optimistic update immediately
+      formCollection.update(formId, (draft) => {
+        draft[field] = value
+      })
+    },
+    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({ 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<number>({
+    onMutate: (volume) => {
+      // Apply optimistic update immediately
+      settingsCollection.update('volume', (draft) => {
+        draft.value = volume
+      })
+    },
+    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(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 which may drop intermediate mutations, **every mutation is guaranteed to be attempted**, making it ideal for workflows where you can't skip any operations.
+
+```tsx
+import { usePacedMutations, queueStrategy } from "@tanstack/react-db"
+
+function FileUploader() {
+  const mutate = usePacedMutations<File>({
+    onMutate: (file) => {
+      // Apply optimistic update immediately
+      uploadCollection.insert({
+        id: crypto.randomUUID(),
+        file,
+        status: 'pending',
+      })
+    },
+    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) => {
+      mutate(file)
+    })
+  }
+
+  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 be attempted (unlike debounce/throttle which may skip intermediate mutations)
+- Waits for each transaction to complete before starting the next
+
+**Error handling**:
+- If a mutation fails, **it is not automatically retried** - the transaction transitions to "failed" state
+- Failed mutations surface their error via `transaction.isPersisted.promise` (which will reject)
+- **Subsequent mutations continue processing** - a single failure does not block the queue
+- Each mutation is independent; there is no all-or-nothing transaction semantics across multiple mutations
+- To implement retry logic, see [Retry Behavior](#retry-behavior)
+
+### 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({ itemId }: { itemId: string }) {
+  const mutate = usePacedMutations<number>({
+    onMutate: (newValue) => {
+      // Apply optimistic update immediately
+      collection.update(itemId, (draft) => {
+        draft.value = newValue
+      })
+    },
+    mutationFn: async ({ transaction }) => {
+      await api.save(transaction.mutations)
+    },
+    strategy: debounceStrategy({ wait: 500 }),
+  })
+
+  // Each mutate call returns a Transaction you can await
+  const handleSave = async (newValue: number) => {
+    const tx = mutate(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(42)}>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<{ id: string; changes: Partial<Item> }>({
+  onMutate: ({ id, changes }) => {
+    // Apply optimistic update immediately
+    collection.update(id, (draft) => {
+      Object.assign(draft, changes)
+    })
+  },
+  mutationFn: async ({ transaction }) => {
+    await api.save(transaction.mutations)
+  },
+  strategy: queueStrategy({ wait: 200 }),
+})
+
+// Use anywhere in your application
+mutate({ id: '123', changes: { name: 'New Name' } })
+```
+
+### Understanding Queues and Hook Instances
+
+**Each unique `usePacedMutations` hook call creates its own independent queue.** This is an important design decision that affects how you structure your mutations.
+
+If you have multiple components calling `usePacedMutations` separately, each will have its own isolated queue:
+
+```tsx
+function EmailDraftEditor1({ draftId }: { draftId: string }) {
+  // This creates Queue A
+  const mutate = usePacedMutations({
+    onMutate: (text) => {
+      draftCollection.update(draftId, (draft) => {
+        draft.text = text
+      })
+    },
+    mutationFn: async ({ transaction }) => {
+      await api.saveDraft(transaction.mutations)
+    },
+    strategy: debounceStrategy({ wait: 500 }),
+  })
+
+  return <textarea onChange={(e) => mutate(e.target.value)} />
+}
+
+function EmailDraftEditor2({ draftId }: { draftId: string }) {
+  // This creates Queue B (separate from Queue A)
+  const mutate = usePacedMutations({
+    onMutate: (text) => {
+      draftCollection.update(draftId, (draft) => {
+        draft.text = text
+      })
+    },
+    mutationFn: async ({ transaction }) => {
+      await api.saveDraft(transaction.mutations)
+    },
+    strategy: debounceStrategy({ wait: 500 }),
+  })
+
+  return <textarea onChange={(e) => mutate(e.target.value)} />
+}
+```
+
+In this example, mutations from `EmailDraftEditor1` and `EmailDraftEditor2` will be queued and processed **independently**. They won't share the same debounce timer or queue.
+
+**To share the same queue across multiple components**, create a single `createPacedMutations` instance and use it everywhere:
+
+```tsx
+// Create a single shared instance
+import { createPacedMutations, debounceStrategy } from "@tanstack/db"
+
+export const mutateDraft = createPacedMutations<{ draftId: string; text: string }>({
+  onMutate: ({ draftId, text }) => {
+    draftCollection.update(draftId, (draft) => {
+      draft.text = text
+    })
+  },
+  mutationFn: async ({ transaction }) => {
+    await api.saveDraft(transaction.mutations)
+  },
+  strategy: debounceStrategy({ wait: 500 }),
+})
+
+// Now both components share the same queue
+function EmailDraftEditor1({ draftId }: { draftId: string }) {
+  return <textarea onChange={(e) => mutateDraft({ draftId, text: e.target.value })} />
+}
+
+function EmailDraftEditor2({ draftId }: { draftId: string }) {
+  return <textarea onChange={(e) => mutateDraft({ draftId, text: e.target.value })} />
+}
+```
+
+With this approach, all mutations from both components share the same debounce timer and queue, ensuring they're processed in the correct order with a single debounce implementation.
+
+**Key takeaways:**
+
+- Each `usePacedMutations()` call = unique queue
+- Each `createPacedMutations()` call = unique queue
+- To share a queue: create one instance and import it everywhere you need it
+- Shared queues ensure mutations from different places are ordered correctly
+
 ## Mutation Merging
 
 When multiple mutations operate on the same item within a transaction, TanStack DB intelligently merges them to:
@@ -1042,6 +1460,45 @@ If an error occurs: `pending` → `persisting` → `failed`
 
 Failed transactions automatically rollback their optimistic state.
 
+### Retry Behavior
+
+**Important:** TanStack DB does not automatically retry failed mutations. If a mutation fails (network error, server error, etc.), the transaction transitions to `failed` state and the optimistic state is rolled back. This is by design. Automatic retry logic varies significantly based on your use case (idempotency requirements, error types, backoff strategies, etc.).
+
+To implement retry logic, wrap your API calls in your `mutationFn`:
+
+```typescript
+// Simple retry helper
+async function withRetry<T>(
+  fn: () => Promise<T>,
+  maxRetries = 3,
+  delay = 1000
+): Promise<T> {
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn()
+    } catch (error) {
+      if (attempt === maxRetries - 1) throw error
+      await new Promise(resolve => setTimeout(resolve, delay * (attempt + 1)))
+    }
+  }
+  throw new Error('Unreachable')
+}
+
+// Use in your collection
+const todoCollection = createCollection({
+  id: "todos",
+  onUpdate: async ({ transaction }) => {
+    const mutation = transaction.mutations[0]
+    // Retry up to 3 times with increasing delay
+    await withRetry(() =>
+      api.todos.update(mutation.original.id, mutation.changes)
+    )
+  },
+})
+```
+
+For more sophisticated retry strategies, consider using a library like [p-retry](https://github.com/sindresorhus/p-retry) which supports exponential backoff, custom retry conditions, and abort signals.
+
 ## Handling Temporary IDs
 
 When inserting new items into collections where the server generates the final ID, you'll need to handle the transition from temporary to real IDs carefully to avoid UI issues and operation failures.
diff --git a/docs/guides/schemas.md b/docs/guides/schemas.md
new file mode 100644
index 000000000..b51296b43
--- /dev/null
+++ b/docs/guides/schemas.md
@@ -0,0 +1,1098 @@
+---
+title: Schemas
+id: schemas
+---
+
+# Schema Validation and Type Transformations
+
+TanStack DB uses schemas to ensure your data is valid and type-safe throughout your application.
+
+## What You'll Learn
+
+This guide covers:
+- How schema validation works in TanStack DB
+- Understanding TInput and TOutput types
+- Common patterns: validation, transformations, and defaults
+- Error handling and best practices
+
+## Quick Example
+
+Schemas catch invalid data from optimistic mutations before it enters your collection:
+
+```typescript
+import { z } from 'zod'
+import { createCollection } from '@tanstack/react-db'
+import { queryCollectionOptions } from '@tanstack/query-db-collection'
+
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string().min(1, "Text is required"),
+  completed: z.boolean(),
+  priority: z.number().min(0).max(5)
+})
+
+const collection = createCollection(
+  queryCollectionOptions({
+    schema: todoSchema,
+    queryKey: ['todos'],
+    queryFn: async () => api.todos.getAll(),
+    getKey: (item) => item.id,
+    // ...
+  })
+)
+
+// Invalid data throws SchemaValidationError
+collection.insert({
+  id: "1",
+  text: "",  // ❌ Too short
+  completed: "yes",  // ❌ Wrong type
+  priority: 10  // ❌ Out of range
+})
+// Error: Validation failed with 3 issues
+
+// Valid data works
+collection.insert({
+  id: "1",
+  text: "Buy groceries",  // ✅
+  completed: false,  // ✅
+  priority: 2  // ✅
+})
+```
+
+Schemas also enable advanced features like type transformations and defaults:
+
+```typescript
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string().min(1),
+  completed: z.boolean().default(false),  // Auto-fill missing values
+  created_at: z.string().transform(val => new Date(val))  // Convert types
+})
+
+collection.insert({
+  id: "1",
+  text: "Buy groceries",
+  created_at: "2024-01-01T00:00:00Z"  // String in
+  // completed auto-filled with false
+})
+
+const todo = collection.get("1")
+console.log(todo.created_at.getFullYear())  // Date object out!
+```
+
+## Supported Schema Libraries
+
+TanStack DB supports any [StandardSchema](https://standardschema.dev) compatible library:
+- [Zod](https://zod.dev)
+- [Valibot](https://valibot.dev)
+- [ArkType](https://arktype.io)
+- [Effect Schema](https://effect.website/docs/schema/introduction/)
+
+Examples in this guide use Zod, but patterns apply to all libraries.
+
+---
+
+## Core Concepts: TInput vs TOutput
+
+Understanding TInput and TOutput is key to working effectively with schemas in TanStack DB.
+
+> **Important:** Schemas validate **client changes only** - data you insert or update via `collection.insert()` and `collection.update()`. They do not automatically validate data loaded from your server or sync layer. If you need to validate server data, you must do so explicitly in your integration layer.
+
+### What are TInput and TOutput?
+
+When you define a schema with transformations, it has two types:
+
+- **TInput**: The type users provide when calling `insert()` or `update()`
+- **TOutput**: The type stored in the collection and returned from queries
+
+```typescript
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  created_at: z.string().transform(val => new Date(val))
+})
+
+// TInput type:  { id: string, text: string, created_at: string }
+// TOutput type: { id: string, text: string, created_at: Date }
+```
+
+The schema acts as a **boundary** that transforms TInput → TOutput.
+
+### Critical Design Principle: TInput Must Be a Superset of TOutput
+
+When using transformations, **TInput must accept all values that TOutput contains**. This is essential for updates to work correctly.
+
+Here's why: when you call `collection.update(id, (draft) => {...})`, the `draft` parameter is typed as `TInput` but contains data that's already been transformed to `TOutput`. For this to work without complex type gymnastics, your schema must accept both the input format AND the output format.
+
+```typescript
+// ❌ BAD: TInput only accepts strings
+const schema = z.object({
+  created_at: z.string().transform(val => new Date(val))
+})
+// TInput:  { created_at: string }
+// TOutput: { created_at: Date }
+// Problem: draft.created_at is a Date, but TInput only accepts string!
+
+// ✅ GOOD: TInput accepts both string and Date (superset of TOutput)
+const schema = z.object({
+  created_at: z.union([z.string(), z.date()])
+    .transform(val => typeof val === 'string' ? new Date(val) : val)
+})
+// TInput:  { created_at: string | Date }
+// TOutput: { created_at: Date }
+// Success: draft.created_at can be a Date because TInput accepts Date!
+```
+
+**Rule of thumb:** If your schema transforms type A to type B, use `z.union([A, B])` to ensure TInput accepts both.
+
+### Why This Matters
+
+**All data in your collection is TOutput:**
+- Data stored in the collection
+- Data returned from queries
+- Data in `PendingMutation.modified`
+- Data in mutation handlers
+
+```typescript
+const collection = createCollection({
+  schema: todoSchema,
+  onInsert: async ({ transaction }) => {
+    const item = transaction.mutations[0].modified
+
+    // item is TOutput
+    console.log(item.created_at instanceof Date)  // true
+
+    // If your API needs a string, serialize it
+    await api.todos.create({
+      ...item,
+      created_at: item.created_at.toISOString()  // Date → string
+    })
+  }
+})
+
+// User provides TInput
+collection.insert({
+  id: "1",
+  text: "Task",
+  created_at: "2024-01-01T00:00:00Z"  // string
+})
+
+// Collection stores and returns TOutput
+const todo = collection.get("1")
+console.log(todo.created_at.getFullYear())  // It's a Date!
+```
+
+---
+
+## Validation Patterns
+
+Schemas provide powerful validation to ensure data quality.
+
+### Basic Type Validation
+
+```typescript
+const userSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  age: z.number(),
+  email: z.string().email(),
+  active: z.boolean()
+})
+
+collection.insert({
+  id: "1",
+  name: "Alice",
+  age: "25",  // ❌ Wrong type - expects number
+  email: "not-an-email",  // ❌ Invalid email format
+  active: true
+})
+// Throws SchemaValidationError
+```
+
+### String Constraints
+
+```typescript
+const productSchema = z.object({
+  id: z.string(),
+  name: z.string().min(3, "Name must be at least 3 characters"),
+  sku: z.string().length(8, "SKU must be exactly 8 characters"),
+  description: z.string().max(500, "Description too long"),
+  url: z.string().url("Must be a valid URL")
+})
+```
+
+### Number Constraints
+
+```typescript
+const orderSchema = z.object({
+  id: z.string(),
+  quantity: z.number()
+    .int("Must be a whole number")
+    .positive("Must be greater than 0"),
+  price: z.number()
+    .min(0.01, "Price must be at least $0.01")
+    .max(999999.99, "Price too high"),
+  discount: z.number()
+    .min(0)
+    .max(100)
+})
+```
+
+### Enum Validation
+
+```typescript
+const taskSchema = z.object({
+  id: z.string(),
+  status: z.enum(['todo', 'in-progress', 'done']),
+  priority: z.enum(['low', 'medium', 'high', 'urgent'])
+})
+
+collection.insert({
+  id: "1",
+  status: "completed",  // ❌ Not in enum
+  priority: "medium"  // ✅
+})
+```
+
+### Optional and Nullable Fields
+
+```typescript
+const personSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  nickname: z.string().optional(),  // Can be omitted
+  middleName: z.string().nullable(),  // Can be null
+  bio: z.string().optional().nullable()  // Can be omitted OR null
+})
+
+// All valid:
+collection.insert({ id: "1", name: "Alice" })  // nickname omitted
+collection.insert({ id: "2", name: "Bob", middleName: null })
+collection.insert({ id: "3", name: "Carol", bio: null })
+```
+
+### Array Validation
+
+```typescript
+const postSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  tags: z.array(z.string()).min(1, "At least one tag required"),
+  likes: z.array(z.number()).max(1000)
+})
+
+collection.insert({
+  id: "1",
+  title: "My Post",
+  tags: [],  // ❌ Need at least one
+  likes: [1, 2, 3]
+})
+```
+
+### Custom Validation
+
+```typescript
+const userSchema = z.object({
+  id: z.string(),
+  username: z.string()
+    .min(3)
+    .refine(
+      (val) => /^[a-zA-Z0-9_]+$/.test(val),
+      "Username can only contain letters, numbers, and underscores"
+    ),
+  password: z.string()
+    .min(8)
+    .refine(
+      (val) => /[A-Z]/.test(val) && /[0-9]/.test(val),
+      "Password must contain at least one uppercase letter and one number"
+    )
+})
+```
+
+### Cross-Field Validation
+
+```typescript
+const dateRangeSchema = z.object({
+  id: z.string(),
+  start_date: z.string(),
+  end_date: z.string()
+}).refine(
+  (data) => new Date(data.end_date) > new Date(data.start_date),
+  "End date must be after start date"
+)
+```
+
+---
+
+## Transformation Patterns
+
+Schemas can transform data as it enters your collection.
+
+### String to Date
+
+The most common transformation - convert ISO strings to Date objects:
+
+```typescript
+const eventSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  start_time: z.string().transform(val => new Date(val))
+})
+
+collection.insert({
+  id: "1",
+  name: "Conference",
+  start_time: "2024-06-15T10:00:00Z"  // TInput: string
+})
+
+const event = collection.get("1")
+console.log(event.start_time.getFullYear())  // TOutput: Date
+```
+
+### String to Number
+
+```typescript
+const formSchema = z.object({
+  id: z.string(),
+  quantity: z.string().transform(val => parseInt(val, 10)),
+  price: z.string().transform(val => parseFloat(val))
+})
+
+collection.insert({
+  id: "1",
+  quantity: "42",  // String from form input
+  price: "19.99"
+})
+
+const item = collection.get("1")
+console.log(typeof item.quantity)  // "number"
+```
+
+### JSON String to Object
+
+```typescript
+const configSchema = z.object({
+  id: z.string(),
+  settings: z.string().transform(val => JSON.parse(val))
+})
+
+collection.insert({
+  id: "1",
+  settings: '{"theme":"dark","notifications":true}'  // JSON string
+})
+
+const config = collection.get("1")
+console.log(config.settings.theme)  // "dark" (parsed object)
+```
+
+### Computed Fields
+
+```typescript
+const userSchema = z.object({
+  id: z.string(),
+  first_name: z.string(),
+  last_name: z.string()
+}).transform(data => ({
+  ...data,
+  full_name: `${data.first_name} ${data.last_name}`  // Computed
+}))
+
+collection.insert({
+  id: "1",
+  first_name: "John",
+  last_name: "Doe"
+})
+
+const user = collection.get("1")
+console.log(user.full_name)  // "John Doe"
+```
+
+### String to Enum
+
+```typescript
+const orderSchema = z.object({
+  id: z.string(),
+  status: z.string().transform(val =>
+    val.toUpperCase() as 'PENDING' | 'SHIPPED' | 'DELIVERED'
+  )
+})
+```
+
+### Sanitization
+
+```typescript
+const commentSchema = z.object({
+  id: z.string(),
+  text: z.string().transform(val => val.trim()),  // Remove whitespace
+  username: z.string().transform(val => val.toLowerCase())  // Normalize
+})
+```
+
+### Complex Transformations
+
+```typescript
+const productSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  price_cents: z.number()
+}).transform(data => ({
+  ...data,
+  price_dollars: data.price_cents / 100,  // Add computed field
+  display_price: `$${(data.price_cents / 100).toFixed(2)}`  // Formatted
+}))
+```
+
+---
+
+## Default Values
+
+Schemas can automatically provide default values for missing fields.
+
+### Literal Defaults
+
+```typescript
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  completed: z.boolean().default(false),
+  priority: z.number().default(0),
+  tags: z.array(z.string()).default([])
+})
+
+collection.insert({
+  id: "1",
+  text: "Buy groceries"
+  // completed, priority, and tags filled automatically
+})
+
+const todo = collection.get("1")
+console.log(todo.completed)  // false
+console.log(todo.priority)   // 0
+console.log(todo.tags)       // []
+```
+
+### Function Defaults
+
+Generate defaults dynamically:
+
+```typescript
+const postSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  created_at: z.date().default(() => new Date()),
+  view_count: z.number().default(0),
+  slug: z.string().default(() => crypto.randomUUID())
+})
+
+collection.insert({
+  id: "1",
+  title: "My First Post"
+  // created_at, view_count, and slug generated automatically
+})
+```
+
+### Conditional Defaults
+
+```typescript
+const userSchema = z.object({
+  id: z.string(),
+  username: z.string(),
+  role: z.enum(['user', 'admin']).default('user'),
+  permissions: z.array(z.string()).default(['read'])
+})
+```
+
+### Complex Defaults
+
+```typescript
+const eventSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  metadata: z.record(z.unknown()).default(() => ({
+    created_by: 'system',
+    version: 1
+  }))
+})
+```
+
+### Combining Defaults with Transformations
+
+```typescript
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  completed: z.boolean().default(false),
+  created_at: z.string()
+    .default(() => new Date().toISOString())
+    .transform(val => new Date(val))
+})
+
+collection.insert({
+  id: "1",
+  text: "Task"
+  // completed defaults to false
+  // created_at defaults to current time, then transforms to Date
+})
+```
+
+---
+
+## Handling Timestamps
+
+When working with timestamps, you typically want automatic creation dates rather than transforming user input.
+
+### Use Defaults for Timestamps
+
+For `created_at` and `updated_at` fields, use defaults to automatically generate timestamps:
+
+```typescript
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  completed: z.boolean().default(false),
+  created_at: z.date().default(() => new Date()),
+  updated_at: z.date().default(() => new Date())
+})
+
+// Timestamps generated automatically
+collection.insert({
+  id: "1",
+  text: "Buy groceries"
+  // created_at and updated_at filled automatically
+})
+
+// Update timestamps
+collection.update("1", (draft) => {
+  draft.text = "Buy groceries and milk"
+  draft.updated_at = new Date()
+})
+```
+
+### Accepting Date Input from External Sources
+
+If you're accepting date input from external sources (forms, APIs), you must use union types to accept both strings and Date objects. This ensures TInput is a superset of TOutput:
+
+```typescript
+const eventSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  scheduled_for: z.union([
+    z.string(),  // Accept ISO string from form input (part of TInput)
+    z.date()     // Accept Date from existing data (TOutput) or programmatic input
+  ]).transform(val =>
+    typeof val === 'string' ? new Date(val) : val
+  )
+})
+// TInput:  { scheduled_for: string | Date }
+// TOutput: { scheduled_for: Date }
+// ✅ TInput is a superset of TOutput (accepts both string and Date)
+
+// Works with string input (new data)
+collection.insert({
+  id: "1",
+  name: "Meeting",
+  scheduled_for: "2024-12-31T15:00:00Z"  // From form input
+})
+
+// Works with Date input (programmatic)
+collection.insert({
+  id: "2",
+  name: "Workshop",
+  scheduled_for: new Date()
+})
+
+// Updates work - scheduled_for is already a Date, and TInput accepts Date
+collection.update("1", (draft) => {
+  draft.name = "Updated Meeting"
+  // draft.scheduled_for is a Date and can be used or modified
+})
+```
+
+---
+
+## Error Handling
+
+When validation fails, TanStack DB throws a `SchemaValidationError` with detailed information.
+
+### Basic Error Handling
+
+```typescript
+import { SchemaValidationError } from '@tanstack/db'
+
+try {
+  collection.insert({
+    id: "1",
+    email: "not-an-email",
+    age: -5
+  })
+} catch (error) {
+  if (error instanceof SchemaValidationError) {
+    console.log(error.type)     // 'insert' or 'update'
+    console.log(error.message)  // "Validation failed with 2 issues"
+    console.log(error.issues)   // Array of validation issues
+  }
+}
+```
+
+### Error Structure
+
+```typescript
+error.issues = [
+  {
+    path: ['email'],
+    message: 'Invalid email address'
+  },
+  {
+    path: ['age'],
+    message: 'Number must be greater than 0'
+  }
+]
+```
+
+### Displaying Errors in UI
+
+```typescript
+const handleSubmit = async (data: unknown) => {
+  try {
+    collection.insert(data)
+  } catch (error) {
+    if (error instanceof SchemaValidationError) {
+      // Show errors by field
+      error.issues.forEach(issue => {
+        const fieldName = issue.path?.join('.') || 'unknown'
+        showFieldError(fieldName, issue.message)
+      })
+    }
+  }
+}
+```
+
+### React Example
+
+```tsx
+import { SchemaValidationError } from '@tanstack/db'
+
+function TodoForm() {
+  const [errors, setErrors] = useState<Record<string, string>>({})
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault()
+    setErrors({})
+
+    try {
+      todoCollection.insert({
+        id: crypto.randomUUID(),
+        text: e.currentTarget.text.value,
+        priority: parseInt(e.currentTarget.priority.value)
+      })
+    } catch (error) {
+      if (error instanceof SchemaValidationError) {
+        const newErrors: Record<string, string> = {}
+        error.issues.forEach(issue => {
+          const field = issue.path?.[0] || 'form'
+          newErrors[field] = issue.message
+        })
+        setErrors(newErrors)
+      }
+    }
+  }
+
+  return (
+    <form onSubmit={handleSubmit}>
+      <input name="text" />
+      {errors.text && <span className="error">{errors.text}</span>}
+
+      <input name="priority" type="number" />
+      {errors.priority && <span className="error">{errors.priority}</span>}
+
+      <button type="submit">Add Todo</button>
+    </form>
+  )
+}
+```
+
+---
+
+## Best Practices
+
+### Keep Transformations Simple
+
+> **Performance Note:** Schema validation is synchronous and runs on every optimistic mutation. For high-frequency updates, keep transformations simple.
+
+```typescript
+// ❌ Avoid expensive operations
+const schema = z.object({
+  data: z.string().transform(val => {
+    // Heavy computation on every mutation
+    return expensiveParsingOperation(val)
+  })
+})
+
+// ✅ Better: Validate only, process elsewhere
+const schema = z.object({
+  data: z.string()  // Simple validation
+})
+
+// Process in component or mutation handler when needed
+const processedData = expensiveParsingOperation(todo.data)
+```
+
+### Use Union Types for Transformations (Essential)
+
+When your schema transforms data to a different type, you **must** use union types to ensure TInput is a superset of TOutput. This is not optional - updates will fail without it.
+
+```typescript
+// ✅ REQUIRED: TInput accepts both string (new data) and Date (existing data)
+const schema = z.object({
+  created_at: z.union([z.string(), z.date()])
+    .transform(val => typeof val === 'string' ? new Date(val) : val)
+})
+// TInput: { created_at: string | Date }
+// TOutput: { created_at: Date }
+
+// ❌ WILL BREAK: Updates fail because draft contains Date but TInput only accepts string
+const schema = z.object({
+  created_at: z.string().transform(val => new Date(val))
+})
+// TInput: { created_at: string }
+// TOutput: { created_at: Date }
+// Problem: collection.update() passes a Date to a schema expecting string!
+```
+
+**Why this is required:** During `collection.update()`, the `draft` object contains TOutput data (already transformed). The schema must accept this data, which means TInput must be a superset of TOutput.
+
+### Validate at the Boundary
+
+Let the collection schema handle validation. Don't duplicate validation logic:
+
+```typescript
+// ❌ Avoid: Duplicate validation
+function addTodo(text: string) {
+  if (!text || text.length < 3) {
+    throw new Error("Text too short")
+  }
+  todoCollection.insert({ id: "1", text })
+}
+
+// ✅ Better: Let schema handle it
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string().min(3, "Text must be at least 3 characters")
+})
+```
+
+### Type Inference
+
+Let TypeScript infer types from your schema:
+
+```typescript
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  completed: z.boolean()
+})
+
+type Todo = z.infer<typeof todoSchema>  // Inferred type
+
+// ✅ Use the inferred type
+const collection = createCollection(
+  queryCollectionOptions({
+    schema: todoSchema,
+    // TypeScript knows the item type automatically
+    getKey: (item) => item.id  // item is Todo
+  })
+)
+```
+
+### Custom Error Messages
+
+Provide helpful error messages for users:
+
+```typescript
+const userSchema = z.object({
+  username: z.string()
+    .min(3, "Username must be at least 3 characters")
+    .max(20, "Username is too long (max 20 characters)")
+    .regex(/^[a-zA-Z0-9_]+$/, "Username can only contain letters, numbers, and underscores"),
+  email: z.string().email("Please enter a valid email address"),
+  age: z.number()
+    .int("Age must be a whole number")
+    .min(13, "You must be at least 13 years old")
+})
+```
+
+---
+
+## Full-Context Examples
+
+### Example 1: Todo App with Rich Types
+
+A complete todo application demonstrating validation, transformations, and defaults:
+
+```typescript
+import { z } from 'zod'
+import { createCollection } from '@tanstack/react-db'
+import { queryCollectionOptions } from '@tanstack/query-db-collection'
+
+// Schema with validation, transformations, and defaults
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string().min(1, "Todo text cannot be empty"),
+  completed: z.boolean().default(false),
+  priority: z.enum(['low', 'medium', 'high']).default('medium'),
+  due_date: z.union([
+    z.string(),
+    z.date()
+  ]).transform(val => typeof val === 'string' ? new Date(val) : val).optional(),
+  created_at: z.union([
+    z.string(),
+    z.date()
+  ]).transform(val => typeof val === 'string' ? new Date(val) : val)
+    .default(() => new Date()),
+  tags: z.array(z.string()).default([])
+})
+
+type Todo = z.infer<typeof todoSchema>
+
+// Collection setup
+const todoCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => {
+      const response = await fetch('/api/todos')
+      const todos = await response.json()
+      // Reuse schema to parse and transform API responses
+      return todos.map((todo: any) => todoSchema.parse(todo))
+    },
+    getKey: (item) => item.id,
+    schema: todoSchema,
+    queryClient,
+
+    onInsert: async ({ transaction }) => {
+      const todo = transaction.mutations[0].modified
+
+      // Serialize dates for API
+      await fetch('/api/todos', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          ...todo,
+          due_date: todo.due_date?.toISOString(),
+          created_at: todo.created_at.toISOString()
+        })
+      })
+    },
+
+    onUpdate: async ({ transaction }) => {
+      await Promise.all(
+        transaction.mutations.map(async (mutation) => {
+          const { original, changes } = mutation
+
+          // Serialize any date fields in changes
+          const serialized = {
+            ...changes,
+            due_date: changes.due_date instanceof Date
+              ? changes.due_date.toISOString()
+              : changes.due_date
+          }
+
+          await fetch(`/api/todos/${original.id}`, {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(serialized)
+          })
+        })
+      )
+    },
+
+    onDelete: async ({ transaction }) => {
+      await Promise.all(
+        transaction.mutations.map(async (mutation) => {
+          await fetch(`/api/todos/${mutation.original.id}`, {
+            method: 'DELETE'
+          })
+        })
+      )
+    }
+  })
+)
+
+// Component usage
+function TodoApp() {
+  const { data: todos } = useLiveQuery(q =>
+    q.from({ todo: todoCollection })
+      .where(({ todo }) => !todo.completed)
+      .orderBy(({ todo }) => todo.created_at, 'desc')
+  )
+
+  const [errors, setErrors] = useState<Record<string, string>>({})
+
+  const addTodo = (text: string, priority: 'low' | 'medium' | 'high') => {
+    try {
+      todoCollection.insert({
+        id: crypto.randomUUID(),
+        text,
+        priority,
+        due_date: "2024-12-31T23:59:59Z"
+        // completed, created_at, tags filled automatically by defaults
+      })
+      setErrors({})
+    } catch (error) {
+      if (error instanceof SchemaValidationError) {
+        const newErrors: Record<string, string> = {}
+        error.issues.forEach(issue => {
+          const field = issue.path?.[0] || 'form'
+          newErrors[field] = issue.message
+        })
+        setErrors(newErrors)
+      }
+    }
+  }
+
+  const toggleComplete = (todo: Todo) => {
+    todoCollection.update(todo.id, (draft) => {
+      draft.completed = !draft.completed
+    })
+  }
+
+  return (
+    <div>
+      <h1>Todos</h1>
+
+      {errors.text && <div className="error">{errors.text}</div>}
+
+      <button onClick={() => addTodo("Buy groceries", "high")}>
+        Add Todo
+      </button>
+
+      <ul>
+        {todos?.map(todo => (
+          <li key={todo.id}>
+            <input
+              type="checkbox"
+              checked={todo.completed}
+              onChange={() => toggleComplete(todo)}
+            />
+            <span>{todo.text}</span>
+            <span>Priority: {todo.priority}</span>
+            {todo.due_date && (
+              <span>Due: {todo.due_date.toLocaleDateString()}</span>
+            )}
+            <span>Created: {todo.created_at.toLocaleDateString()}</span>
+          </li>
+        ))}
+      </ul>
+    </div>
+  )
+}
+```
+
+### Example 2: E-commerce Product with Computed Fields
+
+```typescript
+import { z } from 'zod'
+
+// Schema with computed fields and transformations
+const productSchema = z.object({
+  id: z.string(),
+  name: z.string().min(3, "Product name must be at least 3 characters"),
+  description: z.string().max(500, "Description too long"),
+  base_price: z.number().positive("Price must be positive"),
+  tax_rate: z.number().min(0).max(1).default(0.1),
+  discount_percent: z.number().min(0).max(100).default(0),
+  stock: z.number().int().min(0).default(0),
+  category: z.enum(['electronics', 'clothing', 'food', 'other']),
+  tags: z.array(z.string()).default([]),
+  created_at: z.union([z.string(), z.date()])
+    .transform(val => typeof val === 'string' ? new Date(val) : val)
+    .default(() => new Date())
+}).transform(data => ({
+  ...data,
+  // Computed fields
+  final_price: data.base_price * (1 + data.tax_rate) * (1 - data.discount_percent / 100),
+  in_stock: data.stock > 0,
+  display_price: `$${(data.base_price * (1 + data.tax_rate) * (1 - data.discount_percent / 100)).toFixed(2)}`
+}))
+
+type Product = z.infer<typeof productSchema>
+
+const productCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['products'],
+    queryFn: async () => api.products.getAll(),
+    getKey: (item) => item.id,
+    schema: productSchema,
+    queryClient,
+
+    onInsert: async ({ transaction }) => {
+      const product = transaction.mutations[0].modified
+
+      // API only needs base fields, not computed ones
+      await api.products.create({
+        name: product.name,
+        description: product.description,
+        base_price: product.base_price,
+        tax_rate: product.tax_rate,
+        discount_percent: product.discount_percent,
+        stock: product.stock,
+        category: product.category,
+        tags: product.tags
+      })
+    }
+  })
+)
+
+// Usage
+function ProductList() {
+  const { data: products } = useLiveQuery(q =>
+    q.from({ product: productCollection })
+      .where(({ product }) => product.in_stock)  // Use computed field
+      .orderBy(({ product }) => product.final_price, 'asc')
+  )
+
+  const addProduct = () => {
+    productCollection.insert({
+      id: crypto.randomUUID(),
+      name: "Wireless Mouse",
+      description: "Ergonomic wireless mouse",
+      base_price: 29.99,
+      discount_percent: 10,
+      category: "electronics",
+      stock: 50
+      // tax_rate, tags, created_at filled by defaults
+      // final_price, in_stock, display_price computed automatically
+    })
+  }
+
+  return (
+    <div>
+      {products?.map(product => (
+        <div key={product.id}>
+          <h3>{product.name}</h3>
+          <p>{product.description}</p>
+          <p>Price: {product.display_price}</p>
+          <p>Stock: {product.in_stock ? `${product.stock} available` : 'Out of stock'}</p>
+          <p>Category: {product.category}</p>
+        </div>
+      ))}
+    </div>
+  )
+}
+```
+
+---
+
+## For Integration Authors
+
+If you're building a custom collection (like Electric or TrailBase), you'll need to handle data parsing and serialization between your storage format and the in-memory collection format. This is separate from schema validation, which happens during client mutations.
+
+See the [Collection Options Creator Guide](./collection-options-creator.md) for comprehensive documentation on creating custom collection integrations, including how to handle schemas, data parsing, and type transformations.
+
+---
+
+## Related Topics
+
+- **[Mutations Guide](./mutations.md)** - Learn about optimistic mutations and how schemas validate mutation data
+- **[Error Handling Guide](./error-handling.md)** - Comprehensive guide to handling `SchemaValidationError` and other errors
+- **[Collection Options Creator Guide](./collection-options-creator.md)** - For integration authors: creating custom collection types with schema support
+- **[StandardSchema Specification](https://standardschema.dev)** - Full specification for StandardSchema v1
diff --git a/docs/overview.md b/docs/overview.md
index b5597a335..8af0254c3 100644
--- a/docs/overview.md
+++ b/docs/overview.md
@@ -7,7 +7,30 @@ id: overview
 
 Welcome to the TanStack DB documentation.
 
-TanStack DB is a reactive client store for building super fast apps on sync. It extends TanStack Query with collections, live queries and optimistic mutations.
+TanStack DB is the reactive client store for your API. It solves the problems of building fast, modern apps, helping you:
+
+- avoid endpoint sprawl and network waterfalls by loading data into normalized collections
+- optimise client performance with sub-millisecond live queries and real-time reactivity
+- take the network off the interaction path with instant optimistic writes
+
+Data loading is optimized. Interactions feel instantaneous. Your backend stays simple and your app stays blazing fast. No matter how much data you load.
+
+## Remove the complexity from building fast, modern apps
+
+TanStack DB lets you query your data however your components need it, with a blazing-fast local query engine, real-time reactivity and instant optimistic updates.
+
+Instead of choosing between the least of two evils:
+
+1. **view-specific APIs** - complicating your backend and leading to network waterfalls
+2. **load everything and filter** - leading to slow loads and sluggish client performance
+
+TanStack DB enables a new way:
+
+3. **normalized collections** - keep your backend simple
+4. **query-driven sync** - optimizes your data loading
+5. **sub-millisecond live queries** - keep your app fast and responsive
+
+It extends TanStack Query with collections, live queries and optimistic mutations, working seamlessly with REST APIs, sync engines, or any data source.
 
 ## Contents
 
@@ -64,16 +87,46 @@ Collections can be populated in many ways, including:
 
 - fetching data, for example [from API endpoints using TanStack Query](https://tanstack.com/query/latest)
 - syncing data, for example [using a sync engine like ElectricSQL](https://electric-sql.com/)
-- storing local data, for example [using localStorage for user preferences and settings](#localstoragecollection) or [in-memory client data or UI state](#localonlycollection)
+- storing local data, for example [using localStorage for user preferences and settings](./collections/local-storage-collection.md) or [in-memory client data or UI state](./collections/local-only-collection.md)
 - from live collection queries, creating [derived collections as materialised views](#using-live-queries)
 
 Once you have your data in collections, you can query across them using live queries in your components.
 
+#### Sync Modes
+
+Collections support three sync modes to optimize data loading:
+
+- **Eager mode** (default): Loads entire collection upfront. Best for <10k rows of mostly static data like user preferences or small reference tables.
+- **On-demand mode**: Loads only what queries request. Best for large datasets (>50k rows), search interfaces, and catalogs where most data won't be accessed.
+- **Progressive mode**: Loads query subset immediately, syncs full dataset in background. Best for collaborative apps needing instant first paint AND sub-millisecond queries.
+
+With on-demand mode, your component's query becomes the API call:
+
+```tsx
+const productsCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['products'],
+    queryFn: async (ctx) => {
+      // Query predicates passed automatically in ctx.meta
+      const params = parseLoadSubsetOptions(ctx.meta?.loadSubsetOptions)
+      return api.getProducts(params) // e.g., GET /api/products?category=electronics&price_lt=100
+    },
+    syncMode: 'on-demand', // ← Enable query-driven sync
+  })
+)
+```
+
+TanStack DB automatically collapses duplicate requests, performs delta loading when expanding queries, optimizes joins into minimal batched requests, and respects your TanStack Query cache policies. You often end up with _fewer_ network requests than custom view-specific APIs.
+
+See the [Query Collection documentation](./collections/query-collection.md#queryfn-and-predicate-push-down) for full predicate mapping details.
+
 ### Using live queries
 
 Live queries are used to query data out of collections. Live queries are reactive: when the underlying data changes in a way that would affect the query result, the result is incrementally updated and returned from the query, triggering a re-render.
 
-TanStack DB live queries are implemented using [d2ts](https://github.com/electric-sql/d2ts), a Typescript implementation of differential dataflow. This allows the query results to update _incrementally_ (rather than by re-running the whole query). This makes them blazing fast, usually sub-millisecond, even for highly complex queries.
+TanStack DB live queries are implemented using [d2ts](https://github.com/electric-sql/d2ts), a TypeScript implementation of differential dataflow. This allows the query results to update _incrementally_ (rather than by re-running the whole query). This makes them blazing fast, usually sub-millisecond, even for highly complex queries.
+
+**Performance:** Updating one row in a sorted 100,000-item collection completes in ~0.7ms on an M1 Pro MacBook—fast enough that optimistic updates feel truly instantaneous, even with complex queries and large datasets.
 
 Live queries support joins across collections. This allows you to:
 
@@ -82,7 +135,7 @@ Live queries support joins across collections. This allows you to:
 
 Every query returns another collection which can _also_ be queried.
 
-For more details on live queries, see the [Live Queries](../guides/live-queries.md) documentation.
+For more details on live queries, see the [Live Queries](./guides/live-queries.md) documentation.
 
 ### Making optimistic mutations
 
@@ -109,7 +162,7 @@ The collection maintains optimistic state separately from synced data. When live
 
 The optimistic state is held until the handler resolves, at which point the data is persisted to the server and synced back. If the handler throws an error, the optimistic state is rolled back.
 
-For more complex mutations, you can create custom actions with `createOptimisticAction` or custom transactions with `createTransaction`. See the [Mutations guide](../guides/mutations.md) for details.
+For more complex mutations, you can create custom actions with `createOptimisticAction` or custom transactions with `createTransaction`. See the [Mutations guide](./guides/mutations.md) for details.
 
 ### Uni-directional data flow
 
@@ -127,374 +180,83 @@ With an instant inner loop of optimistic state, superseded in time by the slower
 
 ### Collections
 
-There are a number of built-in collection types:
-
-1. [`QueryCollection`](#querycollection) to load data into collections using [TanStack Query](https://tanstack.com/query)
-2. [`ElectricCollection`](#electriccollection) to sync data into collections using [ElectricSQL](https://electric-sql.com)
-3. [`TrailBaseCollection`](#trailbasecollection) to sync data into collections using [TrailBase](https://trailbase.io)
-4. [`RxDBCollection`](#rxdbcollection) to integrate with [RxDB](https://rxdb.info) for local persistence and sync
-5. [`LocalStorageCollection`](#localstoragecollection) for small amounts of local-only state that syncs across browser tabs
-6. [`LocalOnlyCollection`](#localonlycollection) for in-memory client data or UI state
-
-You can also use:
-
-- use live collection queries to [derive collections from other collections](#derived-collections)
-- the [base Collection](#base-collection) to define your own collection types
+TanStack DB provides several built-in collection types for different data sources and use cases. Each collection type has its own detailed documentation page:
 
-#### Collection schemas
+#### Built-in Collection Types
 
-All collections optionally (though strongly recommended) support adding a `schema`.
-
-If provided, this must be a [Standard Schema](https://standardschema.dev) compatible schema instance, such as a [Zod](https://zod.dev) or [Effect](https://effect.website/docs/schema/introduction/) schema.
+**Fetch Collections**
 
-The collection will use the schema to do client-side validation of optimistic mutations.
+- **[QueryCollection](./collections/query-collection.md)** &mdash; Load data into collections using TanStack Query for REST APIs and data fetching.
 
-The collection will use the schema for its type so if you provide a schema, you can't also pass in an explicit
-type (e.g. `createCollection<Todo>()`).
+**Sync Collections**
 
-#### `QueryCollection`
+- **[ElectricCollection](./collections/electric-collection.md)** &mdash; Sync data into collections from Postgres using ElectricSQL's real-time sync engine.
 
-[TanStack Query](https://tanstack.com/query) fetches data using managed queries. Use `queryCollectionOptions` to fetch data into a collection using TanStack Query:
+- **[TrailBaseCollection](./collections/trailbase-collection.md)** &mdash; Sync data into collections using TrailBase's self-hosted backend with real-time subscriptions.
 
-```ts
-import { createCollection } from "@tanstack/react-db"
-import { queryCollectionOptions } from "@tanstack/query-db-collection"
-
-const todoCollection = createCollection(
-  queryCollectionOptions({
-    queryKey: ["todoItems"],
-    queryFn: async () => {
-      const response = await fetch("/api/todos")
-      return response.json()
-    },
-    getKey: (item) => item.id,
-    schema: todoSchema, // any standard schema
-  })
-)
-```
+- **[RxDBCollection](./collections/rxdb-collection.md)** &mdash; Integrate with RxDB for offline-first local persistence with powerful replication and sync capabilities.
 
-The collection will be populated with the query results.
+- **[PowerSyncCollection](./collections/powersync-collection.md)** &mdash; Sync with PowerSync's SQLite-based database for offline-first persistence with real-time synchronization with PostgreSQL, MongoDB, and MySQL backends.
 
-#### `ElectricCollection`
+**Local Collections**
 
-[Electric](https://electric-sql.com) is a read-path sync engine for Postgres. It allows you to sync subsets of data out of a Postgres database, [through your API](https://electric-sql.com/blog/2024/11/21/local-first-with-your-existing-api), into a TanStack DB collection.
+- **[LocalStorageCollection](./collections/local-storage-collection.md)** &mdash; Store small amounts of local-only state that persists across sessions and syncs across browser tabs.
 
-Electric's main primitive for sync is a [Shape](https://electric-sql.com/docs/guides/shapes). Use `electricCollectionOptions` to sync a shape into a collection:
+- **[LocalOnlyCollection](./collections/local-only-collection.md)** &mdash; Manage in-memory client data or UI state that doesn't need persistence or cross-tab sync.
 
-```ts
-import { createCollection } from "@tanstack/react-db"
-import { electricCollectionOptions } from "@tanstack/electric-db-collection"
+#### Collection Schemas
 
-export const todoCollection = createCollection(
-  electricCollectionOptions({
-    id: "todos",
-    shapeOptions: {
-      url: "https://example.com/v1/shape",
-      params: {
-        table: "todos",
-      },
-    },
-    getKey: (item) => item.id,
-    schema: todoSchema,
-  })
-)
-```
-
-The Electric collection requires two Electric-specific options:
-
-- `shapeOptions` &mdash; the Electric [ShapeStreamOptions](https://electric-sql.com/docs/api/clients/typescript#options) that define the [Shape](https://electric-sql.com/docs/guides/shapes) to sync into the collection; this includes the
-  - `url` to your sync engine; and
-  - `params` to specify the `table` to sync and any optional `where` clauses, etc.
-- `getKey` &mdash; identifies the id for the rows being synced into the collection
-
-A new collections doesn't start syncing until you call `collection.preload()` or you query it.
-
-Electric shapes allow you to filter data using where clauses:
-
-```ts
-export const myPendingTodos = createCollection(
-  electricCollectionOptions({
-    id: "todos",
-    shapeOptions: {
-      url: "https://example.com/v1/shape",
-      params: {
-        table: "todos",
-        where: `
-        status = 'pending'
-        AND
-        user_id = '${user.id}'
-      `,
-      },
-    },
-    getKey: (item) => item.id,
-    schema: todoSchema,
-  })
-)
-```
-
-> [!TIP]
-> Shape where clauses, used to filter the data you sync into `ElectricCollection`s, are different from the [live queries](#live-queries) you use to query data in components.
->
-> Live queries are much more expressive than shapes, allowing you to query across collections, join, aggregate, etc. Shapes just contain filtered database tables and are used to populate the data in a collection.
-
-If you need more control over what data syncs into the collection, Electric allows you to [use your API](https://electric-sql.com/blog/2024/11/21/local-first-with-your-existing-api#filtering) as a proxy to both authorize and filter data.
-
-See the [Electric docs](https://electric-sql.com/docs/intro) for more information.
-
-#### `TrailBaseCollection`
-
-[TrailBase](https://trailbase.io) is an easy-to-self-host, single-executable application backend with built-in SQLite, a V8 JS runtime, auth, admin UIs and sync functionality.
-
-TrailBase lets you expose tables via [Record APIs](https://trailbase.io/documentation/apis_record/) and subscribe to changes when `enable_subscriptions` is set. Use `trailBaseCollectionOptions` to sync records into a collection:
-
-```ts
-import { createCollection } from "@tanstack/react-db"
-import { trailBaseCollectionOptions } from "@tanstack/trailbase-db-collection"
-import { initClient } from "trailbase"
-
-const trailBaseClient = initClient(`https://trailbase.io`)
-
-export const todoCollection = createCollection<SelectTodo, Todo>(
-  trailBaseCollectionOptions({
-    id: "todos",
-    recordApi: trailBaseClient.records(`todos`),
-    getKey: (item) => item.id,
-    schema: todoSchema,
-    parse: {
-      created_at: (ts) => new Date(ts * 1000),
-    },
-    serialize: {
-      created_at: (date) => Math.floor(date.valueOf() / 1000),
-    },
-  })
-)
-```
-
-This collection requires the following TrailBase-specific options:
-
-- `recordApi` — identifies the API to sync.
-- `getKey` — identifies the id for the records being synced into the collection.
-- `parse` — maps `(v: Todo[k]) => SelectTodo[k]`.
-- `serialize` — maps `(v: SelectTodo[k]) => Todo[k]`.
-
-A new collections doesn't start syncing until you call `collection.preload()` or you query it.
+All collections optionally (though strongly recommended) support adding a `schema`.
 
-#### `RxDBCollection`
+If provided, this must be a [Standard Schema](https://standardschema.dev) compatible schema instance, such as [Zod](https://zod.dev), [Valibot](https://valibot.dev), [ArkType](https://arktype.io), or [Effect](https://effect.website/docs/schema/introduction/).
 
-[RxDB](https://rxdb.info) is a client-side database for JavaScript apps with replication, conflict resolution, and offline-first features.  
-Use `rxdbCollectionOptions` from `@tanstack/rxdb-db-collection` to integrate an RxDB collection with TanStack DB:
+**What schemas do:**
 
-```ts
-import { createCollection } from "@tanstack/react-db"
-import { rxdbCollectionOptions } from "@tanstack/rxdb-db-collection"
-import { createRxDatabase } from "rxdb"
+1. **Runtime validation** - Ensures data meets your constraints before entering the collection
+2. **Type transformations** - Convert input types to rich output types (e.g., string → Date)
+3. **Default values** - Automatically populate missing fields
+4. **Type safety** - Infer TypeScript types from your schema
 
-const db = await createRxDatabase({
-  name: "mydb",
-  storage: getRxStorageMemory(),
-})
-await db.addCollections({
-  todos: {
-    schema: {
-      version: 0,
-      primaryKey: "id",
-      type: "object",
-      properties: {
-        id: { type: "string", maxLength: 100 },
-        text: { type: "string" },
-        completed: { type: "boolean" },
-      },
-    },
-  },
+**Example:**
+```typescript
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  completed: z.boolean().default(false),
+  created_at: z.string().transform(val => new Date(val)),  // string → Date
+  priority: z.number().default(0)
 })
 
-// Wrap the RxDB collection with TanStack DB
-export const todoCollection = createCollection(
-  rxdbCollectionOptions({
-    rxCollection: db.todos,
-    startSync: true,
-  })
-)
-```
-
-With this integration:
-
-- TanStack DB subscribes to RxDB's change streams and reflects updates, deletes, and inserts in real-time.
-- You get local-first sync when RxDB replication is configured.
-- Mutation handlers (onInsert, onUpdate, onDelete) are implemented using RxDB's APIs (bulkUpsert, incrementalPatch, bulkRemove).
-
-This makes RxDB a great choice for apps that need local-first storage, replication, or peer-to-peer sync combined with TanStack DB's live queries and transaction lifecycle.
-
-#### `LocalStorageCollection`
-
-localStorage collections store small amounts of local-only state that persists across browser sessions and syncs across browser tabs in real-time. All data is stored under a single localStorage key and automatically synchronized using storage events.
-
-Use `localStorageCollectionOptions` to create a collection that stores data in localStorage:
-
-```ts
-import { createCollection } from "@tanstack/react-db"
-import { localStorageCollectionOptions } from "@tanstack/react-db"
-
-export const userPreferencesCollection = createCollection(
-  localStorageCollectionOptions({
-    id: "user-preferences",
-    storageKey: "app-user-prefs", // localStorage key
-    getKey: (item) => item.id,
-    schema: userPrefsSchema,
-  })
-)
-```
-
-The localStorage collection requires:
-
-- `storageKey` — the localStorage key where all collection data is stored
-- `getKey` — identifies the id for items in the collection
-
-Mutation handlers (`onInsert`, `onUpdate`, `onDelete`) are completely optional. Data will persist to localStorage whether or not you provide handlers. You can provide alternative storage backends like `sessionStorage` or custom implementations that match the localStorage API.
-
-```ts
-export const sessionCollection = createCollection(
-  localStorageCollectionOptions({
-    id: "session-data",
-    storageKey: "session-key",
-    storage: sessionStorage, // Use sessionStorage instead
-    getKey: (item) => item.id,
-  })
-)
-```
-
-> [!TIP]
-> localStorage collections are perfect for user preferences, UI state, and other data that should persist locally but doesn't need server synchronization. For server-synchronized data, use [`QueryCollection`](#querycollection) or [`ElectricCollection`](#electriccollection) instead.
-
-#### `LocalOnlyCollection`
-
-LocalOnly collections are designed for in-memory client data or UI state that doesn't need to persist across browser sessions or sync across tabs. They provide a simple way to manage temporary, session-only data with full optimistic mutation support.
-
-Use `localOnlyCollectionOptions` to create a collection that stores data only in memory:
-
-```ts
-import { createCollection } from "@tanstack/react-db"
-import { localOnlyCollectionOptions } from "@tanstack/react-db"
-
-export const uiStateCollection = createCollection(
-  localOnlyCollectionOptions({
-    id: "ui-state",
-    getKey: (item) => item.id,
-    schema: uiStateSchema,
-    // Optional initial data to populate the collection
-    initialData: [
-      { id: "sidebar", isOpen: false },
-      { id: "theme", mode: "light" },
-    ],
-  })
-)
-```
-
-The LocalOnly collection requires:
-
-- `getKey` — identifies the id for items in the collection
-
-Optional configuration:
-
-- `initialData` — array of items to populate the collection with on creation
-- `onInsert`, `onUpdate`, `onDelete` — optional mutation handlers for custom logic
-
-Mutation handlers are completely optional. When provided, they are called before the optimistic state is confirmed. The collection automatically manages the transition from optimistic to confirmed state internally.
-
-```ts
-export const tempDataCollection = createCollection(
-  localOnlyCollectionOptions({
-    id: "temp-data",
-    getKey: (item) => item.id,
-    onInsert: async ({ transaction }) => {
-      // Custom logic before confirming the insert
-      console.log("Inserting:", transaction.mutations[0].modified)
-    },
-    onUpdate: async ({ transaction }) => {
-      // Custom logic before confirming the update
-      const { original, modified } = transaction.mutations[0]
-      console.log("Updating from", original, "to", modified)
-    },
-  })
-)
-```
-
-> [!TIP]
-> LocalOnly collections are perfect for temporary UI state, form data, or any client-side data that doesn't need persistence. For data that should persist across sessions, use [`LocalStorageCollection`](#localstoragecollection) instead.
-
-**Using LocalStorage and LocalOnly Collections with Manual Transactions:**
-
-When using either LocalStorage or LocalOnly collections with manual transactions (created via `createTransaction`), you must call `utils.acceptMutations()` in your transaction's `mutationFn` to persist the changes. This is necessary because these collections don't participate in the standard mutation handler flow for manual transactions.
-
-```ts
-import { createTransaction } from "@tanstack/react-db"
-
-const localData = createCollection(
-  localOnlyCollectionOptions({
-    id: "form-draft",
-    getKey: (item) => item.id,
-  })
-)
-
-const serverCollection = createCollection(
+const collection = createCollection(
   queryCollectionOptions({
-    queryKey: ["items"],
-    queryFn: async () => api.items.getAll(),
-    getKey: (item) => item.id,
-    onInsert: async ({ transaction }) => {
-      await api.items.create(transaction.mutations[0].modified)
-    },
+    schema: todoSchema,
+    // ...
   })
 )
 
-const tx = createTransaction({
-  mutationFn: async ({ transaction }) => {
-    // Server collection mutations are handled by their onInsert handler automatically
-    // (onInsert will be called and awaited)
-
-    // After server mutations succeed, persist local collection mutations
-    localData.utils.acceptMutations(transaction)
-  },
-})
-
-// Apply mutations to both collections in one transaction
-tx.mutate(() => {
-  localData.insert({ id: "draft-1", data: "..." })
-  serverCollection.insert({ id: "1", name: "Item" })
+// Users provide simple inputs
+collection.insert({
+  id: "1",
+  text: "Buy groceries",
+  created_at: "2024-01-01T00:00:00Z"  // string
+  // completed and priority filled automatically
 })
 
-await tx.commit()
+// Collection stores and returns rich types
+const todo = collection.get("1")
+console.log(todo.created_at.getFullYear())  // It's a Date!
+console.log(todo.completed)  // false (default)
 ```
 
-#### Derived collections
+The collection will use the schema for its type inference. If you provide a schema, you cannot also pass an explicit type parameter (e.g., `createCollection<Todo>()`).
 
-Live queries return collections. This allows you to derive collections from other collections.
+**Learn more:** See the [Schemas guide](./guides/schemas.md) for comprehensive documentation on schema validation, type transformations, and best practices.
 
-For example:
+#### Creating Custom Collection Types
 
-```ts
-import { createLiveQueryCollection, eq } from "@tanstack/db"
+You can create your own collection types by implementing the `Collection` interface found in [`../packages/db/src/collection/index.ts`](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts).
 
-// Imagine you have a collection of todos.
-const todoCollection = createCollection({
-  // config
-})
-
-// You can derive a new collection that's a subset of it.
-const completedTodoCollection = createLiveQueryCollection({
-  startSync: true,
-  query: (q) =>
-    q.from({ todo: todoCollection }).where(({ todo }) => todo.completed),
-})
-```
-
-This also works with joins to derive collections from multiple source collections. And it works recursively -- you can derive collections from other derived collections. Changes propagate efficiently using differential dataflow and it's collections all the way down.
-
-#### Collection
-
-There is a `Collection` interface in [`../packages/db/src/collection.ts`](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts). You can use this to implement your own collection types.
-
-See the existing implementations in [`../packages/db`](https://github.com/TanStack/db/tree/main/packages/db), [`../packages/query-db-collection`](https://github.com/TanStack/db/tree/main/packages/query-db-collection), [`../packages/electric-db-collection`](https://github.com/TanStack/db/tree/main/packages/electric-db-collection) and [`../packages/trailbase-db-collection`](https://github.com/TanStack/db/tree/main/packages/trailbase-db-collection) for reference.
+See the existing implementations in [`../packages/db`](https://github.com/TanStack/db/tree/main/packages/db), [`../packages/query-db-collection`](https://github.com/TanStack/db/tree/main/packages/query-db-collection), [`../packages/electric-db-collection`](https://github.com/TanStack/db/tree/main/packages/electric-db-collection) and [`../packages/trailbase-db-collection`](https://github.com/TanStack/db/tree/main/packages/trailbase-db-collection) for reference. Also see the [Collection Options Creator guide](./guides/collection-options-creator.md) for a pattern to create reusable collection configuration factories.
 
 ### Live queries
 
@@ -549,6 +311,34 @@ const Todos = () => {
 }
 ```
 
+#### `useLiveSuspenseQuery` hook
+
+For React Suspense support, use `useLiveSuspenseQuery`. This hook suspends rendering during initial data load and guarantees that `data` is always defined:
+
+```tsx
+import { useLiveSuspenseQuery } from '@tanstack/react-db'
+import { Suspense } from 'react'
+
+const Todos = () => {
+  // data is always defined - no need for optional chaining
+  const { data: todos } = useLiveSuspenseQuery((q) =>
+    q
+      .from({ todo: todoCollection })
+      .where(({ todo }) => eq(todo.completed, false))
+  )
+
+  return <List items={ todos } />
+}
+
+const App = () => (
+  <Suspense fallback={<div>Loading...</div>}>
+    <Todos />
+  </Suspense>
+)
+```
+
+See the [React Suspense section in Live Queries](./guides/live-queries#using-with-react-suspense) for detailed usage patterns and when to use `useLiveSuspenseQuery` vs `useLiveQuery`.
+
 #### `queryBuilder`
 
 You can also build queries directly (outside of the component lifecycle) using the underlying `queryBuilder` API:
@@ -572,13 +362,13 @@ Note also that:
 1. the query results [are themselves a collection](#derived-collections)
 2. the `useLiveQuery` automatically starts and stops live query subscriptions when you mount and unmount your components; if you're creating queries manually, you need to manually manage the subscription lifecycle yourself
 
-See the [Live Queries](../guides/live-queries.md) documentation for more details.
+See the [Live Queries](./guides/live-queries.md) documentation for more details.
 
 ### Transactional mutators
 
 For more complex mutations beyond simple CRUD operations, TanStack DB provides `createOptimisticAction` and `createTransaction` for creating custom mutations with full control over the mutation lifecycle.
 
-See the [Mutations guide](../guides/mutations.md) for comprehensive documentation on:
+See the [Mutations guide](./guides/mutations.md) for comprehensive documentation on:
 
 - Creating custom actions with `createOptimisticAction`
 - Manual transactions with `createTransaction`
@@ -592,7 +382,7 @@ See the [Mutations guide](../guides/mutations.md) for comprehensive documentatio
 Here we illustrate two common ways of using TanStack DB:
 
 1. [using TanStack Query](#1-tanstack-query) with an existing REST API
-2. [using the ElectricSQL sync engine](#2-electricsql-sync) with a generic ingestion endpoint
+2. [using the ElectricSQL sync engine](#2-electricsql-sync) for real-time sync with your existing API
 
 > [!TIP]
 > You can combine these patterns. One of the benefits of TanStack DB is that you can integrate different ways of loading data and handling mutations into the same app. Your components don't need to know where the data came from or goes.
@@ -603,8 +393,8 @@ You can use TanStack DB with your existing REST API via TanStack Query.
 
 The steps are to:
 
-1. create [`QueryCollection`](#querycollection)s that load data using TanStack Query
-2. implement [`mutationFn`](#mutationfn)s that handle mutations by posting them to your API endpoints
+1. create [QueryCollection](./collections/query-collection.md)s that load data using TanStack Query
+2. implement mutation handlers that handle mutations by posting them to your API endpoints
 
 ```tsx
 import { useLiveQuery, createCollection } from "@tanstack/react-db"
@@ -673,6 +463,16 @@ This pattern allows you to extend an existing TanStack Query application, or any
 
 One of the most powerful ways of using TanStack DB is with a sync engine, for a fully local-first experience with real-time sync. This allows you to incrementally adopt sync into an existing app, whilst still handling writes with your existing API.
 
+#### Why Sync Engines?
+
+While TanStack DB works great with REST APIs, sync engines provide powerful benefits:
+
+- **Easy real-time updates**: No WebSocket plumbing—write to your database and changes stream automatically to all clients
+- **Automatic side-effects**: When a mutation triggers cascading changes across tables, all affected data syncs automatically without manual cache invalidation
+- **Efficient delta updates**: Only changed rows cross the wire, making it practical to load large datasets client-side
+
+This pattern enables the "load everything once" approach that makes apps like Linear and Figma feel instant.
+
 Here, we illustrate this pattern using [ElectricSQL](https://electric-sql.com) as the sync engine.
 
 ```tsx
diff --git a/docs/quick-start.md b/docs/quick-start.md
index 7973803cb..ea6799974 100644
--- a/docs/quick-start.md
+++ b/docs/quick-start.md
@@ -3,10 +3,10 @@ title: Quick Start
 id: quick-start
 ---
 
-TanStack DB is a reactive client store for building super fast apps. This example will show you how to:
+TanStack DB is the reactive client-first store for your API. Stop building custom endpoints for every view—query your data however your components need it. This example will show you how to:
 
 - **Load data** into collections using TanStack Query
-- **Query data** with blazing fast live queries
+- **Query data** with blazing-fast live queries
 - **Mutate data** with instant optimistic updates
 
 ```tsx
@@ -178,6 +178,6 @@ You now understand the basics of TanStack DB! The collection loads and persists
 
 Explore the docs to learn more about:
 
-- **[Installation](../installation.md)** - All framework and collection packages
-- **[Overview](../overview.md)** - Complete feature overview and examples
-- **[Live Queries](../guides/live-queries.md)** - Advanced querying, joins, and aggregations
+- **[Installation](./installation.md)** - All framework and collection packages
+- **[Overview](./overview.md)** - Complete feature overview and examples
+- **[Live Queries](./guides/live-queries.md)** - Advanced querying, joins, and aggregations
diff --git a/docs/reference/@tanstack/namespaces/IR/classes/Aggregate.md b/docs/reference/@tanstack/namespaces/IR/classes/Aggregate.md
new file mode 100644
index 000000000..75915c41c
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/classes/Aggregate.md
@@ -0,0 +1,104 @@
+---
+id: Aggregate
+title: Aggregate
+---
+
+# Class: Aggregate\<T\>
+
+Defined in: [packages/db/src/query/ir.ts:125](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L125)
+
+## Extends
+
+- `BaseExpression`\<`T`\>
+
+## Type Parameters
+
+### T
+
+`T` = `any`
+
+## Constructors
+
+### Constructor
+
+```ts
+new Aggregate<T>(name, args): Aggregate<T>;
+```
+
+Defined in: [packages/db/src/query/ir.ts:127](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L127)
+
+#### Parameters
+
+##### name
+
+`string`
+
+##### args
+
+[`BasicExpression`](../type-aliases/BasicExpression.md)\<`any`\>[]
+
+#### Returns
+
+`Aggregate`\<`T`\>
+
+#### Overrides
+
+```ts
+BaseExpression<T>.constructor
+```
+
+## Properties
+
+### \_\_returnType
+
+```ts
+readonly __returnType: T;
+```
+
+Defined in: [packages/db/src/query/ir.ts:69](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L69)
+
+**`Internal`**
+
+- Type brand for TypeScript inference
+
+#### Inherited from
+
+```ts
+BaseExpression.__returnType
+```
+
+***
+
+### args
+
+```ts
+args: BasicExpression<any>[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:129](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L129)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: [packages/db/src/query/ir.ts:128](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L128)
+
+***
+
+### type
+
+```ts
+type: "agg";
+```
+
+Defined in: [packages/db/src/query/ir.ts:126](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L126)
+
+#### Overrides
+
+```ts
+BaseExpression.type
+```
diff --git a/docs/reference/@tanstack/namespaces/IR/classes/CollectionRef.md b/docs/reference/@tanstack/namespaces/IR/classes/CollectionRef.md
new file mode 100644
index 000000000..1550a7e6f
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/classes/CollectionRef.md
@@ -0,0 +1,98 @@
+---
+id: CollectionRef
+title: CollectionRef
+---
+
+# Class: CollectionRef
+
+Defined in: [packages/db/src/query/ir.ts:72](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L72)
+
+## Extends
+
+- `BaseExpression`
+
+## Constructors
+
+### Constructor
+
+```ts
+new CollectionRef(collection, alias): CollectionRef;
+```
+
+Defined in: [packages/db/src/query/ir.ts:74](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L74)
+
+#### Parameters
+
+##### collection
+
+[`CollectionImpl`](../../../../classes/CollectionImpl.md)
+
+##### alias
+
+`string`
+
+#### Returns
+
+`CollectionRef`
+
+#### Overrides
+
+```ts
+BaseExpression.constructor
+```
+
+## Properties
+
+### \_\_returnType
+
+```ts
+readonly __returnType: any;
+```
+
+Defined in: [packages/db/src/query/ir.ts:69](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L69)
+
+**`Internal`**
+
+- Type brand for TypeScript inference
+
+#### Inherited from
+
+```ts
+BaseExpression.__returnType
+```
+
+***
+
+### alias
+
+```ts
+alias: string;
+```
+
+Defined in: [packages/db/src/query/ir.ts:76](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L76)
+
+***
+
+### collection
+
+```ts
+collection: CollectionImpl;
+```
+
+Defined in: [packages/db/src/query/ir.ts:75](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L75)
+
+***
+
+### type
+
+```ts
+type: "collectionRef";
+```
+
+Defined in: [packages/db/src/query/ir.ts:73](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L73)
+
+#### Overrides
+
+```ts
+BaseExpression.type
+```
diff --git a/docs/reference/@tanstack/namespaces/IR/classes/Func.md b/docs/reference/@tanstack/namespaces/IR/classes/Func.md
new file mode 100644
index 000000000..37fe6c377
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/classes/Func.md
@@ -0,0 +1,104 @@
+---
+id: Func
+title: Func
+---
+
+# Class: Func\<T\>
+
+Defined in: [packages/db/src/query/ir.ts:110](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L110)
+
+## Extends
+
+- `BaseExpression`\<`T`\>
+
+## Type Parameters
+
+### T
+
+`T` = `any`
+
+## Constructors
+
+### Constructor
+
+```ts
+new Func<T>(name, args): Func<T>;
+```
+
+Defined in: [packages/db/src/query/ir.ts:112](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L112)
+
+#### Parameters
+
+##### name
+
+`string`
+
+##### args
+
+[`BasicExpression`](../type-aliases/BasicExpression.md)\<`any`\>[]
+
+#### Returns
+
+`Func`\<`T`\>
+
+#### Overrides
+
+```ts
+BaseExpression<T>.constructor
+```
+
+## Properties
+
+### \_\_returnType
+
+```ts
+readonly __returnType: T;
+```
+
+Defined in: [packages/db/src/query/ir.ts:69](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L69)
+
+**`Internal`**
+
+- Type brand for TypeScript inference
+
+#### Inherited from
+
+```ts
+BaseExpression.__returnType
+```
+
+***
+
+### args
+
+```ts
+args: BasicExpression<any>[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:114](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L114)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: [packages/db/src/query/ir.ts:113](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L113)
+
+***
+
+### type
+
+```ts
+type: "func";
+```
+
+Defined in: [packages/db/src/query/ir.ts:111](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L111)
+
+#### Overrides
+
+```ts
+BaseExpression.type
+```
diff --git a/docs/reference/@tanstack/namespaces/IR/classes/PropRef.md b/docs/reference/@tanstack/namespaces/IR/classes/PropRef.md
new file mode 100644
index 000000000..ac7bfd418
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/classes/PropRef.md
@@ -0,0 +1,90 @@
+---
+id: PropRef
+title: PropRef
+---
+
+# Class: PropRef\<T\>
+
+Defined in: [packages/db/src/query/ir.ts:92](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L92)
+
+## Extends
+
+- `BaseExpression`\<`T`\>
+
+## Type Parameters
+
+### T
+
+`T` = `any`
+
+## Constructors
+
+### Constructor
+
+```ts
+new PropRef<T>(path): PropRef<T>;
+```
+
+Defined in: [packages/db/src/query/ir.ts:94](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L94)
+
+#### Parameters
+
+##### path
+
+`string`[]
+
+#### Returns
+
+`PropRef`\<`T`\>
+
+#### Overrides
+
+```ts
+BaseExpression<T>.constructor
+```
+
+## Properties
+
+### \_\_returnType
+
+```ts
+readonly __returnType: T;
+```
+
+Defined in: [packages/db/src/query/ir.ts:69](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L69)
+
+**`Internal`**
+
+- Type brand for TypeScript inference
+
+#### Inherited from
+
+```ts
+BaseExpression.__returnType
+```
+
+***
+
+### path
+
+```ts
+path: string[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:95](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L95)
+
+***
+
+### type
+
+```ts
+type: "ref";
+```
+
+Defined in: [packages/db/src/query/ir.ts:93](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L93)
+
+#### Overrides
+
+```ts
+BaseExpression.type
+```
diff --git a/docs/reference/@tanstack/namespaces/IR/classes/QueryRef.md b/docs/reference/@tanstack/namespaces/IR/classes/QueryRef.md
new file mode 100644
index 000000000..5f29109ba
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/classes/QueryRef.md
@@ -0,0 +1,98 @@
+---
+id: QueryRef
+title: QueryRef
+---
+
+# Class: QueryRef
+
+Defined in: [packages/db/src/query/ir.ts:82](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L82)
+
+## Extends
+
+- `BaseExpression`
+
+## Constructors
+
+### Constructor
+
+```ts
+new QueryRef(query, alias): QueryRef;
+```
+
+Defined in: [packages/db/src/query/ir.ts:84](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L84)
+
+#### Parameters
+
+##### query
+
+[`QueryIR`](../interfaces/QueryIR.md)
+
+##### alias
+
+`string`
+
+#### Returns
+
+`QueryRef`
+
+#### Overrides
+
+```ts
+BaseExpression.constructor
+```
+
+## Properties
+
+### \_\_returnType
+
+```ts
+readonly __returnType: any;
+```
+
+Defined in: [packages/db/src/query/ir.ts:69](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L69)
+
+**`Internal`**
+
+- Type brand for TypeScript inference
+
+#### Inherited from
+
+```ts
+BaseExpression.__returnType
+```
+
+***
+
+### alias
+
+```ts
+alias: string;
+```
+
+Defined in: [packages/db/src/query/ir.ts:86](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L86)
+
+***
+
+### query
+
+```ts
+query: QueryIR;
+```
+
+Defined in: [packages/db/src/query/ir.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L85)
+
+***
+
+### type
+
+```ts
+type: "queryRef";
+```
+
+Defined in: [packages/db/src/query/ir.ts:83](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L83)
+
+#### Overrides
+
+```ts
+BaseExpression.type
+```
diff --git a/docs/reference/@tanstack/namespaces/IR/classes/Value.md b/docs/reference/@tanstack/namespaces/IR/classes/Value.md
new file mode 100644
index 000000000..448308304
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/classes/Value.md
@@ -0,0 +1,90 @@
+---
+id: Value
+title: Value
+---
+
+# Class: Value\<T\>
+
+Defined in: [packages/db/src/query/ir.ts:101](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L101)
+
+## Extends
+
+- `BaseExpression`\<`T`\>
+
+## Type Parameters
+
+### T
+
+`T` = `any`
+
+## Constructors
+
+### Constructor
+
+```ts
+new Value<T>(value): Value<T>;
+```
+
+Defined in: [packages/db/src/query/ir.ts:103](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L103)
+
+#### Parameters
+
+##### value
+
+`T`
+
+#### Returns
+
+`Value`\<`T`\>
+
+#### Overrides
+
+```ts
+BaseExpression<T>.constructor
+```
+
+## Properties
+
+### \_\_returnType
+
+```ts
+readonly __returnType: T;
+```
+
+Defined in: [packages/db/src/query/ir.ts:69](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L69)
+
+**`Internal`**
+
+- Type brand for TypeScript inference
+
+#### Inherited from
+
+```ts
+BaseExpression.__returnType
+```
+
+***
+
+### type
+
+```ts
+type: "val";
+```
+
+Defined in: [packages/db/src/query/ir.ts:102](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L102)
+
+#### Overrides
+
+```ts
+BaseExpression.type
+```
+
+***
+
+### value
+
+```ts
+value: T;
+```
+
+Defined in: [packages/db/src/query/ir.ts:104](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L104)
diff --git a/docs/reference/@tanstack/namespaces/IR/functions/createResidualWhere.md b/docs/reference/@tanstack/namespaces/IR/functions/createResidualWhere.md
new file mode 100644
index 000000000..93851c21c
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/functions/createResidualWhere.md
@@ -0,0 +1,24 @@
+---
+id: createResidualWhere
+title: createResidualWhere
+---
+
+# Function: createResidualWhere()
+
+```ts
+function createResidualWhere(expression): Where;
+```
+
+Defined in: [packages/db/src/query/ir.ts:187](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L187)
+
+Create a residual Where clause from an expression
+
+## Parameters
+
+### expression
+
+[`BasicExpression`](../type-aliases/BasicExpression.md)\<`boolean`\>
+
+## Returns
+
+[`Where`](../type-aliases/Where.md)
diff --git a/docs/reference/@tanstack/namespaces/IR/functions/followRef.md b/docs/reference/@tanstack/namespaces/IR/functions/followRef.md
new file mode 100644
index 000000000..3147d38c1
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/functions/followRef.md
@@ -0,0 +1,47 @@
+---
+id: followRef
+title: followRef
+---
+
+# Function: followRef()
+
+```ts
+function followRef(
+   query, 
+   ref, 
+   collection): 
+  | void
+  | {
+  collection: Collection;
+  path: string[];
+};
+```
+
+Defined in: [packages/db/src/query/ir.ts:213](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L213)
+
+Follows the given reference in a query
+until its finds the root field the reference points to.
+
+## Parameters
+
+### query
+
+[`QueryIR`](../interfaces/QueryIR.md)
+
+### ref
+
+[`PropRef`](../classes/PropRef.md)\<`any`\>
+
+### collection
+
+[`Collection`](../../../../interfaces/Collection.md)
+
+## Returns
+
+  \| `void`
+  \| \{
+  `collection`: [`Collection`](../../../../interfaces/Collection.md);
+  `path`: `string`[];
+\}
+
+The collection, its alias, and the path to the root field in this collection
diff --git a/docs/reference/@tanstack/namespaces/IR/functions/getHavingExpression.md b/docs/reference/@tanstack/namespaces/IR/functions/getHavingExpression.md
new file mode 100644
index 000000000..a52e0646a
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/functions/getHavingExpression.md
@@ -0,0 +1,28 @@
+---
+id: getHavingExpression
+title: getHavingExpression
+---
+
+# Function: getHavingExpression()
+
+```ts
+function getHavingExpression(having): 
+  | Aggregate<any>
+| BasicExpression<any>;
+```
+
+Defined in: [packages/db/src/query/ir.ts:165](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L165)
+
+Extract the expression from a HAVING clause
+HAVING clauses can contain aggregates, unlike regular WHERE clauses
+
+## Parameters
+
+### having
+
+[`Where`](../type-aliases/Where.md)
+
+## Returns
+
+  \| [`Aggregate`](../classes/Aggregate.md)\<`any`\>
+  \| [`BasicExpression`](../type-aliases/BasicExpression.md)\<`any`\>
diff --git a/docs/reference/@tanstack/namespaces/IR/functions/getWhereExpression.md b/docs/reference/@tanstack/namespaces/IR/functions/getWhereExpression.md
new file mode 100644
index 000000000..41bb467a8
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/functions/getWhereExpression.md
@@ -0,0 +1,24 @@
+---
+id: getWhereExpression
+title: getWhereExpression
+---
+
+# Function: getWhereExpression()
+
+```ts
+function getWhereExpression(where): BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/query/ir.ts:155](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L155)
+
+Extract the expression from a Where clause
+
+## Parameters
+
+### where
+
+[`Where`](../type-aliases/Where.md)
+
+## Returns
+
+[`BasicExpression`](../type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/@tanstack/namespaces/IR/functions/isExpressionLike.md b/docs/reference/@tanstack/namespaces/IR/functions/isExpressionLike.md
new file mode 100644
index 000000000..a9e580e1a
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/functions/isExpressionLike.md
@@ -0,0 +1,25 @@
+---
+id: isExpressionLike
+title: isExpressionLike
+---
+
+# Function: isExpressionLike()
+
+```ts
+function isExpressionLike(value): boolean;
+```
+
+Defined in: [packages/db/src/query/ir.ts:139](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L139)
+
+Runtime helper to detect IR expression-like objects.
+Prefer this over ad-hoc local implementations to keep behavior consistent.
+
+## Parameters
+
+### value
+
+`any`
+
+## Returns
+
+`boolean`
diff --git a/docs/reference/@tanstack/namespaces/IR/functions/isResidualWhere.md b/docs/reference/@tanstack/namespaces/IR/functions/isResidualWhere.md
new file mode 100644
index 000000000..28f2a059c
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/functions/isResidualWhere.md
@@ -0,0 +1,24 @@
+---
+id: isResidualWhere
+title: isResidualWhere
+---
+
+# Function: isResidualWhere()
+
+```ts
+function isResidualWhere(where): boolean;
+```
+
+Defined in: [packages/db/src/query/ir.ts:176](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L176)
+
+Check if a Where clause is marked as residual
+
+## Parameters
+
+### where
+
+[`Where`](../type-aliases/Where.md)
+
+## Returns
+
+`boolean`
diff --git a/docs/reference/@tanstack/namespaces/IR/index.md b/docs/reference/@tanstack/namespaces/IR/index.md
new file mode 100644
index 000000000..2e6b180ed
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/index.md
@@ -0,0 +1,44 @@
+---
+id: IR
+title: IR
+---
+
+# IR
+
+## Classes
+
+- [Aggregate](classes/Aggregate.md)
+- [CollectionRef](classes/CollectionRef.md)
+- [Func](classes/Func.md)
+- [PropRef](classes/PropRef.md)
+- [QueryRef](classes/QueryRef.md)
+- [Value](classes/Value.md)
+
+## Interfaces
+
+- [JoinClause](interfaces/JoinClause.md)
+- [QueryIR](interfaces/QueryIR.md)
+
+## Type Aliases
+
+- [BasicExpression](type-aliases/BasicExpression.md)
+- [From](type-aliases/From.md)
+- [GroupBy](type-aliases/GroupBy.md)
+- [Having](type-aliases/Having.md)
+- [Join](type-aliases/Join.md)
+- [Limit](type-aliases/Limit.md)
+- [Offset](type-aliases/Offset.md)
+- [OrderBy](type-aliases/OrderBy.md)
+- [OrderByClause](type-aliases/OrderByClause.md)
+- [OrderByDirection](type-aliases/OrderByDirection.md)
+- [Select](type-aliases/Select.md)
+- [Where](type-aliases/Where.md)
+
+## Functions
+
+- [createResidualWhere](functions/createResidualWhere.md)
+- [followRef](functions/followRef.md)
+- [getHavingExpression](functions/getHavingExpression.md)
+- [getWhereExpression](functions/getWhereExpression.md)
+- [isExpressionLike](functions/isExpressionLike.md)
+- [isResidualWhere](functions/isResidualWhere.md)
diff --git a/docs/reference/@tanstack/namespaces/IR/interfaces/JoinClause.md b/docs/reference/@tanstack/namespaces/IR/interfaces/JoinClause.md
new file mode 100644
index 000000000..0ba211c77
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/interfaces/JoinClause.md
@@ -0,0 +1,50 @@
+---
+id: JoinClause
+title: JoinClause
+---
+
+# Interface: JoinClause
+
+Defined in: [packages/db/src/query/ir.ts:36](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L36)
+
+## Properties
+
+### from
+
+```ts
+from: 
+  | CollectionRef
+  | QueryRef;
+```
+
+Defined in: [packages/db/src/query/ir.ts:37](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L37)
+
+***
+
+### left
+
+```ts
+left: BasicExpression;
+```
+
+Defined in: [packages/db/src/query/ir.ts:39](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L39)
+
+***
+
+### right
+
+```ts
+right: BasicExpression;
+```
+
+Defined in: [packages/db/src/query/ir.ts:40](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L40)
+
+***
+
+### type
+
+```ts
+type: "inner" | "left" | "right" | "full" | "outer" | "cross";
+```
+
+Defined in: [packages/db/src/query/ir.ts:38](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L38)
diff --git a/docs/reference/@tanstack/namespaces/IR/interfaces/QueryIR.md b/docs/reference/@tanstack/namespaces/IR/interfaces/QueryIR.md
new file mode 100644
index 000000000..c47622a9e
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/interfaces/QueryIR.md
@@ -0,0 +1,178 @@
+---
+id: QueryIR
+title: QueryIR
+---
+
+# Interface: QueryIR
+
+Defined in: [packages/db/src/query/ir.ts:9](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L9)
+
+## Properties
+
+### distinct?
+
+```ts
+optional distinct: true;
+```
+
+Defined in: [packages/db/src/query/ir.ts:19](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L19)
+
+***
+
+### fnHaving?
+
+```ts
+optional fnHaving: (row) => any[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:25](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L25)
+
+#### Parameters
+
+##### row
+
+[`NamespacedRow`](../../../../type-aliases/NamespacedRow.md)
+
+#### Returns
+
+`any`
+
+***
+
+### fnSelect()?
+
+```ts
+optional fnSelect: (row) => any;
+```
+
+Defined in: [packages/db/src/query/ir.ts:23](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L23)
+
+#### Parameters
+
+##### row
+
+[`NamespacedRow`](../../../../type-aliases/NamespacedRow.md)
+
+#### Returns
+
+`any`
+
+***
+
+### fnWhere?
+
+```ts
+optional fnWhere: (row) => any[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:24](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L24)
+
+#### Parameters
+
+##### row
+
+[`NamespacedRow`](../../../../type-aliases/NamespacedRow.md)
+
+#### Returns
+
+`any`
+
+***
+
+### from
+
+```ts
+from: From;
+```
+
+Defined in: [packages/db/src/query/ir.ts:10](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L10)
+
+***
+
+### groupBy?
+
+```ts
+optional groupBy: GroupBy;
+```
+
+Defined in: [packages/db/src/query/ir.ts:14](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L14)
+
+***
+
+### having?
+
+```ts
+optional having: Where[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:15](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L15)
+
+***
+
+### join?
+
+```ts
+optional join: Join;
+```
+
+Defined in: [packages/db/src/query/ir.ts:12](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L12)
+
+***
+
+### limit?
+
+```ts
+optional limit: number;
+```
+
+Defined in: [packages/db/src/query/ir.ts:17](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L17)
+
+***
+
+### offset?
+
+```ts
+optional offset: number;
+```
+
+Defined in: [packages/db/src/query/ir.ts:18](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L18)
+
+***
+
+### orderBy?
+
+```ts
+optional orderBy: OrderBy;
+```
+
+Defined in: [packages/db/src/query/ir.ts:16](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L16)
+
+***
+
+### select?
+
+```ts
+optional select: Select;
+```
+
+Defined in: [packages/db/src/query/ir.ts:11](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L11)
+
+***
+
+### singleResult?
+
+```ts
+optional singleResult: true;
+```
+
+Defined in: [packages/db/src/query/ir.ts:20](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L20)
+
+***
+
+### where?
+
+```ts
+optional where: Where[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:13](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L13)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/BasicExpression.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/BasicExpression.md
new file mode 100644
index 000000000..8621d0743
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/BasicExpression.md
@@ -0,0 +1,21 @@
+---
+id: BasicExpression
+title: BasicExpression
+---
+
+# Type Alias: BasicExpression\<T\>
+
+```ts
+type BasicExpression<T> = 
+  | PropRef<T>
+  | Value<T>
+| Func<T>;
+```
+
+Defined in: [packages/db/src/query/ir.ts:123](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L123)
+
+## Type Parameters
+
+### T
+
+`T` = `any`
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/From.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/From.md
new file mode 100644
index 000000000..53396c221
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/From.md
@@ -0,0 +1,14 @@
+---
+id: From
+title: From
+---
+
+# Type Alias: From
+
+```ts
+type From = 
+  | CollectionRef
+  | QueryRef;
+```
+
+Defined in: [packages/db/src/query/ir.ts:28](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L28)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/GroupBy.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/GroupBy.md
new file mode 100644
index 000000000..71426706e
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/GroupBy.md
@@ -0,0 +1,12 @@
+---
+id: GroupBy
+title: GroupBy
+---
+
+# Type Alias: GroupBy
+
+```ts
+type GroupBy = BasicExpression[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:47](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L47)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/Having.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/Having.md
new file mode 100644
index 000000000..7c101b514
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/Having.md
@@ -0,0 +1,12 @@
+---
+id: Having
+title: Having
+---
+
+# Type Alias: Having
+
+```ts
+type Having = Where;
+```
+
+Defined in: [packages/db/src/query/ir.ts:49](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L49)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/Join.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/Join.md
new file mode 100644
index 000000000..f05df96fd
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/Join.md
@@ -0,0 +1,12 @@
+---
+id: Join
+title: Join
+---
+
+# Type Alias: Join
+
+```ts
+type Join = JoinClause[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:34](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L34)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/Limit.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/Limit.md
new file mode 100644
index 000000000..fd93855d3
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/Limit.md
@@ -0,0 +1,12 @@
+---
+id: Limit
+title: Limit
+---
+
+# Type Alias: Limit
+
+```ts
+type Limit = number;
+```
+
+Defined in: [packages/db/src/query/ir.ts:60](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L60)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/Offset.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/Offset.md
new file mode 100644
index 000000000..eeb67a560
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/Offset.md
@@ -0,0 +1,12 @@
+---
+id: Offset
+title: Offset
+---
+
+# Type Alias: Offset
+
+```ts
+type Offset = number;
+```
+
+Defined in: [packages/db/src/query/ir.ts:62](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L62)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/OrderBy.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/OrderBy.md
new file mode 100644
index 000000000..af3fac551
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/OrderBy.md
@@ -0,0 +1,12 @@
+---
+id: OrderBy
+title: OrderBy
+---
+
+# Type Alias: OrderBy
+
+```ts
+type OrderBy = OrderByClause[];
+```
+
+Defined in: [packages/db/src/query/ir.ts:51](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L51)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/OrderByClause.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/OrderByClause.md
new file mode 100644
index 000000000..98ea1969e
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/OrderByClause.md
@@ -0,0 +1,32 @@
+---
+id: OrderByClause
+title: OrderByClause
+---
+
+# Type Alias: OrderByClause
+
+```ts
+type OrderByClause = object;
+```
+
+Defined in: [packages/db/src/query/ir.ts:53](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L53)
+
+## Properties
+
+### compareOptions
+
+```ts
+compareOptions: CompareOptions;
+```
+
+Defined in: [packages/db/src/query/ir.ts:55](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L55)
+
+***
+
+### expression
+
+```ts
+expression: BasicExpression;
+```
+
+Defined in: [packages/db/src/query/ir.ts:54](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L54)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/OrderByDirection.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/OrderByDirection.md
new file mode 100644
index 000000000..043ef946d
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/OrderByDirection.md
@@ -0,0 +1,12 @@
+---
+id: OrderByDirection
+title: OrderByDirection
+---
+
+# Type Alias: OrderByDirection
+
+```ts
+type OrderByDirection = "asc" | "desc";
+```
+
+Defined in: [packages/db/src/query/ir.ts:58](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L58)
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/Select.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/Select.md
new file mode 100644
index 000000000..1bf77381f
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/Select.md
@@ -0,0 +1,21 @@
+---
+id: Select
+title: Select
+---
+
+# Type Alias: Select
+
+```ts
+type Select = object;
+```
+
+Defined in: [packages/db/src/query/ir.ts:30](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L30)
+
+## Index Signature
+
+```ts
+[alias: string]: 
+  | Aggregate<any>
+  | BasicExpression<any>
+  | Select
+```
diff --git a/docs/reference/@tanstack/namespaces/IR/type-aliases/Where.md b/docs/reference/@tanstack/namespaces/IR/type-aliases/Where.md
new file mode 100644
index 000000000..ac22debbd
--- /dev/null
+++ b/docs/reference/@tanstack/namespaces/IR/type-aliases/Where.md
@@ -0,0 +1,17 @@
+---
+id: Where
+title: Where
+---
+
+# Type Alias: Where
+
+```ts
+type Where = 
+  | BasicExpression<boolean>
+  | {
+  expression: BasicExpression<boolean>;
+  residual?: boolean;
+};
+```
+
+Defined in: [packages/db/src/query/ir.ts:43](https://github.com/TanStack/db/blob/main/packages/db/src/query/ir.ts#L43)
diff --git a/docs/reference/classes/AggregateFunctionNotInSelectError.md b/docs/reference/classes/AggregateFunctionNotInSelectError.md
new file mode 100644
index 000000000..bd8803348
--- /dev/null
+++ b/docs/reference/classes/AggregateFunctionNotInSelectError.md
@@ -0,0 +1,220 @@
+---
+id: AggregateFunctionNotInSelectError
+title: AggregateFunctionNotInSelectError
+---
+
+# Class: AggregateFunctionNotInSelectError
+
+Defined in: [packages/db/src/errors.ts:594](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L594)
+
+## Extends
+
+- [`GroupByError`](GroupByError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new AggregateFunctionNotInSelectError(functionName): AggregateFunctionNotInSelectError;
+```
+
+Defined in: [packages/db/src/errors.ts:595](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L595)
+
+#### Parameters
+
+##### functionName
+
+`string`
+
+#### Returns
+
+`AggregateFunctionNotInSelectError`
+
+#### Overrides
+
+[`GroupByError`](GroupByError.md).[`constructor`](GroupByError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`cause`](GroupByError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`message`](GroupByError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`name`](GroupByError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`stack`](GroupByError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`stackTraceLimit`](GroupByError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`captureStackTrace`](GroupByError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`prepareStackTrace`](GroupByError.md#preparestacktrace)
diff --git a/docs/reference/classes/AggregateNotSupportedError.md b/docs/reference/classes/AggregateNotSupportedError.md
new file mode 100644
index 000000000..5a064ce2d
--- /dev/null
+++ b/docs/reference/classes/AggregateNotSupportedError.md
@@ -0,0 +1,216 @@
+---
+id: AggregateNotSupportedError
+title: AggregateNotSupportedError
+---
+
+# Class: AggregateNotSupportedError
+
+Defined in: [packages/db/src/errors.ts:710](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L710)
+
+Error thrown when aggregate expressions are used outside of a GROUP BY context.
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new AggregateNotSupportedError(): AggregateNotSupportedError;
+```
+
+Defined in: [packages/db/src/errors.ts:711](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L711)
+
+#### Returns
+
+`AggregateNotSupportedError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/BTreeIndex.md b/docs/reference/classes/BTreeIndex.md
new file mode 100644
index 000000000..68054f1c3
--- /dev/null
+++ b/docs/reference/classes/BTreeIndex.md
@@ -0,0 +1,848 @@
+---
+id: BTreeIndex
+title: BTreeIndex
+---
+
+# Class: BTreeIndex\<TKey\>
+
+Defined in: [packages/db/src/indexes/btree-index.ts:31](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L31)
+
+B+Tree index for sorted data with range queries
+This maintains items in sorted order and provides efficient range operations
+
+## Extends
+
+- [`BaseIndex`](BaseIndex.md)\<`TKey`\>
+
+## Type Parameters
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+## Constructors
+
+### Constructor
+
+```ts
+new BTreeIndex<TKey>(
+   id, 
+   expression, 
+   name?, 
+options?): BTreeIndex<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:51](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L51)
+
+#### Parameters
+
+##### id
+
+`number`
+
+##### expression
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)
+
+##### name?
+
+`string`
+
+##### options?
+
+`any`
+
+#### Returns
+
+`BTreeIndex`\<`TKey`\>
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`constructor`](BaseIndex.md#constructor)
+
+## Properties
+
+### compareOptions
+
+```ts
+protected compareOptions: CompareOptions;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:87](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L87)
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`compareOptions`](BaseIndex.md#compareoptions)
+
+***
+
+### expression
+
+```ts
+readonly expression: BasicExpression;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:81](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L81)
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`expression`](BaseIndex.md#expression)
+
+***
+
+### id
+
+```ts
+readonly id: number;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:79](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L79)
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`id`](BaseIndex.md#id)
+
+***
+
+### lastUpdated
+
+```ts
+protected lastUpdated: Date;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:86](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L86)
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`lastUpdated`](BaseIndex.md#lastupdated)
+
+***
+
+### lookupCount
+
+```ts
+protected lookupCount: number = 0;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:84](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L84)
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`lookupCount`](BaseIndex.md#lookupcount)
+
+***
+
+### name?
+
+```ts
+readonly optional name: string;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:80](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L80)
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`name`](BaseIndex.md#name)
+
+***
+
+### supportedOperations
+
+```ts
+readonly supportedOperations: Set<"eq" | "gt" | "gte" | "lt" | "lte" | "in" | "like" | "ilike">;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:34](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L34)
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`supportedOperations`](BaseIndex.md#supportedoperations)
+
+***
+
+### totalLookupTime
+
+```ts
+protected totalLookupTime: number = 0;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L85)
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`totalLookupTime`](BaseIndex.md#totallookuptime)
+
+## Accessors
+
+### indexedKeysSet
+
+#### Get Signature
+
+```ts
+get indexedKeysSet(): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:337](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L337)
+
+##### Returns
+
+`Set`\<`TKey`\>
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`indexedKeysSet`](BaseIndex.md#indexedkeysset)
+
+***
+
+### keyCount
+
+#### Get Signature
+
+```ts
+get keyCount(): number;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:200](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L200)
+
+Gets the number of indexed keys
+
+##### Returns
+
+`number`
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`keyCount`](BaseIndex.md#keycount)
+
+***
+
+### orderedEntriesArray
+
+#### Get Signature
+
+```ts
+get orderedEntriesArray(): [any, Set<TKey>][];
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:341](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L341)
+
+##### Returns
+
+\[`any`, `Set`\<`TKey`\>\][]
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`orderedEntriesArray`](BaseIndex.md#orderedentriesarray)
+
+***
+
+### orderedEntriesArrayReversed
+
+#### Get Signature
+
+```ts
+get orderedEntriesArrayReversed(): [any, Set<TKey>][];
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:347](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L347)
+
+##### Returns
+
+\[`any`, `Set`\<`TKey`\>\][]
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`orderedEntriesArrayReversed`](BaseIndex.md#orderedentriesarrayreversed)
+
+***
+
+### valueMapData
+
+#### Get Signature
+
+```ts
+get valueMapData(): Map<any, Set<TKey>>;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:354](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L354)
+
+##### Returns
+
+`Map`\<`any`, `Set`\<`TKey`\>\>
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`valueMapData`](BaseIndex.md#valuemapdata)
+
+## Methods
+
+### add()
+
+```ts
+add(key, item): void;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:70](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L70)
+
+Adds a value to the index
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+##### item
+
+`any`
+
+#### Returns
+
+`void`
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`add`](BaseIndex.md#add)
+
+***
+
+### build()
+
+```ts
+build(entries): void;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:144](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L144)
+
+Builds the index from a collection of entries
+
+#### Parameters
+
+##### entries
+
+`Iterable`\<\[`TKey`, `any`\]\>
+
+#### Returns
+
+`void`
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`build`](BaseIndex.md#build)
+
+***
+
+### clear()
+
+```ts
+clear(): void;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:155](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L155)
+
+Clears all data from the index
+
+#### Returns
+
+`void`
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`clear`](BaseIndex.md#clear)
+
+***
+
+### equalityLookup()
+
+```ts
+equalityLookup(value): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:209](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L209)
+
+Performs an equality lookup
+
+#### Parameters
+
+##### value
+
+`any`
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`equalityLookup`](BaseIndex.md#equalitylookup)
+
+***
+
+### evaluateIndexExpression()
+
+```ts
+protected evaluateIndexExpression(item): any;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:182](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L182)
+
+#### Parameters
+
+##### item
+
+`any`
+
+#### Returns
+
+`any`
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`evaluateIndexExpression`](BaseIndex.md#evaluateindexexpression)
+
+***
+
+### getStats()
+
+```ts
+getStats(): IndexStats;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:169](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L169)
+
+#### Returns
+
+[`IndexStats`](../interfaces/IndexStats.md)
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`getStats`](BaseIndex.md#getstats)
+
+***
+
+### inArrayLookup()
+
+```ts
+inArrayLookup(values): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:322](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L322)
+
+Performs an IN array lookup
+
+#### Parameters
+
+##### values
+
+`any`[]
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`inArrayLookup`](BaseIndex.md#inarraylookup)
+
+***
+
+### initialize()
+
+```ts
+protected initialize(_options?): void;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:65](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L65)
+
+#### Parameters
+
+##### \_options?
+
+[`BTreeIndexOptions`](../interfaces/BTreeIndexOptions.md)
+
+#### Returns
+
+`void`
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`initialize`](BaseIndex.md#initialize)
+
+***
+
+### lookup()
+
+```ts
+lookup(operation, value): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:165](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L165)
+
+Performs a lookup operation
+
+#### Parameters
+
+##### operation
+
+`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
+
+##### value
+
+`any`
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`lookup`](BaseIndex.md#lookup)
+
+***
+
+### matchesCompareOptions()
+
+```ts
+matchesCompareOptions(compareOptions): boolean;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:146](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L146)
+
+Checks if the compare options match the index's compare options.
+The direction is ignored because the index can be reversed if the direction is different.
+
+#### Parameters
+
+##### compareOptions
+
+`CompareOptions`
+
+#### Returns
+
+`boolean`
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`matchesCompareOptions`](BaseIndex.md#matchescompareoptions)
+
+***
+
+### matchesDirection()
+
+```ts
+matchesDirection(direction): boolean;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:165](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L165)
+
+Checks if the index matches the provided direction.
+
+#### Parameters
+
+##### direction
+
+[`OrderByDirection`](../@tanstack/namespaces/IR/type-aliases/OrderByDirection.md)
+
+#### Returns
+
+`boolean`
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`matchesDirection`](BaseIndex.md#matchesdirection)
+
+***
+
+### matchesField()
+
+```ts
+matchesField(fieldPath): boolean;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:134](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L134)
+
+#### Parameters
+
+##### fieldPath
+
+`string`[]
+
+#### Returns
+
+`boolean`
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`matchesField`](BaseIndex.md#matchesfield)
+
+***
+
+### rangeQuery()
+
+```ts
+rangeQuery(options): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:218](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L218)
+
+Performs a range query with options
+This is more efficient for compound queries like "WHERE a > 5 AND a < 10"
+
+#### Parameters
+
+##### options
+
+[`RangeQueryOptions`](../interfaces/RangeQueryOptions.md) = `{}`
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`rangeQuery`](BaseIndex.md#rangequery)
+
+***
+
+### rangeQueryReversed()
+
+```ts
+rangeQueryReversed(options): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:251](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L251)
+
+Performs a reversed range query
+
+#### Parameters
+
+##### options
+
+[`RangeQueryOptions`](../interfaces/RangeQueryOptions.md) = `{}`
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`rangeQueryReversed`](BaseIndex.md#rangequeryreversed)
+
+***
+
+### remove()
+
+```ts
+remove(key, item): void;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:101](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L101)
+
+Removes a value from the index
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+##### item
+
+`any`
+
+#### Returns
+
+`void`
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`remove`](BaseIndex.md#remove)
+
+***
+
+### supports()
+
+```ts
+supports(operation): boolean;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:130](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L130)
+
+#### Parameters
+
+##### operation
+
+`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
+
+#### Returns
+
+`boolean`
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`supports`](BaseIndex.md#supports)
+
+***
+
+### take()
+
+```ts
+take(
+   n, 
+   from?, 
+   filterFn?): TKey[];
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:299](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L299)
+
+Returns the next n items after the provided item or the first n items if no from item is provided.
+
+#### Parameters
+
+##### n
+
+`number`
+
+The number of items to return
+
+##### from?
+
+`any`
+
+The item to start from (exclusive). Starts from the smallest item (inclusive) if not provided.
+
+##### filterFn?
+
+(`key`) => `boolean`
+
+#### Returns
+
+`TKey`[]
+
+The next n items after the provided key. Returns the first n items if no from item is provided.
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`take`](BaseIndex.md#take)
+
+***
+
+### takeReversed()
+
+```ts
+takeReversed(
+   n, 
+   from?, 
+   filterFn?): TKey[];
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:310](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L310)
+
+Returns the next n items **before** the provided item (in descending order) or the last n items if no from item is provided.
+
+#### Parameters
+
+##### n
+
+`number`
+
+The number of items to return
+
+##### from?
+
+`any`
+
+The item to start from (exclusive). Starts from the largest item (inclusive) if not provided.
+
+##### filterFn?
+
+(`key`) => `boolean`
+
+#### Returns
+
+`TKey`[]
+
+The next n items **before** the provided key. Returns the last n items if no from item is provided.
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`takeReversed`](BaseIndex.md#takereversed)
+
+***
+
+### trackLookup()
+
+```ts
+protected trackLookup(startTime): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:187](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L187)
+
+#### Parameters
+
+##### startTime
+
+`number`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`trackLookup`](BaseIndex.md#tracklookup)
+
+***
+
+### update()
+
+```ts
+update(
+   key, 
+   oldItem, 
+   newItem): void;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:136](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L136)
+
+Updates a value in the index
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+##### oldItem
+
+`any`
+
+##### newItem
+
+`any`
+
+#### Returns
+
+`void`
+
+#### Overrides
+
+[`BaseIndex`](BaseIndex.md).[`update`](BaseIndex.md#update)
+
+***
+
+### updateTimestamp()
+
+```ts
+protected updateTimestamp(): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:193](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L193)
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`BaseIndex`](BaseIndex.md).[`updateTimestamp`](BaseIndex.md#updatetimestamp)
diff --git a/docs/reference/classes/BaseIndex.md b/docs/reference/classes/BaseIndex.md
new file mode 100644
index 000000000..0327f8674
--- /dev/null
+++ b/docs/reference/classes/BaseIndex.md
@@ -0,0 +1,760 @@
+---
+id: BaseIndex
+title: BaseIndex
+---
+
+# Abstract Class: BaseIndex\<TKey\>
+
+Defined in: [packages/db/src/indexes/base-index.ts:76](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L76)
+
+Base abstract class that all index types extend
+
+## Extended by
+
+- [`BTreeIndex`](BTreeIndex.md)
+
+## Type Parameters
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+## Implements
+
+- [`IndexInterface`](../interfaces/IndexInterface.md)\<`TKey`\>
+
+## Constructors
+
+### Constructor
+
+```ts
+new BaseIndex<TKey>(
+   id, 
+   expression, 
+   name?, 
+options?): BaseIndex<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:89](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L89)
+
+#### Parameters
+
+##### id
+
+`number`
+
+##### expression
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)
+
+##### name?
+
+`string`
+
+##### options?
+
+`any`
+
+#### Returns
+
+`BaseIndex`\<`TKey`\>
+
+## Properties
+
+### compareOptions
+
+```ts
+protected compareOptions: CompareOptions;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:87](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L87)
+
+***
+
+### expression
+
+```ts
+readonly expression: BasicExpression;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:81](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L81)
+
+***
+
+### id
+
+```ts
+readonly id: number;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:79](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L79)
+
+***
+
+### lastUpdated
+
+```ts
+protected lastUpdated: Date;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:86](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L86)
+
+***
+
+### lookupCount
+
+```ts
+protected lookupCount: number = 0;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:84](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L84)
+
+***
+
+### name?
+
+```ts
+readonly optional name: string;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:80](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L80)
+
+***
+
+### supportedOperations
+
+```ts
+abstract readonly supportedOperations: Set<"eq" | "gt" | "gte" | "lt" | "lte" | "in" | "like" | "ilike">;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:82](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L82)
+
+***
+
+### totalLookupTime
+
+```ts
+protected totalLookupTime: number = 0;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L85)
+
+## Accessors
+
+### indexedKeysSet
+
+#### Get Signature
+
+```ts
+get abstract indexedKeysSet(): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:126](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L126)
+
+##### Returns
+
+`Set`\<`TKey`\>
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`indexedKeysSet`](../interfaces/IndexInterface.md#indexedkeysset)
+
+***
+
+### keyCount
+
+#### Get Signature
+
+```ts
+get abstract keyCount(): number;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:119](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L119)
+
+##### Returns
+
+`number`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`keyCount`](../interfaces/IndexInterface.md#keycount)
+
+***
+
+### orderedEntriesArray
+
+#### Get Signature
+
+```ts
+get abstract orderedEntriesArray(): [any, Set<TKey>][];
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:124](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L124)
+
+##### Returns
+
+\[`any`, `Set`\<`TKey`\>\][]
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`orderedEntriesArray`](../interfaces/IndexInterface.md#orderedentriesarray)
+
+***
+
+### orderedEntriesArrayReversed
+
+#### Get Signature
+
+```ts
+get abstract orderedEntriesArrayReversed(): [any, Set<TKey>][];
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:125](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L125)
+
+##### Returns
+
+\[`any`, `Set`\<`TKey`\>\][]
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`orderedEntriesArrayReversed`](../interfaces/IndexInterface.md#orderedentriesarrayreversed)
+
+***
+
+### valueMapData
+
+#### Get Signature
+
+```ts
+get abstract valueMapData(): Map<any, Set<TKey>>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:127](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L127)
+
+##### Returns
+
+`Map`\<`any`, `Set`\<`TKey`\>\>
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`valueMapData`](../interfaces/IndexInterface.md#valuemapdata)
+
+## Methods
+
+### add()
+
+```ts
+abstract add(key, item): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:103](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L103)
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+##### item
+
+`any`
+
+#### Returns
+
+`void`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`add`](../interfaces/IndexInterface.md#add)
+
+***
+
+### build()
+
+```ts
+abstract build(entries): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:106](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L106)
+
+#### Parameters
+
+##### entries
+
+`Iterable`\<\[`TKey`, `any`\]\>
+
+#### Returns
+
+`void`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`build`](../interfaces/IndexInterface.md#build)
+
+***
+
+### clear()
+
+```ts
+abstract clear(): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:107](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L107)
+
+#### Returns
+
+`void`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`clear`](../interfaces/IndexInterface.md#clear)
+
+***
+
+### equalityLookup()
+
+```ts
+abstract equalityLookup(value): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:120](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L120)
+
+#### Parameters
+
+##### value
+
+`any`
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`equalityLookup`](../interfaces/IndexInterface.md#equalitylookup)
+
+***
+
+### evaluateIndexExpression()
+
+```ts
+protected evaluateIndexExpression(item): any;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:182](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L182)
+
+#### Parameters
+
+##### item
+
+`any`
+
+#### Returns
+
+`any`
+
+***
+
+### getStats()
+
+```ts
+getStats(): IndexStats;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:169](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L169)
+
+#### Returns
+
+[`IndexStats`](../interfaces/IndexStats.md)
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`getStats`](../interfaces/IndexInterface.md#getstats)
+
+***
+
+### inArrayLookup()
+
+```ts
+abstract inArrayLookup(values): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:121](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L121)
+
+#### Parameters
+
+##### values
+
+`any`[]
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`inArrayLookup`](../interfaces/IndexInterface.md#inarraylookup)
+
+***
+
+### initialize()
+
+```ts
+abstract protected initialize(options?): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:180](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L180)
+
+#### Parameters
+
+##### options?
+
+`any`
+
+#### Returns
+
+`void`
+
+***
+
+### lookup()
+
+```ts
+abstract lookup(operation, value): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:108](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L108)
+
+#### Parameters
+
+##### operation
+
+`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
+
+##### value
+
+`any`
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`lookup`](../interfaces/IndexInterface.md#lookup)
+
+***
+
+### matchesCompareOptions()
+
+```ts
+matchesCompareOptions(compareOptions): boolean;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:146](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L146)
+
+Checks if the compare options match the index's compare options.
+The direction is ignored because the index can be reversed if the direction is different.
+
+#### Parameters
+
+##### compareOptions
+
+`CompareOptions`
+
+#### Returns
+
+`boolean`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`matchesCompareOptions`](../interfaces/IndexInterface.md#matchescompareoptions)
+
+***
+
+### matchesDirection()
+
+```ts
+matchesDirection(direction): boolean;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:165](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L165)
+
+Checks if the index matches the provided direction.
+
+#### Parameters
+
+##### direction
+
+[`OrderByDirection`](../@tanstack/namespaces/IR/type-aliases/OrderByDirection.md)
+
+#### Returns
+
+`boolean`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`matchesDirection`](../interfaces/IndexInterface.md#matchesdirection)
+
+***
+
+### matchesField()
+
+```ts
+matchesField(fieldPath): boolean;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:134](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L134)
+
+#### Parameters
+
+##### fieldPath
+
+`string`[]
+
+#### Returns
+
+`boolean`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`matchesField`](../interfaces/IndexInterface.md#matchesfield)
+
+***
+
+### rangeQuery()
+
+```ts
+abstract rangeQuery(options): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:122](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L122)
+
+#### Parameters
+
+##### options
+
+[`RangeQueryOptions`](../interfaces/RangeQueryOptions.md)
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`rangeQuery`](../interfaces/IndexInterface.md#rangequery)
+
+***
+
+### rangeQueryReversed()
+
+```ts
+abstract rangeQueryReversed(options): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:123](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L123)
+
+#### Parameters
+
+##### options
+
+[`RangeQueryOptions`](../interfaces/RangeQueryOptions.md)
+
+#### Returns
+
+`Set`\<`TKey`\>
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`rangeQueryReversed`](../interfaces/IndexInterface.md#rangequeryreversed)
+
+***
+
+### remove()
+
+```ts
+abstract remove(key, item): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:104](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L104)
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+##### item
+
+`any`
+
+#### Returns
+
+`void`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`remove`](../interfaces/IndexInterface.md#remove)
+
+***
+
+### supports()
+
+```ts
+supports(operation): boolean;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:130](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L130)
+
+#### Parameters
+
+##### operation
+
+`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
+
+#### Returns
+
+`boolean`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`supports`](../interfaces/IndexInterface.md#supports)
+
+***
+
+### take()
+
+```ts
+abstract take(
+   n, 
+   from?, 
+   filterFn?): TKey[];
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:109](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L109)
+
+#### Parameters
+
+##### n
+
+`number`
+
+##### from?
+
+`TKey`
+
+##### filterFn?
+
+(`key`) => `boolean`
+
+#### Returns
+
+`TKey`[]
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`take`](../interfaces/IndexInterface.md#take)
+
+***
+
+### takeReversed()
+
+```ts
+abstract takeReversed(
+   n, 
+   from?, 
+   filterFn?): TKey[];
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:114](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L114)
+
+#### Parameters
+
+##### n
+
+`number`
+
+##### from?
+
+`TKey`
+
+##### filterFn?
+
+(`key`) => `boolean`
+
+#### Returns
+
+`TKey`[]
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`takeReversed`](../interfaces/IndexInterface.md#takereversed)
+
+***
+
+### trackLookup()
+
+```ts
+protected trackLookup(startTime): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:187](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L187)
+
+#### Parameters
+
+##### startTime
+
+`number`
+
+#### Returns
+
+`void`
+
+***
+
+### update()
+
+```ts
+abstract update(
+   key, 
+   oldItem, 
+   newItem): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:105](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L105)
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+##### oldItem
+
+`any`
+
+##### newItem
+
+`any`
+
+#### Returns
+
+`void`
+
+#### Implementation of
+
+[`IndexInterface`](../interfaces/IndexInterface.md).[`update`](../interfaces/IndexInterface.md#update)
+
+***
+
+### updateTimestamp()
+
+```ts
+protected updateTimestamp(): void;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:193](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L193)
+
+#### Returns
+
+`void`
diff --git a/docs/reference/classes/basequerybuilder.md b/docs/reference/classes/BaseQueryBuilder.md
similarity index 50%
rename from docs/reference/classes/basequerybuilder.md
rename to docs/reference/classes/BaseQueryBuilder.md
index c519a8503..20f8e6ccd 100644
--- a/docs/reference/classes/basequerybuilder.md
+++ b/docs/reference/classes/BaseQueryBuilder.md
@@ -3,35 +3,35 @@ id: BaseQueryBuilder
 title: BaseQueryBuilder
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Class: BaseQueryBuilder\<TContext\>
 
-Defined in: [packages/db/src/query/builder/index.ts:37](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L37)
+Defined in: [packages/db/src/query/builder/index.ts:54](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L54)
 
 ## Type Parameters
 
-• **TContext** *extends* [`Context`](../../interfaces/context.md) = [`Context`](../../interfaces/context.md)
+### TContext
+
+`TContext` *extends* [`Context`](../interfaces/Context.md) = [`Context`](../interfaces/Context.md)
 
 ## Constructors
 
-### new BaseQueryBuilder()
+### Constructor
 
 ```ts
-new BaseQueryBuilder<TContext>(query): BaseQueryBuilder<TContext>
+new BaseQueryBuilder<TContext>(query): BaseQueryBuilder<TContext>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:40](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L40)
+Defined in: [packages/db/src/query/builder/index.ts:57](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L57)
 
 #### Parameters
 
 ##### query
 
-`Partial`\<`QueryIR`\> = `{}`
+`Partial`\<[`QueryIR`](../@tanstack/namespaces/IR/interfaces/QueryIR.md)\> = `{}`
 
 #### Returns
 
-[`BaseQueryBuilder`](../basequerybuilder.md)\<`TContext`\>
+`BaseQueryBuilder`\<`TContext`\>
 
 ## Accessors
 
@@ -40,10 +40,10 @@ Defined in: [packages/db/src/query/builder/index.ts:40](https://github.com/TanSt
 #### Get Signature
 
 ```ts
-get fn(): object
+get fn(): object;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:645](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L645)
+Defined in: [packages/db/src/query/builder/index.ts:729](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L729)
 
 Functional variants of the query builder
 These are imperative function that are called for ery row.
@@ -61,10 +61,12 @@ q.fn.select((row) => ({
 
 ##### Returns
 
-`object`
-
 ###### having()
 
+```ts
+having(callback): QueryBuilder<TContext>;
+```
+
 Filter grouped rows using a function that operates on each aggregated row
 Warning: This cannot be optimized by the query compiler
 
@@ -74,11 +76,11 @@ Warning: This cannot be optimized by the query compiler
 
 (`row`) => `any`
 
-A function that receives an aggregated row and returns a boolean
+A function that receives an aggregated row (with $selected when select() was called) and returns a boolean
 
 ###### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 A QueryBuilder with functional having filter applied
 
@@ -89,17 +91,24 @@ A QueryBuilder with functional having filter applied
 query
   .from({ posts: postsCollection })
   .groupBy(({posts}) => posts.userId)
-  .fn.having(row => row.count > 5)
+  .select(({posts}) => ({ userId: posts.userId, count: count(posts.id) }))
+  .fn.having(({ $selected }) => $selected.count > 5)
 ```
 
 ###### select()
 
+```ts
+select<TFuncSelectResult>(callback): QueryBuilder<WithResult<TContext, TFuncSelectResult>>;
+```
+
 Select fields using a function that operates on each row
 Warning: This cannot be optimized by the query compiler
 
 ###### Type Parameters
 
-• **TFuncSelectResult**
+###### TFuncSelectResult
+
+`TFuncSelectResult`
 
 ###### Parameters
 
@@ -111,7 +120,7 @@ A function that receives a row and returns the selected value
 
 ###### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<\{ \[K in string \| number \| symbol\]: (Omit\<TContext, "result"\> & \{ result: \{ \[K in string \| number \| symbol\]: TFuncSelectResult\[K\] \} \})\[K\] \}\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`WithResult`\<`TContext`, `TFuncSelectResult`\>\>
 
 A QueryBuilder with functional selection applied
 
@@ -129,6 +138,10 @@ query
 
 ###### where()
 
+```ts
+where(callback): QueryBuilder<TContext>;
+```
+
 Filter rows using a function that operates on each row
 Warning: This cannot be optimized by the query compiler
 
@@ -142,7 +155,7 @@ A function that receives a row and returns a boolean
 
 ###### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 A QueryBuilder with functional filtering applied
 
@@ -160,31 +173,31 @@ query
 ### \_getQuery()
 
 ```ts
-_getQuery(): QueryIR
+_getQuery(): QueryIR;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:731](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L731)
+Defined in: [packages/db/src/query/builder/index.ts:816](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L816)
 
 #### Returns
 
-`QueryIR`
+[`QueryIR`](../@tanstack/namespaces/IR/interfaces/QueryIR.md)
 
 ***
 
 ### distinct()
 
 ```ts
-distinct(): QueryBuilder<TContext>
+distinct(): QueryBuilder<TContext>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:606](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L606)
+Defined in: [packages/db/src/query/builder/index.ts:668](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L668)
 
 Specify that the query should return distinct rows.
 Deduplicates rows based on the selected columns.
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 A QueryBuilder with distinct enabled
 
@@ -203,21 +216,23 @@ query
 ### findOne()
 
 ```ts
-findOne(): QueryBuilder<TContext>
+findOne(): QueryBuilder<TContext & SingleResult>;
 ```
 
-Specify that the query should return a single row as `data` and not an array.
+Defined in: [packages/db/src/query/builder/index.ts:688](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L688)
+
+Specify that the query should return a single result
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext` & [`SingleResult`](../type-aliases/SingleResult.md)\>
 
-A QueryBuilder with single return enabled
+A QueryBuilder that returns the first result
 
 #### Example
 
 ```ts
-// Get an user by ID
+// Get the user matching the query
 query
   .from({ users: usersCollection })
   .where(({users}) => eq(users.id, 1))
@@ -230,20 +245,22 @@ query
 
 ```ts
 from<TSource>(source): QueryBuilder<{
-  baseSchema: { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<U, string | number, {}, StandardSchemaV1<unknown, unknown>, U> ? U : TSource[K] extends QueryBuilder<TContext> ? { [K in string | number | symbol]: ((...)[(...)] extends object ? any[any] : (...) extends (...) ? (...) : (...))[K] } : never }[K] };
+  baseSchema: SchemaFromSource<TSource>;
   fromSourceName: keyof TSource & string;
   hasJoins: false;
-  schema: { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<U, string | number, {}, StandardSchemaV1<unknown, unknown>, U> ? U : TSource[K] extends QueryBuilder<TContext> ? { [K in string | number | symbol]: ((...)[(...)] extends object ? any[any] : (...) extends (...) ? (...) : (...))[K] } : never }[K] };
-}>
+  schema: SchemaFromSource<TSource>;
+}>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:94](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L94)
+Defined in: [packages/db/src/query/builder/index.ts:136](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L136)
 
 Specify the source table or subquery for the query
 
 #### Type Parameters
 
-• **TSource** *extends* [`Source`](../../type-aliases/source.md)
+##### TSource
+
+`TSource` *extends* [`Source`](../type-aliases/Source.md)
 
 #### Parameters
 
@@ -255,12 +272,12 @@ An object with a single key-value pair where the key is the table alias and the
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<\{
-  `baseSchema`: \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \};
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<\{
+  `baseSchema`: `SchemaFromSource`\<`TSource`\>;
   `fromSourceName`: keyof `TSource` & `string`;
   `hasJoins`: `false`;
-  `schema`: \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \};
- \}\>
+  `schema`: `SchemaFromSource`\<`TSource`\>;
+\}\>
 
 A QueryBuilder with the specified source
 
@@ -280,16 +297,18 @@ query.from({ activeUsers })
 ### fullJoin()
 
 ```ts
-fullJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<U, string | number, {}, StandardSchemaV1<unknown, unknown>, U> ? U : TSource[K] extends QueryBuilder<TContext> ? { [K in string | number | symbol]: ((...)[(...)] extends object ? any[any] : (...) extends (...) ? (...) : (...))[K] } : never }[K] }, "full">>
+fullJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "full">>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:285](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L285)
+Defined in: [packages/db/src/query/builder/index.ts:327](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L327)
 
 Perform a FULL JOIN with another table or subquery
 
 #### Type Parameters
 
-• **TSource** *extends* [`Source`](../../type-aliases/source.md)
+##### TSource
+
+`TSource` *extends* [`Source`](../type-aliases/Source.md)
 
 #### Parameters
 
@@ -301,13 +320,13 @@ An object with a single key-value pair where the key is the table alias and the
 
 ##### onCallback
 
-`JoinOnCallback`\<`MergeContext`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
+`JoinOnCallback`\<`MergeContextForJoinCallback`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<any, any, any, any, any\> ? InferCollectionType\<any\[any\]\> : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
 
 A function that receives table references and returns the join condition
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`MergeContextWithJoinType`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}, `"full"`\>\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`MergeContextWithJoinType`\<`TContext`, `SchemaFromSource`\<`TSource`\>, `"full"`\>\>
 
 A QueryBuilder with the full joined table available
 
@@ -325,10 +344,10 @@ query
 ### groupBy()
 
 ```ts
-groupBy(callback): QueryBuilder<TContext>
+groupBy(callback): QueryBuilder<TContext>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:529](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L529)
+Defined in: [packages/db/src/query/builder/index.ts:590](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L590)
 
 Group rows by one or more columns for aggregation
 
@@ -342,7 +361,7 @@ A function that receives table references and returns the field(s) to group by
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 A QueryBuilder with grouping applied (enables aggregate functions in SELECT and HAVING)
 
@@ -374,10 +393,10 @@ query
 ### having()
 
 ```ts
-having(callback): QueryBuilder<TContext>
+having(callback): QueryBuilder<TContext>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:365](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L365)
+Defined in: [packages/db/src/query/builder/index.ts:414](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L414)
 
 Filter grouped rows based on aggregate conditions
 
@@ -391,7 +410,7 @@ A function that receives table references and returns an expression
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 A QueryBuilder with the having condition applied
 
@@ -423,16 +442,18 @@ query
 ### innerJoin()
 
 ```ts
-innerJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<U, string | number, {}, StandardSchemaV1<unknown, unknown>, U> ? U : TSource[K] extends QueryBuilder<TContext> ? { [K in string | number | symbol]: ((...)[(...)] extends object ? any[any] : (...) extends (...) ? (...) : (...))[K] } : never }[K] }, "inner">>
+innerJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "inner">>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:259](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L259)
+Defined in: [packages/db/src/query/builder/index.ts:301](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L301)
 
 Perform an INNER JOIN with another table or subquery
 
 #### Type Parameters
 
-• **TSource** *extends* [`Source`](../../type-aliases/source.md)
+##### TSource
+
+`TSource` *extends* [`Source`](../type-aliases/Source.md)
 
 #### Parameters
 
@@ -444,13 +465,13 @@ An object with a single key-value pair where the key is the table alias and the
 
 ##### onCallback
 
-`JoinOnCallback`\<`MergeContext`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
+`JoinOnCallback`\<`MergeContextForJoinCallback`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<any, any, any, any, any\> ? InferCollectionType\<any\[any\]\> : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
 
 A function that receives table references and returns the join condition
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`MergeContextWithJoinType`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}, `"inner"`\>\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`MergeContextWithJoinType`\<`TContext`, `SchemaFromSource`\<`TSource`\>, `"inner"`\>\>
 
 A QueryBuilder with the inner joined table available
 
@@ -471,18 +492,22 @@ query
 join<TSource, TJoinType>(
    source, 
    onCallback, 
-type): QueryBuilder<MergeContextWithJoinType<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<U, string | number, {}, StandardSchemaV1<unknown, unknown>, U> ? U : TSource[K] extends QueryBuilder<TContext> ? { [K in string | number | symbol]: ((...)[(...)] extends object ? any[any] : (...) extends (...) ? (...) : (...))[K] } : never }[K] }, TJoinType>>
+type): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, TJoinType>>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:137](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L137)
+Defined in: [packages/db/src/query/builder/index.ts:179](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L179)
 
 Join another table or subquery to the current query
 
 #### Type Parameters
 
-• **TSource** *extends* [`Source`](../../type-aliases/source.md)
+##### TSource
+
+`TSource` *extends* [`Source`](../type-aliases/Source.md)
 
-• **TJoinType** *extends* `"full"` \| `"left"` \| `"right"` \| `"inner"` = `"left"`
+##### TJoinType
+
+`TJoinType` *extends* `"inner"` \| `"left"` \| `"right"` \| `"full"` = `"left"`
 
 #### Parameters
 
@@ -494,7 +519,7 @@ An object with a single key-value pair where the key is the table alias and the
 
 ##### onCallback
 
-`JoinOnCallback`\<`MergeContext`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
+`JoinOnCallback`\<`MergeContextForJoinCallback`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<any, any, any, any, any\> ? InferCollectionType\<any\[any\]\> : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
 
 A function that receives table references and returns the join condition
 
@@ -506,7 +531,7 @@ The type of join: 'inner', 'left', 'right', or 'full' (defaults to 'left')
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`MergeContextWithJoinType`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}, `TJoinType`\>\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`MergeContextWithJoinType`\<`TContext`, `SchemaFromSource`\<`TSource`\>, `TJoinType`\>\>
 
 A QueryBuilder with the joined table available
 
@@ -535,16 +560,18 @@ query
 ### leftJoin()
 
 ```ts
-leftJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<U, string | number, {}, StandardSchemaV1<unknown, unknown>, U> ? U : TSource[K] extends QueryBuilder<TContext> ? { [K in string | number | symbol]: ((...)[(...)] extends object ? any[any] : (...) extends (...) ? (...) : (...))[K] } : never }[K] }, "left">>
+leftJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "left">>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:207](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L207)
+Defined in: [packages/db/src/query/builder/index.ts:249](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L249)
 
 Perform a LEFT JOIN with another table or subquery
 
 #### Type Parameters
 
-• **TSource** *extends* [`Source`](../../type-aliases/source.md)
+##### TSource
+
+`TSource` *extends* [`Source`](../type-aliases/Source.md)
 
 #### Parameters
 
@@ -556,13 +583,13 @@ An object with a single key-value pair where the key is the table alias and the
 
 ##### onCallback
 
-`JoinOnCallback`\<`MergeContext`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
+`JoinOnCallback`\<`MergeContextForJoinCallback`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<any, any, any, any, any\> ? InferCollectionType\<any\[any\]\> : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
 
 A function that receives table references and returns the join condition
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`MergeContextWithJoinType`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}, `"left"`\>\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`MergeContextWithJoinType`\<`TContext`, `SchemaFromSource`\<`TSource`\>, `"left"`\>\>
 
 A QueryBuilder with the left joined table available
 
@@ -580,10 +607,10 @@ query
 ### limit()
 
 ```ts
-limit(count): QueryBuilder<TContext>
+limit(count): QueryBuilder<TContext>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:561](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L561)
+Defined in: [packages/db/src/query/builder/index.ts:623](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L623)
 
 Limit the number of rows returned by the query
 `orderBy` is required for `limit`
@@ -598,7 +625,7 @@ Maximum number of rows to return
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 A QueryBuilder with the limit applied
 
@@ -617,10 +644,10 @@ query
 ### offset()
 
 ```ts
-offset(count): QueryBuilder<TContext>
+offset(count): QueryBuilder<TContext>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:585](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L585)
+Defined in: [packages/db/src/query/builder/index.ts:647](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L647)
 
 Skip a number of rows before returning results
 `orderBy` is required for `offset`
@@ -635,7 +662,7 @@ Number of rows to skip
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 A QueryBuilder with the offset applied
 
@@ -655,10 +682,10 @@ query
 ### orderBy()
 
 ```ts
-orderBy(callback, direction): QueryBuilder<TContext>
+orderBy(callback, options): QueryBuilder<TContext>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:479](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L479)
+Defined in: [packages/db/src/query/builder/index.ts:514](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L514)
 
 Sort the query results by one or more columns
 
@@ -670,15 +697,13 @@ Sort the query results by one or more columns
 
 A function that receives table references and returns the field to sort by
 
-##### direction
-
-`OrderByDirection` = `...`
+##### options
 
-Sort direction: 'asc' for ascending, 'desc' for descending (defaults to 'asc')
+[`OrderByDirection`](../@tanstack/namespaces/IR/type-aliases/OrderByDirection.md) | `OrderByOptions`
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 A QueryBuilder with the ordering applied
 
@@ -707,16 +732,18 @@ query
 ### rightJoin()
 
 ```ts
-rightJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<U, string | number, {}, StandardSchemaV1<unknown, unknown>, U> ? U : TSource[K] extends QueryBuilder<TContext> ? { [K in string | number | symbol]: ((...)[(...)] extends object ? any[any] : (...) extends (...) ? (...) : (...))[K] } : never }[K] }, "right">>
+rightJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "right">>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:233](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L233)
+Defined in: [packages/db/src/query/builder/index.ts:275](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L275)
 
 Perform a RIGHT JOIN with another table or subquery
 
 #### Type Parameters
 
-• **TSource** *extends* [`Source`](../../type-aliases/source.md)
+##### TSource
+
+`TSource` *extends* [`Source`](../type-aliases/Source.md)
 
 #### Parameters
 
@@ -728,13 +755,13 @@ An object with a single key-value pair where the key is the table alias and the
 
 ##### onCallback
 
-`JoinOnCallback`\<`MergeContext`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
+`JoinOnCallback`\<`MergeContextForJoinCallback`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<any, any, any, any, any\> ? InferCollectionType\<any\[any\]\> : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}\>\>
 
 A function that receives table references and returns the join condition
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`MergeContextWithJoinType`\<`TContext`, \{ \[K in string \| number \| symbol\]: \{ \[K in string \| number \| symbol\]: TSource\[K\] extends CollectionImpl\<U, string \| number, \{\}, StandardSchemaV1\<unknown, unknown\>, U\> ? U : TSource\[K\] extends QueryBuilder\<TContext\> ? \{ \[K in string \| number \| symbol\]: ((...)\[(...)\] extends object ? any\[any\] : (...) extends (...) ? (...) : (...))\[K\] \} : never \}\[K\] \}, `"right"`\>\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`MergeContextWithJoinType`\<`TContext`, `SchemaFromSource`\<`TSource`\>, `"right"`\>\>
 
 A QueryBuilder with the right joined table available
 
@@ -752,20 +779,18 @@ query
 ### select()
 
 ```ts
-select<TSelectObject>(callback): QueryBuilder<{ [K in string | number | symbol]: (Omit<TContext, "result"> & { result: { [K in string | number | symbol]: ResultTypeFromSelect<TSelectObject>[K] } })[K] }>
+select<TSelectObject>(callback): QueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelectObject>>>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:412](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L412)
+Defined in: [packages/db/src/query/builder/index.ts:473](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L473)
 
 Select specific columns or computed values from the query
 
 #### Type Parameters
 
-• **TSelectObject** *extends* `Record`\<`string`, 
-  \| `BasicExpression`
-  \| `Aggregate`\<`any`\>
-  \| `RefProxy`\<`any`\>
-  \| `RefProxyFor`\<`any`\>\>
+##### TSelectObject
+
+`TSelectObject` *extends* `SelectShape`
 
 #### Parameters
 
@@ -777,7 +802,7 @@ A function that receives table references and returns an object with selected fi
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<\{ \[K in string \| number \| symbol\]: (Omit\<TContext, "result"\> & \{ result: \{ \[K in string \| number \| symbol\]: ResultTypeFromSelect\<TSelectObject\>\[K\] \} \})\[K\] \}\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`WithResult`\<`TContext`, `ResultTypeFromSelect`\<`TSelectObject`\>\>\>
 
 A QueryBuilder that returns only the selected fields
 
@@ -815,10 +840,10 @@ query
 ### where()
 
 ```ts
-where(callback): QueryBuilder<TContext>
+where(callback): QueryBuilder<TContext>;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:324](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L324)
+Defined in: [packages/db/src/query/builder/index.ts:366](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L366)
 
 Filter rows based on a condition
 
@@ -832,7 +857,7 @@ A function that receives table references and returns an expression
 
 #### Returns
 
-[`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+[`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 A QueryBuilder with the where condition applied
 
diff --git a/docs/reference/classes/CannotCombineEmptyExpressionListError.md b/docs/reference/classes/CannotCombineEmptyExpressionListError.md
new file mode 100644
index 000000000..aced73bc2
--- /dev/null
+++ b/docs/reference/classes/CannotCombineEmptyExpressionListError.md
@@ -0,0 +1,214 @@
+---
+id: CannotCombineEmptyExpressionListError
+title: CannotCombineEmptyExpressionListError
+---
+
+# Class: CannotCombineEmptyExpressionListError
+
+Defined in: [packages/db/src/errors.ts:673](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L673)
+
+## Extends
+
+- [`QueryOptimizerError`](QueryOptimizerError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new CannotCombineEmptyExpressionListError(): CannotCombineEmptyExpressionListError;
+```
+
+Defined in: [packages/db/src/errors.ts:674](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L674)
+
+#### Returns
+
+`CannotCombineEmptyExpressionListError`
+
+#### Overrides
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`constructor`](QueryOptimizerError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`cause`](QueryOptimizerError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`message`](QueryOptimizerError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`name`](QueryOptimizerError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`stack`](QueryOptimizerError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`stackTraceLimit`](QueryOptimizerError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`captureStackTrace`](QueryOptimizerError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`prepareStackTrace`](QueryOptimizerError.md#preparestacktrace)
diff --git a/docs/reference/classes/CollectionConfigurationError.md b/docs/reference/classes/CollectionConfigurationError.md
new file mode 100644
index 000000000..e71badeba
--- /dev/null
+++ b/docs/reference/classes/CollectionConfigurationError.md
@@ -0,0 +1,227 @@
+---
+id: CollectionConfigurationError
+title: CollectionConfigurationError
+---
+
+# Class: CollectionConfigurationError
+
+Defined in: [packages/db/src/errors.ts:71](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L71)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`CollectionRequiresConfigError`](CollectionRequiresConfigError.md)
+- [`CollectionRequiresSyncConfigError`](CollectionRequiresSyncConfigError.md)
+- [`InvalidSchemaError`](InvalidSchemaError.md)
+- [`SchemaMustBeSynchronousError`](SchemaMustBeSynchronousError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new CollectionConfigurationError(message): CollectionConfigurationError;
+```
+
+Defined in: [packages/db/src/errors.ts:72](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L72)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`CollectionConfigurationError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/collectionimpl.md b/docs/reference/classes/CollectionImpl.md
similarity index 50%
rename from docs/reference/classes/collectionimpl.md
rename to docs/reference/classes/CollectionImpl.md
index 4b41d1cc9..98a0cb5fc 100644
--- a/docs/reference/classes/collectionimpl.md
+++ b/docs/reference/classes/CollectionImpl.md
@@ -3,37 +3,46 @@ id: CollectionImpl
 title: CollectionImpl
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
+# Class: CollectionImpl\<TOutput, TKey, TUtils, TSchema, TInput\>
 
-# Class: CollectionImpl\<T, TKey, TUtils, TSchema, TInsertInput\>
-
-Defined in: [packages/db/src/collection.ts:204](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L204)
+Defined in: [packages/db/src/collection/index.ts:266](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L266)
 
 ## Extended by
 
-- [`Collection`](../../interfaces/collection.md)
+- [`Collection`](../interfaces/Collection.md)
 
 ## Type Parameters
 
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
+### TOutput
+
+`TOutput` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TUtils
 
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md) = \{
+\}
 
-• **TUtils** *extends* [`UtilsRecord`](../../type-aliases/utilsrecord.md) = \{\}
+### TSchema
 
-• **TSchema** *extends* `StandardSchemaV1` = `StandardSchemaV1`
+`TSchema` *extends* `StandardSchemaV1` = `StandardSchemaV1`
 
-• **TInsertInput** *extends* `object` = `T`
+### TInput
+
+`TInput` *extends* `object` = `TOutput`
 
 ## Constructors
 
-### new CollectionImpl()
+### Constructor
 
 ```ts
-new CollectionImpl<T, TKey, TUtils, TSchema, TInsertInput>(config): CollectionImpl<T, TKey, TUtils, TSchema, TInsertInput>
+new CollectionImpl<TOutput, TKey, TUtils, TSchema, TInput>(config): CollectionImpl<TOutput, TKey, TUtils, TSchema, TInput>;
 ```
 
-Defined in: [packages/db/src/collection.ts:407](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L407)
+Defined in: [packages/db/src/collection/index.ts:305](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L305)
 
 Creates a new Collection instance
 
@@ -41,13 +50,13 @@ Creates a new Collection instance
 
 ##### config
 
-[`CollectionConfig`](../../interfaces/collectionconfig.md)\<`T`, `TKey`, `TSchema`, `TInsertInput`\>
+[`CollectionConfig`](../interfaces/CollectionConfig.md)\<`TOutput`, `TKey`, `TSchema`\>
 
 Configuration object for the collection
 
 #### Returns
 
-[`CollectionImpl`](../collectionimpl.md)\<`T`, `TKey`, `TUtils`, `TSchema`, `TInsertInput`\>
+`CollectionImpl`\<`TOutput`, `TKey`, `TUtils`, `TSchema`, `TInput`\>
 
 #### Throws
 
@@ -55,111 +64,117 @@ Error if sync config is missing
 
 ## Properties
 
-### config
+### \_lifecycle
 
 ```ts
-config: CollectionConfig<T, TKey, TSchema, TInsertInput>;
+_lifecycle: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>;
 ```
 
-Defined in: [packages/db/src/collection.ts:211](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L211)
+Defined in: [packages/db/src/collection/index.ts:283](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L283)
 
 ***
 
-### id
+### \_state
 
 ```ts
-id: string;
+_state: CollectionStateManager<TOutput, TKey, TSchema, TInput>;
 ```
 
-Defined in: [packages/db/src/collection.ts:331](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L331)
+Defined in: [packages/db/src/collection/index.ts:295](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L295)
 
 ***
 
-### optimisticDeletes
+### \_sync
 
 ```ts
-optimisticDeletes: Set<TKey>;
+_sync: CollectionSyncManager<TOutput, TKey, TSchema, TInput>;
 ```
 
-Defined in: [packages/db/src/collection.ts:221](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L221)
+Defined in: [packages/db/src/collection/index.ts:284](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L284)
 
 ***
 
-### optimisticUpserts
+### config
 
 ```ts
-optimisticUpserts: Map<TKey, T>;
+config: CollectionConfig<TOutput, TKey, TSchema>;
 ```
 
-Defined in: [packages/db/src/collection.ts:220](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L220)
+Defined in: [packages/db/src/collection/index.ts:274](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L274)
 
 ***
 
-### pendingSyncedTransactions
+### id
 
 ```ts
-pendingSyncedTransactions: PendingSyncedTransaction<T>[] = [];
+id: string;
 ```
 
-Defined in: [packages/db/src/collection.ts:215](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L215)
+Defined in: [packages/db/src/collection/index.ts:273](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L273)
 
 ***
 
-### syncedData
+### utils
 
 ```ts
-syncedData: Map<TKey, T> | SortedMap<TKey, T>;
+utils: Record<string, Fn> = {};
 ```
 
-Defined in: [packages/db/src/collection.ts:216](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L216)
+Defined in: [packages/db/src/collection/index.ts:278](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L278)
 
-***
+## Accessors
 
-### syncedMetadata
+### compareOptions
+
+#### Get Signature
 
 ```ts
-syncedMetadata: Map<TKey, unknown>;
+get compareOptions(): StringCollationConfig;
 ```
 
-Defined in: [packages/db/src/collection.ts:217](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L217)
+Defined in: [packages/db/src/collection/index.ts:580](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L580)
+
+##### Returns
+
+[`StringCollationConfig`](../type-aliases/StringCollationConfig.md)
 
 ***
 
-### transactions
+### indexes
+
+#### Get Signature
 
 ```ts
-transactions: SortedMap<string, Transaction<any>>;
+get indexes(): Map<number, BaseIndex<TKey>>;
 ```
 
-Defined in: [packages/db/src/collection.ts:214](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L214)
-
-***
+Defined in: [packages/db/src/collection/index.ts:565](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L565)
 
-### utils
+Get resolved indexes for query optimization
 
-```ts
-utils: Record<string, Fn> = {};
-```
+##### Returns
 
-Defined in: [packages/db/src/collection.ts:238](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L238)
+`Map`\<`number`, [`BaseIndex`](BaseIndex.md)\<`TKey`\>\>
 
-## Accessors
+***
 
-### indexes
+### isLoadingSubset
 
 #### Get Signature
 
 ```ts
-get indexes(): Map<number, BaseIndex<TKey>>
+get isLoadingSubset(): boolean;
 ```
 
-Defined in: [packages/db/src/collection.ts:1439](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1439)
+Defined in: [packages/db/src/collection/index.ts:431](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L431)
 
-Get resolved indexes for query optimization
+Check if the collection is currently loading more data
 
 ##### Returns
 
-`Map`\<`number`, [`BaseIndex`](../baseindex.md)\<`TKey`\>\>
+`boolean`
+
+true if the collection has pending load more operations, false otherwise
 
 ***
 
@@ -168,10 +183,10 @@ Get resolved indexes for query optimization
 #### Get Signature
 
 ```ts
-get size(): number
+get size(): number;
 ```
 
-Defined in: [packages/db/src/collection.ts:995](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L995)
+Defined in: [packages/db/src/collection/index.ts:468](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L468)
 
 Get the current size of the collection (cached)
 
@@ -186,10 +201,10 @@ Get the current size of the collection (cached)
 #### Get Signature
 
 ```ts
-get state(): Map<TKey, T>
+get state(): Map<TKey, TOutput>;
 ```
 
-Defined in: [packages/db/src/collection.ts:2038](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2038)
+Defined in: [packages/db/src/collection/index.ts:757](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L757)
 
 Gets the current state of the collection as a Map
 
@@ -211,7 +226,7 @@ if (itemsMap.has("todo-1")) {
 
 ##### Returns
 
-`Map`\<`TKey`, `T`\>
+`Map`\<`TKey`, `TOutput`\>
 
 Map containing all items in the collection, with keys as identifiers
 
@@ -222,16 +237,34 @@ Map containing all items in the collection, with keys as identifiers
 #### Get Signature
 
 ```ts
-get status(): CollectionStatus
+get status(): CollectionStatus;
 ```
 
-Defined in: [packages/db/src/collection.ts:336](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L336)
+Defined in: [packages/db/src/collection/index.ts:386](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L386)
 
 Gets the current status of the collection
 
 ##### Returns
 
-[`CollectionStatus`](../../type-aliases/collectionstatus.md)
+[`CollectionStatus`](../type-aliases/CollectionStatus.md)
+
+***
+
+### subscriberCount
+
+#### Get Signature
+
+```ts
+get subscriberCount(): number;
+```
+
+Defined in: [packages/db/src/collection/index.ts:393](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L393)
+
+Get the number of subscribers to the collection
+
+##### Returns
+
+`number`
 
 ***
 
@@ -240,16 +273,16 @@ Gets the current status of the collection
 #### Get Signature
 
 ```ts
-get toArray(): T[]
+get toArray(): TOutput[];
 ```
 
-Defined in: [packages/db/src/collection.ts:2071](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2071)
+Defined in: [packages/db/src/collection/index.ts:786](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L786)
 
 Gets the current state of the collection as an Array
 
 ##### Returns
 
-`T`[]
+`TOutput`[]
 
 An Array containing all items in the collection
 
@@ -258,26 +291,26 @@ An Array containing all items in the collection
 ### \[iterator\]()
 
 ```ts
-iterator: IterableIterator<[TKey, T]>
+iterator: IterableIterator<[TKey, TOutput]>;
 ```
 
-Defined in: [packages/db/src/collection.ts:1046](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1046)
+Defined in: [packages/db/src/collection/index.ts:496](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L496)
 
 Get all entries (virtual derived state)
 
 #### Returns
 
-`IterableIterator`\<\[`TKey`, `T`\]\>
+`IterableIterator`\<\[`TKey`, `TOutput`\]\>
 
 ***
 
 ### cleanup()
 
 ```ts
-cleanup(): Promise<void>
+cleanup(): Promise<void>;
 ```
 
-Defined in: [packages/db/src/collection.ts:583](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L583)
+Defined in: [packages/db/src/collection/index.ts:923](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L923)
 
 Clean up the collection by stopping sync and clearing data
 This can be called manually or automatically by garbage collection
@@ -288,38 +321,23 @@ This can be called manually or automatically by garbage collection
 
 ***
 
-### commitPendingTransactions()
-
-```ts
-commitPendingTransactions(): void
-```
-
-Defined in: [packages/db/src/collection.ts:1082](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1082)
-
-Attempts to commit pending synced transactions if there are no active transactions
-This method processes operations from pending transactions and applies them to the synced data
-
-#### Returns
-
-`void`
-
-***
-
 ### createIndex()
 
 ```ts
-createIndex<TResolver>(indexCallback, config): IndexProxy<TKey>
+createIndex<TResolver>(indexCallback, config): IndexProxy<TKey>;
 ```
 
-Defined in: [packages/db/src/collection.ts:1344](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1344)
+Defined in: [packages/db/src/collection/index.ts:555](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L555)
 
 Creates an index on a collection for faster queries.
-Indexes significantly improve query performance by allowing binary search
-and range queries instead of full scans.
+Indexes significantly improve query performance by allowing constant time lookups
+and logarithmic time range queries instead of full scans.
 
 #### Type Parameters
 
-• **TResolver** *extends* [`IndexResolver`](../../type-aliases/indexresolver.md)\<`TKey`\> = *typeof* [`BTreeIndex`](../btreeindex.md)
+##### TResolver
+
+`TResolver` *extends* [`IndexResolver`](../type-aliases/IndexResolver.md)\<`TKey`\> = *typeof* [`BTreeIndex`](BTreeIndex.md)
 
 The type of the index resolver (constructor or async loader)
 
@@ -333,13 +351,13 @@ Function that extracts the indexed value from each item
 
 ##### config
 
-[`IndexOptions`](../../interfaces/indexoptions.md)\<`TResolver`\> = `{}`
+[`IndexOptions`](../interfaces/IndexOptions.md)\<`TResolver`\> = `{}`
 
 Configuration including index type and type-specific options
 
 #### Returns
 
-[`IndexProxy`](../indexproxy.md)\<`TKey`\>
+[`IndexProxy`](IndexProxy.md)\<`TKey`\>
 
 An index proxy that provides access to the index when ready
 
@@ -352,7 +370,10 @@ const ageIndex = collection.createIndex((row) => row.age)
 // Create a ordered index with custom options
 const ageIndex = collection.createIndex((row) => row.age, {
   indexType: BTreeIndex,
-  options: { compareFn: customComparator },
+  options: {
+    compareFn: customComparator,
+    compareOptions: { direction: 'asc', nulls: 'first', stringSort: 'lexical' }
+  },
   name: 'age_btree'
 })
 
@@ -371,10 +392,12 @@ const textIndex = collection.createIndex((row) => row.content, {
 ### currentStateAsChanges()
 
 ```ts
-currentStateAsChanges(options): ChangeMessage<T, string | number>[]
+currentStateAsChanges(options): 
+  | void
+  | ChangeMessage<TOutput, string | number>[];
 ```
 
-Defined in: [packages/db/src/collection.ts:2113](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2113)
+Defined in: [packages/db/src/collection/index.ts:824](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L824)
 
 Returns the current state of the collection as an array of changes
 
@@ -382,13 +405,14 @@ Returns the current state of the collection as an array of changes
 
 ##### options
 
-[`CurrentStateAsChangesOptions`](../../interfaces/currentstateaschangesoptions.md)\<`T`\> = `{}`
+[`CurrentStateAsChangesOptions`](../interfaces/CurrentStateAsChangesOptions.md) = `{}`
 
 Options including optional where filter
 
 #### Returns
 
-[`ChangeMessage`](../../interfaces/changemessage.md)\<`T`, `string` \| `number`\>[]
+  \| `void`
+  \| [`ChangeMessage`](../interfaces/ChangeMessage.md)\<`TOutput`, `string` \| `number`\>[]
 
 An array of changes
 
@@ -414,10 +438,10 @@ const activeChanges = collection.currentStateAsChanges({
 ### delete()
 
 ```ts
-delete(keys, config?): Transaction<any>
+delete(keys, config?): Transaction<any>;
 ```
 
-Defined in: [packages/db/src/collection.ts:1939](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1939)
+Defined in: [packages/db/src/collection/index.ts:734](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L734)
 
 Deletes one or more items from the collection
 
@@ -431,13 +455,13 @@ Single key or array of keys to delete
 
 ##### config?
 
-[`OperationConfig`](../../interfaces/operationconfig.md)
+[`OperationConfig`](../interfaces/OperationConfig.md)
 
 Optional configuration including metadata
 
 #### Returns
 
-[`Transaction`](../transaction.md)\<`any`\>
+[`Transaction`](../interfaces/Transaction.md)\<`any`\>
 
 A Transaction object representing the delete operation(s)
 
@@ -477,26 +501,26 @@ try {
 ### entries()
 
 ```ts
-entries(): IterableIterator<[TKey, T]>
+entries(): IterableIterator<[TKey, TOutput]>;
 ```
 
-Defined in: [packages/db/src/collection.ts:1034](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1034)
+Defined in: [packages/db/src/collection/index.ts:489](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L489)
 
 Get all entries (virtual derived state)
 
 #### Returns
 
-`IterableIterator`\<\[`TKey`, `T`\]\>
+`IterableIterator`\<\[`TKey`, `TOutput`\]\>
 
 ***
 
 ### forEach()
 
 ```ts
-forEach(callbackfn): void
+forEach(callbackfn): void;
 ```
 
-Defined in: [packages/db/src/collection.ts:1055](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1055)
+Defined in: [packages/db/src/collection/index.ts:503](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L503)
 
 Execute a callback for each entry in the collection
 
@@ -512,37 +536,13 @@ Execute a callback for each entry in the collection
 
 ***
 
-### generateGlobalKey()
-
-```ts
-generateGlobalKey(key, item): string
-```
-
-Defined in: [packages/db/src/collection.ts:1306](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1306)
-
-#### Parameters
-
-##### key
-
-`any`
-
-##### item
-
-`any`
-
-#### Returns
-
-`string`
-
-***
-
 ### get()
 
 ```ts
-get(key): undefined | T
+get(key): TOutput | undefined;
 ```
 
-Defined in: [packages/db/src/collection.ts:959](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L959)
+Defined in: [packages/db/src/collection/index.ts:454](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L454)
 
 Get the current value for a key (virtual derived state)
 
@@ -554,23 +554,23 @@ Get the current value for a key (virtual derived state)
 
 #### Returns
 
-`undefined` \| `T`
+`TOutput` \| `undefined`
 
 ***
 
 ### getKeyFromItem()
 
 ```ts
-getKeyFromItem(item): TKey
+getKeyFromItem(item): TKey;
 ```
 
-Defined in: [packages/db/src/collection.ts:1302](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1302)
+Defined in: [packages/db/src/collection/index.ts:518](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L518)
 
 #### Parameters
 
 ##### item
 
-`T`
+`TOutput`
 
 #### Returns
 
@@ -581,10 +581,10 @@ Defined in: [packages/db/src/collection.ts:1302](https://github.com/TanStack/db/
 ### has()
 
 ```ts
-has(key): boolean
+has(key): boolean;
 ```
 
-Defined in: [packages/db/src/collection.ts:977](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L977)
+Defined in: [packages/db/src/collection/index.ts:461](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L461)
 
 Check if a key exists in the collection (virtual derived state)
 
@@ -605,10 +605,10 @@ Check if a key exists in the collection (virtual derived state)
 ```ts
 insert(data, config?): 
   | Transaction<Record<string, unknown>>
-| Transaction<T>
+| Transaction<TOutput>;
 ```
 
-Defined in: [packages/db/src/collection.ts:1594](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1594)
+Defined in: [packages/db/src/collection/index.ts:621](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L621)
 
 Inserts one or more items into the collection
 
@@ -616,18 +616,18 @@ Inserts one or more items into the collection
 
 ##### data
 
-`TInsertInput` | `TInsertInput`[]
+`TInput` | `TInput`[]
 
 ##### config?
 
-[`InsertConfig`](../../interfaces/insertconfig.md)
+[`InsertConfig`](../interfaces/InsertConfig.md)
 
 Optional configuration including metadata
 
 #### Returns
 
-  \| [`Transaction`](../transaction.md)\<`Record`\<`string`, `unknown`\>\>
-  \| [`Transaction`](../transaction.md)\<`T`\>
+  \| [`Transaction`](../interfaces/Transaction.md)\<`Record`\<`string`, `unknown`\>\>
+  \| [`Transaction`](../interfaces/Transaction.md)\<`TOutput`\>
 
 A Transaction object representing the insert operation(s)
 
@@ -676,10 +676,10 @@ try {
 ### isReady()
 
 ```ts
-isReady(): boolean
+isReady(): boolean;
 ```
 
-Defined in: [packages/db/src/collection.ts:294](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L294)
+Defined in: [packages/db/src/collection/index.ts:423](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L423)
 
 Check if the collection is ready for use
 Returns true if the collection has been marked as ready by its sync implementation
@@ -706,10 +706,10 @@ if (collection.isReady()) {
 ### keys()
 
 ```ts
-keys(): IterableIterator<TKey>
+keys(): IterableIterator<TKey>;
 ```
 
-Defined in: [packages/db/src/collection.ts:1002](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1002)
+Defined in: [packages/db/src/collection/index.ts:475](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L475)
 
 Get all keys (virtual derived state)
 
@@ -722,16 +722,18 @@ Get all keys (virtual derived state)
 ### map()
 
 ```ts
-map<U>(callbackfn): U[]
+map<U>(callbackfn): U[];
 ```
 
-Defined in: [packages/db/src/collection.ts:1067](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1067)
+Defined in: [packages/db/src/collection/index.ts:512](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L512)
 
 Create a new array with the results of calling a function for each entry in the collection
 
 #### Type Parameters
 
-• **U**
+##### U
+
+`U`
 
 #### Parameters
 
@@ -745,64 +747,182 @@ Create a new array with the results of calling a function for each entry in the
 
 ***
 
-### onFirstReady()
+### off()
 
 ```ts
-onFirstReady(callback): void
+off<T>(event, callback): void;
 ```
 
-Defined in: [packages/db/src/collection.ts:272](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L272)
+Defined in: [packages/db/src/collection/index.ts:902](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L902)
 
-Register a callback to be executed when the collection first becomes ready
-Useful for preloading collections
+Unsubscribe from a collection event
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* 
+  \| `"status:idle"`
+  \| `"status:loading"`
+  \| `"status:ready"`
+  \| `"status:error"`
+  \| `"status:cleaned-up"`
+  \| `"status:change"`
+  \| `"subscribers:change"`
+  \| `"loadingSubset:change"`
+  \| `"truncate"`
 
 #### Parameters
 
+##### event
+
+`T`
+
 ##### callback
 
-() => `void`
+`CollectionEventHandler`\<`T`\>
 
-Function to call when the collection first becomes ready
+#### Returns
+
+`void`
+
+***
+
+### on()
+
+```ts
+on<T>(event, callback): () => void;
+```
+
+Defined in: [packages/db/src/collection/index.ts:882](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L882)
+
+Subscribe to a collection event
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* 
+  \| `"status:idle"`
+  \| `"status:loading"`
+  \| `"status:ready"`
+  \| `"status:error"`
+  \| `"status:cleaned-up"`
+  \| `"status:change"`
+  \| `"subscribers:change"`
+  \| `"loadingSubset:change"`
+  \| `"truncate"`
+
+#### Parameters
+
+##### event
+
+`T`
+
+##### callback
+
+`CollectionEventHandler`\<`T`\>
 
 #### Returns
 
+```ts
+(): void;
+```
+
+##### Returns
+
 `void`
 
-#### Example
+***
+
+### once()
 
 ```ts
-collection.onFirstReady(() => {
-  console.log('Collection is ready for the first time')
-  // Safe to access collection.state now
-})
+once<T>(event, callback): () => void;
 ```
 
+Defined in: [packages/db/src/collection/index.ts:892](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L892)
+
+Subscribe to a collection event once
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* 
+  \| `"status:idle"`
+  \| `"status:loading"`
+  \| `"status:ready"`
+  \| `"status:error"`
+  \| `"status:cleaned-up"`
+  \| `"status:change"`
+  \| `"subscribers:change"`
+  \| `"loadingSubset:change"`
+  \| `"truncate"`
+
+#### Parameters
+
+##### event
+
+`T`
+
+##### callback
+
+`CollectionEventHandler`\<`T`\>
+
+#### Returns
+
+```ts
+(): void;
+```
+
+##### Returns
+
+`void`
+
 ***
 
-### onTransactionStateChange()
+### onFirstReady()
 
 ```ts
-onTransactionStateChange(): void
+onFirstReady(callback): void;
 ```
 
-Defined in: [packages/db/src/collection.ts:2271](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2271)
+Defined in: [packages/db/src/collection/index.ts:407](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L407)
+
+Register a callback to be executed when the collection first becomes ready
+Useful for preloading collections
+
+#### Parameters
+
+##### callback
+
+() => `void`
 
-Trigger a recomputation when transactions change
-This method should be called by the Transaction class when state changes
+Function to call when the collection first becomes ready
 
 #### Returns
 
 `void`
 
+#### Example
+
+```ts
+collection.onFirstReady(() => {
+  console.log('Collection is ready for the first time')
+  // Safe to access collection.state now
+})
+```
+
 ***
 
 ### preload()
 
 ```ts
-preload(): Promise<void>
+preload(): Promise<void>;
 ```
 
-Defined in: [packages/db/src/collection.ts:544](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L544)
+Defined in: [packages/db/src/collection/index.ts:447](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L447)
 
 Preload the collection data by starting sync if not already started
 Multiple concurrent calls will share the same promise
@@ -816,10 +936,10 @@ Multiple concurrent calls will share the same promise
 ### startSyncImmediate()
 
 ```ts
-startSyncImmediate(): void
+startSyncImmediate(): void;
 ```
 
-Defined in: [packages/db/src/collection.ts:450](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L450)
+Defined in: [packages/db/src/collection/index.ts:439](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L439)
 
 Start sync immediately - internal method for compiled queries
 This bypasses lazy loading for special cases like live query results
@@ -833,17 +953,17 @@ This bypasses lazy loading for special cases like live query results
 ### stateWhenReady()
 
 ```ts
-stateWhenReady(): Promise<Map<TKey, T>>
+stateWhenReady(): Promise<Map<TKey, TOutput>>;
 ```
 
-Defined in: [packages/db/src/collection.ts:2052](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2052)
+Defined in: [packages/db/src/collection/index.ts:771](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L771)
 
 Gets the current state of the collection as a Map, but only resolves when data is available
 Waits for the first sync commit to complete before resolving
 
 #### Returns
 
-`Promise`\<`Map`\<`TKey`, `T`\>\>
+`Promise`\<`Map`\<`TKey`, `TOutput`\>\>
 
 Promise that resolves to a Map containing all items in the collection
 
@@ -852,10 +972,10 @@ Promise that resolves to a Map containing all items in the collection
 ### subscribeChanges()
 
 ```ts
-subscribeChanges(callback, options): () => void
+subscribeChanges(callback, options): CollectionSubscription;
 ```
 
-Defined in: [packages/db/src/collection.ts:2158](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2158)
+Defined in: [packages/db/src/collection/index.ts:872](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L872)
 
 Subscribe to changes in the collection
 
@@ -869,115 +989,75 @@ Function called when items change
 
 ##### options
 
-[`SubscribeChangesOptions`](../../interfaces/subscribechangesoptions.md)\<`T`\> = `{}`
+[`SubscribeChangesOptions`](../interfaces/SubscribeChangesOptions.md)\<`TOutput`\> = `{}`
 
 Subscription options including includeInitialState and where filter
 
 #### Returns
 
-`Function`
+`CollectionSubscription`
 
 Unsubscribe function - Call this to stop listening for changes
 
-##### Returns
-
-`void`
-
 #### Examples
 
 ```ts
 // Basic subscription
-const unsubscribe = collection.subscribeChanges((changes) => {
+const subscription = collection.subscribeChanges((changes) => {
   changes.forEach(change => {
     console.log(`${change.type}: ${change.key}`, change.value)
   })
 })
 
-// Later: unsubscribe()
+// Later: subscription.unsubscribe()
 ```
 
 ```ts
 // Include current state immediately
-const unsubscribe = collection.subscribeChanges((changes) => {
+const subscription = collection.subscribeChanges((changes) => {
   updateUI(changes)
 }, { includeInitialState: true })
 ```
 
 ```ts
-// Subscribe only to changes matching a condition
-const unsubscribe = collection.subscribeChanges((changes) => {
+// Subscribe only to changes matching a condition using where callback
+import { eq } from "@tanstack/db"
+
+const subscription = collection.subscribeChanges((changes) => {
   updateUI(changes)
 }, {
   includeInitialState: true,
-  where: (row) => row.status === 'active'
+  where: (row) => eq(row.status, "active")
 })
 ```
 
 ```ts
-// Subscribe using a pre-compiled expression
-const unsubscribe = collection.subscribeChanges((changes) => {
+// Using multiple conditions with and()
+import { and, eq, gt } from "@tanstack/db"
+
+const subscription = collection.subscribeChanges((changes) => {
   updateUI(changes)
 }, {
-  includeInitialState: true,
-  whereExpression: eq(row.status, 'active')
+  where: (row) => and(eq(row.status, "active"), gt(row.priority, 5))
 })
 ```
 
 ***
 
-### subscribeChangesKey()
-
-```ts
-subscribeChangesKey(
-   key, 
-   listener, 
-   __namedParameters): () => void
-```
-
-Defined in: [packages/db/src/collection.ts:2197](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2197)
-
-Subscribe to changes for a specific key
-
-#### Parameters
-
-##### key
-
-`TKey`
-
-##### listener
-
-[`ChangeListener`](../../type-aliases/changelistener.md)\<`T`, `TKey`\>
-
-##### \_\_namedParameters
-
-###### includeInitialState?
-
-`boolean` = `false`
-
-#### Returns
-
-`Function`
-
-##### Returns
-
-`void`
-
-***
-
 ### toArrayWhenReady()
 
 ```ts
-toArrayWhenReady(): Promise<T[]>
+toArrayWhenReady(): Promise<TOutput[]>;
 ```
 
-Defined in: [packages/db/src/collection.ts:2081](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2081)
+Defined in: [packages/db/src/collection/index.ts:796](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L796)
 
 Gets the current state of the collection as an Array, but only resolves when data is available
 Waits for the first sync commit to complete before resolving
 
 #### Returns
 
-`Promise`\<`T`[]\>
+`Promise`\<`TOutput`[]\>
 
 Promise that resolves to an Array containing all items in the collection
 
@@ -988,17 +1068,13 @@ Promise that resolves to an Array containing all items in the collection
 #### Call Signature
 
 ```ts
-update<TItem>(key, callback): Transaction
+update(key, callback): Transaction;
 ```
 
-Defined in: [packages/db/src/collection.ts:1725](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1725)
+Defined in: [packages/db/src/collection/index.ts:666](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L666)
 
 Updates one or more items in the collection using a callback function
 
-##### Type Parameters
-
-• **TItem** *extends* `object` = `T`
-
 ##### Parameters
 
 ###### key
@@ -1011,7 +1087,7 @@ Updates one or more items in the collection using a callback function
 
 ##### Returns
 
-[`Transaction`](../transaction.md)
+[`Transaction`](../interfaces/Transaction.md)
 
 A Transaction object representing the update operation(s)
 
@@ -1060,20 +1136,16 @@ try {
 #### Call Signature
 
 ```ts
-update<TItem>(
+update(
    keys, 
    config, 
-   callback): Transaction
+   callback): Transaction;
 ```
 
-Defined in: [packages/db/src/collection.ts:1731](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1731)
+Defined in: [packages/db/src/collection/index.ts:672](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L672)
 
 Updates one or more items in the collection using a callback function
 
-##### Type Parameters
-
-• **TItem** *extends* `object` = `T`
-
 ##### Parameters
 
 ###### keys
@@ -1084,7 +1156,7 @@ Single key or array of keys to update
 
 ###### config
 
-[`OperationConfig`](../../interfaces/operationconfig.md)
+[`OperationConfig`](../interfaces/OperationConfig.md)
 
 ###### callback
 
@@ -1092,7 +1164,7 @@ Single key or array of keys to update
 
 ##### Returns
 
-[`Transaction`](../transaction.md)
+[`Transaction`](../interfaces/Transaction.md)
 
 A Transaction object representing the update operation(s)
 
@@ -1141,17 +1213,13 @@ try {
 #### Call Signature
 
 ```ts
-update<TItem>(id, callback): Transaction
+update(id, callback): Transaction;
 ```
 
-Defined in: [packages/db/src/collection.ts:1738](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1738)
+Defined in: [packages/db/src/collection/index.ts:679](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L679)
 
 Updates one or more items in the collection using a callback function
 
-##### Type Parameters
-
-• **TItem** *extends* `object` = `T`
-
 ##### Parameters
 
 ###### id
@@ -1164,7 +1232,7 @@ Updates one or more items in the collection using a callback function
 
 ##### Returns
 
-[`Transaction`](../transaction.md)
+[`Transaction`](../interfaces/Transaction.md)
 
 A Transaction object representing the update operation(s)
 
@@ -1213,20 +1281,16 @@ try {
 #### Call Signature
 
 ```ts
-update<TItem>(
+update(
    id, 
    config, 
-   callback): Transaction
+   callback): Transaction;
 ```
 
-Defined in: [packages/db/src/collection.ts:1744](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1744)
+Defined in: [packages/db/src/collection/index.ts:685](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L685)
 
 Updates one or more items in the collection using a callback function
 
-##### Type Parameters
-
-• **TItem** *extends* `object` = `T`
-
 ##### Parameters
 
 ###### id
@@ -1235,7 +1299,7 @@ Updates one or more items in the collection using a callback function
 
 ###### config
 
-[`OperationConfig`](../../interfaces/operationconfig.md)
+[`OperationConfig`](../interfaces/OperationConfig.md)
 
 ###### callback
 
@@ -1243,7 +1307,7 @@ Updates one or more items in the collection using a callback function
 
 ##### Returns
 
-[`Transaction`](../transaction.md)
+[`Transaction`](../interfaces/Transaction.md)
 
 A Transaction object representing the update operation(s)
 
@@ -1291,16 +1355,90 @@ try {
 
 ***
 
+### validateData()
+
+```ts
+validateData(
+   data, 
+   type, 
+   key?): TOutput;
+```
+
+Defined in: [packages/db/src/collection/index.ts:572](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L572)
+
+Validates the data against the schema
+
+#### Parameters
+
+##### data
+
+`unknown`
+
+##### type
+
+`"insert"` | `"update"`
+
+##### key?
+
+`TKey`
+
+#### Returns
+
+`TOutput`
+
+***
+
 ### values()
 
 ```ts
-values(): IterableIterator<T>
+values(): IterableIterator<TOutput>;
 ```
 
-Defined in: [packages/db/src/collection.ts:1022](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1022)
+Defined in: [packages/db/src/collection/index.ts:482](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L482)
 
 Get all values (virtual derived state)
 
 #### Returns
 
-`IterableIterator`\<`T`\>
+`IterableIterator`\<`TOutput`\>
+
+***
+
+### waitFor()
+
+```ts
+waitFor<T>(event, timeout?): Promise<AllCollectionEvents[T]>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:912](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L912)
+
+Wait for a collection event
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* 
+  \| `"status:idle"`
+  \| `"status:loading"`
+  \| `"status:ready"`
+  \| `"status:error"`
+  \| `"status:cleaned-up"`
+  \| `"status:change"`
+  \| `"subscribers:change"`
+  \| `"loadingSubset:change"`
+  \| `"truncate"`
+
+#### Parameters
+
+##### event
+
+`T`
+
+##### timeout?
+
+`number`
+
+#### Returns
+
+`Promise`\<`AllCollectionEvents`\[`T`\]\>
diff --git a/docs/reference/classes/CollectionInErrorStateError.md b/docs/reference/classes/CollectionInErrorStateError.md
new file mode 100644
index 000000000..8c83cc03a
--- /dev/null
+++ b/docs/reference/classes/CollectionInErrorStateError.md
@@ -0,0 +1,224 @@
+---
+id: CollectionInErrorStateError
+title: CollectionInErrorStateError
+---
+
+# Class: CollectionInErrorStateError
+
+Defined in: [packages/db/src/errors.ts:110](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L110)
+
+## Extends
+
+- [`CollectionStateError`](CollectionStateError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new CollectionInErrorStateError(operation, collectionId): CollectionInErrorStateError;
+```
+
+Defined in: [packages/db/src/errors.ts:111](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L111)
+
+#### Parameters
+
+##### operation
+
+`string`
+
+##### collectionId
+
+`string`
+
+#### Returns
+
+`CollectionInErrorStateError`
+
+#### Overrides
+
+[`CollectionStateError`](CollectionStateError.md).[`constructor`](CollectionStateError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`cause`](CollectionStateError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`message`](CollectionStateError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`name`](CollectionStateError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`stack`](CollectionStateError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`stackTraceLimit`](CollectionStateError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`captureStackTrace`](CollectionStateError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`prepareStackTrace`](CollectionStateError.md#preparestacktrace)
diff --git a/docs/reference/classes/CollectionInputNotFoundError.md b/docs/reference/classes/CollectionInputNotFoundError.md
new file mode 100644
index 000000000..703b282da
--- /dev/null
+++ b/docs/reference/classes/CollectionInputNotFoundError.md
@@ -0,0 +1,234 @@
+---
+id: CollectionInputNotFoundError
+title: CollectionInputNotFoundError
+---
+
+# Class: CollectionInputNotFoundError
+
+Defined in: [packages/db/src/errors.ts:454](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L454)
+
+Error thrown when a collection input stream is not found during query compilation.
+In self-joins, each alias (e.g., 'employee', 'manager') requires its own input stream.
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new CollectionInputNotFoundError(
+   alias, 
+   collectionId?, 
+   availableKeys?): CollectionInputNotFoundError;
+```
+
+Defined in: [packages/db/src/errors.ts:455](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L455)
+
+#### Parameters
+
+##### alias
+
+`string`
+
+##### collectionId?
+
+`string`
+
+##### availableKeys?
+
+`string`[]
+
+#### Returns
+
+`CollectionInputNotFoundError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/CollectionIsInErrorStateError.md b/docs/reference/classes/CollectionIsInErrorStateError.md
new file mode 100644
index 000000000..86a1813a2
--- /dev/null
+++ b/docs/reference/classes/CollectionIsInErrorStateError.md
@@ -0,0 +1,214 @@
+---
+id: CollectionIsInErrorStateError
+title: CollectionIsInErrorStateError
+---
+
+# Class: CollectionIsInErrorStateError
+
+Defined in: [packages/db/src/errors.ts:126](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L126)
+
+## Extends
+
+- [`CollectionStateError`](CollectionStateError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new CollectionIsInErrorStateError(): CollectionIsInErrorStateError;
+```
+
+Defined in: [packages/db/src/errors.ts:127](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L127)
+
+#### Returns
+
+`CollectionIsInErrorStateError`
+
+#### Overrides
+
+[`CollectionStateError`](CollectionStateError.md).[`constructor`](CollectionStateError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`cause`](CollectionStateError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`message`](CollectionStateError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`name`](CollectionStateError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`stack`](CollectionStateError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`stackTraceLimit`](CollectionStateError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`captureStackTrace`](CollectionStateError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`prepareStackTrace`](CollectionStateError.md#preparestacktrace)
diff --git a/docs/reference/classes/CollectionOperationError.md b/docs/reference/classes/CollectionOperationError.md
new file mode 100644
index 000000000..f090d7b44
--- /dev/null
+++ b/docs/reference/classes/CollectionOperationError.md
@@ -0,0 +1,233 @@
+---
+id: CollectionOperationError
+title: CollectionOperationError
+---
+
+# Class: CollectionOperationError
+
+Defined in: [packages/db/src/errors.ts:139](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L139)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`UndefinedKeyError`](UndefinedKeyError.md)
+- [`InvalidKeyError`](InvalidKeyError.md)
+- [`DuplicateKeyError`](DuplicateKeyError.md)
+- [`DuplicateKeySyncError`](DuplicateKeySyncError.md)
+- [`MissingUpdateArgumentError`](MissingUpdateArgumentError.md)
+- [`NoKeysPassedToUpdateError`](NoKeysPassedToUpdateError.md)
+- [`UpdateKeyNotFoundError`](UpdateKeyNotFoundError.md)
+- [`KeyUpdateNotAllowedError`](KeyUpdateNotAllowedError.md)
+- [`NoKeysPassedToDeleteError`](NoKeysPassedToDeleteError.md)
+- [`DeleteKeyNotFoundError`](DeleteKeyNotFoundError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new CollectionOperationError(message): CollectionOperationError;
+```
+
+Defined in: [packages/db/src/errors.ts:140](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L140)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`CollectionOperationError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/CollectionRequiresConfigError.md b/docs/reference/classes/CollectionRequiresConfigError.md
new file mode 100644
index 000000000..6e1ac161f
--- /dev/null
+++ b/docs/reference/classes/CollectionRequiresConfigError.md
@@ -0,0 +1,214 @@
+---
+id: CollectionRequiresConfigError
+title: CollectionRequiresConfigError
+---
+
+# Class: CollectionRequiresConfigError
+
+Defined in: [packages/db/src/errors.ts:78](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L78)
+
+## Extends
+
+- [`CollectionConfigurationError`](CollectionConfigurationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new CollectionRequiresConfigError(): CollectionRequiresConfigError;
+```
+
+Defined in: [packages/db/src/errors.ts:79](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L79)
+
+#### Returns
+
+`CollectionRequiresConfigError`
+
+#### Overrides
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`constructor`](CollectionConfigurationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`cause`](CollectionConfigurationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`message`](CollectionConfigurationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`name`](CollectionConfigurationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`stack`](CollectionConfigurationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`stackTraceLimit`](CollectionConfigurationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`captureStackTrace`](CollectionConfigurationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`prepareStackTrace`](CollectionConfigurationError.md#preparestacktrace)
diff --git a/docs/reference/classes/CollectionRequiresSyncConfigError.md b/docs/reference/classes/CollectionRequiresSyncConfigError.md
new file mode 100644
index 000000000..99e4d12ce
--- /dev/null
+++ b/docs/reference/classes/CollectionRequiresSyncConfigError.md
@@ -0,0 +1,214 @@
+---
+id: CollectionRequiresSyncConfigError
+title: CollectionRequiresSyncConfigError
+---
+
+# Class: CollectionRequiresSyncConfigError
+
+Defined in: [packages/db/src/errors.ts:84](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L84)
+
+## Extends
+
+- [`CollectionConfigurationError`](CollectionConfigurationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new CollectionRequiresSyncConfigError(): CollectionRequiresSyncConfigError;
+```
+
+Defined in: [packages/db/src/errors.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L85)
+
+#### Returns
+
+`CollectionRequiresSyncConfigError`
+
+#### Overrides
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`constructor`](CollectionConfigurationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`cause`](CollectionConfigurationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`message`](CollectionConfigurationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`name`](CollectionConfigurationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`stack`](CollectionConfigurationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`stackTraceLimit`](CollectionConfigurationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`captureStackTrace`](CollectionConfigurationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`prepareStackTrace`](CollectionConfigurationError.md#preparestacktrace)
diff --git a/docs/reference/classes/CollectionStateError.md b/docs/reference/classes/CollectionStateError.md
new file mode 100644
index 000000000..5848428b0
--- /dev/null
+++ b/docs/reference/classes/CollectionStateError.md
@@ -0,0 +1,227 @@
+---
+id: CollectionStateError
+title: CollectionStateError
+---
+
+# Class: CollectionStateError
+
+Defined in: [packages/db/src/errors.ts:103](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L103)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`CollectionInErrorStateError`](CollectionInErrorStateError.md)
+- [`InvalidCollectionStatusTransitionError`](InvalidCollectionStatusTransitionError.md)
+- [`CollectionIsInErrorStateError`](CollectionIsInErrorStateError.md)
+- [`NegativeActiveSubscribersError`](NegativeActiveSubscribersError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new CollectionStateError(message): CollectionStateError;
+```
+
+Defined in: [packages/db/src/errors.ts:104](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L104)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`CollectionStateError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/DeduplicatedLoadSubset.md b/docs/reference/classes/DeduplicatedLoadSubset.md
new file mode 100644
index 000000000..490a8435e
--- /dev/null
+++ b/docs/reference/classes/DeduplicatedLoadSubset.md
@@ -0,0 +1,120 @@
+---
+id: DeduplicatedLoadSubset
+title: DeduplicatedLoadSubset
+---
+
+# Class: DeduplicatedLoadSubset
+
+Defined in: [packages/db/src/query/subset-dedupe.ts:34](https://github.com/TanStack/db/blob/main/packages/db/src/query/subset-dedupe.ts#L34)
+
+Deduplicated wrapper for a loadSubset function.
+Tracks what data has been loaded and avoids redundant calls by applying
+subset logic to predicates.
+
+## Param
+
+The options for the DeduplicatedLoadSubset
+
+## Param
+
+The underlying loadSubset function to wrap
+
+## Param
+
+An optional callback function that is invoked when a loadSubset call is deduplicated.
+                             If the call is deduplicated because the requested data is being loaded by an inflight request,
+                             then this callback is invoked when the inflight request completes successfully and the data is fully loaded.
+                             This callback is useful if you need to track rows per query, in which case you can't ignore deduplicated calls
+                             because you need to know which rows were loaded for each query.
+
+## Example
+
+```ts
+const dedupe = new DeduplicatedLoadSubset({ loadSubset: myLoadSubset, onDeduplicate: (opts) => console.log(`Call was deduplicated:`, opts) })
+
+// First call - fetches data
+await dedupe.loadSubset({ where: gt(ref('age'), val(10)) })
+
+// Second call - subset of first, returns true immediately
+await dedupe.loadSubset({ where: gt(ref('age'), val(20)) })
+
+// Clear state to start fresh
+dedupe.reset()
+```
+
+## Constructors
+
+### Constructor
+
+```ts
+new DeduplicatedLoadSubset(opts): DeduplicatedLoadSubset;
+```
+
+Defined in: [packages/db/src/query/subset-dedupe.ts:67](https://github.com/TanStack/db/blob/main/packages/db/src/query/subset-dedupe.ts#L67)
+
+#### Parameters
+
+##### opts
+
+###### loadSubset
+
+(`options`) => `true` \| `Promise`\<`void`\>
+
+###### onDeduplicate?
+
+(`options`) => `void`
+
+#### Returns
+
+`DeduplicatedLoadSubset`
+
+## Methods
+
+### loadSubset()
+
+```ts
+loadSubset(options): true | Promise<void>;
+```
+
+Defined in: [packages/db/src/query/subset-dedupe.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/query/subset-dedupe.ts#L85)
+
+Load a subset of data, with automatic deduplication based on previously
+loaded predicates and in-flight requests.
+
+This method is auto-bound, so it can be safely passed as a callback without
+losing its `this` context (e.g., `loadSubset: dedupe.loadSubset` in a sync config).
+
+#### Parameters
+
+##### options
+
+[`LoadSubsetOptions`](../type-aliases/LoadSubsetOptions.md)
+
+The predicate options (where, orderBy, limit)
+
+#### Returns
+
+`true` \| `Promise`\<`void`\>
+
+true if data is already loaded, or a Promise that resolves when data is loaded
+
+***
+
+### reset()
+
+```ts
+reset(): void;
+```
+
+Defined in: [packages/db/src/query/subset-dedupe.ts:198](https://github.com/TanStack/db/blob/main/packages/db/src/query/subset-dedupe.ts#L198)
+
+Reset all tracking state.
+Clears the history of loaded predicates and in-flight calls.
+Use this when you want to start fresh, for example after clearing the underlying data store.
+
+Note: Any in-flight requests will still complete, but they will not update the tracking
+state after the reset. This prevents old requests from repopulating cleared state.
+
+#### Returns
+
+`void`
diff --git a/docs/reference/classes/DeleteKeyNotFoundError.md b/docs/reference/classes/DeleteKeyNotFoundError.md
new file mode 100644
index 000000000..31d23f4cf
--- /dev/null
+++ b/docs/reference/classes/DeleteKeyNotFoundError.md
@@ -0,0 +1,220 @@
+---
+id: DeleteKeyNotFoundError
+title: DeleteKeyNotFoundError
+---
+
+# Class: DeleteKeyNotFoundError
+
+Defined in: [packages/db/src/errors.ts:245](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L245)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new DeleteKeyNotFoundError(key): DeleteKeyNotFoundError;
+```
+
+Defined in: [packages/db/src/errors.ts:246](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L246)
+
+#### Parameters
+
+##### key
+
+`string` | `number`
+
+#### Returns
+
+`DeleteKeyNotFoundError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/DistinctRequiresSelectError.md b/docs/reference/classes/DistinctRequiresSelectError.md
new file mode 100644
index 000000000..0bdf047f1
--- /dev/null
+++ b/docs/reference/classes/DistinctRequiresSelectError.md
@@ -0,0 +1,214 @@
+---
+id: DistinctRequiresSelectError
+title: DistinctRequiresSelectError
+---
+
+# Class: DistinctRequiresSelectError
+
+Defined in: [packages/db/src/errors.ts:430](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L430)
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new DistinctRequiresSelectError(): DistinctRequiresSelectError;
+```
+
+Defined in: [packages/db/src/errors.ts:431](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L431)
+
+#### Returns
+
+`DistinctRequiresSelectError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/DuplicateAliasInSubqueryError.md b/docs/reference/classes/DuplicateAliasInSubqueryError.md
new file mode 100644
index 000000000..3df54274a
--- /dev/null
+++ b/docs/reference/classes/DuplicateAliasInSubqueryError.md
@@ -0,0 +1,228 @@
+---
+id: DuplicateAliasInSubqueryError
+title: DuplicateAliasInSubqueryError
+---
+
+# Class: DuplicateAliasInSubqueryError
+
+Defined in: [packages/db/src/errors.ts:475](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L475)
+
+Error thrown when a subquery uses the same alias as its parent query.
+This causes issues because parent and subquery would share the same input streams,
+leading to empty results or incorrect data (aggregation cross-leaking).
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new DuplicateAliasInSubqueryError(alias, parentAliases): DuplicateAliasInSubqueryError;
+```
+
+Defined in: [packages/db/src/errors.ts:476](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L476)
+
+#### Parameters
+
+##### alias
+
+`string`
+
+##### parentAliases
+
+`string`[]
+
+#### Returns
+
+`DuplicateAliasInSubqueryError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/DuplicateDbInstanceError.md b/docs/reference/classes/DuplicateDbInstanceError.md
new file mode 100644
index 000000000..2251277f2
--- /dev/null
+++ b/docs/reference/classes/DuplicateDbInstanceError.md
@@ -0,0 +1,214 @@
+---
+id: DuplicateDbInstanceError
+title: DuplicateDbInstanceError
+---
+
+# Class: DuplicateDbInstanceError
+
+Defined in: [packages/db/src/errors.ts:45](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L45)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new DuplicateDbInstanceError(): DuplicateDbInstanceError;
+```
+
+Defined in: [packages/db/src/errors.ts:46](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L46)
+
+#### Returns
+
+`DuplicateDbInstanceError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/DuplicateKeyError.md b/docs/reference/classes/DuplicateKeyError.md
new file mode 100644
index 000000000..fb6e0ba18
--- /dev/null
+++ b/docs/reference/classes/DuplicateKeyError.md
@@ -0,0 +1,220 @@
+---
+id: DuplicateKeyError
+title: DuplicateKeyError
+---
+
+# Class: DuplicateKeyError
+
+Defined in: [packages/db/src/errors.ts:163](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L163)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new DuplicateKeyError(key): DuplicateKeyError;
+```
+
+Defined in: [packages/db/src/errors.ts:164](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L164)
+
+#### Parameters
+
+##### key
+
+`string` | `number`
+
+#### Returns
+
+`DuplicateKeyError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/DuplicateKeySyncError.md b/docs/reference/classes/DuplicateKeySyncError.md
new file mode 100644
index 000000000..878d8c564
--- /dev/null
+++ b/docs/reference/classes/DuplicateKeySyncError.md
@@ -0,0 +1,241 @@
+---
+id: DuplicateKeySyncError
+title: DuplicateKeySyncError
+---
+
+# Class: DuplicateKeySyncError
+
+Defined in: [packages/db/src/errors.ts:171](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L171)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new DuplicateKeySyncError(
+   key, 
+   collectionId, 
+   options?): DuplicateKeySyncError;
+```
+
+Defined in: [packages/db/src/errors.ts:172](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L172)
+
+#### Parameters
+
+##### key
+
+`string` | `number`
+
+##### collectionId
+
+`string`
+
+##### options?
+
+###### hasCustomGetKey?
+
+`boolean`
+
+###### hasDistinct?
+
+`boolean`
+
+###### hasJoins?
+
+`boolean`
+
+#### Returns
+
+`DuplicateKeySyncError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/EmptyReferencePathError.md b/docs/reference/classes/EmptyReferencePathError.md
new file mode 100644
index 000000000..76586f4cc
--- /dev/null
+++ b/docs/reference/classes/EmptyReferencePathError.md
@@ -0,0 +1,214 @@
+---
+id: EmptyReferencePathError
+title: EmptyReferencePathError
+---
+
+# Class: EmptyReferencePathError
+
+Defined in: [packages/db/src/errors.ts:498](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L498)
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new EmptyReferencePathError(): EmptyReferencePathError;
+```
+
+Defined in: [packages/db/src/errors.ts:499](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L499)
+
+#### Returns
+
+`EmptyReferencePathError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/GroupByError.md b/docs/reference/classes/GroupByError.md
new file mode 100644
index 000000000..8876f38bb
--- /dev/null
+++ b/docs/reference/classes/GroupByError.md
@@ -0,0 +1,227 @@
+---
+id: GroupByError
+title: GroupByError
+---
+
+# Class: GroupByError
+
+Defined in: [packages/db/src/errors.ts:573](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L573)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`NonAggregateExpressionNotInGroupByError`](NonAggregateExpressionNotInGroupByError.md)
+- [`UnsupportedAggregateFunctionError`](UnsupportedAggregateFunctionError.md)
+- [`AggregateFunctionNotInSelectError`](AggregateFunctionNotInSelectError.md)
+- [`UnknownHavingExpressionTypeError`](UnknownHavingExpressionTypeError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new GroupByError(message): GroupByError;
+```
+
+Defined in: [packages/db/src/errors.ts:574](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L574)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`GroupByError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/HavingRequiresGroupByError.md b/docs/reference/classes/HavingRequiresGroupByError.md
new file mode 100644
index 000000000..d53276126
--- /dev/null
+++ b/docs/reference/classes/HavingRequiresGroupByError.md
@@ -0,0 +1,214 @@
+---
+id: HavingRequiresGroupByError
+title: HavingRequiresGroupByError
+---
+
+# Class: HavingRequiresGroupByError
+
+Defined in: [packages/db/src/errors.ts:436](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L436)
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new HavingRequiresGroupByError(): HavingRequiresGroupByError;
+```
+
+Defined in: [packages/db/src/errors.ts:437](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L437)
+
+#### Returns
+
+`HavingRequiresGroupByError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/indexproxy.md b/docs/reference/classes/IndexProxy.md
similarity index 81%
rename from docs/reference/classes/indexproxy.md
rename to docs/reference/classes/IndexProxy.md
index 7c612d7e6..203620ae0 100644
--- a/docs/reference/classes/indexproxy.md
+++ b/docs/reference/classes/IndexProxy.md
@@ -3,8 +3,6 @@ id: IndexProxy
 title: IndexProxy
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Class: IndexProxy\<TKey\>
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:131](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L131)
@@ -13,14 +11,16 @@ Proxy that provides synchronous interface while index loads asynchronously
 
 ## Type Parameters
 
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
 
 ## Constructors
 
-### new IndexProxy()
+### Constructor
 
 ```ts
-new IndexProxy<TKey>(indexId, lazyIndex): IndexProxy<TKey>
+new IndexProxy<TKey>(indexId, lazyIndex): IndexProxy<TKey>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:132](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L132)
@@ -33,11 +33,11 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:132](https://github.com/TanSt
 
 ##### lazyIndex
 
-[`LazyIndexWrapper`](../lazyindexwrapper.md)\<`TKey`\>
+[`LazyIndexWrapper`](LazyIndexWrapper.md)\<`TKey`\>
 
 #### Returns
 
-[`IndexProxy`](../indexproxy.md)\<`TKey`\>
+`IndexProxy`\<`TKey`\>
 
 ## Accessors
 
@@ -46,7 +46,7 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:132](https://github.com/TanSt
 #### Get Signature
 
 ```ts
-get expression(): BasicExpression
+get expression(): BasicExpression;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:178](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L178)
@@ -55,7 +55,7 @@ Get the index expression (available immediately)
 
 ##### Returns
 
-`BasicExpression`
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)
 
 ***
 
@@ -64,7 +64,7 @@ Get the index expression (available immediately)
 #### Get Signature
 
 ```ts
-get id(): number
+get id(): number;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:161](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L161)
@@ -82,7 +82,7 @@ Get the index ID
 #### Get Signature
 
 ```ts
-get index(): BaseIndex<TKey>
+get index(): BaseIndex<TKey>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:140](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L140)
@@ -91,7 +91,7 @@ Get the resolved index (throws if not ready)
 
 ##### Returns
 
-[`BaseIndex`](../baseindex.md)\<`TKey`\>
+[`BaseIndex`](BaseIndex.md)\<`TKey`\>
 
 ***
 
@@ -100,7 +100,7 @@ Get the resolved index (throws if not ready)
 #### Get Signature
 
 ```ts
-get indexedKeysSet(): Set<TKey>
+get indexedKeysSet(): Set<TKey>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:216](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L216)
@@ -116,7 +116,7 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:216](https://github.com/TanSt
 #### Get Signature
 
 ```ts
-get isReady(): boolean
+get isReady(): boolean;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:147](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L147)
@@ -134,7 +134,7 @@ Check if index is ready
 #### Get Signature
 
 ```ts
-get keyCount(): number
+get keyCount(): number;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:211](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L211)
@@ -152,7 +152,7 @@ Get the key count (throws if not ready)
 #### Get Signature
 
 ```ts
-get name(): undefined | string
+get name(): string | undefined;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:168](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L168)
@@ -161,7 +161,7 @@ Get the index name (throws if not ready)
 
 ##### Returns
 
-`undefined` \| `string`
+`string` \| `undefined`
 
 ***
 
@@ -170,7 +170,7 @@ Get the index name (throws if not ready)
 #### Get Signature
 
 ```ts
-get orderedEntriesArray(): [any, Set<TKey>][]
+get orderedEntriesArray(): [any, Set<TKey>][];
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:221](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L221)
@@ -186,7 +186,7 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:221](https://github.com/TanSt
 #### Get Signature
 
 ```ts
-get valueMapData(): Map<any, Set<TKey>>
+get valueMapData(): Map<any, Set<TKey>>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:226](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L226)
@@ -200,21 +200,21 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:226](https://github.com/TanSt
 ### \_getLazyWrapper()
 
 ```ts
-_getLazyWrapper(): LazyIndexWrapper<TKey>
+_getLazyWrapper(): LazyIndexWrapper<TKey>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:248](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L248)
 
 #### Returns
 
-[`LazyIndexWrapper`](../lazyindexwrapper.md)\<`TKey`\>
+[`LazyIndexWrapper`](LazyIndexWrapper.md)\<`TKey`\>
 
 ***
 
 ### equalityLookup()
 
 ```ts
-equalityLookup(value): Set<TKey>
+equalityLookup(value): Set<TKey>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:232](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L232)
@@ -234,7 +234,7 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:232](https://github.com/TanSt
 ### getStats()
 
 ```ts
-getStats(): IndexStats
+getStats(): IndexStats;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:192](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L192)
@@ -243,14 +243,14 @@ Get index statistics (throws if not ready)
 
 #### Returns
 
-[`IndexStats`](../../interfaces/indexstats.md)
+[`IndexStats`](../interfaces/IndexStats.md)
 
 ***
 
 ### inArrayLookup()
 
 ```ts
-inArrayLookup(values): Set<TKey>
+inArrayLookup(values): Set<TKey>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:242](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L242)
@@ -270,7 +270,7 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:242](https://github.com/TanSt
 ### matchesField()
 
 ```ts
-matchesField(fieldPath): boolean
+matchesField(fieldPath): boolean;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:199](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L199)
@@ -292,7 +292,7 @@ Check if index matches a field path (available immediately)
 ### rangeQuery()
 
 ```ts
-rangeQuery(options): Set<TKey>
+rangeQuery(options): Set<TKey>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:237](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L237)
@@ -312,7 +312,7 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:237](https://github.com/TanSt
 ### supports()
 
 ```ts
-supports(operation): boolean
+supports(operation): boolean;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:185](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L185)
@@ -334,7 +334,7 @@ Check if index supports an operation (throws if not ready)
 ### whenReady()
 
 ```ts
-whenReady(): Promise<BaseIndex<TKey>>
+whenReady(): Promise<BaseIndex<TKey>>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:154](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L154)
@@ -343,4 +343,4 @@ Wait for index to be ready
 
 #### Returns
 
-`Promise`\<[`BaseIndex`](../baseindex.md)\<`TKey`\>\>
+`Promise`\<[`BaseIndex`](BaseIndex.md)\<`TKey`\>\>
diff --git a/docs/reference/classes/InvalidCollectionStatusTransitionError.md b/docs/reference/classes/InvalidCollectionStatusTransitionError.md
new file mode 100644
index 000000000..8881268af
--- /dev/null
+++ b/docs/reference/classes/InvalidCollectionStatusTransitionError.md
@@ -0,0 +1,231 @@
+---
+id: InvalidCollectionStatusTransitionError
+title: InvalidCollectionStatusTransitionError
+---
+
+# Class: InvalidCollectionStatusTransitionError
+
+Defined in: [packages/db/src/errors.ts:118](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L118)
+
+## Extends
+
+- [`CollectionStateError`](CollectionStateError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidCollectionStatusTransitionError(
+   from, 
+   to, 
+   collectionId): InvalidCollectionStatusTransitionError;
+```
+
+Defined in: [packages/db/src/errors.ts:119](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L119)
+
+#### Parameters
+
+##### from
+
+`string`
+
+##### to
+
+`string`
+
+##### collectionId
+
+`string`
+
+#### Returns
+
+`InvalidCollectionStatusTransitionError`
+
+#### Overrides
+
+[`CollectionStateError`](CollectionStateError.md).[`constructor`](CollectionStateError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`cause`](CollectionStateError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`message`](CollectionStateError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`name`](CollectionStateError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`stack`](CollectionStateError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`stackTraceLimit`](CollectionStateError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`captureStackTrace`](CollectionStateError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`prepareStackTrace`](CollectionStateError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidJoinCondition.md b/docs/reference/classes/InvalidJoinCondition.md
new file mode 100644
index 000000000..9a5f53e7c
--- /dev/null
+++ b/docs/reference/classes/InvalidJoinCondition.md
@@ -0,0 +1,214 @@
+---
+id: InvalidJoinCondition
+title: InvalidJoinCondition
+---
+
+# Class: InvalidJoinCondition
+
+Defined in: [packages/db/src/errors.ts:560](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L560)
+
+## Extends
+
+- [`JoinError`](JoinError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidJoinCondition(): InvalidJoinCondition;
+```
+
+Defined in: [packages/db/src/errors.ts:561](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L561)
+
+#### Returns
+
+`InvalidJoinCondition`
+
+#### Overrides
+
+[`JoinError`](JoinError.md).[`constructor`](JoinError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`cause`](JoinError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`message`](JoinError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`name`](JoinError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stack`](JoinError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stackTraceLimit`](JoinError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`captureStackTrace`](JoinError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`prepareStackTrace`](JoinError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidJoinConditionLeftSourceError.md b/docs/reference/classes/InvalidJoinConditionLeftSourceError.md
new file mode 100644
index 000000000..96f78a2ed
--- /dev/null
+++ b/docs/reference/classes/InvalidJoinConditionLeftSourceError.md
@@ -0,0 +1,220 @@
+---
+id: InvalidJoinConditionLeftSourceError
+title: InvalidJoinConditionLeftSourceError
+---
+
+# Class: InvalidJoinConditionLeftSourceError
+
+Defined in: [packages/db/src/errors.ts:544](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L544)
+
+## Extends
+
+- [`JoinError`](JoinError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidJoinConditionLeftSourceError(sourceAlias): InvalidJoinConditionLeftSourceError;
+```
+
+Defined in: [packages/db/src/errors.ts:545](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L545)
+
+#### Parameters
+
+##### sourceAlias
+
+`string`
+
+#### Returns
+
+`InvalidJoinConditionLeftSourceError`
+
+#### Overrides
+
+[`JoinError`](JoinError.md).[`constructor`](JoinError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`cause`](JoinError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`message`](JoinError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`name`](JoinError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stack`](JoinError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stackTraceLimit`](JoinError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`captureStackTrace`](JoinError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`prepareStackTrace`](JoinError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidJoinConditionRightSourceError.md b/docs/reference/classes/InvalidJoinConditionRightSourceError.md
new file mode 100644
index 000000000..8f3a705e3
--- /dev/null
+++ b/docs/reference/classes/InvalidJoinConditionRightSourceError.md
@@ -0,0 +1,220 @@
+---
+id: InvalidJoinConditionRightSourceError
+title: InvalidJoinConditionRightSourceError
+---
+
+# Class: InvalidJoinConditionRightSourceError
+
+Defined in: [packages/db/src/errors.ts:552](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L552)
+
+## Extends
+
+- [`JoinError`](JoinError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidJoinConditionRightSourceError(sourceAlias): InvalidJoinConditionRightSourceError;
+```
+
+Defined in: [packages/db/src/errors.ts:553](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L553)
+
+#### Parameters
+
+##### sourceAlias
+
+`string`
+
+#### Returns
+
+`InvalidJoinConditionRightSourceError`
+
+#### Overrides
+
+[`JoinError`](JoinError.md).[`constructor`](JoinError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`cause`](JoinError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`message`](JoinError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`name`](JoinError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stack`](JoinError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stackTraceLimit`](JoinError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`captureStackTrace`](JoinError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`prepareStackTrace`](JoinError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidJoinConditionSameSourceError.md b/docs/reference/classes/InvalidJoinConditionSameSourceError.md
new file mode 100644
index 000000000..4dbe95489
--- /dev/null
+++ b/docs/reference/classes/InvalidJoinConditionSameSourceError.md
@@ -0,0 +1,220 @@
+---
+id: InvalidJoinConditionSameSourceError
+title: InvalidJoinConditionSameSourceError
+---
+
+# Class: InvalidJoinConditionSameSourceError
+
+Defined in: [packages/db/src/errors.ts:530](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L530)
+
+## Extends
+
+- [`JoinError`](JoinError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidJoinConditionSameSourceError(sourceAlias): InvalidJoinConditionSameSourceError;
+```
+
+Defined in: [packages/db/src/errors.ts:531](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L531)
+
+#### Parameters
+
+##### sourceAlias
+
+`string`
+
+#### Returns
+
+`InvalidJoinConditionSameSourceError`
+
+#### Overrides
+
+[`JoinError`](JoinError.md).[`constructor`](JoinError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`cause`](JoinError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`message`](JoinError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`name`](JoinError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stack`](JoinError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stackTraceLimit`](JoinError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`captureStackTrace`](JoinError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`prepareStackTrace`](JoinError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidJoinConditionSourceMismatchError.md b/docs/reference/classes/InvalidJoinConditionSourceMismatchError.md
new file mode 100644
index 000000000..111f2bb1b
--- /dev/null
+++ b/docs/reference/classes/InvalidJoinConditionSourceMismatchError.md
@@ -0,0 +1,214 @@
+---
+id: InvalidJoinConditionSourceMismatchError
+title: InvalidJoinConditionSourceMismatchError
+---
+
+# Class: InvalidJoinConditionSourceMismatchError
+
+Defined in: [packages/db/src/errors.ts:538](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L538)
+
+## Extends
+
+- [`JoinError`](JoinError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidJoinConditionSourceMismatchError(): InvalidJoinConditionSourceMismatchError;
+```
+
+Defined in: [packages/db/src/errors.ts:539](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L539)
+
+#### Returns
+
+`InvalidJoinConditionSourceMismatchError`
+
+#### Overrides
+
+[`JoinError`](JoinError.md).[`constructor`](JoinError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`cause`](JoinError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`message`](JoinError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`name`](JoinError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stack`](JoinError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stackTraceLimit`](JoinError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`captureStackTrace`](JoinError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`prepareStackTrace`](JoinError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidKeyError.md b/docs/reference/classes/InvalidKeyError.md
new file mode 100644
index 000000000..b06bd9262
--- /dev/null
+++ b/docs/reference/classes/InvalidKeyError.md
@@ -0,0 +1,224 @@
+---
+id: InvalidKeyError
+title: InvalidKeyError
+---
+
+# Class: InvalidKeyError
+
+Defined in: [packages/db/src/errors.ts:154](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L154)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidKeyError(key, item): InvalidKeyError;
+```
+
+Defined in: [packages/db/src/errors.ts:155](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L155)
+
+#### Parameters
+
+##### key
+
+`unknown`
+
+##### item
+
+`unknown`
+
+#### Returns
+
+`InvalidKeyError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidSchemaError.md b/docs/reference/classes/InvalidSchemaError.md
new file mode 100644
index 000000000..b50d2cff0
--- /dev/null
+++ b/docs/reference/classes/InvalidSchemaError.md
@@ -0,0 +1,214 @@
+---
+id: InvalidSchemaError
+title: InvalidSchemaError
+---
+
+# Class: InvalidSchemaError
+
+Defined in: [packages/db/src/errors.ts:90](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L90)
+
+## Extends
+
+- [`CollectionConfigurationError`](CollectionConfigurationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidSchemaError(): InvalidSchemaError;
+```
+
+Defined in: [packages/db/src/errors.ts:91](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L91)
+
+#### Returns
+
+`InvalidSchemaError`
+
+#### Overrides
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`constructor`](CollectionConfigurationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`cause`](CollectionConfigurationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`message`](CollectionConfigurationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`name`](CollectionConfigurationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`stack`](CollectionConfigurationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`stackTraceLimit`](CollectionConfigurationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`captureStackTrace`](CollectionConfigurationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`prepareStackTrace`](CollectionConfigurationError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidSourceError.md b/docs/reference/classes/InvalidSourceError.md
new file mode 100644
index 000000000..a2bde42a9
--- /dev/null
+++ b/docs/reference/classes/InvalidSourceError.md
@@ -0,0 +1,220 @@
+---
+id: InvalidSourceError
+title: InvalidSourceError
+---
+
+# Class: InvalidSourceError
+
+Defined in: [packages/db/src/errors.ts:380](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L380)
+
+## Extends
+
+- [`QueryBuilderError`](QueryBuilderError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidSourceError(alias): InvalidSourceError;
+```
+
+Defined in: [packages/db/src/errors.ts:381](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L381)
+
+#### Parameters
+
+##### alias
+
+`string`
+
+#### Returns
+
+`InvalidSourceError`
+
+#### Overrides
+
+[`QueryBuilderError`](QueryBuilderError.md).[`constructor`](QueryBuilderError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`cause`](QueryBuilderError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`message`](QueryBuilderError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`name`](QueryBuilderError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stack`](QueryBuilderError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stackTraceLimit`](QueryBuilderError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`captureStackTrace`](QueryBuilderError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`prepareStackTrace`](QueryBuilderError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidSourceTypeError.md b/docs/reference/classes/InvalidSourceTypeError.md
new file mode 100644
index 000000000..09425c7cc
--- /dev/null
+++ b/docs/reference/classes/InvalidSourceTypeError.md
@@ -0,0 +1,224 @@
+---
+id: InvalidSourceTypeError
+title: InvalidSourceTypeError
+---
+
+# Class: InvalidSourceTypeError
+
+Defined in: [packages/db/src/errors.ts:388](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L388)
+
+## Extends
+
+- [`QueryBuilderError`](QueryBuilderError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidSourceTypeError(context, type): InvalidSourceTypeError;
+```
+
+Defined in: [packages/db/src/errors.ts:389](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L389)
+
+#### Parameters
+
+##### context
+
+`string`
+
+##### type
+
+`string`
+
+#### Returns
+
+`InvalidSourceTypeError`
+
+#### Overrides
+
+[`QueryBuilderError`](QueryBuilderError.md).[`constructor`](QueryBuilderError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`cause`](QueryBuilderError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`message`](QueryBuilderError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`name`](QueryBuilderError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stack`](QueryBuilderError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stackTraceLimit`](QueryBuilderError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`captureStackTrace`](QueryBuilderError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`prepareStackTrace`](QueryBuilderError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidStorageDataFormatError.md b/docs/reference/classes/InvalidStorageDataFormatError.md
new file mode 100644
index 000000000..5438372aa
--- /dev/null
+++ b/docs/reference/classes/InvalidStorageDataFormatError.md
@@ -0,0 +1,224 @@
+---
+id: InvalidStorageDataFormatError
+title: InvalidStorageDataFormatError
+---
+
+# Class: InvalidStorageDataFormatError
+
+Defined in: [packages/db/src/errors.ts:638](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L638)
+
+## Extends
+
+- [`LocalStorageCollectionError`](LocalStorageCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidStorageDataFormatError(storageKey, key): InvalidStorageDataFormatError;
+```
+
+Defined in: [packages/db/src/errors.ts:639](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L639)
+
+#### Parameters
+
+##### storageKey
+
+`string`
+
+##### key
+
+`string`
+
+#### Returns
+
+`InvalidStorageDataFormatError`
+
+#### Overrides
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`constructor`](LocalStorageCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`cause`](LocalStorageCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`message`](LocalStorageCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`name`](LocalStorageCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`stack`](LocalStorageCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`stackTraceLimit`](LocalStorageCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`captureStackTrace`](LocalStorageCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`prepareStackTrace`](LocalStorageCollectionError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidStorageObjectFormatError.md b/docs/reference/classes/InvalidStorageObjectFormatError.md
new file mode 100644
index 000000000..365a3b13b
--- /dev/null
+++ b/docs/reference/classes/InvalidStorageObjectFormatError.md
@@ -0,0 +1,220 @@
+---
+id: InvalidStorageObjectFormatError
+title: InvalidStorageObjectFormatError
+---
+
+# Class: InvalidStorageObjectFormatError
+
+Defined in: [packages/db/src/errors.ts:646](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L646)
+
+## Extends
+
+- [`LocalStorageCollectionError`](LocalStorageCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidStorageObjectFormatError(storageKey): InvalidStorageObjectFormatError;
+```
+
+Defined in: [packages/db/src/errors.ts:647](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L647)
+
+#### Parameters
+
+##### storageKey
+
+`string`
+
+#### Returns
+
+`InvalidStorageObjectFormatError`
+
+#### Overrides
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`constructor`](LocalStorageCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`cause`](LocalStorageCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`message`](LocalStorageCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`name`](LocalStorageCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`stack`](LocalStorageCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`stackTraceLimit`](LocalStorageCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`captureStackTrace`](LocalStorageCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`prepareStackTrace`](LocalStorageCollectionError.md#preparestacktrace)
diff --git a/docs/reference/classes/InvalidWhereExpressionError.md b/docs/reference/classes/InvalidWhereExpressionError.md
new file mode 100644
index 000000000..60b62eb67
--- /dev/null
+++ b/docs/reference/classes/InvalidWhereExpressionError.md
@@ -0,0 +1,220 @@
+---
+id: InvalidWhereExpressionError
+title: InvalidWhereExpressionError
+---
+
+# Class: InvalidWhereExpressionError
+
+Defined in: [packages/db/src/errors.ts:409](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L409)
+
+## Extends
+
+- [`QueryBuilderError`](QueryBuilderError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidWhereExpressionError(valueType): InvalidWhereExpressionError;
+```
+
+Defined in: [packages/db/src/errors.ts:410](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L410)
+
+#### Parameters
+
+##### valueType
+
+`string`
+
+#### Returns
+
+`InvalidWhereExpressionError`
+
+#### Overrides
+
+[`QueryBuilderError`](QueryBuilderError.md).[`constructor`](QueryBuilderError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`cause`](QueryBuilderError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`message`](QueryBuilderError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`name`](QueryBuilderError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stack`](QueryBuilderError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stackTraceLimit`](QueryBuilderError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`captureStackTrace`](QueryBuilderError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`prepareStackTrace`](QueryBuilderError.md#preparestacktrace)
diff --git a/docs/reference/classes/JoinCollectionNotFoundError.md b/docs/reference/classes/JoinCollectionNotFoundError.md
new file mode 100644
index 000000000..5dcabc85f
--- /dev/null
+++ b/docs/reference/classes/JoinCollectionNotFoundError.md
@@ -0,0 +1,220 @@
+---
+id: JoinCollectionNotFoundError
+title: JoinCollectionNotFoundError
+---
+
+# Class: JoinCollectionNotFoundError
+
+Defined in: [packages/db/src/errors.ts:510](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L510)
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new JoinCollectionNotFoundError(collectionId): JoinCollectionNotFoundError;
+```
+
+Defined in: [packages/db/src/errors.ts:511](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L511)
+
+#### Parameters
+
+##### collectionId
+
+`string`
+
+#### Returns
+
+`JoinCollectionNotFoundError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/JoinConditionMustBeEqualityError.md b/docs/reference/classes/JoinConditionMustBeEqualityError.md
new file mode 100644
index 000000000..1ad3b91e6
--- /dev/null
+++ b/docs/reference/classes/JoinConditionMustBeEqualityError.md
@@ -0,0 +1,214 @@
+---
+id: JoinConditionMustBeEqualityError
+title: JoinConditionMustBeEqualityError
+---
+
+# Class: JoinConditionMustBeEqualityError
+
+Defined in: [packages/db/src/errors.ts:397](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L397)
+
+## Extends
+
+- [`QueryBuilderError`](QueryBuilderError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new JoinConditionMustBeEqualityError(): JoinConditionMustBeEqualityError;
+```
+
+Defined in: [packages/db/src/errors.ts:398](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L398)
+
+#### Returns
+
+`JoinConditionMustBeEqualityError`
+
+#### Overrides
+
+[`QueryBuilderError`](QueryBuilderError.md).[`constructor`](QueryBuilderError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`cause`](QueryBuilderError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`message`](QueryBuilderError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`name`](QueryBuilderError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stack`](QueryBuilderError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stackTraceLimit`](QueryBuilderError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`captureStackTrace`](QueryBuilderError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`prepareStackTrace`](QueryBuilderError.md#preparestacktrace)
diff --git a/docs/reference/classes/JoinError.md b/docs/reference/classes/JoinError.md
new file mode 100644
index 000000000..ab4ba1bb5
--- /dev/null
+++ b/docs/reference/classes/JoinError.md
@@ -0,0 +1,230 @@
+---
+id: JoinError
+title: JoinError
+---
+
+# Class: JoinError
+
+Defined in: [packages/db/src/errors.ts:517](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L517)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`UnsupportedJoinTypeError`](UnsupportedJoinTypeError.md)
+- [`InvalidJoinConditionSameSourceError`](InvalidJoinConditionSameSourceError.md)
+- [`InvalidJoinConditionSourceMismatchError`](InvalidJoinConditionSourceMismatchError.md)
+- [`InvalidJoinConditionLeftSourceError`](InvalidJoinConditionLeftSourceError.md)
+- [`InvalidJoinConditionRightSourceError`](InvalidJoinConditionRightSourceError.md)
+- [`InvalidJoinCondition`](InvalidJoinCondition.md)
+- [`UnsupportedJoinSourceTypeError`](UnsupportedJoinSourceTypeError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new JoinError(message): JoinError;
+```
+
+Defined in: [packages/db/src/errors.ts:518](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L518)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`JoinError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/KeyUpdateNotAllowedError.md b/docs/reference/classes/KeyUpdateNotAllowedError.md
new file mode 100644
index 000000000..0a56360a8
--- /dev/null
+++ b/docs/reference/classes/KeyUpdateNotAllowedError.md
@@ -0,0 +1,224 @@
+---
+id: KeyUpdateNotAllowedError
+title: KeyUpdateNotAllowedError
+---
+
+# Class: KeyUpdateNotAllowedError
+
+Defined in: [packages/db/src/errors.ts:231](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L231)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new KeyUpdateNotAllowedError(originalKey, newKey): KeyUpdateNotAllowedError;
+```
+
+Defined in: [packages/db/src/errors.ts:232](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L232)
+
+#### Parameters
+
+##### originalKey
+
+`string` | `number`
+
+##### newKey
+
+`string` | `number`
+
+#### Returns
+
+`KeyUpdateNotAllowedError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/lazyindexwrapper.md b/docs/reference/classes/LazyIndexWrapper.md
similarity index 74%
rename from docs/reference/classes/lazyindexwrapper.md
rename to docs/reference/classes/LazyIndexWrapper.md
index df3b97336..703809366 100644
--- a/docs/reference/classes/lazyindexwrapper.md
+++ b/docs/reference/classes/LazyIndexWrapper.md
@@ -3,8 +3,6 @@ id: LazyIndexWrapper
 title: LazyIndexWrapper
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Class: LazyIndexWrapper\<TKey\>
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:39](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L39)
@@ -13,11 +11,13 @@ Wrapper that defers index creation until first sync
 
 ## Type Parameters
 
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
 
 ## Constructors
 
-### new LazyIndexWrapper()
+### Constructor
 
 ```ts
 new LazyIndexWrapper<TKey>(
@@ -26,7 +26,7 @@ new LazyIndexWrapper<TKey>(
    name, 
    resolver, 
    options, 
-collectionEntries?): LazyIndexWrapper<TKey>
+collectionEntries?): LazyIndexWrapper<TKey>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:43](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L43)
@@ -39,15 +39,15 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:43](https://github.com/TanSta
 
 ##### expression
 
-`BasicExpression`
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)
 
 ##### name
 
-`undefined` | `string`
+`string` | `undefined`
 
 ##### resolver
 
-[`IndexResolver`](../../type-aliases/indexresolver.md)\<`TKey`\>
+[`IndexResolver`](../type-aliases/IndexResolver.md)\<`TKey`\>
 
 ##### options
 
@@ -59,14 +59,14 @@ Defined in: [packages/db/src/indexes/lazy-index.ts:43](https://github.com/TanSta
 
 #### Returns
 
-[`LazyIndexWrapper`](../lazyindexwrapper.md)\<`TKey`\>
+`LazyIndexWrapper`\<`TKey`\>
 
 ## Methods
 
 ### getExpression()
 
 ```ts
-getExpression(): BasicExpression
+getExpression(): BasicExpression;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:118](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L118)
@@ -75,14 +75,14 @@ Get the index expression
 
 #### Returns
 
-`BasicExpression`
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)
 
 ***
 
 ### getId()
 
 ```ts
-getId(): number
+getId(): number;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:104](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L104)
@@ -98,7 +98,7 @@ Get the index ID
 ### getName()
 
 ```ts
-getName(): undefined | string
+getName(): string | undefined;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:111](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L111)
@@ -107,14 +107,14 @@ Get the index name
 
 #### Returns
 
-`undefined` \| `string`
+`string` \| `undefined`
 
 ***
 
 ### getResolved()
 
 ```ts
-getResolved(): BaseIndex<TKey>
+getResolved(): BaseIndex<TKey>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:92](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L92)
@@ -123,14 +123,14 @@ Get resolved index (throws if not ready)
 
 #### Returns
 
-[`BaseIndex`](../baseindex.md)\<`TKey`\>
+[`BaseIndex`](BaseIndex.md)\<`TKey`\>
 
 ***
 
 ### isResolved()
 
 ```ts
-isResolved(): boolean
+isResolved(): boolean;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L85)
@@ -146,7 +146,7 @@ Check if already resolved
 ### resolve()
 
 ```ts
-resolve(): Promise<BaseIndex<TKey>>
+resolve(): Promise<BaseIndex<TKey>>;
 ```
 
 Defined in: [packages/db/src/indexes/lazy-index.ts:69](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/lazy-index.ts#L69)
@@ -155,4 +155,4 @@ Resolve the actual index
 
 #### Returns
 
-`Promise`\<[`BaseIndex`](../baseindex.md)\<`TKey`\>\>
+`Promise`\<[`BaseIndex`](BaseIndex.md)\<`TKey`\>\>
diff --git a/docs/reference/classes/LimitOffsetRequireOrderByError.md b/docs/reference/classes/LimitOffsetRequireOrderByError.md
new file mode 100644
index 000000000..354b1d110
--- /dev/null
+++ b/docs/reference/classes/LimitOffsetRequireOrderByError.md
@@ -0,0 +1,214 @@
+---
+id: LimitOffsetRequireOrderByError
+title: LimitOffsetRequireOrderByError
+---
+
+# Class: LimitOffsetRequireOrderByError
+
+Defined in: [packages/db/src/errors.ts:442](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L442)
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new LimitOffsetRequireOrderByError(): LimitOffsetRequireOrderByError;
+```
+
+Defined in: [packages/db/src/errors.ts:443](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L443)
+
+#### Returns
+
+`LimitOffsetRequireOrderByError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/LocalStorageCollectionError.md b/docs/reference/classes/LocalStorageCollectionError.md
new file mode 100644
index 000000000..93c72cfca
--- /dev/null
+++ b/docs/reference/classes/LocalStorageCollectionError.md
@@ -0,0 +1,226 @@
+---
+id: LocalStorageCollectionError
+title: LocalStorageCollectionError
+---
+
+# Class: LocalStorageCollectionError
+
+Defined in: [packages/db/src/errors.ts:625](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L625)
+
+## Extends
+
+- [`StorageError`](StorageError.md)
+
+## Extended by
+
+- [`StorageKeyRequiredError`](StorageKeyRequiredError.md)
+- [`InvalidStorageDataFormatError`](InvalidStorageDataFormatError.md)
+- [`InvalidStorageObjectFormatError`](InvalidStorageObjectFormatError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new LocalStorageCollectionError(message): LocalStorageCollectionError;
+```
+
+Defined in: [packages/db/src/errors.ts:626](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L626)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`LocalStorageCollectionError`
+
+#### Overrides
+
+[`StorageError`](StorageError.md).[`constructor`](StorageError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`cause`](StorageError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`message`](StorageError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`name`](StorageError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`stack`](StorageError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`stackTraceLimit`](StorageError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`captureStackTrace`](StorageError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`prepareStackTrace`](StorageError.md#preparestacktrace)
diff --git a/docs/reference/classes/MissingAliasInputsError.md b/docs/reference/classes/MissingAliasInputsError.md
new file mode 100644
index 000000000..ab0bd39b1
--- /dev/null
+++ b/docs/reference/classes/MissingAliasInputsError.md
@@ -0,0 +1,223 @@
+---
+id: MissingAliasInputsError
+title: MissingAliasInputsError
+---
+
+# Class: MissingAliasInputsError
+
+Defined in: [packages/db/src/errors.ts:722](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L722)
+
+Internal error when the compiler returns aliases that don't have corresponding input streams.
+This should never happen since all aliases come from user declarations.
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new MissingAliasInputsError(missingAliases): MissingAliasInputsError;
+```
+
+Defined in: [packages/db/src/errors.ts:723](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L723)
+
+#### Parameters
+
+##### missingAliases
+
+`string`[]
+
+#### Returns
+
+`MissingAliasInputsError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/MissingDeleteHandlerError.md b/docs/reference/classes/MissingDeleteHandlerError.md
new file mode 100644
index 000000000..388d7b89c
--- /dev/null
+++ b/docs/reference/classes/MissingDeleteHandlerError.md
@@ -0,0 +1,214 @@
+---
+id: MissingDeleteHandlerError
+title: MissingDeleteHandlerError
+---
+
+# Class: MissingDeleteHandlerError
+
+Defined in: [packages/db/src/errors.ts:277](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L277)
+
+## Extends
+
+- [`MissingHandlerError`](MissingHandlerError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new MissingDeleteHandlerError(): MissingDeleteHandlerError;
+```
+
+Defined in: [packages/db/src/errors.ts:278](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L278)
+
+#### Returns
+
+`MissingDeleteHandlerError`
+
+#### Overrides
+
+[`MissingHandlerError`](MissingHandlerError.md).[`constructor`](MissingHandlerError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`cause`](MissingHandlerError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`message`](MissingHandlerError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`name`](MissingHandlerError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`stack`](MissingHandlerError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`stackTraceLimit`](MissingHandlerError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`captureStackTrace`](MissingHandlerError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`prepareStackTrace`](MissingHandlerError.md#preparestacktrace)
diff --git a/docs/reference/classes/MissingHandlerError.md b/docs/reference/classes/MissingHandlerError.md
new file mode 100644
index 000000000..bc70f3840
--- /dev/null
+++ b/docs/reference/classes/MissingHandlerError.md
@@ -0,0 +1,226 @@
+---
+id: MissingHandlerError
+title: MissingHandlerError
+---
+
+# Class: MissingHandlerError
+
+Defined in: [packages/db/src/errors.ts:254](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L254)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`MissingInsertHandlerError`](MissingInsertHandlerError.md)
+- [`MissingUpdateHandlerError`](MissingUpdateHandlerError.md)
+- [`MissingDeleteHandlerError`](MissingDeleteHandlerError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new MissingHandlerError(message): MissingHandlerError;
+```
+
+Defined in: [packages/db/src/errors.ts:255](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L255)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`MissingHandlerError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/MissingInsertHandlerError.md b/docs/reference/classes/MissingInsertHandlerError.md
new file mode 100644
index 000000000..9295cda73
--- /dev/null
+++ b/docs/reference/classes/MissingInsertHandlerError.md
@@ -0,0 +1,214 @@
+---
+id: MissingInsertHandlerError
+title: MissingInsertHandlerError
+---
+
+# Class: MissingInsertHandlerError
+
+Defined in: [packages/db/src/errors.ts:261](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L261)
+
+## Extends
+
+- [`MissingHandlerError`](MissingHandlerError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new MissingInsertHandlerError(): MissingInsertHandlerError;
+```
+
+Defined in: [packages/db/src/errors.ts:262](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L262)
+
+#### Returns
+
+`MissingInsertHandlerError`
+
+#### Overrides
+
+[`MissingHandlerError`](MissingHandlerError.md).[`constructor`](MissingHandlerError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`cause`](MissingHandlerError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`message`](MissingHandlerError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`name`](MissingHandlerError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`stack`](MissingHandlerError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`stackTraceLimit`](MissingHandlerError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`captureStackTrace`](MissingHandlerError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`prepareStackTrace`](MissingHandlerError.md#preparestacktrace)
diff --git a/docs/reference/classes/MissingMutationFunctionError.md b/docs/reference/classes/MissingMutationFunctionError.md
new file mode 100644
index 000000000..5ae61674d
--- /dev/null
+++ b/docs/reference/classes/MissingMutationFunctionError.md
@@ -0,0 +1,214 @@
+---
+id: MissingMutationFunctionError
+title: MissingMutationFunctionError
+---
+
+# Class: MissingMutationFunctionError
+
+Defined in: [packages/db/src/errors.ts:293](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L293)
+
+## Extends
+
+- [`TransactionError`](TransactionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new MissingMutationFunctionError(): MissingMutationFunctionError;
+```
+
+Defined in: [packages/db/src/errors.ts:294](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L294)
+
+#### Returns
+
+`MissingMutationFunctionError`
+
+#### Overrides
+
+[`TransactionError`](TransactionError.md).[`constructor`](TransactionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`cause`](TransactionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`message`](TransactionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`name`](TransactionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stack`](TransactionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stackTraceLimit`](TransactionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`captureStackTrace`](TransactionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`prepareStackTrace`](TransactionError.md#preparestacktrace)
diff --git a/docs/reference/classes/MissingUpdateArgumentError.md b/docs/reference/classes/MissingUpdateArgumentError.md
new file mode 100644
index 000000000..1294dc291
--- /dev/null
+++ b/docs/reference/classes/MissingUpdateArgumentError.md
@@ -0,0 +1,214 @@
+---
+id: MissingUpdateArgumentError
+title: MissingUpdateArgumentError
+---
+
+# Class: MissingUpdateArgumentError
+
+Defined in: [packages/db/src/errors.ts:211](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L211)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new MissingUpdateArgumentError(): MissingUpdateArgumentError;
+```
+
+Defined in: [packages/db/src/errors.ts:212](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L212)
+
+#### Returns
+
+`MissingUpdateArgumentError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/MissingUpdateHandlerError.md b/docs/reference/classes/MissingUpdateHandlerError.md
new file mode 100644
index 000000000..785544806
--- /dev/null
+++ b/docs/reference/classes/MissingUpdateHandlerError.md
@@ -0,0 +1,214 @@
+---
+id: MissingUpdateHandlerError
+title: MissingUpdateHandlerError
+---
+
+# Class: MissingUpdateHandlerError
+
+Defined in: [packages/db/src/errors.ts:269](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L269)
+
+## Extends
+
+- [`MissingHandlerError`](MissingHandlerError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new MissingUpdateHandlerError(): MissingUpdateHandlerError;
+```
+
+Defined in: [packages/db/src/errors.ts:270](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L270)
+
+#### Returns
+
+`MissingUpdateHandlerError`
+
+#### Overrides
+
+[`MissingHandlerError`](MissingHandlerError.md).[`constructor`](MissingHandlerError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`cause`](MissingHandlerError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`message`](MissingHandlerError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`name`](MissingHandlerError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`stack`](MissingHandlerError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`stackTraceLimit`](MissingHandlerError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`captureStackTrace`](MissingHandlerError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`MissingHandlerError`](MissingHandlerError.md).[`prepareStackTrace`](MissingHandlerError.md#preparestacktrace)
diff --git a/docs/reference/classes/NegativeActiveSubscribersError.md b/docs/reference/classes/NegativeActiveSubscribersError.md
new file mode 100644
index 000000000..d94047c24
--- /dev/null
+++ b/docs/reference/classes/NegativeActiveSubscribersError.md
@@ -0,0 +1,214 @@
+---
+id: NegativeActiveSubscribersError
+title: NegativeActiveSubscribersError
+---
+
+# Class: NegativeActiveSubscribersError
+
+Defined in: [packages/db/src/errors.ts:132](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L132)
+
+## Extends
+
+- [`CollectionStateError`](CollectionStateError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new NegativeActiveSubscribersError(): NegativeActiveSubscribersError;
+```
+
+Defined in: [packages/db/src/errors.ts:133](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L133)
+
+#### Returns
+
+`NegativeActiveSubscribersError`
+
+#### Overrides
+
+[`CollectionStateError`](CollectionStateError.md).[`constructor`](CollectionStateError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`cause`](CollectionStateError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`message`](CollectionStateError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`name`](CollectionStateError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`stack`](CollectionStateError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`stackTraceLimit`](CollectionStateError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`captureStackTrace`](CollectionStateError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionStateError`](CollectionStateError.md).[`prepareStackTrace`](CollectionStateError.md#preparestacktrace)
diff --git a/docs/reference/classes/NoKeysPassedToDeleteError.md b/docs/reference/classes/NoKeysPassedToDeleteError.md
new file mode 100644
index 000000000..1683b8d17
--- /dev/null
+++ b/docs/reference/classes/NoKeysPassedToDeleteError.md
@@ -0,0 +1,214 @@
+---
+id: NoKeysPassedToDeleteError
+title: NoKeysPassedToDeleteError
+---
+
+# Class: NoKeysPassedToDeleteError
+
+Defined in: [packages/db/src/errors.ts:239](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L239)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new NoKeysPassedToDeleteError(): NoKeysPassedToDeleteError;
+```
+
+Defined in: [packages/db/src/errors.ts:240](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L240)
+
+#### Returns
+
+`NoKeysPassedToDeleteError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/NoKeysPassedToUpdateError.md b/docs/reference/classes/NoKeysPassedToUpdateError.md
new file mode 100644
index 000000000..d8931ca89
--- /dev/null
+++ b/docs/reference/classes/NoKeysPassedToUpdateError.md
@@ -0,0 +1,214 @@
+---
+id: NoKeysPassedToUpdateError
+title: NoKeysPassedToUpdateError
+---
+
+# Class: NoKeysPassedToUpdateError
+
+Defined in: [packages/db/src/errors.ts:217](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L217)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new NoKeysPassedToUpdateError(): NoKeysPassedToUpdateError;
+```
+
+Defined in: [packages/db/src/errors.ts:218](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L218)
+
+#### Returns
+
+`NoKeysPassedToUpdateError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/NoPendingSyncTransactionCommitError.md b/docs/reference/classes/NoPendingSyncTransactionCommitError.md
new file mode 100644
index 000000000..fce0a8d88
--- /dev/null
+++ b/docs/reference/classes/NoPendingSyncTransactionCommitError.md
@@ -0,0 +1,214 @@
+---
+id: NoPendingSyncTransactionCommitError
+title: NoPendingSyncTransactionCommitError
+---
+
+# Class: NoPendingSyncTransactionCommitError
+
+Defined in: [packages/db/src/errors.ts:346](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L346)
+
+## Extends
+
+- [`TransactionError`](TransactionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new NoPendingSyncTransactionCommitError(): NoPendingSyncTransactionCommitError;
+```
+
+Defined in: [packages/db/src/errors.ts:347](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L347)
+
+#### Returns
+
+`NoPendingSyncTransactionCommitError`
+
+#### Overrides
+
+[`TransactionError`](TransactionError.md).[`constructor`](TransactionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`cause`](TransactionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`message`](TransactionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`name`](TransactionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stack`](TransactionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stackTraceLimit`](TransactionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`captureStackTrace`](TransactionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`prepareStackTrace`](TransactionError.md#preparestacktrace)
diff --git a/docs/reference/classes/NoPendingSyncTransactionWriteError.md b/docs/reference/classes/NoPendingSyncTransactionWriteError.md
new file mode 100644
index 000000000..b311bcbc1
--- /dev/null
+++ b/docs/reference/classes/NoPendingSyncTransactionWriteError.md
@@ -0,0 +1,214 @@
+---
+id: NoPendingSyncTransactionWriteError
+title: NoPendingSyncTransactionWriteError
+---
+
+# Class: NoPendingSyncTransactionWriteError
+
+Defined in: [packages/db/src/errors.ts:332](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L332)
+
+## Extends
+
+- [`TransactionError`](TransactionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new NoPendingSyncTransactionWriteError(): NoPendingSyncTransactionWriteError;
+```
+
+Defined in: [packages/db/src/errors.ts:333](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L333)
+
+#### Returns
+
+`NoPendingSyncTransactionWriteError`
+
+#### Overrides
+
+[`TransactionError`](TransactionError.md).[`constructor`](TransactionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`cause`](TransactionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`message`](TransactionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`name`](TransactionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stack`](TransactionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stackTraceLimit`](TransactionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`captureStackTrace`](TransactionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`prepareStackTrace`](TransactionError.md#preparestacktrace)
diff --git a/docs/reference/classes/NonAggregateExpressionNotInGroupByError.md b/docs/reference/classes/NonAggregateExpressionNotInGroupByError.md
new file mode 100644
index 000000000..90ee11ed3
--- /dev/null
+++ b/docs/reference/classes/NonAggregateExpressionNotInGroupByError.md
@@ -0,0 +1,220 @@
+---
+id: NonAggregateExpressionNotInGroupByError
+title: NonAggregateExpressionNotInGroupByError
+---
+
+# Class: NonAggregateExpressionNotInGroupByError
+
+Defined in: [packages/db/src/errors.ts:580](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L580)
+
+## Extends
+
+- [`GroupByError`](GroupByError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new NonAggregateExpressionNotInGroupByError(alias): NonAggregateExpressionNotInGroupByError;
+```
+
+Defined in: [packages/db/src/errors.ts:581](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L581)
+
+#### Parameters
+
+##### alias
+
+`string`
+
+#### Returns
+
+`NonAggregateExpressionNotInGroupByError`
+
+#### Overrides
+
+[`GroupByError`](GroupByError.md).[`constructor`](GroupByError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`cause`](GroupByError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`message`](GroupByError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`name`](GroupByError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`stack`](GroupByError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`stackTraceLimit`](GroupByError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`captureStackTrace`](GroupByError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`prepareStackTrace`](GroupByError.md#preparestacktrace)
diff --git a/docs/reference/classes/NonRetriableError.md b/docs/reference/classes/NonRetriableError.md
new file mode 100644
index 000000000..f7c35f700
--- /dev/null
+++ b/docs/reference/classes/NonRetriableError.md
@@ -0,0 +1,220 @@
+---
+id: NonRetriableError
+title: NonRetriableError
+---
+
+# Class: NonRetriableError
+
+Defined in: [packages/db/src/errors.ts:10](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L10)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new NonRetriableError(message): NonRetriableError;
+```
+
+Defined in: [packages/db/src/errors.ts:11](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L11)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`NonRetriableError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/OnMutateMustBeSynchronousError.md b/docs/reference/classes/OnMutateMustBeSynchronousError.md
new file mode 100644
index 000000000..a32ffc11b
--- /dev/null
+++ b/docs/reference/classes/OnMutateMustBeSynchronousError.md
@@ -0,0 +1,214 @@
+---
+id: OnMutateMustBeSynchronousError
+title: OnMutateMustBeSynchronousError
+---
+
+# Class: OnMutateMustBeSynchronousError
+
+Defined in: [packages/db/src/errors.ts:299](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L299)
+
+## Extends
+
+- [`TransactionError`](TransactionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new OnMutateMustBeSynchronousError(): OnMutateMustBeSynchronousError;
+```
+
+Defined in: [packages/db/src/errors.ts:300](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L300)
+
+#### Returns
+
+`OnMutateMustBeSynchronousError`
+
+#### Overrides
+
+[`TransactionError`](TransactionError.md).[`constructor`](TransactionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`cause`](TransactionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`message`](TransactionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`name`](TransactionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stack`](TransactionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stackTraceLimit`](TransactionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`captureStackTrace`](TransactionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`prepareStackTrace`](TransactionError.md#preparestacktrace)
diff --git a/docs/reference/classes/OnlyOneSourceAllowedError.md b/docs/reference/classes/OnlyOneSourceAllowedError.md
new file mode 100644
index 000000000..5eb3d2024
--- /dev/null
+++ b/docs/reference/classes/OnlyOneSourceAllowedError.md
@@ -0,0 +1,220 @@
+---
+id: OnlyOneSourceAllowedError
+title: OnlyOneSourceAllowedError
+---
+
+# Class: OnlyOneSourceAllowedError
+
+Defined in: [packages/db/src/errors.ts:368](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L368)
+
+## Extends
+
+- [`QueryBuilderError`](QueryBuilderError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new OnlyOneSourceAllowedError(context): OnlyOneSourceAllowedError;
+```
+
+Defined in: [packages/db/src/errors.ts:369](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L369)
+
+#### Parameters
+
+##### context
+
+`string`
+
+#### Returns
+
+`OnlyOneSourceAllowedError`
+
+#### Overrides
+
+[`QueryBuilderError`](QueryBuilderError.md).[`constructor`](QueryBuilderError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`cause`](QueryBuilderError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`message`](QueryBuilderError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`name`](QueryBuilderError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stack`](QueryBuilderError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stackTraceLimit`](QueryBuilderError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`captureStackTrace`](QueryBuilderError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`prepareStackTrace`](QueryBuilderError.md#preparestacktrace)
diff --git a/docs/reference/classes/QueryBuilderError.md b/docs/reference/classes/QueryBuilderError.md
new file mode 100644
index 000000000..cce1caaeb
--- /dev/null
+++ b/docs/reference/classes/QueryBuilderError.md
@@ -0,0 +1,230 @@
+---
+id: QueryBuilderError
+title: QueryBuilderError
+---
+
+# Class: QueryBuilderError
+
+Defined in: [packages/db/src/errors.ts:361](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L361)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`OnlyOneSourceAllowedError`](OnlyOneSourceAllowedError.md)
+- [`SubQueryMustHaveFromClauseError`](SubQueryMustHaveFromClauseError.md)
+- [`InvalidSourceError`](InvalidSourceError.md)
+- [`InvalidSourceTypeError`](InvalidSourceTypeError.md)
+- [`JoinConditionMustBeEqualityError`](JoinConditionMustBeEqualityError.md)
+- [`QueryMustHaveFromClauseError`](QueryMustHaveFromClauseError.md)
+- [`InvalidWhereExpressionError`](InvalidWhereExpressionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new QueryBuilderError(message): QueryBuilderError;
+```
+
+Defined in: [packages/db/src/errors.ts:362](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L362)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`QueryBuilderError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/QueryCompilationError.md b/docs/reference/classes/QueryCompilationError.md
new file mode 100644
index 000000000..e29a482c4
--- /dev/null
+++ b/docs/reference/classes/QueryCompilationError.md
@@ -0,0 +1,237 @@
+---
+id: QueryCompilationError
+title: QueryCompilationError
+---
+
+# Class: QueryCompilationError
+
+Defined in: [packages/db/src/errors.ts:423](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L423)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`DistinctRequiresSelectError`](DistinctRequiresSelectError.md)
+- [`HavingRequiresGroupByError`](HavingRequiresGroupByError.md)
+- [`LimitOffsetRequireOrderByError`](LimitOffsetRequireOrderByError.md)
+- [`CollectionInputNotFoundError`](CollectionInputNotFoundError.md)
+- [`DuplicateAliasInSubqueryError`](DuplicateAliasInSubqueryError.md)
+- [`UnsupportedFromTypeError`](UnsupportedFromTypeError.md)
+- [`UnknownExpressionTypeError`](UnknownExpressionTypeError.md)
+- [`EmptyReferencePathError`](EmptyReferencePathError.md)
+- [`UnknownFunctionError`](UnknownFunctionError.md)
+- [`JoinCollectionNotFoundError`](JoinCollectionNotFoundError.md)
+- [`SubscriptionNotFoundError`](SubscriptionNotFoundError.md)
+- [`AggregateNotSupportedError`](AggregateNotSupportedError.md)
+- [`MissingAliasInputsError`](MissingAliasInputsError.md)
+- [`SetWindowRequiresOrderByError`](SetWindowRequiresOrderByError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new QueryCompilationError(message): QueryCompilationError;
+```
+
+Defined in: [packages/db/src/errors.ts:424](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L424)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`QueryCompilationError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/QueryMustHaveFromClauseError.md b/docs/reference/classes/QueryMustHaveFromClauseError.md
new file mode 100644
index 000000000..be36165a2
--- /dev/null
+++ b/docs/reference/classes/QueryMustHaveFromClauseError.md
@@ -0,0 +1,214 @@
+---
+id: QueryMustHaveFromClauseError
+title: QueryMustHaveFromClauseError
+---
+
+# Class: QueryMustHaveFromClauseError
+
+Defined in: [packages/db/src/errors.ts:403](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L403)
+
+## Extends
+
+- [`QueryBuilderError`](QueryBuilderError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new QueryMustHaveFromClauseError(): QueryMustHaveFromClauseError;
+```
+
+Defined in: [packages/db/src/errors.ts:404](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L404)
+
+#### Returns
+
+`QueryMustHaveFromClauseError`
+
+#### Overrides
+
+[`QueryBuilderError`](QueryBuilderError.md).[`constructor`](QueryBuilderError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`cause`](QueryBuilderError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`message`](QueryBuilderError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`name`](QueryBuilderError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stack`](QueryBuilderError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stackTraceLimit`](QueryBuilderError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`captureStackTrace`](QueryBuilderError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`prepareStackTrace`](QueryBuilderError.md#preparestacktrace)
diff --git a/docs/reference/classes/QueryOptimizerError.md b/docs/reference/classes/QueryOptimizerError.md
new file mode 100644
index 000000000..388fbda81
--- /dev/null
+++ b/docs/reference/classes/QueryOptimizerError.md
@@ -0,0 +1,225 @@
+---
+id: QueryOptimizerError
+title: QueryOptimizerError
+---
+
+# Class: QueryOptimizerError
+
+Defined in: [packages/db/src/errors.ts:666](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L666)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`CannotCombineEmptyExpressionListError`](CannotCombineEmptyExpressionListError.md)
+- [`WhereClauseConversionError`](WhereClauseConversionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new QueryOptimizerError(message): QueryOptimizerError;
+```
+
+Defined in: [packages/db/src/errors.ts:667](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L667)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`QueryOptimizerError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/SchemaMustBeSynchronousError.md b/docs/reference/classes/SchemaMustBeSynchronousError.md
new file mode 100644
index 000000000..875b79afd
--- /dev/null
+++ b/docs/reference/classes/SchemaMustBeSynchronousError.md
@@ -0,0 +1,214 @@
+---
+id: SchemaMustBeSynchronousError
+title: SchemaMustBeSynchronousError
+---
+
+# Class: SchemaMustBeSynchronousError
+
+Defined in: [packages/db/src/errors.ts:96](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L96)
+
+## Extends
+
+- [`CollectionConfigurationError`](CollectionConfigurationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SchemaMustBeSynchronousError(): SchemaMustBeSynchronousError;
+```
+
+Defined in: [packages/db/src/errors.ts:97](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L97)
+
+#### Returns
+
+`SchemaMustBeSynchronousError`
+
+#### Overrides
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`constructor`](CollectionConfigurationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`cause`](CollectionConfigurationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`message`](CollectionConfigurationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`name`](CollectionConfigurationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`stack`](CollectionConfigurationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`stackTraceLimit`](CollectionConfigurationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`captureStackTrace`](CollectionConfigurationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionConfigurationError`](CollectionConfigurationError.md).[`prepareStackTrace`](CollectionConfigurationError.md#preparestacktrace)
diff --git a/docs/reference/classes/SchemaValidationError.md b/docs/reference/classes/SchemaValidationError.md
new file mode 100644
index 000000000..8c7f1d436
--- /dev/null
+++ b/docs/reference/classes/SchemaValidationError.md
@@ -0,0 +1,251 @@
+---
+id: SchemaValidationError
+title: SchemaValidationError
+---
+
+# Class: SchemaValidationError
+
+Defined in: [packages/db/src/errors.ts:18](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L18)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SchemaValidationError(
+   type, 
+   issues, 
+   message?): SchemaValidationError;
+```
+
+Defined in: [packages/db/src/errors.ts:25](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L25)
+
+#### Parameters
+
+##### type
+
+`"insert"` | `"update"`
+
+##### issues
+
+readonly `object`[]
+
+##### message?
+
+`string`
+
+#### Returns
+
+`SchemaValidationError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### issues
+
+```ts
+issues: readonly object[];
+```
+
+Defined in: [packages/db/src/errors.ts:20](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L20)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### type
+
+```ts
+type: "insert" | "update";
+```
+
+Defined in: [packages/db/src/errors.ts:19](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L19)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/SerializationError.md b/docs/reference/classes/SerializationError.md
new file mode 100644
index 000000000..d9baad0d6
--- /dev/null
+++ b/docs/reference/classes/SerializationError.md
@@ -0,0 +1,224 @@
+---
+id: SerializationError
+title: SerializationError
+---
+
+# Class: SerializationError
+
+Defined in: [packages/db/src/errors.ts:616](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L616)
+
+## Extends
+
+- [`StorageError`](StorageError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SerializationError(operation, originalError): SerializationError;
+```
+
+Defined in: [packages/db/src/errors.ts:617](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L617)
+
+#### Parameters
+
+##### operation
+
+`string`
+
+##### originalError
+
+`string`
+
+#### Returns
+
+`SerializationError`
+
+#### Overrides
+
+[`StorageError`](StorageError.md).[`constructor`](StorageError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`cause`](StorageError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`message`](StorageError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`name`](StorageError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`stack`](StorageError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`stackTraceLimit`](StorageError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`captureStackTrace`](StorageError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`StorageError`](StorageError.md).[`prepareStackTrace`](StorageError.md#preparestacktrace)
diff --git a/docs/reference/classes/SetWindowRequiresOrderByError.md b/docs/reference/classes/SetWindowRequiresOrderByError.md
new file mode 100644
index 000000000..45e026011
--- /dev/null
+++ b/docs/reference/classes/SetWindowRequiresOrderByError.md
@@ -0,0 +1,216 @@
+---
+id: SetWindowRequiresOrderByError
+title: SetWindowRequiresOrderByError
+---
+
+# Class: SetWindowRequiresOrderByError
+
+Defined in: [packages/db/src/errors.ts:734](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L734)
+
+Error thrown when setWindow is called on a collection without an ORDER BY clause.
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SetWindowRequiresOrderByError(): SetWindowRequiresOrderByError;
+```
+
+Defined in: [packages/db/src/errors.ts:735](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L735)
+
+#### Returns
+
+`SetWindowRequiresOrderByError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/sortedmap.md b/docs/reference/classes/SortedMap.md
similarity index 52%
rename from docs/reference/classes/sortedmap.md
rename to docs/reference/classes/SortedMap.md
index 24db956e4..b61e5adcb 100644
--- a/docs/reference/classes/sortedmap.md
+++ b/docs/reference/classes/SortedMap.md
@@ -3,33 +3,35 @@ id: SortedMap
 title: SortedMap
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Class: SortedMap\<TKey, TValue\>
 
-Defined in: [packages/db/src/SortedMap.ts:6](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L6)
+Defined in: [packages/db/src/SortedMap.ts:8](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L8)
 
 A Map implementation that keeps its entries sorted based on a comparator function
 
 ## Type Parameters
 
-• **TKey**
+### TKey
+
+`TKey` *extends* `string` \| `number`
 
-The type of keys in the map
+The type of keys in the map (must be string | number)
 
-• **TValue**
+### TValue
+
+`TValue`
 
 The type of values in the map
 
 ## Constructors
 
-### new SortedMap()
+### Constructor
 
 ```ts
-new SortedMap<TKey, TValue>(comparator?): SortedMap<TKey, TValue>
+new SortedMap<TKey, TValue>(comparator?): SortedMap<TKey, TValue>;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:16](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L16)
+Defined in: [packages/db/src/SortedMap.ts:19](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L19)
 
 Creates a new SortedMap instance
 
@@ -39,11 +41,12 @@ Creates a new SortedMap instance
 
 (`a`, `b`) => `number`
 
-Optional function to compare values for sorting
+Optional function to compare values for sorting.
+                    If not provided, entries are sorted by key only.
 
 #### Returns
 
-[`SortedMap`](../sortedmap.md)\<`TKey`, `TValue`\>
+`SortedMap`\<`TKey`, `TValue`\>
 
 ## Accessors
 
@@ -52,10 +55,10 @@ Optional function to compare values for sorting
 #### Get Signature
 
 ```ts
-get size(): number
+get size(): number;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:138](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L138)
+Defined in: [packages/db/src/SortedMap.ts:157](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L157)
 
 Gets the number of key-value pairs in the map
 
@@ -68,10 +71,10 @@ Gets the number of key-value pairs in the map
 ### \[iterator\]()
 
 ```ts
-iterator: IterableIterator<[TKey, TValue]>
+iterator: IterableIterator<[TKey, TValue]>;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:147](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L147)
+Defined in: [packages/db/src/SortedMap.ts:166](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L166)
 
 Default iterator that returns entries in sorted order
 
@@ -86,10 +89,10 @@ An iterator for the map's entries
 ### clear()
 
 ```ts
-clear(): void
+clear(): void;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:130](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L130)
+Defined in: [packages/db/src/SortedMap.ts:149](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L149)
 
 Removes all key-value pairs from the map
 
@@ -102,10 +105,10 @@ Removes all key-value pairs from the map
 ### delete()
 
 ```ts
-delete(key): boolean
+delete(key): boolean;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:106](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L106)
+Defined in: [packages/db/src/SortedMap.ts:125](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L125)
 
 Removes a key-value pair from the map
 
@@ -128,10 +131,10 @@ True if the key was found and removed, false otherwise
 ### entries()
 
 ```ts
-entries(): IterableIterator<[TKey, TValue]>
+entries(): IterableIterator<[TKey, TValue]>;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:158](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L158)
+Defined in: [packages/db/src/SortedMap.ts:177](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L177)
 
 Returns an iterator for the map's entries in sorted order
 
@@ -146,10 +149,10 @@ An iterator for the map's entries
 ### forEach()
 
 ```ts
-forEach(callbackfn): void
+forEach(callbackfn): void;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:189](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L189)
+Defined in: [packages/db/src/SortedMap.ts:208](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L208)
 
 Executes a callback function for each key-value pair in the map in sorted order
 
@@ -170,10 +173,10 @@ Function to execute for each entry
 ### get()
 
 ```ts
-get(key): undefined | TValue
+get(key): TValue | undefined;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:96](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L96)
+Defined in: [packages/db/src/SortedMap.ts:115](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L115)
 
 Gets a value by its key
 
@@ -187,7 +190,7 @@ The key to look up
 
 #### Returns
 
-`undefined` \| `TValue`
+`TValue` \| `undefined`
 
 The value associated with the key, or undefined if not found
 
@@ -196,10 +199,10 @@ The value associated with the key, or undefined if not found
 ### has()
 
 ```ts
-has(key): boolean
+has(key): boolean;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:123](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L123)
+Defined in: [packages/db/src/SortedMap.ts:142](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L142)
 
 Checks if a key exists in the map
 
@@ -222,10 +225,10 @@ True if the key exists, false otherwise
 ### keys()
 
 ```ts
-keys(): IterableIterator<TKey>
+keys(): IterableIterator<TKey>;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:167](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L167)
+Defined in: [packages/db/src/SortedMap.ts:186](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L186)
 
 Returns an iterator for the map's keys in sorted order
 
@@ -240,10 +243,10 @@ An iterator for the map's keys
 ### set()
 
 ```ts
-set(key, value): this
+set(key, value): this;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:73](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L73)
+Defined in: [packages/db/src/SortedMap.ts:92](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L92)
 
 Sets a key-value pair in the map and maintains sort order
 
@@ -272,10 +275,10 @@ This SortedMap instance for chaining
 ### values()
 
 ```ts
-values(): IterableIterator<TValue>
+values(): IterableIterator<TValue>;
 ```
 
-Defined in: [packages/db/src/SortedMap.ts:176](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L176)
+Defined in: [packages/db/src/SortedMap.ts:195](https://github.com/TanStack/db/blob/main/packages/db/src/SortedMap.ts#L195)
 
 Returns an iterator for the map's values in sorted order
 
diff --git a/docs/reference/classes/StorageError.md b/docs/reference/classes/StorageError.md
new file mode 100644
index 000000000..0261cfdac
--- /dev/null
+++ b/docs/reference/classes/StorageError.md
@@ -0,0 +1,225 @@
+---
+id: StorageError
+title: StorageError
+---
+
+# Class: StorageError
+
+Defined in: [packages/db/src/errors.ts:609](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L609)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`SerializationError`](SerializationError.md)
+- [`LocalStorageCollectionError`](LocalStorageCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new StorageError(message): StorageError;
+```
+
+Defined in: [packages/db/src/errors.ts:610](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L610)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`StorageError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/StorageKeyRequiredError.md b/docs/reference/classes/StorageKeyRequiredError.md
new file mode 100644
index 000000000..3b57818f7
--- /dev/null
+++ b/docs/reference/classes/StorageKeyRequiredError.md
@@ -0,0 +1,214 @@
+---
+id: StorageKeyRequiredError
+title: StorageKeyRequiredError
+---
+
+# Class: StorageKeyRequiredError
+
+Defined in: [packages/db/src/errors.ts:632](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L632)
+
+## Extends
+
+- [`LocalStorageCollectionError`](LocalStorageCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new StorageKeyRequiredError(): StorageKeyRequiredError;
+```
+
+Defined in: [packages/db/src/errors.ts:633](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L633)
+
+#### Returns
+
+`StorageKeyRequiredError`
+
+#### Overrides
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`constructor`](LocalStorageCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`cause`](LocalStorageCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`message`](LocalStorageCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`name`](LocalStorageCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`stack`](LocalStorageCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`stackTraceLimit`](LocalStorageCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`captureStackTrace`](LocalStorageCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`LocalStorageCollectionError`](LocalStorageCollectionError.md).[`prepareStackTrace`](LocalStorageCollectionError.md#preparestacktrace)
diff --git a/docs/reference/classes/SubQueryMustHaveFromClauseError.md b/docs/reference/classes/SubQueryMustHaveFromClauseError.md
new file mode 100644
index 000000000..1e63981b4
--- /dev/null
+++ b/docs/reference/classes/SubQueryMustHaveFromClauseError.md
@@ -0,0 +1,220 @@
+---
+id: SubQueryMustHaveFromClauseError
+title: SubQueryMustHaveFromClauseError
+---
+
+# Class: SubQueryMustHaveFromClauseError
+
+Defined in: [packages/db/src/errors.ts:374](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L374)
+
+## Extends
+
+- [`QueryBuilderError`](QueryBuilderError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SubQueryMustHaveFromClauseError(context): SubQueryMustHaveFromClauseError;
+```
+
+Defined in: [packages/db/src/errors.ts:375](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L375)
+
+#### Parameters
+
+##### context
+
+`string`
+
+#### Returns
+
+`SubQueryMustHaveFromClauseError`
+
+#### Overrides
+
+[`QueryBuilderError`](QueryBuilderError.md).[`constructor`](QueryBuilderError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`cause`](QueryBuilderError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`message`](QueryBuilderError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`name`](QueryBuilderError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stack`](QueryBuilderError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`stackTraceLimit`](QueryBuilderError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`captureStackTrace`](QueryBuilderError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryBuilderError`](QueryBuilderError.md).[`prepareStackTrace`](QueryBuilderError.md#preparestacktrace)
diff --git a/docs/reference/classes/SubscriptionNotFoundError.md b/docs/reference/classes/SubscriptionNotFoundError.md
new file mode 100644
index 000000000..0b3d77747
--- /dev/null
+++ b/docs/reference/classes/SubscriptionNotFoundError.md
@@ -0,0 +1,239 @@
+---
+id: SubscriptionNotFoundError
+title: SubscriptionNotFoundError
+---
+
+# Class: SubscriptionNotFoundError
+
+Defined in: [packages/db/src/errors.ts:694](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L694)
+
+Error when a subscription cannot be found during lazy join processing.
+For subqueries, aliases may be remapped (e.g., 'activeUser' → 'user').
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SubscriptionNotFoundError(
+   resolvedAlias, 
+   originalAlias, 
+   collectionId, 
+   availableAliases): SubscriptionNotFoundError;
+```
+
+Defined in: [packages/db/src/errors.ts:695](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L695)
+
+#### Parameters
+
+##### resolvedAlias
+
+`string`
+
+##### originalAlias
+
+`string`
+
+##### collectionId
+
+`string`
+
+##### availableAliases
+
+`string`[]
+
+#### Returns
+
+`SubscriptionNotFoundError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/SyncCleanupError.md b/docs/reference/classes/SyncCleanupError.md
new file mode 100644
index 000000000..d2c6e61ac
--- /dev/null
+++ b/docs/reference/classes/SyncCleanupError.md
@@ -0,0 +1,224 @@
+---
+id: SyncCleanupError
+title: SyncCleanupError
+---
+
+# Class: SyncCleanupError
+
+Defined in: [packages/db/src/errors.ts:655](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L655)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SyncCleanupError(collectionId, error): SyncCleanupError;
+```
+
+Defined in: [packages/db/src/errors.ts:656](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L656)
+
+#### Parameters
+
+##### collectionId
+
+`string`
+
+##### error
+
+`string` | `Error`
+
+#### Returns
+
+`SyncCleanupError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/SyncTransactionAlreadyCommittedError.md b/docs/reference/classes/SyncTransactionAlreadyCommittedError.md
new file mode 100644
index 000000000..c18d73d5c
--- /dev/null
+++ b/docs/reference/classes/SyncTransactionAlreadyCommittedError.md
@@ -0,0 +1,214 @@
+---
+id: SyncTransactionAlreadyCommittedError
+title: SyncTransactionAlreadyCommittedError
+---
+
+# Class: SyncTransactionAlreadyCommittedError
+
+Defined in: [packages/db/src/errors.ts:352](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L352)
+
+## Extends
+
+- [`TransactionError`](TransactionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SyncTransactionAlreadyCommittedError(): SyncTransactionAlreadyCommittedError;
+```
+
+Defined in: [packages/db/src/errors.ts:353](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L353)
+
+#### Returns
+
+`SyncTransactionAlreadyCommittedError`
+
+#### Overrides
+
+[`TransactionError`](TransactionError.md).[`constructor`](TransactionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`cause`](TransactionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`message`](TransactionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`name`](TransactionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stack`](TransactionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stackTraceLimit`](TransactionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`captureStackTrace`](TransactionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`prepareStackTrace`](TransactionError.md#preparestacktrace)
diff --git a/docs/reference/classes/SyncTransactionAlreadyCommittedWriteError.md b/docs/reference/classes/SyncTransactionAlreadyCommittedWriteError.md
new file mode 100644
index 000000000..2b845bc14
--- /dev/null
+++ b/docs/reference/classes/SyncTransactionAlreadyCommittedWriteError.md
@@ -0,0 +1,214 @@
+---
+id: SyncTransactionAlreadyCommittedWriteError
+title: SyncTransactionAlreadyCommittedWriteError
+---
+
+# Class: SyncTransactionAlreadyCommittedWriteError
+
+Defined in: [packages/db/src/errors.ts:338](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L338)
+
+## Extends
+
+- [`TransactionError`](TransactionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SyncTransactionAlreadyCommittedWriteError(): SyncTransactionAlreadyCommittedWriteError;
+```
+
+Defined in: [packages/db/src/errors.ts:339](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L339)
+
+#### Returns
+
+`SyncTransactionAlreadyCommittedWriteError`
+
+#### Overrides
+
+[`TransactionError`](TransactionError.md).[`constructor`](TransactionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`cause`](TransactionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`message`](TransactionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`name`](TransactionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stack`](TransactionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stackTraceLimit`](TransactionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`captureStackTrace`](TransactionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`prepareStackTrace`](TransactionError.md#preparestacktrace)
diff --git a/docs/reference/classes/TanStackDBError.md b/docs/reference/classes/TanStackDBError.md
new file mode 100644
index 000000000..f0566cbf1
--- /dev/null
+++ b/docs/reference/classes/TanStackDBError.md
@@ -0,0 +1,254 @@
+---
+id: TanStackDBError
+title: TanStackDBError
+---
+
+# Class: TanStackDBError
+
+Defined in: [packages/db/src/errors.ts:2](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L2)
+
+## Extends
+
+- `Error`
+
+## Extended by
+
+- [`NonRetriableError`](NonRetriableError.md)
+- [`SchemaValidationError`](SchemaValidationError.md)
+- [`DuplicateDbInstanceError`](DuplicateDbInstanceError.md)
+- [`CollectionConfigurationError`](CollectionConfigurationError.md)
+- [`CollectionStateError`](CollectionStateError.md)
+- [`CollectionOperationError`](CollectionOperationError.md)
+- [`MissingHandlerError`](MissingHandlerError.md)
+- [`TransactionError`](TransactionError.md)
+- [`QueryBuilderError`](QueryBuilderError.md)
+- [`QueryCompilationError`](QueryCompilationError.md)
+- [`JoinError`](JoinError.md)
+- [`GroupByError`](GroupByError.md)
+- [`StorageError`](StorageError.md)
+- [`SyncCleanupError`](SyncCleanupError.md)
+- [`QueryOptimizerError`](QueryOptimizerError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new TanStackDBError(message): TanStackDBError;
+```
+
+Defined in: [packages/db/src/errors.ts:3](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L3)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`TanStackDBError`
+
+#### Overrides
+
+```ts
+Error.constructor
+```
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+```ts
+Error.cause
+```
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+```ts
+Error.message
+```
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+```ts
+Error.name
+```
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+```ts
+Error.stack
+```
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+```ts
+Error.stackTraceLimit
+```
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+```ts
+Error.captureStackTrace
+```
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+```ts
+Error.prepareStackTrace
+```
diff --git a/docs/reference/classes/TransactionAlreadyCompletedRollbackError.md b/docs/reference/classes/TransactionAlreadyCompletedRollbackError.md
new file mode 100644
index 000000000..c05ee0a35
--- /dev/null
+++ b/docs/reference/classes/TransactionAlreadyCompletedRollbackError.md
@@ -0,0 +1,214 @@
+---
+id: TransactionAlreadyCompletedRollbackError
+title: TransactionAlreadyCompletedRollbackError
+---
+
+# Class: TransactionAlreadyCompletedRollbackError
+
+Defined in: [packages/db/src/errors.ts:316](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L316)
+
+## Extends
+
+- [`TransactionError`](TransactionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new TransactionAlreadyCompletedRollbackError(): TransactionAlreadyCompletedRollbackError;
+```
+
+Defined in: [packages/db/src/errors.ts:317](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L317)
+
+#### Returns
+
+`TransactionAlreadyCompletedRollbackError`
+
+#### Overrides
+
+[`TransactionError`](TransactionError.md).[`constructor`](TransactionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`cause`](TransactionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`message`](TransactionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`name`](TransactionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stack`](TransactionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stackTraceLimit`](TransactionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`captureStackTrace`](TransactionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`prepareStackTrace`](TransactionError.md#preparestacktrace)
diff --git a/docs/reference/classes/TransactionError.md b/docs/reference/classes/TransactionError.md
new file mode 100644
index 000000000..10269124c
--- /dev/null
+++ b/docs/reference/classes/TransactionError.md
@@ -0,0 +1,232 @@
+---
+id: TransactionError
+title: TransactionError
+---
+
+# Class: TransactionError
+
+Defined in: [packages/db/src/errors.ts:286](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L286)
+
+## Extends
+
+- [`TanStackDBError`](TanStackDBError.md)
+
+## Extended by
+
+- [`MissingMutationFunctionError`](MissingMutationFunctionError.md)
+- [`OnMutateMustBeSynchronousError`](OnMutateMustBeSynchronousError.md)
+- [`TransactionNotPendingMutateError`](TransactionNotPendingMutateError.md)
+- [`TransactionAlreadyCompletedRollbackError`](TransactionAlreadyCompletedRollbackError.md)
+- [`TransactionNotPendingCommitError`](TransactionNotPendingCommitError.md)
+- [`NoPendingSyncTransactionWriteError`](NoPendingSyncTransactionWriteError.md)
+- [`SyncTransactionAlreadyCommittedWriteError`](SyncTransactionAlreadyCommittedWriteError.md)
+- [`NoPendingSyncTransactionCommitError`](NoPendingSyncTransactionCommitError.md)
+- [`SyncTransactionAlreadyCommittedError`](SyncTransactionAlreadyCommittedError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new TransactionError(message): TransactionError;
+```
+
+Defined in: [packages/db/src/errors.ts:287](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L287)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`TransactionError`
+
+#### Overrides
+
+[`TanStackDBError`](TanStackDBError.md).[`constructor`](TanStackDBError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`cause`](TanStackDBError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`message`](TanStackDBError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`name`](TanStackDBError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stack`](TanStackDBError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`stackTraceLimit`](TanStackDBError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`captureStackTrace`](TanStackDBError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TanStackDBError`](TanStackDBError.md).[`prepareStackTrace`](TanStackDBError.md#preparestacktrace)
diff --git a/docs/reference/classes/TransactionNotPendingCommitError.md b/docs/reference/classes/TransactionNotPendingCommitError.md
new file mode 100644
index 000000000..a69fa6f3c
--- /dev/null
+++ b/docs/reference/classes/TransactionNotPendingCommitError.md
@@ -0,0 +1,214 @@
+---
+id: TransactionNotPendingCommitError
+title: TransactionNotPendingCommitError
+---
+
+# Class: TransactionNotPendingCommitError
+
+Defined in: [packages/db/src/errors.ts:324](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L324)
+
+## Extends
+
+- [`TransactionError`](TransactionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new TransactionNotPendingCommitError(): TransactionNotPendingCommitError;
+```
+
+Defined in: [packages/db/src/errors.ts:325](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L325)
+
+#### Returns
+
+`TransactionNotPendingCommitError`
+
+#### Overrides
+
+[`TransactionError`](TransactionError.md).[`constructor`](TransactionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`cause`](TransactionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`message`](TransactionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`name`](TransactionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stack`](TransactionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stackTraceLimit`](TransactionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`captureStackTrace`](TransactionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`prepareStackTrace`](TransactionError.md#preparestacktrace)
diff --git a/docs/reference/classes/TransactionNotPendingMutateError.md b/docs/reference/classes/TransactionNotPendingMutateError.md
new file mode 100644
index 000000000..c57b13c42
--- /dev/null
+++ b/docs/reference/classes/TransactionNotPendingMutateError.md
@@ -0,0 +1,214 @@
+---
+id: TransactionNotPendingMutateError
+title: TransactionNotPendingMutateError
+---
+
+# Class: TransactionNotPendingMutateError
+
+Defined in: [packages/db/src/errors.ts:308](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L308)
+
+## Extends
+
+- [`TransactionError`](TransactionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new TransactionNotPendingMutateError(): TransactionNotPendingMutateError;
+```
+
+Defined in: [packages/db/src/errors.ts:309](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L309)
+
+#### Returns
+
+`TransactionNotPendingMutateError`
+
+#### Overrides
+
+[`TransactionError`](TransactionError.md).[`constructor`](TransactionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`cause`](TransactionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`message`](TransactionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`name`](TransactionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stack`](TransactionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`stackTraceLimit`](TransactionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`captureStackTrace`](TransactionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`TransactionError`](TransactionError.md).[`prepareStackTrace`](TransactionError.md#preparestacktrace)
diff --git a/docs/reference/classes/UndefinedKeyError.md b/docs/reference/classes/UndefinedKeyError.md
new file mode 100644
index 000000000..57fa5d9a1
--- /dev/null
+++ b/docs/reference/classes/UndefinedKeyError.md
@@ -0,0 +1,220 @@
+---
+id: UndefinedKeyError
+title: UndefinedKeyError
+---
+
+# Class: UndefinedKeyError
+
+Defined in: [packages/db/src/errors.ts:146](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L146)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UndefinedKeyError(item): UndefinedKeyError;
+```
+
+Defined in: [packages/db/src/errors.ts:147](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L147)
+
+#### Parameters
+
+##### item
+
+`any`
+
+#### Returns
+
+`UndefinedKeyError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/UnknownExpressionTypeError.md b/docs/reference/classes/UnknownExpressionTypeError.md
new file mode 100644
index 000000000..0e81ec6e6
--- /dev/null
+++ b/docs/reference/classes/UnknownExpressionTypeError.md
@@ -0,0 +1,220 @@
+---
+id: UnknownExpressionTypeError
+title: UnknownExpressionTypeError
+---
+
+# Class: UnknownExpressionTypeError
+
+Defined in: [packages/db/src/errors.ts:492](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L492)
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UnknownExpressionTypeError(type): UnknownExpressionTypeError;
+```
+
+Defined in: [packages/db/src/errors.ts:493](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L493)
+
+#### Parameters
+
+##### type
+
+`string`
+
+#### Returns
+
+`UnknownExpressionTypeError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/UnknownFunctionError.md b/docs/reference/classes/UnknownFunctionError.md
new file mode 100644
index 000000000..dcfcfac04
--- /dev/null
+++ b/docs/reference/classes/UnknownFunctionError.md
@@ -0,0 +1,220 @@
+---
+id: UnknownFunctionError
+title: UnknownFunctionError
+---
+
+# Class: UnknownFunctionError
+
+Defined in: [packages/db/src/errors.ts:504](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L504)
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UnknownFunctionError(functionName): UnknownFunctionError;
+```
+
+Defined in: [packages/db/src/errors.ts:505](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L505)
+
+#### Parameters
+
+##### functionName
+
+`string`
+
+#### Returns
+
+`UnknownFunctionError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/UnknownHavingExpressionTypeError.md b/docs/reference/classes/UnknownHavingExpressionTypeError.md
new file mode 100644
index 000000000..28bbbf626
--- /dev/null
+++ b/docs/reference/classes/UnknownHavingExpressionTypeError.md
@@ -0,0 +1,220 @@
+---
+id: UnknownHavingExpressionTypeError
+title: UnknownHavingExpressionTypeError
+---
+
+# Class: UnknownHavingExpressionTypeError
+
+Defined in: [packages/db/src/errors.ts:602](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L602)
+
+## Extends
+
+- [`GroupByError`](GroupByError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UnknownHavingExpressionTypeError(type): UnknownHavingExpressionTypeError;
+```
+
+Defined in: [packages/db/src/errors.ts:603](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L603)
+
+#### Parameters
+
+##### type
+
+`string`
+
+#### Returns
+
+`UnknownHavingExpressionTypeError`
+
+#### Overrides
+
+[`GroupByError`](GroupByError.md).[`constructor`](GroupByError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`cause`](GroupByError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`message`](GroupByError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`name`](GroupByError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`stack`](GroupByError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`stackTraceLimit`](GroupByError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`captureStackTrace`](GroupByError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`prepareStackTrace`](GroupByError.md#preparestacktrace)
diff --git a/docs/reference/classes/UnsupportedAggregateFunctionError.md b/docs/reference/classes/UnsupportedAggregateFunctionError.md
new file mode 100644
index 000000000..6ba271a2c
--- /dev/null
+++ b/docs/reference/classes/UnsupportedAggregateFunctionError.md
@@ -0,0 +1,220 @@
+---
+id: UnsupportedAggregateFunctionError
+title: UnsupportedAggregateFunctionError
+---
+
+# Class: UnsupportedAggregateFunctionError
+
+Defined in: [packages/db/src/errors.ts:588](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L588)
+
+## Extends
+
+- [`GroupByError`](GroupByError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UnsupportedAggregateFunctionError(functionName): UnsupportedAggregateFunctionError;
+```
+
+Defined in: [packages/db/src/errors.ts:589](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L589)
+
+#### Parameters
+
+##### functionName
+
+`string`
+
+#### Returns
+
+`UnsupportedAggregateFunctionError`
+
+#### Overrides
+
+[`GroupByError`](GroupByError.md).[`constructor`](GroupByError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`cause`](GroupByError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`message`](GroupByError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`name`](GroupByError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`stack`](GroupByError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`stackTraceLimit`](GroupByError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`captureStackTrace`](GroupByError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`GroupByError`](GroupByError.md).[`prepareStackTrace`](GroupByError.md#preparestacktrace)
diff --git a/docs/reference/classes/UnsupportedFromTypeError.md b/docs/reference/classes/UnsupportedFromTypeError.md
new file mode 100644
index 000000000..1edccc559
--- /dev/null
+++ b/docs/reference/classes/UnsupportedFromTypeError.md
@@ -0,0 +1,220 @@
+---
+id: UnsupportedFromTypeError
+title: UnsupportedFromTypeError
+---
+
+# Class: UnsupportedFromTypeError
+
+Defined in: [packages/db/src/errors.ts:486](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L486)
+
+## Extends
+
+- [`QueryCompilationError`](QueryCompilationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UnsupportedFromTypeError(type): UnsupportedFromTypeError;
+```
+
+Defined in: [packages/db/src/errors.ts:487](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L487)
+
+#### Parameters
+
+##### type
+
+`string`
+
+#### Returns
+
+`UnsupportedFromTypeError`
+
+#### Overrides
+
+[`QueryCompilationError`](QueryCompilationError.md).[`constructor`](QueryCompilationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`cause`](QueryCompilationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`message`](QueryCompilationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`name`](QueryCompilationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stack`](QueryCompilationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`stackTraceLimit`](QueryCompilationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`captureStackTrace`](QueryCompilationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCompilationError`](QueryCompilationError.md).[`prepareStackTrace`](QueryCompilationError.md#preparestacktrace)
diff --git a/docs/reference/classes/UnsupportedJoinSourceTypeError.md b/docs/reference/classes/UnsupportedJoinSourceTypeError.md
new file mode 100644
index 000000000..b16ccdccb
--- /dev/null
+++ b/docs/reference/classes/UnsupportedJoinSourceTypeError.md
@@ -0,0 +1,220 @@
+---
+id: UnsupportedJoinSourceTypeError
+title: UnsupportedJoinSourceTypeError
+---
+
+# Class: UnsupportedJoinSourceTypeError
+
+Defined in: [packages/db/src/errors.ts:566](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L566)
+
+## Extends
+
+- [`JoinError`](JoinError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UnsupportedJoinSourceTypeError(type): UnsupportedJoinSourceTypeError;
+```
+
+Defined in: [packages/db/src/errors.ts:567](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L567)
+
+#### Parameters
+
+##### type
+
+`string`
+
+#### Returns
+
+`UnsupportedJoinSourceTypeError`
+
+#### Overrides
+
+[`JoinError`](JoinError.md).[`constructor`](JoinError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`cause`](JoinError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`message`](JoinError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`name`](JoinError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stack`](JoinError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stackTraceLimit`](JoinError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`captureStackTrace`](JoinError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`prepareStackTrace`](JoinError.md#preparestacktrace)
diff --git a/docs/reference/classes/UnsupportedJoinTypeError.md b/docs/reference/classes/UnsupportedJoinTypeError.md
new file mode 100644
index 000000000..b4af5500f
--- /dev/null
+++ b/docs/reference/classes/UnsupportedJoinTypeError.md
@@ -0,0 +1,220 @@
+---
+id: UnsupportedJoinTypeError
+title: UnsupportedJoinTypeError
+---
+
+# Class: UnsupportedJoinTypeError
+
+Defined in: [packages/db/src/errors.ts:524](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L524)
+
+## Extends
+
+- [`JoinError`](JoinError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UnsupportedJoinTypeError(joinType): UnsupportedJoinTypeError;
+```
+
+Defined in: [packages/db/src/errors.ts:525](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L525)
+
+#### Parameters
+
+##### joinType
+
+`string`
+
+#### Returns
+
+`UnsupportedJoinTypeError`
+
+#### Overrides
+
+[`JoinError`](JoinError.md).[`constructor`](JoinError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`cause`](JoinError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`message`](JoinError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`name`](JoinError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stack`](JoinError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`stackTraceLimit`](JoinError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`captureStackTrace`](JoinError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`JoinError`](JoinError.md).[`prepareStackTrace`](JoinError.md#preparestacktrace)
diff --git a/docs/reference/classes/UpdateKeyNotFoundError.md b/docs/reference/classes/UpdateKeyNotFoundError.md
new file mode 100644
index 000000000..6a6a48778
--- /dev/null
+++ b/docs/reference/classes/UpdateKeyNotFoundError.md
@@ -0,0 +1,220 @@
+---
+id: UpdateKeyNotFoundError
+title: UpdateKeyNotFoundError
+---
+
+# Class: UpdateKeyNotFoundError
+
+Defined in: [packages/db/src/errors.ts:223](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L223)
+
+## Extends
+
+- [`CollectionOperationError`](CollectionOperationError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UpdateKeyNotFoundError(key): UpdateKeyNotFoundError;
+```
+
+Defined in: [packages/db/src/errors.ts:224](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L224)
+
+#### Parameters
+
+##### key
+
+`string` | `number`
+
+#### Returns
+
+`UpdateKeyNotFoundError`
+
+#### Overrides
+
+[`CollectionOperationError`](CollectionOperationError.md).[`constructor`](CollectionOperationError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`cause`](CollectionOperationError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`message`](CollectionOperationError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`name`](CollectionOperationError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stack`](CollectionOperationError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`stackTraceLimit`](CollectionOperationError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`captureStackTrace`](CollectionOperationError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`CollectionOperationError`](CollectionOperationError.md).[`prepareStackTrace`](CollectionOperationError.md#preparestacktrace)
diff --git a/docs/reference/classes/WhereClauseConversionError.md b/docs/reference/classes/WhereClauseConversionError.md
new file mode 100644
index 000000000..7c0f878b6
--- /dev/null
+++ b/docs/reference/classes/WhereClauseConversionError.md
@@ -0,0 +1,226 @@
+---
+id: WhereClauseConversionError
+title: WhereClauseConversionError
+---
+
+# Class: WhereClauseConversionError
+
+Defined in: [packages/db/src/errors.ts:682](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L682)
+
+Internal error when the query optimizer fails to convert a WHERE clause to a collection filter.
+
+## Extends
+
+- [`QueryOptimizerError`](QueryOptimizerError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new WhereClauseConversionError(collectionId, alias): WhereClauseConversionError;
+```
+
+Defined in: [packages/db/src/errors.ts:683](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L683)
+
+#### Parameters
+
+##### collectionId
+
+`string`
+
+##### alias
+
+`string`
+
+#### Returns
+
+`WhereClauseConversionError`
+
+#### Overrides
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`constructor`](QueryOptimizerError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`cause`](QueryOptimizerError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`message`](QueryOptimizerError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`name`](QueryOptimizerError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`stack`](QueryOptimizerError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`stackTraceLimit`](QueryOptimizerError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`captureStackTrace`](QueryOptimizerError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryOptimizerError`](QueryOptimizerError.md).[`prepareStackTrace`](QueryOptimizerError.md#preparestacktrace)
diff --git a/docs/reference/classes/aggregatefunctionnotinselecterror.md b/docs/reference/classes/aggregatefunctionnotinselecterror.md
deleted file mode 100644
index 2946c6d82..000000000
--- a/docs/reference/classes/aggregatefunctionnotinselecterror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: AggregateFunctionNotInSelectError
-title: AggregateFunctionNotInSelectError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: AggregateFunctionNotInSelectError
-
-Defined in: [packages/db/src/errors.ts:451](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L451)
-
-## Extends
-
-- [`GroupByError`](../groupbyerror.md)
-
-## Constructors
-
-### new AggregateFunctionNotInSelectError()
-
-```ts
-new AggregateFunctionNotInSelectError(functionName): AggregateFunctionNotInSelectError
-```
-
-Defined in: [packages/db/src/errors.ts:452](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L452)
-
-#### Parameters
-
-##### functionName
-
-`string`
-
-#### Returns
-
-[`AggregateFunctionNotInSelectError`](../aggregatefunctionnotinselecterror.md)
-
-#### Overrides
-
-[`GroupByError`](../groupbyerror.md).[`constructor`](../GroupByError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`cause`](../GroupByError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`message`](../GroupByError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`name`](../GroupByError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`stack`](../GroupByError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`prepareStackTrace`](../GroupByError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`stackTraceLimit`](../GroupByError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`captureStackTrace`](../GroupByError.md#capturestacktrace)
diff --git a/docs/reference/classes/btreeindex.md b/docs/reference/classes/btreeindex.md
deleted file mode 100644
index 3f9c16511..000000000
--- a/docs/reference/classes/btreeindex.md
+++ /dev/null
@@ -1,625 +0,0 @@
----
-id: BTreeIndex
-title: BTreeIndex
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: BTreeIndex\<TKey\>
-
-Defined in: [packages/db/src/indexes/btree-index.ts:28](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L28)
-
-B+Tree index for sorted data with range queries
-This maintains items in sorted order and provides efficient range operations
-
-## Extends
-
-- [`BaseIndex`](../baseindex.md)\<`TKey`\>
-
-## Type Parameters
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-## Constructors
-
-### new BTreeIndex()
-
-```ts
-new BTreeIndex<TKey>(
-   id, 
-   expression, 
-   name?, 
-options?): BTreeIndex<TKey>
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:48](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L48)
-
-#### Parameters
-
-##### id
-
-`number`
-
-##### expression
-
-`BasicExpression`
-
-##### name?
-
-`string`
-
-##### options?
-
-`any`
-
-#### Returns
-
-[`BTreeIndex`](../btreeindex.md)\<`TKey`\>
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`constructor`](../BaseIndex.md#constructors)
-
-## Properties
-
-### expression
-
-```ts
-readonly expression: BasicExpression;
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:33](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L33)
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`expression`](../BaseIndex.md#expression-1)
-
-***
-
-### id
-
-```ts
-readonly id: number;
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:31](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L31)
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`id`](../BaseIndex.md#id-1)
-
-***
-
-### lastUpdated
-
-```ts
-protected lastUpdated: Date;
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:38](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L38)
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`lastUpdated`](../BaseIndex.md#lastupdated)
-
-***
-
-### lookupCount
-
-```ts
-protected lookupCount: number = 0;
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:36](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L36)
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`lookupCount`](../BaseIndex.md#lookupcount)
-
-***
-
-### name?
-
-```ts
-readonly optional name: string;
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:32](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L32)
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`name`](../BaseIndex.md#name-1)
-
-***
-
-### supportedOperations
-
-```ts
-readonly supportedOperations: Set<"eq" | "gt" | "gte" | "lt" | "lte" | "in" | "like" | "ilike">;
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:31](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L31)
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`supportedOperations`](../BaseIndex.md#supportedoperations)
-
-***
-
-### totalLookupTime
-
-```ts
-protected totalLookupTime: number = 0;
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:37](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L37)
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`totalLookupTime`](../BaseIndex.md#totallookuptime)
-
-## Accessors
-
-### indexedKeysSet
-
-#### Get Signature
-
-```ts
-get indexedKeysSet(): Set<TKey>
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:250](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L250)
-
-##### Returns
-
-`Set`\<`TKey`\>
-
-***
-
-### keyCount
-
-#### Get Signature
-
-```ts
-get keyCount(): number
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:188](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L188)
-
-Gets the number of indexed keys
-
-##### Returns
-
-`number`
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`keyCount`](../BaseIndex.md#keycount)
-
-***
-
-### orderedEntriesArray
-
-#### Get Signature
-
-```ts
-get orderedEntriesArray(): [any, Set<TKey>][]
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:254](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L254)
-
-##### Returns
-
-\[`any`, `Set`\<`TKey`\>\][]
-
-***
-
-### valueMapData
-
-#### Get Signature
-
-```ts
-get valueMapData(): Map<any, Set<TKey>>
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:260](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L260)
-
-##### Returns
-
-`Map`\<`any`, `Set`\<`TKey`\>\>
-
-## Methods
-
-### add()
-
-```ts
-add(key, item): void
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:64](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L64)
-
-Adds a value to the index
-
-#### Parameters
-
-##### key
-
-`TKey`
-
-##### item
-
-`any`
-
-#### Returns
-
-`void`
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`add`](../BaseIndex.md#add)
-
-***
-
-### build()
-
-```ts
-build(entries): void
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:132](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L132)
-
-Builds the index from a collection of entries
-
-#### Parameters
-
-##### entries
-
-`Iterable`\<\[`TKey`, `any`\]\>
-
-#### Returns
-
-`void`
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`build`](../BaseIndex.md#build)
-
-***
-
-### clear()
-
-```ts
-clear(): void
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:143](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L143)
-
-Clears all data from the index
-
-#### Returns
-
-`void`
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`clear`](../BaseIndex.md#clear)
-
-***
-
-### equalityLookup()
-
-```ts
-equalityLookup(value): Set<TKey>
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:197](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L197)
-
-Performs an equality lookup
-
-#### Parameters
-
-##### value
-
-`any`
-
-#### Returns
-
-`Set`\<`TKey`\>
-
-***
-
-### evaluateIndexExpression()
-
-```ts
-protected evaluateIndexExpression(item): any
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:87](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L87)
-
-#### Parameters
-
-##### item
-
-`any`
-
-#### Returns
-
-`any`
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`evaluateIndexExpression`](../BaseIndex.md#evaluateindexexpression)
-
-***
-
-### getStats()
-
-```ts
-getStats(): IndexStats
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:74](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L74)
-
-#### Returns
-
-[`IndexStats`](../../interfaces/indexstats.md)
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`getStats`](../BaseIndex.md#getstats)
-
-***
-
-### inArrayLookup()
-
-```ts
-inArrayLookup(values): Set<TKey>
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:236](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L236)
-
-Performs an IN array lookup
-
-#### Parameters
-
-##### values
-
-`any`[]
-
-#### Returns
-
-`Set`\<`TKey`\>
-
-***
-
-### initialize()
-
-```ts
-protected initialize(_options?): void
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:59](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L59)
-
-#### Parameters
-
-##### \_options?
-
-[`BTreeIndexOptions`](../../interfaces/btreeindexoptions.md)
-
-#### Returns
-
-`void`
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`initialize`](../BaseIndex.md#initialize)
-
-***
-
-### lookup()
-
-```ts
-lookup(operation, value): Set<TKey>
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:153](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L153)
-
-Performs a lookup operation
-
-#### Parameters
-
-##### operation
-
-`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
-
-##### value
-
-`any`
-
-#### Returns
-
-`Set`\<`TKey`\>
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`lookup`](../BaseIndex.md#lookup)
-
-***
-
-### matchesField()
-
-```ts
-matchesField(fieldPath): boolean
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:66](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L66)
-
-#### Parameters
-
-##### fieldPath
-
-`string`[]
-
-#### Returns
-
-`boolean`
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`matchesField`](../BaseIndex.md#matchesfield)
-
-***
-
-### rangeQuery()
-
-```ts
-rangeQuery(options): Set<TKey>
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:205](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L205)
-
-Performs a range query with options
-This is more efficient for compound queries like "WHERE a > 5 AND a < 10"
-
-#### Parameters
-
-##### options
-
-[`RangeQueryOptions`](../../interfaces/rangequeryoptions.md) = `{}`
-
-#### Returns
-
-`Set`\<`TKey`\>
-
-***
-
-### remove()
-
-```ts
-remove(key, item): void
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:92](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L92)
-
-Removes a value from the index
-
-#### Parameters
-
-##### key
-
-`TKey`
-
-##### item
-
-`any`
-
-#### Returns
-
-`void`
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`remove`](../BaseIndex.md#remove)
-
-***
-
-### supports()
-
-```ts
-supports(operation): boolean
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:62](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L62)
-
-#### Parameters
-
-##### operation
-
-`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
-
-#### Returns
-
-`boolean`
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`supports`](../BaseIndex.md#supports)
-
-***
-
-### trackLookup()
-
-```ts
-protected trackLookup(startTime): void
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:92](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L92)
-
-#### Parameters
-
-##### startTime
-
-`number`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`trackLookup`](../BaseIndex.md#tracklookup)
-
-***
-
-### update()
-
-```ts
-update(
-   key, 
-   oldItem, 
-   newItem): void
-```
-
-Defined in: [packages/db/src/indexes/btree-index.ts:124](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L124)
-
-Updates a value in the index
-
-#### Parameters
-
-##### key
-
-`TKey`
-
-##### oldItem
-
-`any`
-
-##### newItem
-
-`any`
-
-#### Returns
-
-`void`
-
-#### Overrides
-
-[`BaseIndex`](../baseindex.md).[`update`](../BaseIndex.md#update)
-
-***
-
-### updateTimestamp()
-
-```ts
-protected updateTimestamp(): void
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:98](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L98)
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`BaseIndex`](../baseindex.md).[`updateTimestamp`](../BaseIndex.md#updatetimestamp)
diff --git a/docs/reference/classes/cannotcombineemptyexpressionlisterror.md b/docs/reference/classes/cannotcombineemptyexpressionlisterror.md
deleted file mode 100644
index 95d4ac316..000000000
--- a/docs/reference/classes/cannotcombineemptyexpressionlisterror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: CannotCombineEmptyExpressionListError
-title: CannotCombineEmptyExpressionListError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: CannotCombineEmptyExpressionListError
-
-Defined in: [packages/db/src/errors.ts:546](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L546)
-
-## Extends
-
-- [`QueryOptimizerError`](../queryoptimizererror.md)
-
-## Constructors
-
-### new CannotCombineEmptyExpressionListError()
-
-```ts
-new CannotCombineEmptyExpressionListError(): CannotCombineEmptyExpressionListError
-```
-
-Defined in: [packages/db/src/errors.ts:547](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L547)
-
-#### Returns
-
-[`CannotCombineEmptyExpressionListError`](../cannotcombineemptyexpressionlisterror.md)
-
-#### Overrides
-
-[`QueryOptimizerError`](../queryoptimizererror.md).[`constructor`](../QueryOptimizerError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryOptimizerError`](../queryoptimizererror.md).[`cause`](../QueryOptimizerError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryOptimizerError`](../queryoptimizererror.md).[`message`](../QueryOptimizerError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryOptimizerError`](../queryoptimizererror.md).[`name`](../QueryOptimizerError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryOptimizerError`](../queryoptimizererror.md).[`stack`](../QueryOptimizerError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryOptimizerError`](../queryoptimizererror.md).[`prepareStackTrace`](../QueryOptimizerError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryOptimizerError`](../queryoptimizererror.md).[`stackTraceLimit`](../QueryOptimizerError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryOptimizerError`](../queryoptimizererror.md).[`captureStackTrace`](../QueryOptimizerError.md#capturestacktrace)
diff --git a/docs/reference/classes/collectionconfigurationerror.md b/docs/reference/classes/collectionconfigurationerror.md
deleted file mode 100644
index 6c9940696..000000000
--- a/docs/reference/classes/collectionconfigurationerror.md
+++ /dev/null
@@ -1,179 +0,0 @@
----
-id: CollectionConfigurationError
-title: CollectionConfigurationError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: CollectionConfigurationError
-
-Defined in: [packages/db/src/errors.ts:45](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L45)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`CollectionRequiresConfigError`](../collectionrequiresconfigerror.md)
-- [`CollectionRequiresSyncConfigError`](../collectionrequiressyncconfigerror.md)
-- [`InvalidSchemaError`](../invalidschemaerror.md)
-- [`SchemaMustBeSynchronousError`](../schemamustbesynchronouserror.md)
-
-## Constructors
-
-### new CollectionConfigurationError()
-
-```ts
-new CollectionConfigurationError(message): CollectionConfigurationError
-```
-
-Defined in: [packages/db/src/errors.ts:46](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L46)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/collectioninerrorstateerror.md b/docs/reference/classes/collectioninerrorstateerror.md
deleted file mode 100644
index 35fa08ff2..000000000
--- a/docs/reference/classes/collectioninerrorstateerror.md
+++ /dev/null
@@ -1,176 +0,0 @@
----
-id: CollectionInErrorStateError
-title: CollectionInErrorStateError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: CollectionInErrorStateError
-
-Defined in: [packages/db/src/errors.ts:84](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L84)
-
-## Extends
-
-- [`CollectionStateError`](../collectionstateerror.md)
-
-## Constructors
-
-### new CollectionInErrorStateError()
-
-```ts
-new CollectionInErrorStateError(operation, collectionId): CollectionInErrorStateError
-```
-
-Defined in: [packages/db/src/errors.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L85)
-
-#### Parameters
-
-##### operation
-
-`string`
-
-##### collectionId
-
-`string`
-
-#### Returns
-
-[`CollectionInErrorStateError`](../collectioninerrorstateerror.md)
-
-#### Overrides
-
-[`CollectionStateError`](../collectionstateerror.md).[`constructor`](../CollectionStateError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`cause`](../CollectionStateError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`message`](../CollectionStateError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`name`](../CollectionStateError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`stack`](../CollectionStateError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`prepareStackTrace`](../CollectionStateError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`stackTraceLimit`](../CollectionStateError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`captureStackTrace`](../CollectionStateError.md#capturestacktrace)
diff --git a/docs/reference/classes/collectioninputnotfounderror.md b/docs/reference/classes/collectioninputnotfounderror.md
deleted file mode 100644
index 367cfad3a..000000000
--- a/docs/reference/classes/collectioninputnotfounderror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: CollectionInputNotFoundError
-title: CollectionInputNotFoundError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: CollectionInputNotFoundError
-
-Defined in: [packages/db/src/errors.ts:350](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L350)
-
-## Extends
-
-- [`QueryCompilationError`](../querycompilationerror.md)
-
-## Constructors
-
-### new CollectionInputNotFoundError()
-
-```ts
-new CollectionInputNotFoundError(collectionId): CollectionInputNotFoundError
-```
-
-Defined in: [packages/db/src/errors.ts:351](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L351)
-
-#### Parameters
-
-##### collectionId
-
-`string`
-
-#### Returns
-
-[`CollectionInputNotFoundError`](../collectioninputnotfounderror.md)
-
-#### Overrides
-
-[`QueryCompilationError`](../querycompilationerror.md).[`constructor`](../QueryCompilationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`cause`](../QueryCompilationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`message`](../QueryCompilationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`name`](../QueryCompilationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stack`](../QueryCompilationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`prepareStackTrace`](../QueryCompilationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stackTraceLimit`](../QueryCompilationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`captureStackTrace`](../QueryCompilationError.md#capturestacktrace)
diff --git a/docs/reference/classes/collectionisinerrorstateerror.md b/docs/reference/classes/collectionisinerrorstateerror.md
deleted file mode 100644
index 6a82b982e..000000000
--- a/docs/reference/classes/collectionisinerrorstateerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: CollectionIsInErrorStateError
-title: CollectionIsInErrorStateError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: CollectionIsInErrorStateError
-
-Defined in: [packages/db/src/errors.ts:100](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L100)
-
-## Extends
-
-- [`CollectionStateError`](../collectionstateerror.md)
-
-## Constructors
-
-### new CollectionIsInErrorStateError()
-
-```ts
-new CollectionIsInErrorStateError(): CollectionIsInErrorStateError
-```
-
-Defined in: [packages/db/src/errors.ts:101](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L101)
-
-#### Returns
-
-[`CollectionIsInErrorStateError`](../collectionisinerrorstateerror.md)
-
-#### Overrides
-
-[`CollectionStateError`](../collectionstateerror.md).[`constructor`](../CollectionStateError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`cause`](../CollectionStateError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`message`](../CollectionStateError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`name`](../CollectionStateError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`stack`](../CollectionStateError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`prepareStackTrace`](../CollectionStateError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`stackTraceLimit`](../CollectionStateError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`captureStackTrace`](../CollectionStateError.md#capturestacktrace)
diff --git a/docs/reference/classes/collectionoperationerror.md b/docs/reference/classes/collectionoperationerror.md
deleted file mode 100644
index 44f165728..000000000
--- a/docs/reference/classes/collectionoperationerror.md
+++ /dev/null
@@ -1,184 +0,0 @@
----
-id: CollectionOperationError
-title: CollectionOperationError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: CollectionOperationError
-
-Defined in: [packages/db/src/errors.ts:113](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L113)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`UndefinedKeyError`](../undefinedkeyerror.md)
-- [`DuplicateKeyError`](../duplicatekeyerror.md)
-- [`DuplicateKeySyncError`](../duplicatekeysyncerror.md)
-- [`MissingUpdateArgumentError`](../missingupdateargumenterror.md)
-- [`NoKeysPassedToUpdateError`](../nokeyspassedtoupdateerror.md)
-- [`UpdateKeyNotFoundError`](../updatekeynotfounderror.md)
-- [`KeyUpdateNotAllowedError`](../keyupdatenotallowederror.md)
-- [`NoKeysPassedToDeleteError`](../nokeyspassedtodeleteerror.md)
-- [`DeleteKeyNotFoundError`](../deletekeynotfounderror.md)
-
-## Constructors
-
-### new CollectionOperationError()
-
-```ts
-new CollectionOperationError(message): CollectionOperationError
-```
-
-Defined in: [packages/db/src/errors.ts:114](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L114)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`CollectionOperationError`](../collectionoperationerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/collectionrequiresconfigerror.md b/docs/reference/classes/collectionrequiresconfigerror.md
deleted file mode 100644
index 076d78f6d..000000000
--- a/docs/reference/classes/collectionrequiresconfigerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: CollectionRequiresConfigError
-title: CollectionRequiresConfigError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: CollectionRequiresConfigError
-
-Defined in: [packages/db/src/errors.ts:52](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L52)
-
-## Extends
-
-- [`CollectionConfigurationError`](../collectionconfigurationerror.md)
-
-## Constructors
-
-### new CollectionRequiresConfigError()
-
-```ts
-new CollectionRequiresConfigError(): CollectionRequiresConfigError
-```
-
-Defined in: [packages/db/src/errors.ts:53](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L53)
-
-#### Returns
-
-[`CollectionRequiresConfigError`](../collectionrequiresconfigerror.md)
-
-#### Overrides
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`constructor`](../CollectionConfigurationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`cause`](../CollectionConfigurationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`message`](../CollectionConfigurationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`name`](../CollectionConfigurationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`stack`](../CollectionConfigurationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`prepareStackTrace`](../CollectionConfigurationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`stackTraceLimit`](../CollectionConfigurationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`captureStackTrace`](../CollectionConfigurationError.md#capturestacktrace)
diff --git a/docs/reference/classes/collectionrequiressyncconfigerror.md b/docs/reference/classes/collectionrequiressyncconfigerror.md
deleted file mode 100644
index 969fbbcdf..000000000
--- a/docs/reference/classes/collectionrequiressyncconfigerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: CollectionRequiresSyncConfigError
-title: CollectionRequiresSyncConfigError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: CollectionRequiresSyncConfigError
-
-Defined in: [packages/db/src/errors.ts:58](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L58)
-
-## Extends
-
-- [`CollectionConfigurationError`](../collectionconfigurationerror.md)
-
-## Constructors
-
-### new CollectionRequiresSyncConfigError()
-
-```ts
-new CollectionRequiresSyncConfigError(): CollectionRequiresSyncConfigError
-```
-
-Defined in: [packages/db/src/errors.ts:59](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L59)
-
-#### Returns
-
-[`CollectionRequiresSyncConfigError`](../collectionrequiressyncconfigerror.md)
-
-#### Overrides
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`constructor`](../CollectionConfigurationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`cause`](../CollectionConfigurationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`message`](../CollectionConfigurationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`name`](../CollectionConfigurationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`stack`](../CollectionConfigurationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`prepareStackTrace`](../CollectionConfigurationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`stackTraceLimit`](../CollectionConfigurationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`captureStackTrace`](../CollectionConfigurationError.md#capturestacktrace)
diff --git a/docs/reference/classes/collectionstateerror.md b/docs/reference/classes/collectionstateerror.md
deleted file mode 100644
index c5567fddc..000000000
--- a/docs/reference/classes/collectionstateerror.md
+++ /dev/null
@@ -1,179 +0,0 @@
----
-id: CollectionStateError
-title: CollectionStateError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: CollectionStateError
-
-Defined in: [packages/db/src/errors.ts:77](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L77)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`CollectionInErrorStateError`](../collectioninerrorstateerror.md)
-- [`InvalidCollectionStatusTransitionError`](../invalidcollectionstatustransitionerror.md)
-- [`CollectionIsInErrorStateError`](../collectionisinerrorstateerror.md)
-- [`NegativeActiveSubscribersError`](../negativeactivesubscriberserror.md)
-
-## Constructors
-
-### new CollectionStateError()
-
-```ts
-new CollectionStateError(message): CollectionStateError
-```
-
-Defined in: [packages/db/src/errors.ts:78](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L78)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`CollectionStateError`](../collectionstateerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/deletekeynotfounderror.md b/docs/reference/classes/deletekeynotfounderror.md
deleted file mode 100644
index 70b79ba87..000000000
--- a/docs/reference/classes/deletekeynotfounderror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: DeleteKeyNotFoundError
-title: DeleteKeyNotFoundError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: DeleteKeyNotFoundError
-
-Defined in: [packages/db/src/errors.ts:178](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L178)
-
-## Extends
-
-- [`CollectionOperationError`](../collectionoperationerror.md)
-
-## Constructors
-
-### new DeleteKeyNotFoundError()
-
-```ts
-new DeleteKeyNotFoundError(key): DeleteKeyNotFoundError
-```
-
-Defined in: [packages/db/src/errors.ts:179](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L179)
-
-#### Parameters
-
-##### key
-
-`string` | `number`
-
-#### Returns
-
-[`DeleteKeyNotFoundError`](../deletekeynotfounderror.md)
-
-#### Overrides
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`constructor`](../CollectionOperationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`cause`](../CollectionOperationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`message`](../CollectionOperationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`name`](../CollectionOperationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stack`](../CollectionOperationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`prepareStackTrace`](../CollectionOperationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stackTraceLimit`](../CollectionOperationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`captureStackTrace`](../CollectionOperationError.md#capturestacktrace)
diff --git a/docs/reference/classes/distinctrequiresselecterror.md b/docs/reference/classes/distinctrequiresselecterror.md
deleted file mode 100644
index dc00d2b46..000000000
--- a/docs/reference/classes/distinctrequiresselecterror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: DistinctRequiresSelectError
-title: DistinctRequiresSelectError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: DistinctRequiresSelectError
-
-Defined in: [packages/db/src/errors.ts:330](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L330)
-
-## Extends
-
-- [`QueryCompilationError`](../querycompilationerror.md)
-
-## Constructors
-
-### new DistinctRequiresSelectError()
-
-```ts
-new DistinctRequiresSelectError(): DistinctRequiresSelectError
-```
-
-Defined in: [packages/db/src/errors.ts:331](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L331)
-
-#### Returns
-
-[`DistinctRequiresSelectError`](../distinctrequiresselecterror.md)
-
-#### Overrides
-
-[`QueryCompilationError`](../querycompilationerror.md).[`constructor`](../QueryCompilationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`cause`](../QueryCompilationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`message`](../QueryCompilationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`name`](../QueryCompilationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stack`](../QueryCompilationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`prepareStackTrace`](../QueryCompilationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stackTraceLimit`](../QueryCompilationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`captureStackTrace`](../QueryCompilationError.md#capturestacktrace)
diff --git a/docs/reference/classes/duplicatekeyerror.md b/docs/reference/classes/duplicatekeyerror.md
deleted file mode 100644
index 49cac206b..000000000
--- a/docs/reference/classes/duplicatekeyerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: DuplicateKeyError
-title: DuplicateKeyError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: DuplicateKeyError
-
-Defined in: [packages/db/src/errors.ts:128](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L128)
-
-## Extends
-
-- [`CollectionOperationError`](../collectionoperationerror.md)
-
-## Constructors
-
-### new DuplicateKeyError()
-
-```ts
-new DuplicateKeyError(key): DuplicateKeyError
-```
-
-Defined in: [packages/db/src/errors.ts:129](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L129)
-
-#### Parameters
-
-##### key
-
-`string` | `number`
-
-#### Returns
-
-[`DuplicateKeyError`](../duplicatekeyerror.md)
-
-#### Overrides
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`constructor`](../CollectionOperationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`cause`](../CollectionOperationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`message`](../CollectionOperationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`name`](../CollectionOperationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stack`](../CollectionOperationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`prepareStackTrace`](../CollectionOperationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stackTraceLimit`](../CollectionOperationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`captureStackTrace`](../CollectionOperationError.md#capturestacktrace)
diff --git a/docs/reference/classes/duplicatekeysyncerror.md b/docs/reference/classes/duplicatekeysyncerror.md
deleted file mode 100644
index 53241ad31..000000000
--- a/docs/reference/classes/duplicatekeysyncerror.md
+++ /dev/null
@@ -1,176 +0,0 @@
----
-id: DuplicateKeySyncError
-title: DuplicateKeySyncError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: DuplicateKeySyncError
-
-Defined in: [packages/db/src/errors.ts:136](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L136)
-
-## Extends
-
-- [`CollectionOperationError`](../collectionoperationerror.md)
-
-## Constructors
-
-### new DuplicateKeySyncError()
-
-```ts
-new DuplicateKeySyncError(key, collectionId): DuplicateKeySyncError
-```
-
-Defined in: [packages/db/src/errors.ts:137](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L137)
-
-#### Parameters
-
-##### key
-
-`string` | `number`
-
-##### collectionId
-
-`string`
-
-#### Returns
-
-[`DuplicateKeySyncError`](../duplicatekeysyncerror.md)
-
-#### Overrides
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`constructor`](../CollectionOperationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`cause`](../CollectionOperationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`message`](../CollectionOperationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`name`](../CollectionOperationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stack`](../CollectionOperationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`prepareStackTrace`](../CollectionOperationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stackTraceLimit`](../CollectionOperationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`captureStackTrace`](../CollectionOperationError.md#capturestacktrace)
diff --git a/docs/reference/classes/emptyreferencepatherror.md b/docs/reference/classes/emptyreferencepatherror.md
deleted file mode 100644
index 877fc003a..000000000
--- a/docs/reference/classes/emptyreferencepatherror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: EmptyReferencePathError
-title: EmptyReferencePathError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: EmptyReferencePathError
-
-Defined in: [packages/db/src/errors.ts:368](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L368)
-
-## Extends
-
-- [`QueryCompilationError`](../querycompilationerror.md)
-
-## Constructors
-
-### new EmptyReferencePathError()
-
-```ts
-new EmptyReferencePathError(): EmptyReferencePathError
-```
-
-Defined in: [packages/db/src/errors.ts:369](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L369)
-
-#### Returns
-
-[`EmptyReferencePathError`](../emptyreferencepatherror.md)
-
-#### Overrides
-
-[`QueryCompilationError`](../querycompilationerror.md).[`constructor`](../QueryCompilationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`cause`](../QueryCompilationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`message`](../QueryCompilationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`name`](../QueryCompilationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stack`](../QueryCompilationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`prepareStackTrace`](../QueryCompilationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stackTraceLimit`](../QueryCompilationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`captureStackTrace`](../QueryCompilationError.md#capturestacktrace)
diff --git a/docs/reference/classes/groupbyerror.md b/docs/reference/classes/groupbyerror.md
deleted file mode 100644
index 6f91fc927..000000000
--- a/docs/reference/classes/groupbyerror.md
+++ /dev/null
@@ -1,179 +0,0 @@
----
-id: GroupByError
-title: GroupByError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: GroupByError
-
-Defined in: [packages/db/src/errors.ts:430](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L430)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`NonAggregateExpressionNotInGroupByError`](../nonaggregateexpressionnotingroupbyerror.md)
-- [`UnsupportedAggregateFunctionError`](../unsupportedaggregatefunctionerror.md)
-- [`AggregateFunctionNotInSelectError`](../aggregatefunctionnotinselecterror.md)
-- [`UnknownHavingExpressionTypeError`](../unknownhavingexpressiontypeerror.md)
-
-## Constructors
-
-### new GroupByError()
-
-```ts
-new GroupByError(message): GroupByError
-```
-
-Defined in: [packages/db/src/errors.ts:431](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L431)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`GroupByError`](../groupbyerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/havingrequiresgroupbyerror.md b/docs/reference/classes/havingrequiresgroupbyerror.md
deleted file mode 100644
index 8d82899a9..000000000
--- a/docs/reference/classes/havingrequiresgroupbyerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: HavingRequiresGroupByError
-title: HavingRequiresGroupByError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: HavingRequiresGroupByError
-
-Defined in: [packages/db/src/errors.ts:336](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L336)
-
-## Extends
-
-- [`QueryCompilationError`](../querycompilationerror.md)
-
-## Constructors
-
-### new HavingRequiresGroupByError()
-
-```ts
-new HavingRequiresGroupByError(): HavingRequiresGroupByError
-```
-
-Defined in: [packages/db/src/errors.ts:337](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L337)
-
-#### Returns
-
-[`HavingRequiresGroupByError`](../havingrequiresgroupbyerror.md)
-
-#### Overrides
-
-[`QueryCompilationError`](../querycompilationerror.md).[`constructor`](../QueryCompilationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`cause`](../QueryCompilationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`message`](../QueryCompilationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`name`](../QueryCompilationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stack`](../QueryCompilationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`prepareStackTrace`](../QueryCompilationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stackTraceLimit`](../QueryCompilationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`captureStackTrace`](../QueryCompilationError.md#capturestacktrace)
diff --git a/docs/reference/classes/invalidcollectionstatustransitionerror.md b/docs/reference/classes/invalidcollectionstatustransitionerror.md
deleted file mode 100644
index be5e56a30..000000000
--- a/docs/reference/classes/invalidcollectionstatustransitionerror.md
+++ /dev/null
@@ -1,183 +0,0 @@
----
-id: InvalidCollectionStatusTransitionError
-title: InvalidCollectionStatusTransitionError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: InvalidCollectionStatusTransitionError
-
-Defined in: [packages/db/src/errors.ts:92](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L92)
-
-## Extends
-
-- [`CollectionStateError`](../collectionstateerror.md)
-
-## Constructors
-
-### new InvalidCollectionStatusTransitionError()
-
-```ts
-new InvalidCollectionStatusTransitionError(
-   from, 
-   to, 
-   collectionId): InvalidCollectionStatusTransitionError
-```
-
-Defined in: [packages/db/src/errors.ts:93](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L93)
-
-#### Parameters
-
-##### from
-
-`string`
-
-##### to
-
-`string`
-
-##### collectionId
-
-`string`
-
-#### Returns
-
-[`InvalidCollectionStatusTransitionError`](../invalidcollectionstatustransitionerror.md)
-
-#### Overrides
-
-[`CollectionStateError`](../collectionstateerror.md).[`constructor`](../CollectionStateError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`cause`](../CollectionStateError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`message`](../CollectionStateError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`name`](../CollectionStateError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`stack`](../CollectionStateError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`prepareStackTrace`](../CollectionStateError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`stackTraceLimit`](../CollectionStateError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`captureStackTrace`](../CollectionStateError.md#capturestacktrace)
diff --git a/docs/reference/classes/invalidjoinconditionsametableerror.md b/docs/reference/classes/invalidjoinconditionsametableerror.md
deleted file mode 100644
index 984a968b7..000000000
--- a/docs/reference/classes/invalidjoinconditionsametableerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: InvalidJoinConditionSameTableError
-title: InvalidJoinConditionSameTableError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: InvalidJoinConditionSameTableError
-
-Defined in: [packages/db/src/errors.ts:394](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L394)
-
-## Extends
-
-- [`JoinError`](../joinerror.md)
-
-## Constructors
-
-### new InvalidJoinConditionSameTableError()
-
-```ts
-new InvalidJoinConditionSameTableError(tableAlias): InvalidJoinConditionSameTableError
-```
-
-Defined in: [packages/db/src/errors.ts:395](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L395)
-
-#### Parameters
-
-##### tableAlias
-
-`string`
-
-#### Returns
-
-[`InvalidJoinConditionSameTableError`](../invalidjoinconditionsametableerror.md)
-
-#### Overrides
-
-[`JoinError`](../joinerror.md).[`constructor`](../JoinError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`cause`](../JoinError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`message`](../JoinError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`name`](../JoinError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stack`](../JoinError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`prepareStackTrace`](../JoinError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stackTraceLimit`](../JoinError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`captureStackTrace`](../JoinError.md#capturestacktrace)
diff --git a/docs/reference/classes/invalidjoinconditiontablemismatcherror.md b/docs/reference/classes/invalidjoinconditiontablemismatcherror.md
deleted file mode 100644
index 62f253a18..000000000
--- a/docs/reference/classes/invalidjoinconditiontablemismatcherror.md
+++ /dev/null
@@ -1,176 +0,0 @@
----
-id: InvalidJoinConditionTableMismatchError
-title: InvalidJoinConditionTableMismatchError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: InvalidJoinConditionTableMismatchError
-
-Defined in: [packages/db/src/errors.ts:402](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L402)
-
-## Extends
-
-- [`JoinError`](../joinerror.md)
-
-## Constructors
-
-### new InvalidJoinConditionTableMismatchError()
-
-```ts
-new InvalidJoinConditionTableMismatchError(mainTableAlias, joinedTableAlias): InvalidJoinConditionTableMismatchError
-```
-
-Defined in: [packages/db/src/errors.ts:403](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L403)
-
-#### Parameters
-
-##### mainTableAlias
-
-`string`
-
-##### joinedTableAlias
-
-`string`
-
-#### Returns
-
-[`InvalidJoinConditionTableMismatchError`](../invalidjoinconditiontablemismatcherror.md)
-
-#### Overrides
-
-[`JoinError`](../joinerror.md).[`constructor`](../JoinError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`cause`](../JoinError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`message`](../JoinError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`name`](../JoinError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stack`](../JoinError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`prepareStackTrace`](../JoinError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stackTraceLimit`](../JoinError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`captureStackTrace`](../JoinError.md#capturestacktrace)
diff --git a/docs/reference/classes/invalidjoinconditionwrongtableserror.md b/docs/reference/classes/invalidjoinconditionwrongtableserror.md
deleted file mode 100644
index 03e2559ce..000000000
--- a/docs/reference/classes/invalidjoinconditionwrongtableserror.md
+++ /dev/null
@@ -1,188 +0,0 @@
----
-id: InvalidJoinConditionWrongTablesError
-title: InvalidJoinConditionWrongTablesError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: InvalidJoinConditionWrongTablesError
-
-Defined in: [packages/db/src/errors.ts:410](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L410)
-
-## Extends
-
-- [`JoinError`](../joinerror.md)
-
-## Constructors
-
-### new InvalidJoinConditionWrongTablesError()
-
-```ts
-new InvalidJoinConditionWrongTablesError(
-   leftTableAlias, 
-   rightTableAlias, 
-   mainTableAlias, 
-   joinedTableAlias): InvalidJoinConditionWrongTablesError
-```
-
-Defined in: [packages/db/src/errors.ts:411](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L411)
-
-#### Parameters
-
-##### leftTableAlias
-
-`string`
-
-##### rightTableAlias
-
-`string`
-
-##### mainTableAlias
-
-`string`
-
-##### joinedTableAlias
-
-`string`
-
-#### Returns
-
-[`InvalidJoinConditionWrongTablesError`](../invalidjoinconditionwrongtableserror.md)
-
-#### Overrides
-
-[`JoinError`](../joinerror.md).[`constructor`](../JoinError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`cause`](../JoinError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`message`](../JoinError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`name`](../JoinError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stack`](../JoinError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`prepareStackTrace`](../JoinError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stackTraceLimit`](../JoinError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`captureStackTrace`](../JoinError.md#capturestacktrace)
diff --git a/docs/reference/classes/invalidschemaerror.md b/docs/reference/classes/invalidschemaerror.md
deleted file mode 100644
index 82bdbf12f..000000000
--- a/docs/reference/classes/invalidschemaerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: InvalidSchemaError
-title: InvalidSchemaError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: InvalidSchemaError
-
-Defined in: [packages/db/src/errors.ts:64](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L64)
-
-## Extends
-
-- [`CollectionConfigurationError`](../collectionconfigurationerror.md)
-
-## Constructors
-
-### new InvalidSchemaError()
-
-```ts
-new InvalidSchemaError(): InvalidSchemaError
-```
-
-Defined in: [packages/db/src/errors.ts:65](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L65)
-
-#### Returns
-
-[`InvalidSchemaError`](../invalidschemaerror.md)
-
-#### Overrides
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`constructor`](../CollectionConfigurationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`cause`](../CollectionConfigurationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`message`](../CollectionConfigurationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`name`](../CollectionConfigurationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`stack`](../CollectionConfigurationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`prepareStackTrace`](../CollectionConfigurationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`stackTraceLimit`](../CollectionConfigurationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`captureStackTrace`](../CollectionConfigurationError.md#capturestacktrace)
diff --git a/docs/reference/classes/invalidsourceerror.md b/docs/reference/classes/invalidsourceerror.md
deleted file mode 100644
index 60f7ae9ad..000000000
--- a/docs/reference/classes/invalidsourceerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: InvalidSourceError
-title: InvalidSourceError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: InvalidSourceError
-
-Defined in: [packages/db/src/errors.ts:304](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L304)
-
-## Extends
-
-- [`QueryBuilderError`](../querybuildererror.md)
-
-## Constructors
-
-### new InvalidSourceError()
-
-```ts
-new InvalidSourceError(): InvalidSourceError
-```
-
-Defined in: [packages/db/src/errors.ts:305](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L305)
-
-#### Returns
-
-[`InvalidSourceError`](../invalidsourceerror.md)
-
-#### Overrides
-
-[`QueryBuilderError`](../querybuildererror.md).[`constructor`](../QueryBuilderError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`cause`](../QueryBuilderError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`message`](../QueryBuilderError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`name`](../QueryBuilderError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stack`](../QueryBuilderError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`prepareStackTrace`](../QueryBuilderError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stackTraceLimit`](../QueryBuilderError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`captureStackTrace`](../QueryBuilderError.md#capturestacktrace)
diff --git a/docs/reference/classes/invalidstoragedataformaterror.md b/docs/reference/classes/invalidstoragedataformaterror.md
deleted file mode 100644
index aed3feb8f..000000000
--- a/docs/reference/classes/invalidstoragedataformaterror.md
+++ /dev/null
@@ -1,176 +0,0 @@
----
-id: InvalidStorageDataFormatError
-title: InvalidStorageDataFormatError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: InvalidStorageDataFormatError
-
-Defined in: [packages/db/src/errors.ts:511](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L511)
-
-## Extends
-
-- [`LocalStorageCollectionError`](../localstoragecollectionerror.md)
-
-## Constructors
-
-### new InvalidStorageDataFormatError()
-
-```ts
-new InvalidStorageDataFormatError(storageKey, key): InvalidStorageDataFormatError
-```
-
-Defined in: [packages/db/src/errors.ts:512](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L512)
-
-#### Parameters
-
-##### storageKey
-
-`string`
-
-##### key
-
-`string`
-
-#### Returns
-
-[`InvalidStorageDataFormatError`](../invalidstoragedataformaterror.md)
-
-#### Overrides
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`constructor`](../LocalStorageCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`cause`](../LocalStorageCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`message`](../LocalStorageCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`name`](../LocalStorageCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stack`](../LocalStorageCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`prepareStackTrace`](../LocalStorageCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stackTraceLimit`](../LocalStorageCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`captureStackTrace`](../LocalStorageCollectionError.md#capturestacktrace)
diff --git a/docs/reference/classes/invalidstorageobjectformaterror.md b/docs/reference/classes/invalidstorageobjectformaterror.md
deleted file mode 100644
index 6c79dbc8c..000000000
--- a/docs/reference/classes/invalidstorageobjectformaterror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: InvalidStorageObjectFormatError
-title: InvalidStorageObjectFormatError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: InvalidStorageObjectFormatError
-
-Defined in: [packages/db/src/errors.ts:519](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L519)
-
-## Extends
-
-- [`LocalStorageCollectionError`](../localstoragecollectionerror.md)
-
-## Constructors
-
-### new InvalidStorageObjectFormatError()
-
-```ts
-new InvalidStorageObjectFormatError(storageKey): InvalidStorageObjectFormatError
-```
-
-Defined in: [packages/db/src/errors.ts:520](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L520)
-
-#### Parameters
-
-##### storageKey
-
-`string`
-
-#### Returns
-
-[`InvalidStorageObjectFormatError`](../invalidstorageobjectformaterror.md)
-
-#### Overrides
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`constructor`](../LocalStorageCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`cause`](../LocalStorageCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`message`](../LocalStorageCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`name`](../LocalStorageCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stack`](../LocalStorageCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`prepareStackTrace`](../LocalStorageCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stackTraceLimit`](../LocalStorageCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`captureStackTrace`](../LocalStorageCollectionError.md#capturestacktrace)
diff --git a/docs/reference/classes/joinconditionmustbeequalityerror.md b/docs/reference/classes/joinconditionmustbeequalityerror.md
deleted file mode 100644
index 8bb40acbc..000000000
--- a/docs/reference/classes/joinconditionmustbeequalityerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: JoinConditionMustBeEqualityError
-title: JoinConditionMustBeEqualityError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: JoinConditionMustBeEqualityError
-
-Defined in: [packages/db/src/errors.ts:310](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L310)
-
-## Extends
-
-- [`QueryBuilderError`](../querybuildererror.md)
-
-## Constructors
-
-### new JoinConditionMustBeEqualityError()
-
-```ts
-new JoinConditionMustBeEqualityError(): JoinConditionMustBeEqualityError
-```
-
-Defined in: [packages/db/src/errors.ts:311](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L311)
-
-#### Returns
-
-[`JoinConditionMustBeEqualityError`](../joinconditionmustbeequalityerror.md)
-
-#### Overrides
-
-[`QueryBuilderError`](../querybuildererror.md).[`constructor`](../QueryBuilderError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`cause`](../QueryBuilderError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`message`](../QueryBuilderError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`name`](../QueryBuilderError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stack`](../QueryBuilderError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`prepareStackTrace`](../QueryBuilderError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stackTraceLimit`](../QueryBuilderError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`captureStackTrace`](../QueryBuilderError.md#capturestacktrace)
diff --git a/docs/reference/classes/joinerror.md b/docs/reference/classes/joinerror.md
deleted file mode 100644
index 9660fc83b..000000000
--- a/docs/reference/classes/joinerror.md
+++ /dev/null
@@ -1,180 +0,0 @@
----
-id: JoinError
-title: JoinError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: JoinError
-
-Defined in: [packages/db/src/errors.ts:381](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L381)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`UnsupportedJoinTypeError`](../unsupportedjointypeerror.md)
-- [`InvalidJoinConditionSameTableError`](../invalidjoinconditionsametableerror.md)
-- [`InvalidJoinConditionTableMismatchError`](../invalidjoinconditiontablemismatcherror.md)
-- [`InvalidJoinConditionWrongTablesError`](../invalidjoinconditionwrongtableserror.md)
-- [`UnsupportedJoinSourceTypeError`](../unsupportedjoinsourcetypeerror.md)
-
-## Constructors
-
-### new JoinError()
-
-```ts
-new JoinError(message): JoinError
-```
-
-Defined in: [packages/db/src/errors.ts:382](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L382)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`JoinError`](../joinerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/keyupdatenotallowederror.md b/docs/reference/classes/keyupdatenotallowederror.md
deleted file mode 100644
index ef5283418..000000000
--- a/docs/reference/classes/keyupdatenotallowederror.md
+++ /dev/null
@@ -1,176 +0,0 @@
----
-id: KeyUpdateNotAllowedError
-title: KeyUpdateNotAllowedError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: KeyUpdateNotAllowedError
-
-Defined in: [packages/db/src/errors.ts:164](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L164)
-
-## Extends
-
-- [`CollectionOperationError`](../collectionoperationerror.md)
-
-## Constructors
-
-### new KeyUpdateNotAllowedError()
-
-```ts
-new KeyUpdateNotAllowedError(originalKey, newKey): KeyUpdateNotAllowedError
-```
-
-Defined in: [packages/db/src/errors.ts:165](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L165)
-
-#### Parameters
-
-##### originalKey
-
-`string` | `number`
-
-##### newKey
-
-`string` | `number`
-
-#### Returns
-
-[`KeyUpdateNotAllowedError`](../keyupdatenotallowederror.md)
-
-#### Overrides
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`constructor`](../CollectionOperationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`cause`](../CollectionOperationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`message`](../CollectionOperationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`name`](../CollectionOperationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stack`](../CollectionOperationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`prepareStackTrace`](../CollectionOperationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stackTraceLimit`](../CollectionOperationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`captureStackTrace`](../CollectionOperationError.md#capturestacktrace)
diff --git a/docs/reference/classes/limitoffsetrequireorderbyerror.md b/docs/reference/classes/limitoffsetrequireorderbyerror.md
deleted file mode 100644
index dacad3675..000000000
--- a/docs/reference/classes/limitoffsetrequireorderbyerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: LimitOffsetRequireOrderByError
-title: LimitOffsetRequireOrderByError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: LimitOffsetRequireOrderByError
-
-Defined in: [packages/db/src/errors.ts:342](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L342)
-
-## Extends
-
-- [`QueryCompilationError`](../querycompilationerror.md)
-
-## Constructors
-
-### new LimitOffsetRequireOrderByError()
-
-```ts
-new LimitOffsetRequireOrderByError(): LimitOffsetRequireOrderByError
-```
-
-Defined in: [packages/db/src/errors.ts:343](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L343)
-
-#### Returns
-
-[`LimitOffsetRequireOrderByError`](../limitoffsetrequireorderbyerror.md)
-
-#### Overrides
-
-[`QueryCompilationError`](../querycompilationerror.md).[`constructor`](../QueryCompilationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`cause`](../QueryCompilationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`message`](../QueryCompilationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`name`](../QueryCompilationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stack`](../QueryCompilationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`prepareStackTrace`](../QueryCompilationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stackTraceLimit`](../QueryCompilationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`captureStackTrace`](../QueryCompilationError.md#capturestacktrace)
diff --git a/docs/reference/classes/localstoragecollectionerror.md b/docs/reference/classes/localstoragecollectionerror.md
deleted file mode 100644
index 8de7fe281..000000000
--- a/docs/reference/classes/localstoragecollectionerror.md
+++ /dev/null
@@ -1,180 +0,0 @@
----
-id: LocalStorageCollectionError
-title: LocalStorageCollectionError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: LocalStorageCollectionError
-
-Defined in: [packages/db/src/errors.ts:482](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L482)
-
-## Extends
-
-- [`StorageError`](../storageerror.md)
-
-## Extended by
-
-- [`StorageKeyRequiredError`](../storagekeyrequirederror.md)
-- [`NoStorageAvailableError`](../nostorageavailableerror.md)
-- [`NoStorageEventApiError`](../nostorageeventapierror.md)
-- [`InvalidStorageDataFormatError`](../invalidstoragedataformaterror.md)
-- [`InvalidStorageObjectFormatError`](../invalidstorageobjectformaterror.md)
-
-## Constructors
-
-### new LocalStorageCollectionError()
-
-```ts
-new LocalStorageCollectionError(message): LocalStorageCollectionError
-```
-
-Defined in: [packages/db/src/errors.ts:483](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L483)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md)
-
-#### Overrides
-
-[`StorageError`](../storageerror.md).[`constructor`](../StorageError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`cause`](../StorageError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`message`](../StorageError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`name`](../StorageError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`stack`](../StorageError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`prepareStackTrace`](../StorageError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`stackTraceLimit`](../StorageError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`captureStackTrace`](../StorageError.md#capturestacktrace)
diff --git a/docs/reference/classes/missingdeletehandlererror.md b/docs/reference/classes/missingdeletehandlererror.md
deleted file mode 100644
index 7ffee715c..000000000
--- a/docs/reference/classes/missingdeletehandlererror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: MissingDeleteHandlerError
-title: MissingDeleteHandlerError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: MissingDeleteHandlerError
-
-Defined in: [packages/db/src/errors.ts:210](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L210)
-
-## Extends
-
-- [`MissingHandlerError`](../missinghandlererror.md)
-
-## Constructors
-
-### new MissingDeleteHandlerError()
-
-```ts
-new MissingDeleteHandlerError(): MissingDeleteHandlerError
-```
-
-Defined in: [packages/db/src/errors.ts:211](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L211)
-
-#### Returns
-
-[`MissingDeleteHandlerError`](../missingdeletehandlererror.md)
-
-#### Overrides
-
-[`MissingHandlerError`](../missinghandlererror.md).[`constructor`](../MissingHandlerError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`cause`](../MissingHandlerError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`message`](../MissingHandlerError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`name`](../MissingHandlerError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`stack`](../MissingHandlerError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`prepareStackTrace`](../MissingHandlerError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`stackTraceLimit`](../MissingHandlerError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`captureStackTrace`](../MissingHandlerError.md#capturestacktrace)
diff --git a/docs/reference/classes/missinghandlererror.md b/docs/reference/classes/missinghandlererror.md
deleted file mode 100644
index eb1dbaf55..000000000
--- a/docs/reference/classes/missinghandlererror.md
+++ /dev/null
@@ -1,178 +0,0 @@
----
-id: MissingHandlerError
-title: MissingHandlerError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: MissingHandlerError
-
-Defined in: [packages/db/src/errors.ts:187](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L187)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`MissingInsertHandlerError`](../missinginserthandlererror.md)
-- [`MissingUpdateHandlerError`](../missingupdatehandlererror.md)
-- [`MissingDeleteHandlerError`](../missingdeletehandlererror.md)
-
-## Constructors
-
-### new MissingHandlerError()
-
-```ts
-new MissingHandlerError(message): MissingHandlerError
-```
-
-Defined in: [packages/db/src/errors.ts:188](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L188)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`MissingHandlerError`](../missinghandlererror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/missinginserthandlererror.md b/docs/reference/classes/missinginserthandlererror.md
deleted file mode 100644
index 53a131ef8..000000000
--- a/docs/reference/classes/missinginserthandlererror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: MissingInsertHandlerError
-title: MissingInsertHandlerError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: MissingInsertHandlerError
-
-Defined in: [packages/db/src/errors.ts:194](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L194)
-
-## Extends
-
-- [`MissingHandlerError`](../missinghandlererror.md)
-
-## Constructors
-
-### new MissingInsertHandlerError()
-
-```ts
-new MissingInsertHandlerError(): MissingInsertHandlerError
-```
-
-Defined in: [packages/db/src/errors.ts:195](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L195)
-
-#### Returns
-
-[`MissingInsertHandlerError`](../missinginserthandlererror.md)
-
-#### Overrides
-
-[`MissingHandlerError`](../missinghandlererror.md).[`constructor`](../MissingHandlerError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`cause`](../MissingHandlerError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`message`](../MissingHandlerError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`name`](../MissingHandlerError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`stack`](../MissingHandlerError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`prepareStackTrace`](../MissingHandlerError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`stackTraceLimit`](../MissingHandlerError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`captureStackTrace`](../MissingHandlerError.md#capturestacktrace)
diff --git a/docs/reference/classes/missingmutationfunctionerror.md b/docs/reference/classes/missingmutationfunctionerror.md
deleted file mode 100644
index 37783b844..000000000
--- a/docs/reference/classes/missingmutationfunctionerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: MissingMutationFunctionError
-title: MissingMutationFunctionError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: MissingMutationFunctionError
-
-Defined in: [packages/db/src/errors.ts:226](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L226)
-
-## Extends
-
-- [`TransactionError`](../transactionerror.md)
-
-## Constructors
-
-### new MissingMutationFunctionError()
-
-```ts
-new MissingMutationFunctionError(): MissingMutationFunctionError
-```
-
-Defined in: [packages/db/src/errors.ts:227](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L227)
-
-#### Returns
-
-[`MissingMutationFunctionError`](../missingmutationfunctionerror.md)
-
-#### Overrides
-
-[`TransactionError`](../transactionerror.md).[`constructor`](../TransactionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`cause`](../TransactionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`message`](../TransactionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`name`](../TransactionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stack`](../TransactionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`prepareStackTrace`](../TransactionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stackTraceLimit`](../TransactionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`captureStackTrace`](../TransactionError.md#capturestacktrace)
diff --git a/docs/reference/classes/missingupdateargumenterror.md b/docs/reference/classes/missingupdateargumenterror.md
deleted file mode 100644
index 76790d62f..000000000
--- a/docs/reference/classes/missingupdateargumenterror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: MissingUpdateArgumentError
-title: MissingUpdateArgumentError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: MissingUpdateArgumentError
-
-Defined in: [packages/db/src/errors.ts:144](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L144)
-
-## Extends
-
-- [`CollectionOperationError`](../collectionoperationerror.md)
-
-## Constructors
-
-### new MissingUpdateArgumentError()
-
-```ts
-new MissingUpdateArgumentError(): MissingUpdateArgumentError
-```
-
-Defined in: [packages/db/src/errors.ts:145](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L145)
-
-#### Returns
-
-[`MissingUpdateArgumentError`](../missingupdateargumenterror.md)
-
-#### Overrides
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`constructor`](../CollectionOperationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`cause`](../CollectionOperationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`message`](../CollectionOperationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`name`](../CollectionOperationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stack`](../CollectionOperationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`prepareStackTrace`](../CollectionOperationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stackTraceLimit`](../CollectionOperationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`captureStackTrace`](../CollectionOperationError.md#capturestacktrace)
diff --git a/docs/reference/classes/missingupdatehandlererror.md b/docs/reference/classes/missingupdatehandlererror.md
deleted file mode 100644
index 6d3847cad..000000000
--- a/docs/reference/classes/missingupdatehandlererror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: MissingUpdateHandlerError
-title: MissingUpdateHandlerError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: MissingUpdateHandlerError
-
-Defined in: [packages/db/src/errors.ts:202](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L202)
-
-## Extends
-
-- [`MissingHandlerError`](../missinghandlererror.md)
-
-## Constructors
-
-### new MissingUpdateHandlerError()
-
-```ts
-new MissingUpdateHandlerError(): MissingUpdateHandlerError
-```
-
-Defined in: [packages/db/src/errors.ts:203](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L203)
-
-#### Returns
-
-[`MissingUpdateHandlerError`](../missingupdatehandlererror.md)
-
-#### Overrides
-
-[`MissingHandlerError`](../missinghandlererror.md).[`constructor`](../MissingHandlerError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`cause`](../MissingHandlerError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`message`](../MissingHandlerError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`name`](../MissingHandlerError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`stack`](../MissingHandlerError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`prepareStackTrace`](../MissingHandlerError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`stackTraceLimit`](../MissingHandlerError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`MissingHandlerError`](../missinghandlererror.md).[`captureStackTrace`](../MissingHandlerError.md#capturestacktrace)
diff --git a/docs/reference/classes/negativeactivesubscriberserror.md b/docs/reference/classes/negativeactivesubscriberserror.md
deleted file mode 100644
index 1043209e1..000000000
--- a/docs/reference/classes/negativeactivesubscriberserror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: NegativeActiveSubscribersError
-title: NegativeActiveSubscribersError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: NegativeActiveSubscribersError
-
-Defined in: [packages/db/src/errors.ts:106](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L106)
-
-## Extends
-
-- [`CollectionStateError`](../collectionstateerror.md)
-
-## Constructors
-
-### new NegativeActiveSubscribersError()
-
-```ts
-new NegativeActiveSubscribersError(): NegativeActiveSubscribersError
-```
-
-Defined in: [packages/db/src/errors.ts:107](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L107)
-
-#### Returns
-
-[`NegativeActiveSubscribersError`](../negativeactivesubscriberserror.md)
-
-#### Overrides
-
-[`CollectionStateError`](../collectionstateerror.md).[`constructor`](../CollectionStateError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`cause`](../CollectionStateError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`message`](../CollectionStateError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`name`](../CollectionStateError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`stack`](../CollectionStateError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`prepareStackTrace`](../CollectionStateError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`stackTraceLimit`](../CollectionStateError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionStateError`](../collectionstateerror.md).[`captureStackTrace`](../CollectionStateError.md#capturestacktrace)
diff --git a/docs/reference/classes/nokeyspassedtodeleteerror.md b/docs/reference/classes/nokeyspassedtodeleteerror.md
deleted file mode 100644
index 7ed703a7e..000000000
--- a/docs/reference/classes/nokeyspassedtodeleteerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: NoKeysPassedToDeleteError
-title: NoKeysPassedToDeleteError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: NoKeysPassedToDeleteError
-
-Defined in: [packages/db/src/errors.ts:172](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L172)
-
-## Extends
-
-- [`CollectionOperationError`](../collectionoperationerror.md)
-
-## Constructors
-
-### new NoKeysPassedToDeleteError()
-
-```ts
-new NoKeysPassedToDeleteError(): NoKeysPassedToDeleteError
-```
-
-Defined in: [packages/db/src/errors.ts:173](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L173)
-
-#### Returns
-
-[`NoKeysPassedToDeleteError`](../nokeyspassedtodeleteerror.md)
-
-#### Overrides
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`constructor`](../CollectionOperationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`cause`](../CollectionOperationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`message`](../CollectionOperationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`name`](../CollectionOperationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stack`](../CollectionOperationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`prepareStackTrace`](../CollectionOperationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stackTraceLimit`](../CollectionOperationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`captureStackTrace`](../CollectionOperationError.md#capturestacktrace)
diff --git a/docs/reference/classes/nokeyspassedtoupdateerror.md b/docs/reference/classes/nokeyspassedtoupdateerror.md
deleted file mode 100644
index df12c4847..000000000
--- a/docs/reference/classes/nokeyspassedtoupdateerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: NoKeysPassedToUpdateError
-title: NoKeysPassedToUpdateError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: NoKeysPassedToUpdateError
-
-Defined in: [packages/db/src/errors.ts:150](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L150)
-
-## Extends
-
-- [`CollectionOperationError`](../collectionoperationerror.md)
-
-## Constructors
-
-### new NoKeysPassedToUpdateError()
-
-```ts
-new NoKeysPassedToUpdateError(): NoKeysPassedToUpdateError
-```
-
-Defined in: [packages/db/src/errors.ts:151](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L151)
-
-#### Returns
-
-[`NoKeysPassedToUpdateError`](../nokeyspassedtoupdateerror.md)
-
-#### Overrides
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`constructor`](../CollectionOperationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`cause`](../CollectionOperationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`message`](../CollectionOperationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`name`](../CollectionOperationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stack`](../CollectionOperationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`prepareStackTrace`](../CollectionOperationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stackTraceLimit`](../CollectionOperationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`captureStackTrace`](../CollectionOperationError.md#capturestacktrace)
diff --git a/docs/reference/classes/nonaggregateexpressionnotingroupbyerror.md b/docs/reference/classes/nonaggregateexpressionnotingroupbyerror.md
deleted file mode 100644
index 9b5d8617b..000000000
--- a/docs/reference/classes/nonaggregateexpressionnotingroupbyerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: NonAggregateExpressionNotInGroupByError
-title: NonAggregateExpressionNotInGroupByError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: NonAggregateExpressionNotInGroupByError
-
-Defined in: [packages/db/src/errors.ts:437](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L437)
-
-## Extends
-
-- [`GroupByError`](../groupbyerror.md)
-
-## Constructors
-
-### new NonAggregateExpressionNotInGroupByError()
-
-```ts
-new NonAggregateExpressionNotInGroupByError(alias): NonAggregateExpressionNotInGroupByError
-```
-
-Defined in: [packages/db/src/errors.ts:438](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L438)
-
-#### Parameters
-
-##### alias
-
-`string`
-
-#### Returns
-
-[`NonAggregateExpressionNotInGroupByError`](../nonaggregateexpressionnotingroupbyerror.md)
-
-#### Overrides
-
-[`GroupByError`](../groupbyerror.md).[`constructor`](../GroupByError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`cause`](../GroupByError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`message`](../GroupByError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`name`](../GroupByError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`stack`](../GroupByError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`prepareStackTrace`](../GroupByError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`stackTraceLimit`](../GroupByError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`captureStackTrace`](../GroupByError.md#capturestacktrace)
diff --git a/docs/reference/classes/nonretriableerror.md b/docs/reference/classes/nonretriableerror.md
deleted file mode 100644
index 6983719ad..000000000
--- a/docs/reference/classes/nonretriableerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: NonRetriableError
-title: NonRetriableError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: NonRetriableError
-
-Defined in: [packages/db/src/errors.ts:10](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L10)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Constructors
-
-### new NonRetriableError()
-
-```ts
-new NonRetriableError(message): NonRetriableError
-```
-
-Defined in: [packages/db/src/errors.ts:11](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L11)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`NonRetriableError`](../nonretriableerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/nopendingsynctransactioncommiterror.md b/docs/reference/classes/nopendingsynctransactioncommiterror.md
deleted file mode 100644
index f4fe113c4..000000000
--- a/docs/reference/classes/nopendingsynctransactioncommiterror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: NoPendingSyncTransactionCommitError
-title: NoPendingSyncTransactionCommitError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: NoPendingSyncTransactionCommitError
-
-Defined in: [packages/db/src/errors.ts:270](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L270)
-
-## Extends
-
-- [`TransactionError`](../transactionerror.md)
-
-## Constructors
-
-### new NoPendingSyncTransactionCommitError()
-
-```ts
-new NoPendingSyncTransactionCommitError(): NoPendingSyncTransactionCommitError
-```
-
-Defined in: [packages/db/src/errors.ts:271](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L271)
-
-#### Returns
-
-[`NoPendingSyncTransactionCommitError`](../nopendingsynctransactioncommiterror.md)
-
-#### Overrides
-
-[`TransactionError`](../transactionerror.md).[`constructor`](../TransactionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`cause`](../TransactionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`message`](../TransactionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`name`](../TransactionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stack`](../TransactionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`prepareStackTrace`](../TransactionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stackTraceLimit`](../TransactionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`captureStackTrace`](../TransactionError.md#capturestacktrace)
diff --git a/docs/reference/classes/nopendingsynctransactionwriteerror.md b/docs/reference/classes/nopendingsynctransactionwriteerror.md
deleted file mode 100644
index 213a493b4..000000000
--- a/docs/reference/classes/nopendingsynctransactionwriteerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: NoPendingSyncTransactionWriteError
-title: NoPendingSyncTransactionWriteError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: NoPendingSyncTransactionWriteError
-
-Defined in: [packages/db/src/errors.ts:256](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L256)
-
-## Extends
-
-- [`TransactionError`](../transactionerror.md)
-
-## Constructors
-
-### new NoPendingSyncTransactionWriteError()
-
-```ts
-new NoPendingSyncTransactionWriteError(): NoPendingSyncTransactionWriteError
-```
-
-Defined in: [packages/db/src/errors.ts:257](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L257)
-
-#### Returns
-
-[`NoPendingSyncTransactionWriteError`](../nopendingsynctransactionwriteerror.md)
-
-#### Overrides
-
-[`TransactionError`](../transactionerror.md).[`constructor`](../TransactionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`cause`](../TransactionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`message`](../TransactionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`name`](../TransactionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stack`](../TransactionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`prepareStackTrace`](../TransactionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stackTraceLimit`](../TransactionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`captureStackTrace`](../TransactionError.md#capturestacktrace)
diff --git a/docs/reference/classes/nostorageavailableerror.md b/docs/reference/classes/nostorageavailableerror.md
deleted file mode 100644
index 34b084f75..000000000
--- a/docs/reference/classes/nostorageavailableerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: NoStorageAvailableError
-title: NoStorageAvailableError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: NoStorageAvailableError
-
-Defined in: [packages/db/src/errors.ts:495](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L495)
-
-## Extends
-
-- [`LocalStorageCollectionError`](../localstoragecollectionerror.md)
-
-## Constructors
-
-### new NoStorageAvailableError()
-
-```ts
-new NoStorageAvailableError(): NoStorageAvailableError
-```
-
-Defined in: [packages/db/src/errors.ts:496](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L496)
-
-#### Returns
-
-[`NoStorageAvailableError`](../nostorageavailableerror.md)
-
-#### Overrides
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`constructor`](../LocalStorageCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`cause`](../LocalStorageCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`message`](../LocalStorageCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`name`](../LocalStorageCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stack`](../LocalStorageCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`prepareStackTrace`](../LocalStorageCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stackTraceLimit`](../LocalStorageCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`captureStackTrace`](../LocalStorageCollectionError.md#capturestacktrace)
diff --git a/docs/reference/classes/nostorageeventapierror.md b/docs/reference/classes/nostorageeventapierror.md
deleted file mode 100644
index 100aed26b..000000000
--- a/docs/reference/classes/nostorageeventapierror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: NoStorageEventApiError
-title: NoStorageEventApiError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: NoStorageEventApiError
-
-Defined in: [packages/db/src/errors.ts:503](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L503)
-
-## Extends
-
-- [`LocalStorageCollectionError`](../localstoragecollectionerror.md)
-
-## Constructors
-
-### new NoStorageEventApiError()
-
-```ts
-new NoStorageEventApiError(): NoStorageEventApiError
-```
-
-Defined in: [packages/db/src/errors.ts:504](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L504)
-
-#### Returns
-
-[`NoStorageEventApiError`](../nostorageeventapierror.md)
-
-#### Overrides
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`constructor`](../LocalStorageCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`cause`](../LocalStorageCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`message`](../LocalStorageCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`name`](../LocalStorageCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stack`](../LocalStorageCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`prepareStackTrace`](../LocalStorageCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stackTraceLimit`](../LocalStorageCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`captureStackTrace`](../LocalStorageCollectionError.md#capturestacktrace)
diff --git a/docs/reference/classes/onlyonesourceallowederror.md b/docs/reference/classes/onlyonesourceallowederror.md
deleted file mode 100644
index 9e3e18c2a..000000000
--- a/docs/reference/classes/onlyonesourceallowederror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: OnlyOneSourceAllowedError
-title: OnlyOneSourceAllowedError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: OnlyOneSourceAllowedError
-
-Defined in: [packages/db/src/errors.ts:292](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L292)
-
-## Extends
-
-- [`QueryBuilderError`](../querybuildererror.md)
-
-## Constructors
-
-### new OnlyOneSourceAllowedError()
-
-```ts
-new OnlyOneSourceAllowedError(context): OnlyOneSourceAllowedError
-```
-
-Defined in: [packages/db/src/errors.ts:293](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L293)
-
-#### Parameters
-
-##### context
-
-`string`
-
-#### Returns
-
-[`OnlyOneSourceAllowedError`](../onlyonesourceallowederror.md)
-
-#### Overrides
-
-[`QueryBuilderError`](../querybuildererror.md).[`constructor`](../QueryBuilderError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`cause`](../QueryBuilderError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`message`](../QueryBuilderError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`name`](../QueryBuilderError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stack`](../QueryBuilderError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`prepareStackTrace`](../QueryBuilderError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stackTraceLimit`](../QueryBuilderError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`captureStackTrace`](../QueryBuilderError.md#capturestacktrace)
diff --git a/docs/reference/classes/querybuildererror.md b/docs/reference/classes/querybuildererror.md
deleted file mode 100644
index 0377c2939..000000000
--- a/docs/reference/classes/querybuildererror.md
+++ /dev/null
@@ -1,180 +0,0 @@
----
-id: QueryBuilderError
-title: QueryBuilderError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: QueryBuilderError
-
-Defined in: [packages/db/src/errors.ts:285](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L285)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`OnlyOneSourceAllowedError`](../onlyonesourceallowederror.md)
-- [`SubQueryMustHaveFromClauseError`](../subquerymusthavefromclauseerror.md)
-- [`InvalidSourceError`](../invalidsourceerror.md)
-- [`JoinConditionMustBeEqualityError`](../joinconditionmustbeequalityerror.md)
-- [`QueryMustHaveFromClauseError`](../querymusthavefromclauseerror.md)
-
-## Constructors
-
-### new QueryBuilderError()
-
-```ts
-new QueryBuilderError(message): QueryBuilderError
-```
-
-Defined in: [packages/db/src/errors.ts:286](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L286)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`QueryBuilderError`](../querybuildererror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/querycompilationerror.md b/docs/reference/classes/querycompilationerror.md
deleted file mode 100644
index 46a81c87b..000000000
--- a/docs/reference/classes/querycompilationerror.md
+++ /dev/null
@@ -1,183 +0,0 @@
----
-id: QueryCompilationError
-title: QueryCompilationError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: QueryCompilationError
-
-Defined in: [packages/db/src/errors.ts:323](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L323)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`DistinctRequiresSelectError`](../distinctrequiresselecterror.md)
-- [`HavingRequiresGroupByError`](../havingrequiresgroupbyerror.md)
-- [`LimitOffsetRequireOrderByError`](../limitoffsetrequireorderbyerror.md)
-- [`CollectionInputNotFoundError`](../collectioninputnotfounderror.md)
-- [`UnsupportedFromTypeError`](../unsupportedfromtypeerror.md)
-- [`UnknownExpressionTypeError`](../unknownexpressiontypeerror.md)
-- [`EmptyReferencePathError`](../emptyreferencepatherror.md)
-- [`UnknownFunctionError`](../unknownfunctionerror.md)
-
-## Constructors
-
-### new QueryCompilationError()
-
-```ts
-new QueryCompilationError(message): QueryCompilationError
-```
-
-Defined in: [packages/db/src/errors.ts:324](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L324)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`QueryCompilationError`](../querycompilationerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/querymusthavefromclauseerror.md b/docs/reference/classes/querymusthavefromclauseerror.md
deleted file mode 100644
index 67b5740c8..000000000
--- a/docs/reference/classes/querymusthavefromclauseerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: QueryMustHaveFromClauseError
-title: QueryMustHaveFromClauseError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: QueryMustHaveFromClauseError
-
-Defined in: [packages/db/src/errors.ts:316](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L316)
-
-## Extends
-
-- [`QueryBuilderError`](../querybuildererror.md)
-
-## Constructors
-
-### new QueryMustHaveFromClauseError()
-
-```ts
-new QueryMustHaveFromClauseError(): QueryMustHaveFromClauseError
-```
-
-Defined in: [packages/db/src/errors.ts:317](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L317)
-
-#### Returns
-
-[`QueryMustHaveFromClauseError`](../querymusthavefromclauseerror.md)
-
-#### Overrides
-
-[`QueryBuilderError`](../querybuildererror.md).[`constructor`](../QueryBuilderError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`cause`](../QueryBuilderError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`message`](../QueryBuilderError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`name`](../QueryBuilderError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stack`](../QueryBuilderError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`prepareStackTrace`](../QueryBuilderError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stackTraceLimit`](../QueryBuilderError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`captureStackTrace`](../QueryBuilderError.md#capturestacktrace)
diff --git a/docs/reference/classes/queryoptimizererror.md b/docs/reference/classes/queryoptimizererror.md
deleted file mode 100644
index e5a2f8581..000000000
--- a/docs/reference/classes/queryoptimizererror.md
+++ /dev/null
@@ -1,176 +0,0 @@
----
-id: QueryOptimizerError
-title: QueryOptimizerError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: QueryOptimizerError
-
-Defined in: [packages/db/src/errors.ts:539](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L539)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`CannotCombineEmptyExpressionListError`](../cannotcombineemptyexpressionlisterror.md)
-
-## Constructors
-
-### new QueryOptimizerError()
-
-```ts
-new QueryOptimizerError(message): QueryOptimizerError
-```
-
-Defined in: [packages/db/src/errors.ts:540](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L540)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`QueryOptimizerError`](../queryoptimizererror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/schemamustbesynchronouserror.md b/docs/reference/classes/schemamustbesynchronouserror.md
deleted file mode 100644
index 530d3f7ba..000000000
--- a/docs/reference/classes/schemamustbesynchronouserror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: SchemaMustBeSynchronousError
-title: SchemaMustBeSynchronousError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: SchemaMustBeSynchronousError
-
-Defined in: [packages/db/src/errors.ts:70](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L70)
-
-## Extends
-
-- [`CollectionConfigurationError`](../collectionconfigurationerror.md)
-
-## Constructors
-
-### new SchemaMustBeSynchronousError()
-
-```ts
-new SchemaMustBeSynchronousError(): SchemaMustBeSynchronousError
-```
-
-Defined in: [packages/db/src/errors.ts:71](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L71)
-
-#### Returns
-
-[`SchemaMustBeSynchronousError`](../schemamustbesynchronouserror.md)
-
-#### Overrides
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`constructor`](../CollectionConfigurationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`cause`](../CollectionConfigurationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`message`](../CollectionConfigurationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`name`](../CollectionConfigurationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`stack`](../CollectionConfigurationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`prepareStackTrace`](../CollectionConfigurationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`stackTraceLimit`](../CollectionConfigurationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionConfigurationError`](../collectionconfigurationerror.md).[`captureStackTrace`](../CollectionConfigurationError.md#capturestacktrace)
diff --git a/docs/reference/classes/schemavalidationerror.md b/docs/reference/classes/schemavalidationerror.md
deleted file mode 100644
index 95f7f239f..000000000
--- a/docs/reference/classes/schemavalidationerror.md
+++ /dev/null
@@ -1,203 +0,0 @@
----
-id: SchemaValidationError
-title: SchemaValidationError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: SchemaValidationError
-
-Defined in: [packages/db/src/errors.ts:18](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L18)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Constructors
-
-### new SchemaValidationError()
-
-```ts
-new SchemaValidationError(
-   type, 
-   issues, 
-   message?): SchemaValidationError
-```
-
-Defined in: [packages/db/src/errors.ts:25](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L25)
-
-#### Parameters
-
-##### type
-
-`"insert"` | `"update"`
-
-##### issues
-
-readonly `object`[]
-
-##### message?
-
-`string`
-
-#### Returns
-
-[`SchemaValidationError`](../schemavalidationerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### issues
-
-```ts
-issues: readonly object[];
-```
-
-Defined in: [packages/db/src/errors.ts:20](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L20)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### type
-
-```ts
-type: "insert" | "update";
-```
-
-Defined in: [packages/db/src/errors.ts:19](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L19)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/serializationerror.md b/docs/reference/classes/serializationerror.md
deleted file mode 100644
index 1a97b097f..000000000
--- a/docs/reference/classes/serializationerror.md
+++ /dev/null
@@ -1,176 +0,0 @@
----
-id: SerializationError
-title: SerializationError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: SerializationError
-
-Defined in: [packages/db/src/errors.ts:473](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L473)
-
-## Extends
-
-- [`StorageError`](../storageerror.md)
-
-## Constructors
-
-### new SerializationError()
-
-```ts
-new SerializationError(operation, originalError): SerializationError
-```
-
-Defined in: [packages/db/src/errors.ts:474](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L474)
-
-#### Parameters
-
-##### operation
-
-`string`
-
-##### originalError
-
-`string`
-
-#### Returns
-
-[`SerializationError`](../serializationerror.md)
-
-#### Overrides
-
-[`StorageError`](../storageerror.md).[`constructor`](../StorageError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`cause`](../StorageError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`message`](../StorageError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`name`](../StorageError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`stack`](../StorageError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`prepareStackTrace`](../StorageError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`stackTraceLimit`](../StorageError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`StorageError`](../storageerror.md).[`captureStackTrace`](../StorageError.md#capturestacktrace)
diff --git a/docs/reference/classes/storageerror.md b/docs/reference/classes/storageerror.md
deleted file mode 100644
index a71d9421d..000000000
--- a/docs/reference/classes/storageerror.md
+++ /dev/null
@@ -1,177 +0,0 @@
----
-id: StorageError
-title: StorageError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: StorageError
-
-Defined in: [packages/db/src/errors.ts:466](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L466)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`SerializationError`](../serializationerror.md)
-- [`LocalStorageCollectionError`](../localstoragecollectionerror.md)
-
-## Constructors
-
-### new StorageError()
-
-```ts
-new StorageError(message): StorageError
-```
-
-Defined in: [packages/db/src/errors.ts:467](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L467)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`StorageError`](../storageerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/storagekeyrequirederror.md b/docs/reference/classes/storagekeyrequirederror.md
deleted file mode 100644
index 03a0d75e0..000000000
--- a/docs/reference/classes/storagekeyrequirederror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: StorageKeyRequiredError
-title: StorageKeyRequiredError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: StorageKeyRequiredError
-
-Defined in: [packages/db/src/errors.ts:489](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L489)
-
-## Extends
-
-- [`LocalStorageCollectionError`](../localstoragecollectionerror.md)
-
-## Constructors
-
-### new StorageKeyRequiredError()
-
-```ts
-new StorageKeyRequiredError(): StorageKeyRequiredError
-```
-
-Defined in: [packages/db/src/errors.ts:490](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L490)
-
-#### Returns
-
-[`StorageKeyRequiredError`](../storagekeyrequirederror.md)
-
-#### Overrides
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`constructor`](../LocalStorageCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`cause`](../LocalStorageCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`message`](../LocalStorageCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`name`](../LocalStorageCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stack`](../LocalStorageCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`prepareStackTrace`](../LocalStorageCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`stackTraceLimit`](../LocalStorageCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`LocalStorageCollectionError`](../localstoragecollectionerror.md).[`captureStackTrace`](../LocalStorageCollectionError.md#capturestacktrace)
diff --git a/docs/reference/classes/subquerymusthavefromclauseerror.md b/docs/reference/classes/subquerymusthavefromclauseerror.md
deleted file mode 100644
index 3a57b0e1a..000000000
--- a/docs/reference/classes/subquerymusthavefromclauseerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: SubQueryMustHaveFromClauseError
-title: SubQueryMustHaveFromClauseError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: SubQueryMustHaveFromClauseError
-
-Defined in: [packages/db/src/errors.ts:298](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L298)
-
-## Extends
-
-- [`QueryBuilderError`](../querybuildererror.md)
-
-## Constructors
-
-### new SubQueryMustHaveFromClauseError()
-
-```ts
-new SubQueryMustHaveFromClauseError(context): SubQueryMustHaveFromClauseError
-```
-
-Defined in: [packages/db/src/errors.ts:299](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L299)
-
-#### Parameters
-
-##### context
-
-`string`
-
-#### Returns
-
-[`SubQueryMustHaveFromClauseError`](../subquerymusthavefromclauseerror.md)
-
-#### Overrides
-
-[`QueryBuilderError`](../querybuildererror.md).[`constructor`](../QueryBuilderError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`cause`](../QueryBuilderError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`message`](../QueryBuilderError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`name`](../QueryBuilderError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stack`](../QueryBuilderError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`prepareStackTrace`](../QueryBuilderError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`stackTraceLimit`](../QueryBuilderError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryBuilderError`](../querybuildererror.md).[`captureStackTrace`](../QueryBuilderError.md#capturestacktrace)
diff --git a/docs/reference/classes/synccleanuperror.md b/docs/reference/classes/synccleanuperror.md
deleted file mode 100644
index 8b891c864..000000000
--- a/docs/reference/classes/synccleanuperror.md
+++ /dev/null
@@ -1,176 +0,0 @@
----
-id: SyncCleanupError
-title: SyncCleanupError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: SyncCleanupError
-
-Defined in: [packages/db/src/errors.ts:528](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L528)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Constructors
-
-### new SyncCleanupError()
-
-```ts
-new SyncCleanupError(collectionId, error): SyncCleanupError
-```
-
-Defined in: [packages/db/src/errors.ts:529](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L529)
-
-#### Parameters
-
-##### collectionId
-
-`string`
-
-##### error
-
-`string` | `Error`
-
-#### Returns
-
-[`SyncCleanupError`](../synccleanuperror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/synctransactionalreadycommittederror.md b/docs/reference/classes/synctransactionalreadycommittederror.md
deleted file mode 100644
index 968a19942..000000000
--- a/docs/reference/classes/synctransactionalreadycommittederror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: SyncTransactionAlreadyCommittedError
-title: SyncTransactionAlreadyCommittedError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: SyncTransactionAlreadyCommittedError
-
-Defined in: [packages/db/src/errors.ts:276](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L276)
-
-## Extends
-
-- [`TransactionError`](../transactionerror.md)
-
-## Constructors
-
-### new SyncTransactionAlreadyCommittedError()
-
-```ts
-new SyncTransactionAlreadyCommittedError(): SyncTransactionAlreadyCommittedError
-```
-
-Defined in: [packages/db/src/errors.ts:277](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L277)
-
-#### Returns
-
-[`SyncTransactionAlreadyCommittedError`](../synctransactionalreadycommittederror.md)
-
-#### Overrides
-
-[`TransactionError`](../transactionerror.md).[`constructor`](../TransactionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`cause`](../TransactionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`message`](../TransactionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`name`](../TransactionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stack`](../TransactionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`prepareStackTrace`](../TransactionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stackTraceLimit`](../TransactionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`captureStackTrace`](../TransactionError.md#capturestacktrace)
diff --git a/docs/reference/classes/synctransactionalreadycommittedwriteerror.md b/docs/reference/classes/synctransactionalreadycommittedwriteerror.md
deleted file mode 100644
index 5886a5b00..000000000
--- a/docs/reference/classes/synctransactionalreadycommittedwriteerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: SyncTransactionAlreadyCommittedWriteError
-title: SyncTransactionAlreadyCommittedWriteError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: SyncTransactionAlreadyCommittedWriteError
-
-Defined in: [packages/db/src/errors.ts:262](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L262)
-
-## Extends
-
-- [`TransactionError`](../transactionerror.md)
-
-## Constructors
-
-### new SyncTransactionAlreadyCommittedWriteError()
-
-```ts
-new SyncTransactionAlreadyCommittedWriteError(): SyncTransactionAlreadyCommittedWriteError
-```
-
-Defined in: [packages/db/src/errors.ts:263](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L263)
-
-#### Returns
-
-[`SyncTransactionAlreadyCommittedWriteError`](../synctransactionalreadycommittedwriteerror.md)
-
-#### Overrides
-
-[`TransactionError`](../transactionerror.md).[`constructor`](../TransactionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`cause`](../TransactionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`message`](../TransactionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`name`](../TransactionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stack`](../TransactionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`prepareStackTrace`](../TransactionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stackTraceLimit`](../TransactionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`captureStackTrace`](../TransactionError.md#capturestacktrace)
diff --git a/docs/reference/classes/tanstackdberror.md b/docs/reference/classes/tanstackdberror.md
deleted file mode 100644
index da6912907..000000000
--- a/docs/reference/classes/tanstackdberror.md
+++ /dev/null
@@ -1,205 +0,0 @@
----
-id: TanStackDBError
-title: TanStackDBError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: TanStackDBError
-
-Defined in: [packages/db/src/errors.ts:2](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L2)
-
-## Extends
-
-- `Error`
-
-## Extended by
-
-- [`NonRetriableError`](../nonretriableerror.md)
-- [`SchemaValidationError`](../schemavalidationerror.md)
-- [`CollectionConfigurationError`](../collectionconfigurationerror.md)
-- [`CollectionStateError`](../collectionstateerror.md)
-- [`CollectionOperationError`](../collectionoperationerror.md)
-- [`MissingHandlerError`](../missinghandlererror.md)
-- [`TransactionError`](../transactionerror.md)
-- [`QueryBuilderError`](../querybuildererror.md)
-- [`QueryCompilationError`](../querycompilationerror.md)
-- [`JoinError`](../joinerror.md)
-- [`GroupByError`](../groupbyerror.md)
-- [`StorageError`](../storageerror.md)
-- [`SyncCleanupError`](../synccleanuperror.md)
-- [`QueryOptimizerError`](../queryoptimizererror.md)
-
-## Constructors
-
-### new TanStackDBError()
-
-```ts
-new TanStackDBError(message): TanStackDBError
-```
-
-Defined in: [packages/db/src/errors.ts:3](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L3)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`TanStackDBError`](../tanstackdberror.md)
-
-#### Overrides
-
-```ts
-Error.constructor
-```
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-```ts
-Error.cause
-```
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-```ts
-Error.message
-```
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-```ts
-Error.name
-```
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-```ts
-Error.stack
-```
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-```ts
-Error.prepareStackTrace
-```
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-```ts
-Error.stackTraceLimit
-```
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-```ts
-Error.captureStackTrace
-```
diff --git a/docs/reference/classes/transactionalreadycompletedrollbackerror.md b/docs/reference/classes/transactionalreadycompletedrollbackerror.md
deleted file mode 100644
index 46e4b9b12..000000000
--- a/docs/reference/classes/transactionalreadycompletedrollbackerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: TransactionAlreadyCompletedRollbackError
-title: TransactionAlreadyCompletedRollbackError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: TransactionAlreadyCompletedRollbackError
-
-Defined in: [packages/db/src/errors.ts:240](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L240)
-
-## Extends
-
-- [`TransactionError`](../transactionerror.md)
-
-## Constructors
-
-### new TransactionAlreadyCompletedRollbackError()
-
-```ts
-new TransactionAlreadyCompletedRollbackError(): TransactionAlreadyCompletedRollbackError
-```
-
-Defined in: [packages/db/src/errors.ts:241](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L241)
-
-#### Returns
-
-[`TransactionAlreadyCompletedRollbackError`](../transactionalreadycompletedrollbackerror.md)
-
-#### Overrides
-
-[`TransactionError`](../transactionerror.md).[`constructor`](../TransactionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`cause`](../TransactionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`message`](../TransactionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`name`](../TransactionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stack`](../TransactionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`prepareStackTrace`](../TransactionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stackTraceLimit`](../TransactionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`captureStackTrace`](../TransactionError.md#capturestacktrace)
diff --git a/docs/reference/classes/transactionerror.md b/docs/reference/classes/transactionerror.md
deleted file mode 100644
index 033992131..000000000
--- a/docs/reference/classes/transactionerror.md
+++ /dev/null
@@ -1,183 +0,0 @@
----
-id: TransactionError
-title: TransactionError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: TransactionError
-
-Defined in: [packages/db/src/errors.ts:219](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L219)
-
-## Extends
-
-- [`TanStackDBError`](../tanstackdberror.md)
-
-## Extended by
-
-- [`MissingMutationFunctionError`](../missingmutationfunctionerror.md)
-- [`TransactionNotPendingMutateError`](../transactionnotpendingmutateerror.md)
-- [`TransactionAlreadyCompletedRollbackError`](../transactionalreadycompletedrollbackerror.md)
-- [`TransactionNotPendingCommitError`](../transactionnotpendingcommiterror.md)
-- [`NoPendingSyncTransactionWriteError`](../nopendingsynctransactionwriteerror.md)
-- [`SyncTransactionAlreadyCommittedWriteError`](../synctransactionalreadycommittedwriteerror.md)
-- [`NoPendingSyncTransactionCommitError`](../nopendingsynctransactioncommiterror.md)
-- [`SyncTransactionAlreadyCommittedError`](../synctransactionalreadycommittederror.md)
-
-## Constructors
-
-### new TransactionError()
-
-```ts
-new TransactionError(message): TransactionError
-```
-
-Defined in: [packages/db/src/errors.ts:220](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L220)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`TransactionError`](../transactionerror.md)
-
-#### Overrides
-
-[`TanStackDBError`](../tanstackdberror.md).[`constructor`](../TanStackDBError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`cause`](../TanStackDBError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`message`](../TanStackDBError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`name`](../TanStackDBError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stack`](../TanStackDBError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`prepareStackTrace`](../TanStackDBError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`stackTraceLimit`](../TanStackDBError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TanStackDBError`](../tanstackdberror.md).[`captureStackTrace`](../TanStackDBError.md#capturestacktrace)
diff --git a/docs/reference/classes/transactionnotpendingcommiterror.md b/docs/reference/classes/transactionnotpendingcommiterror.md
deleted file mode 100644
index 69c51ca58..000000000
--- a/docs/reference/classes/transactionnotpendingcommiterror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: TransactionNotPendingCommitError
-title: TransactionNotPendingCommitError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: TransactionNotPendingCommitError
-
-Defined in: [packages/db/src/errors.ts:248](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L248)
-
-## Extends
-
-- [`TransactionError`](../transactionerror.md)
-
-## Constructors
-
-### new TransactionNotPendingCommitError()
-
-```ts
-new TransactionNotPendingCommitError(): TransactionNotPendingCommitError
-```
-
-Defined in: [packages/db/src/errors.ts:249](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L249)
-
-#### Returns
-
-[`TransactionNotPendingCommitError`](../transactionnotpendingcommiterror.md)
-
-#### Overrides
-
-[`TransactionError`](../transactionerror.md).[`constructor`](../TransactionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`cause`](../TransactionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`message`](../TransactionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`name`](../TransactionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stack`](../TransactionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`prepareStackTrace`](../TransactionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stackTraceLimit`](../TransactionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`captureStackTrace`](../TransactionError.md#capturestacktrace)
diff --git a/docs/reference/classes/transactionnotpendingmutateerror.md b/docs/reference/classes/transactionnotpendingmutateerror.md
deleted file mode 100644
index 3d86c7ae5..000000000
--- a/docs/reference/classes/transactionnotpendingmutateerror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: TransactionNotPendingMutateError
-title: TransactionNotPendingMutateError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: TransactionNotPendingMutateError
-
-Defined in: [packages/db/src/errors.ts:232](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L232)
-
-## Extends
-
-- [`TransactionError`](../transactionerror.md)
-
-## Constructors
-
-### new TransactionNotPendingMutateError()
-
-```ts
-new TransactionNotPendingMutateError(): TransactionNotPendingMutateError
-```
-
-Defined in: [packages/db/src/errors.ts:233](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L233)
-
-#### Returns
-
-[`TransactionNotPendingMutateError`](../transactionnotpendingmutateerror.md)
-
-#### Overrides
-
-[`TransactionError`](../transactionerror.md).[`constructor`](../TransactionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`cause`](../TransactionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`message`](../TransactionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`name`](../TransactionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stack`](../TransactionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`prepareStackTrace`](../TransactionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`stackTraceLimit`](../TransactionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`TransactionError`](../transactionerror.md).[`captureStackTrace`](../TransactionError.md#capturestacktrace)
diff --git a/docs/reference/classes/undefinedkeyerror.md b/docs/reference/classes/undefinedkeyerror.md
deleted file mode 100644
index 4be382c3f..000000000
--- a/docs/reference/classes/undefinedkeyerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: UndefinedKeyError
-title: UndefinedKeyError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: UndefinedKeyError
-
-Defined in: [packages/db/src/errors.ts:120](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L120)
-
-## Extends
-
-- [`CollectionOperationError`](../collectionoperationerror.md)
-
-## Constructors
-
-### new UndefinedKeyError()
-
-```ts
-new UndefinedKeyError(item): UndefinedKeyError
-```
-
-Defined in: [packages/db/src/errors.ts:121](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L121)
-
-#### Parameters
-
-##### item
-
-`any`
-
-#### Returns
-
-[`UndefinedKeyError`](../undefinedkeyerror.md)
-
-#### Overrides
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`constructor`](../CollectionOperationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`cause`](../CollectionOperationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`message`](../CollectionOperationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`name`](../CollectionOperationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stack`](../CollectionOperationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`prepareStackTrace`](../CollectionOperationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stackTraceLimit`](../CollectionOperationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`captureStackTrace`](../CollectionOperationError.md#capturestacktrace)
diff --git a/docs/reference/classes/unknownexpressiontypeerror.md b/docs/reference/classes/unknownexpressiontypeerror.md
deleted file mode 100644
index e33b9dc66..000000000
--- a/docs/reference/classes/unknownexpressiontypeerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: UnknownExpressionTypeError
-title: UnknownExpressionTypeError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: UnknownExpressionTypeError
-
-Defined in: [packages/db/src/errors.ts:362](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L362)
-
-## Extends
-
-- [`QueryCompilationError`](../querycompilationerror.md)
-
-## Constructors
-
-### new UnknownExpressionTypeError()
-
-```ts
-new UnknownExpressionTypeError(type): UnknownExpressionTypeError
-```
-
-Defined in: [packages/db/src/errors.ts:363](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L363)
-
-#### Parameters
-
-##### type
-
-`string`
-
-#### Returns
-
-[`UnknownExpressionTypeError`](../unknownexpressiontypeerror.md)
-
-#### Overrides
-
-[`QueryCompilationError`](../querycompilationerror.md).[`constructor`](../QueryCompilationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`cause`](../QueryCompilationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`message`](../QueryCompilationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`name`](../QueryCompilationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stack`](../QueryCompilationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`prepareStackTrace`](../QueryCompilationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stackTraceLimit`](../QueryCompilationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`captureStackTrace`](../QueryCompilationError.md#capturestacktrace)
diff --git a/docs/reference/classes/unknownfunctionerror.md b/docs/reference/classes/unknownfunctionerror.md
deleted file mode 100644
index 6537fe3c3..000000000
--- a/docs/reference/classes/unknownfunctionerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: UnknownFunctionError
-title: UnknownFunctionError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: UnknownFunctionError
-
-Defined in: [packages/db/src/errors.ts:374](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L374)
-
-## Extends
-
-- [`QueryCompilationError`](../querycompilationerror.md)
-
-## Constructors
-
-### new UnknownFunctionError()
-
-```ts
-new UnknownFunctionError(functionName): UnknownFunctionError
-```
-
-Defined in: [packages/db/src/errors.ts:375](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L375)
-
-#### Parameters
-
-##### functionName
-
-`string`
-
-#### Returns
-
-[`UnknownFunctionError`](../unknownfunctionerror.md)
-
-#### Overrides
-
-[`QueryCompilationError`](../querycompilationerror.md).[`constructor`](../QueryCompilationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`cause`](../QueryCompilationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`message`](../QueryCompilationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`name`](../QueryCompilationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stack`](../QueryCompilationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`prepareStackTrace`](../QueryCompilationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stackTraceLimit`](../QueryCompilationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`captureStackTrace`](../QueryCompilationError.md#capturestacktrace)
diff --git a/docs/reference/classes/unknownhavingexpressiontypeerror.md b/docs/reference/classes/unknownhavingexpressiontypeerror.md
deleted file mode 100644
index 6142ad276..000000000
--- a/docs/reference/classes/unknownhavingexpressiontypeerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: UnknownHavingExpressionTypeError
-title: UnknownHavingExpressionTypeError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: UnknownHavingExpressionTypeError
-
-Defined in: [packages/db/src/errors.ts:459](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L459)
-
-## Extends
-
-- [`GroupByError`](../groupbyerror.md)
-
-## Constructors
-
-### new UnknownHavingExpressionTypeError()
-
-```ts
-new UnknownHavingExpressionTypeError(type): UnknownHavingExpressionTypeError
-```
-
-Defined in: [packages/db/src/errors.ts:460](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L460)
-
-#### Parameters
-
-##### type
-
-`string`
-
-#### Returns
-
-[`UnknownHavingExpressionTypeError`](../unknownhavingexpressiontypeerror.md)
-
-#### Overrides
-
-[`GroupByError`](../groupbyerror.md).[`constructor`](../GroupByError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`cause`](../GroupByError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`message`](../GroupByError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`name`](../GroupByError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`stack`](../GroupByError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`prepareStackTrace`](../GroupByError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`stackTraceLimit`](../GroupByError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`captureStackTrace`](../GroupByError.md#capturestacktrace)
diff --git a/docs/reference/classes/unsupportedaggregatefunctionerror.md b/docs/reference/classes/unsupportedaggregatefunctionerror.md
deleted file mode 100644
index d9d2b3305..000000000
--- a/docs/reference/classes/unsupportedaggregatefunctionerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: UnsupportedAggregateFunctionError
-title: UnsupportedAggregateFunctionError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: UnsupportedAggregateFunctionError
-
-Defined in: [packages/db/src/errors.ts:445](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L445)
-
-## Extends
-
-- [`GroupByError`](../groupbyerror.md)
-
-## Constructors
-
-### new UnsupportedAggregateFunctionError()
-
-```ts
-new UnsupportedAggregateFunctionError(functionName): UnsupportedAggregateFunctionError
-```
-
-Defined in: [packages/db/src/errors.ts:446](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L446)
-
-#### Parameters
-
-##### functionName
-
-`string`
-
-#### Returns
-
-[`UnsupportedAggregateFunctionError`](../unsupportedaggregatefunctionerror.md)
-
-#### Overrides
-
-[`GroupByError`](../groupbyerror.md).[`constructor`](../GroupByError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`cause`](../GroupByError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`message`](../GroupByError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`name`](../GroupByError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`stack`](../GroupByError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`prepareStackTrace`](../GroupByError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`stackTraceLimit`](../GroupByError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`GroupByError`](../groupbyerror.md).[`captureStackTrace`](../GroupByError.md#capturestacktrace)
diff --git a/docs/reference/classes/unsupportedfromtypeerror.md b/docs/reference/classes/unsupportedfromtypeerror.md
deleted file mode 100644
index df9039d8a..000000000
--- a/docs/reference/classes/unsupportedfromtypeerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: UnsupportedFromTypeError
-title: UnsupportedFromTypeError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: UnsupportedFromTypeError
-
-Defined in: [packages/db/src/errors.ts:356](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L356)
-
-## Extends
-
-- [`QueryCompilationError`](../querycompilationerror.md)
-
-## Constructors
-
-### new UnsupportedFromTypeError()
-
-```ts
-new UnsupportedFromTypeError(type): UnsupportedFromTypeError
-```
-
-Defined in: [packages/db/src/errors.ts:357](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L357)
-
-#### Parameters
-
-##### type
-
-`string`
-
-#### Returns
-
-[`UnsupportedFromTypeError`](../unsupportedfromtypeerror.md)
-
-#### Overrides
-
-[`QueryCompilationError`](../querycompilationerror.md).[`constructor`](../QueryCompilationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`cause`](../QueryCompilationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`message`](../QueryCompilationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`name`](../QueryCompilationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stack`](../QueryCompilationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`prepareStackTrace`](../QueryCompilationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`stackTraceLimit`](../QueryCompilationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCompilationError`](../querycompilationerror.md).[`captureStackTrace`](../QueryCompilationError.md#capturestacktrace)
diff --git a/docs/reference/classes/unsupportedjoinsourcetypeerror.md b/docs/reference/classes/unsupportedjoinsourcetypeerror.md
deleted file mode 100644
index 728bd6adb..000000000
--- a/docs/reference/classes/unsupportedjoinsourcetypeerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: UnsupportedJoinSourceTypeError
-title: UnsupportedJoinSourceTypeError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: UnsupportedJoinSourceTypeError
-
-Defined in: [packages/db/src/errors.ts:423](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L423)
-
-## Extends
-
-- [`JoinError`](../joinerror.md)
-
-## Constructors
-
-### new UnsupportedJoinSourceTypeError()
-
-```ts
-new UnsupportedJoinSourceTypeError(type): UnsupportedJoinSourceTypeError
-```
-
-Defined in: [packages/db/src/errors.ts:424](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L424)
-
-#### Parameters
-
-##### type
-
-`string`
-
-#### Returns
-
-[`UnsupportedJoinSourceTypeError`](../unsupportedjoinsourcetypeerror.md)
-
-#### Overrides
-
-[`JoinError`](../joinerror.md).[`constructor`](../JoinError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`cause`](../JoinError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`message`](../JoinError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`name`](../JoinError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stack`](../JoinError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`prepareStackTrace`](../JoinError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stackTraceLimit`](../JoinError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`captureStackTrace`](../JoinError.md#capturestacktrace)
diff --git a/docs/reference/classes/unsupportedjointypeerror.md b/docs/reference/classes/unsupportedjointypeerror.md
deleted file mode 100644
index d240f499b..000000000
--- a/docs/reference/classes/unsupportedjointypeerror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: UnsupportedJoinTypeError
-title: UnsupportedJoinTypeError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: UnsupportedJoinTypeError
-
-Defined in: [packages/db/src/errors.ts:388](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L388)
-
-## Extends
-
-- [`JoinError`](../joinerror.md)
-
-## Constructors
-
-### new UnsupportedJoinTypeError()
-
-```ts
-new UnsupportedJoinTypeError(joinType): UnsupportedJoinTypeError
-```
-
-Defined in: [packages/db/src/errors.ts:389](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L389)
-
-#### Parameters
-
-##### joinType
-
-`string`
-
-#### Returns
-
-[`UnsupportedJoinTypeError`](../unsupportedjointypeerror.md)
-
-#### Overrides
-
-[`JoinError`](../joinerror.md).[`constructor`](../JoinError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`cause`](../JoinError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`message`](../JoinError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`name`](../JoinError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stack`](../JoinError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`prepareStackTrace`](../JoinError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`stackTraceLimit`](../JoinError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`JoinError`](../joinerror.md).[`captureStackTrace`](../JoinError.md#capturestacktrace)
diff --git a/docs/reference/classes/updatekeynotfounderror.md b/docs/reference/classes/updatekeynotfounderror.md
deleted file mode 100644
index a3ef7c329..000000000
--- a/docs/reference/classes/updatekeynotfounderror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: UpdateKeyNotFoundError
-title: UpdateKeyNotFoundError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: UpdateKeyNotFoundError
-
-Defined in: [packages/db/src/errors.ts:156](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L156)
-
-## Extends
-
-- [`CollectionOperationError`](../collectionoperationerror.md)
-
-## Constructors
-
-### new UpdateKeyNotFoundError()
-
-```ts
-new UpdateKeyNotFoundError(key): UpdateKeyNotFoundError
-```
-
-Defined in: [packages/db/src/errors.ts:157](https://github.com/TanStack/db/blob/main/packages/db/src/errors.ts#L157)
-
-#### Parameters
-
-##### key
-
-`string` | `number`
-
-#### Returns
-
-[`UpdateKeyNotFoundError`](../updatekeynotfounderror.md)
-
-#### Overrides
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`constructor`](../CollectionOperationError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`cause`](../CollectionOperationError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`message`](../CollectionOperationError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`name`](../CollectionOperationError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stack`](../CollectionOperationError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`prepareStackTrace`](../CollectionOperationError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`stackTraceLimit`](../CollectionOperationError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionOperationError`](../collectionoperationerror.md).[`captureStackTrace`](../CollectionOperationError.md#capturestacktrace)
diff --git a/docs/reference/electric-db-collection/classes/ElectricDBCollectionError.md b/docs/reference/electric-db-collection/classes/ElectricDBCollectionError.md
new file mode 100644
index 000000000..a7ee69f1d
--- /dev/null
+++ b/docs/reference/electric-db-collection/classes/ElectricDBCollectionError.md
@@ -0,0 +1,247 @@
+---
+id: ElectricDBCollectionError
+title: ElectricDBCollectionError
+---
+
+# Class: ElectricDBCollectionError
+
+Defined in: [packages/electric-db-collection/src/errors.ts:4](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L4)
+
+## Extends
+
+- `TanStackDBError`
+
+## Extended by
+
+- [`ExpectedNumberInAwaitTxIdError`](ExpectedNumberInAwaitTxIdError.md)
+- [`TimeoutWaitingForTxIdError`](TimeoutWaitingForTxIdError.md)
+- [`TimeoutWaitingForMatchError`](TimeoutWaitingForMatchError.md)
+- [`StreamAbortedError`](StreamAbortedError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new ElectricDBCollectionError(message, collectionId?): ElectricDBCollectionError;
+```
+
+Defined in: [packages/electric-db-collection/src/errors.ts:5](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L5)
+
+#### Parameters
+
+##### message
+
+`string`
+
+##### collectionId?
+
+`string`
+
+#### Returns
+
+`ElectricDBCollectionError`
+
+#### Overrides
+
+```ts
+TanStackDBError.constructor
+```
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+```ts
+TanStackDBError.cause
+```
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+```ts
+TanStackDBError.message
+```
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+```ts
+TanStackDBError.name
+```
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+```ts
+TanStackDBError.stack
+```
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+```ts
+TanStackDBError.stackTraceLimit
+```
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+```ts
+TanStackDBError.captureStackTrace
+```
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+```ts
+TanStackDBError.prepareStackTrace
+```
diff --git a/docs/reference/electric-db-collection/classes/ExpectedNumberInAwaitTxIdError.md b/docs/reference/electric-db-collection/classes/ExpectedNumberInAwaitTxIdError.md
new file mode 100644
index 000000000..9b2a3317b
--- /dev/null
+++ b/docs/reference/electric-db-collection/classes/ExpectedNumberInAwaitTxIdError.md
@@ -0,0 +1,224 @@
+---
+id: ExpectedNumberInAwaitTxIdError
+title: ExpectedNumberInAwaitTxIdError
+---
+
+# Class: ExpectedNumberInAwaitTxIdError
+
+Defined in: [packages/electric-db-collection/src/errors.ts:11](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L11)
+
+## Extends
+
+- [`ElectricDBCollectionError`](ElectricDBCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new ExpectedNumberInAwaitTxIdError(txIdType, collectionId?): ExpectedNumberInAwaitTxIdError;
+```
+
+Defined in: [packages/electric-db-collection/src/errors.ts:12](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L12)
+
+#### Parameters
+
+##### txIdType
+
+`string`
+
+##### collectionId?
+
+`string`
+
+#### Returns
+
+`ExpectedNumberInAwaitTxIdError`
+
+#### Overrides
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`constructor`](ElectricDBCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`cause`](ElectricDBCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`message`](ElectricDBCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`name`](ElectricDBCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`stack`](ElectricDBCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`stackTraceLimit`](ElectricDBCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`captureStackTrace`](ElectricDBCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`prepareStackTrace`](ElectricDBCollectionError.md#preparestacktrace)
diff --git a/docs/reference/electric-db-collection/classes/StreamAbortedError.md b/docs/reference/electric-db-collection/classes/StreamAbortedError.md
new file mode 100644
index 000000000..6b2a5c286
--- /dev/null
+++ b/docs/reference/electric-db-collection/classes/StreamAbortedError.md
@@ -0,0 +1,220 @@
+---
+id: StreamAbortedError
+title: StreamAbortedError
+---
+
+# Class: StreamAbortedError
+
+Defined in: [packages/electric-db-collection/src/errors.ts:32](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L32)
+
+## Extends
+
+- [`ElectricDBCollectionError`](ElectricDBCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new StreamAbortedError(collectionId?): StreamAbortedError;
+```
+
+Defined in: [packages/electric-db-collection/src/errors.ts:33](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L33)
+
+#### Parameters
+
+##### collectionId?
+
+`string`
+
+#### Returns
+
+`StreamAbortedError`
+
+#### Overrides
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`constructor`](ElectricDBCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`cause`](ElectricDBCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`message`](ElectricDBCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`name`](ElectricDBCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`stack`](ElectricDBCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`stackTraceLimit`](ElectricDBCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`captureStackTrace`](ElectricDBCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`prepareStackTrace`](ElectricDBCollectionError.md#preparestacktrace)
diff --git a/docs/reference/electric-db-collection/classes/TimeoutWaitingForMatchError.md b/docs/reference/electric-db-collection/classes/TimeoutWaitingForMatchError.md
new file mode 100644
index 000000000..8d6383e1d
--- /dev/null
+++ b/docs/reference/electric-db-collection/classes/TimeoutWaitingForMatchError.md
@@ -0,0 +1,220 @@
+---
+id: TimeoutWaitingForMatchError
+title: TimeoutWaitingForMatchError
+---
+
+# Class: TimeoutWaitingForMatchError
+
+Defined in: [packages/electric-db-collection/src/errors.ts:25](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L25)
+
+## Extends
+
+- [`ElectricDBCollectionError`](ElectricDBCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new TimeoutWaitingForMatchError(collectionId?): TimeoutWaitingForMatchError;
+```
+
+Defined in: [packages/electric-db-collection/src/errors.ts:26](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L26)
+
+#### Parameters
+
+##### collectionId?
+
+`string`
+
+#### Returns
+
+`TimeoutWaitingForMatchError`
+
+#### Overrides
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`constructor`](ElectricDBCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`cause`](ElectricDBCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`message`](ElectricDBCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`name`](ElectricDBCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`stack`](ElectricDBCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`stackTraceLimit`](ElectricDBCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`captureStackTrace`](ElectricDBCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`prepareStackTrace`](ElectricDBCollectionError.md#preparestacktrace)
diff --git a/docs/reference/electric-db-collection/classes/TimeoutWaitingForTxIdError.md b/docs/reference/electric-db-collection/classes/TimeoutWaitingForTxIdError.md
new file mode 100644
index 000000000..ec39c57d4
--- /dev/null
+++ b/docs/reference/electric-db-collection/classes/TimeoutWaitingForTxIdError.md
@@ -0,0 +1,224 @@
+---
+id: TimeoutWaitingForTxIdError
+title: TimeoutWaitingForTxIdError
+---
+
+# Class: TimeoutWaitingForTxIdError
+
+Defined in: [packages/electric-db-collection/src/errors.ts:18](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L18)
+
+## Extends
+
+- [`ElectricDBCollectionError`](ElectricDBCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new TimeoutWaitingForTxIdError(txId, collectionId?): TimeoutWaitingForTxIdError;
+```
+
+Defined in: [packages/electric-db-collection/src/errors.ts:19](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L19)
+
+#### Parameters
+
+##### txId
+
+`number`
+
+##### collectionId?
+
+`string`
+
+#### Returns
+
+`TimeoutWaitingForTxIdError`
+
+#### Overrides
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`constructor`](ElectricDBCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`cause`](ElectricDBCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`message`](ElectricDBCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`name`](ElectricDBCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`stack`](ElectricDBCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`stackTraceLimit`](ElectricDBCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`captureStackTrace`](ElectricDBCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`ElectricDBCollectionError`](ElectricDBCollectionError.md).[`prepareStackTrace`](ElectricDBCollectionError.md#preparestacktrace)
diff --git a/docs/reference/electric-db-collection/classes/electricdbcollectionerror.md b/docs/reference/electric-db-collection/classes/electricdbcollectionerror.md
deleted file mode 100644
index a4c78230e..000000000
--- a/docs/reference/electric-db-collection/classes/electricdbcollectionerror.md
+++ /dev/null
@@ -1,196 +0,0 @@
----
-id: ElectricDBCollectionError
-title: ElectricDBCollectionError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: ElectricDBCollectionError
-
-Defined in: [packages/electric-db-collection/src/errors.ts:4](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L4)
-
-## Extends
-
-- `TanStackDBError`
-
-## Extended by
-
-- [`ExpectedNumberInAwaitTxIdError`](../expectednumberinawaittxiderror.md)
-- [`TimeoutWaitingForTxIdError`](../timeoutwaitingfortxiderror.md)
-- [`ElectricInsertHandlerMustReturnTxIdError`](../electricinserthandlermustreturntxiderror.md)
-- [`ElectricUpdateHandlerMustReturnTxIdError`](../electricupdatehandlermustreturntxiderror.md)
-- [`ElectricDeleteHandlerMustReturnTxIdError`](../electricdeletehandlermustreturntxiderror.md)
-
-## Constructors
-
-### new ElectricDBCollectionError()
-
-```ts
-new ElectricDBCollectionError(message): ElectricDBCollectionError
-```
-
-Defined in: [packages/electric-db-collection/src/errors.ts:5](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L5)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md)
-
-#### Overrides
-
-```ts
-TanStackDBError.constructor
-```
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-```ts
-TanStackDBError.cause
-```
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-```ts
-TanStackDBError.message
-```
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-```ts
-TanStackDBError.name
-```
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-```ts
-TanStackDBError.stack
-```
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-```ts
-TanStackDBError.prepareStackTrace
-```
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-```ts
-TanStackDBError.stackTraceLimit
-```
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-```ts
-TanStackDBError.captureStackTrace
-```
diff --git a/docs/reference/electric-db-collection/classes/electricdeletehandlermustreturntxiderror.md b/docs/reference/electric-db-collection/classes/electricdeletehandlermustreturntxiderror.md
deleted file mode 100644
index 10d1c6654..000000000
--- a/docs/reference/electric-db-collection/classes/electricdeletehandlermustreturntxiderror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: ElectricDeleteHandlerMustReturnTxIdError
-title: ElectricDeleteHandlerMustReturnTxIdError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: ElectricDeleteHandlerMustReturnTxIdError
-
-Defined in: [packages/electric-db-collection/src/errors.ts:43](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L43)
-
-## Extends
-
-- [`ElectricDBCollectionError`](../electricdbcollectionerror.md)
-
-## Constructors
-
-### new ElectricDeleteHandlerMustReturnTxIdError()
-
-```ts
-new ElectricDeleteHandlerMustReturnTxIdError(): ElectricDeleteHandlerMustReturnTxIdError
-```
-
-Defined in: [packages/electric-db-collection/src/errors.ts:44](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L44)
-
-#### Returns
-
-[`ElectricDeleteHandlerMustReturnTxIdError`](../electricdeletehandlermustreturntxiderror.md)
-
-#### Overrides
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`constructor`](../ElectricDBCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`cause`](../ElectricDBCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`message`](../ElectricDBCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`name`](../ElectricDBCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stack`](../ElectricDBCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`prepareStackTrace`](../ElectricDBCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stackTraceLimit`](../ElectricDBCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`captureStackTrace`](../ElectricDBCollectionError.md#capturestacktrace)
diff --git a/docs/reference/electric-db-collection/classes/electricinserthandlermustreturntxiderror.md b/docs/reference/electric-db-collection/classes/electricinserthandlermustreturntxiderror.md
deleted file mode 100644
index 2c33e6bb4..000000000
--- a/docs/reference/electric-db-collection/classes/electricinserthandlermustreturntxiderror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: ElectricInsertHandlerMustReturnTxIdError
-title: ElectricInsertHandlerMustReturnTxIdError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: ElectricInsertHandlerMustReturnTxIdError
-
-Defined in: [packages/electric-db-collection/src/errors.ts:25](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L25)
-
-## Extends
-
-- [`ElectricDBCollectionError`](../electricdbcollectionerror.md)
-
-## Constructors
-
-### new ElectricInsertHandlerMustReturnTxIdError()
-
-```ts
-new ElectricInsertHandlerMustReturnTxIdError(): ElectricInsertHandlerMustReturnTxIdError
-```
-
-Defined in: [packages/electric-db-collection/src/errors.ts:26](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L26)
-
-#### Returns
-
-[`ElectricInsertHandlerMustReturnTxIdError`](../electricinserthandlermustreturntxiderror.md)
-
-#### Overrides
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`constructor`](../ElectricDBCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`cause`](../ElectricDBCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`message`](../ElectricDBCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`name`](../ElectricDBCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stack`](../ElectricDBCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`prepareStackTrace`](../ElectricDBCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stackTraceLimit`](../ElectricDBCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`captureStackTrace`](../ElectricDBCollectionError.md#capturestacktrace)
diff --git a/docs/reference/electric-db-collection/classes/electricupdatehandlermustreturntxiderror.md b/docs/reference/electric-db-collection/classes/electricupdatehandlermustreturntxiderror.md
deleted file mode 100644
index 059914022..000000000
--- a/docs/reference/electric-db-collection/classes/electricupdatehandlermustreturntxiderror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: ElectricUpdateHandlerMustReturnTxIdError
-title: ElectricUpdateHandlerMustReturnTxIdError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: ElectricUpdateHandlerMustReturnTxIdError
-
-Defined in: [packages/electric-db-collection/src/errors.ts:34](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L34)
-
-## Extends
-
-- [`ElectricDBCollectionError`](../electricdbcollectionerror.md)
-
-## Constructors
-
-### new ElectricUpdateHandlerMustReturnTxIdError()
-
-```ts
-new ElectricUpdateHandlerMustReturnTxIdError(): ElectricUpdateHandlerMustReturnTxIdError
-```
-
-Defined in: [packages/electric-db-collection/src/errors.ts:35](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L35)
-
-#### Returns
-
-[`ElectricUpdateHandlerMustReturnTxIdError`](../electricupdatehandlermustreturntxiderror.md)
-
-#### Overrides
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`constructor`](../ElectricDBCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`cause`](../ElectricDBCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`message`](../ElectricDBCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`name`](../ElectricDBCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stack`](../ElectricDBCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`prepareStackTrace`](../ElectricDBCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stackTraceLimit`](../ElectricDBCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`captureStackTrace`](../ElectricDBCollectionError.md#capturestacktrace)
diff --git a/docs/reference/electric-db-collection/classes/expectednumberinawaittxiderror.md b/docs/reference/electric-db-collection/classes/expectednumberinawaittxiderror.md
deleted file mode 100644
index 7e0cc14f4..000000000
--- a/docs/reference/electric-db-collection/classes/expectednumberinawaittxiderror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: ExpectedNumberInAwaitTxIdError
-title: ExpectedNumberInAwaitTxIdError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: ExpectedNumberInAwaitTxIdError
-
-Defined in: [packages/electric-db-collection/src/errors.ts:11](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L11)
-
-## Extends
-
-- [`ElectricDBCollectionError`](../electricdbcollectionerror.md)
-
-## Constructors
-
-### new ExpectedNumberInAwaitTxIdError()
-
-```ts
-new ExpectedNumberInAwaitTxIdError(txIdType): ExpectedNumberInAwaitTxIdError
-```
-
-Defined in: [packages/electric-db-collection/src/errors.ts:12](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L12)
-
-#### Parameters
-
-##### txIdType
-
-`string`
-
-#### Returns
-
-[`ExpectedNumberInAwaitTxIdError`](../expectednumberinawaittxiderror.md)
-
-#### Overrides
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`constructor`](../ElectricDBCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`cause`](../ElectricDBCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`message`](../ElectricDBCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`name`](../ElectricDBCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stack`](../ElectricDBCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`prepareStackTrace`](../ElectricDBCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stackTraceLimit`](../ElectricDBCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`captureStackTrace`](../ElectricDBCollectionError.md#capturestacktrace)
diff --git a/docs/reference/electric-db-collection/classes/timeoutwaitingfortxiderror.md b/docs/reference/electric-db-collection/classes/timeoutwaitingfortxiderror.md
deleted file mode 100644
index b27c1ff04..000000000
--- a/docs/reference/electric-db-collection/classes/timeoutwaitingfortxiderror.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: TimeoutWaitingForTxIdError
-title: TimeoutWaitingForTxIdError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: TimeoutWaitingForTxIdError
-
-Defined in: [packages/electric-db-collection/src/errors.ts:18](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L18)
-
-## Extends
-
-- [`ElectricDBCollectionError`](../electricdbcollectionerror.md)
-
-## Constructors
-
-### new TimeoutWaitingForTxIdError()
-
-```ts
-new TimeoutWaitingForTxIdError(txId): TimeoutWaitingForTxIdError
-```
-
-Defined in: [packages/electric-db-collection/src/errors.ts:19](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/errors.ts#L19)
-
-#### Parameters
-
-##### txId
-
-`number`
-
-#### Returns
-
-[`TimeoutWaitingForTxIdError`](../timeoutwaitingfortxiderror.md)
-
-#### Overrides
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`constructor`](../ElectricDBCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`cause`](../ElectricDBCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`message`](../ElectricDBCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`name`](../ElectricDBCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stack`](../ElectricDBCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`prepareStackTrace`](../ElectricDBCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`stackTraceLimit`](../ElectricDBCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`ElectricDBCollectionError`](../electricdbcollectionerror.md).[`captureStackTrace`](../ElectricDBCollectionError.md#capturestacktrace)
diff --git a/docs/reference/electric-db-collection/functions/electricCollectionOptions.md b/docs/reference/electric-db-collection/functions/electricCollectionOptions.md
new file mode 100644
index 000000000..d0d410a83
--- /dev/null
+++ b/docs/reference/electric-db-collection/functions/electricCollectionOptions.md
@@ -0,0 +1,70 @@
+---
+id: electricCollectionOptions
+title: electricCollectionOptions
+---
+
+# Function: electricCollectionOptions()
+
+## Call Signature
+
+```ts
+function electricCollectionOptions<T>(config): Omit<CollectionConfig<InferSchemaOutput<T>, string | number, T, UtilsRecord>, "utils"> & object;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:510](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L510)
+
+Creates Electric collection options for use with a standard Collection
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+The explicit type of items in the collection (highest priority)
+
+### Parameters
+
+#### config
+
+[`ElectricCollectionConfig`](../interfaces/ElectricCollectionConfig.md)\<`InferSchemaOutput`\<`T`\>, `T`\> & `object`
+
+Configuration options for the Electric collection
+
+### Returns
+
+`Omit`\<`CollectionConfig`\<`InferSchemaOutput`\<`T`\>, `string` \| `number`, `T`, `UtilsRecord`\>, `"utils"`\> & `object`
+
+Collection options with utilities
+
+## Call Signature
+
+```ts
+function electricCollectionOptions<T>(config): Omit<CollectionConfig<T, string | number, never, UtilsRecord>, "utils"> & object;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:521](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L521)
+
+Creates Electric collection options for use with a standard Collection
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `Row`\<`unknown`\>
+
+The explicit type of items in the collection (highest priority)
+
+### Parameters
+
+#### config
+
+[`ElectricCollectionConfig`](../interfaces/ElectricCollectionConfig.md)\<`T`, `never`\> & `object`
+
+Configuration options for the Electric collection
+
+### Returns
+
+`Omit`\<`CollectionConfig`\<`T`, `string` \| `number`, `never`, `UtilsRecord`\>, `"utils"`\> & `object`
+
+Collection options with utilities
diff --git a/docs/reference/electric-db-collection/functions/electriccollectionoptions.md b/docs/reference/electric-db-collection/functions/electriccollectionoptions.md
deleted file mode 100644
index e824b3006..000000000
--- a/docs/reference/electric-db-collection/functions/electriccollectionoptions.md
+++ /dev/null
@@ -1,122 +0,0 @@
----
-id: electricCollectionOptions
-title: electricCollectionOptions
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: electricCollectionOptions()
-
-```ts
-function electricCollectionOptions<TExplicit, TSchema, TFallback>(config): object
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:285](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L285)
-
-Creates Electric collection options for use with a standard Collection
-
-## Type Parameters
-
-• **TExplicit** *extends* `Row`\<`unknown`\> = `Row`\<`unknown`\>
-
-The explicit type of items in the collection (highest priority)
-
-• **TSchema** *extends* `StandardSchemaV1`\<`unknown`, `unknown`\> = `never`
-
-The schema type for validation and type inference (second priority)
-
-• **TFallback** *extends* `Row`\<`unknown`\> = `Row`\<`unknown`\>
-
-The fallback type if no explicit or schema type is provided
-
-## Parameters
-
-### config
-
-[`ElectricCollectionConfig`](../../interfaces/electriccollectionconfig.md)\<`TExplicit`, `TSchema`, `TFallback`\>
-
-Configuration options for the Electric collection
-
-## Returns
-
-`object`
-
-Collection options with utilities
-
-### getKey()
-
-```ts
-getKey: (item) => string | number;
-```
-
-#### Parameters
-
-##### item
-
-`ResolveType`
-
-#### Returns
-
-`string` \| `number`
-
-### id?
-
-```ts
-optional id: string;
-```
-
-All standard Collection configuration properties
-
-### onDelete
-
-```ts
-onDelete: 
-  | undefined
-  | (params) => Promise<{
-  txid: number | number[];
- }> = wrappedOnDelete;
-```
-
-### onInsert
-
-```ts
-onInsert: 
-  | undefined
-  | (params) => Promise<{
-  txid: number | number[];
- }> = wrappedOnInsert;
-```
-
-### onUpdate
-
-```ts
-onUpdate: 
-  | undefined
-  | (params) => Promise<{
-  txid: number | number[];
- }> = wrappedOnUpdate;
-```
-
-### schema?
-
-```ts
-optional schema: TSchema;
-```
-
-### sync
-
-```ts
-sync: SyncConfig<ResolveType<TExplicit, TSchema, TFallback>, string | number>;
-```
-
-### utils
-
-```ts
-utils: object;
-```
-
-#### utils.awaitTxId
-
-```ts
-awaitTxId: AwaitTxIdFn;
-```
diff --git a/docs/reference/electric-db-collection/functions/isChangeMessage.md b/docs/reference/electric-db-collection/functions/isChangeMessage.md
new file mode 100644
index 000000000..9e3cba59a
--- /dev/null
+++ b/docs/reference/electric-db-collection/functions/isChangeMessage.md
@@ -0,0 +1,46 @@
+---
+id: isChangeMessage
+title: isChangeMessage
+---
+
+# Function: isChangeMessage()
+
+```ts
+function isChangeMessage<T>(message): message is ChangeMessage<T>;
+```
+
+Defined in: node\_modules/.pnpm/@electric-sql+client@1.3.1/node\_modules/@electric-sql/client/dist/index.d.ts:816
+
+Type guard for checking Message is ChangeMessage.
+
+See [TS docs](https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards)
+for information on how to use type guards.
+
+## Type Parameters
+
+### T
+
+`T` *extends* `Row`\<`unknown`\> = `Row`\<`never`\>
+
+## Parameters
+
+### message
+
+`Message`\<`T`\>
+
+the message to check
+
+## Returns
+
+`message is ChangeMessage<T>`
+
+true if the message is a ChangeMessage
+
+## Example
+
+```ts
+if (isChangeMessage(message)) {
+  const msgChng: ChangeMessage = message // Ok
+  const msgCtrl: ControlMessage = message // Err, type mismatch
+}
+```
diff --git a/docs/reference/electric-db-collection/functions/isControlMessage.md b/docs/reference/electric-db-collection/functions/isControlMessage.md
new file mode 100644
index 000000000..0d686b88f
--- /dev/null
+++ b/docs/reference/electric-db-collection/functions/isControlMessage.md
@@ -0,0 +1,48 @@
+---
+id: isControlMessage
+title: isControlMessage
+---
+
+# Function: isControlMessage()
+
+```ts
+function isControlMessage<T>(message): message is ControlMessage;
+```
+
+Defined in: node\_modules/.pnpm/@electric-sql+client@1.3.1/node\_modules/@electric-sql/client/dist/index.d.ts:834
+
+Type guard for checking Message is ControlMessage.
+
+See [TS docs](https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards)
+for information on how to use type guards.
+
+## Type Parameters
+
+### T
+
+`T` *extends* `Row`\<`unknown`\> = `Row`\<`never`\>
+
+## Parameters
+
+### message
+
+`Message`\<`T`\>
+
+the message to check
+
+## Returns
+
+`message is ControlMessage`
+
+true if the message is a ControlMessage
+
+ *
+
+## Example
+
+```ts
+if (isControlMessage(message)) {
+  const msgChng: ChangeMessage = message // Err, type mismatch
+  const msgCtrl: ControlMessage = message // Ok
+}
+```
diff --git a/docs/reference/electric-db-collection/index.md b/docs/reference/electric-db-collection/index.md
index 24b07bbd4..b8b740997 100644
--- a/docs/reference/electric-db-collection/index.md
+++ b/docs/reference/electric-db-collection/index.md
@@ -3,28 +3,28 @@ id: "@tanstack/electric-db-collection"
 title: "@tanstack/electric-db-collection"
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # @tanstack/electric-db-collection
 
 ## Classes
 
-- [ElectricDBCollectionError](../classes/electricdbcollectionerror.md)
-- [ElectricDeleteHandlerMustReturnTxIdError](../classes/electricdeletehandlermustreturntxiderror.md)
-- [ElectricInsertHandlerMustReturnTxIdError](../classes/electricinserthandlermustreturntxiderror.md)
-- [ElectricUpdateHandlerMustReturnTxIdError](../classes/electricupdatehandlermustreturntxiderror.md)
-- [ExpectedNumberInAwaitTxIdError](../classes/expectednumberinawaittxiderror.md)
-- [TimeoutWaitingForTxIdError](../classes/timeoutwaitingfortxiderror.md)
+- [ElectricDBCollectionError](classes/ElectricDBCollectionError.md)
+- [ExpectedNumberInAwaitTxIdError](classes/ExpectedNumberInAwaitTxIdError.md)
+- [StreamAbortedError](classes/StreamAbortedError.md)
+- [TimeoutWaitingForMatchError](classes/TimeoutWaitingForMatchError.md)
+- [TimeoutWaitingForTxIdError](classes/TimeoutWaitingForTxIdError.md)
 
 ## Interfaces
 
-- [ElectricCollectionConfig](../interfaces/electriccollectionconfig.md)
-- [ElectricCollectionUtils](../interfaces/electriccollectionutils.md)
+- [ElectricCollectionConfig](interfaces/ElectricCollectionConfig.md)
+- [ElectricCollectionUtils](interfaces/ElectricCollectionUtils.md)
 
 ## Type Aliases
 
-- [Txid](../type-aliases/txid.md)
+- [AwaitTxIdFn](type-aliases/AwaitTxIdFn.md)
+- [Txid](type-aliases/Txid.md)
 
 ## Functions
 
-- [electricCollectionOptions](../functions/electriccollectionoptions.md)
+- [electricCollectionOptions](functions/electricCollectionOptions.md)
+- [isChangeMessage](functions/isChangeMessage.md)
+- [isControlMessage](functions/isControlMessage.md)
diff --git a/docs/reference/electric-db-collection/interfaces/ElectricCollectionConfig.md b/docs/reference/electric-db-collection/interfaces/ElectricCollectionConfig.md
new file mode 100644
index 000000000..dfa78a9d0
--- /dev/null
+++ b/docs/reference/electric-db-collection/interfaces/ElectricCollectionConfig.md
@@ -0,0 +1,242 @@
+---
+id: ElectricCollectionConfig
+title: ElectricCollectionConfig
+---
+
+# Interface: ElectricCollectionConfig\<T, TSchema\>
+
+Defined in: [packages/electric-db-collection/src/electric.ts:141](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L141)
+
+Configuration interface for Electric collection options
+
+## Extends
+
+- `Omit`\<`BaseCollectionConfig`\<`T`, `string` \| `number`, `TSchema`, [`ElectricCollectionUtils`](ElectricCollectionUtils.md)\<`T`\>, `any`\>, `"onInsert"` \| `"onUpdate"` \| `"onDelete"` \| `"syncMode"`\>
+
+## Type Parameters
+
+### T
+
+`T` *extends* `Row`\<`unknown`\> = `Row`\<`unknown`\>
+
+The type of items in the collection
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `never`
+
+The schema type for validation
+
+## Properties
+
+### \[ELECTRIC\_TEST\_HOOKS\]?
+
+```ts
+optional [ELECTRIC_TEST_HOOKS]: ElectricTestHooks;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:164](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L164)
+
+Internal test hooks (for testing only)
+Hidden via Symbol to prevent accidental usage in production
+
+***
+
+### onDelete()?
+
+```ts
+optional onDelete: (params) => Promise<MatchingStrategy>;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:281](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L281)
+
+Optional asynchronous handler function called before a delete operation
+
+#### Parameters
+
+##### params
+
+`DeleteMutationFnParams`\<`T`, `string` \| `number`, [`ElectricCollectionUtils`](ElectricCollectionUtils.md)\<`T`\>\>
+
+Object containing transaction and collection information
+
+#### Returns
+
+`Promise`\<`MatchingStrategy`\>
+
+Promise resolving to { txid, timeout? } or void
+
+#### Examples
+
+```ts
+// Basic Electric delete handler with txid (recommended)
+onDelete: async ({ transaction }) => {
+  const mutation = transaction.mutations[0]
+  const result = await api.todos.delete({
+    id: mutation.original.id
+  })
+  return { txid: result.txid }
+}
+```
+
+```ts
+// Use awaitMatch utility for custom matching
+onDelete: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  await api.todos.delete({ id: mutation.original.id })
+  await collection.utils.awaitMatch(
+    (message) => isChangeMessage(message) &&
+                 message.headers.operation === 'delete' &&
+                 message.value.id === mutation.original.id
+  )
+}
+```
+
+***
+
+### onInsert()?
+
+```ts
+optional onInsert: (params) => Promise<MatchingStrategy>;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:212](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L212)
+
+Optional asynchronous handler function called before an insert operation
+
+#### Parameters
+
+##### params
+
+`InsertMutationFnParams`\<`T`, `string` \| `number`, [`ElectricCollectionUtils`](ElectricCollectionUtils.md)\<`T`\>\>
+
+Object containing transaction and collection information
+
+#### Returns
+
+`Promise`\<`MatchingStrategy`\>
+
+Promise resolving to { txid, timeout? } or void
+
+#### Examples
+
+```ts
+// Basic Electric insert handler with txid (recommended)
+onInsert: async ({ transaction }) => {
+  const newItem = transaction.mutations[0].modified
+  const result = await api.todos.create({
+    data: newItem
+  })
+  return { txid: result.txid }
+}
+```
+
+```ts
+// Insert handler with custom timeout
+onInsert: async ({ transaction }) => {
+  const newItem = transaction.mutations[0].modified
+  const result = await api.todos.create({
+    data: newItem
+  })
+  return { txid: result.txid, timeout: 10000 } // Wait up to 10 seconds
+}
+```
+
+```ts
+// Insert handler with multiple items - return array of txids
+onInsert: async ({ transaction }) => {
+  const items = transaction.mutations.map(m => m.modified)
+  const results = await Promise.all(
+    items.map(item => api.todos.create({ data: item }))
+  )
+  return { txid: results.map(r => r.txid) }
+}
+```
+
+```ts
+// Use awaitMatch utility for custom matching
+onInsert: async ({ transaction, collection }) => {
+  const newItem = transaction.mutations[0].modified
+  await api.todos.create({ data: newItem })
+  await collection.utils.awaitMatch(
+    (message) => isChangeMessage(message) &&
+                 message.headers.operation === 'insert' &&
+                 message.value.name === newItem.name
+  )
+}
+```
+
+***
+
+### onUpdate()?
+
+```ts
+optional onUpdate: (params) => Promise<MatchingStrategy>;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:247](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L247)
+
+Optional asynchronous handler function called before an update operation
+
+#### Parameters
+
+##### params
+
+`UpdateMutationFnParams`\<`T`, `string` \| `number`, [`ElectricCollectionUtils`](ElectricCollectionUtils.md)\<`T`\>\>
+
+Object containing transaction and collection information
+
+#### Returns
+
+`Promise`\<`MatchingStrategy`\>
+
+Promise resolving to { txid, timeout? } or void
+
+#### Examples
+
+```ts
+// Basic Electric update handler with txid (recommended)
+onUpdate: async ({ transaction }) => {
+  const { original, changes } = transaction.mutations[0]
+  const result = await api.todos.update({
+    where: { id: original.id },
+    data: changes
+  })
+  return { txid: result.txid }
+}
+```
+
+```ts
+// Use awaitMatch utility for custom matching
+onUpdate: async ({ transaction, collection }) => {
+  const { original, changes } = transaction.mutations[0]
+  await api.todos.update({ where: { id: original.id }, data: changes })
+  await collection.utils.awaitMatch(
+    (message) => isChangeMessage(message) &&
+                 message.headers.operation === 'update' &&
+                 message.value.id === original.id
+  )
+}
+```
+
+***
+
+### shapeOptions
+
+```ts
+shapeOptions: ShapeStreamOptions<GetExtensions<T>>;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:157](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L157)
+
+Configuration options for the ElectricSQL ShapeStream
+
+***
+
+### syncMode?
+
+```ts
+optional syncMode: ElectricSyncMode;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:158](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L158)
diff --git a/docs/reference/electric-db-collection/interfaces/ElectricCollectionUtils.md b/docs/reference/electric-db-collection/interfaces/ElectricCollectionUtils.md
new file mode 100644
index 000000000..d75a7ba5c
--- /dev/null
+++ b/docs/reference/electric-db-collection/interfaces/ElectricCollectionUtils.md
@@ -0,0 +1,46 @@
+---
+id: ElectricCollectionUtils
+title: ElectricCollectionUtils
+---
+
+# Interface: ElectricCollectionUtils\<T\>
+
+Defined in: [packages/electric-db-collection/src/electric.ts:492](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L492)
+
+Electric collection utilities type
+
+## Extends
+
+- `UtilsRecord`
+
+## Type Parameters
+
+### T
+
+`T` *extends* `Row`\<`unknown`\> = `Row`\<`unknown`\>
+
+## Indexable
+
+```ts
+[key: string]: any
+```
+
+## Properties
+
+### awaitMatch
+
+```ts
+awaitMatch: AwaitMatchFn<T>;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:496](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L496)
+
+***
+
+### awaitTxId
+
+```ts
+awaitTxId: AwaitTxIdFn;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:495](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L495)
diff --git a/docs/reference/electric-db-collection/interfaces/electriccollectionconfig.md b/docs/reference/electric-db-collection/interfaces/electriccollectionconfig.md
deleted file mode 100644
index 93ace7123..000000000
--- a/docs/reference/electric-db-collection/interfaces/electriccollectionconfig.md
+++ /dev/null
@@ -1,338 +0,0 @@
----
-id: ElectricCollectionConfig
-title: ElectricCollectionConfig
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: ElectricCollectionConfig\<TExplicit, TSchema, TFallback\>
-
-Defined in: [packages/electric-db-collection/src/electric.ts:73](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L73)
-
-Configuration interface for Electric collection options
-
-## Remarks
-
-Type resolution follows a priority order:
-1. If you provide an explicit type via generic parameter, it will be used
-2. If no explicit type is provided but a schema is, the schema's output type will be inferred
-3. If neither explicit type nor schema is provided, the fallback type will be used
-
-You should provide EITHER an explicit type OR a schema, but not both, as they would conflict.
-
-## Type Parameters
-
-• **TExplicit** *extends* `Row`\<`unknown`\> = `Row`\<`unknown`\>
-
-The explicit type of items in the collection (highest priority)
-
-• **TSchema** *extends* `StandardSchemaV1` = `never`
-
-The schema type for validation and type inference (second priority)
-
-• **TFallback** *extends* `Row`\<`unknown`\> = `Row`\<`unknown`\>
-
-The fallback type if no explicit or schema type is provided
-
-## Properties
-
-### getKey()
-
-```ts
-getKey: (item) => string | number;
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:90](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L90)
-
-#### Parameters
-
-##### item
-
-`ResolveType`
-
-#### Returns
-
-`string` \| `number`
-
-***
-
-### id?
-
-```ts
-optional id: string;
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:88](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L88)
-
-All standard Collection configuration properties
-
-***
-
-### onDelete()?
-
-```ts
-optional onDelete: (params) => Promise<{
-  txid: number | number[];
-}>;
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:246](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L246)
-
-Optional asynchronous handler function called before a delete operation
-Must return an object containing a txid number or array of txids
-
-#### Parameters
-
-##### params
-
-`DeleteMutationFnParams`\<`ResolveType`\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-Object containing transaction and collection information
-
-#### Returns
-
-`Promise`\<\{
-  `txid`: `number` \| `number`[];
- \}\>
-
-Promise resolving to an object with txid or txids
-
-#### Examples
-
-```ts
-// Basic Electric delete handler - MUST return { txid: number }
-onDelete: async ({ transaction }) => {
-  const mutation = transaction.mutations[0]
-  const result = await api.todos.delete({
-    id: mutation.original.id
-  })
-  return { txid: result.txid } // Required for Electric sync matching
-}
-```
-
-```ts
-// Delete handler with multiple items - return array of txids
-onDelete: async ({ transaction }) => {
-  const deletes = await Promise.all(
-    transaction.mutations.map(m =>
-      api.todos.delete({
-        where: { id: m.key }
-      })
-    )
-  )
-  return { txid: deletes.map(d => d.txid) } // Array of txids
-}
-```
-
-```ts
-// Delete handler with batch operation - single txid
-onDelete: async ({ transaction }) => {
-  const idsToDelete = transaction.mutations.map(m => m.original.id)
-  const result = await api.todos.deleteMany({
-    ids: idsToDelete
-  })
-  return { txid: result.txid } // Single txid for batch operation
-}
-```
-
-```ts
-// Delete handler with optimistic rollback
-onDelete: async ({ transaction }) => {
-  const mutation = transaction.mutations[0]
-  try {
-    const result = await api.deleteTodo(mutation.original.id)
-    return { txid: result.txid }
-  } catch (error) {
-    // Transaction will automatically rollback optimistic changes
-    console.error('Delete failed, rolling back:', error)
-    throw error
-  }
-}
-```
-
-***
-
-### onInsert()?
-
-```ts
-optional onInsert: (params) => Promise<{
-  txid: number | number[];
-}>;
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:141](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L141)
-
-Optional asynchronous handler function called before an insert operation
-Must return an object containing a txid number or array of txids
-
-#### Parameters
-
-##### params
-
-`InsertMutationFnParams`\<`ResolveType`\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-Object containing transaction and collection information
-
-#### Returns
-
-`Promise`\<\{
-  `txid`: `number` \| `number`[];
- \}\>
-
-Promise resolving to an object with txid or txids
-
-#### Examples
-
-```ts
-// Basic Electric insert handler - MUST return { txid: number }
-onInsert: async ({ transaction }) => {
-  const newItem = transaction.mutations[0].modified
-  const result = await api.todos.create({
-    data: newItem
-  })
-  return { txid: result.txid } // Required for Electric sync matching
-}
-```
-
-```ts
-// Insert handler with multiple items - return array of txids
-onInsert: async ({ transaction }) => {
-  const items = transaction.mutations.map(m => m.modified)
-  const results = await Promise.all(
-    items.map(item => api.todos.create({ data: item }))
-  )
-  return { txid: results.map(r => r.txid) } // Array of txids
-}
-```
-
-```ts
-// Insert handler with error handling
-onInsert: async ({ transaction }) => {
-  try {
-    const newItem = transaction.mutations[0].modified
-    const result = await api.createTodo(newItem)
-    return { txid: result.txid }
-  } catch (error) {
-    console.error('Insert failed:', error)
-    throw error // This will cause the transaction to fail
-  }
-}
-```
-
-```ts
-// Insert handler with batch operation - single txid
-onInsert: async ({ transaction }) => {
-  const items = transaction.mutations.map(m => m.modified)
-  const result = await api.todos.createMany({
-    data: items
-  })
-  return { txid: result.txid } // Single txid for batch operation
-}
-```
-
-***
-
-### onUpdate()?
-
-```ts
-optional onUpdate: (params) => Promise<{
-  txid: number | number[];
-}>;
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:189](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L189)
-
-Optional asynchronous handler function called before an update operation
-Must return an object containing a txid number or array of txids
-
-#### Parameters
-
-##### params
-
-`UpdateMutationFnParams`\<`ResolveType`\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-Object containing transaction and collection information
-
-#### Returns
-
-`Promise`\<\{
-  `txid`: `number` \| `number`[];
- \}\>
-
-Promise resolving to an object with txid or txids
-
-#### Examples
-
-```ts
-// Basic Electric update handler - MUST return { txid: number }
-onUpdate: async ({ transaction }) => {
-  const { original, changes } = transaction.mutations[0]
-  const result = await api.todos.update({
-    where: { id: original.id },
-    data: changes // Only the changed fields
-  })
-  return { txid: result.txid } // Required for Electric sync matching
-}
-```
-
-```ts
-// Update handler with multiple items - return array of txids
-onUpdate: async ({ transaction }) => {
-  const updates = await Promise.all(
-    transaction.mutations.map(m =>
-      api.todos.update({
-        where: { id: m.original.id },
-        data: m.changes
-      })
-    )
-  )
-  return { txid: updates.map(u => u.txid) } // Array of txids
-}
-```
-
-```ts
-// Update handler with optimistic rollback
-onUpdate: async ({ transaction }) => {
-  const mutation = transaction.mutations[0]
-  try {
-    const result = await api.updateTodo(mutation.original.id, mutation.changes)
-    return { txid: result.txid }
-  } catch (error) {
-    // Transaction will automatically rollback optimistic changes
-    console.error('Update failed, rolling back:', error)
-    throw error
-  }
-}
-```
-
-***
-
-### schema?
-
-```ts
-optional schema: TSchema;
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:89](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L89)
-
-***
-
-### shapeOptions
-
-```ts
-shapeOptions: ShapeStreamOptions<GetExtensions<ResolveType<TExplicit, TSchema, TFallback>>>;
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:81](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L81)
-
-Configuration options for the ElectricSQL ShapeStream
-
-***
-
-### sync?
-
-```ts
-optional sync: SyncConfig<ResolveType<TExplicit, TSchema, TFallback>, string | number>;
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:91](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L91)
diff --git a/docs/reference/electric-db-collection/interfaces/electriccollectionutils.md b/docs/reference/electric-db-collection/interfaces/electriccollectionutils.md
deleted file mode 100644
index 5dcfc48b6..000000000
--- a/docs/reference/electric-db-collection/interfaces/electriccollectionutils.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-id: ElectricCollectionUtils
-title: ElectricCollectionUtils
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: ElectricCollectionUtils
-
-Defined in: [packages/electric-db-collection/src/electric.ts:272](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L272)
-
-Electric collection utilities type
-
-## Extends
-
-- `UtilsRecord`
-
-## Indexable
-
-```ts
-[key: string]: Fn
-```
-
-## Properties
-
-### awaitTxId
-
-```ts
-awaitTxId: AwaitTxIdFn;
-```
-
-Defined in: [packages/electric-db-collection/src/electric.ts:273](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L273)
diff --git a/docs/reference/electric-db-collection/type-aliases/AwaitTxIdFn.md b/docs/reference/electric-db-collection/type-aliases/AwaitTxIdFn.md
new file mode 100644
index 000000000..0d7422b2b
--- /dev/null
+++ b/docs/reference/electric-db-collection/type-aliases/AwaitTxIdFn.md
@@ -0,0 +1,28 @@
+---
+id: AwaitTxIdFn
+title: AwaitTxIdFn
+---
+
+# Type Alias: AwaitTxIdFn()
+
+```ts
+type AwaitTxIdFn = (txId, timeout?) => Promise<boolean>;
+```
+
+Defined in: [packages/electric-db-collection/src/electric.ts:479](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L479)
+
+Type for the awaitTxId utility function
+
+## Parameters
+
+### txId
+
+[`Txid`](Txid.md)
+
+### timeout?
+
+`number`
+
+## Returns
+
+`Promise`\<`boolean`\>
diff --git a/docs/reference/electric-db-collection/type-aliases/txid.md b/docs/reference/electric-db-collection/type-aliases/Txid.md
similarity index 53%
rename from docs/reference/electric-db-collection/type-aliases/txid.md
rename to docs/reference/electric-db-collection/type-aliases/Txid.md
index ef5db6138..2133770f8 100644
--- a/docs/reference/electric-db-collection/type-aliases/txid.md
+++ b/docs/reference/electric-db-collection/type-aliases/Txid.md
@@ -3,14 +3,12 @@ id: Txid
 title: Txid
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: Txid
 
 ```ts
 type Txid = number;
 ```
 
-Defined in: [packages/electric-db-collection/src/electric.ts:37](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L37)
+Defined in: [packages/electric-db-collection/src/electric.ts:79](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/src/electric.ts#L79)
 
 Type representing a transaction ID in ElectricSQL
diff --git a/docs/reference/functions/add.md b/docs/reference/functions/add.md
index 0c1a7e674..767e7d8d1 100644
--- a/docs/reference/functions/add.md
+++ b/docs/reference/functions/add.md
@@ -3,26 +3,34 @@ id: add
 title: add
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: add()
 
 ```ts
-function add(left, right): BasicExpression<number>
+function add<T1, T2>(left, right): BinaryNumericReturnType<T1, T2>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:208](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L208)
+Defined in: [packages/db/src/query/builder/functions.ts:295](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L295)
+
+## Type Parameters
+
+### T1
+
+`T1` *extends* `unknown`
+
+### T2
+
+`T2` *extends* `unknown`
 
 ## Parameters
 
 ### left
 
-`number` | `BasicExpression`\<`number`\> | `RefProxy`\<`number`\> | `RefProxy`\<`undefined` \| `number`\>
+`T1`
 
 ### right
 
-`number` | `BasicExpression`\<`number`\> | `RefProxy`\<`number`\> | `RefProxy`\<`undefined` \| `number`\>
+`T2`
 
 ## Returns
 
-`BasicExpression`\<`number`\>
+`BinaryNumericReturnType`\<`T1`, `T2`\>
diff --git a/docs/reference/functions/and.md b/docs/reference/functions/and.md
index aab2ecf86..85a7304a1 100644
--- a/docs/reference/functions/and.md
+++ b/docs/reference/functions/and.md
@@ -3,17 +3,15 @@ id: and
 title: and
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: and()
 
 ## Call Signature
 
 ```ts
-function and(left, right): BasicExpression<boolean>
+function and(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:77](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L77)
+Defined in: [packages/db/src/query/builder/functions.ts:181](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L181)
 
 ### Parameters
 
@@ -27,7 +25,7 @@ Defined in: [packages/db/src/query/builder/functions.ts:77](https://github.com/T
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
@@ -35,10 +33,10 @@ Defined in: [packages/db/src/query/builder/functions.ts:77](https://github.com/T
 function and(
    left, 
    right, ...
-rest): BasicExpression<boolean>
+rest): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:81](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L81)
+Defined in: [packages/db/src/query/builder/functions.ts:185](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L185)
 
 ### Parameters
 
@@ -56,4 +54,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:81](https://github.com/T
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/avg.md b/docs/reference/functions/avg.md
index c8f9b3f4f..98b7f615a 100644
--- a/docs/reference/functions/avg.md
+++ b/docs/reference/functions/avg.md
@@ -3,22 +3,26 @@ id: avg
 title: avg
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: avg()
 
 ```ts
-function avg(arg): Aggregate<number>
+function avg<T>(arg): AggregateReturnType<T>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:229](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L229)
+Defined in: [packages/db/src/query/builder/functions.ts:311](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L311)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `unknown`
 
 ## Parameters
 
 ### arg
 
-`number` | `BasicExpression`\<`number`\> | `RefProxy`\<`number`\> | `RefProxy`\<`undefined` \| `number`\>
+`T`
 
 ## Returns
 
-`Aggregate`\<`number`\>
+`AggregateReturnType`\<`T`\>
diff --git a/docs/reference/functions/coalesce.md b/docs/reference/functions/coalesce.md
index f772f898f..2849b63e8 100644
--- a/docs/reference/functions/coalesce.md
+++ b/docs/reference/functions/coalesce.md
@@ -3,15 +3,13 @@ id: coalesce
 title: coalesce
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: coalesce()
 
 ```ts
-function coalesce(...args): BasicExpression<any>
+function coalesce(...args): BasicExpression<any>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:201](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L201)
+Defined in: [packages/db/src/query/builder/functions.ts:288](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L288)
 
 ## Parameters
 
@@ -21,4 +19,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:201](https://github.com/
 
 ## Returns
 
-`BasicExpression`\<`any`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`any`\>
diff --git a/docs/reference/functions/compileQuery.md b/docs/reference/functions/compileQuery.md
new file mode 100644
index 000000000..ae1e2e08a
--- /dev/null
+++ b/docs/reference/functions/compileQuery.md
@@ -0,0 +1,90 @@
+---
+id: compileQuery
+title: compileQuery
+---
+
+# Function: compileQuery()
+
+```ts
+function compileQuery(
+   rawQuery, 
+   inputs, 
+   collections, 
+   subscriptions, 
+   callbacks, 
+   lazySources, 
+   optimizableOrderByCollections, 
+   setWindowFn, 
+   cache, 
+   queryMapping): CompilationResult;
+```
+
+Defined in: [packages/db/src/query/compiler/index.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/query/compiler/index.ts#L85)
+
+Compiles a query IR into a D2 pipeline
+
+## Parameters
+
+### rawQuery
+
+[`QueryIR`](../@tanstack/namespaces/IR/interfaces/QueryIR.md)
+
+The query IR to compile
+
+### inputs
+
+`Record`\<`string`, [`KeyedStream`](../type-aliases/KeyedStream.md)\>
+
+Mapping of source aliases to input streams (e.g., `{ employee: input1, manager: input2 }`)
+
+### collections
+
+`Record`\<`string`, [`Collection`](../interfaces/Collection.md)\<`any`, `any`, `any`, `any`, `any`\>\>
+
+Mapping of collection IDs to Collection instances
+
+### subscriptions
+
+`Record`\<`string`, `CollectionSubscription`\>
+
+Mapping of source aliases to CollectionSubscription instances
+
+### callbacks
+
+`Record`\<`string`, `LazyCollectionCallbacks`\>
+
+Mapping of source aliases to lazy loading callbacks
+
+### lazySources
+
+`Set`\<`string`\>
+
+Set of source aliases that should load data lazily
+
+### optimizableOrderByCollections
+
+`Record`\<`string`, `OrderByOptimizationInfo`\>
+
+Map of collection IDs to order-by optimization info
+
+### setWindowFn
+
+(`windowFn`) => `void`
+
+### cache
+
+`QueryCache` = `...`
+
+Optional cache for compiled subqueries (used internally for recursion)
+
+### queryMapping
+
+`QueryMapping` = `...`
+
+Optional mapping from optimized queries to original queries
+
+## Returns
+
+`CompilationResult`
+
+A CompilationResult with the pipeline, source WHERE clauses, and alias metadata
diff --git a/docs/reference/functions/compilequery.md b/docs/reference/functions/compilequery.md
deleted file mode 100644
index 6e0291f25..000000000
--- a/docs/reference/functions/compilequery.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-id: compileQuery
-title: compileQuery
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: compileQuery()
-
-```ts
-function compileQuery(
-   rawQuery, 
-   inputs, 
-   cache, 
-   queryMapping): CompilationResult
-```
-
-Defined in: [packages/db/src/query/compiler/index.ts:46](https://github.com/TanStack/db/blob/main/packages/db/src/query/compiler/index.ts#L46)
-
-Compiles a query2 IR into a D2 pipeline
-
-## Parameters
-
-### rawQuery
-
-`QueryIR`
-
-The query IR to compile
-
-### inputs
-
-`Record`\<`string`, [`KeyedStream`](../../type-aliases/keyedstream.md)\>
-
-Mapping of collection names to input streams
-
-### cache
-
-`QueryCache` = `...`
-
-Optional cache for compiled subqueries (used internally for recursion)
-
-### queryMapping
-
-`QueryMapping` = `...`
-
-Optional mapping from optimized queries to original queries
-
-## Returns
-
-`CompilationResult`
-
-A CompilationResult with the pipeline and collection WHERE clauses
diff --git a/docs/reference/functions/concat.md b/docs/reference/functions/concat.md
index 0c57d805a..1da806bc5 100644
--- a/docs/reference/functions/concat.md
+++ b/docs/reference/functions/concat.md
@@ -3,15 +3,13 @@ id: concat
 title: concat
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: concat()
 
 ```ts
-function concat(...args): BasicExpression<string>
+function concat(...args): BasicExpression<string>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:192](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L192)
+Defined in: [packages/db/src/query/builder/functions.ts:279](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L279)
 
 ## Parameters
 
@@ -21,4 +19,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:192](https://github.com/
 
 ## Returns
 
-`BasicExpression`\<`string`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`string`\>
diff --git a/docs/reference/functions/count.md b/docs/reference/functions/count.md
index e826f62a8..ef1a990e9 100644
--- a/docs/reference/functions/count.md
+++ b/docs/reference/functions/count.md
@@ -3,15 +3,13 @@ id: count
 title: count
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: count()
 
 ```ts
-function count(arg): Aggregate<number>
+function count(arg): Aggregate<number>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:225](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L225)
+Defined in: [packages/db/src/query/builder/functions.ts:307](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L307)
 
 ## Parameters
 
@@ -21,4 +19,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:225](https://github.com/
 
 ## Returns
 
-`Aggregate`\<`number`\>
+[`Aggregate`](../@tanstack/namespaces/IR/classes/Aggregate.md)\<`number`\>
diff --git a/docs/reference/functions/createarraychangeproxy.md b/docs/reference/functions/createArrayChangeProxy.md
similarity index 67%
rename from docs/reference/functions/createarraychangeproxy.md
rename to docs/reference/functions/createArrayChangeProxy.md
index 206cbe340..79d80a31c 100644
--- a/docs/reference/functions/createarraychangeproxy.md
+++ b/docs/reference/functions/createArrayChangeProxy.md
@@ -3,21 +3,21 @@ id: createArrayChangeProxy
 title: createArrayChangeProxy
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: createArrayChangeProxy()
 
 ```ts
-function createArrayChangeProxy<T>(targets): object
+function createArrayChangeProxy<T>(targets): object;
 ```
 
-Defined in: [packages/db/src/proxy.ts:964](https://github.com/TanStack/db/blob/main/packages/db/src/proxy.ts#L964)
+Defined in: [packages/db/src/proxy.ts:1130](https://github.com/TanStack/db/blob/main/packages/db/src/proxy.ts#L1130)
 
 Creates proxies for an array of objects and tracks changes to each
 
 ## Type Parameters
 
-• **T** *extends* `object`
+### T
+
+`T` *extends* `object`
 
 ## Parameters
 
diff --git a/docs/reference/functions/createchangeproxy.md b/docs/reference/functions/createChangeProxy.md
similarity index 67%
rename from docs/reference/functions/createchangeproxy.md
rename to docs/reference/functions/createChangeProxy.md
index 21aa330c5..efc5b50b3 100644
--- a/docs/reference/functions/createchangeproxy.md
+++ b/docs/reference/functions/createChangeProxy.md
@@ -3,21 +3,21 @@ id: createChangeProxy
 title: createChangeProxy
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: createChangeProxy()
 
 ```ts
-function createChangeProxy<T>(target, parent?): object
+function createChangeProxy<T>(target, parent?): object;
 ```
 
-Defined in: [packages/db/src/proxy.ts:273](https://github.com/TanStack/db/blob/main/packages/db/src/proxy.ts#L273)
+Defined in: [packages/db/src/proxy.ts:628](https://github.com/TanStack/db/blob/main/packages/db/src/proxy.ts#L628)
 
 Creates a proxy that tracks changes to the target object
 
 ## Type Parameters
 
-• **T** *extends* `Record`\<`string` \| `symbol`, `any`\>
+### T
+
+`T` *extends* `Record`\<`string` \| `symbol`, `any`\>
 
 ## Parameters
 
diff --git a/docs/reference/functions/createCollection.md b/docs/reference/functions/createCollection.md
new file mode 100644
index 000000000..556471744
--- /dev/null
+++ b/docs/reference/functions/createCollection.md
@@ -0,0 +1,878 @@
+---
+id: createCollection
+title: createCollection
+---
+
+# Function: createCollection()
+
+## Call Signature
+
+```ts
+function createCollection<T, TKey, TUtils>(options): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>> & NonSingleResult;
+```
+
+Defined in: [packages/db/src/collection/index.ts:134](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L134)
+
+Creates a new Collection instance with the given configuration
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+The type of the key for the collection
+
+#### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+The utilities record type
+
+### Parameters
+
+#### options
+
+`Omit`\<[`CollectionConfig`](../interfaces/CollectionConfig.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `T`, `TUtils`\>, `"utils"`\> & `object` & [`NonSingleResult`](../type-aliases/NonSingleResult.md)
+
+Collection options with optional utilities
+
+### Returns
+
+[`Collection`](../interfaces/Collection.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `TUtils`, `T`, [`InferSchemaInput`](../type-aliases/InferSchemaInput.md)\<`T`\>\> & [`NonSingleResult`](../type-aliases/NonSingleResult.md)
+
+A new Collection with utilities exposed both at top level and under .utils
+
+### Examples
+
+```ts
+// Pattern 1: With operation handlers (direct collection calls)
+const todos = createCollection({
+  id: "todos",
+  getKey: (todo) => todo.id,
+  schema,
+  onInsert: async ({ transaction, collection }) => {
+    // Send to API
+    await api.createTodo(transaction.mutations[0].modified)
+  },
+  onUpdate: async ({ transaction, collection }) => {
+    await api.updateTodo(transaction.mutations[0].modified)
+  },
+  onDelete: async ({ transaction, collection }) => {
+    await api.deleteTodo(transaction.mutations[0].key)
+  },
+  sync: { sync: () => {} }
+})
+
+// Direct usage (handlers manage transactions)
+const tx = todos.insert({ id: "1", text: "Buy milk", completed: false })
+await tx.isPersisted.promise
+```
+
+```ts
+// Pattern 2: Manual transaction management
+const todos = createCollection({
+  getKey: (todo) => todo.id,
+  schema: todoSchema,
+  sync: { sync: () => {} }
+})
+
+// Explicit transaction usage
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle all mutations in transaction
+    await api.saveChanges(transaction.mutations)
+  }
+})
+
+tx.mutate(() => {
+  todos.insert({ id: "1", text: "Buy milk" })
+  todos.update("2", draft => { draft.completed = true })
+})
+
+await tx.isPersisted.promise
+```
+
+```ts
+// Using schema for type inference (preferred as it also gives you client side validation)
+const todoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  completed: z.boolean()
+})
+
+const todos = createCollection({
+  schema: todoSchema,
+  getKey: (todo) => todo.id,
+  sync: { sync: () => {} }
+})
+```
+
+## Call Signature
+
+```ts
+function createCollection<T, TKey, TUtils>(options): Collection<InferSchemaOutput<T>, TKey, Exclude<TUtils, undefined>, T, InferSchemaInput<T>> & NonSingleResult;
+```
+
+Defined in: [packages/db/src/collection/index.ts:151](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L151)
+
+Creates a new Collection instance with the given configuration
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+The type of the key for the collection
+
+#### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+The utilities record type
+
+### Parameters
+
+#### options
+
+[`CollectionConfig`](../interfaces/CollectionConfig.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `T`, `TUtils`\> & `object` & [`NonSingleResult`](../type-aliases/NonSingleResult.md)
+
+Collection options with optional utilities
+
+### Returns
+
+[`Collection`](../interfaces/Collection.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `Exclude`\<`TUtils`, `undefined`\>, `T`, [`InferSchemaInput`](../type-aliases/InferSchemaInput.md)\<`T`\>\> & [`NonSingleResult`](../type-aliases/NonSingleResult.md)
+
+A new Collection with utilities exposed both at top level and under .utils
+
+### Examples
+
+```ts
+// Pattern 1: With operation handlers (direct collection calls)
+const todos = createCollection({
+  id: "todos",
+  getKey: (todo) => todo.id,
+  schema,
+  onInsert: async ({ transaction, collection }) => {
+    // Send to API
+    await api.createTodo(transaction.mutations[0].modified)
+  },
+  onUpdate: async ({ transaction, collection }) => {
+    await api.updateTodo(transaction.mutations[0].modified)
+  },
+  onDelete: async ({ transaction, collection }) => {
+    await api.deleteTodo(transaction.mutations[0].key)
+  },
+  sync: { sync: () => {} }
+})
+
+// Direct usage (handlers manage transactions)
+const tx = todos.insert({ id: "1", text: "Buy milk", completed: false })
+await tx.isPersisted.promise
+```
+
+```ts
+// Pattern 2: Manual transaction management
+const todos = createCollection({
+  getKey: (todo) => todo.id,
+  schema: todoSchema,
+  sync: { sync: () => {} }
+})
+
+// Explicit transaction usage
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle all mutations in transaction
+    await api.saveChanges(transaction.mutations)
+  }
+})
+
+tx.mutate(() => {
+  todos.insert({ id: "1", text: "Buy milk" })
+  todos.update("2", draft => { draft.completed = true })
+})
+
+await tx.isPersisted.promise
+```
+
+```ts
+// Using schema for type inference (preferred as it also gives you client side validation)
+const todoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  completed: z.boolean()
+})
+
+const todos = createCollection({
+  schema: todoSchema,
+  getKey: (todo) => todo.id,
+  sync: { sync: () => {} }
+})
+```
+
+## Call Signature
+
+```ts
+function createCollection<T, TKey, TUtils>(options): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>> & SingleResult;
+```
+
+Defined in: [packages/db/src/collection/index.ts:169](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L169)
+
+Creates a new Collection instance with the given configuration
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+The type of the key for the collection
+
+#### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+The utilities record type
+
+### Parameters
+
+#### options
+
+`Omit`\<[`CollectionConfig`](../interfaces/CollectionConfig.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `T`, `TUtils`\>, `"utils"`\> & `object` & [`SingleResult`](../type-aliases/SingleResult.md)
+
+Collection options with optional utilities
+
+### Returns
+
+[`Collection`](../interfaces/Collection.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `TUtils`, `T`, [`InferSchemaInput`](../type-aliases/InferSchemaInput.md)\<`T`\>\> & [`SingleResult`](../type-aliases/SingleResult.md)
+
+A new Collection with utilities exposed both at top level and under .utils
+
+### Examples
+
+```ts
+// Pattern 1: With operation handlers (direct collection calls)
+const todos = createCollection({
+  id: "todos",
+  getKey: (todo) => todo.id,
+  schema,
+  onInsert: async ({ transaction, collection }) => {
+    // Send to API
+    await api.createTodo(transaction.mutations[0].modified)
+  },
+  onUpdate: async ({ transaction, collection }) => {
+    await api.updateTodo(transaction.mutations[0].modified)
+  },
+  onDelete: async ({ transaction, collection }) => {
+    await api.deleteTodo(transaction.mutations[0].key)
+  },
+  sync: { sync: () => {} }
+})
+
+// Direct usage (handlers manage transactions)
+const tx = todos.insert({ id: "1", text: "Buy milk", completed: false })
+await tx.isPersisted.promise
+```
+
+```ts
+// Pattern 2: Manual transaction management
+const todos = createCollection({
+  getKey: (todo) => todo.id,
+  schema: todoSchema,
+  sync: { sync: () => {} }
+})
+
+// Explicit transaction usage
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle all mutations in transaction
+    await api.saveChanges(transaction.mutations)
+  }
+})
+
+tx.mutate(() => {
+  todos.insert({ id: "1", text: "Buy milk" })
+  todos.update("2", draft => { draft.completed = true })
+})
+
+await tx.isPersisted.promise
+```
+
+```ts
+// Using schema for type inference (preferred as it also gives you client side validation)
+const todoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  completed: z.boolean()
+})
+
+const todos = createCollection({
+  schema: todoSchema,
+  getKey: (todo) => todo.id,
+  sync: { sync: () => {} }
+})
+```
+
+## Call Signature
+
+```ts
+function createCollection<T, TKey, TUtils>(options): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>> & SingleResult;
+```
+
+Defined in: [packages/db/src/collection/index.ts:185](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L185)
+
+Creates a new Collection instance with the given configuration
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+The type of the key for the collection
+
+#### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+The utilities record type
+
+### Parameters
+
+#### options
+
+[`CollectionConfig`](../interfaces/CollectionConfig.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `T`, `TUtils`\> & `object` & [`SingleResult`](../type-aliases/SingleResult.md)
+
+Collection options with optional utilities
+
+### Returns
+
+[`Collection`](../interfaces/Collection.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `TUtils`, `T`, [`InferSchemaInput`](../type-aliases/InferSchemaInput.md)\<`T`\>\> & [`SingleResult`](../type-aliases/SingleResult.md)
+
+A new Collection with utilities exposed both at top level and under .utils
+
+### Examples
+
+```ts
+// Pattern 1: With operation handlers (direct collection calls)
+const todos = createCollection({
+  id: "todos",
+  getKey: (todo) => todo.id,
+  schema,
+  onInsert: async ({ transaction, collection }) => {
+    // Send to API
+    await api.createTodo(transaction.mutations[0].modified)
+  },
+  onUpdate: async ({ transaction, collection }) => {
+    await api.updateTodo(transaction.mutations[0].modified)
+  },
+  onDelete: async ({ transaction, collection }) => {
+    await api.deleteTodo(transaction.mutations[0].key)
+  },
+  sync: { sync: () => {} }
+})
+
+// Direct usage (handlers manage transactions)
+const tx = todos.insert({ id: "1", text: "Buy milk", completed: false })
+await tx.isPersisted.promise
+```
+
+```ts
+// Pattern 2: Manual transaction management
+const todos = createCollection({
+  getKey: (todo) => todo.id,
+  schema: todoSchema,
+  sync: { sync: () => {} }
+})
+
+// Explicit transaction usage
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle all mutations in transaction
+    await api.saveChanges(transaction.mutations)
+  }
+})
+
+tx.mutate(() => {
+  todos.insert({ id: "1", text: "Buy milk" })
+  todos.update("2", draft => { draft.completed = true })
+})
+
+await tx.isPersisted.promise
+```
+
+```ts
+// Using schema for type inference (preferred as it also gives you client side validation)
+const todoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  completed: z.boolean()
+})
+
+const todos = createCollection({
+  schema: todoSchema,
+  getKey: (todo) => todo.id,
+  sync: { sync: () => {} }
+})
+```
+
+## Call Signature
+
+```ts
+function createCollection<T, TKey, TUtils>(options): Collection<T, TKey, TUtils, never, T> & NonSingleResult;
+```
+
+Defined in: [packages/db/src/collection/index.ts:198](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L198)
+
+Creates a new Collection instance with the given configuration
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number`
+
+The type of the key for the collection
+
+#### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+The utilities record type
+
+### Parameters
+
+#### options
+
+`Omit`\<[`CollectionConfig`](../interfaces/CollectionConfig.md)\<`T`, `TKey`, `never`, `TUtils`\>, `"utils"`\> & `object` & [`NonSingleResult`](../type-aliases/NonSingleResult.md)
+
+Collection options with optional utilities
+
+### Returns
+
+[`Collection`](../interfaces/Collection.md)\<`T`, `TKey`, `TUtils`, `never`, `T`\> & [`NonSingleResult`](../type-aliases/NonSingleResult.md)
+
+A new Collection with utilities exposed both at top level and under .utils
+
+### Examples
+
+```ts
+// Pattern 1: With operation handlers (direct collection calls)
+const todos = createCollection({
+  id: "todos",
+  getKey: (todo) => todo.id,
+  schema,
+  onInsert: async ({ transaction, collection }) => {
+    // Send to API
+    await api.createTodo(transaction.mutations[0].modified)
+  },
+  onUpdate: async ({ transaction, collection }) => {
+    await api.updateTodo(transaction.mutations[0].modified)
+  },
+  onDelete: async ({ transaction, collection }) => {
+    await api.deleteTodo(transaction.mutations[0].key)
+  },
+  sync: { sync: () => {} }
+})
+
+// Direct usage (handlers manage transactions)
+const tx = todos.insert({ id: "1", text: "Buy milk", completed: false })
+await tx.isPersisted.promise
+```
+
+```ts
+// Pattern 2: Manual transaction management
+const todos = createCollection({
+  getKey: (todo) => todo.id,
+  schema: todoSchema,
+  sync: { sync: () => {} }
+})
+
+// Explicit transaction usage
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle all mutations in transaction
+    await api.saveChanges(transaction.mutations)
+  }
+})
+
+tx.mutate(() => {
+  todos.insert({ id: "1", text: "Buy milk" })
+  todos.update("2", draft => { draft.completed = true })
+})
+
+await tx.isPersisted.promise
+```
+
+```ts
+// Using schema for type inference (preferred as it also gives you client side validation)
+const todoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  completed: z.boolean()
+})
+
+const todos = createCollection({
+  schema: todoSchema,
+  getKey: (todo) => todo.id,
+  sync: { sync: () => {} }
+})
+```
+
+## Call Signature
+
+```ts
+function createCollection<T, TKey, TUtils>(options): Collection<T, TKey, TUtils, never, T> & NonSingleResult;
+```
+
+Defined in: [packages/db/src/collection/index.ts:211](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L211)
+
+Creates a new Collection instance with the given configuration
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the key for the collection
+
+#### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md) = [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+The utilities record type
+
+### Parameters
+
+#### options
+
+[`CollectionConfig`](../interfaces/CollectionConfig.md)\<`T`, `TKey`, `never`, `TUtils`\> & `object` & [`NonSingleResult`](../type-aliases/NonSingleResult.md)
+
+Collection options with optional utilities
+
+### Returns
+
+[`Collection`](../interfaces/Collection.md)\<`T`, `TKey`, `TUtils`, `never`, `T`\> & [`NonSingleResult`](../type-aliases/NonSingleResult.md)
+
+A new Collection with utilities exposed both at top level and under .utils
+
+### Examples
+
+```ts
+// Pattern 1: With operation handlers (direct collection calls)
+const todos = createCollection({
+  id: "todos",
+  getKey: (todo) => todo.id,
+  schema,
+  onInsert: async ({ transaction, collection }) => {
+    // Send to API
+    await api.createTodo(transaction.mutations[0].modified)
+  },
+  onUpdate: async ({ transaction, collection }) => {
+    await api.updateTodo(transaction.mutations[0].modified)
+  },
+  onDelete: async ({ transaction, collection }) => {
+    await api.deleteTodo(transaction.mutations[0].key)
+  },
+  sync: { sync: () => {} }
+})
+
+// Direct usage (handlers manage transactions)
+const tx = todos.insert({ id: "1", text: "Buy milk", completed: false })
+await tx.isPersisted.promise
+```
+
+```ts
+// Pattern 2: Manual transaction management
+const todos = createCollection({
+  getKey: (todo) => todo.id,
+  schema: todoSchema,
+  sync: { sync: () => {} }
+})
+
+// Explicit transaction usage
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle all mutations in transaction
+    await api.saveChanges(transaction.mutations)
+  }
+})
+
+tx.mutate(() => {
+  todos.insert({ id: "1", text: "Buy milk" })
+  todos.update("2", draft => { draft.completed = true })
+})
+
+await tx.isPersisted.promise
+```
+
+```ts
+// Using schema for type inference (preferred as it also gives you client side validation)
+const todoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  completed: z.boolean()
+})
+
+const todos = createCollection({
+  schema: todoSchema,
+  getKey: (todo) => todo.id,
+  sync: { sync: () => {} }
+})
+```
+
+## Call Signature
+
+```ts
+function createCollection<T, TKey, TUtils>(options): Collection<T, TKey, TUtils, never, T> & SingleResult;
+```
+
+Defined in: [packages/db/src/collection/index.ts:223](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L223)
+
+Creates a new Collection instance with the given configuration
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the key for the collection
+
+#### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md) = [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+The utilities record type
+
+### Parameters
+
+#### options
+
+`Omit`\<[`CollectionConfig`](../interfaces/CollectionConfig.md)\<`T`, `TKey`, `never`, `TUtils`\>, `"utils"`\> & `object` & [`SingleResult`](../type-aliases/SingleResult.md)
+
+Collection options with optional utilities
+
+### Returns
+
+[`Collection`](../interfaces/Collection.md)\<`T`, `TKey`, `TUtils`, `never`, `T`\> & [`SingleResult`](../type-aliases/SingleResult.md)
+
+A new Collection with utilities exposed both at top level and under .utils
+
+### Examples
+
+```ts
+// Pattern 1: With operation handlers (direct collection calls)
+const todos = createCollection({
+  id: "todos",
+  getKey: (todo) => todo.id,
+  schema,
+  onInsert: async ({ transaction, collection }) => {
+    // Send to API
+    await api.createTodo(transaction.mutations[0].modified)
+  },
+  onUpdate: async ({ transaction, collection }) => {
+    await api.updateTodo(transaction.mutations[0].modified)
+  },
+  onDelete: async ({ transaction, collection }) => {
+    await api.deleteTodo(transaction.mutations[0].key)
+  },
+  sync: { sync: () => {} }
+})
+
+// Direct usage (handlers manage transactions)
+const tx = todos.insert({ id: "1", text: "Buy milk", completed: false })
+await tx.isPersisted.promise
+```
+
+```ts
+// Pattern 2: Manual transaction management
+const todos = createCollection({
+  getKey: (todo) => todo.id,
+  schema: todoSchema,
+  sync: { sync: () => {} }
+})
+
+// Explicit transaction usage
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle all mutations in transaction
+    await api.saveChanges(transaction.mutations)
+  }
+})
+
+tx.mutate(() => {
+  todos.insert({ id: "1", text: "Buy milk" })
+  todos.update("2", draft => { draft.completed = true })
+})
+
+await tx.isPersisted.promise
+```
+
+```ts
+// Using schema for type inference (preferred as it also gives you client side validation)
+const todoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  completed: z.boolean()
+})
+
+const todos = createCollection({
+  schema: todoSchema,
+  getKey: (todo) => todo.id,
+  sync: { sync: () => {} }
+})
+```
+
+## Call Signature
+
+```ts
+function createCollection<T, TKey, TUtils>(options): Collection<T, TKey, TUtils, never, T> & SingleResult;
+```
+
+Defined in: [packages/db/src/collection/index.ts:236](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L236)
+
+Creates a new Collection instance with the given configuration
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the key for the collection
+
+#### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md) = [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+The utilities record type
+
+### Parameters
+
+#### options
+
+[`CollectionConfig`](../interfaces/CollectionConfig.md)\<`T`, `TKey`, `never`, `TUtils`\> & `object` & [`SingleResult`](../type-aliases/SingleResult.md)
+
+Collection options with optional utilities
+
+### Returns
+
+[`Collection`](../interfaces/Collection.md)\<`T`, `TKey`, `TUtils`, `never`, `T`\> & [`SingleResult`](../type-aliases/SingleResult.md)
+
+A new Collection with utilities exposed both at top level and under .utils
+
+### Examples
+
+```ts
+// Pattern 1: With operation handlers (direct collection calls)
+const todos = createCollection({
+  id: "todos",
+  getKey: (todo) => todo.id,
+  schema,
+  onInsert: async ({ transaction, collection }) => {
+    // Send to API
+    await api.createTodo(transaction.mutations[0].modified)
+  },
+  onUpdate: async ({ transaction, collection }) => {
+    await api.updateTodo(transaction.mutations[0].modified)
+  },
+  onDelete: async ({ transaction, collection }) => {
+    await api.deleteTodo(transaction.mutations[0].key)
+  },
+  sync: { sync: () => {} }
+})
+
+// Direct usage (handlers manage transactions)
+const tx = todos.insert({ id: "1", text: "Buy milk", completed: false })
+await tx.isPersisted.promise
+```
+
+```ts
+// Pattern 2: Manual transaction management
+const todos = createCollection({
+  getKey: (todo) => todo.id,
+  schema: todoSchema,
+  sync: { sync: () => {} }
+})
+
+// Explicit transaction usage
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Handle all mutations in transaction
+    await api.saveChanges(transaction.mutations)
+  }
+})
+
+tx.mutate(() => {
+  todos.insert({ id: "1", text: "Buy milk" })
+  todos.update("2", draft => { draft.completed = true })
+})
+
+await tx.isPersisted.promise
+```
+
+```ts
+// Using schema for type inference (preferred as it also gives you client side validation)
+const todoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  completed: z.boolean()
+})
+
+const todos = createCollection({
+  schema: todoSchema,
+  getKey: (todo) => todo.id,
+  sync: { sync: () => {} }
+})
+```
diff --git a/docs/reference/functions/createlivequerycollection.md b/docs/reference/functions/createLiveQueryCollection.md
similarity index 62%
rename from docs/reference/functions/createlivequerycollection.md
rename to docs/reference/functions/createLiveQueryCollection.md
index 4e5bcfff0..55db713f5 100644
--- a/docs/reference/functions/createlivequerycollection.md
+++ b/docs/reference/functions/createLiveQueryCollection.md
@@ -3,35 +3,39 @@ id: createLiveQueryCollection
 title: createLiveQueryCollection
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: createLiveQueryCollection()
 
 ## Call Signature
 
 ```ts
-function createLiveQueryCollection<TContext, TResult>(query): Collection<TResult, string | number, {}>
+function createLiveQueryCollection<TContext, TResult>(query): CollectionForContext<TContext, TResult, {
+}> & object;
 ```
 
-Defined in: [packages/db/src/query/live-query-collection.ts:424](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L424)
+Defined in: [packages/db/src/query/live-query-collection.ts:115](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L115)
 
 Creates a live query collection directly
 
 ### Type Parameters
 
-• **TContext** *extends* [`Context`](../../interfaces/context.md)
+#### TContext
+
+`TContext` *extends* [`Context`](../interfaces/Context.md)
+
+#### TResult
 
-• **TResult** *extends* `object` = \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}
+`TResult` *extends* `object` = \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}
 
 ### Parameters
 
 #### query
 
-(`q`) => [`QueryBuilder`](../../type-aliases/querybuilder.md)\<`TContext`\>
+(`q`) => [`QueryBuilder`](../type-aliases/QueryBuilder.md)\<`TContext`\>
 
 ### Returns
 
-[`Collection`](../../interfaces/collection.md)\<`TResult`, `string` \| `number`, \{\}\>
+`CollectionForContext`\<`TContext`, `TResult`, \{
+\}\> & `object`
 
 ### Example
 
@@ -67,30 +71,39 @@ const searchResults = createLiveQueryCollection({
 ## Call Signature
 
 ```ts
-function createLiveQueryCollection<TContext, TResult, TUtils>(config): Collection<TResult, string | number, TUtils>
+function createLiveQueryCollection<TContext, TResult, TUtils>(config): CollectionForContext<TContext, TResult, {
+}> & object;
 ```
 
-Defined in: [packages/db/src/query/live-query-collection.ts:432](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L432)
+Defined in: [packages/db/src/query/live-query-collection.ts:125](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L125)
 
 Creates a live query collection directly
 
 ### Type Parameters
 
-• **TContext** *extends* [`Context`](../../interfaces/context.md)
+#### TContext
+
+`TContext` *extends* [`Context`](../interfaces/Context.md)
+
+#### TResult
+
+`TResult` *extends* `object` = \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}
 
-• **TResult** *extends* `object` = \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}
+#### TUtils
 
-• **TUtils** *extends* [`UtilsRecord`](../../type-aliases/utilsrecord.md) = \{\}
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md) = \{
+\}
 
 ### Parameters
 
 #### config
 
-[`LiveQueryCollectionConfig`](../../interfaces/livequerycollectionconfig.md)\<`TContext`, `TResult`\> & `object`
+[`LiveQueryCollectionConfig`](../interfaces/LiveQueryCollectionConfig.md)\<`TContext`, `TResult`\> & `object`
 
 ### Returns
 
-[`Collection`](../../interfaces/collection.md)\<`TResult`, `string` \| `number`, `TUtils`\>
+`CollectionForContext`\<`TContext`, `TResult`, \{
+\}\> & `object`
 
 ### Example
 
diff --git a/docs/reference/functions/createoptimisticaction.md b/docs/reference/functions/createOptimisticAction.md
similarity index 61%
rename from docs/reference/functions/createoptimisticaction.md
rename to docs/reference/functions/createOptimisticAction.md
index 01a815629..f01ae27db 100644
--- a/docs/reference/functions/createoptimisticaction.md
+++ b/docs/reference/functions/createOptimisticAction.md
@@ -3,15 +3,13 @@ id: createOptimisticAction
 title: createOptimisticAction
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: createOptimisticAction()
 
 ```ts
-function createOptimisticAction<TVariables>(options): (variables) => Transaction
+function createOptimisticAction<TVariables>(options): (variables) => Transaction;
 ```
 
-Defined in: [packages/db/src/optimistic-action.ts:41](https://github.com/TanStack/db/blob/main/packages/db/src/optimistic-action.ts#L41)
+Defined in: [packages/db/src/optimistic-action.ts:54](https://github.com/TanStack/db/blob/main/packages/db/src/optimistic-action.ts#L54)
 
 Creates an optimistic action function that applies local optimistic updates immediately
 before executing the actual mutation on the server.
@@ -20,9 +18,16 @@ This pattern allows for responsive UI updates while the actual mutation is in pr
 The optimistic update is applied via the `onMutate` callback, and the server mutation
 is executed via the `mutationFn`.
 
+**Important:** Inside your `mutationFn`, you must ensure that your server writes have synced back
+before you return, as the optimistic state is dropped when you return from the mutation function.
+You generally use collection-specific helpers to do this, such as Query's `utils.refetch()`,
+direct write APIs, or Electric's `utils.awaitTxId()`.
+
 ## Type Parameters
 
-• **TVariables** = `unknown`
+### TVariables
+
+`TVariables` = `unknown`
 
 The type of variables that will be passed to the action function
 
@@ -30,16 +35,18 @@ The type of variables that will be passed to the action function
 
 ### options
 
-[`CreateOptimisticActionsOptions`](../../interfaces/createoptimisticactionsoptions.md)\<`TVariables`\>
+[`CreateOptimisticActionsOptions`](../interfaces/CreateOptimisticActionsOptions.md)\<`TVariables`\>
 
 Configuration options for the optimistic action
 
 ## Returns
 
-`Function`
-
 A function that accepts variables of type TVariables and returns a Transaction
 
+```ts
+(variables): Transaction;
+```
+
 ### Parameters
 
 #### variables
@@ -48,7 +55,7 @@ A function that accepts variables of type TVariables and returns a Transaction
 
 ### Returns
 
-[`Transaction`](../../classes/transaction.md)
+[`Transaction`](../interfaces/Transaction.md)
 
 ## Example
 
@@ -68,7 +75,13 @@ const addTodo = createOptimisticAction<string>({
       method: 'POST',
       body: JSON.stringify({ text, completed: false }),
     })
-    return response.json()
+    const result = await response.json()
+
+    // IMPORTANT: Ensure server writes have synced back before returning
+    // This ensures the optimistic state can be safely discarded
+    await todoCollection.utils.refetch()
+
+    return result
   }
 })
 
diff --git a/docs/reference/functions/createPacedMutations.md b/docs/reference/functions/createPacedMutations.md
new file mode 100644
index 000000000..a51bd3a51
--- /dev/null
+++ b/docs/reference/functions/createPacedMutations.md
@@ -0,0 +1,98 @@
+---
+id: createPacedMutations
+title: createPacedMutations
+---
+
+# Function: createPacedMutations()
+
+```ts
+function createPacedMutations<TVariables, T>(config): (variables) => Transaction<T>;
+```
+
+Defined in: [packages/db/src/paced-mutations.ts:87](https://github.com/TanStack/db/blob/main/packages/db/src/paced-mutations.ts#L87)
+
+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.
+
+## Type Parameters
+
+### TVariables
+
+`TVariables` = `unknown`
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+## Parameters
+
+### config
+
+[`PacedMutationsConfig`](../interfaces/PacedMutationsConfig.md)\<`TVariables`, `T`\>
+
+Configuration including onMutate, mutationFn and strategy
+
+## Returns
+
+A function that accepts variables and returns a Transaction
+
+```ts
+(variables): Transaction<T>;
+```
+
+### Parameters
+
+#### variables
+
+`TVariables`
+
+### Returns
+
+[`Transaction`](../interfaces/Transaction.md)\<`T`\>
+
+## Examples
+
+```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 ({ 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
+```
+
+```ts
+// Queue strategy for sequential processing
+const addTodo = createPacedMutations<{ text: string }>({
+  onMutate: ({ text }) => {
+    collection.insert({ id: uuid(), text, completed: false })
+  },
+  mutationFn: async ({ transaction }) => {
+    await api.save(transaction.mutations)
+  },
+  strategy: queueStrategy({
+    wait: 200,
+    addItemsTo: 'back',
+    getItemsFrom: 'front'
+  })
+})
+```
diff --git a/docs/reference/functions/createtransaction.md b/docs/reference/functions/createTransaction.md
similarity index 74%
rename from docs/reference/functions/createtransaction.md
rename to docs/reference/functions/createTransaction.md
index a856e7788..e1207af82 100644
--- a/docs/reference/functions/createtransaction.md
+++ b/docs/reference/functions/createTransaction.md
@@ -3,33 +3,33 @@ id: createTransaction
 title: createTransaction
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: createTransaction()
 
 ```ts
-function createTransaction<T>(config): Transaction<T>
+function createTransaction<T>(config): Transaction<T>;
 ```
 
-Defined in: [packages/db/src/transactions.ts:74](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L74)
+Defined in: [packages/db/src/transactions.ts:156](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L156)
 
 Creates a new transaction for grouping multiple collection operations
 
 ## Type Parameters
 
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
 
 ## Parameters
 
 ### config
 
-[`TransactionConfig`](../../interfaces/transactionconfig.md)\<`T`\>
+[`TransactionConfig`](../interfaces/TransactionConfig.md)\<`T`\>
 
 Transaction configuration with mutation function
 
 ## Returns
 
-[`Transaction`](../../classes/transaction.md)\<`T`\>
+[`Transaction`](../interfaces/Transaction.md)\<`T`\>
 
 A new Transaction instance
 
diff --git a/docs/reference/functions/createcollection.md b/docs/reference/functions/createcollection.md
deleted file mode 100644
index f9450c188..000000000
--- a/docs/reference/functions/createcollection.md
+++ /dev/null
@@ -1,119 +0,0 @@
----
-id: createCollection
-title: createCollection
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: createCollection()
-
-```ts
-function createCollection<TExplicit, TKey, TUtils, TSchema, TFallback>(options): Collection<ResolveType<TExplicit, TSchema, TFallback>, TKey, TUtils, TSchema, ResolveInsertInput<TExplicit, TSchema, TFallback>>
-```
-
-Defined in: [packages/db/src/collection.ts:160](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L160)
-
-Creates a new Collection instance with the given configuration
-
-## Type Parameters
-
-• **TExplicit** = `unknown`
-
-The explicit type of items in the collection (highest priority)
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-The type of the key for the collection
-
-• **TUtils** *extends* [`UtilsRecord`](../../type-aliases/utilsrecord.md) = \{\}
-
-The utilities record type
-
-• **TSchema** *extends* `StandardSchemaV1`\<`unknown`, `unknown`\> = `StandardSchemaV1`\<`unknown`, `unknown`\>
-
-The schema type for validation and type inference (second priority)
-
-• **TFallback** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-The fallback type if no explicit or schema type is provided
-
-## Parameters
-
-### options
-
-[`CollectionConfig`](../../interfaces/collectionconfig.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>, `TKey`, `TSchema`, [`ResolveInsertInput`](../../type-aliases/resolveinsertinput.md)\<`TExplicit`, `TSchema`, `TFallback`\>\> & `object`
-
-Collection options with optional utilities
-
-## Returns
-
-[`Collection`](../../interfaces/collection.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>, `TKey`, `TUtils`, `TSchema`, [`ResolveInsertInput`](../../type-aliases/resolveinsertinput.md)\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-A new Collection with utilities exposed both at top level and under .utils
-
-## Examples
-
-```ts
-// Pattern 1: With operation handlers (direct collection calls)
-const todos = createCollection({
-  id: "todos",
-  getKey: (todo) => todo.id,
-  schema,
-  onInsert: async ({ transaction, collection }) => {
-    // Send to API
-    await api.createTodo(transaction.mutations[0].modified)
-  },
-  onUpdate: async ({ transaction, collection }) => {
-    await api.updateTodo(transaction.mutations[0].modified)
-  },
-  onDelete: async ({ transaction, collection }) => {
-    await api.deleteTodo(transaction.mutations[0].key)
-  },
-  sync: { sync: () => {} }
-})
-
-// Direct usage (handlers manage transactions)
-const tx = todos.insert({ id: "1", text: "Buy milk", completed: false })
-await tx.isPersisted.promise
-```
-
-```ts
-// Pattern 2: Manual transaction management
-const todos = createCollection({
-  getKey: (todo) => todo.id,
-  schema: todoSchema,
-  sync: { sync: () => {} }
-})
-
-// Explicit transaction usage
-const tx = createTransaction({
-  mutationFn: async ({ transaction }) => {
-    // Handle all mutations in transaction
-    await api.saveChanges(transaction.mutations)
-  }
-})
-
-tx.mutate(() => {
-  todos.insert({ id: "1", text: "Buy milk" })
-  todos.update("2", draft => { draft.completed = true })
-})
-
-await tx.isPersisted.promise
-```
-
-```ts
-// Using schema for type inference (preferred as it also gives you client side validation)
-const todoSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  completed: z.boolean()
-})
-
-const todos = createCollection({
-  schema: todoSchema,
-  getKey: (todo) => todo.id,
-  sync: { sync: () => {} }
-})
-
-// Note: You must provide either an explicit type or a schema, but not both.
-```
diff --git a/docs/reference/functions/debounceStrategy.md b/docs/reference/functions/debounceStrategy.md
new file mode 100644
index 000000000..cb38e9688
--- /dev/null
+++ b/docs/reference/functions/debounceStrategy.md
@@ -0,0 +1,46 @@
+---
+id: debounceStrategy
+title: debounceStrategy
+---
+
+# Function: debounceStrategy()
+
+```ts
+function debounceStrategy(options): DebounceStrategy;
+```
+
+Defined in: [packages/db/src/strategies/debounceStrategy.ts:28](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/debounceStrategy.ts#L28)
+
+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.
+
+## Parameters
+
+### options
+
+[`DebounceStrategyOptions`](../interfaces/DebounceStrategyOptions.md)
+
+Configuration for the debounce behavior
+
+## Returns
+
+[`DebounceStrategy`](../interfaces/DebounceStrategy.md)
+
+A debounce strategy instance
+
+## Example
+
+```ts
+const mutate = usePacedMutations({
+  onMutate: (value) => {
+    collection.update(id, draft => { draft.value = value })
+  },
+  mutationFn: async ({ transaction }) => {
+    await api.save(transaction.mutations)
+  },
+  strategy: debounceStrategy({ wait: 500 })
+})
+```
diff --git a/docs/reference/functions/deepEquals.md b/docs/reference/functions/deepEquals.md
new file mode 100644
index 000000000..c95964693
--- /dev/null
+++ b/docs/reference/functions/deepEquals.md
@@ -0,0 +1,45 @@
+---
+id: deepEquals
+title: deepEquals
+---
+
+# Function: deepEquals()
+
+```ts
+function deepEquals(a, b): boolean;
+```
+
+Defined in: [packages/db/src/utils.ts:29](https://github.com/TanStack/db/blob/main/packages/db/src/utils.ts#L29)
+
+Deep equality function that compares two values recursively
+Handles primitives, objects, arrays, Date, RegExp, Map, Set, TypedArrays, and Temporal objects
+
+## Parameters
+
+### a
+
+`any`
+
+First value to compare
+
+### b
+
+`any`
+
+Second value to compare
+
+## Returns
+
+`boolean`
+
+True if the values are deeply equal, false otherwise
+
+## Example
+
+```typescript
+deepEquals({ a: 1, b: 2 }, { b: 2, a: 1 }) // true (property order doesn't matter)
+deepEquals([1, { x: 2 }], [1, { x: 2 }]) // true
+deepEquals({ a: 1 }, { a: 2 }) // false
+deepEquals(new Date('2023-01-01'), new Date('2023-01-01')) // true
+deepEquals(new Map([['a', 1]]), new Map([['a', 1]])) // true
+```
diff --git a/docs/reference/functions/eq.md b/docs/reference/functions/eq.md
index 18a1eed87..8890c3eac 100644
--- a/docs/reference/functions/eq.md
+++ b/docs/reference/functions/eq.md
@@ -3,79 +3,83 @@ id: eq
 title: eq
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: eq()
 
 ## Call Signature
 
 ```ts
-function eq<T>(left, right): BasicExpression<boolean>
+function eq<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:11](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L11)
+Defined in: [packages/db/src/query/builder/functions.ts:115](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L115)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`RefProxy`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 #### right
 
-`T` | `RefProxy`\<`T`\> | `BasicExpression`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function eq<T>(left, right): BasicExpression<boolean>
+function eq<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:15](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L15)
+Defined in: [packages/db/src/query/builder/functions.ts:119](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L119)
 
 ### Type Parameters
 
-• **T** *extends* `string` \| `number` \| `boolean`
+#### T
+
+`T` *extends* `string` \| `number` \| `boolean`
 
 ### Parameters
 
 #### left
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 #### right
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function eq<T>(left, right): BasicExpression<boolean>
+function eq<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:19](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L19)
+Defined in: [packages/db/src/query/builder/functions.ts:123](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L123)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`Aggregate`\<`T`\>
+[`Aggregate`](../@tanstack/namespaces/IR/classes/Aggregate.md)\<`T`\>
 
 #### right
 
@@ -83,4 +87,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:19](https://github.com/T
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/extractFieldPath.md b/docs/reference/functions/extractFieldPath.md
new file mode 100644
index 000000000..1738e66db
--- /dev/null
+++ b/docs/reference/functions/extractFieldPath.md
@@ -0,0 +1,36 @@
+---
+id: extractFieldPath
+title: extractFieldPath
+---
+
+# Function: extractFieldPath()
+
+```ts
+function extractFieldPath(expr): FieldPath | null;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:107](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L107)
+
+Extracts the field path from a PropRef expression.
+Returns null for non-ref expressions.
+
+## Parameters
+
+### expr
+
+`BasicExpression`
+
+The expression to extract from
+
+## Returns
+
+[`FieldPath`](../type-aliases/FieldPath.md) \| `null`
+
+The field path array, or null
+
+## Example
+
+```typescript
+const field = extractFieldPath(someExpression)
+// Returns: ['product', 'category']
+```
diff --git a/docs/reference/functions/extractSimpleComparisons.md b/docs/reference/functions/extractSimpleComparisons.md
new file mode 100644
index 000000000..39c3ff0db
--- /dev/null
+++ b/docs/reference/functions/extractSimpleComparisons.md
@@ -0,0 +1,50 @@
+---
+id: extractSimpleComparisons
+title: extractSimpleComparisons
+---
+
+# Function: extractSimpleComparisons()
+
+```ts
+function extractSimpleComparisons(expr): SimpleComparison[];
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:327](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L327)
+
+Extracts all simple comparisons from a WHERE expression.
+This is useful for simple APIs that only support basic filters.
+
+Note: This only works for simple AND-ed conditions and NOT-wrapped comparisons.
+Throws an error if it encounters unsupported operations like OR or complex nested expressions.
+
+NOT operators are flattened by prefixing the operator name (e.g., `not(eq(...))` becomes `not_eq`).
+
+## Parameters
+
+### expr
+
+The WHERE expression to parse
+
+`BasicExpression`\<`boolean`\> | `null` | `undefined`
+
+## Returns
+
+[`SimpleComparison`](../interfaces/SimpleComparison.md)[]
+
+Array of simple comparisons
+
+## Throws
+
+Error if expression contains OR or other unsupported operations
+
+## Example
+
+```typescript
+const comparisons = extractSimpleComparisons(where)
+// Returns: [
+//   { field: ['category'], operator: 'eq', value: 'electronics' },
+//   { field: ['price'], operator: 'lt', value: 100 },
+//   { field: ['email'], operator: 'isNull' }, // No value for null checks
+//   { field: ['status'], operator: 'not_eq', value: 'archived' }
+// ]
+```
diff --git a/docs/reference/functions/extractValue.md b/docs/reference/functions/extractValue.md
new file mode 100644
index 000000000..e48f9a9d6
--- /dev/null
+++ b/docs/reference/functions/extractValue.md
@@ -0,0 +1,36 @@
+---
+id: extractValue
+title: extractValue
+---
+
+# Function: extractValue()
+
+```ts
+function extractValue(expr): any;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:127](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L127)
+
+Extracts the value from a Value expression.
+Returns undefined for non-value expressions.
+
+## Parameters
+
+### expr
+
+`BasicExpression`
+
+The expression to extract from
+
+## Returns
+
+`any`
+
+The extracted value
+
+## Example
+
+```typescript
+const val = extractValue(someExpression)
+// Returns: 'electronics'
+```
diff --git a/docs/reference/functions/getactivetransaction.md b/docs/reference/functions/getActiveTransaction.md
similarity index 64%
rename from docs/reference/functions/getactivetransaction.md
rename to docs/reference/functions/getActiveTransaction.md
index be2050a51..b1488c8d0 100644
--- a/docs/reference/functions/getactivetransaction.md
+++ b/docs/reference/functions/getActiveTransaction.md
@@ -3,25 +3,23 @@ id: getActiveTransaction
 title: getActiveTransaction
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: getActiveTransaction()
 
 ```ts
 function getActiveTransaction(): 
-  | undefined
-| Transaction<Record<string, unknown>>
+  | Transaction<Record<string, unknown>>
+  | undefined;
 ```
 
-Defined in: [packages/db/src/transactions.ts:93](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L93)
+Defined in: [packages/db/src/transactions.ts:175](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L175)
 
 Gets the currently active ambient transaction, if any
 Used internally by collection operations to join existing transactions
 
 ## Returns
 
+  \| [`Transaction`](../interfaces/Transaction.md)\<`Record`\<`string`, `unknown`\>\>
   \| `undefined`
-  \| [`Transaction`](../../classes/transaction.md)\<`Record`\<`string`, `unknown`\>\>
 
 The active transaction or undefined if none is active
 
diff --git a/docs/reference/functions/gt.md b/docs/reference/functions/gt.md
index 3b97b1cbc..7a6cb1589 100644
--- a/docs/reference/functions/gt.md
+++ b/docs/reference/functions/gt.md
@@ -3,79 +3,83 @@ id: gt
 title: gt
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: gt()
 
 ## Call Signature
 
 ```ts
-function gt<T>(left, right): BasicExpression<boolean>
+function gt<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:24](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L24)
+Defined in: [packages/db/src/query/builder/functions.ts:128](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L128)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`RefProxy`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 #### right
 
-`T` | `RefProxy`\<`T`\> | `BasicExpression`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function gt<T>(left, right): BasicExpression<boolean>
+function gt<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:28](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L28)
+Defined in: [packages/db/src/query/builder/functions.ts:132](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L132)
 
 ### Type Parameters
 
-• **T** *extends* `string` \| `number`
+#### T
+
+`T` *extends* `string` \| `number`
 
 ### Parameters
 
 #### left
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 #### right
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function gt<T>(left, right): BasicExpression<boolean>
+function gt<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:32](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L32)
+Defined in: [packages/db/src/query/builder/functions.ts:136](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L136)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`Aggregate`\<`T`\>
+[`Aggregate`](../@tanstack/namespaces/IR/classes/Aggregate.md)\<`T`\>
 
 #### right
 
@@ -83,4 +87,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:32](https://github.com/T
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/gte.md b/docs/reference/functions/gte.md
index cf0c4d3e1..6a5f0c6e8 100644
--- a/docs/reference/functions/gte.md
+++ b/docs/reference/functions/gte.md
@@ -3,79 +3,83 @@ id: gte
 title: gte
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: gte()
 
 ## Call Signature
 
 ```ts
-function gte<T>(left, right): BasicExpression<boolean>
+function gte<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:37](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L37)
+Defined in: [packages/db/src/query/builder/functions.ts:141](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L141)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`RefProxy`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 #### right
 
-`T` | `RefProxy`\<`T`\> | `BasicExpression`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function gte<T>(left, right): BasicExpression<boolean>
+function gte<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:41](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L41)
+Defined in: [packages/db/src/query/builder/functions.ts:145](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L145)
 
 ### Type Parameters
 
-• **T** *extends* `string` \| `number`
+#### T
+
+`T` *extends* `string` \| `number`
 
 ### Parameters
 
 #### left
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 #### right
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function gte<T>(left, right): BasicExpression<boolean>
+function gte<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:45](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L45)
+Defined in: [packages/db/src/query/builder/functions.ts:149](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L149)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`Aggregate`\<`T`\>
+[`Aggregate`](../@tanstack/namespaces/IR/classes/Aggregate.md)\<`T`\>
 
 #### right
 
@@ -83,4 +87,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:45](https://github.com/T
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/ilike.md b/docs/reference/functions/ilike.md
index 1f884ac3c..7f422aa0c 100644
--- a/docs/reference/functions/ilike.md
+++ b/docs/reference/functions/ilike.md
@@ -3,26 +3,24 @@ id: ilike
 title: ilike
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: ilike()
 
 ```ts
-function ilike(left, right): BasicExpression<boolean>
+function ilike(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:144](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L144)
+Defined in: [packages/db/src/query/builder/functions.ts:252](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L252)
 
 ## Parameters
 
 ### left
 
-`string` | `RefProxy`\<`string`\> | `RefProxy`\<`null` \| `string`\> | `RefProxy`\<`undefined` \| `string`\> | `BasicExpression`\<`string`\>
+`StringLike`
 
 ### right
 
-`string` | `RefProxy`\<`string`\> | `BasicExpression`\<`string`\>
+`StringLike`
 
 ## Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/inArray.md b/docs/reference/functions/inArray.md
new file mode 100644
index 000000000..5f93c467b
--- /dev/null
+++ b/docs/reference/functions/inArray.md
@@ -0,0 +1,26 @@
+---
+id: inArray
+title: inArray
+---
+
+# Function: inArray()
+
+```ts
+function inArray(value, array): BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/query/builder/functions.ts:237](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L237)
+
+## Parameters
+
+### value
+
+`any`
+
+### array
+
+`any`
+
+## Returns
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/inarray.md b/docs/reference/functions/inarray.md
deleted file mode 100644
index 12c1e9d11..000000000
--- a/docs/reference/functions/inarray.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-id: inArray
-title: inArray
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: inArray()
-
-```ts
-function inArray(value, array): BasicExpression<boolean>
-```
-
-Defined in: [packages/db/src/query/builder/functions.ts:124](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L124)
-
-## Parameters
-
-### value
-
-`any`
-
-### array
-
-`any`
-
-## Returns
-
-`BasicExpression`\<`boolean`\>
diff --git a/docs/reference/functions/isLimitSubset.md b/docs/reference/functions/isLimitSubset.md
new file mode 100644
index 000000000..5578b4b24
--- /dev/null
+++ b/docs/reference/functions/isLimitSubset.md
@@ -0,0 +1,46 @@
+---
+id: isLimitSubset
+title: isLimitSubset
+---
+
+# Function: isLimitSubset()
+
+```ts
+function isLimitSubset(subset, superset): boolean;
+```
+
+Defined in: [packages/db/src/query/predicate-utils.ts:771](https://github.com/TanStack/db/blob/main/packages/db/src/query/predicate-utils.ts#L771)
+
+Check if one limit is a subset of another.
+Returns true if the subset limit requirements are satisfied by the superset limit.
+
+Note: This function does NOT consider offset. For offset-aware subset checking,
+use `isOffsetLimitSubset` instead.
+
+## Parameters
+
+### subset
+
+The limit requirement to check
+
+`number` | `undefined`
+
+### superset
+
+The limit that might satisfy the requirement
+
+`number` | `undefined`
+
+## Returns
+
+`boolean`
+
+true if subset is satisfied by superset
+
+## Example
+
+```ts
+isLimitSubset(10, 20) // true (requesting 10 items when 20 are available)
+isLimitSubset(20, 10) // false (requesting 20 items when only 10 are available)
+isLimitSubset(10, undefined) // true (requesting 10 items when unlimited are available)
+```
diff --git a/docs/reference/functions/isNull.md b/docs/reference/functions/isNull.md
new file mode 100644
index 000000000..3b7576a6f
--- /dev/null
+++ b/docs/reference/functions/isNull.md
@@ -0,0 +1,22 @@
+---
+id: isNull
+title: isNull
+---
+
+# Function: isNull()
+
+```ts
+function isNull(value): BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/query/builder/functions.ts:233](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L233)
+
+## Parameters
+
+### value
+
+`any`
+
+## Returns
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/isOffsetLimitSubset.md b/docs/reference/functions/isOffsetLimitSubset.md
new file mode 100644
index 000000000..0844f2a99
--- /dev/null
+++ b/docs/reference/functions/isOffsetLimitSubset.md
@@ -0,0 +1,63 @@
+---
+id: isOffsetLimitSubset
+title: isOffsetLimitSubset
+---
+
+# Function: isOffsetLimitSubset()
+
+```ts
+function isOffsetLimitSubset(subset, superset): boolean;
+```
+
+Defined in: [packages/db/src/query/predicate-utils.ts:811](https://github.com/TanStack/db/blob/main/packages/db/src/query/predicate-utils.ts#L811)
+
+Check if one offset+limit range is a subset of another.
+Returns true if the subset range is fully contained within the superset range.
+
+A query with `{limit: 10, offset: 0}` loads rows [0, 10).
+A query with `{limit: 10, offset: 20}` loads rows [20, 30).
+
+For subset to be satisfied by superset:
+- Superset must start at or before subset (superset.offset <= subset.offset)
+- Superset must end at or after subset (superset.offset + superset.limit >= subset.offset + subset.limit)
+
+## Parameters
+
+### subset
+
+The offset+limit requirements to check
+
+#### limit?
+
+`number`
+
+#### offset?
+
+`number`
+
+### superset
+
+The offset+limit that might satisfy the requirements
+
+#### limit?
+
+`number`
+
+#### offset?
+
+`number`
+
+## Returns
+
+`boolean`
+
+true if subset range is fully contained within superset range
+
+## Example
+
+```ts
+isOffsetLimitSubset({ offset: 0, limit: 5 }, { offset: 0, limit: 10 }) // true
+isOffsetLimitSubset({ offset: 5, limit: 5 }, { offset: 0, limit: 10 }) // true (rows 5-9 within 0-9)
+isOffsetLimitSubset({ offset: 5, limit: 10 }, { offset: 0, limit: 10 }) // false (rows 5-14 exceed 0-9)
+isOffsetLimitSubset({ offset: 20, limit: 10 }, { offset: 0, limit: 10 }) // false (rows 20-29 outside 0-9)
+```
diff --git a/docs/reference/functions/isOrderBySubset.md b/docs/reference/functions/isOrderBySubset.md
new file mode 100644
index 000000000..525dbacc9
--- /dev/null
+++ b/docs/reference/functions/isOrderBySubset.md
@@ -0,0 +1,42 @@
+---
+id: isOrderBySubset
+title: isOrderBySubset
+---
+
+# Function: isOrderBySubset()
+
+```ts
+function isOrderBySubset(subset, superset): boolean;
+```
+
+Defined in: [packages/db/src/query/predicate-utils.ts:713](https://github.com/TanStack/db/blob/main/packages/db/src/query/predicate-utils.ts#L713)
+
+Check if one orderBy clause is a subset of another.
+Returns true if the subset ordering requirements are satisfied by the superset ordering.
+
+## Parameters
+
+### subset
+
+The ordering requirements to check
+
+[`OrderBy`](../@tanstack/namespaces/IR/type-aliases/OrderBy.md) | `undefined`
+
+### superset
+
+The ordering that might satisfy the requirements
+
+[`OrderBy`](../@tanstack/namespaces/IR/type-aliases/OrderBy.md) | `undefined`
+
+## Returns
+
+`boolean`
+
+true if subset is satisfied by superset
+
+## Example
+
+```ts
+// Subset is prefix of superset
+isOrderBySubset([{expr: age, asc}], [{expr: age, asc}, {expr: name, desc}]) // true
+```
diff --git a/docs/reference/functions/isPredicateSubset.md b/docs/reference/functions/isPredicateSubset.md
new file mode 100644
index 000000000..78d107235
--- /dev/null
+++ b/docs/reference/functions/isPredicateSubset.md
@@ -0,0 +1,44 @@
+---
+id: isPredicateSubset
+title: isPredicateSubset
+---
+
+# Function: isPredicateSubset()
+
+```ts
+function isPredicateSubset(subset, superset): boolean;
+```
+
+Defined in: [packages/db/src/query/predicate-utils.ts:854](https://github.com/TanStack/db/blob/main/packages/db/src/query/predicate-utils.ts#L854)
+
+Check if one predicate (where + orderBy + limit + offset) is a subset of another.
+Returns true if all aspects of the subset predicate are satisfied by the superset.
+
+## Parameters
+
+### subset
+
+[`LoadSubsetOptions`](../type-aliases/LoadSubsetOptions.md)
+
+The predicate requirements to check
+
+### superset
+
+[`LoadSubsetOptions`](../type-aliases/LoadSubsetOptions.md)
+
+The predicate that might satisfy the requirements
+
+## Returns
+
+`boolean`
+
+true if subset is satisfied by superset
+
+## Example
+
+```ts
+isPredicateSubset(
+  { where: gt(ref('age'), val(20)), limit: 10 },
+  { where: gt(ref('age'), val(10)), limit: 20 }
+) // true
+```
diff --git a/docs/reference/functions/isUndefined.md b/docs/reference/functions/isUndefined.md
new file mode 100644
index 000000000..8924d9cd1
--- /dev/null
+++ b/docs/reference/functions/isUndefined.md
@@ -0,0 +1,22 @@
+---
+id: isUndefined
+title: isUndefined
+---
+
+# Function: isUndefined()
+
+```ts
+function isUndefined(value): BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/query/builder/functions.ts:229](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L229)
+
+## Parameters
+
+### value
+
+`any`
+
+## Returns
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/isWhereSubset.md b/docs/reference/functions/isWhereSubset.md
new file mode 100644
index 000000000..4817c778e
--- /dev/null
+++ b/docs/reference/functions/isWhereSubset.md
@@ -0,0 +1,47 @@
+---
+id: isWhereSubset
+title: isWhereSubset
+---
+
+# Function: isWhereSubset()
+
+```ts
+function isWhereSubset(subset, superset): boolean;
+```
+
+Defined in: [packages/db/src/query/predicate-utils.ts:21](https://github.com/TanStack/db/blob/main/packages/db/src/query/predicate-utils.ts#L21)
+
+Check if one where clause is a logical subset of another.
+Returns true if the subset predicate is more restrictive than (or equal to) the superset predicate.
+
+## Parameters
+
+### subset
+
+The potentially more restrictive predicate
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\> | `undefined`
+
+### superset
+
+The potentially less restrictive predicate
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\> | `undefined`
+
+## Returns
+
+`boolean`
+
+true if subset logically implies superset
+
+## Examples
+
+```ts
+// age > 20 is subset of age > 10 (more restrictive)
+isWhereSubset(gt(ref('age'), val(20)), gt(ref('age'), val(10))) // true
+```
+
+```ts
+// age > 10 AND name = 'X' is subset of age > 10 (more conditions)
+isWhereSubset(and(gt(ref('age'), val(10)), eq(ref('name'), val('X'))), gt(ref('age'), val(10))) // true
+```
diff --git a/docs/reference/functions/length.md b/docs/reference/functions/length.md
index cd63f0846..93ae660bd 100644
--- a/docs/reference/functions/length.md
+++ b/docs/reference/functions/length.md
@@ -3,22 +3,26 @@ id: length
 title: length
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: length()
 
 ```ts
-function length(arg): BasicExpression<number>
+function length<T>(arg): NumericFunctionReturnType<T>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:178](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L178)
+Defined in: [packages/db/src/query/builder/functions.ts:273](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L273)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `unknown`
 
 ## Parameters
 
 ### arg
 
-`string` | `any`[] | `RefProxy`\<`string`\> | `RefProxy`\<`undefined` \| `string`\> | `BasicExpression`\<`string`\> | `RefProxy`\<`any`[]\> | `RefProxy`\<`undefined` \| `any`[]\> | `BasicExpression`\<`any`[]\>
+`T`
 
 ## Returns
 
-`BasicExpression`\<`number`\>
+`NumericFunctionReturnType`\<`T`\>
diff --git a/docs/reference/functions/like.md b/docs/reference/functions/like.md
index bc603d97c..fdaa7fc93 100644
--- a/docs/reference/functions/like.md
+++ b/docs/reference/functions/like.md
@@ -3,26 +3,24 @@ id: like
 title: like
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: like()
 
 ```ts
-function like(left, right): BasicExpression<boolean>
+function like(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:131](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L131)
+Defined in: [packages/db/src/query/builder/functions.ts:244](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L244)
 
 ## Parameters
 
 ### left
 
-`string` | `RefProxy`\<`string`\> | `RefProxy`\<`null` \| `string`\> | `RefProxy`\<`undefined` \| `string`\> | `BasicExpression`\<`string`\>
+`StringLike`
 
 ### right
 
-`string` | `RefProxy`\<`string`\> | `BasicExpression`\<`string`\>
+`StringLike`
 
 ## Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/livequerycollectionoptions.md b/docs/reference/functions/liveQueryCollectionOptions.md
similarity index 54%
rename from docs/reference/functions/livequerycollectionoptions.md
rename to docs/reference/functions/liveQueryCollectionOptions.md
index 0aec61d24..43427f374 100644
--- a/docs/reference/functions/livequerycollectionoptions.md
+++ b/docs/reference/functions/liveQueryCollectionOptions.md
@@ -3,35 +3,39 @@ id: liveQueryCollectionOptions
 title: liveQueryCollectionOptions
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: liveQueryCollectionOptions()
 
 ```ts
-function liveQueryCollectionOptions<TContext, TResult>(config): CollectionConfig<TResult>
+function liveQueryCollectionOptions<TContext, TResult>(config): CollectionConfigForContext<TContext, TResult, {
+}> & object;
 ```
 
-Defined in: [packages/db/src/query/live-query-collection.ts:117](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L117)
+Defined in: [packages/db/src/query/live-query-collection.ts:62](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L62)
 
 Creates live query collection options for use with createCollection
 
 ## Type Parameters
 
-• **TContext** *extends* [`Context`](../../interfaces/context.md)
+### TContext
+
+`TContext` *extends* [`Context`](../interfaces/Context.md)
+
+### TResult
 
-• **TResult** *extends* `object` = \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}
+`TResult` *extends* `object` = \{ \[K in string \| number \| symbol\]: (TContext\["result"\] extends object ? any\[any\] : TContext\["hasJoins"\] extends true ? TContext\["schema"\] : TContext\["schema"\]\[TContext\["fromSourceName"\]\])\[K\] \}
 
 ## Parameters
 
 ### config
 
-[`LiveQueryCollectionConfig`](../../interfaces/livequerycollectionconfig.md)\<`TContext`, `TResult`\>
+[`LiveQueryCollectionConfig`](../interfaces/LiveQueryCollectionConfig.md)\<`TContext`, `TResult`\>
 
 Configuration options for the live query collection
 
 ## Returns
 
-[`CollectionConfig`](../../interfaces/collectionconfig.md)\<`TResult`\>
+`CollectionConfigForContext`\<`TContext`, `TResult`, \{
+\}\> & `object`
 
 Collection options that can be passed to createCollection
 
diff --git a/docs/reference/functions/localOnlyCollectionOptions.md b/docs/reference/functions/localOnlyCollectionOptions.md
new file mode 100644
index 000000000..06ea87aff
--- /dev/null
+++ b/docs/reference/functions/localOnlyCollectionOptions.md
@@ -0,0 +1,230 @@
+---
+id: localOnlyCollectionOptions
+title: localOnlyCollectionOptions
+---
+
+# Function: localOnlyCollectionOptions()
+
+## Call Signature
+
+```ts
+function localOnlyCollectionOptions<T, TKey>(config): CollectionConfig<InferSchemaOutput<T>, TKey, T, UtilsRecord> & object & object;
+```
+
+Defined in: [packages/db/src/local-only.ts:149](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L149)
+
+Creates Local-only collection options for use with a standard Collection
+
+This is an in-memory collection that doesn't sync with external sources but uses a loopback sync config
+that immediately "syncs" all optimistic changes to the collection, making them permanent.
+Perfect for local-only data that doesn't need persistence or external synchronization.
+
+**Using with Manual Transactions:**
+
+For manual transactions, you must call `utils.acceptMutations()` in your transaction's `mutationFn`
+to persist changes made during `tx.mutate()`. This is necessary because local-only collections
+don't participate in the standard mutation handler flow for manual transactions.
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the key returned by getKey
+
+### Parameters
+
+#### config
+
+[`LocalOnlyCollectionConfig`](../interfaces/LocalOnlyCollectionConfig.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `T`, `TKey`\> & `object`
+
+Configuration options for the Local-only collection
+
+### Returns
+
+[`CollectionConfig`](../interfaces/CollectionConfig.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `T`, [`UtilsRecord`](../type-aliases/UtilsRecord.md)\> & `object` & `object`
+
+Collection options with utilities including acceptMutations
+
+### Examples
+
+```ts
+// Basic local-only collection
+const collection = createCollection(
+  localOnlyCollectionOptions({
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// Local-only collection with initial data
+const collection = createCollection(
+  localOnlyCollectionOptions({
+    getKey: (item) => item.id,
+    initialData: [
+      { id: 1, name: 'Item 1' },
+      { id: 2, name: 'Item 2' },
+    ],
+  })
+)
+```
+
+```ts
+// Local-only collection with mutation handlers
+const collection = createCollection(
+  localOnlyCollectionOptions({
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      console.log('Item inserted:', transaction.mutations[0].modified)
+      // Custom logic after insert
+    },
+  })
+)
+```
+
+```ts
+// Using with manual transactions
+const localData = createCollection(
+  localOnlyCollectionOptions({
+    getKey: (item) => item.id,
+  })
+)
+
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Use local data in API call
+    const localMutations = transaction.mutations.filter(m => m.collection === localData)
+    await api.save({ metadata: localMutations[0]?.modified })
+
+    // Persist local-only mutations after API success
+    localData.utils.acceptMutations(transaction)
+  }
+})
+
+tx.mutate(() => {
+  localData.insert({ id: 1, data: 'metadata' })
+  apiCollection.insert({ id: 2, data: 'main data' })
+})
+
+await tx.commit()
+```
+
+## Call Signature
+
+```ts
+function localOnlyCollectionOptions<T, TKey>(config): CollectionConfig<T, TKey, never, UtilsRecord> & object & object;
+```
+
+Defined in: [packages/db/src/local-only.ts:162](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L162)
+
+Creates Local-only collection options for use with a standard Collection
+
+This is an in-memory collection that doesn't sync with external sources but uses a loopback sync config
+that immediately "syncs" all optimistic changes to the collection, making them permanent.
+Perfect for local-only data that doesn't need persistence or external synchronization.
+
+**Using with Manual Transactions:**
+
+For manual transactions, you must call `utils.acceptMutations()` in your transaction's `mutationFn`
+to persist changes made during `tx.mutate()`. This is necessary because local-only collections
+don't participate in the standard mutation handler flow for manual transactions.
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+The schema type if a schema is provided, otherwise the type of items in the collection
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the key returned by getKey
+
+### Parameters
+
+#### config
+
+[`LocalOnlyCollectionConfig`](../interfaces/LocalOnlyCollectionConfig.md)\<`T`, `never`, `TKey`\> & `object`
+
+Configuration options for the Local-only collection
+
+### Returns
+
+[`CollectionConfig`](../interfaces/CollectionConfig.md)\<`T`, `TKey`, `never`, [`UtilsRecord`](../type-aliases/UtilsRecord.md)\> & `object` & `object`
+
+Collection options with utilities including acceptMutations
+
+### Examples
+
+```ts
+// Basic local-only collection
+const collection = createCollection(
+  localOnlyCollectionOptions({
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// Local-only collection with initial data
+const collection = createCollection(
+  localOnlyCollectionOptions({
+    getKey: (item) => item.id,
+    initialData: [
+      { id: 1, name: 'Item 1' },
+      { id: 2, name: 'Item 2' },
+    ],
+  })
+)
+```
+
+```ts
+// Local-only collection with mutation handlers
+const collection = createCollection(
+  localOnlyCollectionOptions({
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      console.log('Item inserted:', transaction.mutations[0].modified)
+      // Custom logic after insert
+    },
+  })
+)
+```
+
+```ts
+// Using with manual transactions
+const localData = createCollection(
+  localOnlyCollectionOptions({
+    getKey: (item) => item.id,
+  })
+)
+
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Use local data in API call
+    const localMutations = transaction.mutations.filter(m => m.collection === localData)
+    await api.save({ metadata: localMutations[0]?.modified })
+
+    // Persist local-only mutations after API success
+    localData.utils.acceptMutations(transaction)
+  }
+})
+
+tx.mutate(() => {
+  localData.insert({ id: 1, data: 'metadata' })
+  apiCollection.insert({ id: 2, data: 'main data' })
+})
+
+await tx.commit()
+```
diff --git a/docs/reference/functions/localStorageCollectionOptions.md b/docs/reference/functions/localStorageCollectionOptions.md
new file mode 100644
index 000000000..6ea5ecad0
--- /dev/null
+++ b/docs/reference/functions/localStorageCollectionOptions.md
@@ -0,0 +1,236 @@
+---
+id: localStorageCollectionOptions
+title: localStorageCollectionOptions
+---
+
+# Function: localStorageCollectionOptions()
+
+## Call Signature
+
+```ts
+function localStorageCollectionOptions<T, TKey>(config): CollectionConfig<InferSchemaOutput<T>, TKey, T, LocalStorageCollectionUtils> & object;
+```
+
+Defined in: [packages/db/src/local-storage.ts:316](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L316)
+
+Creates localStorage collection options for use with a standard Collection
+
+This function creates a collection that persists data to localStorage/sessionStorage
+and synchronizes changes across browser tabs using storage events.
+
+**Fallback Behavior:**
+
+When localStorage is not available (e.g., in server-side rendering environments),
+this function automatically falls back to an in-memory storage implementation.
+This prevents errors during module initialization and allows the collection to
+work in any environment, though data will not persist across page reloads or
+be shared across tabs when using the in-memory fallback.
+
+**Using with Manual Transactions:**
+
+For manual transactions, you must call `utils.acceptMutations()` in your transaction's `mutationFn`
+to persist changes made during `tx.mutate()`. This is necessary because local-storage collections
+don't participate in the standard mutation handler flow for manual transactions.
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### Parameters
+
+#### config
+
+[`LocalStorageCollectionConfig`](../interfaces/LocalStorageCollectionConfig.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `T`, `TKey`\> & `object`
+
+Configuration options for the localStorage collection
+
+### Returns
+
+[`CollectionConfig`](../interfaces/CollectionConfig.md)\<[`InferSchemaOutput`](../type-aliases/InferSchemaOutput.md)\<`T`\>, `TKey`, `T`, [`LocalStorageCollectionUtils`](../interfaces/LocalStorageCollectionUtils.md)\> & `object`
+
+Collection options with utilities including clearStorage, getStorageSize, and acceptMutations
+
+### Examples
+
+```ts
+// Basic localStorage collection
+const collection = createCollection(
+  localStorageCollectionOptions({
+    storageKey: 'todos',
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// localStorage collection with custom storage
+const collection = createCollection(
+  localStorageCollectionOptions({
+    storageKey: 'todos',
+    storage: window.sessionStorage, // Use sessionStorage instead
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// localStorage collection with mutation handlers
+const collection = createCollection(
+  localStorageCollectionOptions({
+    storageKey: 'todos',
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      console.log('Item inserted:', transaction.mutations[0].modified)
+    },
+  })
+)
+```
+
+```ts
+// Using with manual transactions
+const localSettings = createCollection(
+  localStorageCollectionOptions({
+    storageKey: 'user-settings',
+    getKey: (item) => item.id,
+  })
+)
+
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Use settings data in API call
+    const settingsMutations = transaction.mutations.filter(m => m.collection === localSettings)
+    await api.updateUserProfile({ settings: settingsMutations[0]?.modified })
+
+    // Persist local-storage mutations after API success
+    localSettings.utils.acceptMutations(transaction)
+  }
+})
+
+tx.mutate(() => {
+  localSettings.insert({ id: 'theme', value: 'dark' })
+  apiCollection.insert({ id: 2, data: 'profile data' })
+})
+
+await tx.commit()
+```
+
+## Call Signature
+
+```ts
+function localStorageCollectionOptions<T, TKey>(config): CollectionConfig<T, TKey, never, LocalStorageCollectionUtils> & object;
+```
+
+Defined in: [packages/db/src/local-storage.ts:336](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L336)
+
+Creates localStorage collection options for use with a standard Collection
+
+This function creates a collection that persists data to localStorage/sessionStorage
+and synchronizes changes across browser tabs using storage events.
+
+**Fallback Behavior:**
+
+When localStorage is not available (e.g., in server-side rendering environments),
+this function automatically falls back to an in-memory storage implementation.
+This prevents errors during module initialization and allows the collection to
+work in any environment, though data will not persist across page reloads or
+be shared across tabs when using the in-memory fallback.
+
+**Using with Manual Transactions:**
+
+For manual transactions, you must call `utils.acceptMutations()` in your transaction's `mutationFn`
+to persist changes made during `tx.mutate()`. This is necessary because local-storage collections
+don't participate in the standard mutation handler flow for manual transactions.
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### Parameters
+
+#### config
+
+[`LocalStorageCollectionConfig`](../interfaces/LocalStorageCollectionConfig.md)\<`T`, `never`, `TKey`\> & `object`
+
+Configuration options for the localStorage collection
+
+### Returns
+
+[`CollectionConfig`](../interfaces/CollectionConfig.md)\<`T`, `TKey`, `never`, [`LocalStorageCollectionUtils`](../interfaces/LocalStorageCollectionUtils.md)\> & `object`
+
+Collection options with utilities including clearStorage, getStorageSize, and acceptMutations
+
+### Examples
+
+```ts
+// Basic localStorage collection
+const collection = createCollection(
+  localStorageCollectionOptions({
+    storageKey: 'todos',
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// localStorage collection with custom storage
+const collection = createCollection(
+  localStorageCollectionOptions({
+    storageKey: 'todos',
+    storage: window.sessionStorage, // Use sessionStorage instead
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// localStorage collection with mutation handlers
+const collection = createCollection(
+  localStorageCollectionOptions({
+    storageKey: 'todos',
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      console.log('Item inserted:', transaction.mutations[0].modified)
+    },
+  })
+)
+```
+
+```ts
+// Using with manual transactions
+const localSettings = createCollection(
+  localStorageCollectionOptions({
+    storageKey: 'user-settings',
+    getKey: (item) => item.id,
+  })
+)
+
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Use settings data in API call
+    const settingsMutations = transaction.mutations.filter(m => m.collection === localSettings)
+    await api.updateUserProfile({ settings: settingsMutations[0]?.modified })
+
+    // Persist local-storage mutations after API success
+    localSettings.utils.acceptMutations(transaction)
+  }
+})
+
+tx.mutate(() => {
+  localSettings.insert({ id: 'theme', value: 'dark' })
+  apiCollection.insert({ id: 2, data: 'profile data' })
+})
+
+await tx.commit()
+```
diff --git a/docs/reference/functions/localonlycollectionoptions.md b/docs/reference/functions/localonlycollectionoptions.md
deleted file mode 100644
index 8e4842137..000000000
--- a/docs/reference/functions/localonlycollectionoptions.md
+++ /dev/null
@@ -1,198 +0,0 @@
----
-id: localOnlyCollectionOptions
-title: localOnlyCollectionOptions
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: localOnlyCollectionOptions()
-
-```ts
-function localOnlyCollectionOptions<TExplicit, TSchema, TFallback, TKey>(config): object
-```
-
-Defined in: [packages/db/src/local-only.ts:137](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L137)
-
-Creates Local-only collection options for use with a standard Collection
-
-This is an in-memory collection that doesn't sync with external sources but uses a loopback sync config
-that immediately "syncs" all optimistic changes to the collection, making them permanent.
-Perfect for local-only data that doesn't need persistence or external synchronization.
-
-## Type Parameters
-
-• **TExplicit** = `unknown`
-
-The explicit type of items in the collection (highest priority)
-
-• **TSchema** *extends* `StandardSchemaV1`\<`unknown`, `unknown`\> = `never`
-
-The schema type for validation and type inference (second priority)
-
-• **TFallback** *extends* `Record`\<`string`, `unknown`\> = `Record`\<`string`, `unknown`\>
-
-The fallback type if no explicit or schema type is provided
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-The type of the key returned by getKey
-
-## Parameters
-
-### config
-
-[`LocalOnlyCollectionConfig`](../../interfaces/localonlycollectionconfig.md)\<`TExplicit`, `TSchema`, `TFallback`, `TKey`\>
-
-Configuration options for the Local-only collection
-
-## Returns
-
-`object`
-
-Collection options with utilities (currently empty but follows the pattern)
-
-### gcTime
-
-```ts
-gcTime: number = 0;
-```
-
-### getKey()
-
-```ts
-getKey: (item) => TKey;
-```
-
-#### Parameters
-
-##### item
-
-[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>
-
-#### Returns
-
-`TKey`
-
-### id?
-
-```ts
-optional id: string;
-```
-
-Standard Collection configuration properties
-
-### onDelete()
-
-```ts
-onDelete: (params) => Promise<any> = wrappedOnDelete;
-```
-
-Wrapper for onDelete handler that also confirms the transaction immediately
-
-#### Parameters
-
-##### params
-
-[`DeleteMutationFnParams`](../../type-aliases/deletemutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>, `TKey`, [`LocalOnlyCollectionUtils`](../../interfaces/localonlycollectionutils.md)\>
-
-#### Returns
-
-`Promise`\<`any`\>
-
-### onInsert()
-
-```ts
-onInsert: (params) => Promise<any> = wrappedOnInsert;
-```
-
-Create wrapper handlers that call user handlers first, then confirm transactions
-Wraps the user's onInsert handler to also confirm the transaction immediately
-
-#### Parameters
-
-##### params
-
-[`InsertMutationFnParams`](../../type-aliases/insertmutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>, `TKey`, [`LocalOnlyCollectionUtils`](../../interfaces/localonlycollectionutils.md)\>
-
-#### Returns
-
-`Promise`\<`any`\>
-
-### onUpdate()
-
-```ts
-onUpdate: (params) => Promise<any> = wrappedOnUpdate;
-```
-
-Wrapper for onUpdate handler that also confirms the transaction immediately
-
-#### Parameters
-
-##### params
-
-[`UpdateMutationFnParams`](../../type-aliases/updatemutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>, `TKey`, [`LocalOnlyCollectionUtils`](../../interfaces/localonlycollectionutils.md)\>
-
-#### Returns
-
-`Promise`\<`any`\>
-
-### schema?
-
-```ts
-optional schema: TSchema;
-```
-
-### startSync
-
-```ts
-startSync: boolean = true;
-```
-
-### sync
-
-```ts
-sync: SyncConfig<ResolveType<TExplicit, TSchema, TFallback>, TKey> = syncResult.sync;
-```
-
-### utils
-
-```ts
-utils: LocalOnlyCollectionUtils;
-```
-
-## Examples
-
-```ts
-// Basic local-only collection
-const collection = createCollection(
-  localOnlyCollectionOptions({
-    getKey: (item) => item.id,
-  })
-)
-```
-
-```ts
-// Local-only collection with initial data
-const collection = createCollection(
-  localOnlyCollectionOptions({
-    getKey: (item) => item.id,
-    initialData: [
-      { id: 1, name: 'Item 1' },
-      { id: 2, name: 'Item 2' },
-    ],
-  })
-)
-```
-
-```ts
-// Local-only collection with mutation handlers
-const collection = createCollection(
-  localOnlyCollectionOptions({
-    getKey: (item) => item.id,
-    onInsert: async ({ transaction }) => {
-      console.log('Item inserted:', transaction.mutations[0].modified)
-      // Custom logic after insert
-    },
-  })
-)
-```
diff --git a/docs/reference/functions/localstoragecollectionoptions.md b/docs/reference/functions/localstoragecollectionoptions.md
deleted file mode 100644
index 082b1ad4a..000000000
--- a/docs/reference/functions/localstoragecollectionoptions.md
+++ /dev/null
@@ -1,195 +0,0 @@
----
-id: localStorageCollectionOptions
-title: localStorageCollectionOptions
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: localStorageCollectionOptions()
-
-```ts
-function localStorageCollectionOptions<TExplicit, TSchema, TFallback>(config): object
-```
-
-Defined in: [packages/db/src/local-storage.ts:205](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L205)
-
-Creates localStorage collection options for use with a standard Collection
-
-This function creates a collection that persists data to localStorage/sessionStorage
-and synchronizes changes across browser tabs using storage events.
-
-## Type Parameters
-
-• **TExplicit** = `unknown`
-
-The explicit type of items in the collection (highest priority)
-
-• **TSchema** *extends* `StandardSchemaV1`\<`unknown`, `unknown`\> = `never`
-
-The schema type for validation and type inference (second priority)
-
-• **TFallback** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-The fallback type if no explicit or schema type is provided
-
-## Parameters
-
-### config
-
-[`LocalStorageCollectionConfig`](../../interfaces/localstoragecollectionconfig.md)\<`TExplicit`, `TSchema`, `TFallback`\>
-
-Configuration options for the localStorage collection
-
-## Returns
-
-`object`
-
-Collection options with utilities including clearStorage and getStorageSize
-
-### getKey()
-
-```ts
-getKey: (item) => string | number;
-```
-
-#### Parameters
-
-##### item
-
-[`ResolveType`](../../type-aliases/resolvetype.md)
-
-#### Returns
-
-`string` \| `number`
-
-### id
-
-```ts
-id: string = collectionId;
-```
-
-### onDelete()
-
-```ts
-onDelete: (params) => Promise<any> = wrappedOnDelete;
-```
-
-#### Parameters
-
-##### params
-
-[`DeleteMutationFnParams`](../../type-aliases/deletemutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-#### Returns
-
-`Promise`\<`any`\>
-
-### onInsert()
-
-```ts
-onInsert: (params) => Promise<any> = wrappedOnInsert;
-```
-
-#### Parameters
-
-##### params
-
-[`InsertMutationFnParams`](../../type-aliases/insertmutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-#### Returns
-
-`Promise`\<`any`\>
-
-### onUpdate()
-
-```ts
-onUpdate: (params) => Promise<any> = wrappedOnUpdate;
-```
-
-#### Parameters
-
-##### params
-
-[`UpdateMutationFnParams`](../../type-aliases/updatemutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-#### Returns
-
-`Promise`\<`any`\>
-
-### schema?
-
-```ts
-optional schema: TSchema;
-```
-
-### sync
-
-```ts
-sync: SyncConfig<ResolveType<TExplicit, TSchema, TFallback>, string | number> & object;
-```
-
-#### Type declaration
-
-##### manualTrigger()?
-
-```ts
-optional manualTrigger: () => void;
-```
-
-###### Returns
-
-`void`
-
-### utils
-
-```ts
-utils: object;
-```
-
-#### utils.clearStorage
-
-```ts
-clearStorage: ClearStorageFn;
-```
-
-#### utils.getStorageSize
-
-```ts
-getStorageSize: GetStorageSizeFn;
-```
-
-## Examples
-
-```ts
-// Basic localStorage collection
-const collection = createCollection(
-  localStorageCollectionOptions({
-    storageKey: 'todos',
-    getKey: (item) => item.id,
-  })
-)
-```
-
-```ts
-// localStorage collection with custom storage
-const collection = createCollection(
-  localStorageCollectionOptions({
-    storageKey: 'todos',
-    storage: window.sessionStorage, // Use sessionStorage instead
-    getKey: (item) => item.id,
-  })
-)
-```
-
-```ts
-// localStorage collection with mutation handlers
-const collection = createCollection(
-  localStorageCollectionOptions({
-    storageKey: 'todos',
-    getKey: (item) => item.id,
-    onInsert: async ({ transaction }) => {
-      console.log('Item inserted:', transaction.mutations[0].modified)
-    },
-  })
-)
-```
diff --git a/docs/reference/functions/lower.md b/docs/reference/functions/lower.md
index 29c608f73..a2b6c0ab8 100644
--- a/docs/reference/functions/lower.md
+++ b/docs/reference/functions/lower.md
@@ -3,22 +3,26 @@ id: lower
 title: lower
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: lower()
 
 ```ts
-function lower(arg): BasicExpression<string>
+function lower<T>(arg): StringFunctionReturnType<T>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:168](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L168)
+Defined in: [packages/db/src/query/builder/functions.ts:267](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L267)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `unknown`
 
 ## Parameters
 
 ### arg
 
-`string` | `RefProxy`\<`string`\> | `RefProxy`\<`undefined` \| `string`\> | `BasicExpression`\<`string`\>
+`T`
 
 ## Returns
 
-`BasicExpression`\<`string`\>
+`StringFunctionReturnType`\<`T`\>
diff --git a/docs/reference/functions/lt.md b/docs/reference/functions/lt.md
index 78c62cdc1..b7c95cdf7 100644
--- a/docs/reference/functions/lt.md
+++ b/docs/reference/functions/lt.md
@@ -3,79 +3,83 @@ id: lt
 title: lt
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: lt()
 
 ## Call Signature
 
 ```ts
-function lt<T>(left, right): BasicExpression<boolean>
+function lt<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:50](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L50)
+Defined in: [packages/db/src/query/builder/functions.ts:154](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L154)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`RefProxy`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 #### right
 
-`T` | `RefProxy`\<`T`\> | `BasicExpression`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function lt<T>(left, right): BasicExpression<boolean>
+function lt<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:54](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L54)
+Defined in: [packages/db/src/query/builder/functions.ts:158](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L158)
 
 ### Type Parameters
 
-• **T** *extends* `string` \| `number`
+#### T
+
+`T` *extends* `string` \| `number`
 
 ### Parameters
 
 #### left
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 #### right
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function lt<T>(left, right): BasicExpression<boolean>
+function lt<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:58](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L58)
+Defined in: [packages/db/src/query/builder/functions.ts:162](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L162)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`Aggregate`\<`T`\>
+[`Aggregate`](../@tanstack/namespaces/IR/classes/Aggregate.md)\<`T`\>
 
 #### right
 
@@ -83,4 +87,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:58](https://github.com/T
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/lte.md b/docs/reference/functions/lte.md
index 8951b0e2e..d71cacef0 100644
--- a/docs/reference/functions/lte.md
+++ b/docs/reference/functions/lte.md
@@ -3,79 +3,83 @@ id: lte
 title: lte
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: lte()
 
 ## Call Signature
 
 ```ts
-function lte<T>(left, right): BasicExpression<boolean>
+function lte<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:63](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L63)
+Defined in: [packages/db/src/query/builder/functions.ts:167](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L167)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`RefProxy`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 #### right
 
-`T` | `RefProxy`\<`T`\> | `BasicExpression`\<`T`\>
+`ComparisonOperand`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function lte<T>(left, right): BasicExpression<boolean>
+function lte<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:67](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L67)
+Defined in: [packages/db/src/query/builder/functions.ts:171](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L171)
 
 ### Type Parameters
 
-• **T** *extends* `string` \| `number`
+#### T
+
+`T` *extends* `string` \| `number`
 
 ### Parameters
 
 #### left
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 #### right
 
-`T` | `BasicExpression`\<`T`\>
+`ComparisonOperandPrimitive`\<`T`\>
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
 ```ts
-function lte<T>(left, right): BasicExpression<boolean>
+function lte<T>(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:71](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L71)
+Defined in: [packages/db/src/query/builder/functions.ts:175](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L175)
 
 ### Type Parameters
 
-• **T**
+#### T
+
+`T`
 
 ### Parameters
 
 #### left
 
-`Aggregate`\<`T`\>
+[`Aggregate`](../@tanstack/namespaces/IR/classes/Aggregate.md)\<`T`\>
 
 #### right
 
@@ -83,4 +87,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:71](https://github.com/T
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/max.md b/docs/reference/functions/max.md
index 17cdee666..81889962b 100644
--- a/docs/reference/functions/max.md
+++ b/docs/reference/functions/max.md
@@ -3,22 +3,26 @@ id: max
 title: max
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: max()
 
 ```ts
-function max(arg): Aggregate<number>
+function max<T>(arg): AggregateReturnType<T>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:259](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L259)
+Defined in: [packages/db/src/query/builder/functions.ts:323](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L323)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `unknown`
 
 ## Parameters
 
 ### arg
 
-`number` | `BasicExpression`\<`number`\> | `RefProxy`\<`number`\> | `RefProxy`\<`undefined` \| `number`\>
+`T`
 
 ## Returns
 
-`Aggregate`\<`number`\>
+`AggregateReturnType`\<`T`\>
diff --git a/docs/reference/functions/min.md b/docs/reference/functions/min.md
index d6c89ce05..6335fff82 100644
--- a/docs/reference/functions/min.md
+++ b/docs/reference/functions/min.md
@@ -3,22 +3,26 @@ id: min
 title: min
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: min()
 
 ```ts
-function min(arg): Aggregate<number>
+function min<T>(arg): AggregateReturnType<T>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:249](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L249)
+Defined in: [packages/db/src/query/builder/functions.ts:319](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L319)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `unknown`
 
 ## Parameters
 
 ### arg
 
-`number` | `BasicExpression`\<`number`\> | `RefProxy`\<`number`\> | `RefProxy`\<`undefined` \| `number`\>
+`T`
 
 ## Returns
 
-`Aggregate`\<`number`\>
+`AggregateReturnType`\<`T`\>
diff --git a/docs/reference/functions/minusWherePredicates.md b/docs/reference/functions/minusWherePredicates.md
new file mode 100644
index 000000000..d86b411df
--- /dev/null
+++ b/docs/reference/functions/minusWherePredicates.md
@@ -0,0 +1,73 @@
+---
+id: minusWherePredicates
+title: minusWherePredicates
+---
+
+# Function: minusWherePredicates()
+
+```ts
+function minusWherePredicates(fromPredicate, subtractPredicate): 
+  | BasicExpression<boolean>
+  | null;
+```
+
+Defined in: [packages/db/src/query/predicate-utils.ts:338](https://github.com/TanStack/db/blob/main/packages/db/src/query/predicate-utils.ts#L338)
+
+Compute the difference between two where predicates: `fromPredicate AND NOT(subtractPredicate)`.
+Returns the simplified predicate, or null if the difference cannot be simplified
+(in which case the caller should fetch the full fromPredicate).
+
+## Parameters
+
+### fromPredicate
+
+The predicate to subtract from
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\> | `undefined`
+
+### subtractPredicate
+
+The predicate to subtract
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\> | `undefined`
+
+## Returns
+
+  \| [`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
+  \| `null`
+
+The simplified difference, or null if cannot be simplified
+
+## Examples
+
+```ts
+// Range difference
+minusWherePredicates(
+  gt(ref('age'), val(10)),      // age > 10
+  gt(ref('age'), val(20))       // age > 20
+) // → age > 10 AND age <= 20
+```
+
+```ts
+// Set difference
+minusWherePredicates(
+  inOp(ref('status'), ['A', 'B', 'C', 'D']),  // status IN ['A','B','C','D']
+  inOp(ref('status'), ['B', 'C'])             // status IN ['B','C']
+) // → status IN ['A', 'D']
+```
+
+```ts
+// Common conditions
+minusWherePredicates(
+  and(gt(ref('age'), val(10)), eq(ref('status'), val('active'))),  // age > 10 AND status = 'active'
+  and(gt(ref('age'), val(20)), eq(ref('status'), val('active')))   // age > 20 AND status = 'active'
+) // → age > 10 AND age <= 20 AND status = 'active'
+```
+
+```ts
+// Complete overlap - empty result
+minusWherePredicates(
+  gt(ref('age'), val(20)),     // age > 20
+  gt(ref('age'), val(10))      // age > 10
+) // → {type: 'val', value: false} (empty set)
+```
diff --git a/docs/reference/functions/not.md b/docs/reference/functions/not.md
index bbbb2fcf4..3a5214236 100644
--- a/docs/reference/functions/not.md
+++ b/docs/reference/functions/not.md
@@ -3,15 +3,13 @@ id: not
 title: not
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: not()
 
 ```ts
-function not(value): BasicExpression<boolean>
+function not(value): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:120](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L120)
+Defined in: [packages/db/src/query/builder/functions.ts:224](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L224)
 
 ## Parameters
 
@@ -21,4 +19,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:120](https://github.com/
 
 ## Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/or.md b/docs/reference/functions/or.md
index 27d089788..351e72ce8 100644
--- a/docs/reference/functions/or.md
+++ b/docs/reference/functions/or.md
@@ -3,17 +3,15 @@ id: or
 title: or
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: or()
 
 ## Call Signature
 
 ```ts
-function or(left, right): BasicExpression<boolean>
+function or(left, right): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:99](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L99)
+Defined in: [packages/db/src/query/builder/functions.ts:203](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L203)
 
 ### Parameters
 
@@ -27,7 +25,7 @@ Defined in: [packages/db/src/query/builder/functions.ts:99](https://github.com/T
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
 
 ## Call Signature
 
@@ -35,10 +33,10 @@ Defined in: [packages/db/src/query/builder/functions.ts:99](https://github.com/T
 function or(
    left, 
    right, ...
-rest): BasicExpression<boolean>
+rest): BasicExpression<boolean>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:103](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L103)
+Defined in: [packages/db/src/query/builder/functions.ts:207](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L207)
 
 ### Parameters
 
@@ -56,4 +54,4 @@ Defined in: [packages/db/src/query/builder/functions.ts:103](https://github.com/
 
 ### Returns
 
-`BasicExpression`\<`boolean`\>
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
diff --git a/docs/reference/functions/parseLoadSubsetOptions.md b/docs/reference/functions/parseLoadSubsetOptions.md
new file mode 100644
index 000000000..40e850e7f
--- /dev/null
+++ b/docs/reference/functions/parseLoadSubsetOptions.md
@@ -0,0 +1,68 @@
+---
+id: parseLoadSubsetOptions
+title: parseLoadSubsetOptions
+---
+
+# Function: parseLoadSubsetOptions()
+
+```ts
+function parseLoadSubsetOptions(options): object;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:499](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L499)
+
+Convenience function to get all LoadSubsetOptions in a pre-parsed format.
+Good starting point for simple use cases.
+
+## Parameters
+
+### options
+
+The LoadSubsetOptions from ctx.meta
+
+\{
+`limit?`: `number`;
+`orderBy?`: [`OrderBy`](../@tanstack/namespaces/IR/type-aliases/OrderBy.md);
+`where?`: `BasicExpression`\<`boolean`\>;
+\} | `null` | `undefined`
+
+## Returns
+
+`object`
+
+Pre-parsed filters, sorts, and limit
+
+### filters
+
+```ts
+filters: SimpleComparison[];
+```
+
+### limit?
+
+```ts
+optional limit: number;
+```
+
+### sorts
+
+```ts
+sorts: ParsedOrderBy[];
+```
+
+## Example
+
+```typescript
+queryFn: async (ctx) => {
+  const parsed = parseLoadSubsetOptions(ctx.meta?.loadSubsetOptions)
+
+  // Convert to your API format
+  return api.getProducts({
+    ...Object.fromEntries(
+      parsed.filters.map(f => [`${f.field.join('.')}_${f.operator}`, f.value])
+    ),
+    sort: parsed.sorts.map(s => `${s.field.join('.')}:${s.direction}`).join(','),
+    limit: parsed.limit
+  })
+}
+```
diff --git a/docs/reference/functions/parseOrderByExpression.md b/docs/reference/functions/parseOrderByExpression.md
new file mode 100644
index 000000000..2df1508c5
--- /dev/null
+++ b/docs/reference/functions/parseOrderByExpression.md
@@ -0,0 +1,38 @@
+---
+id: parseOrderByExpression
+title: parseOrderByExpression
+---
+
+# Function: parseOrderByExpression()
+
+```ts
+function parseOrderByExpression(orderBy): ParsedOrderBy[];
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:265](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L265)
+
+Parses an ORDER BY expression into a simple array of sort specifications.
+
+## Parameters
+
+### orderBy
+
+The ORDER BY expression array
+
+[`OrderBy`](../@tanstack/namespaces/IR/type-aliases/OrderBy.md) | `null` | `undefined`
+
+## Returns
+
+[`ParsedOrderBy`](../interfaces/ParsedOrderBy.md)[]
+
+Array of parsed order by specifications
+
+## Example
+
+```typescript
+const sorts = parseOrderByExpression(orderBy)
+// Returns: [
+//   { field: ['category'], direction: 'asc', nulls: 'last' },
+//   { field: ['price'], direction: 'desc', nulls: 'last' }
+// ]
+```
diff --git a/docs/reference/functions/parseWhereExpression.md b/docs/reference/functions/parseWhereExpression.md
new file mode 100644
index 000000000..792773811
--- /dev/null
+++ b/docs/reference/functions/parseWhereExpression.md
@@ -0,0 +1,71 @@
+---
+id: parseWhereExpression
+title: parseWhereExpression
+---
+
+# Function: parseWhereExpression()
+
+```ts
+function parseWhereExpression<T>(expr, options): T | null;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:201](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L201)
+
+Parses a WHERE expression into a custom format using provided handlers.
+
+This is the main helper for converting TanStack DB where clauses into your API's filter format.
+You provide handlers for each operator, and this function traverses the expression tree
+and calls the appropriate handlers.
+
+## Type Parameters
+
+### T
+
+`T` = `any`
+
+## Parameters
+
+### expr
+
+The WHERE expression to parse
+
+`BasicExpression`\<`boolean`\> | `null` | `undefined`
+
+### options
+
+[`ParseWhereOptions`](../interfaces/ParseWhereOptions.md)\<`T`\>
+
+Configuration with handler functions for each operator
+
+## Returns
+
+`T` \| `null`
+
+The parsed result in your custom format
+
+## Examples
+
+```typescript
+// REST API with query parameters
+const filters = parseWhereExpression(where, {
+  handlers: {
+    eq: (field, value) => ({ [field.join('.')]: value }),
+    lt: (field, value) => ({ [`${field.join('.')}_lt`]: value }),
+    gt: (field, value) => ({ [`${field.join('.')}_gt`]: value }),
+    and: (...filters) => Object.assign({}, ...filters),
+    or: (...filters) => ({ $or: filters })
+  }
+})
+// Returns: { category: 'electronics', price_lt: 100 }
+```
+
+```typescript
+// GraphQL where clause
+const where = parseWhereExpression(whereExpr, {
+  handlers: {
+    eq: (field, value) => ({ [field.join('_')]: { _eq: value } }),
+    lt: (field, value) => ({ [field.join('_')]: { _lt: value } }),
+    and: (...filters) => ({ _and: filters })
+  }
+})
+```
diff --git a/docs/reference/functions/queueStrategy.md b/docs/reference/functions/queueStrategy.md
new file mode 100644
index 000000000..b310dc239
--- /dev/null
+++ b/docs/reference/functions/queueStrategy.md
@@ -0,0 +1,69 @@
+---
+id: queueStrategy
+title: queueStrategy
+---
+
+# Function: queueStrategy()
+
+```ts
+function queueStrategy(options?): QueueStrategy;
+```
+
+Defined in: [packages/db/src/strategies/queueStrategy.ts:52](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/queueStrategy.ts#L52)
+
+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 attempted sequentially. Each transaction commit completes before
+the next one starts. Useful when data consistency is critical and
+every operation must be attempted in order.
+
+**Error handling behavior:**
+- If a mutation fails, it is NOT automatically retried - the transaction transitions to "failed" state
+- Failed mutations surface their error via `transaction.isPersisted.promise` (which will reject)
+- Subsequent mutations continue processing - a single failure does not block the queue
+- Each mutation is independent; there is no all-or-nothing transaction semantics
+
+## Parameters
+
+### options?
+
+[`QueueStrategyOptions`](../interfaces/QueueStrategyOptions.md)
+
+Configuration for queue behavior (FIFO/LIFO, timing, size limits)
+
+## Returns
+
+[`QueueStrategy`](../interfaces/QueueStrategy.md)
+
+A queue strategy instance
+
+## Examples
+
+```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'
+  })
+})
+```
+
+```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'
+  })
+})
+```
diff --git a/docs/reference/functions/sum.md b/docs/reference/functions/sum.md
index cebf3ce49..760550dff 100644
--- a/docs/reference/functions/sum.md
+++ b/docs/reference/functions/sum.md
@@ -3,22 +3,26 @@ id: sum
 title: sum
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: sum()
 
 ```ts
-function sum(arg): Aggregate<number>
+function sum<T>(arg): AggregateReturnType<T>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:239](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L239)
+Defined in: [packages/db/src/query/builder/functions.ts:315](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L315)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `unknown`
 
 ## Parameters
 
 ### arg
 
-`number` | `BasicExpression`\<`number`\> | `RefProxy`\<`number`\> | `RefProxy`\<`undefined` \| `number`\>
+`T`
 
 ## Returns
 
-`Aggregate`\<`number`\>
+`AggregateReturnType`\<`T`\>
diff --git a/docs/reference/functions/throttleStrategy.md b/docs/reference/functions/throttleStrategy.md
new file mode 100644
index 000000000..35c7aa07e
--- /dev/null
+++ b/docs/reference/functions/throttleStrategy.md
@@ -0,0 +1,65 @@
+---
+id: throttleStrategy
+title: throttleStrategy
+---
+
+# Function: throttleStrategy()
+
+```ts
+function throttleStrategy(options): ThrottleStrategy;
+```
+
+Defined in: [packages/db/src/strategies/throttleStrategy.ts:48](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/throttleStrategy.ts#L48)
+
+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.
+
+## Parameters
+
+### options
+
+[`ThrottleStrategyOptions`](../interfaces/ThrottleStrategyOptions.md)
+
+Configuration for throttle behavior
+
+## Returns
+
+[`ThrottleStrategy`](../interfaces/ThrottleStrategy.md)
+
+A throttle strategy instance
+
+## Examples
+
+```ts
+// Throttle slider updates to every 200ms
+const mutate = usePacedMutations({
+  onMutate: (volume) => {
+    settingsCollection.update('volume', draft => { draft.value = volume })
+  },
+  mutationFn: async ({ transaction }) => {
+    await api.updateVolume(transaction.mutations)
+  },
+  strategy: throttleStrategy({ wait: 200 })
+})
+```
+
+```ts
+// Throttle with leading and trailing execution
+const mutate = usePacedMutations({
+  onMutate: (data) => {
+    collection.update(id, draft => { Object.assign(draft, data) })
+  },
+  mutationFn: async ({ transaction }) => {
+    await api.save(transaction.mutations)
+  },
+  strategy: throttleStrategy({
+    wait: 500,
+    leading: true,
+    trailing: true
+  })
+})
+```
diff --git a/docs/reference/functions/unionWherePredicates.md b/docs/reference/functions/unionWherePredicates.md
new file mode 100644
index 000000000..ffd244a1c
--- /dev/null
+++ b/docs/reference/functions/unionWherePredicates.md
@@ -0,0 +1,42 @@
+---
+id: unionWherePredicates
+title: unionWherePredicates
+---
+
+# Function: unionWherePredicates()
+
+```ts
+function unionWherePredicates(predicates): BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/query/predicate-utils.ts:295](https://github.com/TanStack/db/blob/main/packages/db/src/query/predicate-utils.ts#L295)
+
+Combine multiple where predicates with OR logic (union).
+Returns a predicate that is satisfied when any input predicate is satisfied.
+Simplifies when possible (e.g., age > 10 OR age > 20 → age > 10).
+
+## Parameters
+
+### predicates
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>[]
+
+Array of where predicates to union
+
+## Returns
+
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)\<`boolean`\>
+
+Combined predicate representing the union
+
+## Examples
+
+```ts
+// Take least restrictive
+unionWherePredicates([gt(ref('age'), val(10)), gt(ref('age'), val(20))]) // age > 10
+```
+
+```ts
+// Combine equals into IN
+unionWherePredicates([eq(ref('age'), val(5)), eq(ref('age'), val(10))]) // age IN [5, 10]
+```
diff --git a/docs/reference/functions/upper.md b/docs/reference/functions/upper.md
index 98fc4d0e2..af4652235 100644
--- a/docs/reference/functions/upper.md
+++ b/docs/reference/functions/upper.md
@@ -3,22 +3,26 @@ id: upper
 title: upper
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: upper()
 
 ```ts
-function upper(arg): BasicExpression<string>
+function upper<T>(arg): StringFunctionReturnType<T>;
 ```
 
-Defined in: [packages/db/src/query/builder/functions.ts:158](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L158)
+Defined in: [packages/db/src/query/builder/functions.ts:261](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L261)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `unknown`
 
 ## Parameters
 
 ### arg
 
-`string` | `RefProxy`\<`string`\> | `RefProxy`\<`undefined` \| `string`\> | `BasicExpression`\<`string`\>
+`T`
 
 ## Returns
 
-`BasicExpression`\<`string`\>
+`StringFunctionReturnType`\<`T`\>
diff --git a/docs/reference/functions/walkExpression.md b/docs/reference/functions/walkExpression.md
new file mode 100644
index 000000000..9f5b412d0
--- /dev/null
+++ b/docs/reference/functions/walkExpression.md
@@ -0,0 +1,43 @@
+---
+id: walkExpression
+title: walkExpression
+---
+
+# Function: walkExpression()
+
+```ts
+function walkExpression(expr, visitor): void;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:150](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L150)
+
+Generic expression tree walker that visits each node in the expression.
+Useful for implementing custom parsing logic.
+
+## Parameters
+
+### expr
+
+The expression to walk
+
+`BasicExpression`\<`any`\> | `null` | `undefined`
+
+### visitor
+
+(`node`) => `void`
+
+Visitor function called for each node
+
+## Returns
+
+`void`
+
+## Example
+
+```typescript
+walkExpression(whereExpr, (node) => {
+  if (node.type === 'func' && node.name === 'eq') {
+    console.log('Found equality comparison')
+  }
+})
+```
diff --git a/docs/reference/functions/witharraychangetracking.md b/docs/reference/functions/withArrayChangeTracking.md
similarity index 71%
rename from docs/reference/functions/witharraychangetracking.md
rename to docs/reference/functions/withArrayChangeTracking.md
index b5d1a0e23..363f47c42 100644
--- a/docs/reference/functions/witharraychangetracking.md
+++ b/docs/reference/functions/withArrayChangeTracking.md
@@ -3,22 +3,22 @@ id: withArrayChangeTracking
 title: withArrayChangeTracking
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: withArrayChangeTracking()
 
 ```ts
-function withArrayChangeTracking<T>(targets, callback): Record<string | symbol, unknown>[]
+function withArrayChangeTracking<T>(targets, callback): Record<string | symbol, unknown>[];
 ```
 
-Defined in: [packages/db/src/proxy.ts:1005](https://github.com/TanStack/db/blob/main/packages/db/src/proxy.ts#L1005)
+Defined in: [packages/db/src/proxy.ts:1171](https://github.com/TanStack/db/blob/main/packages/db/src/proxy.ts#L1171)
 
 Creates proxies for an array of objects, passes them to a callback function,
 and returns the changes made by the callback for each object
 
 ## Type Parameters
 
-• **T** *extends* `object`
+### T
+
+`T` *extends* `object`
 
 ## Parameters
 
diff --git a/docs/reference/functions/withchangetracking.md b/docs/reference/functions/withChangeTracking.md
similarity index 69%
rename from docs/reference/functions/withchangetracking.md
rename to docs/reference/functions/withChangeTracking.md
index d8a81ea62..70ce03300 100644
--- a/docs/reference/functions/withchangetracking.md
+++ b/docs/reference/functions/withChangeTracking.md
@@ -3,22 +3,22 @@ id: withChangeTracking
 title: withChangeTracking
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Function: withChangeTracking()
 
 ```ts
-function withChangeTracking<T>(target, callback): Record<string | symbol, unknown>
+function withChangeTracking<T>(target, callback): Record<string | symbol, unknown>;
 ```
 
-Defined in: [packages/db/src/proxy.ts:986](https://github.com/TanStack/db/blob/main/packages/db/src/proxy.ts#L986)
+Defined in: [packages/db/src/proxy.ts:1152](https://github.com/TanStack/db/blob/main/packages/db/src/proxy.ts#L1152)
 
 Creates a proxy for an object, passes it to a callback function,
 and returns the changes made by the callback
 
 ## Type Parameters
 
-• **T** *extends* `object`
+### T
+
+`T` *extends* `object`
 
 ## Parameters
 
diff --git a/docs/reference/index.md b/docs/reference/index.md
index 36bb21b16..326486e10 100644
--- a/docs/reference/index.md
+++ b/docs/reference/index.md
@@ -3,204 +3,285 @@ id: "@tanstack/db"
 title: "@tanstack/db"
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # @tanstack/db
 
+## Namespaces
+
+- [IR](@tanstack/namespaces/IR/index.md)
+
 ## Classes
 
-- [AggregateFunctionNotInSelectError](../classes/aggregatefunctionnotinselecterror.md)
-- [BaseIndex](../classes/baseindex.md)
-- [BaseQueryBuilder](../classes/basequerybuilder.md)
-- [BTreeIndex](../classes/btreeindex.md)
-- [CannotCombineEmptyExpressionListError](../classes/cannotcombineemptyexpressionlisterror.md)
-- [CollectionConfigurationError](../classes/collectionconfigurationerror.md)
-- [CollectionImpl](../classes/collectionimpl.md)
-- [CollectionInErrorStateError](../classes/collectioninerrorstateerror.md)
-- [CollectionInputNotFoundError](../classes/collectioninputnotfounderror.md)
-- [CollectionIsInErrorStateError](../classes/collectionisinerrorstateerror.md)
-- [CollectionOperationError](../classes/collectionoperationerror.md)
-- [CollectionRequiresConfigError](../classes/collectionrequiresconfigerror.md)
-- [CollectionRequiresSyncConfigError](../classes/collectionrequiressyncconfigerror.md)
-- [CollectionStateError](../classes/collectionstateerror.md)
-- [DeleteKeyNotFoundError](../classes/deletekeynotfounderror.md)
-- [DistinctRequiresSelectError](../classes/distinctrequiresselecterror.md)
-- [DuplicateKeyError](../classes/duplicatekeyerror.md)
-- [DuplicateKeySyncError](../classes/duplicatekeysyncerror.md)
-- [EmptyReferencePathError](../classes/emptyreferencepatherror.md)
-- [GroupByError](../classes/groupbyerror.md)
-- [HavingRequiresGroupByError](../classes/havingrequiresgroupbyerror.md)
-- [IndexProxy](../classes/indexproxy.md)
-- [InvalidCollectionStatusTransitionError](../classes/invalidcollectionstatustransitionerror.md)
-- [InvalidJoinConditionSameTableError](../classes/invalidjoinconditionsametableerror.md)
-- [InvalidJoinConditionTableMismatchError](../classes/invalidjoinconditiontablemismatcherror.md)
-- [InvalidJoinConditionWrongTablesError](../classes/invalidjoinconditionwrongtableserror.md)
-- [InvalidSchemaError](../classes/invalidschemaerror.md)
-- [InvalidSourceError](../classes/invalidsourceerror.md)
-- [InvalidStorageDataFormatError](../classes/invalidstoragedataformaterror.md)
-- [InvalidStorageObjectFormatError](../classes/invalidstorageobjectformaterror.md)
-- [JoinConditionMustBeEqualityError](../classes/joinconditionmustbeequalityerror.md)
-- [JoinError](../classes/joinerror.md)
-- [KeyUpdateNotAllowedError](../classes/keyupdatenotallowederror.md)
-- [LazyIndexWrapper](../classes/lazyindexwrapper.md)
-- [LimitOffsetRequireOrderByError](../classes/limitoffsetrequireorderbyerror.md)
-- [LocalStorageCollectionError](../classes/localstoragecollectionerror.md)
-- [MissingDeleteHandlerError](../classes/missingdeletehandlererror.md)
-- [MissingHandlerError](../classes/missinghandlererror.md)
-- [MissingInsertHandlerError](../classes/missinginserthandlererror.md)
-- [MissingMutationFunctionError](../classes/missingmutationfunctionerror.md)
-- [MissingUpdateArgumentError](../classes/missingupdateargumenterror.md)
-- [MissingUpdateHandlerError](../classes/missingupdatehandlererror.md)
-- [NegativeActiveSubscribersError](../classes/negativeactivesubscriberserror.md)
-- [NoKeysPassedToDeleteError](../classes/nokeyspassedtodeleteerror.md)
-- [NoKeysPassedToUpdateError](../classes/nokeyspassedtoupdateerror.md)
-- [NonAggregateExpressionNotInGroupByError](../classes/nonaggregateexpressionnotingroupbyerror.md)
-- [NonRetriableError](../classes/nonretriableerror.md)
-- [NoPendingSyncTransactionCommitError](../classes/nopendingsynctransactioncommiterror.md)
-- [NoPendingSyncTransactionWriteError](../classes/nopendingsynctransactionwriteerror.md)
-- [NoStorageAvailableError](../classes/nostorageavailableerror.md)
-- [NoStorageEventApiError](../classes/nostorageeventapierror.md)
-- [OnlyOneSourceAllowedError](../classes/onlyonesourceallowederror.md)
-- [QueryBuilderError](../classes/querybuildererror.md)
-- [QueryCompilationError](../classes/querycompilationerror.md)
-- [QueryMustHaveFromClauseError](../classes/querymusthavefromclauseerror.md)
-- [QueryOptimizerError](../classes/queryoptimizererror.md)
-- [SchemaMustBeSynchronousError](../classes/schemamustbesynchronouserror.md)
-- [SchemaValidationError](../classes/schemavalidationerror.md)
-- [SerializationError](../classes/serializationerror.md)
-- [SortedMap](../classes/sortedmap.md)
-- [StorageError](../classes/storageerror.md)
-- [StorageKeyRequiredError](../classes/storagekeyrequirederror.md)
-- [SubQueryMustHaveFromClauseError](../classes/subquerymusthavefromclauseerror.md)
-- [SyncCleanupError](../classes/synccleanuperror.md)
-- [SyncTransactionAlreadyCommittedError](../classes/synctransactionalreadycommittederror.md)
-- [SyncTransactionAlreadyCommittedWriteError](../classes/synctransactionalreadycommittedwriteerror.md)
-- [TanStackDBError](../classes/tanstackdberror.md)
-- [Transaction](../classes/transaction.md)
-- [TransactionAlreadyCompletedRollbackError](../classes/transactionalreadycompletedrollbackerror.md)
-- [TransactionError](../classes/transactionerror.md)
-- [TransactionNotPendingCommitError](../classes/transactionnotpendingcommiterror.md)
-- [TransactionNotPendingMutateError](../classes/transactionnotpendingmutateerror.md)
-- [UndefinedKeyError](../classes/undefinedkeyerror.md)
-- [UnknownExpressionTypeError](../classes/unknownexpressiontypeerror.md)
-- [UnknownFunctionError](../classes/unknownfunctionerror.md)
-- [UnknownHavingExpressionTypeError](../classes/unknownhavingexpressiontypeerror.md)
-- [UnsupportedAggregateFunctionError](../classes/unsupportedaggregatefunctionerror.md)
-- [UnsupportedFromTypeError](../classes/unsupportedfromtypeerror.md)
-- [UnsupportedJoinSourceTypeError](../classes/unsupportedjoinsourcetypeerror.md)
-- [UnsupportedJoinTypeError](../classes/unsupportedjointypeerror.md)
-- [UpdateKeyNotFoundError](../classes/updatekeynotfounderror.md)
+- [AggregateFunctionNotInSelectError](classes/AggregateFunctionNotInSelectError.md)
+- [AggregateNotSupportedError](classes/AggregateNotSupportedError.md)
+- [BaseIndex](classes/BaseIndex.md)
+- [BaseQueryBuilder](classes/BaseQueryBuilder.md)
+- [BTreeIndex](classes/BTreeIndex.md)
+- [CannotCombineEmptyExpressionListError](classes/CannotCombineEmptyExpressionListError.md)
+- [CollectionConfigurationError](classes/CollectionConfigurationError.md)
+- [CollectionImpl](classes/CollectionImpl.md)
+- [CollectionInErrorStateError](classes/CollectionInErrorStateError.md)
+- [CollectionInputNotFoundError](classes/CollectionInputNotFoundError.md)
+- [CollectionIsInErrorStateError](classes/CollectionIsInErrorStateError.md)
+- [CollectionOperationError](classes/CollectionOperationError.md)
+- [CollectionRequiresConfigError](classes/CollectionRequiresConfigError.md)
+- [CollectionRequiresSyncConfigError](classes/CollectionRequiresSyncConfigError.md)
+- [CollectionStateError](classes/CollectionStateError.md)
+- [DeduplicatedLoadSubset](classes/DeduplicatedLoadSubset.md)
+- [DeleteKeyNotFoundError](classes/DeleteKeyNotFoundError.md)
+- [DistinctRequiresSelectError](classes/DistinctRequiresSelectError.md)
+- [DuplicateAliasInSubqueryError](classes/DuplicateAliasInSubqueryError.md)
+- [DuplicateDbInstanceError](classes/DuplicateDbInstanceError.md)
+- [DuplicateKeyError](classes/DuplicateKeyError.md)
+- [DuplicateKeySyncError](classes/DuplicateKeySyncError.md)
+- [EmptyReferencePathError](classes/EmptyReferencePathError.md)
+- [GroupByError](classes/GroupByError.md)
+- [HavingRequiresGroupByError](classes/HavingRequiresGroupByError.md)
+- [IndexProxy](classes/IndexProxy.md)
+- [InvalidCollectionStatusTransitionError](classes/InvalidCollectionStatusTransitionError.md)
+- [InvalidJoinCondition](classes/InvalidJoinCondition.md)
+- [InvalidJoinConditionLeftSourceError](classes/InvalidJoinConditionLeftSourceError.md)
+- [InvalidJoinConditionRightSourceError](classes/InvalidJoinConditionRightSourceError.md)
+- [InvalidJoinConditionSameSourceError](classes/InvalidJoinConditionSameSourceError.md)
+- [InvalidJoinConditionSourceMismatchError](classes/InvalidJoinConditionSourceMismatchError.md)
+- [InvalidKeyError](classes/InvalidKeyError.md)
+- [InvalidSchemaError](classes/InvalidSchemaError.md)
+- [InvalidSourceError](classes/InvalidSourceError.md)
+- [InvalidSourceTypeError](classes/InvalidSourceTypeError.md)
+- [InvalidStorageDataFormatError](classes/InvalidStorageDataFormatError.md)
+- [InvalidStorageObjectFormatError](classes/InvalidStorageObjectFormatError.md)
+- [InvalidWhereExpressionError](classes/InvalidWhereExpressionError.md)
+- [JoinCollectionNotFoundError](classes/JoinCollectionNotFoundError.md)
+- [JoinConditionMustBeEqualityError](classes/JoinConditionMustBeEqualityError.md)
+- [JoinError](classes/JoinError.md)
+- [KeyUpdateNotAllowedError](classes/KeyUpdateNotAllowedError.md)
+- [LazyIndexWrapper](classes/LazyIndexWrapper.md)
+- [LimitOffsetRequireOrderByError](classes/LimitOffsetRequireOrderByError.md)
+- [LocalStorageCollectionError](classes/LocalStorageCollectionError.md)
+- [MissingAliasInputsError](classes/MissingAliasInputsError.md)
+- [MissingDeleteHandlerError](classes/MissingDeleteHandlerError.md)
+- [MissingHandlerError](classes/MissingHandlerError.md)
+- [MissingInsertHandlerError](classes/MissingInsertHandlerError.md)
+- [MissingMutationFunctionError](classes/MissingMutationFunctionError.md)
+- [MissingUpdateArgumentError](classes/MissingUpdateArgumentError.md)
+- [MissingUpdateHandlerError](classes/MissingUpdateHandlerError.md)
+- [NegativeActiveSubscribersError](classes/NegativeActiveSubscribersError.md)
+- [NoKeysPassedToDeleteError](classes/NoKeysPassedToDeleteError.md)
+- [NoKeysPassedToUpdateError](classes/NoKeysPassedToUpdateError.md)
+- [NonAggregateExpressionNotInGroupByError](classes/NonAggregateExpressionNotInGroupByError.md)
+- [NonRetriableError](classes/NonRetriableError.md)
+- [NoPendingSyncTransactionCommitError](classes/NoPendingSyncTransactionCommitError.md)
+- [NoPendingSyncTransactionWriteError](classes/NoPendingSyncTransactionWriteError.md)
+- [OnlyOneSourceAllowedError](classes/OnlyOneSourceAllowedError.md)
+- [OnMutateMustBeSynchronousError](classes/OnMutateMustBeSynchronousError.md)
+- [QueryBuilderError](classes/QueryBuilderError.md)
+- [QueryCompilationError](classes/QueryCompilationError.md)
+- [QueryMustHaveFromClauseError](classes/QueryMustHaveFromClauseError.md)
+- [QueryOptimizerError](classes/QueryOptimizerError.md)
+- [SchemaMustBeSynchronousError](classes/SchemaMustBeSynchronousError.md)
+- [SchemaValidationError](classes/SchemaValidationError.md)
+- [SerializationError](classes/SerializationError.md)
+- [SetWindowRequiresOrderByError](classes/SetWindowRequiresOrderByError.md)
+- [SortedMap](classes/SortedMap.md)
+- [StorageError](classes/StorageError.md)
+- [StorageKeyRequiredError](classes/StorageKeyRequiredError.md)
+- [SubQueryMustHaveFromClauseError](classes/SubQueryMustHaveFromClauseError.md)
+- [SubscriptionNotFoundError](classes/SubscriptionNotFoundError.md)
+- [SyncCleanupError](classes/SyncCleanupError.md)
+- [SyncTransactionAlreadyCommittedError](classes/SyncTransactionAlreadyCommittedError.md)
+- [SyncTransactionAlreadyCommittedWriteError](classes/SyncTransactionAlreadyCommittedWriteError.md)
+- [TanStackDBError](classes/TanStackDBError.md)
+- [TransactionAlreadyCompletedRollbackError](classes/TransactionAlreadyCompletedRollbackError.md)
+- [TransactionError](classes/TransactionError.md)
+- [TransactionNotPendingCommitError](classes/TransactionNotPendingCommitError.md)
+- [TransactionNotPendingMutateError](classes/TransactionNotPendingMutateError.md)
+- [UndefinedKeyError](classes/UndefinedKeyError.md)
+- [UnknownExpressionTypeError](classes/UnknownExpressionTypeError.md)
+- [UnknownFunctionError](classes/UnknownFunctionError.md)
+- [UnknownHavingExpressionTypeError](classes/UnknownHavingExpressionTypeError.md)
+- [UnsupportedAggregateFunctionError](classes/UnsupportedAggregateFunctionError.md)
+- [UnsupportedFromTypeError](classes/UnsupportedFromTypeError.md)
+- [UnsupportedJoinSourceTypeError](classes/UnsupportedJoinSourceTypeError.md)
+- [UnsupportedJoinTypeError](classes/UnsupportedJoinTypeError.md)
+- [UpdateKeyNotFoundError](classes/UpdateKeyNotFoundError.md)
+- [WhereClauseConversionError](classes/WhereClauseConversionError.md)
 
 ## Interfaces
 
-- [BTreeIndexOptions](../interfaces/btreeindexoptions.md)
-- [ChangeMessage](../interfaces/changemessage.md)
-- [Collection](../interfaces/collection.md)
-- [CollectionConfig](../interfaces/collectionconfig.md)
-- [Context](../interfaces/context.md)
-- [CreateOptimisticActionsOptions](../interfaces/createoptimisticactionsoptions.md)
-- [CurrentStateAsChangesOptions](../interfaces/currentstateaschangesoptions.md)
-- [IndexOptions](../interfaces/indexoptions.md)
-- [IndexStats](../interfaces/indexstats.md)
-- [InsertConfig](../interfaces/insertconfig.md)
-- [LiveQueryCollectionConfig](../interfaces/livequerycollectionconfig.md)
-- [LocalOnlyCollectionConfig](../interfaces/localonlycollectionconfig.md)
-- [LocalOnlyCollectionUtils](../interfaces/localonlycollectionutils.md)
-- [LocalStorageCollectionConfig](../interfaces/localstoragecollectionconfig.md)
-- [LocalStorageCollectionUtils](../interfaces/localstoragecollectionutils.md)
-- [OperationConfig](../interfaces/operationconfig.md)
-- [OptimisticChangeMessage](../interfaces/optimisticchangemessage.md)
-- [PendingMutation](../interfaces/pendingmutation.md)
-- [RangeQueryOptions](../interfaces/rangequeryoptions.md)
-- [SubscribeChangesOptions](../interfaces/subscribechangesoptions.md)
-- [SyncConfig](../interfaces/syncconfig.md)
-- [TransactionConfig](../interfaces/transactionconfig.md)
+- [BaseCollectionConfig](interfaces/BaseCollectionConfig.md)
+- [BaseStrategy](interfaces/BaseStrategy.md)
+- [BTreeIndexOptions](interfaces/BTreeIndexOptions.md)
+- [ChangeMessage](interfaces/ChangeMessage.md)
+- [Collection](interfaces/Collection.md)
+- [CollectionConfig](interfaces/CollectionConfig.md)
+- [CollectionLike](interfaces/CollectionLike.md)
+- [Context](interfaces/Context.md)
+- [CreateOptimisticActionsOptions](interfaces/CreateOptimisticActionsOptions.md)
+- [CurrentStateAsChangesOptions](interfaces/CurrentStateAsChangesOptions.md)
+- [DebounceStrategy](interfaces/DebounceStrategy.md)
+- [DebounceStrategyOptions](interfaces/DebounceStrategyOptions.md)
+- [IndexInterface](interfaces/IndexInterface.md)
+- [IndexOptions](interfaces/IndexOptions.md)
+- [IndexStats](interfaces/IndexStats.md)
+- [InsertConfig](interfaces/InsertConfig.md)
+- [LiveQueryCollectionConfig](interfaces/LiveQueryCollectionConfig.md)
+- [LocalOnlyCollectionConfig](interfaces/LocalOnlyCollectionConfig.md)
+- [LocalOnlyCollectionUtils](interfaces/LocalOnlyCollectionUtils.md)
+- [LocalStorageCollectionConfig](interfaces/LocalStorageCollectionConfig.md)
+- [LocalStorageCollectionUtils](interfaces/LocalStorageCollectionUtils.md)
+- [OperationConfig](interfaces/OperationConfig.md)
+- [PacedMutationsConfig](interfaces/PacedMutationsConfig.md)
+- [ParsedOrderBy](interfaces/ParsedOrderBy.md)
+- [Parser](interfaces/Parser.md)
+- [ParseWhereOptions](interfaces/ParseWhereOptions.md)
+- [PendingMutation](interfaces/PendingMutation.md)
+- [QueueStrategy](interfaces/QueueStrategy.md)
+- [QueueStrategyOptions](interfaces/QueueStrategyOptions.md)
+- [RangeQueryOptions](interfaces/RangeQueryOptions.md)
+- [SimpleComparison](interfaces/SimpleComparison.md)
+- [SubscribeChangesOptions](interfaces/SubscribeChangesOptions.md)
+- [SubscribeChangesSnapshotOptions](interfaces/SubscribeChangesSnapshotOptions.md)
+- [Subscription](interfaces/Subscription.md)
+- [SubscriptionStatusChangeEvent](interfaces/SubscriptionStatusChangeEvent.md)
+- [SubscriptionStatusEvent](interfaces/SubscriptionStatusEvent.md)
+- [SubscriptionUnsubscribedEvent](interfaces/SubscriptionUnsubscribedEvent.md)
+- [SyncConfig](interfaces/SyncConfig.md)
+- [ThrottleStrategy](interfaces/ThrottleStrategy.md)
+- [ThrottleStrategyOptions](interfaces/ThrottleStrategyOptions.md)
+- [Transaction](interfaces/Transaction.md)
+- [TransactionConfig](interfaces/TransactionConfig.md)
 
 ## Type Aliases
 
-- [ChangeListener](../type-aliases/changelistener.md)
-- [ChangesPayload](../type-aliases/changespayload.md)
-- [ClearStorageFn](../type-aliases/clearstoragefn.md)
-- [CollectionStatus](../type-aliases/collectionstatus.md)
-- [DeleteMutationFn](../type-aliases/deletemutationfn.md)
-- [DeleteMutationFnParams](../type-aliases/deletemutationfnparams.md)
-- [Fn](../type-aliases/fn.md)
-- [GetResult](../type-aliases/getresult.md)
-- [GetStorageSizeFn](../type-aliases/getstoragesizefn.md)
-- [IndexConstructor](../type-aliases/indexconstructor.md)
-- [IndexOperation](../type-aliases/indexoperation.md)
-- [IndexResolver](../type-aliases/indexresolver.md)
-- [InferSchemaInput](../type-aliases/inferschemainput.md)
-- [InferSchemaOutput](../type-aliases/inferschemaoutput.md)
-- [InitialQueryBuilder](../type-aliases/initialquerybuilder.md)
-- [InputRow](../type-aliases/inputrow.md)
-- [InsertMutationFn](../type-aliases/insertmutationfn.md)
-- [InsertMutationFnParams](../type-aliases/insertmutationfnparams.md)
-- [KeyedNamespacedRow](../type-aliases/keyednamespacedrow.md)
-- [KeyedStream](../type-aliases/keyedstream.md)
-- [MutationFn](../type-aliases/mutationfn.md)
-- [MutationFnParams](../type-aliases/mutationfnparams.md)
-- [NamespacedAndKeyedStream](../type-aliases/namespacedandkeyedstream.md)
-- [NamespacedRow](../type-aliases/namespacedrow.md)
-- [NonEmptyArray](../type-aliases/nonemptyarray.md)
-- [OperationType](../type-aliases/operationtype.md)
-- [QueryBuilder](../type-aliases/querybuilder.md)
-- [Ref](../type-aliases/ref.md)
-- [ResolveInsertInput](../type-aliases/resolveinsertinput.md)
-- [ResolveTransactionChanges](../type-aliases/resolvetransactionchanges.md)
-- [ResolveType](../type-aliases/resolvetype.md)
-- [ResultStream](../type-aliases/resultstream.md)
-- [Row](../type-aliases/row.md)
-- [Source](../type-aliases/source.md)
-- [StandardSchema](../type-aliases/standardschema.md)
-- [StandardSchemaAlias](../type-aliases/standardschemaalias.md)
-- [StorageApi](../type-aliases/storageapi.md)
-- [StorageEventApi](../type-aliases/storageeventapi.md)
-- [TransactionState](../type-aliases/transactionstate.md)
-- [TransactionWithMutations](../type-aliases/transactionwithmutations.md)
-- [UpdateMutationFn](../type-aliases/updatemutationfn.md)
-- [UpdateMutationFnParams](../type-aliases/updatemutationfnparams.md)
-- [UtilsRecord](../type-aliases/utilsrecord.md)
+- [ChangeListener](type-aliases/ChangeListener.md)
+- [ChangeMessageOrDeleteKeyMessage](type-aliases/ChangeMessageOrDeleteKeyMessage.md)
+- [ChangesPayload](type-aliases/ChangesPayload.md)
+- [CleanupFn](type-aliases/CleanupFn.md)
+- [ClearStorageFn](type-aliases/ClearStorageFn.md)
+- [CollectionConfigSingleRowOption](type-aliases/CollectionConfigSingleRowOption.md)
+- [CollectionStatus](type-aliases/CollectionStatus.md)
+- [CursorExpressions](type-aliases/CursorExpressions.md)
+- [DeleteKeyMessage](type-aliases/DeleteKeyMessage.md)
+- [DeleteMutationFn](type-aliases/DeleteMutationFn.md)
+- [DeleteMutationFnParams](type-aliases/DeleteMutationFnParams.md)
+- [ExtractContext](type-aliases/ExtractContext.md)
+- [FieldPath](type-aliases/FieldPath.md)
+- [Fn](type-aliases/Fn.md)
+- [GetResult](type-aliases/GetResult.md)
+- [GetStorageSizeFn](type-aliases/GetStorageSizeFn.md)
+- [IndexConstructor](type-aliases/IndexConstructor.md)
+- [IndexOperation](type-aliases/IndexOperation.md)
+- [IndexResolver](type-aliases/IndexResolver.md)
+- [InferResultType](type-aliases/InferResultType.md)
+- [InferSchemaInput](type-aliases/InferSchemaInput.md)
+- [InferSchemaOutput](type-aliases/InferSchemaOutput.md)
+- [InitialQueryBuilder](type-aliases/InitialQueryBuilder.md)
+- [InputRow](type-aliases/InputRow.md)
+- [InsertMutationFn](type-aliases/InsertMutationFn.md)
+- [InsertMutationFnParams](type-aliases/InsertMutationFnParams.md)
+- [KeyedNamespacedRow](type-aliases/KeyedNamespacedRow.md)
+- [KeyedStream](type-aliases/KeyedStream.md)
+- [LiveQueryCollectionUtils](type-aliases/LiveQueryCollectionUtils.md)
+- [LoadSubsetFn](type-aliases/LoadSubsetFn.md)
+- [LoadSubsetOptions](type-aliases/LoadSubsetOptions.md)
+- [MakeOptional](type-aliases/MakeOptional.md)
+- [MaybeSingleResult](type-aliases/MaybeSingleResult.md)
+- [MutationFn](type-aliases/MutationFn.md)
+- [MutationFnParams](type-aliases/MutationFnParams.md)
+- [NamespacedAndKeyedStream](type-aliases/NamespacedAndKeyedStream.md)
+- [NamespacedRow](type-aliases/NamespacedRow.md)
+- [NonEmptyArray](type-aliases/NonEmptyArray.md)
+- [NonSingleResult](type-aliases/NonSingleResult.md)
+- [OperationType](type-aliases/OperationType.md)
+- [OperatorName](type-aliases/OperatorName.md)
+- [OptimisticChangeMessage](type-aliases/OptimisticChangeMessage.md)
+- [QueryBuilder](type-aliases/QueryBuilder.md)
+- [QueryResult](type-aliases/QueryResult.md)
+- [Ref](type-aliases/Ref.md)
+- [ResolveTransactionChanges](type-aliases/ResolveTransactionChanges.md)
+- [ResultStream](type-aliases/ResultStream.md)
+- [Row](type-aliases/Row.md)
+- [SingleResult](type-aliases/SingleResult.md)
+- [Source](type-aliases/Source.md)
+- [StandardSchema](type-aliases/StandardSchema.md)
+- [StandardSchemaAlias](type-aliases/StandardSchemaAlias.md)
+- [StorageApi](type-aliases/StorageApi.md)
+- [StorageEventApi](type-aliases/StorageEventApi.md)
+- [Strategy](type-aliases/Strategy.md)
+- [StrategyOptions](type-aliases/StrategyOptions.md)
+- [StringCollationConfig](type-aliases/StringCollationConfig.md)
+- [SubscriptionEvents](type-aliases/SubscriptionEvents.md)
+- [SubscriptionStatus](type-aliases/SubscriptionStatus.md)
+- [SyncConfigRes](type-aliases/SyncConfigRes.md)
+- [SyncMode](type-aliases/SyncMode.md)
+- [TransactionState](type-aliases/TransactionState.md)
+- [TransactionWithMutations](type-aliases/TransactionWithMutations.md)
+- [UnloadSubsetFn](type-aliases/UnloadSubsetFn.md)
+- [UpdateMutationFn](type-aliases/UpdateMutationFn.md)
+- [UpdateMutationFnParams](type-aliases/UpdateMutationFnParams.md)
+- [UtilsRecord](type-aliases/UtilsRecord.md)
+- [WritableDeep](type-aliases/WritableDeep.md)
 
 ## Variables
 
-- [IndexOperation](../variables/indexoperation.md)
-- [Query](../variables/query.md)
+- [IndexOperation](variables/IndexOperation.md)
+- [operators](variables/operators.md)
+- [Query](variables/Query.md)
 
 ## Functions
 
-- [add](../functions/add.md)
-- [and](../functions/and.md)
-- [avg](../functions/avg.md)
-- [coalesce](../functions/coalesce.md)
-- [compileQuery](../functions/compilequery.md)
-- [concat](../functions/concat.md)
-- [count](../functions/count.md)
-- [createArrayChangeProxy](../functions/createarraychangeproxy.md)
-- [createChangeProxy](../functions/createchangeproxy.md)
-- [createCollection](../functions/createcollection.md)
-- [createLiveQueryCollection](../functions/createlivequerycollection.md)
-- [createOptimisticAction](../functions/createoptimisticaction.md)
-- [createTransaction](../functions/createtransaction.md)
-- [eq](../functions/eq.md)
-- [getActiveTransaction](../functions/getactivetransaction.md)
-- [gt](../functions/gt.md)
-- [gte](../functions/gte.md)
-- [ilike](../functions/ilike.md)
-- [inArray](../functions/inarray.md)
-- [length](../functions/length.md)
-- [like](../functions/like.md)
-- [liveQueryCollectionOptions](../functions/livequerycollectionoptions.md)
-- [localOnlyCollectionOptions](../functions/localonlycollectionoptions.md)
-- [localStorageCollectionOptions](../functions/localstoragecollectionoptions.md)
-- [lower](../functions/lower.md)
-- [lt](../functions/lt.md)
-- [lte](../functions/lte.md)
-- [max](../functions/max.md)
-- [min](../functions/min.md)
-- [not](../functions/not.md)
-- [or](../functions/or.md)
-- [sum](../functions/sum.md)
-- [upper](../functions/upper.md)
-- [withArrayChangeTracking](../functions/witharraychangetracking.md)
-- [withChangeTracking](../functions/withchangetracking.md)
+- [add](functions/add.md)
+- [and](functions/and.md)
+- [avg](functions/avg.md)
+- [coalesce](functions/coalesce.md)
+- [compileQuery](functions/compileQuery.md)
+- [concat](functions/concat.md)
+- [count](functions/count.md)
+- [createArrayChangeProxy](functions/createArrayChangeProxy.md)
+- [createChangeProxy](functions/createChangeProxy.md)
+- [createCollection](functions/createCollection.md)
+- [createLiveQueryCollection](functions/createLiveQueryCollection.md)
+- [createOptimisticAction](functions/createOptimisticAction.md)
+- [createPacedMutations](functions/createPacedMutations.md)
+- [createTransaction](functions/createTransaction.md)
+- [debounceStrategy](functions/debounceStrategy.md)
+- [deepEquals](functions/deepEquals.md)
+- [eq](functions/eq.md)
+- [extractFieldPath](functions/extractFieldPath.md)
+- [extractSimpleComparisons](functions/extractSimpleComparisons.md)
+- [extractValue](functions/extractValue.md)
+- [getActiveTransaction](functions/getActiveTransaction.md)
+- [gt](functions/gt.md)
+- [gte](functions/gte.md)
+- [ilike](functions/ilike.md)
+- [inArray](functions/inArray.md)
+- [isLimitSubset](functions/isLimitSubset.md)
+- [isNull](functions/isNull.md)
+- [isOffsetLimitSubset](functions/isOffsetLimitSubset.md)
+- [isOrderBySubset](functions/isOrderBySubset.md)
+- [isPredicateSubset](functions/isPredicateSubset.md)
+- [isUndefined](functions/isUndefined.md)
+- [isWhereSubset](functions/isWhereSubset.md)
+- [length](functions/length.md)
+- [like](functions/like.md)
+- [liveQueryCollectionOptions](functions/liveQueryCollectionOptions.md)
+- [localOnlyCollectionOptions](functions/localOnlyCollectionOptions.md)
+- [localStorageCollectionOptions](functions/localStorageCollectionOptions.md)
+- [lower](functions/lower.md)
+- [lt](functions/lt.md)
+- [lte](functions/lte.md)
+- [max](functions/max.md)
+- [min](functions/min.md)
+- [minusWherePredicates](functions/minusWherePredicates.md)
+- [not](functions/not.md)
+- [or](functions/or.md)
+- [parseLoadSubsetOptions](functions/parseLoadSubsetOptions.md)
+- [parseOrderByExpression](functions/parseOrderByExpression.md)
+- [parseWhereExpression](functions/parseWhereExpression.md)
+- [queueStrategy](functions/queueStrategy.md)
+- [sum](functions/sum.md)
+- [throttleStrategy](functions/throttleStrategy.md)
+- [unionWherePredicates](functions/unionWherePredicates.md)
+- [upper](functions/upper.md)
+- [walkExpression](functions/walkExpression.md)
+- [withArrayChangeTracking](functions/withArrayChangeTracking.md)
+- [withChangeTracking](functions/withChangeTracking.md)
diff --git a/docs/reference/interfaces/btreeindexoptions.md b/docs/reference/interfaces/BTreeIndexOptions.md
similarity index 51%
rename from docs/reference/interfaces/btreeindexoptions.md
rename to docs/reference/interfaces/BTreeIndexOptions.md
index 4dec3c202..95e568924 100644
--- a/docs/reference/interfaces/btreeindexoptions.md
+++ b/docs/reference/interfaces/BTreeIndexOptions.md
@@ -3,11 +3,9 @@ id: BTreeIndexOptions
 title: BTreeIndexOptions
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Interface: BTreeIndexOptions
 
-Defined in: [packages/db/src/indexes/btree-index.ts:10](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L10)
+Defined in: [packages/db/src/indexes/btree-index.ts:12](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L12)
 
 Options for Ordered index
 
@@ -19,7 +17,7 @@ Options for Ordered index
 optional compareFn: (a, b) => number;
 ```
 
-Defined in: [packages/db/src/indexes/btree-index.ts:11](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L11)
+Defined in: [packages/db/src/indexes/btree-index.ts:13](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L13)
 
 #### Parameters
 
@@ -34,3 +32,13 @@ Defined in: [packages/db/src/indexes/btree-index.ts:11](https://github.com/TanSt
 #### Returns
 
 `number`
+
+***
+
+### compareOptions?
+
+```ts
+optional compareOptions: CompareOptions;
+```
+
+Defined in: [packages/db/src/indexes/btree-index.ts:14](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L14)
diff --git a/docs/reference/interfaces/collectionconfig.md b/docs/reference/interfaces/BaseCollectionConfig.md
similarity index 61%
rename from docs/reference/interfaces/collectionconfig.md
rename to docs/reference/interfaces/BaseCollectionConfig.md
index 72b022b5c..e5220f92c 100644
--- a/docs/reference/interfaces/collectionconfig.md
+++ b/docs/reference/interfaces/BaseCollectionConfig.md
@@ -1,33 +1,48 @@
 ---
-id: CollectionConfig
-title: CollectionConfig
+id: BaseCollectionConfig
+title: BaseCollectionConfig
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
+# Interface: BaseCollectionConfig\<T, TKey, TSchema, TUtils, TReturn\>
 
-# Interface: CollectionConfig\<T, TKey, TSchema, TInsertInput\>
+Defined in: [packages/db/src/types.ts:499](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L499)
 
-Defined in: [packages/db/src/types.ts:349](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L349)
+## Extended by
+
+- [`CollectionConfig`](CollectionConfig.md)
+- [`LocalStorageCollectionConfig`](LocalStorageCollectionConfig.md)
 
 ## Type Parameters
 
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TSchema
 
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
+`TSchema` *extends* `StandardSchemaV1` = `never`
 
-• **TSchema** *extends* `StandardSchemaV1` = `StandardSchemaV1`
+### TUtils
 
-• **TInsertInput** *extends* `object` = `T`
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md) = [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+### TReturn
+
+`TReturn` = `any`
 
 ## Properties
 
 ### autoIndex?
 
 ```ts
-optional autoIndex: "off" | "eager";
+optional autoIndex: "eager" | "off";
 ```
 
-Defined in: [packages/db/src/types.ts:388](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L388)
+Defined in: [packages/db/src/types.ts:548](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L548)
 
 Auto-indexing mode for the collection.
 When enabled, indexes will be automatically created for simple where expressions.
@@ -51,7 +66,7 @@ When enabled, indexes will be automatically created for simple where expressions
 optional compare: (x, y) => number;
 ```
 
-Defined in: [packages/db/src/types.ts:399](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L399)
+Defined in: [packages/db/src/types.ts:559](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L559)
 
 Optional function to compare two items.
 This is used to order the items in the collection.
@@ -85,13 +100,28 @@ compare: (x, y) => x.createdAt.getTime() - y.createdAt.getTime()
 
 ***
 
+### defaultStringCollation?
+
+```ts
+optional defaultStringCollation: StringCollationConfig;
+```
+
+Defined in: [packages/db/src/types.ts:705](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L705)
+
+Specifies how to compare data in the collection.
+This should be configured to match data ordering on the backend.
+E.g., when using the Electric DB collection these options
+      should match the database's collation settings.
+
+***
+
 ### gcTime?
 
 ```ts
 optional gcTime: number;
 ```
 
-Defined in: [packages/db/src/types.ts:374](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L374)
+Defined in: [packages/db/src/types.ts:528](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L528)
 
 Time in milliseconds after which the collection will be garbage collected
 when it has no active subscribers. Defaults to 5 minutes (300000ms).
@@ -104,7 +134,7 @@ when it has no active subscribers. Defaults to 5 minutes (300000ms).
 getKey: (item) => TKey;
 ```
 
-Defined in: [packages/db/src/types.ts:369](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L369)
+Defined in: [packages/db/src/types.ts:523](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L523)
 
 Function to extract the ID from an object
 This is required for update/delete operations which now only accept IDs
@@ -138,17 +168,17 @@ getKey: (item) => item.uuid
 optional id: string;
 ```
 
-Defined in: [packages/db/src/types.ts:357](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L357)
+Defined in: [packages/db/src/types.ts:512](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L512)
 
 ***
 
 ### onDelete?
 
 ```ts
-optional onDelete: DeleteMutationFn<T, TKey, Record<string, Fn>>;
+optional onDelete: DeleteMutationFn<T, TKey, TUtils, TReturn>;
 ```
 
-Defined in: [packages/db/src/types.ts:528](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L528)
+Defined in: [packages/db/src/types.ts:697](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L697)
 
 Optional asynchronous handler function called before a delete operation
 
@@ -209,10 +239,10 @@ onDelete: async ({ transaction, collection }) => {
 ### onInsert?
 
 ```ts
-optional onInsert: InsertMutationFn<TInsertInput, TKey, Record<string, Fn>>;
+optional onInsert: InsertMutationFn<T, TKey, TUtils, TReturn>;
 ```
 
-Defined in: [packages/db/src/types.ts:441](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L441)
+Defined in: [packages/db/src/types.ts:610](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L610)
 
 Optional asynchronous handler function called before an insert operation
 
@@ -272,10 +302,10 @@ onInsert: async ({ transaction, collection }) => {
 ### onUpdate?
 
 ```ts
-optional onUpdate: UpdateMutationFn<T, TKey, Record<string, Fn>>;
+optional onUpdate: UpdateMutationFn<T, TKey, TUtils, TReturn>;
 ```
 
-Defined in: [packages/db/src/types.ts:485](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L485)
+Defined in: [packages/db/src/types.ts:654](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L654)
 
 Optional asynchronous handler function called before an update operation
 
@@ -339,7 +369,7 @@ onUpdate: async ({ transaction, collection }) => {
 optional schema: TSchema;
 ```
 
-Defined in: [packages/db/src/types.ts:359](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L359)
+Defined in: [packages/db/src/types.ts:513](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L513)
 
 ***
 
@@ -349,17 +379,49 @@ Defined in: [packages/db/src/types.ts:359](https://github.com/TanStack/db/blob/m
 optional startSync: boolean;
 ```
 
-Defined in: [packages/db/src/types.ts:379](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L379)
+Defined in: [packages/db/src/types.ts:539](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L539)
+
+Whether to eagerly start syncing on collection creation.
+When true, syncing begins immediately. When false, syncing starts when the first subscriber attaches.
+
+Note: Even with startSync=true, collections will pause syncing when there are no active
+subscribers (typically when components querying the collection unmount), resuming when new
+subscribers attach. This preserves normal staleTime/gcTime behavior.
+
+#### Default
+
+```ts
+false
+```
+
+***
+
+### syncMode?
+
+```ts
+optional syncMode: SyncMode;
+```
+
+Defined in: [packages/db/src/types.ts:568](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L568)
+
+The mode of sync to use for the collection.
+
+#### Default
+
+`eager`
+
+#### Description
 
-Whether to start syncing immediately when the collection is created.
-Defaults to false for lazy loading. Set to true to immediately sync.
+- `eager`: syncs all data immediately on preload
+- `on-demand`: syncs data in incremental snapshots when the collection is queried
+The exact implementation of the sync mode is up to the sync implementation.
 
 ***
 
-### sync
+### utils?
 
 ```ts
-sync: SyncConfig<T, TKey>;
+optional utils: TUtils;
 ```
 
-Defined in: [packages/db/src/types.ts:358](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L358)
+Defined in: [packages/db/src/types.ts:707](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L707)
diff --git a/docs/reference/interfaces/BaseStrategy.md b/docs/reference/interfaces/BaseStrategy.md
new file mode 100644
index 000000000..af8c9a5aa
--- /dev/null
+++ b/docs/reference/interfaces/BaseStrategy.md
@@ -0,0 +1,83 @@
+---
+id: BaseStrategy
+title: BaseStrategy
+---
+
+# Interface: BaseStrategy\<TName\>
+
+Defined in: [packages/db/src/strategies/types.ts:6](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L6)
+
+Base strategy interface that all strategy implementations must conform to
+
+## Extended by
+
+- [`DebounceStrategy`](DebounceStrategy.md)
+- [`QueueStrategy`](QueueStrategy.md)
+- [`ThrottleStrategy`](ThrottleStrategy.md)
+
+## Type Parameters
+
+### TName
+
+`TName` *extends* `string` = `string`
+
+## Properties
+
+### \_type
+
+```ts
+_type: TName;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:8](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L8)
+
+Type discriminator for strategy identification
+
+***
+
+### cleanup()
+
+```ts
+cleanup: () => void;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:23](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L23)
+
+Clean up any resources held by the strategy
+Should be called when the strategy is no longer needed
+
+#### Returns
+
+`void`
+
+***
+
+### execute()
+
+```ts
+execute: <T>(fn) => void | Promise<void>;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:15](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L15)
+
+Execute a function according to the strategy's timing rules
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+#### Parameters
+
+##### fn
+
+() => [`Transaction`](Transaction.md)\<`T`\>
+
+The function to execute
+
+#### Returns
+
+`void` \| `Promise`\<`void`\>
+
+The result of the function execution (if applicable)
diff --git a/docs/reference/interfaces/ChangeMessage.md b/docs/reference/interfaces/ChangeMessage.md
new file mode 100644
index 000000000..a88327eed
--- /dev/null
+++ b/docs/reference/interfaces/ChangeMessage.md
@@ -0,0 +1,68 @@
+---
+id: ChangeMessage
+title: ChangeMessage
+---
+
+# Interface: ChangeMessage\<T, TKey\>
+
+Defined in: [packages/db/src/types.ts:359](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L359)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+## Properties
+
+### key
+
+```ts
+key: TKey;
+```
+
+Defined in: [packages/db/src/types.ts:363](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L363)
+
+***
+
+### metadata?
+
+```ts
+optional metadata: Record<string, unknown>;
+```
+
+Defined in: [packages/db/src/types.ts:367](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L367)
+
+***
+
+### previousValue?
+
+```ts
+optional previousValue: T;
+```
+
+Defined in: [packages/db/src/types.ts:365](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L365)
+
+***
+
+### type
+
+```ts
+type: OperationType;
+```
+
+Defined in: [packages/db/src/types.ts:366](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L366)
+
+***
+
+### value
+
+```ts
+value: T;
+```
+
+Defined in: [packages/db/src/types.ts:364](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L364)
diff --git a/docs/reference/interfaces/Collection.md b/docs/reference/interfaces/Collection.md
new file mode 100644
index 000000000..c7db4964b
--- /dev/null
+++ b/docs/reference/interfaces/Collection.md
@@ -0,0 +1,1611 @@
+---
+id: Collection
+title: Collection
+---
+
+# Interface: Collection\<T, TKey, TUtils, TSchema, TInsertInput\>
+
+Defined in: [packages/db/src/collection/index.ts:48](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L48)
+
+Enhanced Collection interface that includes both data type T and utilities TUtils
+
+## Extends
+
+- [`CollectionImpl`](../classes/CollectionImpl.md)\<`T`, `TKey`, `TUtils`, `TSchema`, `TInsertInput`\>
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+The type of items in the collection
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the key for the collection
+
+### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md) = [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+The utilities record type
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `StandardSchemaV1`
+
+### TInsertInput
+
+`TInsertInput` *extends* `object` = `T`
+
+The type for insert operations (can be different from T for schemas with defaults)
+
+## Properties
+
+### \_lifecycle
+
+```ts
+_lifecycle: CollectionLifecycleManager<T, TKey, TSchema, TInsertInput>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:283](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L283)
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`_lifecycle`](../classes/CollectionImpl.md#_lifecycle)
+
+***
+
+### \_state
+
+```ts
+_state: CollectionStateManager<T, TKey, TSchema, TInsertInput>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:295](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L295)
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`_state`](../classes/CollectionImpl.md#_state)
+
+***
+
+### \_sync
+
+```ts
+_sync: CollectionSyncManager<T, TKey, TSchema, TInsertInput>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:284](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L284)
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`_sync`](../classes/CollectionImpl.md#_sync)
+
+***
+
+### config
+
+```ts
+config: CollectionConfig<T, TKey, TSchema>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:274](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L274)
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`config`](../classes/CollectionImpl.md#config)
+
+***
+
+### id
+
+```ts
+id: string;
+```
+
+Defined in: [packages/db/src/collection/index.ts:273](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L273)
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`id`](../classes/CollectionImpl.md#id)
+
+***
+
+### singleResult?
+
+```ts
+readonly optional singleResult: true;
+```
+
+Defined in: [packages/db/src/collection/index.ts:56](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L56)
+
+***
+
+### utils
+
+```ts
+readonly utils: TUtils;
+```
+
+Defined in: [packages/db/src/collection/index.ts:55](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L55)
+
+#### Overrides
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`utils`](../classes/CollectionImpl.md#utils)
+
+## Accessors
+
+### compareOptions
+
+#### Get Signature
+
+```ts
+get compareOptions(): StringCollationConfig;
+```
+
+Defined in: [packages/db/src/collection/index.ts:580](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L580)
+
+##### Returns
+
+[`StringCollationConfig`](../type-aliases/StringCollationConfig.md)
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`compareOptions`](../classes/CollectionImpl.md#compareoptions)
+
+***
+
+### indexes
+
+#### Get Signature
+
+```ts
+get indexes(): Map<number, BaseIndex<TKey>>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:565](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L565)
+
+Get resolved indexes for query optimization
+
+##### Returns
+
+`Map`\<`number`, [`BaseIndex`](../classes/BaseIndex.md)\<`TKey`\>\>
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`indexes`](../classes/CollectionImpl.md#indexes)
+
+***
+
+### isLoadingSubset
+
+#### Get Signature
+
+```ts
+get isLoadingSubset(): boolean;
+```
+
+Defined in: [packages/db/src/collection/index.ts:431](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L431)
+
+Check if the collection is currently loading more data
+
+##### Returns
+
+`boolean`
+
+true if the collection has pending load more operations, false otherwise
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`isLoadingSubset`](../classes/CollectionImpl.md#isloadingsubset)
+
+***
+
+### size
+
+#### Get Signature
+
+```ts
+get size(): number;
+```
+
+Defined in: [packages/db/src/collection/index.ts:468](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L468)
+
+Get the current size of the collection (cached)
+
+##### Returns
+
+`number`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`size`](../classes/CollectionImpl.md#size)
+
+***
+
+### state
+
+#### Get Signature
+
+```ts
+get state(): Map<TKey, TOutput>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:757](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L757)
+
+Gets the current state of the collection as a Map
+
+##### Example
+
+```ts
+const itemsMap = collection.state
+console.log(`Collection has ${itemsMap.size} items`)
+
+for (const [key, item] of itemsMap) {
+  console.log(`${key}: ${item.title}`)
+}
+
+// Check if specific item exists
+if (itemsMap.has("todo-1")) {
+  console.log("Todo 1 exists:", itemsMap.get("todo-1"))
+}
+```
+
+##### Returns
+
+`Map`\<`TKey`, `TOutput`\>
+
+Map containing all items in the collection, with keys as identifiers
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`state`](../classes/CollectionImpl.md#state)
+
+***
+
+### status
+
+#### Get Signature
+
+```ts
+get status(): CollectionStatus;
+```
+
+Defined in: [packages/db/src/collection/index.ts:386](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L386)
+
+Gets the current status of the collection
+
+##### Returns
+
+[`CollectionStatus`](../type-aliases/CollectionStatus.md)
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`status`](../classes/CollectionImpl.md#status)
+
+***
+
+### subscriberCount
+
+#### Get Signature
+
+```ts
+get subscriberCount(): number;
+```
+
+Defined in: [packages/db/src/collection/index.ts:393](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L393)
+
+Get the number of subscribers to the collection
+
+##### Returns
+
+`number`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`subscriberCount`](../classes/CollectionImpl.md#subscribercount)
+
+***
+
+### toArray
+
+#### Get Signature
+
+```ts
+get toArray(): TOutput[];
+```
+
+Defined in: [packages/db/src/collection/index.ts:786](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L786)
+
+Gets the current state of the collection as an Array
+
+##### Returns
+
+`TOutput`[]
+
+An Array containing all items in the collection
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`toArray`](../classes/CollectionImpl.md#toarray)
+
+## Methods
+
+### \[iterator\]()
+
+```ts
+iterator: IterableIterator<[TKey, T]>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:496](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L496)
+
+Get all entries (virtual derived state)
+
+#### Returns
+
+`IterableIterator`\<\[`TKey`, `T`\]\>
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`[iterator]`](../classes/CollectionImpl.md#iterator)
+
+***
+
+### cleanup()
+
+```ts
+cleanup(): Promise<void>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:923](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L923)
+
+Clean up the collection by stopping sync and clearing data
+This can be called manually or automatically by garbage collection
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`cleanup`](../classes/CollectionImpl.md#cleanup)
+
+***
+
+### createIndex()
+
+```ts
+createIndex<TResolver>(indexCallback, config): IndexProxy<TKey>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:555](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L555)
+
+Creates an index on a collection for faster queries.
+Indexes significantly improve query performance by allowing constant time lookups
+and logarithmic time range queries instead of full scans.
+
+#### Type Parameters
+
+##### TResolver
+
+`TResolver` *extends* [`IndexResolver`](../type-aliases/IndexResolver.md)\<`TKey`\> = *typeof* [`BTreeIndex`](../classes/BTreeIndex.md)
+
+The type of the index resolver (constructor or async loader)
+
+#### Parameters
+
+##### indexCallback
+
+(`row`) => `any`
+
+Function that extracts the indexed value from each item
+
+##### config
+
+[`IndexOptions`](IndexOptions.md)\<`TResolver`\> = `{}`
+
+Configuration including index type and type-specific options
+
+#### Returns
+
+[`IndexProxy`](../classes/IndexProxy.md)\<`TKey`\>
+
+An index proxy that provides access to the index when ready
+
+#### Example
+
+```ts
+// Create a default B+ tree index
+const ageIndex = collection.createIndex((row) => row.age)
+
+// Create a ordered index with custom options
+const ageIndex = collection.createIndex((row) => row.age, {
+  indexType: BTreeIndex,
+  options: {
+    compareFn: customComparator,
+    compareOptions: { direction: 'asc', nulls: 'first', stringSort: 'lexical' }
+  },
+  name: 'age_btree'
+})
+
+// Create an async-loaded index
+const textIndex = collection.createIndex((row) => row.content, {
+  indexType: async () => {
+    const { FullTextIndex } = await import('./indexes/fulltext.js')
+    return FullTextIndex
+  },
+  options: { language: 'en' }
+})
+```
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`createIndex`](../classes/CollectionImpl.md#createindex)
+
+***
+
+### currentStateAsChanges()
+
+```ts
+currentStateAsChanges(options): 
+  | void
+  | ChangeMessage<T, string | number>[];
+```
+
+Defined in: [packages/db/src/collection/index.ts:824](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L824)
+
+Returns the current state of the collection as an array of changes
+
+#### Parameters
+
+##### options
+
+[`CurrentStateAsChangesOptions`](CurrentStateAsChangesOptions.md) = `{}`
+
+Options including optional where filter
+
+#### Returns
+
+  \| `void`
+  \| [`ChangeMessage`](ChangeMessage.md)\<`T`, `string` \| `number`\>[]
+
+An array of changes
+
+#### Example
+
+```ts
+// Get all items as changes
+const allChanges = collection.currentStateAsChanges()
+
+// Get only items matching a condition
+const activeChanges = collection.currentStateAsChanges({
+  where: (row) => row.status === 'active'
+})
+
+// Get only items using a pre-compiled expression
+const activeChanges = collection.currentStateAsChanges({
+  whereExpression: eq(row.status, 'active')
+})
+```
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`currentStateAsChanges`](../classes/CollectionImpl.md#currentstateaschanges)
+
+***
+
+### delete()
+
+```ts
+delete(keys, config?): Transaction<any>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:734](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L734)
+
+Deletes one or more items from the collection
+
+#### Parameters
+
+##### keys
+
+Single key or array of keys to delete
+
+`TKey` | `TKey`[]
+
+##### config?
+
+[`OperationConfig`](OperationConfig.md)
+
+Optional configuration including metadata
+
+#### Returns
+
+[`Transaction`](Transaction.md)\<`any`\>
+
+A Transaction object representing the delete operation(s)
+
+#### Examples
+
+```ts
+// Delete a single item
+const tx = collection.delete("todo-1")
+await tx.isPersisted.promise
+```
+
+```ts
+// Delete multiple items
+const tx = collection.delete(["todo-1", "todo-2"])
+await tx.isPersisted.promise
+```
+
+```ts
+// Delete with metadata
+const tx = collection.delete("todo-1", { metadata: { reason: "completed" } })
+await tx.isPersisted.promise
+```
+
+```ts
+// Handle errors
+try {
+  const tx = collection.delete("item-1")
+  await tx.isPersisted.promise
+  console.log('Delete successful')
+} catch (error) {
+  console.log('Delete failed:', error)
+}
+```
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`delete`](../classes/CollectionImpl.md#delete)
+
+***
+
+### entries()
+
+```ts
+entries(): IterableIterator<[TKey, T]>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:489](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L489)
+
+Get all entries (virtual derived state)
+
+#### Returns
+
+`IterableIterator`\<\[`TKey`, `T`\]\>
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`entries`](../classes/CollectionImpl.md#entries)
+
+***
+
+### forEach()
+
+```ts
+forEach(callbackfn): void;
+```
+
+Defined in: [packages/db/src/collection/index.ts:503](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L503)
+
+Execute a callback for each entry in the collection
+
+#### Parameters
+
+##### callbackfn
+
+(`value`, `key`, `index`) => `void`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`forEach`](../classes/CollectionImpl.md#foreach)
+
+***
+
+### get()
+
+```ts
+get(key): T | undefined;
+```
+
+Defined in: [packages/db/src/collection/index.ts:454](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L454)
+
+Get the current value for a key (virtual derived state)
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+#### Returns
+
+`T` \| `undefined`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`get`](../classes/CollectionImpl.md#get)
+
+***
+
+### getKeyFromItem()
+
+```ts
+getKeyFromItem(item): TKey;
+```
+
+Defined in: [packages/db/src/collection/index.ts:518](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L518)
+
+#### Parameters
+
+##### item
+
+`T`
+
+#### Returns
+
+`TKey`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`getKeyFromItem`](../classes/CollectionImpl.md#getkeyfromitem)
+
+***
+
+### has()
+
+```ts
+has(key): boolean;
+```
+
+Defined in: [packages/db/src/collection/index.ts:461](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L461)
+
+Check if a key exists in the collection (virtual derived state)
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+#### Returns
+
+`boolean`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`has`](../classes/CollectionImpl.md#has)
+
+***
+
+### insert()
+
+```ts
+insert(data, config?): 
+  | Transaction<Record<string, unknown>>
+| Transaction<T>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:621](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L621)
+
+Inserts one or more items into the collection
+
+#### Parameters
+
+##### data
+
+`TInsertInput` | `TInsertInput`[]
+
+##### config?
+
+[`InsertConfig`](InsertConfig.md)
+
+Optional configuration including metadata
+
+#### Returns
+
+  \| [`Transaction`](Transaction.md)\<`Record`\<`string`, `unknown`\>\>
+  \| [`Transaction`](Transaction.md)\<`T`\>
+
+A Transaction object representing the insert operation(s)
+
+#### Throws
+
+If the data fails schema validation
+
+#### Examples
+
+```ts
+// Insert a single todo (requires onInsert handler)
+const tx = collection.insert({ id: "1", text: "Buy milk", completed: false })
+await tx.isPersisted.promise
+```
+
+```ts
+// Insert multiple todos at once
+const tx = collection.insert([
+  { id: "1", text: "Buy milk", completed: false },
+  { id: "2", text: "Walk dog", completed: true }
+])
+await tx.isPersisted.promise
+```
+
+```ts
+// Insert with metadata
+const tx = collection.insert({ id: "1", text: "Buy groceries" },
+  { metadata: { source: "mobile-app" } }
+)
+await tx.isPersisted.promise
+```
+
+```ts
+// Handle errors
+try {
+  const tx = collection.insert({ id: "1", text: "New item" })
+  await tx.isPersisted.promise
+  console.log('Insert successful')
+} catch (error) {
+  console.log('Insert failed:', error)
+}
+```
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`insert`](../classes/CollectionImpl.md#insert)
+
+***
+
+### isReady()
+
+```ts
+isReady(): boolean;
+```
+
+Defined in: [packages/db/src/collection/index.ts:423](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L423)
+
+Check if the collection is ready for use
+Returns true if the collection has been marked as ready by its sync implementation
+
+#### Returns
+
+`boolean`
+
+true if the collection is ready, false otherwise
+
+#### Example
+
+```ts
+if (collection.isReady()) {
+  console.log('Collection is ready, data is available')
+  // Safe to access collection.state
+} else {
+  console.log('Collection is still loading')
+}
+```
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`isReady`](../classes/CollectionImpl.md#isready)
+
+***
+
+### keys()
+
+```ts
+keys(): IterableIterator<TKey>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:475](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L475)
+
+Get all keys (virtual derived state)
+
+#### Returns
+
+`IterableIterator`\<`TKey`\>
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`keys`](../classes/CollectionImpl.md#keys)
+
+***
+
+### map()
+
+```ts
+map<U>(callbackfn): U[];
+```
+
+Defined in: [packages/db/src/collection/index.ts:512](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L512)
+
+Create a new array with the results of calling a function for each entry in the collection
+
+#### Type Parameters
+
+##### U
+
+`U`
+
+#### Parameters
+
+##### callbackfn
+
+(`value`, `key`, `index`) => `U`
+
+#### Returns
+
+`U`[]
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`map`](../classes/CollectionImpl.md#map)
+
+***
+
+### off()
+
+```ts
+off<T>(event, callback): void;
+```
+
+Defined in: [packages/db/src/collection/index.ts:902](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L902)
+
+Unsubscribe from a collection event
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* 
+  \| `"status:idle"`
+  \| `"status:loading"`
+  \| `"status:ready"`
+  \| `"status:error"`
+  \| `"status:cleaned-up"`
+  \| `"status:change"`
+  \| `"subscribers:change"`
+  \| `"loadingSubset:change"`
+  \| `"truncate"`
+
+#### Parameters
+
+##### event
+
+`T`
+
+##### callback
+
+`CollectionEventHandler`\<`T`\>
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`off`](../classes/CollectionImpl.md#off)
+
+***
+
+### on()
+
+```ts
+on<T>(event, callback): () => void;
+```
+
+Defined in: [packages/db/src/collection/index.ts:882](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L882)
+
+Subscribe to a collection event
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* 
+  \| `"status:idle"`
+  \| `"status:loading"`
+  \| `"status:ready"`
+  \| `"status:error"`
+  \| `"status:cleaned-up"`
+  \| `"status:change"`
+  \| `"subscribers:change"`
+  \| `"loadingSubset:change"`
+  \| `"truncate"`
+
+#### Parameters
+
+##### event
+
+`T`
+
+##### callback
+
+`CollectionEventHandler`\<`T`\>
+
+#### Returns
+
+```ts
+(): void;
+```
+
+##### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`on`](../classes/CollectionImpl.md#on)
+
+***
+
+### once()
+
+```ts
+once<T>(event, callback): () => void;
+```
+
+Defined in: [packages/db/src/collection/index.ts:892](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L892)
+
+Subscribe to a collection event once
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* 
+  \| `"status:idle"`
+  \| `"status:loading"`
+  \| `"status:ready"`
+  \| `"status:error"`
+  \| `"status:cleaned-up"`
+  \| `"status:change"`
+  \| `"subscribers:change"`
+  \| `"loadingSubset:change"`
+  \| `"truncate"`
+
+#### Parameters
+
+##### event
+
+`T`
+
+##### callback
+
+`CollectionEventHandler`\<`T`\>
+
+#### Returns
+
+```ts
+(): void;
+```
+
+##### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`once`](../classes/CollectionImpl.md#once)
+
+***
+
+### onFirstReady()
+
+```ts
+onFirstReady(callback): void;
+```
+
+Defined in: [packages/db/src/collection/index.ts:407](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L407)
+
+Register a callback to be executed when the collection first becomes ready
+Useful for preloading collections
+
+#### Parameters
+
+##### callback
+
+() => `void`
+
+Function to call when the collection first becomes ready
+
+#### Returns
+
+`void`
+
+#### Example
+
+```ts
+collection.onFirstReady(() => {
+  console.log('Collection is ready for the first time')
+  // Safe to access collection.state now
+})
+```
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`onFirstReady`](../classes/CollectionImpl.md#onfirstready)
+
+***
+
+### preload()
+
+```ts
+preload(): Promise<void>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:447](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L447)
+
+Preload the collection data by starting sync if not already started
+Multiple concurrent calls will share the same promise
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`preload`](../classes/CollectionImpl.md#preload)
+
+***
+
+### startSyncImmediate()
+
+```ts
+startSyncImmediate(): void;
+```
+
+Defined in: [packages/db/src/collection/index.ts:439](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L439)
+
+Start sync immediately - internal method for compiled queries
+This bypasses lazy loading for special cases like live query results
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`startSyncImmediate`](../classes/CollectionImpl.md#startsyncimmediate)
+
+***
+
+### stateWhenReady()
+
+```ts
+stateWhenReady(): Promise<Map<TKey, T>>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:771](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L771)
+
+Gets the current state of the collection as a Map, but only resolves when data is available
+Waits for the first sync commit to complete before resolving
+
+#### Returns
+
+`Promise`\<`Map`\<`TKey`, `T`\>\>
+
+Promise that resolves to a Map containing all items in the collection
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`stateWhenReady`](../classes/CollectionImpl.md#statewhenready)
+
+***
+
+### subscribeChanges()
+
+```ts
+subscribeChanges(callback, options): CollectionSubscription;
+```
+
+Defined in: [packages/db/src/collection/index.ts:872](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L872)
+
+Subscribe to changes in the collection
+
+#### Parameters
+
+##### callback
+
+(`changes`) => `void`
+
+Function called when items change
+
+##### options
+
+[`SubscribeChangesOptions`](SubscribeChangesOptions.md)\<`T`\> = `{}`
+
+Subscription options including includeInitialState and where filter
+
+#### Returns
+
+`CollectionSubscription`
+
+Unsubscribe function - Call this to stop listening for changes
+
+#### Examples
+
+```ts
+// Basic subscription
+const subscription = collection.subscribeChanges((changes) => {
+  changes.forEach(change => {
+    console.log(`${change.type}: ${change.key}`, change.value)
+  })
+})
+
+// Later: subscription.unsubscribe()
+```
+
+```ts
+// Include current state immediately
+const subscription = collection.subscribeChanges((changes) => {
+  updateUI(changes)
+}, { includeInitialState: true })
+```
+
+```ts
+// Subscribe only to changes matching a condition using where callback
+import { eq } from "@tanstack/db"
+
+const subscription = collection.subscribeChanges((changes) => {
+  updateUI(changes)
+}, {
+  includeInitialState: true,
+  where: (row) => eq(row.status, "active")
+})
+```
+
+```ts
+// Using multiple conditions with and()
+import { and, eq, gt } from "@tanstack/db"
+
+const subscription = collection.subscribeChanges((changes) => {
+  updateUI(changes)
+}, {
+  where: (row) => and(eq(row.status, "active"), gt(row.priority, 5))
+})
+```
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`subscribeChanges`](../classes/CollectionImpl.md#subscribechanges)
+
+***
+
+### toArrayWhenReady()
+
+```ts
+toArrayWhenReady(): Promise<T[]>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:796](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L796)
+
+Gets the current state of the collection as an Array, but only resolves when data is available
+Waits for the first sync commit to complete before resolving
+
+#### Returns
+
+`Promise`\<`T`[]\>
+
+Promise that resolves to an Array containing all items in the collection
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`toArrayWhenReady`](../classes/CollectionImpl.md#toarraywhenready)
+
+***
+
+### update()
+
+#### Call Signature
+
+```ts
+update(key, callback): Transaction;
+```
+
+Defined in: [packages/db/src/collection/index.ts:666](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L666)
+
+Updates one or more items in the collection using a callback function
+
+##### Parameters
+
+###### key
+
+`unknown`[]
+
+###### callback
+
+(`drafts`) => `void`
+
+##### Returns
+
+[`Transaction`](Transaction.md)
+
+A Transaction object representing the update operation(s)
+
+##### Throws
+
+If the updated data fails schema validation
+
+##### Examples
+
+```ts
+// Update single item by key
+const tx = collection.update("todo-1", (draft) => {
+  draft.completed = true
+})
+await tx.isPersisted.promise
+```
+
+```ts
+// Update multiple items
+const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
+  drafts.forEach(draft => { draft.completed = true })
+})
+await tx.isPersisted.promise
+```
+
+```ts
+// Update with metadata
+const tx = collection.update("todo-1",
+  { metadata: { reason: "user update" } },
+  (draft) => { draft.text = "Updated text" }
+)
+await tx.isPersisted.promise
+```
+
+```ts
+// Handle errors
+try {
+  const tx = collection.update("item-1", draft => { draft.value = "new" })
+  await tx.isPersisted.promise
+  console.log('Update successful')
+} catch (error) {
+  console.log('Update failed:', error)
+}
+```
+
+##### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`update`](../classes/CollectionImpl.md#update)
+
+#### Call Signature
+
+```ts
+update(
+   keys, 
+   config, 
+   callback): Transaction;
+```
+
+Defined in: [packages/db/src/collection/index.ts:672](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L672)
+
+Updates one or more items in the collection using a callback function
+
+##### Parameters
+
+###### keys
+
+`unknown`[]
+
+Single key or array of keys to update
+
+###### config
+
+[`OperationConfig`](OperationConfig.md)
+
+###### callback
+
+(`drafts`) => `void`
+
+##### Returns
+
+[`Transaction`](Transaction.md)
+
+A Transaction object representing the update operation(s)
+
+##### Throws
+
+If the updated data fails schema validation
+
+##### Examples
+
+```ts
+// Update single item by key
+const tx = collection.update("todo-1", (draft) => {
+  draft.completed = true
+})
+await tx.isPersisted.promise
+```
+
+```ts
+// Update multiple items
+const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
+  drafts.forEach(draft => { draft.completed = true })
+})
+await tx.isPersisted.promise
+```
+
+```ts
+// Update with metadata
+const tx = collection.update("todo-1",
+  { metadata: { reason: "user update" } },
+  (draft) => { draft.text = "Updated text" }
+)
+await tx.isPersisted.promise
+```
+
+```ts
+// Handle errors
+try {
+  const tx = collection.update("item-1", draft => { draft.value = "new" })
+  await tx.isPersisted.promise
+  console.log('Update successful')
+} catch (error) {
+  console.log('Update failed:', error)
+}
+```
+
+##### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`update`](../classes/CollectionImpl.md#update)
+
+#### Call Signature
+
+```ts
+update(id, callback): Transaction;
+```
+
+Defined in: [packages/db/src/collection/index.ts:679](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L679)
+
+Updates one or more items in the collection using a callback function
+
+##### Parameters
+
+###### id
+
+`unknown`
+
+###### callback
+
+(`draft`) => `void`
+
+##### Returns
+
+[`Transaction`](Transaction.md)
+
+A Transaction object representing the update operation(s)
+
+##### Throws
+
+If the updated data fails schema validation
+
+##### Examples
+
+```ts
+// Update single item by key
+const tx = collection.update("todo-1", (draft) => {
+  draft.completed = true
+})
+await tx.isPersisted.promise
+```
+
+```ts
+// Update multiple items
+const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
+  drafts.forEach(draft => { draft.completed = true })
+})
+await tx.isPersisted.promise
+```
+
+```ts
+// Update with metadata
+const tx = collection.update("todo-1",
+  { metadata: { reason: "user update" } },
+  (draft) => { draft.text = "Updated text" }
+)
+await tx.isPersisted.promise
+```
+
+```ts
+// Handle errors
+try {
+  const tx = collection.update("item-1", draft => { draft.value = "new" })
+  await tx.isPersisted.promise
+  console.log('Update successful')
+} catch (error) {
+  console.log('Update failed:', error)
+}
+```
+
+##### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`update`](../classes/CollectionImpl.md#update)
+
+#### Call Signature
+
+```ts
+update(
+   id, 
+   config, 
+   callback): Transaction;
+```
+
+Defined in: [packages/db/src/collection/index.ts:685](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L685)
+
+Updates one or more items in the collection using a callback function
+
+##### Parameters
+
+###### id
+
+`unknown`
+
+###### config
+
+[`OperationConfig`](OperationConfig.md)
+
+###### callback
+
+(`draft`) => `void`
+
+##### Returns
+
+[`Transaction`](Transaction.md)
+
+A Transaction object representing the update operation(s)
+
+##### Throws
+
+If the updated data fails schema validation
+
+##### Examples
+
+```ts
+// Update single item by key
+const tx = collection.update("todo-1", (draft) => {
+  draft.completed = true
+})
+await tx.isPersisted.promise
+```
+
+```ts
+// Update multiple items
+const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
+  drafts.forEach(draft => { draft.completed = true })
+})
+await tx.isPersisted.promise
+```
+
+```ts
+// Update with metadata
+const tx = collection.update("todo-1",
+  { metadata: { reason: "user update" } },
+  (draft) => { draft.text = "Updated text" }
+)
+await tx.isPersisted.promise
+```
+
+```ts
+// Handle errors
+try {
+  const tx = collection.update("item-1", draft => { draft.value = "new" })
+  await tx.isPersisted.promise
+  console.log('Update successful')
+} catch (error) {
+  console.log('Update failed:', error)
+}
+```
+
+##### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`update`](../classes/CollectionImpl.md#update)
+
+***
+
+### validateData()
+
+```ts
+validateData(
+   data, 
+   type, 
+   key?): T;
+```
+
+Defined in: [packages/db/src/collection/index.ts:572](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L572)
+
+Validates the data against the schema
+
+#### Parameters
+
+##### data
+
+`unknown`
+
+##### type
+
+`"insert"` | `"update"`
+
+##### key?
+
+`TKey`
+
+#### Returns
+
+`T`
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`validateData`](../classes/CollectionImpl.md#validatedata)
+
+***
+
+### values()
+
+```ts
+values(): IterableIterator<T>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:482](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L482)
+
+Get all values (virtual derived state)
+
+#### Returns
+
+`IterableIterator`\<`T`\>
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`values`](../classes/CollectionImpl.md#values)
+
+***
+
+### waitFor()
+
+```ts
+waitFor<T>(event, timeout?): Promise<AllCollectionEvents[T]>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:912](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L912)
+
+Wait for a collection event
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* 
+  \| `"status:idle"`
+  \| `"status:loading"`
+  \| `"status:ready"`
+  \| `"status:error"`
+  \| `"status:cleaned-up"`
+  \| `"status:change"`
+  \| `"subscribers:change"`
+  \| `"loadingSubset:change"`
+  \| `"truncate"`
+
+#### Parameters
+
+##### event
+
+`T`
+
+##### timeout?
+
+`number`
+
+#### Returns
+
+`Promise`\<`AllCollectionEvents`\[`T`\]\>
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`waitFor`](../classes/CollectionImpl.md#waitfor)
diff --git a/docs/reference/interfaces/CollectionConfig.md b/docs/reference/interfaces/CollectionConfig.md
new file mode 100644
index 000000000..4b66cdd72
--- /dev/null
+++ b/docs/reference/interfaces/CollectionConfig.md
@@ -0,0 +1,484 @@
+---
+id: CollectionConfig
+title: CollectionConfig
+---
+
+# Interface: CollectionConfig\<T, TKey, TSchema, TUtils\>
+
+Defined in: [packages/db/src/types.ts:710](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L710)
+
+## Extends
+
+- [`BaseCollectionConfig`](BaseCollectionConfig.md)\<`T`, `TKey`, `TSchema`, `TUtils`\>
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `never`
+
+### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](../type-aliases/UtilsRecord.md) = [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+## Properties
+
+### autoIndex?
+
+```ts
+optional autoIndex: "eager" | "off";
+```
+
+Defined in: [packages/db/src/types.ts:548](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L548)
+
+Auto-indexing mode for the collection.
+When enabled, indexes will be automatically created for simple where expressions.
+
+#### Default
+
+```ts
+"eager"
+```
+
+#### Description
+
+- "off": No automatic indexing
+- "eager": Automatically create indexes for simple where expressions in subscribeChanges (default)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`autoIndex`](BaseCollectionConfig.md#autoindex)
+
+***
+
+### compare()?
+
+```ts
+optional compare: (x, y) => number;
+```
+
+Defined in: [packages/db/src/types.ts:559](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L559)
+
+Optional function to compare two items.
+This is used to order the items in the collection.
+
+#### Parameters
+
+##### x
+
+`T`
+
+The first item to compare
+
+##### y
+
+`T`
+
+The second item to compare
+
+#### Returns
+
+`number`
+
+A number indicating the order of the items
+
+#### Example
+
+```ts
+// For a collection with a 'createdAt' field
+compare: (x, y) => x.createdAt.getTime() - y.createdAt.getTime()
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`compare`](BaseCollectionConfig.md#compare)
+
+***
+
+### defaultStringCollation?
+
+```ts
+optional defaultStringCollation: StringCollationConfig;
+```
+
+Defined in: [packages/db/src/types.ts:705](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L705)
+
+Specifies how to compare data in the collection.
+This should be configured to match data ordering on the backend.
+E.g., when using the Electric DB collection these options
+      should match the database's collation settings.
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`defaultStringCollation`](BaseCollectionConfig.md#defaultstringcollation)
+
+***
+
+### gcTime?
+
+```ts
+optional gcTime: number;
+```
+
+Defined in: [packages/db/src/types.ts:528](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L528)
+
+Time in milliseconds after which the collection will be garbage collected
+when it has no active subscribers. Defaults to 5 minutes (300000ms).
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`gcTime`](BaseCollectionConfig.md#gctime)
+
+***
+
+### getKey()
+
+```ts
+getKey: (item) => TKey;
+```
+
+Defined in: [packages/db/src/types.ts:523](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L523)
+
+Function to extract the ID from an object
+This is required for update/delete operations which now only accept IDs
+
+#### Parameters
+
+##### item
+
+`T`
+
+The item to extract the ID from
+
+#### Returns
+
+`TKey`
+
+The ID string for the item
+
+#### Example
+
+```ts
+// For a collection with a 'uuid' field as the primary key
+getKey: (item) => item.uuid
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`getKey`](BaseCollectionConfig.md#getkey)
+
+***
+
+### id?
+
+```ts
+optional id: string;
+```
+
+Defined in: [packages/db/src/types.ts:512](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L512)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`id`](BaseCollectionConfig.md#id)
+
+***
+
+### onDelete?
+
+```ts
+optional onDelete: DeleteMutationFn<T, TKey, TUtils, any>;
+```
+
+Defined in: [packages/db/src/types.ts:697](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L697)
+
+Optional asynchronous handler function called before a delete operation
+
+#### Param
+
+Object containing transaction and collection information
+
+#### Returns
+
+Promise resolving to any value
+
+#### Examples
+
+```ts
+// Basic delete handler
+onDelete: async ({ transaction, collection }) => {
+  const deletedKey = transaction.mutations[0].key
+  await api.deleteTodo(deletedKey)
+}
+```
+
+```ts
+// Delete handler with multiple items
+onDelete: async ({ transaction, collection }) => {
+  const keysToDelete = transaction.mutations.map(m => m.key)
+  await api.deleteTodos(keysToDelete)
+}
+```
+
+```ts
+// Delete handler with confirmation
+onDelete: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  const shouldDelete = await confirmDeletion(mutation.original)
+  if (!shouldDelete) {
+    throw new Error('Delete cancelled by user')
+  }
+  await api.deleteTodo(mutation.original.id)
+}
+```
+
+```ts
+// Delete handler with optimistic rollback
+onDelete: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  try {
+    await api.deleteTodo(mutation.original.id)
+  } catch (error) {
+    // Transaction will automatically rollback optimistic changes
+    console.error('Delete failed, rolling back:', error)
+    throw error
+  }
+}
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`onDelete`](BaseCollectionConfig.md#ondelete)
+
+***
+
+### onInsert?
+
+```ts
+optional onInsert: InsertMutationFn<T, TKey, TUtils, any>;
+```
+
+Defined in: [packages/db/src/types.ts:610](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L610)
+
+Optional asynchronous handler function called before an insert operation
+
+#### Param
+
+Object containing transaction and collection information
+
+#### Returns
+
+Promise resolving to any value
+
+#### Examples
+
+```ts
+// Basic insert handler
+onInsert: async ({ transaction, collection }) => {
+  const newItem = transaction.mutations[0].modified
+  await api.createTodo(newItem)
+}
+```
+
+```ts
+// Insert handler with multiple items
+onInsert: async ({ transaction, collection }) => {
+  const items = transaction.mutations.map(m => m.modified)
+  await api.createTodos(items)
+}
+```
+
+```ts
+// Insert handler with error handling
+onInsert: async ({ transaction, collection }) => {
+  try {
+    const newItem = transaction.mutations[0].modified
+    const result = await api.createTodo(newItem)
+    return result
+  } catch (error) {
+    console.error('Insert failed:', error)
+    throw error // This will cause the transaction to fail
+  }
+}
+```
+
+```ts
+// Insert handler with metadata
+onInsert: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  await api.createTodo(mutation.modified, {
+    source: mutation.metadata?.source,
+    timestamp: mutation.createdAt
+  })
+}
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`onInsert`](BaseCollectionConfig.md#oninsert)
+
+***
+
+### onUpdate?
+
+```ts
+optional onUpdate: UpdateMutationFn<T, TKey, TUtils, any>;
+```
+
+Defined in: [packages/db/src/types.ts:654](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L654)
+
+Optional asynchronous handler function called before an update operation
+
+#### Param
+
+Object containing transaction and collection information
+
+#### Returns
+
+Promise resolving to any value
+
+#### Examples
+
+```ts
+// Basic update handler
+onUpdate: async ({ transaction, collection }) => {
+  const updatedItem = transaction.mutations[0].modified
+  await api.updateTodo(updatedItem.id, updatedItem)
+}
+```
+
+```ts
+// Update handler with partial updates
+onUpdate: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  const changes = mutation.changes // Only the changed fields
+  await api.updateTodo(mutation.original.id, changes)
+}
+```
+
+```ts
+// Update handler with multiple items
+onUpdate: async ({ transaction, collection }) => {
+  const updates = transaction.mutations.map(m => ({
+    id: m.key,
+    changes: m.changes
+  }))
+  await api.updateTodos(updates)
+}
+```
+
+```ts
+// Update handler with optimistic rollback
+onUpdate: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  try {
+    await api.updateTodo(mutation.original.id, mutation.changes)
+  } catch (error) {
+    // Transaction will automatically rollback optimistic changes
+    console.error('Update failed, rolling back:', error)
+    throw error
+  }
+}
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`onUpdate`](BaseCollectionConfig.md#onupdate)
+
+***
+
+### schema?
+
+```ts
+optional schema: TSchema;
+```
+
+Defined in: [packages/db/src/types.ts:513](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L513)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`schema`](BaseCollectionConfig.md#schema)
+
+***
+
+### startSync?
+
+```ts
+optional startSync: boolean;
+```
+
+Defined in: [packages/db/src/types.ts:539](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L539)
+
+Whether to eagerly start syncing on collection creation.
+When true, syncing begins immediately. When false, syncing starts when the first subscriber attaches.
+
+Note: Even with startSync=true, collections will pause syncing when there are no active
+subscribers (typically when components querying the collection unmount), resuming when new
+subscribers attach. This preserves normal staleTime/gcTime behavior.
+
+#### Default
+
+```ts
+false
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`startSync`](BaseCollectionConfig.md#startsync)
+
+***
+
+### sync
+
+```ts
+sync: SyncConfig<T, TKey>;
+```
+
+Defined in: [packages/db/src/types.ts:716](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L716)
+
+***
+
+### syncMode?
+
+```ts
+optional syncMode: SyncMode;
+```
+
+Defined in: [packages/db/src/types.ts:568](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L568)
+
+The mode of sync to use for the collection.
+
+#### Default
+
+`eager`
+
+#### Description
+
+- `eager`: syncs all data immediately on preload
+- `on-demand`: syncs data in incremental snapshots when the collection is queried
+The exact implementation of the sync mode is up to the sync implementation.
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`syncMode`](BaseCollectionConfig.md#syncmode)
+
+***
+
+### utils?
+
+```ts
+optional utils: TUtils;
+```
+
+Defined in: [packages/db/src/types.ts:707](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L707)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`utils`](BaseCollectionConfig.md#utils)
diff --git a/docs/reference/interfaces/CollectionLike.md b/docs/reference/interfaces/CollectionLike.md
new file mode 100644
index 000000000..0b8f2e026
--- /dev/null
+++ b/docs/reference/interfaces/CollectionLike.md
@@ -0,0 +1,147 @@
+---
+id: CollectionLike
+title: CollectionLike
+---
+
+# Interface: CollectionLike\<T, TKey\>
+
+Defined in: [packages/db/src/types.ts:13](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L13)
+
+Interface for a collection-like object that provides the necessary methods
+for the change events system to work
+
+## Extends
+
+- `Pick`\<[`Collection`](Collection.md)\<`T`, `TKey`\>, `"get"` \| `"has"` \| `"entries"` \| `"indexes"` \| `"id"` \| `"compareOptions"`\>
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+## Properties
+
+### compareOptions
+
+```ts
+compareOptions: StringCollationConfig;
+```
+
+Defined in: [packages/db/src/collection/index.ts:580](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L580)
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`compareOptions`](../classes/CollectionImpl.md#compareoptions)
+
+***
+
+### id
+
+```ts
+id: string;
+```
+
+Defined in: [packages/db/src/collection/index.ts:273](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L273)
+
+#### Inherited from
+
+[`CollectionImpl`](../classes/CollectionImpl.md).[`id`](../classes/CollectionImpl.md#id)
+
+***
+
+### indexes
+
+```ts
+indexes: Map<number, BaseIndex<TKey>>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:565](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L565)
+
+#### Inherited from
+
+```ts
+Pick.indexes
+```
+
+## Methods
+
+### entries()
+
+```ts
+entries(): IterableIterator<[TKey, T]>;
+```
+
+Defined in: [packages/db/src/collection/index.ts:489](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L489)
+
+Get all entries (virtual derived state)
+
+#### Returns
+
+`IterableIterator`\<\[`TKey`, `T`\]\>
+
+#### Inherited from
+
+```ts
+Pick.entries
+```
+
+***
+
+### get()
+
+```ts
+get(key): T | undefined;
+```
+
+Defined in: [packages/db/src/collection/index.ts:454](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L454)
+
+Get the current value for a key (virtual derived state)
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+#### Returns
+
+`T` \| `undefined`
+
+#### Inherited from
+
+```ts
+Pick.get
+```
+
+***
+
+### has()
+
+```ts
+has(key): boolean;
+```
+
+Defined in: [packages/db/src/collection/index.ts:461](https://github.com/TanStack/db/blob/main/packages/db/src/collection/index.ts#L461)
+
+Check if a key exists in the collection (virtual derived state)
+
+#### Parameters
+
+##### key
+
+`TKey`
+
+#### Returns
+
+`boolean`
+
+#### Inherited from
+
+```ts
+Pick.has
+```
diff --git a/docs/reference/interfaces/Context.md b/docs/reference/interfaces/Context.md
new file mode 100644
index 000000000..246dca186
--- /dev/null
+++ b/docs/reference/interfaces/Context.md
@@ -0,0 +1,99 @@
+---
+id: Context
+title: Context
+---
+
+# Interface: Context
+
+Defined in: [packages/db/src/query/builder/types.ts:35](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L35)
+
+Context - The central state container for query builder operations
+
+This interface tracks all the information needed to build and type-check queries:
+
+**Schema Management**:
+- `baseSchema`: The original tables/collections from the `from()` clause
+- `schema`: Current available tables (expands with joins, contracts with subqueries)
+
+**Query State**:
+- `fromSourceName`: Which table was used in `from()` - needed for optionality logic
+- `hasJoins`: Whether any joins have been added (affects result type inference)
+- `joinTypes`: Maps table aliases to their join types for optionality calculations
+
+**Result Tracking**:
+- `result`: The final shape after `select()` - undefined until select is called
+
+The context evolves through the query builder chain:
+1. `from()` sets baseSchema and schema to the same thing
+2. `join()` expands schema and sets hasJoins/joinTypes
+3. `select()` sets result to the projected shape
+
+## Properties
+
+### baseSchema
+
+```ts
+baseSchema: ContextSchema;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:37](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L37)
+
+***
+
+### fromSourceName
+
+```ts
+fromSourceName: string;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:41](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L41)
+
+***
+
+### hasJoins?
+
+```ts
+optional hasJoins: boolean;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:43](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L43)
+
+***
+
+### joinTypes?
+
+```ts
+optional joinTypes: Record<string, "inner" | "left" | "right" | "full" | "outer" | "cross">;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:45](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L45)
+
+***
+
+### result?
+
+```ts
+optional result: any;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:50](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L50)
+
+***
+
+### schema
+
+```ts
+schema: ContextSchema;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:39](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L39)
+
+***
+
+### singleResult?
+
+```ts
+optional singleResult: boolean;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:52](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L52)
diff --git a/docs/reference/interfaces/createoptimisticactionsoptions.md b/docs/reference/interfaces/CreateOptimisticActionsOptions.md
similarity index 61%
rename from docs/reference/interfaces/createoptimisticactionsoptions.md
rename to docs/reference/interfaces/CreateOptimisticActionsOptions.md
index 7c9993e5c..dd24d349a 100644
--- a/docs/reference/interfaces/createoptimisticactionsoptions.md
+++ b/docs/reference/interfaces/CreateOptimisticActionsOptions.md
@@ -3,23 +3,25 @@ id: CreateOptimisticActionsOptions
 title: CreateOptimisticActionsOptions
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Interface: CreateOptimisticActionsOptions\<TVars, T\>
 
-Defined in: [packages/db/src/types.ts:174](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L174)
+Defined in: [packages/db/src/types.ts:179](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L179)
 
 Options for the createOptimisticAction helper
 
 ## Extends
 
-- `Omit`\<[`TransactionConfig`](../transactionconfig.md)\<`T`\>, `"mutationFn"`\>
+- `Omit`\<[`TransactionConfig`](TransactionConfig.md)\<`T`\>, `"mutationFn"`\>
 
 ## Type Parameters
 
-• **TVars** = `unknown`
+### TVars
+
+`TVars` = `unknown`
 
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
 
 ## Properties
 
@@ -29,13 +31,11 @@ Options for the createOptimisticAction helper
 optional autoCommit: boolean;
 ```
 
-Defined in: [packages/db/src/types.ts:165](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L165)
+Defined in: [packages/db/src/types.ts:170](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L170)
 
 #### Inherited from
 
-```ts
-Omit.autoCommit
-```
+[`TransactionConfig`](TransactionConfig.md).[`autoCommit`](TransactionConfig.md#autocommit)
 
 ***
 
@@ -45,7 +45,7 @@ Omit.autoCommit
 optional id: string;
 ```
 
-Defined in: [packages/db/src/types.ts:163](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L163)
+Defined in: [packages/db/src/types.ts:168](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L168)
 
 Unique identifier for the transaction
 
@@ -63,7 +63,7 @@ Omit.id
 optional metadata: Record<string, unknown>;
 ```
 
-Defined in: [packages/db/src/types.ts:168](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L168)
+Defined in: [packages/db/src/types.ts:173](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L173)
 
 Custom metadata to associate with the transaction
 
@@ -81,7 +81,7 @@ Omit.metadata
 mutationFn: (vars, params) => Promise<any>;
 ```
 
-Defined in: [packages/db/src/types.ts:181](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L181)
+Defined in: [packages/db/src/types.ts:186](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L186)
 
 Function to execute the mutation on the server
 
@@ -93,7 +93,7 @@ Function to execute the mutation on the server
 
 ##### params
 
-[`MutationFnParams`](../../type-aliases/mutationfnparams.md)\<`T`\>
+[`MutationFnParams`](../type-aliases/MutationFnParams.md)\<`T`\>
 
 #### Returns
 
@@ -107,7 +107,7 @@ Function to execute the mutation on the server
 onMutate: (vars) => void;
 ```
 
-Defined in: [packages/db/src/types.ts:179](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L179)
+Defined in: [packages/db/src/types.ts:184](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L184)
 
 Function to apply optimistic updates locally before the mutation completes
 
diff --git a/docs/reference/interfaces/CurrentStateAsChangesOptions.md b/docs/reference/interfaces/CurrentStateAsChangesOptions.md
new file mode 100644
index 000000000..bfdb6888f
--- /dev/null
+++ b/docs/reference/interfaces/CurrentStateAsChangesOptions.md
@@ -0,0 +1,52 @@
+---
+id: CurrentStateAsChangesOptions
+title: CurrentStateAsChangesOptions
+---
+
+# Interface: CurrentStateAsChangesOptions
+
+Defined in: [packages/db/src/types.ts:824](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L824)
+
+Options for getting current state as changes
+
+## Properties
+
+### limit?
+
+```ts
+optional limit: number;
+```
+
+Defined in: [packages/db/src/types.ts:828](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L828)
+
+***
+
+### optimizedOnly?
+
+```ts
+optional optimizedOnly: boolean;
+```
+
+Defined in: [packages/db/src/types.ts:829](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L829)
+
+***
+
+### orderBy?
+
+```ts
+optional orderBy: OrderBy;
+```
+
+Defined in: [packages/db/src/types.ts:827](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L827)
+
+***
+
+### where?
+
+```ts
+optional where: BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/types.ts:826](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L826)
+
+Pre-compiled expression for filtering the current state
diff --git a/docs/reference/interfaces/DebounceStrategy.md b/docs/reference/interfaces/DebounceStrategy.md
new file mode 100644
index 000000000..9ca361705
--- /dev/null
+++ b/docs/reference/interfaces/DebounceStrategy.md
@@ -0,0 +1,97 @@
+---
+id: DebounceStrategy
+title: DebounceStrategy
+---
+
+# Interface: DebounceStrategy
+
+Defined in: [packages/db/src/strategies/types.ts:42](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L42)
+
+Debounce strategy that delays execution until activity stops
+
+## Extends
+
+- [`BaseStrategy`](BaseStrategy.md)\<`"debounce"`\>
+
+## Properties
+
+### \_type
+
+```ts
+_type: "debounce";
+```
+
+Defined in: [packages/db/src/strategies/types.ts:8](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L8)
+
+Type discriminator for strategy identification
+
+#### Inherited from
+
+[`BaseStrategy`](BaseStrategy.md).[`_type`](BaseStrategy.md#_type)
+
+***
+
+### cleanup()
+
+```ts
+cleanup: () => void;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:23](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L23)
+
+Clean up any resources held by the strategy
+Should be called when the strategy is no longer needed
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`BaseStrategy`](BaseStrategy.md).[`cleanup`](BaseStrategy.md#cleanup)
+
+***
+
+### execute()
+
+```ts
+execute: <T>(fn) => void | Promise<void>;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:15](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L15)
+
+Execute a function according to the strategy's timing rules
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+#### Parameters
+
+##### fn
+
+() => [`Transaction`](Transaction.md)\<`T`\>
+
+The function to execute
+
+#### Returns
+
+`void` \| `Promise`\<`void`\>
+
+The result of the function execution (if applicable)
+
+#### Inherited from
+
+[`BaseStrategy`](BaseStrategy.md).[`execute`](BaseStrategy.md#execute)
+
+***
+
+### options
+
+```ts
+options: DebounceStrategyOptions;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:43](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L43)
diff --git a/docs/reference/interfaces/DebounceStrategyOptions.md b/docs/reference/interfaces/DebounceStrategyOptions.md
new file mode 100644
index 000000000..99e5fe458
--- /dev/null
+++ b/docs/reference/interfaces/DebounceStrategyOptions.md
@@ -0,0 +1,47 @@
+---
+id: DebounceStrategyOptions
+title: DebounceStrategyOptions
+---
+
+# Interface: DebounceStrategyOptions
+
+Defined in: [packages/db/src/strategies/types.ts:30](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L30)
+
+Options for debounce strategy
+Delays execution until after a period of inactivity
+
+## Properties
+
+### leading?
+
+```ts
+optional leading: boolean;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:34](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L34)
+
+Execute immediately on the first call
+
+***
+
+### trailing?
+
+```ts
+optional trailing: boolean;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:36](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L36)
+
+Execute after the wait period on the last call
+
+***
+
+### wait
+
+```ts
+wait: number;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:32](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L32)
+
+Wait time in milliseconds before execution
diff --git a/docs/reference/classes/baseindex.md b/docs/reference/interfaces/IndexInterface.md
similarity index 57%
rename from docs/reference/classes/baseindex.md
rename to docs/reference/interfaces/IndexInterface.md
index c48d9ffa5..5a649aa31 100644
--- a/docs/reference/classes/baseindex.md
+++ b/docs/reference/interfaces/IndexInterface.md
@@ -1,297 +1,293 @@
 ---
-id: BaseIndex
-title: BaseIndex
+id: IndexInterface
+title: IndexInterface
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: `abstract` BaseIndex\<TKey\>
+# Interface: IndexInterface\<TKey\>
 
 Defined in: [packages/db/src/indexes/base-index.ts:28](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L28)
 
-Base abstract class that all index types extend
-
-## Extended by
-
-- [`BTreeIndex`](../btreeindex.md)
-
 ## Type Parameters
 
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
+### TKey
 
-## Constructors
+`TKey` *extends* `string` \| `number` = `string` \| `number`
 
-### new BaseIndex()
+## Properties
+
+### add()
 
 ```ts
-new BaseIndex<TKey>(
-   id, 
-   expression, 
-   name?, 
-options?): BaseIndex<TKey>
+add: (key, item) => void;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:40](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L40)
+Defined in: [packages/db/src/indexes/base-index.ts:31](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L31)
 
 #### Parameters
 
-##### id
-
-`number`
-
-##### expression
-
-`BasicExpression`
-
-##### name?
+##### key
 
-`string`
+`TKey`
 
-##### options?
+##### item
 
 `any`
 
 #### Returns
 
-[`BaseIndex`](../baseindex.md)\<`TKey`\>
+`void`
 
-## Properties
+***
 
-### expression
+### build()
 
 ```ts
-readonly expression: BasicExpression;
+build: (entries) => void;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:33](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L33)
+Defined in: [packages/db/src/indexes/base-index.ts:35](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L35)
 
-***
+#### Parameters
 
-### id
+##### entries
 
-```ts
-readonly id: number;
-```
+`Iterable`\<\[`TKey`, `any`\]\>
 
-Defined in: [packages/db/src/indexes/base-index.ts:31](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L31)
+#### Returns
+
+`void`
 
 ***
 
-### lastUpdated
+### clear()
 
 ```ts
-protected lastUpdated: Date;
+clear: () => void;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:38](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L38)
+Defined in: [packages/db/src/indexes/base-index.ts:36](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L36)
+
+#### Returns
+
+`void`
 
 ***
 
-### lookupCount
+### equalityLookup()
 
 ```ts
-protected lookupCount: number = 0;
+equalityLookup: (value) => Set<TKey>;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:36](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L36)
+Defined in: [packages/db/src/indexes/base-index.ts:40](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L40)
 
-***
+#### Parameters
 
-### name?
+##### value
 
-```ts
-readonly optional name: string;
-```
+`any`
 
-Defined in: [packages/db/src/indexes/base-index.ts:32](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L32)
+#### Returns
+
+`Set`\<`TKey`\>
 
 ***
 
-### supportedOperations
+### getStats()
 
 ```ts
-abstract readonly supportedOperations: Set<"eq" | "gt" | "gte" | "lt" | "lte" | "in" | "like" | "ilike">;
+getStats: () => IndexStats;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:34](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L34)
+Defined in: [packages/db/src/indexes/base-index.ts:70](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L70)
+
+#### Returns
+
+[`IndexStats`](IndexStats.md)
 
 ***
 
-### totalLookupTime
+### inArrayLookup()
 
 ```ts
-protected totalLookupTime: number = 0;
+inArrayLookup: (values) => Set<TKey>;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:37](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L37)
-
-## Accessors
+Defined in: [packages/db/src/indexes/base-index.ts:41](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L41)
 
-### keyCount
-
-#### Get Signature
+#### Parameters
 
-```ts
-get abstract keyCount(): number
-```
+##### values
 
-Defined in: [packages/db/src/indexes/base-index.ts:59](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L59)
+`any`[]
 
-##### Returns
+#### Returns
 
-`number`
+`Set`\<`TKey`\>
 
-## Methods
+***
 
-### add()
+### lookup()
 
 ```ts
-abstract add(key, item): void
+lookup: (operation, value) => Set<TKey>;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:53](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L53)
+Defined in: [packages/db/src/indexes/base-index.ts:38](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L38)
 
 #### Parameters
 
-##### key
+##### operation
 
-`TKey`
+`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
 
-##### item
+##### value
 
 `any`
 
 #### Returns
 
-`void`
+`Set`\<`TKey`\>
 
 ***
 
-### build()
+### matchesCompareOptions()
 
 ```ts
-abstract build(entries): void
+matchesCompareOptions: (compareOptions) => boolean;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:56](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L56)
+Defined in: [packages/db/src/indexes/base-index.ts:67](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L67)
 
 #### Parameters
 
-##### entries
+##### compareOptions
 
-`Iterable`\<\[`TKey`, `any`\]\>
+`CompareOptions`
 
 #### Returns
 
-`void`
+`boolean`
 
 ***
 
-### clear()
+### matchesDirection()
 
 ```ts
-abstract clear(): void
+matchesDirection: (direction) => boolean;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:57](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L57)
+Defined in: [packages/db/src/indexes/base-index.ts:68](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L68)
+
+#### Parameters
+
+##### direction
+
+[`OrderByDirection`](../@tanstack/namespaces/IR/type-aliases/OrderByDirection.md)
 
 #### Returns
 
-`void`
+`boolean`
 
 ***
 
-### evaluateIndexExpression()
+### matchesField()
 
 ```ts
-protected evaluateIndexExpression(item): any
+matchesField: (fieldPath) => boolean;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:87](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L87)
+Defined in: [packages/db/src/indexes/base-index.ts:66](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L66)
 
 #### Parameters
 
-##### item
+##### fieldPath
 
-`any`
+`string`[]
 
 #### Returns
 
-`any`
+`boolean`
 
 ***
 
-### getStats()
+### rangeQuery()
 
 ```ts
-getStats(): IndexStats
+rangeQuery: (options) => Set<TKey>;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:74](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L74)
+Defined in: [packages/db/src/indexes/base-index.ts:43](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L43)
+
+#### Parameters
+
+##### options
+
+[`RangeQueryOptions`](RangeQueryOptions.md)
 
 #### Returns
 
-[`IndexStats`](../../interfaces/indexstats.md)
+`Set`\<`TKey`\>
 
 ***
 
-### initialize()
+### rangeQueryReversed()
 
 ```ts
-abstract protected initialize(options?): void
+rangeQueryReversed: (options) => Set<TKey>;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L85)
+Defined in: [packages/db/src/indexes/base-index.ts:44](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L44)
 
 #### Parameters
 
-##### options?
+##### options
 
-`any`
+[`RangeQueryOptions`](RangeQueryOptions.md)
 
 #### Returns
 
-`void`
+`Set`\<`TKey`\>
 
 ***
 
-### lookup()
+### remove()
 
 ```ts
-abstract lookup(operation, value): Set<TKey>
+remove: (key, item) => void;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:58](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L58)
+Defined in: [packages/db/src/indexes/base-index.ts:32](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L32)
 
 #### Parameters
 
-##### operation
+##### key
 
-`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
+`TKey`
 
-##### value
+##### item
 
 `any`
 
 #### Returns
 
-`Set`\<`TKey`\>
+`void`
 
 ***
 
-### matchesField()
+### supports()
 
 ```ts
-matchesField(fieldPath): boolean
+supports: (operation) => boolean;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:66](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L66)
+Defined in: [packages/db/src/indexes/base-index.ts:64](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L64)
 
 #### Parameters
 
-##### fieldPath
+##### operation
 
-`string`[]
+`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
 
 #### Returns
 
@@ -299,109 +295,164 @@ Defined in: [packages/db/src/indexes/base-index.ts:66](https://github.com/TanSta
 
 ***
 
-### remove()
+### take()
 
 ```ts
-abstract remove(key, item): void
+take: (n, from?, filterFn?) => TKey[];
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:54](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L54)
+Defined in: [packages/db/src/indexes/base-index.ts:46](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L46)
 
 #### Parameters
 
-##### key
+##### n
+
+`number`
+
+##### from?
 
 `TKey`
 
-##### item
+##### filterFn?
 
-`any`
+(`key`) => `boolean`
 
 #### Returns
 
-`void`
+`TKey`[]
 
 ***
 
-### supports()
+### takeReversed()
 
 ```ts
-supports(operation): boolean
+takeReversed: (n, from?, filterFn?) => TKey[];
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:62](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L62)
+Defined in: [packages/db/src/indexes/base-index.ts:51](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L51)
 
 #### Parameters
 
-##### operation
+##### n
 
-`"eq"` | `"gt"` | `"gte"` | `"lt"` | `"lte"` | `"in"` | `"like"` | `"ilike"`
+`number`
+
+##### from?
+
+`TKey`
+
+##### filterFn?
+
+(`key`) => `boolean`
 
 #### Returns
 
-`boolean`
+`TKey`[]
 
 ***
 
-### trackLookup()
+### update()
 
 ```ts
-protected trackLookup(startTime): void
+update: (key, oldItem, newItem) => void;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:92](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L92)
+Defined in: [packages/db/src/indexes/base-index.ts:33](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L33)
 
 #### Parameters
 
-##### startTime
+##### key
 
-`number`
+`TKey`
+
+##### oldItem
+
+`any`
+
+##### newItem
+
+`any`
 
 #### Returns
 
 `void`
 
+## Accessors
+
+### indexedKeysSet
+
+#### Get Signature
+
+```ts
+get indexedKeysSet(): Set<TKey>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:61](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L61)
+
+##### Returns
+
+`Set`\<`TKey`\>
+
 ***
 
-### update()
+### keyCount
+
+#### Get Signature
 
 ```ts
-abstract update(
-   key, 
-   oldItem, 
-   newItem): void
+get keyCount(): number;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:55](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L55)
+Defined in: [packages/db/src/indexes/base-index.ts:57](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L57)
 
-#### Parameters
+##### Returns
 
-##### key
+`number`
 
-`TKey`
+***
 
-##### oldItem
+### orderedEntriesArray
 
-`any`
+#### Get Signature
 
-##### newItem
+```ts
+get orderedEntriesArray(): [any, Set<TKey>][];
+```
 
-`any`
+Defined in: [packages/db/src/indexes/base-index.ts:58](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L58)
 
-#### Returns
+##### Returns
 
-`void`
+\[`any`, `Set`\<`TKey`\>\][]
 
 ***
 
-### updateTimestamp()
+### orderedEntriesArrayReversed
+
+#### Get Signature
 
 ```ts
-protected updateTimestamp(): void
+get orderedEntriesArrayReversed(): [any, Set<TKey>][];
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:98](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L98)
+Defined in: [packages/db/src/indexes/base-index.ts:59](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L59)
 
-#### Returns
+##### Returns
 
-`void`
+\[`any`, `Set`\<`TKey`\>\][]
+
+***
+
+### valueMapData
+
+#### Get Signature
+
+```ts
+get valueMapData(): Map<any, Set<TKey>>;
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:62](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L62)
+
+##### Returns
+
+`Map`\<`any`, `Set`\<`TKey`\>\>
diff --git a/docs/reference/interfaces/indexoptions.md b/docs/reference/interfaces/IndexOptions.md
similarity index 84%
rename from docs/reference/interfaces/indexoptions.md
rename to docs/reference/interfaces/IndexOptions.md
index 25fbdbc4c..3ca169871 100644
--- a/docs/reference/interfaces/indexoptions.md
+++ b/docs/reference/interfaces/IndexOptions.md
@@ -3,8 +3,6 @@ id: IndexOptions
 title: IndexOptions
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Interface: IndexOptions\<TResolver\>
 
 Defined in: [packages/db/src/indexes/index-options.ts:6](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/index-options.ts#L6)
@@ -13,7 +11,9 @@ Enhanced index options that support both sync and async resolvers
 
 ## Type Parameters
 
-• **TResolver** *extends* [`IndexResolver`](../../type-aliases/indexresolver.md) = [`IndexResolver`](../../type-aliases/indexresolver.md)
+### TResolver
+
+`TResolver` *extends* [`IndexResolver`](../type-aliases/IndexResolver.md) = [`IndexResolver`](../type-aliases/IndexResolver.md)
 
 ## Properties
 
diff --git a/docs/reference/interfaces/indexstats.md b/docs/reference/interfaces/IndexStats.md
similarity index 74%
rename from docs/reference/interfaces/indexstats.md
rename to docs/reference/interfaces/IndexStats.md
index d5210f06c..ff3db9e4b 100644
--- a/docs/reference/interfaces/indexstats.md
+++ b/docs/reference/interfaces/IndexStats.md
@@ -3,11 +3,9 @@ id: IndexStats
 title: IndexStats
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Interface: IndexStats
 
-Defined in: [packages/db/src/indexes/base-index.ts:18](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L18)
+Defined in: [packages/db/src/indexes/base-index.ts:21](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L21)
 
 Statistics about index usage and performance
 
@@ -19,7 +17,7 @@ Statistics about index usage and performance
 readonly averageLookupTime: number;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:21](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L21)
+Defined in: [packages/db/src/indexes/base-index.ts:24](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L24)
 
 ***
 
@@ -29,7 +27,7 @@ Defined in: [packages/db/src/indexes/base-index.ts:21](https://github.com/TanSta
 readonly entryCount: number;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:19](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L19)
+Defined in: [packages/db/src/indexes/base-index.ts:22](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L22)
 
 ***
 
@@ -39,7 +37,7 @@ Defined in: [packages/db/src/indexes/base-index.ts:19](https://github.com/TanSta
 readonly lastUpdated: Date;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:22](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L22)
+Defined in: [packages/db/src/indexes/base-index.ts:25](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L25)
 
 ***
 
@@ -49,4 +47,4 @@ Defined in: [packages/db/src/indexes/base-index.ts:22](https://github.com/TanSta
 readonly lookupCount: number;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:20](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L20)
+Defined in: [packages/db/src/indexes/base-index.ts:23](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L23)
diff --git a/docs/reference/interfaces/InsertConfig.md b/docs/reference/interfaces/InsertConfig.md
new file mode 100644
index 000000000..73a7a4c61
--- /dev/null
+++ b/docs/reference/interfaces/InsertConfig.md
@@ -0,0 +1,30 @@
+---
+id: InsertConfig
+title: InsertConfig
+---
+
+# Interface: InsertConfig
+
+Defined in: [packages/db/src/types.ts:417](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L417)
+
+## Properties
+
+### metadata?
+
+```ts
+optional metadata: Record<string, unknown>;
+```
+
+Defined in: [packages/db/src/types.ts:418](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L418)
+
+***
+
+### optimistic?
+
+```ts
+optional optimistic: boolean;
+```
+
+Defined in: [packages/db/src/types.ts:420](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L420)
+
+Whether to apply optimistic updates immediately. Defaults to true.
diff --git a/docs/reference/interfaces/LiveQueryCollectionConfig.md b/docs/reference/interfaces/LiveQueryCollectionConfig.md
new file mode 100644
index 000000000..bdd05f5ed
--- /dev/null
+++ b/docs/reference/interfaces/LiveQueryCollectionConfig.md
@@ -0,0 +1,185 @@
+---
+id: LiveQueryCollectionConfig
+title: LiveQueryCollectionConfig
+---
+
+# Interface: LiveQueryCollectionConfig\<TContext, TResult\>
+
+Defined in: [packages/db/src/query/live/types.ts:55](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L55)
+
+Configuration interface for live query collection options
+
+## Example
+
+```typescript
+const config: LiveQueryCollectionConfig<any, any> = {
+  // id is optional - will auto-generate "live-query-1", "live-query-2", etc.
+  query: (q) => q
+    .from({ comment: commentsCollection })
+    .join(
+      { user: usersCollection },
+      ({ comment, user }) => eq(comment.user_id, user.id)
+    )
+    .where(({ comment }) => eq(comment.active, true))
+    .select(({ comment, user }) => ({
+      id: comment.id,
+      content: comment.content,
+      authorName: user.name,
+    })),
+  // getKey is optional - defaults to using stream key
+  getKey: (item) => item.id,
+}
+```
+
+## Type Parameters
+
+### TContext
+
+`TContext` *extends* [`Context`](Context.md)
+
+### TResult
+
+`TResult` *extends* `object` = [`GetResult`](../type-aliases/GetResult.md)\<`TContext`\> & `object`
+
+## Properties
+
+### defaultStringCollation?
+
+```ts
+optional defaultStringCollation: StringCollationConfig;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:109](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L109)
+
+Optional compare options for string sorting.
+If provided, these will be used instead of inheriting from the FROM collection.
+
+***
+
+### gcTime?
+
+```ts
+optional gcTime: number;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:98](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L98)
+
+GC time for the collection
+
+***
+
+### getKey()?
+
+```ts
+optional getKey: (item) => string | number;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:76](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L76)
+
+Function to extract the key from result items
+If not provided, defaults to using the key from the D2 stream
+
+#### Parameters
+
+##### item
+
+`TResult`
+
+#### Returns
+
+`string` \| `number`
+
+***
+
+### id?
+
+```ts
+optional id: string;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:63](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L63)
+
+Unique identifier for the collection
+If not provided, defaults to `live-query-${number}` with auto-incrementing number
+
+***
+
+### onDelete?
+
+```ts
+optional onDelete: DeleteMutationFn<TResult, string | number, UtilsRecord, any>;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:88](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L88)
+
+***
+
+### onInsert?
+
+```ts
+optional onInsert: InsertMutationFn<TResult, string | number, UtilsRecord, any>;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:86](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L86)
+
+Optional mutation handlers
+
+***
+
+### onUpdate?
+
+```ts
+optional onUpdate: UpdateMutationFn<TResult, string | number, UtilsRecord, any>;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:87](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L87)
+
+***
+
+### query
+
+```ts
+query: 
+  | QueryBuilder<TContext>
+| (q) => QueryBuilder<TContext>;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:68](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L68)
+
+Query builder function that defines the live query
+
+***
+
+### schema?
+
+```ts
+optional schema: undefined;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:81](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L81)
+
+Optional schema for validation
+
+***
+
+### singleResult?
+
+```ts
+optional singleResult: true;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:103](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L103)
+
+If enabled the collection will return a single object instead of an array
+
+***
+
+### startSync?
+
+```ts
+optional startSync: boolean;
+```
+
+Defined in: [packages/db/src/query/live/types.ts:93](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/types.ts#L93)
+
+Start sync / the query immediately
diff --git a/docs/reference/interfaces/LocalOnlyCollectionConfig.md b/docs/reference/interfaces/LocalOnlyCollectionConfig.md
new file mode 100644
index 000000000..3b04dd77a
--- /dev/null
+++ b/docs/reference/interfaces/LocalOnlyCollectionConfig.md
@@ -0,0 +1,463 @@
+---
+id: LocalOnlyCollectionConfig
+title: LocalOnlyCollectionConfig
+---
+
+# Interface: LocalOnlyCollectionConfig\<T, TSchema, TKey\>
+
+Defined in: [packages/db/src/local-only.ts:22](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L22)
+
+Configuration interface for Local-only collection options
+
+## Extends
+
+- `Omit`\<[`BaseCollectionConfig`](BaseCollectionConfig.md)\<`T`, `TKey`, `TSchema`, [`LocalOnlyCollectionUtils`](LocalOnlyCollectionUtils.md)\>, `"gcTime"` \| `"startSync"`\>
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `object`
+
+The type of items in the collection
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `never`
+
+The schema type for validation
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the key returned by `getKey`
+
+## Properties
+
+### autoIndex?
+
+```ts
+optional autoIndex: "eager" | "off";
+```
+
+Defined in: [packages/db/src/types.ts:548](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L548)
+
+Auto-indexing mode for the collection.
+When enabled, indexes will be automatically created for simple where expressions.
+
+#### Default
+
+```ts
+"eager"
+```
+
+#### Description
+
+- "off": No automatic indexing
+- "eager": Automatically create indexes for simple where expressions in subscribeChanges (default)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`autoIndex`](BaseCollectionConfig.md#autoindex)
+
+***
+
+### compare()?
+
+```ts
+optional compare: (x, y) => number;
+```
+
+Defined in: [packages/db/src/types.ts:559](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L559)
+
+Optional function to compare two items.
+This is used to order the items in the collection.
+
+#### Parameters
+
+##### x
+
+`T`
+
+The first item to compare
+
+##### y
+
+`T`
+
+The second item to compare
+
+#### Returns
+
+`number`
+
+A number indicating the order of the items
+
+#### Example
+
+```ts
+// For a collection with a 'createdAt' field
+compare: (x, y) => x.createdAt.getTime() - y.createdAt.getTime()
+```
+
+#### Inherited from
+
+```ts
+Omit.compare
+```
+
+***
+
+### defaultStringCollation?
+
+```ts
+optional defaultStringCollation: StringCollationConfig;
+```
+
+Defined in: [packages/db/src/types.ts:705](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L705)
+
+Specifies how to compare data in the collection.
+This should be configured to match data ordering on the backend.
+E.g., when using the Electric DB collection these options
+      should match the database's collation settings.
+
+#### Inherited from
+
+```ts
+Omit.defaultStringCollation
+```
+
+***
+
+### getKey()
+
+```ts
+getKey: (item) => TKey;
+```
+
+Defined in: [packages/db/src/types.ts:523](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L523)
+
+Function to extract the ID from an object
+This is required for update/delete operations which now only accept IDs
+
+#### Parameters
+
+##### item
+
+`T`
+
+The item to extract the ID from
+
+#### Returns
+
+`TKey`
+
+The ID string for the item
+
+#### Example
+
+```ts
+// For a collection with a 'uuid' field as the primary key
+getKey: (item) => item.uuid
+```
+
+#### Inherited from
+
+```ts
+Omit.getKey
+```
+
+***
+
+### id?
+
+```ts
+optional id: string;
+```
+
+Defined in: [packages/db/src/types.ts:512](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L512)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`id`](BaseCollectionConfig.md#id)
+
+***
+
+### initialData?
+
+```ts
+optional initialData: T[];
+```
+
+Defined in: [packages/db/src/local-only.ts:34](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L34)
+
+Optional initial data to populate the collection with on creation
+This data will be applied during the initial sync process
+
+***
+
+### onDelete?
+
+```ts
+optional onDelete: DeleteMutationFn<T, TKey, LocalOnlyCollectionUtils, any>;
+```
+
+Defined in: [packages/db/src/types.ts:697](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L697)
+
+Optional asynchronous handler function called before a delete operation
+
+#### Param
+
+Object containing transaction and collection information
+
+#### Returns
+
+Promise resolving to any value
+
+#### Examples
+
+```ts
+// Basic delete handler
+onDelete: async ({ transaction, collection }) => {
+  const deletedKey = transaction.mutations[0].key
+  await api.deleteTodo(deletedKey)
+}
+```
+
+```ts
+// Delete handler with multiple items
+onDelete: async ({ transaction, collection }) => {
+  const keysToDelete = transaction.mutations.map(m => m.key)
+  await api.deleteTodos(keysToDelete)
+}
+```
+
+```ts
+// Delete handler with confirmation
+onDelete: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  const shouldDelete = await confirmDeletion(mutation.original)
+  if (!shouldDelete) {
+    throw new Error('Delete cancelled by user')
+  }
+  await api.deleteTodo(mutation.original.id)
+}
+```
+
+```ts
+// Delete handler with optimistic rollback
+onDelete: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  try {
+    await api.deleteTodo(mutation.original.id)
+  } catch (error) {
+    // Transaction will automatically rollback optimistic changes
+    console.error('Delete failed, rolling back:', error)
+    throw error
+  }
+}
+```
+
+#### Inherited from
+
+```ts
+Omit.onDelete
+```
+
+***
+
+### onInsert?
+
+```ts
+optional onInsert: InsertMutationFn<T, TKey, LocalOnlyCollectionUtils, any>;
+```
+
+Defined in: [packages/db/src/types.ts:610](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L610)
+
+Optional asynchronous handler function called before an insert operation
+
+#### Param
+
+Object containing transaction and collection information
+
+#### Returns
+
+Promise resolving to any value
+
+#### Examples
+
+```ts
+// Basic insert handler
+onInsert: async ({ transaction, collection }) => {
+  const newItem = transaction.mutations[0].modified
+  await api.createTodo(newItem)
+}
+```
+
+```ts
+// Insert handler with multiple items
+onInsert: async ({ transaction, collection }) => {
+  const items = transaction.mutations.map(m => m.modified)
+  await api.createTodos(items)
+}
+```
+
+```ts
+// Insert handler with error handling
+onInsert: async ({ transaction, collection }) => {
+  try {
+    const newItem = transaction.mutations[0].modified
+    const result = await api.createTodo(newItem)
+    return result
+  } catch (error) {
+    console.error('Insert failed:', error)
+    throw error // This will cause the transaction to fail
+  }
+}
+```
+
+```ts
+// Insert handler with metadata
+onInsert: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  await api.createTodo(mutation.modified, {
+    source: mutation.metadata?.source,
+    timestamp: mutation.createdAt
+  })
+}
+```
+
+#### Inherited from
+
+```ts
+Omit.onInsert
+```
+
+***
+
+### onUpdate?
+
+```ts
+optional onUpdate: UpdateMutationFn<T, TKey, LocalOnlyCollectionUtils, any>;
+```
+
+Defined in: [packages/db/src/types.ts:654](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L654)
+
+Optional asynchronous handler function called before an update operation
+
+#### Param
+
+Object containing transaction and collection information
+
+#### Returns
+
+Promise resolving to any value
+
+#### Examples
+
+```ts
+// Basic update handler
+onUpdate: async ({ transaction, collection }) => {
+  const updatedItem = transaction.mutations[0].modified
+  await api.updateTodo(updatedItem.id, updatedItem)
+}
+```
+
+```ts
+// Update handler with partial updates
+onUpdate: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  const changes = mutation.changes // Only the changed fields
+  await api.updateTodo(mutation.original.id, changes)
+}
+```
+
+```ts
+// Update handler with multiple items
+onUpdate: async ({ transaction, collection }) => {
+  const updates = transaction.mutations.map(m => ({
+    id: m.key,
+    changes: m.changes
+  }))
+  await api.updateTodos(updates)
+}
+```
+
+```ts
+// Update handler with optimistic rollback
+onUpdate: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  try {
+    await api.updateTodo(mutation.original.id, mutation.changes)
+  } catch (error) {
+    // Transaction will automatically rollback optimistic changes
+    console.error('Update failed, rolling back:', error)
+    throw error
+  }
+}
+```
+
+#### Inherited from
+
+```ts
+Omit.onUpdate
+```
+
+***
+
+### schema?
+
+```ts
+optional schema: TSchema;
+```
+
+Defined in: [packages/db/src/types.ts:513](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L513)
+
+#### Inherited from
+
+```ts
+Omit.schema
+```
+
+***
+
+### syncMode?
+
+```ts
+optional syncMode: SyncMode;
+```
+
+Defined in: [packages/db/src/types.ts:568](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L568)
+
+The mode of sync to use for the collection.
+
+#### Default
+
+`eager`
+
+#### Description
+
+- `eager`: syncs all data immediately on preload
+- `on-demand`: syncs data in incremental snapshots when the collection is queried
+The exact implementation of the sync mode is up to the sync implementation.
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`syncMode`](BaseCollectionConfig.md#syncmode)
+
+***
+
+### utils?
+
+```ts
+optional utils: LocalOnlyCollectionUtils;
+```
+
+Defined in: [packages/db/src/types.ts:707](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L707)
+
+#### Inherited from
+
+```ts
+Omit.utils
+```
diff --git a/docs/reference/interfaces/LocalOnlyCollectionUtils.md b/docs/reference/interfaces/LocalOnlyCollectionUtils.md
new file mode 100644
index 000000000..c86fbc07b
--- /dev/null
+++ b/docs/reference/interfaces/LocalOnlyCollectionUtils.md
@@ -0,0 +1,62 @@
+---
+id: LocalOnlyCollectionUtils
+title: LocalOnlyCollectionUtils
+---
+
+# Interface: LocalOnlyCollectionUtils
+
+Defined in: [packages/db/src/local-only.ts:40](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L40)
+
+Local-only collection utilities type
+
+## Extends
+
+- [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+## Indexable
+
+```ts
+[key: string]: any
+```
+
+## Properties
+
+### acceptMutations()
+
+```ts
+acceptMutations: (transaction) => void;
+```
+
+Defined in: [packages/db/src/local-only.ts:58](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L58)
+
+Accepts mutations from a transaction that belong to this collection and persists them.
+This should be called in your transaction's mutationFn to persist local-only data.
+
+#### Parameters
+
+##### transaction
+
+The transaction containing mutations to accept
+
+###### mutations
+
+[`PendingMutation`](PendingMutation.md)\<`Record`\<`string`, `unknown`\>, [`OperationType`](../type-aliases/OperationType.md), [`Collection`](Collection.md)\<`Record`\<`string`, `unknown`\>, `any`, `any`, `any`, `any`\>\>[]
+
+#### Returns
+
+`void`
+
+#### Example
+
+```ts
+const localData = createCollection(localOnlyCollectionOptions({...}))
+
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Make API call first
+    await api.save(...)
+    // Then persist local-only mutations after success
+    localData.utils.acceptMutations(transaction)
+  }
+})
+```
diff --git a/docs/reference/interfaces/LocalStorageCollectionConfig.md b/docs/reference/interfaces/LocalStorageCollectionConfig.md
new file mode 100644
index 000000000..907f25ea3
--- /dev/null
+++ b/docs/reference/interfaces/LocalStorageCollectionConfig.md
@@ -0,0 +1,529 @@
+---
+id: LocalStorageCollectionConfig
+title: LocalStorageCollectionConfig
+---
+
+# Interface: LocalStorageCollectionConfig\<T, TSchema, TKey\>
+
+Defined in: [packages/db/src/local-storage.ts:58](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L58)
+
+Configuration interface for localStorage collection options
+
+## Extends
+
+- [`BaseCollectionConfig`](BaseCollectionConfig.md)\<`T`, `TKey`, `TSchema`\>
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `object`
+
+The type of items in the collection
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `never`
+
+The schema type for validation
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the key returned by `getKey`
+
+## Properties
+
+### autoIndex?
+
+```ts
+optional autoIndex: "eager" | "off";
+```
+
+Defined in: [packages/db/src/types.ts:548](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L548)
+
+Auto-indexing mode for the collection.
+When enabled, indexes will be automatically created for simple where expressions.
+
+#### Default
+
+```ts
+"eager"
+```
+
+#### Description
+
+- "off": No automatic indexing
+- "eager": Automatically create indexes for simple where expressions in subscribeChanges (default)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`autoIndex`](BaseCollectionConfig.md#autoindex)
+
+***
+
+### compare()?
+
+```ts
+optional compare: (x, y) => number;
+```
+
+Defined in: [packages/db/src/types.ts:559](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L559)
+
+Optional function to compare two items.
+This is used to order the items in the collection.
+
+#### Parameters
+
+##### x
+
+`T`
+
+The first item to compare
+
+##### y
+
+`T`
+
+The second item to compare
+
+#### Returns
+
+`number`
+
+A number indicating the order of the items
+
+#### Example
+
+```ts
+// For a collection with a 'createdAt' field
+compare: (x, y) => x.createdAt.getTime() - y.createdAt.getTime()
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`compare`](BaseCollectionConfig.md#compare)
+
+***
+
+### defaultStringCollation?
+
+```ts
+optional defaultStringCollation: StringCollationConfig;
+```
+
+Defined in: [packages/db/src/types.ts:705](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L705)
+
+Specifies how to compare data in the collection.
+This should be configured to match data ordering on the backend.
+E.g., when using the Electric DB collection these options
+      should match the database's collation settings.
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`defaultStringCollation`](BaseCollectionConfig.md#defaultstringcollation)
+
+***
+
+### gcTime?
+
+```ts
+optional gcTime: number;
+```
+
+Defined in: [packages/db/src/types.ts:528](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L528)
+
+Time in milliseconds after which the collection will be garbage collected
+when it has no active subscribers. Defaults to 5 minutes (300000ms).
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`gcTime`](BaseCollectionConfig.md#gctime)
+
+***
+
+### getKey()
+
+```ts
+getKey: (item) => TKey;
+```
+
+Defined in: [packages/db/src/types.ts:523](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L523)
+
+Function to extract the ID from an object
+This is required for update/delete operations which now only accept IDs
+
+#### Parameters
+
+##### item
+
+`T`
+
+The item to extract the ID from
+
+#### Returns
+
+`TKey`
+
+The ID string for the item
+
+#### Example
+
+```ts
+// For a collection with a 'uuid' field as the primary key
+getKey: (item) => item.uuid
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`getKey`](BaseCollectionConfig.md#getkey)
+
+***
+
+### id?
+
+```ts
+optional id: string;
+```
+
+Defined in: [packages/db/src/types.ts:512](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L512)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`id`](BaseCollectionConfig.md#id)
+
+***
+
+### onDelete?
+
+```ts
+optional onDelete: DeleteMutationFn<T, TKey, UtilsRecord, any>;
+```
+
+Defined in: [packages/db/src/types.ts:697](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L697)
+
+Optional asynchronous handler function called before a delete operation
+
+#### Param
+
+Object containing transaction and collection information
+
+#### Returns
+
+Promise resolving to any value
+
+#### Examples
+
+```ts
+// Basic delete handler
+onDelete: async ({ transaction, collection }) => {
+  const deletedKey = transaction.mutations[0].key
+  await api.deleteTodo(deletedKey)
+}
+```
+
+```ts
+// Delete handler with multiple items
+onDelete: async ({ transaction, collection }) => {
+  const keysToDelete = transaction.mutations.map(m => m.key)
+  await api.deleteTodos(keysToDelete)
+}
+```
+
+```ts
+// Delete handler with confirmation
+onDelete: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  const shouldDelete = await confirmDeletion(mutation.original)
+  if (!shouldDelete) {
+    throw new Error('Delete cancelled by user')
+  }
+  await api.deleteTodo(mutation.original.id)
+}
+```
+
+```ts
+// Delete handler with optimistic rollback
+onDelete: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  try {
+    await api.deleteTodo(mutation.original.id)
+  } catch (error) {
+    // Transaction will automatically rollback optimistic changes
+    console.error('Delete failed, rolling back:', error)
+    throw error
+  }
+}
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`onDelete`](BaseCollectionConfig.md#ondelete)
+
+***
+
+### onInsert?
+
+```ts
+optional onInsert: InsertMutationFn<T, TKey, UtilsRecord, any>;
+```
+
+Defined in: [packages/db/src/types.ts:610](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L610)
+
+Optional asynchronous handler function called before an insert operation
+
+#### Param
+
+Object containing transaction and collection information
+
+#### Returns
+
+Promise resolving to any value
+
+#### Examples
+
+```ts
+// Basic insert handler
+onInsert: async ({ transaction, collection }) => {
+  const newItem = transaction.mutations[0].modified
+  await api.createTodo(newItem)
+}
+```
+
+```ts
+// Insert handler with multiple items
+onInsert: async ({ transaction, collection }) => {
+  const items = transaction.mutations.map(m => m.modified)
+  await api.createTodos(items)
+}
+```
+
+```ts
+// Insert handler with error handling
+onInsert: async ({ transaction, collection }) => {
+  try {
+    const newItem = transaction.mutations[0].modified
+    const result = await api.createTodo(newItem)
+    return result
+  } catch (error) {
+    console.error('Insert failed:', error)
+    throw error // This will cause the transaction to fail
+  }
+}
+```
+
+```ts
+// Insert handler with metadata
+onInsert: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  await api.createTodo(mutation.modified, {
+    source: mutation.metadata?.source,
+    timestamp: mutation.createdAt
+  })
+}
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`onInsert`](BaseCollectionConfig.md#oninsert)
+
+***
+
+### onUpdate?
+
+```ts
+optional onUpdate: UpdateMutationFn<T, TKey, UtilsRecord, any>;
+```
+
+Defined in: [packages/db/src/types.ts:654](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L654)
+
+Optional asynchronous handler function called before an update operation
+
+#### Param
+
+Object containing transaction and collection information
+
+#### Returns
+
+Promise resolving to any value
+
+#### Examples
+
+```ts
+// Basic update handler
+onUpdate: async ({ transaction, collection }) => {
+  const updatedItem = transaction.mutations[0].modified
+  await api.updateTodo(updatedItem.id, updatedItem)
+}
+```
+
+```ts
+// Update handler with partial updates
+onUpdate: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  const changes = mutation.changes // Only the changed fields
+  await api.updateTodo(mutation.original.id, changes)
+}
+```
+
+```ts
+// Update handler with multiple items
+onUpdate: async ({ transaction, collection }) => {
+  const updates = transaction.mutations.map(m => ({
+    id: m.key,
+    changes: m.changes
+  }))
+  await api.updateTodos(updates)
+}
+```
+
+```ts
+// Update handler with optimistic rollback
+onUpdate: async ({ transaction, collection }) => {
+  const mutation = transaction.mutations[0]
+  try {
+    await api.updateTodo(mutation.original.id, mutation.changes)
+  } catch (error) {
+    // Transaction will automatically rollback optimistic changes
+    console.error('Update failed, rolling back:', error)
+    throw error
+  }
+}
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`onUpdate`](BaseCollectionConfig.md#onupdate)
+
+***
+
+### parser?
+
+```ts
+optional parser: Parser;
+```
+
+Defined in: [packages/db/src/local-storage.ts:84](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L84)
+
+Parser to use for serializing and deserializing data to and from storage
+Defaults to JSON
+
+***
+
+### schema?
+
+```ts
+optional schema: TSchema;
+```
+
+Defined in: [packages/db/src/types.ts:513](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L513)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`schema`](BaseCollectionConfig.md#schema)
+
+***
+
+### startSync?
+
+```ts
+optional startSync: boolean;
+```
+
+Defined in: [packages/db/src/types.ts:539](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L539)
+
+Whether to eagerly start syncing on collection creation.
+When true, syncing begins immediately. When false, syncing starts when the first subscriber attaches.
+
+Note: Even with startSync=true, collections will pause syncing when there are no active
+subscribers (typically when components querying the collection unmount), resuming when new
+subscribers attach. This preserves normal staleTime/gcTime behavior.
+
+#### Default
+
+```ts
+false
+```
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`startSync`](BaseCollectionConfig.md#startsync)
+
+***
+
+### storage?
+
+```ts
+optional storage: StorageApi;
+```
+
+Defined in: [packages/db/src/local-storage.ts:72](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L72)
+
+Storage API to use (defaults to window.localStorage)
+Can be any object that implements the Storage interface (e.g., sessionStorage)
+
+***
+
+### storageEventApi?
+
+```ts
+optional storageEventApi: StorageEventApi;
+```
+
+Defined in: [packages/db/src/local-storage.ts:78](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L78)
+
+Storage event API to use for cross-tab synchronization (defaults to window)
+Can be any object that implements addEventListener/removeEventListener for storage events
+
+***
+
+### storageKey
+
+```ts
+storageKey: string;
+```
+
+Defined in: [packages/db/src/local-storage.ts:66](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L66)
+
+The key to use for storing the collection data in localStorage/sessionStorage
+
+***
+
+### syncMode?
+
+```ts
+optional syncMode: SyncMode;
+```
+
+Defined in: [packages/db/src/types.ts:568](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L568)
+
+The mode of sync to use for the collection.
+
+#### Default
+
+`eager`
+
+#### Description
+
+- `eager`: syncs all data immediately on preload
+- `on-demand`: syncs data in incremental snapshots when the collection is queried
+The exact implementation of the sync mode is up to the sync implementation.
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`syncMode`](BaseCollectionConfig.md#syncmode)
+
+***
+
+### utils?
+
+```ts
+optional utils: UtilsRecord;
+```
+
+Defined in: [packages/db/src/types.ts:707](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L707)
+
+#### Inherited from
+
+[`BaseCollectionConfig`](BaseCollectionConfig.md).[`utils`](BaseCollectionConfig.md#utils)
diff --git a/docs/reference/interfaces/LocalStorageCollectionUtils.md b/docs/reference/interfaces/LocalStorageCollectionUtils.md
new file mode 100644
index 000000000..9472f18f6
--- /dev/null
+++ b/docs/reference/interfaces/LocalStorageCollectionUtils.md
@@ -0,0 +1,82 @@
+---
+id: LocalStorageCollectionUtils
+title: LocalStorageCollectionUtils
+---
+
+# Interface: LocalStorageCollectionUtils
+
+Defined in: [packages/db/src/local-storage.ts:100](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L100)
+
+LocalStorage collection utilities type
+
+## Extends
+
+- [`UtilsRecord`](../type-aliases/UtilsRecord.md)
+
+## Indexable
+
+```ts
+[key: string]: any
+```
+
+## Properties
+
+### acceptMutations()
+
+```ts
+acceptMutations: (transaction) => void;
+```
+
+Defined in: [packages/db/src/local-storage.ts:120](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L120)
+
+Accepts mutations from a transaction that belong to this collection and persists them to localStorage.
+This should be called in your transaction's mutationFn to persist local-storage data.
+
+#### Parameters
+
+##### transaction
+
+The transaction containing mutations to accept
+
+###### mutations
+
+[`PendingMutation`](PendingMutation.md)\<`Record`\<`string`, `unknown`\>, [`OperationType`](../type-aliases/OperationType.md), [`Collection`](Collection.md)\<`Record`\<`string`, `unknown`\>, `any`, `any`, `any`, `any`\>\>[]
+
+#### Returns
+
+`void`
+
+#### Example
+
+```ts
+const localSettings = createCollection(localStorageCollectionOptions({...}))
+
+const tx = createTransaction({
+  mutationFn: async ({ transaction }) => {
+    // Make API call first
+    await api.save(...)
+    // Then persist local-storage mutations after success
+    localSettings.utils.acceptMutations(transaction)
+  }
+})
+```
+
+***
+
+### clearStorage
+
+```ts
+clearStorage: ClearStorageFn;
+```
+
+Defined in: [packages/db/src/local-storage.ts:101](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L101)
+
+***
+
+### getStorageSize
+
+```ts
+getStorageSize: GetStorageSizeFn;
+```
+
+Defined in: [packages/db/src/local-storage.ts:102](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L102)
diff --git a/docs/reference/interfaces/OperationConfig.md b/docs/reference/interfaces/OperationConfig.md
new file mode 100644
index 000000000..260bb3660
--- /dev/null
+++ b/docs/reference/interfaces/OperationConfig.md
@@ -0,0 +1,30 @@
+---
+id: OperationConfig
+title: OperationConfig
+---
+
+# Interface: OperationConfig
+
+Defined in: [packages/db/src/types.ts:411](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L411)
+
+## Properties
+
+### metadata?
+
+```ts
+optional metadata: Record<string, unknown>;
+```
+
+Defined in: [packages/db/src/types.ts:412](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L412)
+
+***
+
+### optimistic?
+
+```ts
+optional optimistic: boolean;
+```
+
+Defined in: [packages/db/src/types.ts:414](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L414)
+
+Whether to apply optimistic updates immediately. Defaults to true.
diff --git a/docs/reference/interfaces/PacedMutationsConfig.md b/docs/reference/interfaces/PacedMutationsConfig.md
new file mode 100644
index 000000000..ead589087
--- /dev/null
+++ b/docs/reference/interfaces/PacedMutationsConfig.md
@@ -0,0 +1,81 @@
+---
+id: PacedMutationsConfig
+title: PacedMutationsConfig
+---
+
+# Interface: PacedMutationsConfig\<TVariables, T\>
+
+Defined in: [packages/db/src/paced-mutations.ts:8](https://github.com/TanStack/db/blob/main/packages/db/src/paced-mutations.ts#L8)
+
+Configuration for creating a paced mutations manager
+
+## Type Parameters
+
+### TVariables
+
+`TVariables` = `unknown`
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+## Properties
+
+### metadata?
+
+```ts
+optional metadata: Record<string, unknown>;
+```
+
+Defined in: [packages/db/src/paced-mutations.ts:30](https://github.com/TanStack/db/blob/main/packages/db/src/paced-mutations.ts#L30)
+
+Custom metadata to associate with transactions
+
+***
+
+### mutationFn
+
+```ts
+mutationFn: MutationFn<T>;
+```
+
+Defined in: [packages/db/src/paced-mutations.ts:21](https://github.com/TanStack/db/blob/main/packages/db/src/paced-mutations.ts#L21)
+
+Function to execute the mutation on the server.
+Receives the transaction parameters containing all merged mutations.
+
+***
+
+### onMutate()
+
+```ts
+onMutate: (variables) => void;
+```
+
+Defined in: [packages/db/src/paced-mutations.ts:16](https://github.com/TanStack/db/blob/main/packages/db/src/paced-mutations.ts#L16)
+
+Callback to apply optimistic updates immediately.
+Receives the variables passed to the mutate function.
+
+#### Parameters
+
+##### variables
+
+`TVariables`
+
+#### Returns
+
+`void`
+
+***
+
+### strategy
+
+```ts
+strategy: Strategy;
+```
+
+Defined in: [packages/db/src/paced-mutations.ts:26](https://github.com/TanStack/db/blob/main/packages/db/src/paced-mutations.ts#L26)
+
+Strategy for controlling mutation execution timing
+Examples: debounceStrategy, queueStrategy, throttleStrategy
diff --git a/docs/reference/interfaces/ParseWhereOptions.md b/docs/reference/interfaces/ParseWhereOptions.md
new file mode 100644
index 000000000..8a90e9014
--- /dev/null
+++ b/docs/reference/interfaces/ParseWhereOptions.md
@@ -0,0 +1,451 @@
+---
+id: ParseWhereOptions
+title: ParseWhereOptions
+---
+
+# Interface: ParseWhereOptions\<T\>
+
+Defined in: [packages/db/src/query/expression-helpers.ts:53](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L53)
+
+Options for customizing how WHERE expressions are parsed
+
+## Type Parameters
+
+### T
+
+`T` = `any`
+
+## Properties
+
+### handlers
+
+```ts
+handlers: object & object;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:67](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L67)
+
+Handler functions for different operators.
+Each handler receives the parsed field path(s) and value(s) and returns your custom format.
+
+Supported operators from TanStack DB:
+- Comparison: eq, gt, gte, lt, lte, in, like, ilike
+- Logical: and, or, not
+- Null checking: isNull, isUndefined
+- String functions: upper, lower, length, concat
+- Numeric: add
+- Utility: coalesce
+- Aggregates: count, avg, sum, min, max
+
+#### Type Declaration
+
+##### add()?
+
+```ts
+optional add: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### and()?
+
+```ts
+optional and: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### avg()?
+
+```ts
+optional avg: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### coalesce()?
+
+```ts
+optional coalesce: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### concat()?
+
+```ts
+optional concat: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### count()?
+
+```ts
+optional count: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### eq()?
+
+```ts
+optional eq: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### gt()?
+
+```ts
+optional gt: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### gte()?
+
+```ts
+optional gte: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### ilike()?
+
+```ts
+optional ilike: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### in()?
+
+```ts
+optional in: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### isNull()?
+
+```ts
+optional isNull: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### isUndefined()?
+
+```ts
+optional isUndefined: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### length()?
+
+```ts
+optional length: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### like()?
+
+```ts
+optional like: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### lower()?
+
+```ts
+optional lower: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### lt()?
+
+```ts
+optional lt: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### lte()?
+
+```ts
+optional lte: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### max()?
+
+```ts
+optional max: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### min()?
+
+```ts
+optional min: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### not()?
+
+```ts
+optional not: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### or()?
+
+```ts
+optional or: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### sum()?
+
+```ts
+optional sum: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+##### upper()?
+
+```ts
+optional upper: (...args) => T;
+```
+
+###### Parameters
+
+###### args
+
+...`any`[]
+
+###### Returns
+
+`T`
+
+***
+
+### onUnknownOperator()?
+
+```ts
+optional onUnknownOperator: (operator, args) => T;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:76](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L76)
+
+Optional handler for when an unknown operator is encountered.
+If not provided, unknown operators throw an error.
+
+#### Parameters
+
+##### operator
+
+`string`
+
+##### args
+
+`any`[]
+
+#### Returns
+
+`T`
diff --git a/docs/reference/interfaces/ParsedOrderBy.md b/docs/reference/interfaces/ParsedOrderBy.md
new file mode 100644
index 000000000..48a1773bf
--- /dev/null
+++ b/docs/reference/interfaces/ParsedOrderBy.md
@@ -0,0 +1,76 @@
+---
+id: ParsedOrderBy
+title: ParsedOrderBy
+---
+
+# Interface: ParsedOrderBy
+
+Defined in: [packages/db/src/query/expression-helpers.ts:82](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L82)
+
+Result of parsing an ORDER BY expression
+
+## Properties
+
+### direction
+
+```ts
+direction: "asc" | "desc";
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:84](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L84)
+
+***
+
+### field
+
+```ts
+field: FieldPath;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:83](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L83)
+
+***
+
+### locale?
+
+```ts
+optional locale: string;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:89](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L89)
+
+Locale for locale-aware string sorting (e.g., 'en-US')
+
+***
+
+### localeOptions?
+
+```ts
+optional localeOptions: object;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:91](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L91)
+
+Additional options for locale-aware sorting
+
+***
+
+### nulls
+
+```ts
+nulls: "first" | "last";
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L85)
+
+***
+
+### stringSort?
+
+```ts
+optional stringSort: "lexical" | "locale";
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:87](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L87)
+
+String sorting method: 'lexical' (default) or 'locale' (locale-aware)
diff --git a/docs/reference/interfaces/Parser.md b/docs/reference/interfaces/Parser.md
new file mode 100644
index 000000000..d1eafc24c
--- /dev/null
+++ b/docs/reference/interfaces/Parser.md
@@ -0,0 +1,48 @@
+---
+id: Parser
+title: Parser
+---
+
+# Interface: Parser
+
+Defined in: [packages/db/src/local-storage.ts:47](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L47)
+
+## Properties
+
+### parse()
+
+```ts
+parse: (data) => unknown;
+```
+
+Defined in: [packages/db/src/local-storage.ts:48](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L48)
+
+#### Parameters
+
+##### data
+
+`string`
+
+#### Returns
+
+`unknown`
+
+***
+
+### stringify()
+
+```ts
+stringify: (data) => string;
+```
+
+Defined in: [packages/db/src/local-storage.ts:49](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L49)
+
+#### Parameters
+
+##### data
+
+`unknown`
+
+#### Returns
+
+`string`
diff --git a/docs/reference/interfaces/PendingMutation.md b/docs/reference/interfaces/PendingMutation.md
new file mode 100644
index 000000000..d6cc2b7c8
--- /dev/null
+++ b/docs/reference/interfaces/PendingMutation.md
@@ -0,0 +1,157 @@
+---
+id: PendingMutation
+title: PendingMutation
+---
+
+# Interface: PendingMutation\<T, TOperation, TCollection\>
+
+Defined in: [packages/db/src/types.ts:89](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L89)
+
+Represents a pending mutation within a transaction
+Contains information about the original and modified data, as well as metadata
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TOperation
+
+`TOperation` *extends* [`OperationType`](../type-aliases/OperationType.md) = [`OperationType`](../type-aliases/OperationType.md)
+
+### TCollection
+
+`TCollection` *extends* [`Collection`](Collection.md)\<`T`, `any`, `any`, `any`, `any`\> = [`Collection`](Collection.md)\<`T`, `any`, `any`, `any`, `any`\>
+
+## Properties
+
+### changes
+
+```ts
+changes: ResolveTransactionChanges<T, TOperation>;
+```
+
+Defined in: [packages/db/src/types.ts:106](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L106)
+
+***
+
+### collection
+
+```ts
+collection: TCollection;
+```
+
+Defined in: [packages/db/src/types.ts:117](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L117)
+
+***
+
+### createdAt
+
+```ts
+createdAt: Date;
+```
+
+Defined in: [packages/db/src/types.ts:115](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L115)
+
+***
+
+### globalKey
+
+```ts
+globalKey: string;
+```
+
+Defined in: [packages/db/src/types.ts:107](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L107)
+
+***
+
+### key
+
+```ts
+key: any;
+```
+
+Defined in: [packages/db/src/types.ts:109](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L109)
+
+***
+
+### metadata
+
+```ts
+metadata: unknown;
+```
+
+Defined in: [packages/db/src/types.ts:111](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L111)
+
+***
+
+### modified
+
+```ts
+modified: T;
+```
+
+Defined in: [packages/db/src/types.ts:104](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L104)
+
+***
+
+### mutationId
+
+```ts
+mutationId: string;
+```
+
+Defined in: [packages/db/src/types.ts:100](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L100)
+
+***
+
+### optimistic
+
+```ts
+optimistic: boolean;
+```
+
+Defined in: [packages/db/src/types.ts:114](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L114)
+
+Whether this mutation should be applied optimistically (defaults to true)
+
+***
+
+### original
+
+```ts
+original: TOperation extends "insert" ? object : T;
+```
+
+Defined in: [packages/db/src/types.ts:102](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L102)
+
+***
+
+### syncMetadata
+
+```ts
+syncMetadata: Record<string, unknown>;
+```
+
+Defined in: [packages/db/src/types.ts:112](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L112)
+
+***
+
+### type
+
+```ts
+type: TOperation;
+```
+
+Defined in: [packages/db/src/types.ts:110](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L110)
+
+***
+
+### updatedAt
+
+```ts
+updatedAt: Date;
+```
+
+Defined in: [packages/db/src/types.ts:116](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L116)
diff --git a/docs/reference/interfaces/QueueStrategy.md b/docs/reference/interfaces/QueueStrategy.md
new file mode 100644
index 000000000..b38776d5c
--- /dev/null
+++ b/docs/reference/interfaces/QueueStrategy.md
@@ -0,0 +1,99 @@
+---
+id: QueueStrategy
+title: QueueStrategy
+---
+
+# Interface: QueueStrategy
+
+Defined in: [packages/db/src/strategies/types.ts:66](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L66)
+
+Queue strategy that processes all executions in order
+FIFO: { addItemsTo: 'back', getItemsFrom: 'front' }
+LIFO: { addItemsTo: 'back', getItemsFrom: 'back' }
+
+## Extends
+
+- [`BaseStrategy`](BaseStrategy.md)\<`"queue"`\>
+
+## Properties
+
+### \_type
+
+```ts
+_type: "queue";
+```
+
+Defined in: [packages/db/src/strategies/types.ts:8](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L8)
+
+Type discriminator for strategy identification
+
+#### Inherited from
+
+[`BaseStrategy`](BaseStrategy.md).[`_type`](BaseStrategy.md#_type)
+
+***
+
+### cleanup()
+
+```ts
+cleanup: () => void;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:23](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L23)
+
+Clean up any resources held by the strategy
+Should be called when the strategy is no longer needed
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`BaseStrategy`](BaseStrategy.md).[`cleanup`](BaseStrategy.md#cleanup)
+
+***
+
+### execute()
+
+```ts
+execute: <T>(fn) => void | Promise<void>;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:15](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L15)
+
+Execute a function according to the strategy's timing rules
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+#### Parameters
+
+##### fn
+
+() => [`Transaction`](Transaction.md)\<`T`\>
+
+The function to execute
+
+#### Returns
+
+`void` \| `Promise`\<`void`\>
+
+The result of the function execution (if applicable)
+
+#### Inherited from
+
+[`BaseStrategy`](BaseStrategy.md).[`execute`](BaseStrategy.md#execute)
+
+***
+
+### options?
+
+```ts
+optional options: QueueStrategyOptions;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:67](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L67)
diff --git a/docs/reference/interfaces/QueueStrategyOptions.md b/docs/reference/interfaces/QueueStrategyOptions.md
new file mode 100644
index 000000000..cefdd24e5
--- /dev/null
+++ b/docs/reference/interfaces/QueueStrategyOptions.md
@@ -0,0 +1,59 @@
+---
+id: QueueStrategyOptions
+title: QueueStrategyOptions
+---
+
+# Interface: QueueStrategyOptions
+
+Defined in: [packages/db/src/strategies/types.ts:50](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L50)
+
+Options for queue strategy
+Processes all executions in order (FIFO/LIFO)
+
+## Properties
+
+### addItemsTo?
+
+```ts
+optional addItemsTo: "front" | "back";
+```
+
+Defined in: [packages/db/src/strategies/types.ts:56](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L56)
+
+Where to add new items in the queue
+
+***
+
+### getItemsFrom?
+
+```ts
+optional getItemsFrom: "front" | "back";
+```
+
+Defined in: [packages/db/src/strategies/types.ts:58](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L58)
+
+Where to get items from when processing
+
+***
+
+### maxSize?
+
+```ts
+optional maxSize: number;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:54](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L54)
+
+Maximum queue size (items are dropped if exceeded)
+
+***
+
+### wait?
+
+```ts
+optional wait: number;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:52](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L52)
+
+Wait time between processing queue items (milliseconds)
diff --git a/docs/reference/interfaces/rangequeryoptions.md b/docs/reference/interfaces/RangeQueryOptions.md
similarity index 73%
rename from docs/reference/interfaces/rangequeryoptions.md
rename to docs/reference/interfaces/RangeQueryOptions.md
index 73e4b3100..cdf9c1ba4 100644
--- a/docs/reference/interfaces/rangequeryoptions.md
+++ b/docs/reference/interfaces/RangeQueryOptions.md
@@ -3,11 +3,9 @@ id: RangeQueryOptions
 title: RangeQueryOptions
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Interface: RangeQueryOptions
 
-Defined in: [packages/db/src/indexes/btree-index.ts:17](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L17)
+Defined in: [packages/db/src/indexes/btree-index.ts:20](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L20)
 
 Options for range queries
 
@@ -19,7 +17,7 @@ Options for range queries
 optional from: any;
 ```
 
-Defined in: [packages/db/src/indexes/btree-index.ts:18](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L18)
+Defined in: [packages/db/src/indexes/btree-index.ts:21](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L21)
 
 ***
 
@@ -29,7 +27,7 @@ Defined in: [packages/db/src/indexes/btree-index.ts:18](https://github.com/TanSt
 optional fromInclusive: boolean;
 ```
 
-Defined in: [packages/db/src/indexes/btree-index.ts:20](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L20)
+Defined in: [packages/db/src/indexes/btree-index.ts:23](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L23)
 
 ***
 
@@ -39,7 +37,7 @@ Defined in: [packages/db/src/indexes/btree-index.ts:20](https://github.com/TanSt
 optional to: any;
 ```
 
-Defined in: [packages/db/src/indexes/btree-index.ts:19](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L19)
+Defined in: [packages/db/src/indexes/btree-index.ts:22](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L22)
 
 ***
 
@@ -49,4 +47,4 @@ Defined in: [packages/db/src/indexes/btree-index.ts:19](https://github.com/TanSt
 optional toInclusive: boolean;
 ```
 
-Defined in: [packages/db/src/indexes/btree-index.ts:21](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L21)
+Defined in: [packages/db/src/indexes/btree-index.ts:24](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/btree-index.ts#L24)
diff --git a/docs/reference/interfaces/SimpleComparison.md b/docs/reference/interfaces/SimpleComparison.md
new file mode 100644
index 000000000..f8f71f670
--- /dev/null
+++ b/docs/reference/interfaces/SimpleComparison.md
@@ -0,0 +1,40 @@
+---
+id: SimpleComparison
+title: SimpleComparison
+---
+
+# Interface: SimpleComparison
+
+Defined in: [packages/db/src/query/expression-helpers.ts:44](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L44)
+
+Represents a simple comparison operation
+
+## Properties
+
+### field
+
+```ts
+field: FieldPath;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:45](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L45)
+
+***
+
+### operator
+
+```ts
+operator: string;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:46](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L46)
+
+***
+
+### value?
+
+```ts
+optional value: any;
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:47](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L47)
diff --git a/docs/reference/interfaces/SubscribeChangesOptions.md b/docs/reference/interfaces/SubscribeChangesOptions.md
new file mode 100644
index 000000000..92a9ba70e
--- /dev/null
+++ b/docs/reference/interfaces/SubscribeChangesOptions.md
@@ -0,0 +1,99 @@
+---
+id: SubscribeChangesOptions
+title: SubscribeChangesOptions
+---
+
+# Interface: SubscribeChangesOptions\<T\>
+
+Defined in: [packages/db/src/types.ts:784](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L784)
+
+Options for subscribing to collection changes
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+## Properties
+
+### includeInitialState?
+
+```ts
+optional includeInitialState: boolean;
+```
+
+Defined in: [packages/db/src/types.ts:788](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L788)
+
+Whether to include the current state as initial changes
+
+***
+
+### onStatusChange()?
+
+```ts
+optional onStatusChange: (event) => void;
+```
+
+Defined in: [packages/db/src/types.ts:811](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L811)
+
+**`Internal`**
+
+Listener for subscription status changes.
+Registered BEFORE any snapshot is requested, ensuring no status transitions are missed.
+
+#### Parameters
+
+##### event
+
+[`SubscriptionStatusChangeEvent`](SubscriptionStatusChangeEvent.md)
+
+#### Returns
+
+`void`
+
+***
+
+### where()?
+
+```ts
+optional where: (row) => any;
+```
+
+Defined in: [packages/db/src/types.ts:803](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L803)
+
+Callback function for filtering changes using a row proxy.
+The callback receives a proxy object that records property access,
+allowing you to use query builder functions like `eq`, `gt`, etc.
+
+#### Parameters
+
+##### row
+
+`SingleRowRefProxy`\<`T`\>
+
+#### Returns
+
+`any`
+
+#### Example
+
+```ts
+import { eq } from "@tanstack/db"
+
+collection.subscribeChanges(callback, {
+  where: (row) => eq(row.status, "active")
+})
+```
+
+***
+
+### whereExpression?
+
+```ts
+optional whereExpression: BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/types.ts:805](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L805)
+
+Pre-compiled expression for filtering changes
diff --git a/docs/reference/interfaces/SubscribeChangesSnapshotOptions.md b/docs/reference/interfaces/SubscribeChangesSnapshotOptions.md
new file mode 100644
index 000000000..2c0d7bc55
--- /dev/null
+++ b/docs/reference/interfaces/SubscribeChangesSnapshotOptions.md
@@ -0,0 +1,125 @@
+---
+id: SubscribeChangesSnapshotOptions
+title: SubscribeChangesSnapshotOptions
+---
+
+# Interface: SubscribeChangesSnapshotOptions\<T\>
+
+Defined in: [packages/db/src/types.ts:814](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L814)
+
+## Extends
+
+- `Omit`\<[`SubscribeChangesOptions`](SubscribeChangesOptions.md)\<`T`\>, `"includeInitialState"`\>
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+## Properties
+
+### limit?
+
+```ts
+optional limit: number;
+```
+
+Defined in: [packages/db/src/types.ts:818](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L818)
+
+***
+
+### onStatusChange()?
+
+```ts
+optional onStatusChange: (event) => void;
+```
+
+Defined in: [packages/db/src/types.ts:811](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L811)
+
+**`Internal`**
+
+Listener for subscription status changes.
+Registered BEFORE any snapshot is requested, ensuring no status transitions are missed.
+
+#### Parameters
+
+##### event
+
+[`SubscriptionStatusChangeEvent`](SubscriptionStatusChangeEvent.md)
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+```ts
+Omit.onStatusChange
+```
+
+***
+
+### orderBy?
+
+```ts
+optional orderBy: OrderBy;
+```
+
+Defined in: [packages/db/src/types.ts:817](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L817)
+
+***
+
+### where()?
+
+```ts
+optional where: (row) => any;
+```
+
+Defined in: [packages/db/src/types.ts:803](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L803)
+
+Callback function for filtering changes using a row proxy.
+The callback receives a proxy object that records property access,
+allowing you to use query builder functions like `eq`, `gt`, etc.
+
+#### Parameters
+
+##### row
+
+`SingleRowRefProxy`\<`T`\>
+
+#### Returns
+
+`any`
+
+#### Example
+
+```ts
+import { eq } from "@tanstack/db"
+
+collection.subscribeChanges(callback, {
+  where: (row) => eq(row.status, "active")
+})
+```
+
+#### Inherited from
+
+```ts
+Omit.where
+```
+
+***
+
+### whereExpression?
+
+```ts
+optional whereExpression: BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/types.ts:805](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L805)
+
+Pre-compiled expression for filtering changes
+
+#### Inherited from
+
+[`SubscribeChangesOptions`](SubscribeChangesOptions.md).[`whereExpression`](SubscribeChangesOptions.md#whereexpression)
diff --git a/docs/reference/interfaces/Subscription.md b/docs/reference/interfaces/Subscription.md
new file mode 100644
index 000000000..0aa55abe0
--- /dev/null
+++ b/docs/reference/interfaces/Subscription.md
@@ -0,0 +1,280 @@
+---
+id: Subscription
+title: Subscription
+---
+
+# Interface: Subscription
+
+Defined in: [packages/db/src/types.ts:252](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L252)
+
+Public interface for a collection subscription
+Used by sync implementations to track subscription lifecycle
+
+## Extends
+
+- `EventEmitter`\<[`SubscriptionEvents`](../type-aliases/SubscriptionEvents.md)\>
+
+## Properties
+
+### status
+
+```ts
+readonly status: SubscriptionStatus;
+```
+
+Defined in: [packages/db/src/types.ts:254](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L254)
+
+Current status of the subscription
+
+## Methods
+
+### clearListeners()
+
+```ts
+protected clearListeners(): void;
+```
+
+Defined in: [packages/db/src/event-emitter.ts:115](https://github.com/TanStack/db/blob/main/packages/db/src/event-emitter.ts#L115)
+
+Clear all listeners
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+```ts
+EventEmitter.clearListeners
+```
+
+***
+
+### emitInner()
+
+```ts
+protected emitInner<T>(event, eventPayload): void;
+```
+
+Defined in: [packages/db/src/event-emitter.ts:96](https://github.com/TanStack/db/blob/main/packages/db/src/event-emitter.ts#L96)
+
+**`Internal`**
+
+Emit an event to all listeners
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* keyof [`SubscriptionEvents`](../type-aliases/SubscriptionEvents.md)
+
+#### Parameters
+
+##### event
+
+`T`
+
+Event name to emit
+
+##### eventPayload
+
+[`SubscriptionEvents`](../type-aliases/SubscriptionEvents.md)\[`T`\]
+
+Event payload
+ For use by subclasses - subclasses should wrap this with a public emit if needed
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+```ts
+EventEmitter.emitInner
+```
+
+***
+
+### off()
+
+```ts
+off<T>(event, callback): void;
+```
+
+Defined in: [packages/db/src/event-emitter.ts:53](https://github.com/TanStack/db/blob/main/packages/db/src/event-emitter.ts#L53)
+
+Unsubscribe from an event
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* keyof [`SubscriptionEvents`](../type-aliases/SubscriptionEvents.md)
+
+#### Parameters
+
+##### event
+
+`T`
+
+Event name to stop listening for
+
+##### callback
+
+(`event`) => `void`
+
+Function to remove
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+```ts
+EventEmitter.off
+```
+
+***
+
+### on()
+
+```ts
+on<T>(event, callback): () => void;
+```
+
+Defined in: [packages/db/src/event-emitter.ts:17](https://github.com/TanStack/db/blob/main/packages/db/src/event-emitter.ts#L17)
+
+Subscribe to an event
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* keyof [`SubscriptionEvents`](../type-aliases/SubscriptionEvents.md)
+
+#### Parameters
+
+##### event
+
+`T`
+
+Event name to listen for
+
+##### callback
+
+(`event`) => `void`
+
+Function to call when event is emitted
+
+#### Returns
+
+Unsubscribe function
+
+```ts
+(): void;
+```
+
+##### Returns
+
+`void`
+
+#### Inherited from
+
+```ts
+EventEmitter.on
+```
+
+***
+
+### once()
+
+```ts
+once<T>(event, callback): () => void;
+```
+
+Defined in: [packages/db/src/event-emitter.ts:37](https://github.com/TanStack/db/blob/main/packages/db/src/event-emitter.ts#L37)
+
+Subscribe to an event once (automatically unsubscribes after first emission)
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* keyof [`SubscriptionEvents`](../type-aliases/SubscriptionEvents.md)
+
+#### Parameters
+
+##### event
+
+`T`
+
+Event name to listen for
+
+##### callback
+
+(`event`) => `void`
+
+Function to call when event is emitted
+
+#### Returns
+
+Unsubscribe function
+
+```ts
+(): void;
+```
+
+##### Returns
+
+`void`
+
+#### Inherited from
+
+```ts
+EventEmitter.once
+```
+
+***
+
+### waitFor()
+
+```ts
+waitFor<T>(event, timeout?): Promise<SubscriptionEvents[T]>;
+```
+
+Defined in: [packages/db/src/event-emitter.ts:66](https://github.com/TanStack/db/blob/main/packages/db/src/event-emitter.ts#L66)
+
+Wait for an event to be emitted
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* keyof [`SubscriptionEvents`](../type-aliases/SubscriptionEvents.md)
+
+#### Parameters
+
+##### event
+
+`T`
+
+Event name to wait for
+
+##### timeout?
+
+`number`
+
+Optional timeout in milliseconds
+
+#### Returns
+
+`Promise`\<[`SubscriptionEvents`](../type-aliases/SubscriptionEvents.md)\[`T`\]\>
+
+Promise that resolves with the event payload
+
+#### Inherited from
+
+```ts
+EventEmitter.waitFor
+```
diff --git a/docs/reference/interfaces/SubscriptionStatusChangeEvent.md b/docs/reference/interfaces/SubscriptionStatusChangeEvent.md
new file mode 100644
index 000000000..ed2298b09
--- /dev/null
+++ b/docs/reference/interfaces/SubscriptionStatusChangeEvent.md
@@ -0,0 +1,50 @@
+---
+id: SubscriptionStatusChangeEvent
+title: SubscriptionStatusChangeEvent
+---
+
+# Interface: SubscriptionStatusChangeEvent
+
+Defined in: [packages/db/src/types.ts:213](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L213)
+
+Event emitted when subscription status changes
+
+## Properties
+
+### previousStatus
+
+```ts
+previousStatus: SubscriptionStatus;
+```
+
+Defined in: [packages/db/src/types.ts:216](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L216)
+
+***
+
+### status
+
+```ts
+status: SubscriptionStatus;
+```
+
+Defined in: [packages/db/src/types.ts:217](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L217)
+
+***
+
+### subscription
+
+```ts
+subscription: Subscription;
+```
+
+Defined in: [packages/db/src/types.ts:215](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L215)
+
+***
+
+### type
+
+```ts
+type: "status:change";
+```
+
+Defined in: [packages/db/src/types.ts:214](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L214)
diff --git a/docs/reference/interfaces/SubscriptionStatusEvent.md b/docs/reference/interfaces/SubscriptionStatusEvent.md
new file mode 100644
index 000000000..0d55a134d
--- /dev/null
+++ b/docs/reference/interfaces/SubscriptionStatusEvent.md
@@ -0,0 +1,56 @@
+---
+id: SubscriptionStatusEvent
+title: SubscriptionStatusEvent
+---
+
+# Interface: SubscriptionStatusEvent\<T\>
+
+Defined in: [packages/db/src/types.ts:223](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L223)
+
+Event emitted when subscription status changes to a specific status
+
+## Type Parameters
+
+### T
+
+`T` *extends* [`SubscriptionStatus`](../type-aliases/SubscriptionStatus.md)
+
+## Properties
+
+### previousStatus
+
+```ts
+previousStatus: SubscriptionStatus;
+```
+
+Defined in: [packages/db/src/types.ts:226](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L226)
+
+***
+
+### status
+
+```ts
+status: T;
+```
+
+Defined in: [packages/db/src/types.ts:227](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L227)
+
+***
+
+### subscription
+
+```ts
+subscription: Subscription;
+```
+
+Defined in: [packages/db/src/types.ts:225](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L225)
+
+***
+
+### type
+
+```ts
+type: `status:${T}`;
+```
+
+Defined in: [packages/db/src/types.ts:224](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L224)
diff --git a/docs/reference/interfaces/SubscriptionUnsubscribedEvent.md b/docs/reference/interfaces/SubscriptionUnsubscribedEvent.md
new file mode 100644
index 000000000..6eea86fa2
--- /dev/null
+++ b/docs/reference/interfaces/SubscriptionUnsubscribedEvent.md
@@ -0,0 +1,30 @@
+---
+id: SubscriptionUnsubscribedEvent
+title: SubscriptionUnsubscribedEvent
+---
+
+# Interface: SubscriptionUnsubscribedEvent
+
+Defined in: [packages/db/src/types.ts:233](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L233)
+
+Event emitted when subscription is unsubscribed
+
+## Properties
+
+### subscription
+
+```ts
+subscription: Subscription;
+```
+
+Defined in: [packages/db/src/types.ts:235](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L235)
+
+***
+
+### type
+
+```ts
+type: "unsubscribed";
+```
+
+Defined in: [packages/db/src/types.ts:234](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L234)
diff --git a/docs/reference/interfaces/SyncConfig.md b/docs/reference/interfaces/SyncConfig.md
new file mode 100644
index 000000000..2ac2c3230
--- /dev/null
+++ b/docs/reference/interfaces/SyncConfig.md
@@ -0,0 +1,106 @@
+---
+id: SyncConfig
+title: SyncConfig
+---
+
+# Interface: SyncConfig\<T, TKey\>
+
+Defined in: [packages/db/src/types.ts:325](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L325)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+## Properties
+
+### getSyncMetadata()?
+
+```ts
+optional getSyncMetadata: () => Record<string, unknown>;
+```
+
+Defined in: [packages/db/src/types.ts:347](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L347)
+
+Get the sync metadata for insert operations
+
+#### Returns
+
+`Record`\<`string`, `unknown`\>
+
+Record containing relation information
+
+***
+
+### rowUpdateMode?
+
+```ts
+optional rowUpdateMode: "full" | "partial";
+```
+
+Defined in: [packages/db/src/types.ts:356](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L356)
+
+The row update mode used to sync to the collection.
+
+#### Default
+
+`partial`
+
+#### Description
+
+- `partial`: Updates contain only the changes to the row.
+- `full`: Updates contain the entire row.
+
+***
+
+### sync()
+
+```ts
+sync: (params) => 
+  | void
+  | CleanupFn
+  | SyncConfigRes;
+```
+
+Defined in: [packages/db/src/types.ts:329](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L329)
+
+#### Parameters
+
+##### params
+
+###### begin
+
+(`options?`) => `void`
+
+Begin a new sync transaction.
+
+###### collection
+
+[`Collection`](Collection.md)\<`T`, `TKey`, `any`, `any`, `any`\>
+
+###### commit
+
+() => `void`
+
+###### markReady
+
+() => `void`
+
+###### truncate
+
+() => `void`
+
+###### write
+
+(`message`) => `void`
+
+#### Returns
+
+  \| `void`
+  \| [`CleanupFn`](../type-aliases/CleanupFn.md)
+  \| [`SyncConfigRes`](../type-aliases/SyncConfigRes.md)
diff --git a/docs/reference/interfaces/ThrottleStrategy.md b/docs/reference/interfaces/ThrottleStrategy.md
new file mode 100644
index 000000000..0732d3b3a
--- /dev/null
+++ b/docs/reference/interfaces/ThrottleStrategy.md
@@ -0,0 +1,97 @@
+---
+id: ThrottleStrategy
+title: ThrottleStrategy
+---
+
+# Interface: ThrottleStrategy
+
+Defined in: [packages/db/src/strategies/types.ts:86](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L86)
+
+Throttle strategy that spaces executions evenly over time
+
+## Extends
+
+- [`BaseStrategy`](BaseStrategy.md)\<`"throttle"`\>
+
+## Properties
+
+### \_type
+
+```ts
+_type: "throttle";
+```
+
+Defined in: [packages/db/src/strategies/types.ts:8](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L8)
+
+Type discriminator for strategy identification
+
+#### Inherited from
+
+[`BaseStrategy`](BaseStrategy.md).[`_type`](BaseStrategy.md#_type)
+
+***
+
+### cleanup()
+
+```ts
+cleanup: () => void;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:23](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L23)
+
+Clean up any resources held by the strategy
+Should be called when the strategy is no longer needed
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`BaseStrategy`](BaseStrategy.md).[`cleanup`](BaseStrategy.md#cleanup)
+
+***
+
+### execute()
+
+```ts
+execute: <T>(fn) => void | Promise<void>;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:15](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L15)
+
+Execute a function according to the strategy's timing rules
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+#### Parameters
+
+##### fn
+
+() => [`Transaction`](Transaction.md)\<`T`\>
+
+The function to execute
+
+#### Returns
+
+`void` \| `Promise`\<`void`\>
+
+The result of the function execution (if applicable)
+
+#### Inherited from
+
+[`BaseStrategy`](BaseStrategy.md).[`execute`](BaseStrategy.md#execute)
+
+***
+
+### options
+
+```ts
+options: ThrottleStrategyOptions;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:87](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L87)
diff --git a/docs/reference/interfaces/ThrottleStrategyOptions.md b/docs/reference/interfaces/ThrottleStrategyOptions.md
new file mode 100644
index 000000000..ab54fdeb0
--- /dev/null
+++ b/docs/reference/interfaces/ThrottleStrategyOptions.md
@@ -0,0 +1,47 @@
+---
+id: ThrottleStrategyOptions
+title: ThrottleStrategyOptions
+---
+
+# Interface: ThrottleStrategyOptions
+
+Defined in: [packages/db/src/strategies/types.ts:74](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L74)
+
+Options for throttle strategy
+Ensures executions are evenly spaced over time
+
+## Properties
+
+### leading?
+
+```ts
+optional leading: boolean;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:78](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L78)
+
+Execute immediately on the first call
+
+***
+
+### trailing?
+
+```ts
+optional trailing: boolean;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:80](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L80)
+
+Execute on the last call after wait period
+
+***
+
+### wait
+
+```ts
+wait: number;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:76](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L76)
+
+Minimum wait time between executions (milliseconds)
diff --git a/docs/reference/classes/transaction.md b/docs/reference/interfaces/Transaction.md
similarity index 55%
rename from docs/reference/classes/transaction.md
rename to docs/reference/interfaces/Transaction.md
index a0fa7dc46..cffa50699 100644
--- a/docs/reference/classes/transaction.md
+++ b/docs/reference/interfaces/Transaction.md
@@ -3,35 +3,15 @@ id: Transaction
 title: Transaction
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
+# Interface: Transaction\<T\>
 
-# Class: Transaction\<T\>
-
-Defined in: [packages/db/src/transactions.ts:116](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L116)
+Defined in: [packages/db/src/transactions.ts:208](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L208)
 
 ## Type Parameters
 
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-## Constructors
-
-### new Transaction()
-
-```ts
-new Transaction<T>(config): Transaction<T>
-```
-
-Defined in: [packages/db/src/transactions.ts:131](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L131)
-
-#### Parameters
-
-##### config
+### T
 
-[`TransactionConfig`](../../interfaces/transactionconfig.md)\<`T`\>
-
-#### Returns
-
-[`Transaction`](../transaction.md)\<`T`\>
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
 
 ## Properties
 
@@ -41,7 +21,7 @@ Defined in: [packages/db/src/transactions.ts:131](https://github.com/TanStack/db
 autoCommit: boolean;
 ```
 
-Defined in: [packages/db/src/transactions.ts:122](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L122)
+Defined in: [packages/db/src/transactions.ts:214](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L214)
 
 ***
 
@@ -51,7 +31,7 @@ Defined in: [packages/db/src/transactions.ts:122](https://github.com/TanStack/db
 createdAt: Date;
 ```
 
-Defined in: [packages/db/src/transactions.ts:123](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L123)
+Defined in: [packages/db/src/transactions.ts:215](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L215)
 
 ***
 
@@ -61,7 +41,7 @@ Defined in: [packages/db/src/transactions.ts:123](https://github.com/TanStack/db
 optional error: object;
 ```
 
-Defined in: [packages/db/src/transactions.ts:126](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L126)
+Defined in: [packages/db/src/transactions.ts:218](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L218)
 
 #### error
 
@@ -83,7 +63,7 @@ message: string;
 id: string;
 ```
 
-Defined in: [packages/db/src/transactions.ts:117](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L117)
+Defined in: [packages/db/src/transactions.ts:209](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L209)
 
 ***
 
@@ -93,7 +73,7 @@ Defined in: [packages/db/src/transactions.ts:117](https://github.com/TanStack/db
 isPersisted: Deferred<Transaction<T>>;
 ```
 
-Defined in: [packages/db/src/transactions.ts:121](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L121)
+Defined in: [packages/db/src/transactions.ts:213](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L213)
 
 ***
 
@@ -103,7 +83,7 @@ Defined in: [packages/db/src/transactions.ts:121](https://github.com/TanStack/db
 metadata: Record<string, unknown>;
 ```
 
-Defined in: [packages/db/src/transactions.ts:125](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L125)
+Defined in: [packages/db/src/transactions.ts:217](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L217)
 
 ***
 
@@ -113,7 +93,7 @@ Defined in: [packages/db/src/transactions.ts:125](https://github.com/TanStack/db
 mutationFn: MutationFn<T>;
 ```
 
-Defined in: [packages/db/src/transactions.ts:119](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L119)
+Defined in: [packages/db/src/transactions.ts:211](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L211)
 
 ***
 
@@ -123,7 +103,7 @@ Defined in: [packages/db/src/transactions.ts:119](https://github.com/TanStack/db
 mutations: PendingMutation<T, OperationType, Collection<T, any, any, any, any>>[];
 ```
 
-Defined in: [packages/db/src/transactions.ts:120](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L120)
+Defined in: [packages/db/src/transactions.ts:212](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L212)
 
 ***
 
@@ -133,7 +113,7 @@ Defined in: [packages/db/src/transactions.ts:120](https://github.com/TanStack/db
 sequenceNumber: number;
 ```
 
-Defined in: [packages/db/src/transactions.ts:124](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L124)
+Defined in: [packages/db/src/transactions.ts:216](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L216)
 
 ***
 
@@ -143,23 +123,39 @@ Defined in: [packages/db/src/transactions.ts:124](https://github.com/TanStack/db
 state: TransactionState;
 ```
 
-Defined in: [packages/db/src/transactions.ts:118](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L118)
+Defined in: [packages/db/src/transactions.ts:210](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L210)
 
 ## Methods
 
 ### applyMutations()
 
 ```ts
-applyMutations(mutations): void
+applyMutations(mutations): void;
 ```
 
-Defined in: [packages/db/src/transactions.ts:212](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L212)
+Defined in: [packages/db/src/transactions.ts:327](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L327)
+
+Apply new mutations to this transaction, intelligently merging with existing mutations
+
+When mutations operate on the same item (same globalKey), they are merged according to
+the following rules:
+
+- **insert + update** → insert (merge changes, keep empty original)
+- **insert + delete** → removed (mutations cancel each other out)
+- **update + delete** → delete (delete dominates)
+- **update + update** → update (union changes, keep first original)
+- **same type** → replace with latest
+
+This merging reduces over-the-wire churn and keeps the optimistic local view
+aligned with user intent.
 
 #### Parameters
 
 ##### mutations
 
-[`PendingMutation`](../../interfaces/pendingmutation.md)\<`any`, [`OperationType`](../../type-aliases/operationtype.md), [`Collection`](../../interfaces/collection.md)\<`any`, `any`, `any`, `any`, `any`\>\>[]
+[`PendingMutation`](PendingMutation.md)\<`any`, [`OperationType`](../type-aliases/OperationType.md), [`Collection`](Collection.md)\<`any`, `any`, `any`, `any`, `any`\>\>[]
+
+Array of new mutations to apply
 
 #### Returns
 
@@ -170,16 +166,16 @@ Defined in: [packages/db/src/transactions.ts:212](https://github.com/TanStack/db
 ### commit()
 
 ```ts
-commit(): Promise<Transaction<T>>
+commit(): Promise<Transaction<T>>;
 ```
 
-Defined in: [packages/db/src/transactions.ts:349](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L349)
+Defined in: [packages/db/src/transactions.ts:472](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L472)
 
 Commit the transaction and execute the mutation function
 
 #### Returns
 
-`Promise`\<[`Transaction`](../transaction.md)\<`T`\>\>
+`Promise`\<`Transaction`\<`T`\>\>
 
 Promise that resolves to this transaction when complete
 
@@ -229,10 +225,10 @@ console.log(tx.state) // "completed" or "failed"
 ### compareCreatedAt()
 
 ```ts
-compareCreatedAt(other): number
+compareCreatedAt(other): number;
 ```
 
-Defined in: [packages/db/src/transactions.ts:395](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L395)
+Defined in: [packages/db/src/transactions.ts:526](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L526)
 
 Compare two transactions by their createdAt time and sequence number in order
 to sort them in the order they were created.
@@ -241,7 +237,7 @@ to sort them in the order they were created.
 
 ##### other
 
-[`Transaction`](../transaction.md)\<`any`\>
+`Transaction`\<`any`\>
 
 The other transaction to compare to
 
@@ -256,10 +252,10 @@ The other transaction to compare to
 ### mutate()
 
 ```ts
-mutate(callback): Transaction<T>
+mutate(callback): Transaction<T>;
 ```
 
-Defined in: [packages/db/src/transactions.ts:193](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L193)
+Defined in: [packages/db/src/transactions.ts:287](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L287)
 
 Execute collection operations within this transaction
 
@@ -269,11 +265,13 @@ Execute collection operations within this transaction
 
 () => `void`
 
-Function containing collection operations to group together
+Function containing collection operations to group together. If the
+callback returns a Promise, the transaction context will remain active until the promise
+settles, allowing optimistic writes after `await` boundaries.
 
 #### Returns
 
-[`Transaction`](../transaction.md)\<`T`\>
+`Transaction`\<`T`\>
 
 This transaction for chaining
 
@@ -322,10 +320,10 @@ await tx.commit()
 ### rollback()
 
 ```ts
-rollback(config?): Transaction<T>
+rollback(config?): Transaction<T>;
 ```
 
-Defined in: [packages/db/src/transactions.ts:266](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L266)
+Defined in: [packages/db/src/transactions.ts:389](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L389)
 
 Rollback the transaction and any conflicting transactions
 
@@ -341,7 +339,7 @@ Configuration for rollback behavior
 
 #### Returns
 
-[`Transaction`](../transaction.md)\<`T`\>
+`Transaction`\<`T`\>
 
 This transaction for chaining
 
@@ -389,16 +387,16 @@ try {
 ### setState()
 
 ```ts
-setState(newState): void
+setState(newState): void;
 ```
 
-Defined in: [packages/db/src/transactions.ts:146](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L146)
+Defined in: [packages/db/src/transactions.ts:238](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L238)
 
 #### Parameters
 
 ##### newState
 
-[`TransactionState`](../../type-aliases/transactionstate.md)
+[`TransactionState`](../type-aliases/TransactionState.md)
 
 #### Returns
 
@@ -409,10 +407,10 @@ Defined in: [packages/db/src/transactions.ts:146](https://github.com/TanStack/db
 ### touchCollection()
 
 ```ts
-touchCollection(): void
+touchCollection(): void;
 ```
 
-Defined in: [packages/db/src/transactions.ts:294](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L294)
+Defined in: [packages/db/src/transactions.ts:417](https://github.com/TanStack/db/blob/main/packages/db/src/transactions.ts#L417)
 
 #### Returns
 
diff --git a/docs/reference/interfaces/transactionconfig.md b/docs/reference/interfaces/TransactionConfig.md
similarity index 59%
rename from docs/reference/interfaces/transactionconfig.md
rename to docs/reference/interfaces/TransactionConfig.md
index 3ac87e3ed..ae5f413e9 100644
--- a/docs/reference/interfaces/transactionconfig.md
+++ b/docs/reference/interfaces/TransactionConfig.md
@@ -3,15 +3,15 @@ id: TransactionConfig
 title: TransactionConfig
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Interface: TransactionConfig\<T\>
 
-Defined in: [packages/db/src/types.ts:161](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L161)
+Defined in: [packages/db/src/types.ts:166](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L166)
 
 ## Type Parameters
 
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
 
 ## Properties
 
@@ -21,7 +21,7 @@ Defined in: [packages/db/src/types.ts:161](https://github.com/TanStack/db/blob/m
 optional autoCommit: boolean;
 ```
 
-Defined in: [packages/db/src/types.ts:165](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L165)
+Defined in: [packages/db/src/types.ts:170](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L170)
 
 ***
 
@@ -31,7 +31,7 @@ Defined in: [packages/db/src/types.ts:165](https://github.com/TanStack/db/blob/m
 optional id: string;
 ```
 
-Defined in: [packages/db/src/types.ts:163](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L163)
+Defined in: [packages/db/src/types.ts:168](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L168)
 
 Unique identifier for the transaction
 
@@ -43,7 +43,7 @@ Unique identifier for the transaction
 optional metadata: Record<string, unknown>;
 ```
 
-Defined in: [packages/db/src/types.ts:168](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L168)
+Defined in: [packages/db/src/types.ts:173](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L173)
 
 Custom metadata to associate with the transaction
 
@@ -55,4 +55,4 @@ Custom metadata to associate with the transaction
 mutationFn: MutationFn<T>;
 ```
 
-Defined in: [packages/db/src/types.ts:166](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L166)
+Defined in: [packages/db/src/types.ts:171](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L171)
diff --git a/docs/reference/interfaces/changemessage.md b/docs/reference/interfaces/changemessage.md
deleted file mode 100644
index 9a80bf276..000000000
--- a/docs/reference/interfaces/changemessage.md
+++ /dev/null
@@ -1,70 +0,0 @@
----
-id: ChangeMessage
-title: ChangeMessage
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: ChangeMessage\<T, TKey\>
-
-Defined in: [packages/db/src/types.ts:228](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L228)
-
-## Extended by
-
-- [`OptimisticChangeMessage`](../optimisticchangemessage.md)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-## Properties
-
-### key
-
-```ts
-key: TKey;
-```
-
-Defined in: [packages/db/src/types.ts:232](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L232)
-
-***
-
-### metadata?
-
-```ts
-optional metadata: Record<string, unknown>;
-```
-
-Defined in: [packages/db/src/types.ts:236](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L236)
-
-***
-
-### previousValue?
-
-```ts
-optional previousValue: T;
-```
-
-Defined in: [packages/db/src/types.ts:234](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L234)
-
-***
-
-### type
-
-```ts
-type: OperationType;
-```
-
-Defined in: [packages/db/src/types.ts:235](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L235)
-
-***
-
-### value
-
-```ts
-value: T;
-```
-
-Defined in: [packages/db/src/types.ts:233](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L233)
diff --git a/docs/reference/interfaces/collection.md b/docs/reference/interfaces/collection.md
deleted file mode 100644
index ad819550d..000000000
--- a/docs/reference/interfaces/collection.md
+++ /dev/null
@@ -1,1462 +0,0 @@
----
-id: Collection
-title: Collection
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: Collection\<T, TKey, TUtils, TSchema, TInsertInput\>
-
-Defined in: [packages/db/src/collection.ts:77](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L77)
-
-Enhanced Collection interface that includes both data type T and utilities TUtils
-
-## Extends
-
-- [`CollectionImpl`](../../classes/collectionimpl.md)\<`T`, `TKey`, `TUtils`, `TSchema`, `TInsertInput`\>
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-The type of items in the collection
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-The type of the key for the collection
-
-• **TUtils** *extends* [`UtilsRecord`](../../type-aliases/utilsrecord.md) = \{\}
-
-The utilities record type
-
-• **TSchema** *extends* `StandardSchemaV1` = `StandardSchemaV1`
-
-• **TInsertInput** *extends* `object` = `T`
-
-The type for insert operations (can be different from T for schemas with defaults)
-
-## Properties
-
-### config
-
-```ts
-config: CollectionConfig<T, TKey, TSchema, TInsertInput>;
-```
-
-Defined in: [packages/db/src/collection.ts:211](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L211)
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`config`](../../classes/CollectionImpl.md#config-1)
-
-***
-
-### id
-
-```ts
-id: string;
-```
-
-Defined in: [packages/db/src/collection.ts:331](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L331)
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`id`](../../classes/CollectionImpl.md#id)
-
-***
-
-### optimisticDeletes
-
-```ts
-optimisticDeletes: Set<TKey>;
-```
-
-Defined in: [packages/db/src/collection.ts:221](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L221)
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`optimisticDeletes`](../../classes/CollectionImpl.md#optimisticdeletes)
-
-***
-
-### optimisticUpserts
-
-```ts
-optimisticUpserts: Map<TKey, T>;
-```
-
-Defined in: [packages/db/src/collection.ts:220](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L220)
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`optimisticUpserts`](../../classes/CollectionImpl.md#optimisticupserts)
-
-***
-
-### pendingSyncedTransactions
-
-```ts
-pendingSyncedTransactions: PendingSyncedTransaction<T>[] = [];
-```
-
-Defined in: [packages/db/src/collection.ts:215](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L215)
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`pendingSyncedTransactions`](../../classes/CollectionImpl.md#pendingsyncedtransactions)
-
-***
-
-### syncedData
-
-```ts
-syncedData: 
-  | Map<TKey, T>
-| SortedMap<TKey, T>;
-```
-
-Defined in: [packages/db/src/collection.ts:216](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L216)
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`syncedData`](../../classes/CollectionImpl.md#synceddata)
-
-***
-
-### syncedMetadata
-
-```ts
-syncedMetadata: Map<TKey, unknown>;
-```
-
-Defined in: [packages/db/src/collection.ts:217](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L217)
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`syncedMetadata`](../../classes/CollectionImpl.md#syncedmetadata)
-
-***
-
-### transactions
-
-```ts
-transactions: SortedMap<string, Transaction<any>>;
-```
-
-Defined in: [packages/db/src/collection.ts:214](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L214)
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`transactions`](../../classes/CollectionImpl.md#transactions)
-
-***
-
-### utils
-
-```ts
-readonly utils: TUtils;
-```
-
-Defined in: [packages/db/src/collection.ts:84](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L84)
-
-#### Overrides
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`utils`](../../classes/CollectionImpl.md#utils)
-
-## Accessors
-
-### indexes
-
-#### Get Signature
-
-```ts
-get indexes(): Map<number, BaseIndex<TKey>>
-```
-
-Defined in: [packages/db/src/collection.ts:1439](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1439)
-
-Get resolved indexes for query optimization
-
-##### Returns
-
-`Map`\<`number`, [`BaseIndex`](../../classes/baseindex.md)\<`TKey`\>\>
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`indexes`](../../classes/CollectionImpl.md#indexes)
-
-***
-
-### size
-
-#### Get Signature
-
-```ts
-get size(): number
-```
-
-Defined in: [packages/db/src/collection.ts:995](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L995)
-
-Get the current size of the collection (cached)
-
-##### Returns
-
-`number`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`size`](../../classes/CollectionImpl.md#size)
-
-***
-
-### state
-
-#### Get Signature
-
-```ts
-get state(): Map<TKey, T>
-```
-
-Defined in: [packages/db/src/collection.ts:2038](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2038)
-
-Gets the current state of the collection as a Map
-
-##### Example
-
-```ts
-const itemsMap = collection.state
-console.log(`Collection has ${itemsMap.size} items`)
-
-for (const [key, item] of itemsMap) {
-  console.log(`${key}: ${item.title}`)
-}
-
-// Check if specific item exists
-if (itemsMap.has("todo-1")) {
-  console.log("Todo 1 exists:", itemsMap.get("todo-1"))
-}
-```
-
-##### Returns
-
-`Map`\<`TKey`, `T`\>
-
-Map containing all items in the collection, with keys as identifiers
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`state`](../../classes/CollectionImpl.md#state)
-
-***
-
-### status
-
-#### Get Signature
-
-```ts
-get status(): CollectionStatus
-```
-
-Defined in: [packages/db/src/collection.ts:336](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L336)
-
-Gets the current status of the collection
-
-##### Returns
-
-[`CollectionStatus`](../../type-aliases/collectionstatus.md)
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`status`](../../classes/CollectionImpl.md#status)
-
-***
-
-### toArray
-
-#### Get Signature
-
-```ts
-get toArray(): T[]
-```
-
-Defined in: [packages/db/src/collection.ts:2071](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2071)
-
-Gets the current state of the collection as an Array
-
-##### Returns
-
-`T`[]
-
-An Array containing all items in the collection
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`toArray`](../../classes/CollectionImpl.md#toarray)
-
-## Methods
-
-### \[iterator\]()
-
-```ts
-iterator: IterableIterator<[TKey, T]>
-```
-
-Defined in: [packages/db/src/collection.ts:1046](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1046)
-
-Get all entries (virtual derived state)
-
-#### Returns
-
-`IterableIterator`\<\[`TKey`, `T`\]\>
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`[iterator]`](../../classes/CollectionImpl.md#iterator)
-
-***
-
-### cleanup()
-
-```ts
-cleanup(): Promise<void>
-```
-
-Defined in: [packages/db/src/collection.ts:583](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L583)
-
-Clean up the collection by stopping sync and clearing data
-This can be called manually or automatically by garbage collection
-
-#### Returns
-
-`Promise`\<`void`\>
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`cleanup`](../../classes/CollectionImpl.md#cleanup)
-
-***
-
-### commitPendingTransactions()
-
-```ts
-commitPendingTransactions(): void
-```
-
-Defined in: [packages/db/src/collection.ts:1082](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1082)
-
-Attempts to commit pending synced transactions if there are no active transactions
-This method processes operations from pending transactions and applies them to the synced data
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`commitPendingTransactions`](../../classes/CollectionImpl.md#commitpendingtransactions)
-
-***
-
-### createIndex()
-
-```ts
-createIndex<TResolver>(indexCallback, config): IndexProxy<TKey>
-```
-
-Defined in: [packages/db/src/collection.ts:1344](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1344)
-
-Creates an index on a collection for faster queries.
-Indexes significantly improve query performance by allowing binary search
-and range queries instead of full scans.
-
-#### Type Parameters
-
-• **TResolver** *extends* [`IndexResolver`](../../type-aliases/indexresolver.md)\<`TKey`\> = *typeof* [`BTreeIndex`](../../classes/btreeindex.md)
-
-The type of the index resolver (constructor or async loader)
-
-#### Parameters
-
-##### indexCallback
-
-(`row`) => `any`
-
-Function that extracts the indexed value from each item
-
-##### config
-
-[`IndexOptions`](../indexoptions.md)\<`TResolver`\> = `{}`
-
-Configuration including index type and type-specific options
-
-#### Returns
-
-[`IndexProxy`](../../classes/indexproxy.md)\<`TKey`\>
-
-An index proxy that provides access to the index when ready
-
-#### Example
-
-```ts
-// Create a default B+ tree index
-const ageIndex = collection.createIndex((row) => row.age)
-
-// Create a ordered index with custom options
-const ageIndex = collection.createIndex((row) => row.age, {
-  indexType: BTreeIndex,
-  options: { compareFn: customComparator },
-  name: 'age_btree'
-})
-
-// Create an async-loaded index
-const textIndex = collection.createIndex((row) => row.content, {
-  indexType: async () => {
-    const { FullTextIndex } = await import('./indexes/fulltext.js')
-    return FullTextIndex
-  },
-  options: { language: 'en' }
-})
-```
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`createIndex`](../../classes/CollectionImpl.md#createindex)
-
-***
-
-### currentStateAsChanges()
-
-```ts
-currentStateAsChanges(options): ChangeMessage<T, string | number>[]
-```
-
-Defined in: [packages/db/src/collection.ts:2113](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2113)
-
-Returns the current state of the collection as an array of changes
-
-#### Parameters
-
-##### options
-
-[`CurrentStateAsChangesOptions`](../currentstateaschangesoptions.md)\<`T`\> = `{}`
-
-Options including optional where filter
-
-#### Returns
-
-[`ChangeMessage`](../changemessage.md)\<`T`, `string` \| `number`\>[]
-
-An array of changes
-
-#### Example
-
-```ts
-// Get all items as changes
-const allChanges = collection.currentStateAsChanges()
-
-// Get only items matching a condition
-const activeChanges = collection.currentStateAsChanges({
-  where: (row) => row.status === 'active'
-})
-
-// Get only items using a pre-compiled expression
-const activeChanges = collection.currentStateAsChanges({
-  whereExpression: eq(row.status, 'active')
-})
-```
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`currentStateAsChanges`](../../classes/CollectionImpl.md#currentstateaschanges)
-
-***
-
-### delete()
-
-```ts
-delete(keys, config?): Transaction<any>
-```
-
-Defined in: [packages/db/src/collection.ts:1939](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1939)
-
-Deletes one or more items from the collection
-
-#### Parameters
-
-##### keys
-
-Single key or array of keys to delete
-
-`TKey` | `TKey`[]
-
-##### config?
-
-[`OperationConfig`](../operationconfig.md)
-
-Optional configuration including metadata
-
-#### Returns
-
-[`Transaction`](../../classes/transaction.md)\<`any`\>
-
-A Transaction object representing the delete operation(s)
-
-#### Examples
-
-```ts
-// Delete a single item
-const tx = collection.delete("todo-1")
-await tx.isPersisted.promise
-```
-
-```ts
-// Delete multiple items
-const tx = collection.delete(["todo-1", "todo-2"])
-await tx.isPersisted.promise
-```
-
-```ts
-// Delete with metadata
-const tx = collection.delete("todo-1", { metadata: { reason: "completed" } })
-await tx.isPersisted.promise
-```
-
-```ts
-// Handle errors
-try {
-  const tx = collection.delete("item-1")
-  await tx.isPersisted.promise
-  console.log('Delete successful')
-} catch (error) {
-  console.log('Delete failed:', error)
-}
-```
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`delete`](../../classes/CollectionImpl.md#delete)
-
-***
-
-### entries()
-
-```ts
-entries(): IterableIterator<[TKey, T]>
-```
-
-Defined in: [packages/db/src/collection.ts:1034](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1034)
-
-Get all entries (virtual derived state)
-
-#### Returns
-
-`IterableIterator`\<\[`TKey`, `T`\]\>
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`entries`](../../classes/CollectionImpl.md#entries)
-
-***
-
-### forEach()
-
-```ts
-forEach(callbackfn): void
-```
-
-Defined in: [packages/db/src/collection.ts:1055](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1055)
-
-Execute a callback for each entry in the collection
-
-#### Parameters
-
-##### callbackfn
-
-(`value`, `key`, `index`) => `void`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`forEach`](../../classes/CollectionImpl.md#foreach)
-
-***
-
-### generateGlobalKey()
-
-```ts
-generateGlobalKey(key, item): string
-```
-
-Defined in: [packages/db/src/collection.ts:1306](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1306)
-
-#### Parameters
-
-##### key
-
-`any`
-
-##### item
-
-`any`
-
-#### Returns
-
-`string`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`generateGlobalKey`](../../classes/CollectionImpl.md#generateglobalkey)
-
-***
-
-### get()
-
-```ts
-get(key): undefined | T
-```
-
-Defined in: [packages/db/src/collection.ts:959](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L959)
-
-Get the current value for a key (virtual derived state)
-
-#### Parameters
-
-##### key
-
-`TKey`
-
-#### Returns
-
-`undefined` \| `T`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`get`](../../classes/CollectionImpl.md#get)
-
-***
-
-### getKeyFromItem()
-
-```ts
-getKeyFromItem(item): TKey
-```
-
-Defined in: [packages/db/src/collection.ts:1302](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1302)
-
-#### Parameters
-
-##### item
-
-`T`
-
-#### Returns
-
-`TKey`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`getKeyFromItem`](../../classes/CollectionImpl.md#getkeyfromitem)
-
-***
-
-### has()
-
-```ts
-has(key): boolean
-```
-
-Defined in: [packages/db/src/collection.ts:977](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L977)
-
-Check if a key exists in the collection (virtual derived state)
-
-#### Parameters
-
-##### key
-
-`TKey`
-
-#### Returns
-
-`boolean`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`has`](../../classes/CollectionImpl.md#has)
-
-***
-
-### insert()
-
-```ts
-insert(data, config?): 
-  | Transaction<Record<string, unknown>>
-| Transaction<T>
-```
-
-Defined in: [packages/db/src/collection.ts:1594](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1594)
-
-Inserts one or more items into the collection
-
-#### Parameters
-
-##### data
-
-`TInsertInput` | `TInsertInput`[]
-
-##### config?
-
-[`InsertConfig`](../insertconfig.md)
-
-Optional configuration including metadata
-
-#### Returns
-
-  \| [`Transaction`](../../classes/transaction.md)\<`Record`\<`string`, `unknown`\>\>
-  \| [`Transaction`](../../classes/transaction.md)\<`T`\>
-
-A Transaction object representing the insert operation(s)
-
-#### Throws
-
-If the data fails schema validation
-
-#### Examples
-
-```ts
-// Insert a single todo (requires onInsert handler)
-const tx = collection.insert({ id: "1", text: "Buy milk", completed: false })
-await tx.isPersisted.promise
-```
-
-```ts
-// Insert multiple todos at once
-const tx = collection.insert([
-  { id: "1", text: "Buy milk", completed: false },
-  { id: "2", text: "Walk dog", completed: true }
-])
-await tx.isPersisted.promise
-```
-
-```ts
-// Insert with metadata
-const tx = collection.insert({ id: "1", text: "Buy groceries" },
-  { metadata: { source: "mobile-app" } }
-)
-await tx.isPersisted.promise
-```
-
-```ts
-// Handle errors
-try {
-  const tx = collection.insert({ id: "1", text: "New item" })
-  await tx.isPersisted.promise
-  console.log('Insert successful')
-} catch (error) {
-  console.log('Insert failed:', error)
-}
-```
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`insert`](../../classes/CollectionImpl.md#insert)
-
-***
-
-### isReady()
-
-```ts
-isReady(): boolean
-```
-
-Defined in: [packages/db/src/collection.ts:294](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L294)
-
-Check if the collection is ready for use
-Returns true if the collection has been marked as ready by its sync implementation
-
-#### Returns
-
-`boolean`
-
-true if the collection is ready, false otherwise
-
-#### Example
-
-```ts
-if (collection.isReady()) {
-  console.log('Collection is ready, data is available')
-  // Safe to access collection.state
-} else {
-  console.log('Collection is still loading')
-}
-```
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`isReady`](../../classes/CollectionImpl.md#isready)
-
-***
-
-### keys()
-
-```ts
-keys(): IterableIterator<TKey>
-```
-
-Defined in: [packages/db/src/collection.ts:1002](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1002)
-
-Get all keys (virtual derived state)
-
-#### Returns
-
-`IterableIterator`\<`TKey`\>
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`keys`](../../classes/CollectionImpl.md#keys-1)
-
-***
-
-### map()
-
-```ts
-map<U>(callbackfn): U[]
-```
-
-Defined in: [packages/db/src/collection.ts:1067](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1067)
-
-Create a new array with the results of calling a function for each entry in the collection
-
-#### Type Parameters
-
-• **U**
-
-#### Parameters
-
-##### callbackfn
-
-(`value`, `key`, `index`) => `U`
-
-#### Returns
-
-`U`[]
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`map`](../../classes/CollectionImpl.md#map)
-
-***
-
-### onFirstReady()
-
-```ts
-onFirstReady(callback): void
-```
-
-Defined in: [packages/db/src/collection.ts:272](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L272)
-
-Register a callback to be executed when the collection first becomes ready
-Useful for preloading collections
-
-#### Parameters
-
-##### callback
-
-() => `void`
-
-Function to call when the collection first becomes ready
-
-#### Returns
-
-`void`
-
-#### Example
-
-```ts
-collection.onFirstReady(() => {
-  console.log('Collection is ready for the first time')
-  // Safe to access collection.state now
-})
-```
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`onFirstReady`](../../classes/CollectionImpl.md#onfirstready)
-
-***
-
-### onTransactionStateChange()
-
-```ts
-onTransactionStateChange(): void
-```
-
-Defined in: [packages/db/src/collection.ts:2271](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2271)
-
-Trigger a recomputation when transactions change
-This method should be called by the Transaction class when state changes
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`onTransactionStateChange`](../../classes/CollectionImpl.md#ontransactionstatechange)
-
-***
-
-### preload()
-
-```ts
-preload(): Promise<void>
-```
-
-Defined in: [packages/db/src/collection.ts:544](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L544)
-
-Preload the collection data by starting sync if not already started
-Multiple concurrent calls will share the same promise
-
-#### Returns
-
-`Promise`\<`void`\>
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`preload`](../../classes/CollectionImpl.md#preload)
-
-***
-
-### startSyncImmediate()
-
-```ts
-startSyncImmediate(): void
-```
-
-Defined in: [packages/db/src/collection.ts:450](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L450)
-
-Start sync immediately - internal method for compiled queries
-This bypasses lazy loading for special cases like live query results
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`startSyncImmediate`](../../classes/CollectionImpl.md#startsyncimmediate)
-
-***
-
-### stateWhenReady()
-
-```ts
-stateWhenReady(): Promise<Map<TKey, T>>
-```
-
-Defined in: [packages/db/src/collection.ts:2052](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2052)
-
-Gets the current state of the collection as a Map, but only resolves when data is available
-Waits for the first sync commit to complete before resolving
-
-#### Returns
-
-`Promise`\<`Map`\<`TKey`, `T`\>\>
-
-Promise that resolves to a Map containing all items in the collection
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`stateWhenReady`](../../classes/CollectionImpl.md#statewhenready)
-
-***
-
-### subscribeChanges()
-
-```ts
-subscribeChanges(callback, options): () => void
-```
-
-Defined in: [packages/db/src/collection.ts:2158](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2158)
-
-Subscribe to changes in the collection
-
-#### Parameters
-
-##### callback
-
-(`changes`) => `void`
-
-Function called when items change
-
-##### options
-
-[`SubscribeChangesOptions`](../subscribechangesoptions.md)\<`T`\> = `{}`
-
-Subscription options including includeInitialState and where filter
-
-#### Returns
-
-`Function`
-
-Unsubscribe function - Call this to stop listening for changes
-
-##### Returns
-
-`void`
-
-#### Examples
-
-```ts
-// Basic subscription
-const unsubscribe = collection.subscribeChanges((changes) => {
-  changes.forEach(change => {
-    console.log(`${change.type}: ${change.key}`, change.value)
-  })
-})
-
-// Later: unsubscribe()
-```
-
-```ts
-// Include current state immediately
-const unsubscribe = collection.subscribeChanges((changes) => {
-  updateUI(changes)
-}, { includeInitialState: true })
-```
-
-```ts
-// Subscribe only to changes matching a condition
-const unsubscribe = collection.subscribeChanges((changes) => {
-  updateUI(changes)
-}, {
-  includeInitialState: true,
-  where: (row) => row.status === 'active'
-})
-```
-
-```ts
-// Subscribe using a pre-compiled expression
-const unsubscribe = collection.subscribeChanges((changes) => {
-  updateUI(changes)
-}, {
-  includeInitialState: true,
-  whereExpression: eq(row.status, 'active')
-})
-```
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`subscribeChanges`](../../classes/CollectionImpl.md#subscribechanges)
-
-***
-
-### subscribeChangesKey()
-
-```ts
-subscribeChangesKey(
-   key, 
-   listener, 
-   __namedParameters): () => void
-```
-
-Defined in: [packages/db/src/collection.ts:2197](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2197)
-
-Subscribe to changes for a specific key
-
-#### Parameters
-
-##### key
-
-`TKey`
-
-##### listener
-
-[`ChangeListener`](../../type-aliases/changelistener.md)\<`T`, `TKey`\>
-
-##### \_\_namedParameters
-
-###### includeInitialState?
-
-`boolean` = `false`
-
-#### Returns
-
-`Function`
-
-##### Returns
-
-`void`
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`subscribeChangesKey`](../../classes/CollectionImpl.md#subscribechangeskey)
-
-***
-
-### toArrayWhenReady()
-
-```ts
-toArrayWhenReady(): Promise<T[]>
-```
-
-Defined in: [packages/db/src/collection.ts:2081](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L2081)
-
-Gets the current state of the collection as an Array, but only resolves when data is available
-Waits for the first sync commit to complete before resolving
-
-#### Returns
-
-`Promise`\<`T`[]\>
-
-Promise that resolves to an Array containing all items in the collection
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`toArrayWhenReady`](../../classes/CollectionImpl.md#toarraywhenready)
-
-***
-
-### update()
-
-#### Call Signature
-
-```ts
-update<TItem>(key, callback): Transaction
-```
-
-Defined in: [packages/db/src/collection.ts:1725](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1725)
-
-Updates one or more items in the collection using a callback function
-
-##### Type Parameters
-
-• **TItem** *extends* `object` = `T`
-
-##### Parameters
-
-###### key
-
-`unknown`[]
-
-###### callback
-
-(`drafts`) => `void`
-
-##### Returns
-
-[`Transaction`](../../classes/transaction.md)
-
-A Transaction object representing the update operation(s)
-
-##### Throws
-
-If the updated data fails schema validation
-
-##### Examples
-
-```ts
-// Update single item by key
-const tx = collection.update("todo-1", (draft) => {
-  draft.completed = true
-})
-await tx.isPersisted.promise
-```
-
-```ts
-// Update multiple items
-const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
-  drafts.forEach(draft => { draft.completed = true })
-})
-await tx.isPersisted.promise
-```
-
-```ts
-// Update with metadata
-const tx = collection.update("todo-1",
-  { metadata: { reason: "user update" } },
-  (draft) => { draft.text = "Updated text" }
-)
-await tx.isPersisted.promise
-```
-
-```ts
-// Handle errors
-try {
-  const tx = collection.update("item-1", draft => { draft.value = "new" })
-  await tx.isPersisted.promise
-  console.log('Update successful')
-} catch (error) {
-  console.log('Update failed:', error)
-}
-```
-
-##### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`update`](../../classes/CollectionImpl.md#update)
-
-#### Call Signature
-
-```ts
-update<TItem>(
-   keys, 
-   config, 
-   callback): Transaction
-```
-
-Defined in: [packages/db/src/collection.ts:1731](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1731)
-
-Updates one or more items in the collection using a callback function
-
-##### Type Parameters
-
-• **TItem** *extends* `object` = `T`
-
-##### Parameters
-
-###### keys
-
-`unknown`[]
-
-Single key or array of keys to update
-
-###### config
-
-[`OperationConfig`](../operationconfig.md)
-
-###### callback
-
-(`drafts`) => `void`
-
-##### Returns
-
-[`Transaction`](../../classes/transaction.md)
-
-A Transaction object representing the update operation(s)
-
-##### Throws
-
-If the updated data fails schema validation
-
-##### Examples
-
-```ts
-// Update single item by key
-const tx = collection.update("todo-1", (draft) => {
-  draft.completed = true
-})
-await tx.isPersisted.promise
-```
-
-```ts
-// Update multiple items
-const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
-  drafts.forEach(draft => { draft.completed = true })
-})
-await tx.isPersisted.promise
-```
-
-```ts
-// Update with metadata
-const tx = collection.update("todo-1",
-  { metadata: { reason: "user update" } },
-  (draft) => { draft.text = "Updated text" }
-)
-await tx.isPersisted.promise
-```
-
-```ts
-// Handle errors
-try {
-  const tx = collection.update("item-1", draft => { draft.value = "new" })
-  await tx.isPersisted.promise
-  console.log('Update successful')
-} catch (error) {
-  console.log('Update failed:', error)
-}
-```
-
-##### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`update`](../../classes/CollectionImpl.md#update)
-
-#### Call Signature
-
-```ts
-update<TItem>(id, callback): Transaction
-```
-
-Defined in: [packages/db/src/collection.ts:1738](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1738)
-
-Updates one or more items in the collection using a callback function
-
-##### Type Parameters
-
-• **TItem** *extends* `object` = `T`
-
-##### Parameters
-
-###### id
-
-`unknown`
-
-###### callback
-
-(`draft`) => `void`
-
-##### Returns
-
-[`Transaction`](../../classes/transaction.md)
-
-A Transaction object representing the update operation(s)
-
-##### Throws
-
-If the updated data fails schema validation
-
-##### Examples
-
-```ts
-// Update single item by key
-const tx = collection.update("todo-1", (draft) => {
-  draft.completed = true
-})
-await tx.isPersisted.promise
-```
-
-```ts
-// Update multiple items
-const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
-  drafts.forEach(draft => { draft.completed = true })
-})
-await tx.isPersisted.promise
-```
-
-```ts
-// Update with metadata
-const tx = collection.update("todo-1",
-  { metadata: { reason: "user update" } },
-  (draft) => { draft.text = "Updated text" }
-)
-await tx.isPersisted.promise
-```
-
-```ts
-// Handle errors
-try {
-  const tx = collection.update("item-1", draft => { draft.value = "new" })
-  await tx.isPersisted.promise
-  console.log('Update successful')
-} catch (error) {
-  console.log('Update failed:', error)
-}
-```
-
-##### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`update`](../../classes/CollectionImpl.md#update)
-
-#### Call Signature
-
-```ts
-update<TItem>(
-   id, 
-   config, 
-   callback): Transaction
-```
-
-Defined in: [packages/db/src/collection.ts:1744](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1744)
-
-Updates one or more items in the collection using a callback function
-
-##### Type Parameters
-
-• **TItem** *extends* `object` = `T`
-
-##### Parameters
-
-###### id
-
-`unknown`
-
-###### config
-
-[`OperationConfig`](../operationconfig.md)
-
-###### callback
-
-(`draft`) => `void`
-
-##### Returns
-
-[`Transaction`](../../classes/transaction.md)
-
-A Transaction object representing the update operation(s)
-
-##### Throws
-
-If the updated data fails schema validation
-
-##### Examples
-
-```ts
-// Update single item by key
-const tx = collection.update("todo-1", (draft) => {
-  draft.completed = true
-})
-await tx.isPersisted.promise
-```
-
-```ts
-// Update multiple items
-const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
-  drafts.forEach(draft => { draft.completed = true })
-})
-await tx.isPersisted.promise
-```
-
-```ts
-// Update with metadata
-const tx = collection.update("todo-1",
-  { metadata: { reason: "user update" } },
-  (draft) => { draft.text = "Updated text" }
-)
-await tx.isPersisted.promise
-```
-
-```ts
-// Handle errors
-try {
-  const tx = collection.update("item-1", draft => { draft.value = "new" })
-  await tx.isPersisted.promise
-  console.log('Update successful')
-} catch (error) {
-  console.log('Update failed:', error)
-}
-```
-
-##### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`update`](../../classes/CollectionImpl.md#update)
-
-***
-
-### values()
-
-```ts
-values(): IterableIterator<T>
-```
-
-Defined in: [packages/db/src/collection.ts:1022](https://github.com/TanStack/db/blob/main/packages/db/src/collection.ts#L1022)
-
-Get all values (virtual derived state)
-
-#### Returns
-
-`IterableIterator`\<`T`\>
-
-#### Inherited from
-
-[`CollectionImpl`](../../classes/collectionimpl.md).[`values`](../../classes/CollectionImpl.md#values)
diff --git a/docs/reference/interfaces/context.md b/docs/reference/interfaces/context.md
deleted file mode 100644
index 1504e1892..000000000
--- a/docs/reference/interfaces/context.md
+++ /dev/null
@@ -1,70 +0,0 @@
----
-id: Context
-title: Context
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: Context
-
-Defined in: [packages/db/src/query/builder/types.ts:5](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L5)
-
-## Properties
-
-### baseSchema
-
-```ts
-baseSchema: ContextSchema;
-```
-
-Defined in: [packages/db/src/query/builder/types.ts:7](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L7)
-
-***
-
-### fromSourceName
-
-```ts
-fromSourceName: string;
-```
-
-Defined in: [packages/db/src/query/builder/types.ts:11](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L11)
-
-***
-
-### hasJoins?
-
-```ts
-optional hasJoins: boolean;
-```
-
-Defined in: [packages/db/src/query/builder/types.ts:13](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L13)
-
-***
-
-### joinTypes?
-
-```ts
-optional joinTypes: Record<string, "full" | "left" | "right" | "inner" | "outer" | "cross">;
-```
-
-Defined in: [packages/db/src/query/builder/types.ts:15](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L15)
-
-***
-
-### result?
-
-```ts
-optional result: any;
-```
-
-Defined in: [packages/db/src/query/builder/types.ts:20](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L20)
-
-***
-
-### schema
-
-```ts
-schema: ContextSchema;
-```
-
-Defined in: [packages/db/src/query/builder/types.ts:9](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L9)
diff --git a/docs/reference/interfaces/currentstateaschangesoptions.md b/docs/reference/interfaces/currentstateaschangesoptions.md
deleted file mode 100644
index 30b723bcf..000000000
--- a/docs/reference/interfaces/currentstateaschangesoptions.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-id: CurrentStateAsChangesOptions
-title: CurrentStateAsChangesOptions
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: CurrentStateAsChangesOptions\<T\>
-
-Defined in: [packages/db/src/types.ts:587](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L587)
-
-Options for getting current state as changes
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-## Properties
-
-### where()?
-
-```ts
-optional where: (row) => any;
-```
-
-Defined in: [packages/db/src/types.ts:591](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L591)
-
-Filter the current state using a where expression
-
-#### Parameters
-
-##### row
-
-`SingleRowRefProxy`\<`T`\>
-
-#### Returns
-
-`any`
-
-***
-
-### whereExpression?
-
-```ts
-optional whereExpression: BasicExpression<boolean>;
-```
-
-Defined in: [packages/db/src/types.ts:593](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L593)
-
-Pre-compiled expression for filtering the current state
diff --git a/docs/reference/interfaces/insertconfig.md b/docs/reference/interfaces/insertconfig.md
deleted file mode 100644
index 0c85a0933..000000000
--- a/docs/reference/interfaces/insertconfig.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-id: InsertConfig
-title: InsertConfig
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: InsertConfig
-
-Defined in: [packages/db/src/types.ts:270](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L270)
-
-## Properties
-
-### metadata?
-
-```ts
-optional metadata: Record<string, unknown>;
-```
-
-Defined in: [packages/db/src/types.ts:271](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L271)
-
-***
-
-### optimistic?
-
-```ts
-optional optimistic: boolean;
-```
-
-Defined in: [packages/db/src/types.ts:273](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L273)
-
-Whether to apply optimistic updates immediately. Defaults to true.
diff --git a/docs/reference/interfaces/livequerycollectionconfig.md b/docs/reference/interfaces/livequerycollectionconfig.md
deleted file mode 100644
index 96d1a0718..000000000
--- a/docs/reference/interfaces/livequerycollectionconfig.md
+++ /dev/null
@@ -1,158 +0,0 @@
----
-id: LiveQueryCollectionConfig
-title: LiveQueryCollectionConfig
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: LiveQueryCollectionConfig\<TContext, TResult\>
-
-Defined in: [packages/db/src/query/live-query-collection.ts:47](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L47)
-
-Configuration interface for live query collection options
-
-## Example
-
-```typescript
-const config: LiveQueryCollectionConfig<any, any> = {
-  // id is optional - will auto-generate "live-query-1", "live-query-2", etc.
-  query: (q) => q
-    .from({ comment: commentsCollection })
-    .join(
-      { user: usersCollection },
-      ({ comment, user }) => eq(comment.user_id, user.id)
-    )
-    .where(({ comment }) => eq(comment.active, true))
-    .select(({ comment, user }) => ({
-      id: comment.id,
-      content: comment.content,
-      authorName: user.name,
-    })),
-  // getKey is optional - defaults to using stream key
-  getKey: (item) => item.id,
-}
-```
-
-## Type Parameters
-
-• **TContext** *extends* [`Context`](../context.md)
-
-• **TResult** *extends* `object` = [`GetResult`](../../type-aliases/getresult.md)\<`TContext`\> & `object`
-
-## Properties
-
-### gcTime?
-
-```ts
-optional gcTime: number;
-```
-
-Defined in: [packages/db/src/query/live-query-collection.ts:90](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L90)
-
-GC time for the collection
-
-***
-
-### getKey()?
-
-```ts
-optional getKey: (item) => string | number;
-```
-
-Defined in: [packages/db/src/query/live-query-collection.ts:68](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L68)
-
-Function to extract the key from result items
-If not provided, defaults to using the key from the D2 stream
-
-#### Parameters
-
-##### item
-
-`TResult`
-
-#### Returns
-
-`string` \| `number`
-
-***
-
-### id?
-
-```ts
-optional id: string;
-```
-
-Defined in: [packages/db/src/query/live-query-collection.ts:55](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L55)
-
-Unique identifier for the collection
-If not provided, defaults to `live-query-${number}` with auto-incrementing number
-
-***
-
-### onDelete?
-
-```ts
-optional onDelete: DeleteMutationFn<TResult, string | number, Record<string, Fn>>;
-```
-
-Defined in: [packages/db/src/query/live-query-collection.ts:80](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L80)
-
-***
-
-### onInsert?
-
-```ts
-optional onInsert: InsertMutationFn<TResult, string | number, Record<string, Fn>>;
-```
-
-Defined in: [packages/db/src/query/live-query-collection.ts:78](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L78)
-
-Optional mutation handlers
-
-***
-
-### onUpdate?
-
-```ts
-optional onUpdate: UpdateMutationFn<TResult, string | number, Record<string, Fn>>;
-```
-
-Defined in: [packages/db/src/query/live-query-collection.ts:79](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L79)
-
-***
-
-### query
-
-```ts
-query: 
-  | QueryBuilder<TContext>
-| (q) => QueryBuilder<TContext>;
-```
-
-Defined in: [packages/db/src/query/live-query-collection.ts:60](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L60)
-
-Query builder function that defines the live query
-
-***
-
-### schema?
-
-```ts
-optional schema: StandardSchemaV1<unknown, unknown>;
-```
-
-Defined in: [packages/db/src/query/live-query-collection.ts:73](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L73)
-
-Optional schema for validation
-
-***
-
-### startSync?
-
-```ts
-optional startSync: boolean;
-```
-
-Defined in: [packages/db/src/query/live-query-collection.ts:85](https://github.com/TanStack/db/blob/main/packages/db/src/query/live-query-collection.ts#L85)
-
-Start sync / the query immediately
diff --git a/docs/reference/interfaces/localonlycollectionconfig.md b/docs/reference/interfaces/localonlycollectionconfig.md
deleted file mode 100644
index 0144346e7..000000000
--- a/docs/reference/interfaces/localonlycollectionconfig.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-id: LocalOnlyCollectionConfig
-title: LocalOnlyCollectionConfig
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: LocalOnlyCollectionConfig\<TExplicit, TSchema, TFallback, TKey\>
-
-Defined in: [packages/db/src/local-only.ts:27](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L27)
-
-Configuration interface for Local-only collection options
-
-## Remarks
-
-Type resolution follows a priority order:
-1. If you provide an explicit type via generic parameter, it will be used
-2. If no explicit type is provided but a schema is, the schema's output type will be inferred
-3. If neither explicit type nor schema is provided, the fallback type will be used
-
-You should provide EITHER an explicit type OR a schema, but not both, as they would conflict.
-
-## Type Parameters
-
-• **TExplicit** = `unknown`
-
-The explicit type of items in the collection (highest priority)
-
-• **TSchema** *extends* `StandardSchemaV1` = `never`
-
-The schema type for validation and type inference (second priority)
-
-• **TFallback** *extends* `Record`\<`string`, `unknown`\> = `Record`\<`string`, `unknown`\>
-
-The fallback type if no explicit or schema type is provided
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-The type of the key returned by getKey
-
-## Properties
-
-### getKey()
-
-```ts
-getKey: (item) => TKey;
-```
-
-Defined in: [packages/db/src/local-only.ts:38](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L38)
-
-#### Parameters
-
-##### item
-
-[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>
-
-#### Returns
-
-`TKey`
-
-***
-
-### id?
-
-```ts
-optional id: string;
-```
-
-Defined in: [packages/db/src/local-only.ts:36](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L36)
-
-Standard Collection configuration properties
-
-***
-
-### initialData?
-
-```ts
-optional initialData: ResolveType<TExplicit, TSchema, TFallback>[];
-```
-
-Defined in: [packages/db/src/local-only.ts:44](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L44)
-
-Optional initial data to populate the collection with on creation
-This data will be applied during the initial sync process
-
-***
-
-### onDelete()?
-
-```ts
-optional onDelete: (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/local-only.ts:77](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L77)
-
-Optional asynchronous handler function called after a delete operation
-
-#### Parameters
-
-##### params
-
-[`DeleteMutationFnParams`](../../type-aliases/deletemutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>, `TKey`, [`LocalOnlyCollectionUtils`](../localonlycollectionutils.md)\>
-
-Object containing transaction and collection information
-
-#### Returns
-
-`Promise`\<`any`\>
-
-Promise resolving to any value
-
-***
-
-### onInsert()?
-
-```ts
-optional onInsert: (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/local-only.ts:51](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L51)
-
-Optional asynchronous handler function called after an insert operation
-
-#### Parameters
-
-##### params
-
-[`InsertMutationFnParams`](../../type-aliases/insertmutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>, `TKey`, [`LocalOnlyCollectionUtils`](../localonlycollectionutils.md)\>
-
-Object containing transaction and collection information
-
-#### Returns
-
-`Promise`\<`any`\>
-
-Promise resolving to any value
-
-***
-
-### onUpdate()?
-
-```ts
-optional onUpdate: (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/local-only.ts:64](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L64)
-
-Optional asynchronous handler function called after an update operation
-
-#### Parameters
-
-##### params
-
-[`UpdateMutationFnParams`](../../type-aliases/updatemutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>, `TKey`, [`LocalOnlyCollectionUtils`](../localonlycollectionutils.md)\>
-
-Object containing transaction and collection information
-
-#### Returns
-
-`Promise`\<`any`\>
-
-Promise resolving to any value
-
-***
-
-### schema?
-
-```ts
-optional schema: TSchema;
-```
-
-Defined in: [packages/db/src/local-only.ts:37](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L37)
diff --git a/docs/reference/interfaces/localonlycollectionutils.md b/docs/reference/interfaces/localonlycollectionutils.md
deleted file mode 100644
index d201c8d55..000000000
--- a/docs/reference/interfaces/localonlycollectionutils.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-id: LocalOnlyCollectionUtils
-title: LocalOnlyCollectionUtils
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: LocalOnlyCollectionUtils
-
-Defined in: [packages/db/src/local-only.ts:89](https://github.com/TanStack/db/blob/main/packages/db/src/local-only.ts#L89)
-
-Local-only collection utilities type (currently empty but matches the pattern)
-
-## Extends
-
-- [`UtilsRecord`](../../type-aliases/utilsrecord.md)
-
-## Indexable
-
-```ts
-[key: string]: Fn
-```
diff --git a/docs/reference/interfaces/localstoragecollectionconfig.md b/docs/reference/interfaces/localstoragecollectionconfig.md
deleted file mode 100644
index ae01344a3..000000000
--- a/docs/reference/interfaces/localstoragecollectionconfig.md
+++ /dev/null
@@ -1,203 +0,0 @@
----
-id: LocalStorageCollectionConfig
-title: LocalStorageCollectionConfig
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: LocalStorageCollectionConfig\<TExplicit, TSchema, TFallback\>
-
-Defined in: [packages/db/src/local-storage.ts:61](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L61)
-
-Configuration interface for localStorage collection options
-
-## Remarks
-
-Type resolution follows a priority order:
-1. If you provide an explicit type via generic parameter, it will be used
-2. If no explicit type is provided but a schema is, the schema's output type will be inferred
-3. If neither explicit type nor schema is provided, the fallback type will be used
-
-You should provide EITHER an explicit type OR a schema, but not both, as they would conflict.
-
-## Type Parameters
-
-• **TExplicit** = `unknown`
-
-The explicit type of items in the collection (highest priority)
-
-• **TSchema** *extends* `StandardSchemaV1` = `never`
-
-The schema type for validation and type inference (second priority)
-
-• **TFallback** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-The fallback type if no explicit or schema type is provided
-
-## Properties
-
-### getKey()
-
-```ts
-getKey: (item) => string | number;
-```
-
-Defined in: [packages/db/src/local-storage.ts:88](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L88)
-
-#### Parameters
-
-##### item
-
-[`ResolveType`](../../type-aliases/resolvetype.md)
-
-#### Returns
-
-`string` \| `number`
-
-***
-
-### id?
-
-```ts
-optional id: string;
-```
-
-Defined in: [packages/db/src/local-storage.ts:86](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L86)
-
-Collection identifier (defaults to "local-collection:{storageKey}" if not provided)
-
-***
-
-### onDelete()?
-
-```ts
-optional onDelete: (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/local-storage.ts:114](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L114)
-
-Optional asynchronous handler function called before a delete operation
-
-#### Parameters
-
-##### params
-
-[`DeleteMutationFnParams`](../../type-aliases/deletemutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-Object containing transaction and collection information
-
-#### Returns
-
-`Promise`\<`any`\>
-
-Promise resolving to any value
-
-***
-
-### onInsert()?
-
-```ts
-optional onInsert: (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/local-storage.ts:96](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L96)
-
-Optional asynchronous handler function called before an insert operation
-
-#### Parameters
-
-##### params
-
-[`InsertMutationFnParams`](../../type-aliases/insertmutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-Object containing transaction and collection information
-
-#### Returns
-
-`Promise`\<`any`\>
-
-Promise resolving to any value
-
-***
-
-### onUpdate()?
-
-```ts
-optional onUpdate: (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/local-storage.ts:105](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L105)
-
-Optional asynchronous handler function called before an update operation
-
-#### Parameters
-
-##### params
-
-[`UpdateMutationFnParams`](../../type-aliases/updatemutationfnparams.md)\<[`ResolveType`](../../type-aliases/resolvetype.md)\<`TExplicit`, `TSchema`, `TFallback`\>\>
-
-Object containing transaction and collection information
-
-#### Returns
-
-`Promise`\<`any`\>
-
-Promise resolving to any value
-
-***
-
-### schema?
-
-```ts
-optional schema: TSchema;
-```
-
-Defined in: [packages/db/src/local-storage.ts:87](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L87)
-
-***
-
-### storage?
-
-```ts
-optional storage: StorageApi;
-```
-
-Defined in: [packages/db/src/local-storage.ts:75](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L75)
-
-Storage API to use (defaults to window.localStorage)
-Can be any object that implements the Storage interface (e.g., sessionStorage)
-
-***
-
-### storageEventApi?
-
-```ts
-optional storageEventApi: StorageEventApi;
-```
-
-Defined in: [packages/db/src/local-storage.ts:81](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L81)
-
-Storage event API to use for cross-tab synchronization (defaults to window)
-Can be any object that implements addEventListener/removeEventListener for storage events
-
-***
-
-### storageKey
-
-```ts
-storageKey: string;
-```
-
-Defined in: [packages/db/src/local-storage.ts:69](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L69)
-
-The key to use for storing the collection data in localStorage/sessionStorage
-
-***
-
-### sync?
-
-```ts
-optional sync: SyncConfig<ResolveType<TExplicit, TSchema, TFallback>, string | number>;
-```
-
-Defined in: [packages/db/src/local-storage.ts:89](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L89)
diff --git a/docs/reference/interfaces/localstoragecollectionutils.md b/docs/reference/interfaces/localstoragecollectionutils.md
deleted file mode 100644
index de20a0d7b..000000000
--- a/docs/reference/interfaces/localstoragecollectionutils.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-id: LocalStorageCollectionUtils
-title: LocalStorageCollectionUtils
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: LocalStorageCollectionUtils
-
-Defined in: [packages/db/src/local-storage.ts:132](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L132)
-
-LocalStorage collection utilities type
-
-## Extends
-
-- [`UtilsRecord`](../../type-aliases/utilsrecord.md)
-
-## Indexable
-
-```ts
-[key: string]: Fn
-```
-
-## Properties
-
-### clearStorage
-
-```ts
-clearStorage: ClearStorageFn;
-```
-
-Defined in: [packages/db/src/local-storage.ts:133](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L133)
-
-***
-
-### getStorageSize
-
-```ts
-getStorageSize: GetStorageSizeFn;
-```
-
-Defined in: [packages/db/src/local-storage.ts:134](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L134)
diff --git a/docs/reference/interfaces/operationconfig.md b/docs/reference/interfaces/operationconfig.md
deleted file mode 100644
index 90c2260e6..000000000
--- a/docs/reference/interfaces/operationconfig.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-id: OperationConfig
-title: OperationConfig
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: OperationConfig
-
-Defined in: [packages/db/src/types.ts:264](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L264)
-
-## Properties
-
-### metadata?
-
-```ts
-optional metadata: Record<string, unknown>;
-```
-
-Defined in: [packages/db/src/types.ts:265](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L265)
-
-***
-
-### optimistic?
-
-```ts
-optional optimistic: boolean;
-```
-
-Defined in: [packages/db/src/types.ts:267](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L267)
-
-Whether to apply optimistic updates immediately. Defaults to true.
diff --git a/docs/reference/interfaces/optimisticchangemessage.md b/docs/reference/interfaces/optimisticchangemessage.md
deleted file mode 100644
index 7634a26e2..000000000
--- a/docs/reference/interfaces/optimisticchangemessage.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-id: OptimisticChangeMessage
-title: OptimisticChangeMessage
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: OptimisticChangeMessage\<T\>
-
-Defined in: [packages/db/src/types.ts:239](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L239)
-
-## Extends
-
-- [`ChangeMessage`](../changemessage.md)\<`T`\>
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-## Properties
-
-### isActive?
-
-```ts
-optional isActive: boolean;
-```
-
-Defined in: [packages/db/src/types.ts:243](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L243)
-
-***
-
-### key
-
-```ts
-key: string | number;
-```
-
-Defined in: [packages/db/src/types.ts:232](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L232)
-
-#### Inherited from
-
-[`ChangeMessage`](../changemessage.md).[`key`](../ChangeMessage.md#key)
-
-***
-
-### metadata?
-
-```ts
-optional metadata: Record<string, unknown>;
-```
-
-Defined in: [packages/db/src/types.ts:236](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L236)
-
-#### Inherited from
-
-[`ChangeMessage`](../changemessage.md).[`metadata`](../ChangeMessage.md#metadata)
-
-***
-
-### previousValue?
-
-```ts
-optional previousValue: T;
-```
-
-Defined in: [packages/db/src/types.ts:234](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L234)
-
-#### Inherited from
-
-[`ChangeMessage`](../changemessage.md).[`previousValue`](../ChangeMessage.md#previousvalue)
-
-***
-
-### type
-
-```ts
-type: OperationType;
-```
-
-Defined in: [packages/db/src/types.ts:235](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L235)
-
-#### Inherited from
-
-[`ChangeMessage`](../changemessage.md).[`type`](../ChangeMessage.md#type)
-
-***
-
-### value
-
-```ts
-value: T;
-```
-
-Defined in: [packages/db/src/types.ts:233](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L233)
-
-#### Inherited from
-
-[`ChangeMessage`](../changemessage.md).[`value`](../ChangeMessage.md#value)
diff --git a/docs/reference/interfaces/pendingmutation.md b/docs/reference/interfaces/pendingmutation.md
deleted file mode 100644
index 3483b8a23..000000000
--- a/docs/reference/interfaces/pendingmutation.md
+++ /dev/null
@@ -1,153 +0,0 @@
----
-id: PendingMutation
-title: PendingMutation
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: PendingMutation\<T, TOperation, TCollection\>
-
-Defined in: [packages/db/src/types.ts:103](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L103)
-
-Represents a pending mutation within a transaction
-Contains information about the original and modified data, as well as metadata
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TOperation** *extends* [`OperationType`](../../type-aliases/operationtype.md) = [`OperationType`](../../type-aliases/operationtype.md)
-
-• **TCollection** *extends* [`Collection`](../collection.md)\<`T`, `any`, `any`, `any`, `any`\> = [`Collection`](../collection.md)\<`T`, `any`, `any`, `any`, `any`\>
-
-## Properties
-
-### changes
-
-```ts
-changes: ResolveTransactionChanges<T, TOperation>;
-```
-
-Defined in: [packages/db/src/types.ts:120](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L120)
-
-***
-
-### collection
-
-```ts
-collection: TCollection;
-```
-
-Defined in: [packages/db/src/types.ts:131](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L131)
-
-***
-
-### createdAt
-
-```ts
-createdAt: Date;
-```
-
-Defined in: [packages/db/src/types.ts:129](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L129)
-
-***
-
-### globalKey
-
-```ts
-globalKey: string;
-```
-
-Defined in: [packages/db/src/types.ts:121](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L121)
-
-***
-
-### key
-
-```ts
-key: any;
-```
-
-Defined in: [packages/db/src/types.ts:123](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L123)
-
-***
-
-### metadata
-
-```ts
-metadata: unknown;
-```
-
-Defined in: [packages/db/src/types.ts:125](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L125)
-
-***
-
-### modified
-
-```ts
-modified: T;
-```
-
-Defined in: [packages/db/src/types.ts:118](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L118)
-
-***
-
-### mutationId
-
-```ts
-mutationId: string;
-```
-
-Defined in: [packages/db/src/types.ts:114](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L114)
-
-***
-
-### optimistic
-
-```ts
-optimistic: boolean;
-```
-
-Defined in: [packages/db/src/types.ts:128](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L128)
-
-Whether this mutation should be applied optimistically (defaults to true)
-
-***
-
-### original
-
-```ts
-original: TOperation extends "insert" ? object : T;
-```
-
-Defined in: [packages/db/src/types.ts:116](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L116)
-
-***
-
-### syncMetadata
-
-```ts
-syncMetadata: Record<string, unknown>;
-```
-
-Defined in: [packages/db/src/types.ts:126](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L126)
-
-***
-
-### type
-
-```ts
-type: TOperation;
-```
-
-Defined in: [packages/db/src/types.ts:124](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L124)
-
-***
-
-### updatedAt
-
-```ts
-updatedAt: Date;
-```
-
-Defined in: [packages/db/src/types.ts:130](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L130)
diff --git a/docs/reference/interfaces/subscribechangesoptions.md b/docs/reference/interfaces/subscribechangesoptions.md
deleted file mode 100644
index 8838c2c68..000000000
--- a/docs/reference/interfaces/subscribechangesoptions.md
+++ /dev/null
@@ -1,62 +0,0 @@
----
-id: SubscribeChangesOptions
-title: SubscribeChangesOptions
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: SubscribeChangesOptions\<T\>
-
-Defined in: [packages/db/src/types.ts:573](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L573)
-
-Options for subscribing to collection changes
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-## Properties
-
-### includeInitialState?
-
-```ts
-optional includeInitialState: boolean;
-```
-
-Defined in: [packages/db/src/types.ts:577](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L577)
-
-Whether to include the current state as initial changes
-
-***
-
-### where()?
-
-```ts
-optional where: (row) => any;
-```
-
-Defined in: [packages/db/src/types.ts:579](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L579)
-
-Filter changes using a where expression
-
-#### Parameters
-
-##### row
-
-`SingleRowRefProxy`\<`T`\>
-
-#### Returns
-
-`any`
-
-***
-
-### whereExpression?
-
-```ts
-optional whereExpression: BasicExpression<boolean>;
-```
-
-Defined in: [packages/db/src/types.ts:581](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L581)
-
-Pre-compiled expression for filtering changes
diff --git a/docs/reference/interfaces/syncconfig.md b/docs/reference/interfaces/syncconfig.md
deleted file mode 100644
index 422d5e0d7..000000000
--- a/docs/reference/interfaces/syncconfig.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-id: SyncConfig
-title: SyncConfig
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: SyncConfig\<T, TKey\>
-
-Defined in: [packages/db/src/types.ts:200](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L200)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-## Properties
-
-### getSyncMetadata()?
-
-```ts
-optional getSyncMetadata: () => Record<string, unknown>;
-```
-
-Defined in: [packages/db/src/types.ts:216](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L216)
-
-Get the sync metadata for insert operations
-
-#### Returns
-
-`Record`\<`string`, `unknown`\>
-
-Record containing relation information
-
-***
-
-### rowUpdateMode?
-
-```ts
-optional rowUpdateMode: "partial" | "full";
-```
-
-Defined in: [packages/db/src/types.ts:225](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L225)
-
-The row update mode used to sync to the collection.
-
-#### Default
-
-`partial`
-
-#### Description
-
-- `partial`: Updates contain only the changes to the row.
-- `full`: Updates contain the entire row.
-
-***
-
-### sync()
-
-```ts
-sync: (params) => void;
-```
-
-Defined in: [packages/db/src/types.ts:204](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L204)
-
-#### Parameters
-
-##### params
-
-###### begin
-
-() => `void`
-
-###### collection
-
-[`Collection`](../collection.md)\<`T`, `TKey`, `any`, `any`, `any`\>
-
-###### commit
-
-() => `void`
-
-###### markReady
-
-() => `void`
-
-###### write
-
-(`message`) => `void`
-
-#### Returns
-
-`void`
diff --git a/docs/reference/powersync-db-collection/classes/PowerSyncTransactor.md b/docs/reference/powersync-db-collection/classes/PowerSyncTransactor.md
new file mode 100644
index 000000000..e33ad5872
--- /dev/null
+++ b/docs/reference/powersync-db-collection/classes/PowerSyncTransactor.md
@@ -0,0 +1,285 @@
+---
+id: PowerSyncTransactor
+title: PowerSyncTransactor
+---
+
+# Class: PowerSyncTransactor
+
+Defined in: [PowerSyncTransactor.ts:54](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L54)
+
+Applies mutations to the PowerSync database. This method is called automatically by the collection's
+insert, update, and delete operations. You typically don't need to call this directly unless you
+have special transaction requirements.
+
+## Example
+
+```typescript
+// Create a collection
+const collection = createCollection(
+  powerSyncCollectionOptions<Document>({
+    database: db,
+    table: APP_SCHEMA.props.documents,
+  })
+)
+
+const addTx = createTransaction({
+  autoCommit: false,
+  mutationFn: async ({ transaction }) => {
+    await new PowerSyncTransactor({ database: db }).applyTransaction(transaction)
+  },
+})
+
+addTx.mutate(() => {
+  for (let i = 0; i < 5; i++) {
+    collection.insert({ id: randomUUID(), name: `tx-${i}` })
+  }
+})
+
+await addTx.commit()
+await addTx.isPersisted.promise
+```
+
+## Param
+
+The transaction containing mutations to apply
+
+## Constructors
+
+### Constructor
+
+```ts
+new PowerSyncTransactor(options): PowerSyncTransactor;
+```
+
+Defined in: [PowerSyncTransactor.ts:58](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L58)
+
+#### Parameters
+
+##### options
+
+[`TransactorOptions`](../type-aliases/TransactorOptions.md)
+
+#### Returns
+
+`PowerSyncTransactor`
+
+## Properties
+
+### database
+
+```ts
+database: AbstractPowerSyncDatabase;
+```
+
+Defined in: [PowerSyncTransactor.ts:55](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L55)
+
+***
+
+### pendingOperationStore
+
+```ts
+pendingOperationStore: PendingOperationStore;
+```
+
+Defined in: [PowerSyncTransactor.ts:56](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L56)
+
+## Methods
+
+### applyTransaction()
+
+```ts
+applyTransaction(transaction): Promise<void>;
+```
+
+Defined in: [PowerSyncTransactor.ts:66](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L66)
+
+Persists a Transaction to the PowerSync SQLite database.
+
+#### Parameters
+
+##### transaction
+
+`Transaction`\<`any`\>
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### getMutationCollectionMeta()
+
+```ts
+protected getMutationCollectionMeta(mutation): PowerSyncCollectionMeta<any>;
+```
+
+Defined in: [PowerSyncTransactor.ts:294](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L294)
+
+#### Parameters
+
+##### mutation
+
+`PendingMutation`\<`any`\>
+
+#### Returns
+
+[`PowerSyncCollectionMeta`](../type-aliases/PowerSyncCollectionMeta.md)\<`any`\>
+
+***
+
+### handleDelete()
+
+```ts
+protected handleDelete(
+   mutation, 
+   context, 
+waitForCompletion): Promise<PendingOperation | null>;
+```
+
+Defined in: [PowerSyncTransactor.ts:221](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L221)
+
+#### Parameters
+
+##### mutation
+
+`PendingMutation`\<`any`\>
+
+##### context
+
+`LockContext`
+
+##### waitForCompletion
+
+`boolean` = `false`
+
+#### Returns
+
+`Promise`\<`PendingOperation` \| `null`\>
+
+***
+
+### handleInsert()
+
+```ts
+protected handleInsert(
+   mutation, 
+   context, 
+waitForCompletion): Promise<PendingOperation | null>;
+```
+
+Defined in: [PowerSyncTransactor.ts:152](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L152)
+
+#### Parameters
+
+##### mutation
+
+`PendingMutation`\<`any`\>
+
+##### context
+
+`LockContext`
+
+##### waitForCompletion
+
+`boolean` = `false`
+
+#### Returns
+
+`Promise`\<`PendingOperation` \| `null`\>
+
+***
+
+### handleOperationWithCompletion()
+
+```ts
+protected handleOperationWithCompletion(
+   mutation, 
+   context, 
+   waitForCompletion, 
+handler): Promise<PendingOperation | null>;
+```
+
+Defined in: [PowerSyncTransactor.ts:263](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L263)
+
+Helper function which wraps a persistence operation by:
+- Fetching the mutation's collection's SQLite table details
+- Executing the mutation
+- Returning the last pending diff operation if required
+
+#### Parameters
+
+##### mutation
+
+`PendingMutation`\<`any`\>
+
+##### context
+
+`LockContext`
+
+##### waitForCompletion
+
+`boolean`
+
+##### handler
+
+(`tableName`, `mutation`, `serializeValue`) => `Promise`\<`void`\>
+
+#### Returns
+
+`Promise`\<`PendingOperation` \| `null`\>
+
+***
+
+### handleUpdate()
+
+```ts
+protected handleUpdate(
+   mutation, 
+   context, 
+waitForCompletion): Promise<PendingOperation | null>;
+```
+
+Defined in: [PowerSyncTransactor.ts:187](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L187)
+
+#### Parameters
+
+##### mutation
+
+`PendingMutation`\<`any`\>
+
+##### context
+
+`LockContext`
+
+##### waitForCompletion
+
+`boolean` = `false`
+
+#### Returns
+
+`Promise`\<`PendingOperation` \| `null`\>
+
+***
+
+### processMutationMetadata()
+
+```ts
+protected processMutationMetadata(mutation): string | null;
+```
+
+Defined in: [PowerSyncTransactor.ts:313](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L313)
+
+Processes collection mutation metadata for persistence to the database.
+We only support storing string metadata.
+
+#### Parameters
+
+##### mutation
+
+`PendingMutation`\<`any`\>
+
+#### Returns
+
+`string` \| `null`
+
+null if no metadata should be stored.
diff --git a/docs/reference/powersync-db-collection/functions/powerSyncCollectionOptions.md b/docs/reference/powersync-db-collection/functions/powerSyncCollectionOptions.md
new file mode 100644
index 000000000..a6dba45f7
--- /dev/null
+++ b/docs/reference/powersync-db-collection/functions/powerSyncCollectionOptions.md
@@ -0,0 +1,213 @@
+---
+id: powerSyncCollectionOptions
+title: powerSyncCollectionOptions
+---
+
+# Function: powerSyncCollectionOptions()
+
+Implementation of powerSyncCollectionOptions that handles both schema and non-schema configurations.
+
+## Call Signature
+
+```ts
+function powerSyncCollectionOptions<TTable>(config): EnhancedPowerSyncCollectionConfig<TTable, OptionalExtractedTable<TTable>, never>;
+```
+
+Defined in: [powersync.ts:71](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/powersync.ts#L71)
+
+Creates a PowerSync collection configuration with basic default validation.
+Input and Output types are the SQLite column types.
+
+### Type Parameters
+
+#### TTable
+
+`TTable` *extends* `Table`\<`ColumnsType`\> = `Table`\<`ColumnsType`\>
+
+### Parameters
+
+#### config
+
+`Omit`\<`BaseCollectionConfig`\<`ExtractedTable`\<`TTable`\>, `string`, `never`, `UtilsRecord`, `any`\>, `"onInsert"` \| `"onUpdate"` \| `"onDelete"` \| `"getKey"`\> & `object`
+
+### Returns
+
+[`EnhancedPowerSyncCollectionConfig`](../type-aliases/EnhancedPowerSyncCollectionConfig.md)\<`TTable`, `OptionalExtractedTable`\<`TTable`\>, `never`\>
+
+### Example
+
+```typescript
+const APP_SCHEMA = new Schema({
+  documents: new Table({
+    name: column.text,
+  }),
+})
+
+type Document = (typeof APP_SCHEMA)["types"]["documents"]
+
+const db = new PowerSyncDatabase({
+  database: {
+    dbFilename: "test.sqlite",
+  },
+  schema: APP_SCHEMA,
+})
+
+const collection = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.documents
+  })
+)
+```
+
+## Call Signature
+
+```ts
+function powerSyncCollectionOptions<TTable, TSchema>(config): CollectionConfig<InferPowerSyncOutputType<TTable, TSchema>, string, TSchema, UtilsRecord> & object & object;
+```
+
+Defined in: [powersync.ts:128](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/powersync.ts#L128)
+
+Creates a PowerSync collection configuration with schema validation.
+
+The input types satisfy the SQLite column types.
+
+The output types are defined by the provided schema. This schema can enforce additional
+validation or type transforms.
+Arbitrary output typed mutations are encoded to SQLite for persistence. We provide a basic standard
+serialization implementation to serialize column values. Custom or advanced types require providing additional
+serializer specifications. Partial column overrides can be supplied to `serializer`.
+
+### Type Parameters
+
+#### TTable
+
+`TTable` *extends* `Table`\<`ColumnsType`\>
+
+#### TSchema
+
+`TSchema` *extends* `StandardSchemaV1`\<`OptionalExtractedTable`\<`TTable`\>, `AnyTableColumnType`\<`TTable`\>\>
+
+### Parameters
+
+#### config
+
+`Omit`\<`BaseCollectionConfig`\<`ExtractedTable`\<`TTable`\>, `string`, `TSchema`, `UtilsRecord`, `any`\>, `"onInsert"` \| `"onUpdate"` \| `"onDelete"` \| `"getKey"`\> & `object` & [`SerializerConfig`](../type-aliases/SerializerConfig.md)\<`InferOutput`\<`TSchema`\>, `ExtractedTable`\<`TTable`\>\> & `object`
+
+### Returns
+
+`CollectionConfig`\<[`InferPowerSyncOutputType`](../type-aliases/InferPowerSyncOutputType.md)\<`TTable`, `TSchema`\>, `string`, `TSchema`, `UtilsRecord`\> & `object` & `object`
+
+### Example
+
+```typescript
+import { z } from "zod"
+
+// The PowerSync SQLite schema
+const APP_SCHEMA = new Schema({
+  documents: new Table({
+    name: column.text,
+    // Dates are stored as ISO date strings in SQLite
+    created_at: column.text
+  }),
+})
+
+// Advanced Zod validations. The output type of this schema
+// is constrained to the SQLite schema of APP_SCHEMA
+const schema = z.object({
+  id: z.string(),
+  // Notice that `name` is not nullable (is required) here and it has additional validation
+  name: z.string().min(3, { message: "Should be at least 3 characters" }).nullable(),
+  // The input type is still the SQLite string type. While collections will output smart Date instances.
+  created_at: z.string().transform(val => new Date(val))
+})
+
+const collection = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.documents,
+    schema,
+    serializer: {
+       // The default is toISOString, this is just to demonstrate custom overrides
+       created_at: (outputValue) => outputValue.toISOString(),
+    },
+  })
+)
+```
+
+## Call Signature
+
+```ts
+function powerSyncCollectionOptions<TTable, TSchema>(config): CollectionConfig<InferPowerSyncOutputType<TTable, TSchema>, string, TSchema, UtilsRecord> & object & object;
+```
+
+Defined in: [powersync.ts:196](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/powersync.ts#L196)
+
+Creates a PowerSync collection configuration with schema validation.
+
+The input types are not linked to the internal SQLite table types. This can
+give greater flexibility, e.g. by accepting rich types as input for `insert` or `update` operations.
+An additional `deserializationSchema` is required in order to process incoming SQLite updates to the output type.
+
+The output types are defined by the provided schema. This schema can enforce additional
+validation or type transforms.
+Arbitrary output typed mutations are encoded to SQLite for persistence. We provide a basic standard
+serialization implementation to serialize column values. Custom or advanced types require providing additional
+serializer specifications. Partial column overrides can be supplied to `serializer`.
+
+### Type Parameters
+
+#### TTable
+
+`TTable` *extends* `Table`\<`ColumnsType`\>
+
+#### TSchema
+
+`TSchema` *extends* `StandardSchemaV1`\<`AnyTableColumnType`\<`TTable`\>, `AnyTableColumnType`\<`TTable`\>\>
+
+### Parameters
+
+#### config
+
+`Omit`\<`BaseCollectionConfig`\<`ExtractedTable`\<`TTable`\>, `string`, `TSchema`, `UtilsRecord`, `any`\>, `"onInsert"` \| `"onUpdate"` \| `"onDelete"` \| `"getKey"`\> & `object` & [`SerializerConfig`](../type-aliases/SerializerConfig.md)\<`InferOutput`\<`TSchema`\>, `ExtractedTable`\<`TTable`\>\> & `object`
+
+### Returns
+
+`CollectionConfig`\<[`InferPowerSyncOutputType`](../type-aliases/InferPowerSyncOutputType.md)\<`TTable`, `TSchema`\>, `string`, `TSchema`, `UtilsRecord`\> & `object` & `object`
+
+### Example
+
+```typescript
+import { z } from "zod"
+
+// The PowerSync SQLite schema
+const APP_SCHEMA = new Schema({
+  documents: new Table({
+    name: column.text,
+    // Booleans are represented as integers in SQLite
+    is_active: column.integer
+  }),
+})
+
+// Advanced Zod validations.
+// We accept boolean values as input for operations and expose Booleans in query results
+const schema = z.object({
+  id: z.string(),
+  isActive: z.boolean(), // TInput and TOutput are boolean
+})
+
+// The deserializationSchema converts the SQLite synced INTEGER (0/1) values to booleans.
+const deserializationSchema = z.object({
+  id: z.string(),
+  isActive: z.number().nullable().transform((val) => val == null ? true : val > 0),
+})
+
+const collection = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.documents,
+    schema,
+    deserializationSchema,
+  })
+)
+```
diff --git a/docs/reference/powersync-db-collection/index.md b/docs/reference/powersync-db-collection/index.md
new file mode 100644
index 000000000..f6467856d
--- /dev/null
+++ b/docs/reference/powersync-db-collection/index.md
@@ -0,0 +1,33 @@
+---
+id: "@tanstack/powersync-db-collection"
+title: "@tanstack/powersync-db-collection"
+---
+
+# @tanstack/powersync-db-collection
+
+## Classes
+
+- [PowerSyncTransactor](classes/PowerSyncTransactor.md)
+
+## Type Aliases
+
+- [BasePowerSyncCollectionConfig](type-aliases/BasePowerSyncCollectionConfig.md)
+- [ConfigWithArbitraryCollectionTypes](type-aliases/ConfigWithArbitraryCollectionTypes.md)
+- [ConfigWithSQLiteInputType](type-aliases/ConfigWithSQLiteInputType.md)
+- [ConfigWithSQLiteTypes](type-aliases/ConfigWithSQLiteTypes.md)
+- [CustomSQLiteSerializer](type-aliases/CustomSQLiteSerializer.md)
+- [EnhancedPowerSyncCollectionConfig](type-aliases/EnhancedPowerSyncCollectionConfig.md)
+- [InferPowerSyncOutputType](type-aliases/InferPowerSyncOutputType.md)
+- [PowerSyncCollectionConfig](type-aliases/PowerSyncCollectionConfig.md)
+- [PowerSyncCollectionMeta](type-aliases/PowerSyncCollectionMeta.md)
+- [PowerSyncCollectionUtils](type-aliases/PowerSyncCollectionUtils.md)
+- [SerializerConfig](type-aliases/SerializerConfig.md)
+- [TransactorOptions](type-aliases/TransactorOptions.md)
+
+## Variables
+
+- [DEFAULT\_BATCH\_SIZE](variables/DEFAULT_BATCH_SIZE.md)
+
+## Functions
+
+- [powerSyncCollectionOptions](functions/powerSyncCollectionOptions.md)
diff --git a/docs/reference/powersync-db-collection/type-aliases/BasePowerSyncCollectionConfig.md b/docs/reference/powersync-db-collection/type-aliases/BasePowerSyncCollectionConfig.md
new file mode 100644
index 000000000..4966c6574
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/BasePowerSyncCollectionConfig.md
@@ -0,0 +1,58 @@
+---
+id: BasePowerSyncCollectionConfig
+title: BasePowerSyncCollectionConfig
+---
+
+# Type Alias: BasePowerSyncCollectionConfig\<TTable, TSchema\>
+
+```ts
+type BasePowerSyncCollectionConfig<TTable, TSchema> = Omit<BaseCollectionConfig<ExtractedTable<TTable>, string, TSchema>, "onInsert" | "onUpdate" | "onDelete" | "getKey"> & object;
+```
+
+Defined in: [definitions.ts:165](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L165)
+
+## Type Declaration
+
+### database
+
+```ts
+database: AbstractPowerSyncDatabase;
+```
+
+The PowerSync database instance
+
+### syncBatchSize?
+
+```ts
+optional syncBatchSize: number;
+```
+
+The maximum number of documents to read from the SQLite table
+in a single batch during the initial sync between PowerSync and the
+in-memory TanStack DB collection.
+
+#### Remarks
+
+- Defaults to [DEFAULT\_BATCH\_SIZE](../variables/DEFAULT_BATCH_SIZE.md) if not specified.
+- Larger values reduce the number of round trips to the storage
+  engine but increase memory usage per batch.
+- Smaller values may lower memory usage and allow earlier
+  streaming of initial results, at the cost of more query calls.
+
+### table
+
+```ts
+table: TTable;
+```
+
+The PowerSync schema Table definition
+
+## Type Parameters
+
+### TTable
+
+`TTable` *extends* `Table` = `Table`
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `never`
diff --git a/docs/reference/powersync-db-collection/type-aliases/ConfigWithArbitraryCollectionTypes.md b/docs/reference/powersync-db-collection/type-aliases/ConfigWithArbitraryCollectionTypes.md
new file mode 100644
index 000000000..a51250077
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/ConfigWithArbitraryCollectionTypes.md
@@ -0,0 +1,62 @@
+---
+id: ConfigWithArbitraryCollectionTypes
+title: ConfigWithArbitraryCollectionTypes
+---
+
+# Type Alias: ConfigWithArbitraryCollectionTypes\<TTable, TSchema\>
+
+```ts
+type ConfigWithArbitraryCollectionTypes<TTable, TSchema> = SerializerConfig<StandardSchemaV1.InferOutput<TSchema>, ExtractedTable<TTable>> & object;
+```
+
+Defined in: [definitions.ts:125](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L125)
+
+Config where TInput and TOutput have arbitrarily typed values.
+The keys of the types need to equal the SQLite types.
+Since TInput is not the SQLite types, we require a schema in order to deserialize incoming SQLite updates. The schema should validate from SQLite to TOutput.
+
+## Type Declaration
+
+### deserializationSchema
+
+```ts
+deserializationSchema: StandardSchemaV1<ExtractedTable<TTable>, StandardSchemaV1.InferOutput<TSchema>>;
+```
+
+Schema for deserializing and validating input data from the sync stream.
+
+This schema defines how to transform and validate data coming from SQLite types (as stored in the database)
+into the desired output types (`TOutput`) expected by your application or validation logic.
+
+The generic parameters allow for arbitrary input and output types, so you can specify custom conversion rules
+for each column. This is especially useful when your application expects richer types (e.g., Date, enums, objects)
+than what SQLite natively supports.
+
+Use this to ensure that incoming data from the sync stream is properly converted and validated before use.
+
+Example:
+```typescript
+deserializationSchema: z.object({
+  createdAt: z.preprocess((val) => new Date(val as string), z.date()),
+  meta: z.preprocess((val) => JSON.parse(val as string), z.object({ ... })),
+})
+```
+
+This enables robust type safety and validation for incoming data, bridging the gap between SQLite storage
+and your application's expected types.
+
+### schema
+
+```ts
+schema: TSchema;
+```
+
+## Type Parameters
+
+### TTable
+
+`TTable` *extends* `Table`
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1`\<`AnyTableColumnType`\<`TTable`\>, `AnyTableColumnType`\<`TTable`\>\>
diff --git a/docs/reference/powersync-db-collection/type-aliases/ConfigWithSQLiteInputType.md b/docs/reference/powersync-db-collection/type-aliases/ConfigWithSQLiteInputType.md
new file mode 100644
index 000000000..1d58b51a6
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/ConfigWithSQLiteInputType.md
@@ -0,0 +1,33 @@
+---
+id: ConfigWithSQLiteInputType
+title: ConfigWithSQLiteInputType
+---
+
+# Type Alias: ConfigWithSQLiteInputType\<TTable, TSchema\>
+
+```ts
+type ConfigWithSQLiteInputType<TTable, TSchema> = SerializerConfig<StandardSchemaV1.InferOutput<TSchema>, ExtractedTable<TTable>> & object;
+```
+
+Defined in: [definitions.ts:106](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L106)
+
+Config where TInput is the SQLite types while TOutput can be defined by TSchema.
+We can use the same schema to validate TInput and incoming SQLite changes.
+
+## Type Declaration
+
+### schema
+
+```ts
+schema: TSchema;
+```
+
+## Type Parameters
+
+### TTable
+
+`TTable` *extends* `Table`
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1`\<`OptionalExtractedTable`\<`TTable`\>, `AnyTableColumnType`\<`TTable`\>\>
diff --git a/docs/reference/powersync-db-collection/type-aliases/ConfigWithSQLiteTypes.md b/docs/reference/powersync-db-collection/type-aliases/ConfigWithSQLiteTypes.md
new file mode 100644
index 000000000..edc414511
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/ConfigWithSQLiteTypes.md
@@ -0,0 +1,14 @@
+---
+id: ConfigWithSQLiteTypes
+title: ConfigWithSQLiteTypes
+---
+
+# Type Alias: ConfigWithSQLiteTypes
+
+```ts
+type ConfigWithSQLiteTypes = object;
+```
+
+Defined in: [definitions.ts:100](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L100)
+
+Config for when TInput and TOutput are both the SQLite types.
diff --git a/docs/reference/powersync-db-collection/type-aliases/CustomSQLiteSerializer.md b/docs/reference/powersync-db-collection/type-aliases/CustomSQLiteSerializer.md
new file mode 100644
index 000000000..898bf6119
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/CustomSQLiteSerializer.md
@@ -0,0 +1,48 @@
+---
+id: CustomSQLiteSerializer
+title: CustomSQLiteSerializer
+---
+
+# Type Alias: CustomSQLiteSerializer\<TOutput, TSQLite\>
+
+```ts
+type CustomSQLiteSerializer<TOutput, TSQLite> = Partial<{ [Key in keyof TOutput]: (value: TOutput[Key]) => Key extends keyof TSQLite ? TSQLite[Key] : never }>;
+```
+
+Defined in: [definitions.ts:52](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L52)
+
+A mapping type for custom serialization of object properties to SQLite-compatible values.
+
+This type allows you to override, for keys in the input object (`TOutput`), a function that transforms
+the value to the corresponding SQLite type (`TSQLite`). Keys not specified will use the default SQLite serialization.
+
+## Generics
+- `TOutput`: The input object type, representing the row data to be serialized.
+- `TSQLite`: The target SQLite-compatible type for each property, typically inferred from the table schema.
+
+## Usage
+Use this type to define a map of serialization functions for specific keys when you need custom handling
+(e.g., converting complex objects, formatting dates, or handling enums).
+
+Example:
+```ts
+const serializer: CustomSQLiteSerializer<MyRowType, MySQLiteType> = {
+  createdAt: (date) => date.toISOString(),
+  status: (status) => status ? 1 : 0,
+  meta: (meta) => JSON.stringify(meta),
+};
+```
+
+## Behavior
+- Each key maps to a function that receives the value and returns the SQLite-compatible value.
+- Used by `serializeForSQLite` to override default serialization for specific columns.
+
+## Type Parameters
+
+### TOutput
+
+`TOutput` *extends* `Record`\<`string`, `unknown`\>
+
+### TSQLite
+
+`TSQLite` *extends* `Record`\<`string`, `unknown`\>
diff --git a/docs/reference/powersync-db-collection/type-aliases/EnhancedPowerSyncCollectionConfig.md b/docs/reference/powersync-db-collection/type-aliases/EnhancedPowerSyncCollectionConfig.md
new file mode 100644
index 000000000..c005ab951
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/EnhancedPowerSyncCollectionConfig.md
@@ -0,0 +1,48 @@
+---
+id: EnhancedPowerSyncCollectionConfig
+title: EnhancedPowerSyncCollectionConfig
+---
+
+# Type Alias: EnhancedPowerSyncCollectionConfig\<TTable, OutputType, TSchema\>
+
+```ts
+type EnhancedPowerSyncCollectionConfig<TTable, OutputType, TSchema> = CollectionConfig<OutputType, string, TSchema> & object;
+```
+
+Defined in: [definitions.ts:259](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L259)
+
+A CollectionConfig which includes utilities for PowerSync.
+
+## Type Declaration
+
+### id?
+
+```ts
+optional id: string;
+```
+
+### schema?
+
+```ts
+optional schema: TSchema;
+```
+
+### utils
+
+```ts
+utils: PowerSyncCollectionUtils<TTable>;
+```
+
+## Type Parameters
+
+### TTable
+
+`TTable` *extends* `Table`
+
+### OutputType
+
+`OutputType` *extends* `Record`\<`string`, `unknown`\> = `Record`\<`string`, `unknown`\>
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `never`
diff --git a/docs/reference/powersync-db-collection/type-aliases/InferPowerSyncOutputType.md b/docs/reference/powersync-db-collection/type-aliases/InferPowerSyncOutputType.md
new file mode 100644
index 000000000..d7e31998e
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/InferPowerSyncOutputType.md
@@ -0,0 +1,26 @@
+---
+id: InferPowerSyncOutputType
+title: InferPowerSyncOutputType
+---
+
+# Type Alias: InferPowerSyncOutputType\<TTable, TSchema\>
+
+```ts
+type InferPowerSyncOutputType<TTable, TSchema> = TSchema extends never ? ExtractedTable<TTable> : InferSchemaOutput<TSchema>;
+```
+
+Defined in: [definitions.ts:20](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L20)
+
+Small helper which determines the output type if:
+- Standard SQLite types are to be used OR
+- If the provided schema should be used.
+
+## Type Parameters
+
+### TTable
+
+`TTable` *extends* `Table` = `Table`
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1`\<`PowerSyncRecord`\> = `never`
diff --git a/docs/reference/powersync-db-collection/type-aliases/PowerSyncCollectionConfig.md b/docs/reference/powersync-db-collection/type-aliases/PowerSyncCollectionConfig.md
new file mode 100644
index 000000000..d06b3d3b7
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/PowerSyncCollectionConfig.md
@@ -0,0 +1,51 @@
+---
+id: PowerSyncCollectionConfig
+title: PowerSyncCollectionConfig
+---
+
+# Type Alias: PowerSyncCollectionConfig\<TTable, TSchema\>
+
+```ts
+type PowerSyncCollectionConfig<TTable, TSchema> = BasePowerSyncCollectionConfig<TTable, TSchema> & 
+  | ConfigWithSQLiteTypes
+  | ConfigWithSQLiteInputType<TTable, TSchema>
+| ConfigWithArbitraryCollectionTypes<TTable, TSchema>;
+```
+
+Defined in: [definitions.ts:222](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L222)
+
+Configuration options for creating a PowerSync collection.
+
+## Type Parameters
+
+### TTable
+
+`TTable` *extends* `Table` = `Table`
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1`\<`any`\> = `never`
+
+## Example
+
+```typescript
+const APP_SCHEMA = new Schema({
+  documents: new Table({
+    name: column.text,
+  }),
+})
+
+const db = new PowerSyncDatabase({
+  database: {
+    dbFilename: "test.sqlite",
+  },
+  schema: APP_SCHEMA,
+})
+
+const collection = createCollection(
+  powerSyncCollectionOptions({
+    database: db,
+    table: APP_SCHEMA.props.documents
+  })
+)
+```
diff --git a/docs/reference/powersync-db-collection/type-aliases/PowerSyncCollectionMeta.md b/docs/reference/powersync-db-collection/type-aliases/PowerSyncCollectionMeta.md
new file mode 100644
index 000000000..b7dddfa05
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/PowerSyncCollectionMeta.md
@@ -0,0 +1,78 @@
+---
+id: PowerSyncCollectionMeta
+title: PowerSyncCollectionMeta
+---
+
+# Type Alias: PowerSyncCollectionMeta\<TTable\>
+
+```ts
+type PowerSyncCollectionMeta<TTable> = object;
+```
+
+Defined in: [definitions.ts:235](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L235)
+
+Metadata for the PowerSync Collection.
+
+## Type Parameters
+
+### TTable
+
+`TTable` *extends* `Table` = `Table`
+
+## Properties
+
+### metadataIsTracked
+
+```ts
+metadataIsTracked: boolean;
+```
+
+Defined in: [definitions.ts:253](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L253)
+
+Whether the PowerSync table tracks metadata.
+
+***
+
+### serializeValue()
+
+```ts
+serializeValue: (value) => ExtractedTable<TTable>;
+```
+
+Defined in: [definitions.ts:248](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L248)
+
+Serializes a collection value to the SQLite type
+
+#### Parameters
+
+##### value
+
+`any`
+
+#### Returns
+
+`ExtractedTable`\<`TTable`\>
+
+***
+
+### tableName
+
+```ts
+tableName: string;
+```
+
+Defined in: [definitions.ts:239](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L239)
+
+The SQLite table representing the collection.
+
+***
+
+### trackedTableName
+
+```ts
+trackedTableName: string;
+```
+
+Defined in: [definitions.ts:243](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L243)
+
+The internal table used to track diffs for the collection.
diff --git a/docs/reference/powersync-db-collection/type-aliases/PowerSyncCollectionUtils.md b/docs/reference/powersync-db-collection/type-aliases/PowerSyncCollectionUtils.md
new file mode 100644
index 000000000..116953154
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/PowerSyncCollectionUtils.md
@@ -0,0 +1,34 @@
+---
+id: PowerSyncCollectionUtils
+title: PowerSyncCollectionUtils
+---
+
+# Type Alias: PowerSyncCollectionUtils\<TTable\>
+
+```ts
+type PowerSyncCollectionUtils<TTable> = object;
+```
+
+Defined in: [definitions.ts:272](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L272)
+
+Collection-level utilities for PowerSync.
+
+## Type Parameters
+
+### TTable
+
+`TTable` *extends* `Table` = `Table`
+
+## Properties
+
+### getMeta()
+
+```ts
+getMeta: () => PowerSyncCollectionMeta<TTable>;
+```
+
+Defined in: [definitions.ts:273](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L273)
+
+#### Returns
+
+[`PowerSyncCollectionMeta`](PowerSyncCollectionMeta.md)\<`TTable`\>
diff --git a/docs/reference/powersync-db-collection/type-aliases/SerializerConfig.md b/docs/reference/powersync-db-collection/type-aliases/SerializerConfig.md
new file mode 100644
index 000000000..2ce69107c
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/SerializerConfig.md
@@ -0,0 +1,77 @@
+---
+id: SerializerConfig
+title: SerializerConfig
+---
+
+# Type Alias: SerializerConfig\<TOutput, TSQLite\>
+
+```ts
+type SerializerConfig<TOutput, TSQLite> = object;
+```
+
+Defined in: [definitions.ts:61](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L61)
+
+## Type Parameters
+
+### TOutput
+
+`TOutput` *extends* `Record`\<`string`, `unknown`\>
+
+### TSQLite
+
+`TSQLite` *extends* `Record`\<`string`, `unknown`\>
+
+## Properties
+
+### onDeserializationError()
+
+```ts
+onDeserializationError: (error) => void;
+```
+
+Defined in: [definitions.ts:94](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L94)
+
+Application logic should ensure that incoming synced data is always valid.
+Failing to deserialize and apply incoming changes results in data inconsistency - which is a fatal error.
+Use this callback to react to deserialization errors.
+
+#### Parameters
+
+##### error
+
+`StandardSchemaV1.FailureResult`
+
+#### Returns
+
+`void`
+
+***
+
+### serializer?
+
+```ts
+optional serializer: CustomSQLiteSerializer<TOutput, TSQLite>;
+```
+
+Defined in: [definitions.ts:87](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L87)
+
+Optional partial serializer object for customizing how individual columns are serialized for SQLite.
+
+This should be a partial map of column keys to serialization functions, following the
+[CustomSQLiteSerializer](CustomSQLiteSerializer.md) type. Each function receives the column value and returns a value
+compatible with SQLite storage.
+
+If not provided for a column, the default behavior is used:
+  - `TEXT`: Strings are stored as-is; Dates are converted to ISO strings; other types are JSON-stringified.
+  - `INTEGER`/`REAL`: Numbers are stored as-is; booleans are mapped to 1/0.
+
+Use this option to override serialization for specific columns, such as formatting dates, handling enums,
+or serializing complex objects.
+
+Example:
+```typescript
+serializer: {
+  createdAt: (date) => date.getTime(), // Store as timestamp
+  meta: (meta) => JSON.stringify(meta), // Custom object serialization
+}
+```
diff --git a/docs/reference/powersync-db-collection/type-aliases/TransactorOptions.md b/docs/reference/powersync-db-collection/type-aliases/TransactorOptions.md
new file mode 100644
index 000000000..7a9051b65
--- /dev/null
+++ b/docs/reference/powersync-db-collection/type-aliases/TransactorOptions.md
@@ -0,0 +1,22 @@
+---
+id: TransactorOptions
+title: TransactorOptions
+---
+
+# Type Alias: TransactorOptions
+
+```ts
+type TransactorOptions = object;
+```
+
+Defined in: [PowerSyncTransactor.ts:15](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L15)
+
+## Properties
+
+### database
+
+```ts
+database: AbstractPowerSyncDatabase;
+```
+
+Defined in: [PowerSyncTransactor.ts:16](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/PowerSyncTransactor.ts#L16)
diff --git a/docs/reference/powersync-db-collection/variables/DEFAULT_BATCH_SIZE.md b/docs/reference/powersync-db-collection/variables/DEFAULT_BATCH_SIZE.md
new file mode 100644
index 000000000..6c7b42275
--- /dev/null
+++ b/docs/reference/powersync-db-collection/variables/DEFAULT_BATCH_SIZE.md
@@ -0,0 +1,14 @@
+---
+id: DEFAULT_BATCH_SIZE
+title: DEFAULT_BATCH_SIZE
+---
+
+# Variable: DEFAULT\_BATCH\_SIZE
+
+```ts
+const DEFAULT_BATCH_SIZE: 1000 = 1000;
+```
+
+Defined in: [definitions.ts:279](https://github.com/TanStack/db/blob/main/packages/powersync-db-collection/src/definitions.ts#L279)
+
+Default value for [PowerSyncCollectionConfig#syncBatchSize](../type-aliases/BasePowerSyncCollectionConfig.md).
diff --git a/docs/reference/query-db-collection/classes/DeleteOperationItemNotFoundError.md b/docs/reference/query-db-collection/classes/DeleteOperationItemNotFoundError.md
new file mode 100644
index 000000000..ed4d24c84
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/DeleteOperationItemNotFoundError.md
@@ -0,0 +1,220 @@
+---
+id: DeleteOperationItemNotFoundError
+title: DeleteOperationItemNotFoundError
+---
+
+# Class: DeleteOperationItemNotFoundError
+
+Defined in: [packages/query-db-collection/src/errors.ts:76](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L76)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new DeleteOperationItemNotFoundError(key): DeleteOperationItemNotFoundError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:77](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L77)
+
+#### Parameters
+
+##### key
+
+`string` | `number`
+
+#### Returns
+
+`DeleteOperationItemNotFoundError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/DuplicateKeyInBatchError.md b/docs/reference/query-db-collection/classes/DuplicateKeyInBatchError.md
new file mode 100644
index 000000000..8c6038af9
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/DuplicateKeyInBatchError.md
@@ -0,0 +1,220 @@
+---
+id: DuplicateKeyInBatchError
+title: DuplicateKeyInBatchError
+---
+
+# Class: DuplicateKeyInBatchError
+
+Defined in: [packages/query-db-collection/src/errors.ts:62](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L62)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new DuplicateKeyInBatchError(key): DuplicateKeyInBatchError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:63](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L63)
+
+#### Parameters
+
+##### key
+
+`string` | `number`
+
+#### Returns
+
+`DuplicateKeyInBatchError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/GetKeyRequiredError.md b/docs/reference/query-db-collection/classes/GetKeyRequiredError.md
new file mode 100644
index 000000000..adb0bb685
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/GetKeyRequiredError.md
@@ -0,0 +1,214 @@
+---
+id: GetKeyRequiredError
+title: GetKeyRequiredError
+---
+
+# Class: GetKeyRequiredError
+
+Defined in: [packages/query-db-collection/src/errors.ts:32](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L32)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new GetKeyRequiredError(): GetKeyRequiredError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:33](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L33)
+
+#### Returns
+
+`GetKeyRequiredError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/InvalidItemStructureError.md b/docs/reference/query-db-collection/classes/InvalidItemStructureError.md
new file mode 100644
index 000000000..bc37f4f43
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/InvalidItemStructureError.md
@@ -0,0 +1,220 @@
+---
+id: InvalidItemStructureError
+title: InvalidItemStructureError
+---
+
+# Class: InvalidItemStructureError
+
+Defined in: [packages/query-db-collection/src/errors.ts:48](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L48)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidItemStructureError(message): InvalidItemStructureError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:49](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L49)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`InvalidItemStructureError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/InvalidSyncOperationError.md b/docs/reference/query-db-collection/classes/InvalidSyncOperationError.md
new file mode 100644
index 000000000..9643105fc
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/InvalidSyncOperationError.md
@@ -0,0 +1,220 @@
+---
+id: InvalidSyncOperationError
+title: InvalidSyncOperationError
+---
+
+# Class: InvalidSyncOperationError
+
+Defined in: [packages/query-db-collection/src/errors.ts:83](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L83)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new InvalidSyncOperationError(message): InvalidSyncOperationError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:84](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L84)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`InvalidSyncOperationError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/ItemNotFoundError.md b/docs/reference/query-db-collection/classes/ItemNotFoundError.md
new file mode 100644
index 000000000..a9c7f9a17
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/ItemNotFoundError.md
@@ -0,0 +1,220 @@
+---
+id: ItemNotFoundError
+title: ItemNotFoundError
+---
+
+# Class: ItemNotFoundError
+
+Defined in: [packages/query-db-collection/src/errors.ts:55](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L55)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new ItemNotFoundError(key): ItemNotFoundError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:56](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L56)
+
+#### Parameters
+
+##### key
+
+`string` | `number`
+
+#### Returns
+
+`ItemNotFoundError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/MissingKeyFieldError.md b/docs/reference/query-db-collection/classes/MissingKeyFieldError.md
new file mode 100644
index 000000000..a1ee4accc
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/MissingKeyFieldError.md
@@ -0,0 +1,224 @@
+---
+id: MissingKeyFieldError
+title: MissingKeyFieldError
+---
+
+# Class: MissingKeyFieldError
+
+Defined in: [packages/query-db-collection/src/errors.ts:97](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L97)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new MissingKeyFieldError(operation, message): MissingKeyFieldError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:98](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L98)
+
+#### Parameters
+
+##### operation
+
+`string`
+
+##### message
+
+`string`
+
+#### Returns
+
+`MissingKeyFieldError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/QueryClientRequiredError.md b/docs/reference/query-db-collection/classes/QueryClientRequiredError.md
new file mode 100644
index 000000000..cf983aae2
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/QueryClientRequiredError.md
@@ -0,0 +1,214 @@
+---
+id: QueryClientRequiredError
+title: QueryClientRequiredError
+---
+
+# Class: QueryClientRequiredError
+
+Defined in: [packages/query-db-collection/src/errors.ts:25](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L25)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new QueryClientRequiredError(): QueryClientRequiredError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:26](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L26)
+
+#### Returns
+
+`QueryClientRequiredError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/QueryCollectionError.md b/docs/reference/query-db-collection/classes/QueryCollectionError.md
new file mode 100644
index 000000000..4e443177e
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/QueryCollectionError.md
@@ -0,0 +1,252 @@
+---
+id: QueryCollectionError
+title: QueryCollectionError
+---
+
+# Class: QueryCollectionError
+
+Defined in: [packages/query-db-collection/src/errors.ts:4](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L4)
+
+## Extends
+
+- `TanStackDBError`
+
+## Extended by
+
+- [`QueryKeyRequiredError`](QueryKeyRequiredError.md)
+- [`QueryFnRequiredError`](QueryFnRequiredError.md)
+- [`QueryClientRequiredError`](QueryClientRequiredError.md)
+- [`GetKeyRequiredError`](GetKeyRequiredError.md)
+- [`SyncNotInitializedError`](SyncNotInitializedError.md)
+- [`InvalidItemStructureError`](InvalidItemStructureError.md)
+- [`ItemNotFoundError`](ItemNotFoundError.md)
+- [`DuplicateKeyInBatchError`](DuplicateKeyInBatchError.md)
+- [`UpdateOperationItemNotFoundError`](UpdateOperationItemNotFoundError.md)
+- [`DeleteOperationItemNotFoundError`](DeleteOperationItemNotFoundError.md)
+- [`InvalidSyncOperationError`](InvalidSyncOperationError.md)
+- [`UnknownOperationTypeError`](UnknownOperationTypeError.md)
+- [`MissingKeyFieldError`](MissingKeyFieldError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new QueryCollectionError(message): QueryCollectionError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:5](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L5)
+
+#### Parameters
+
+##### message
+
+`string`
+
+#### Returns
+
+`QueryCollectionError`
+
+#### Overrides
+
+```ts
+TanStackDBError.constructor
+```
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+```ts
+TanStackDBError.cause
+```
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+```ts
+TanStackDBError.message
+```
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+```ts
+TanStackDBError.name
+```
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+```ts
+TanStackDBError.stack
+```
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+```ts
+TanStackDBError.stackTraceLimit
+```
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+```ts
+TanStackDBError.captureStackTrace
+```
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+```ts
+TanStackDBError.prepareStackTrace
+```
diff --git a/docs/reference/query-db-collection/classes/QueryFnRequiredError.md b/docs/reference/query-db-collection/classes/QueryFnRequiredError.md
new file mode 100644
index 000000000..8acbcf589
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/QueryFnRequiredError.md
@@ -0,0 +1,214 @@
+---
+id: QueryFnRequiredError
+title: QueryFnRequiredError
+---
+
+# Class: QueryFnRequiredError
+
+Defined in: [packages/query-db-collection/src/errors.ts:18](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L18)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new QueryFnRequiredError(): QueryFnRequiredError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:19](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L19)
+
+#### Returns
+
+`QueryFnRequiredError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/QueryKeyRequiredError.md b/docs/reference/query-db-collection/classes/QueryKeyRequiredError.md
new file mode 100644
index 000000000..fdbbafa46
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/QueryKeyRequiredError.md
@@ -0,0 +1,214 @@
+---
+id: QueryKeyRequiredError
+title: QueryKeyRequiredError
+---
+
+# Class: QueryKeyRequiredError
+
+Defined in: [packages/query-db-collection/src/errors.ts:11](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L11)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new QueryKeyRequiredError(): QueryKeyRequiredError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:12](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L12)
+
+#### Returns
+
+`QueryKeyRequiredError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/SyncNotInitializedError.md b/docs/reference/query-db-collection/classes/SyncNotInitializedError.md
new file mode 100644
index 000000000..25a501e89
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/SyncNotInitializedError.md
@@ -0,0 +1,214 @@
+---
+id: SyncNotInitializedError
+title: SyncNotInitializedError
+---
+
+# Class: SyncNotInitializedError
+
+Defined in: [packages/query-db-collection/src/errors.ts:39](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L39)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new SyncNotInitializedError(): SyncNotInitializedError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:40](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L40)
+
+#### Returns
+
+`SyncNotInitializedError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/UnknownOperationTypeError.md b/docs/reference/query-db-collection/classes/UnknownOperationTypeError.md
new file mode 100644
index 000000000..0fd2aab5c
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/UnknownOperationTypeError.md
@@ -0,0 +1,220 @@
+---
+id: UnknownOperationTypeError
+title: UnknownOperationTypeError
+---
+
+# Class: UnknownOperationTypeError
+
+Defined in: [packages/query-db-collection/src/errors.ts:90](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L90)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UnknownOperationTypeError(type): UnknownOperationTypeError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:91](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L91)
+
+#### Parameters
+
+##### type
+
+`string`
+
+#### Returns
+
+`UnknownOperationTypeError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/UpdateOperationItemNotFoundError.md b/docs/reference/query-db-collection/classes/UpdateOperationItemNotFoundError.md
new file mode 100644
index 000000000..3a86f840e
--- /dev/null
+++ b/docs/reference/query-db-collection/classes/UpdateOperationItemNotFoundError.md
@@ -0,0 +1,220 @@
+---
+id: UpdateOperationItemNotFoundError
+title: UpdateOperationItemNotFoundError
+---
+
+# Class: UpdateOperationItemNotFoundError
+
+Defined in: [packages/query-db-collection/src/errors.ts:69](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L69)
+
+## Extends
+
+- [`QueryCollectionError`](QueryCollectionError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new UpdateOperationItemNotFoundError(key): UpdateOperationItemNotFoundError;
+```
+
+Defined in: [packages/query-db-collection/src/errors.ts:70](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L70)
+
+#### Parameters
+
+##### key
+
+`string` | `number`
+
+#### Returns
+
+`UpdateOperationItemNotFoundError`
+
+#### Overrides
+
+[`QueryCollectionError`](QueryCollectionError.md).[`constructor`](QueryCollectionError.md#constructor)
+
+## Properties
+
+### cause?
+
+```ts
+optional cause: unknown;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`cause`](QueryCollectionError.md#cause)
+
+***
+
+### message
+
+```ts
+message: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1077
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`message`](QueryCollectionError.md#message)
+
+***
+
+### name
+
+```ts
+name: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`name`](QueryCollectionError.md#name)
+
+***
+
+### stack?
+
+```ts
+optional stack: string;
+```
+
+Defined in: node\_modules/.pnpm/typescript@5.9.3/node\_modules/typescript/lib/lib.es5.d.ts:1078
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stack`](QueryCollectionError.md#stack)
+
+***
+
+### stackTraceLimit
+
+```ts
+static stackTraceLimit: number;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:68
+
+The `Error.stackTraceLimit` property specifies the number of stack frames
+collected by a stack trace (whether generated by `new Error().stack` or
+`Error.captureStackTrace(obj)`).
+
+The default value is `10` but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured _after_ the value has been changed.
+
+If set to a non-number value, or set to a negative number, stack traces will
+not capture any frames.
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`stackTraceLimit`](QueryCollectionError.md#stacktracelimit)
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:52
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack;  // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+  b();
+}
+
+function b() {
+  c();
+}
+
+function c() {
+  // Create an error without stack trace to avoid calculating the stack trace twice.
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error();
+  Error.stackTraceLimit = stackTraceLimit;
+
+  // Capture the stack trace above function b
+  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+  throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+##### targetObject
+
+`object`
+
+##### constructorOpt?
+
+`Function`
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`captureStackTrace`](QueryCollectionError.md#capturestacktrace)
+
+***
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: node\_modules/.pnpm/@types+node@24.7.0/node\_modules/@types/node/globals.d.ts:56
+
+#### Parameters
+
+##### err
+
+`Error`
+
+##### stackTraces
+
+`CallSite`[]
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`QueryCollectionError`](QueryCollectionError.md).[`prepareStackTrace`](QueryCollectionError.md#preparestacktrace)
diff --git a/docs/reference/query-db-collection/classes/getkeyrequirederror.md b/docs/reference/query-db-collection/classes/getkeyrequirederror.md
deleted file mode 100644
index 521e748d4..000000000
--- a/docs/reference/query-db-collection/classes/getkeyrequirederror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: GetKeyRequiredError
-title: GetKeyRequiredError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: GetKeyRequiredError
-
-Defined in: [packages/query-db-collection/src/errors.ts:32](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L32)
-
-## Extends
-
-- [`QueryCollectionError`](../querycollectionerror.md)
-
-## Constructors
-
-### new GetKeyRequiredError()
-
-```ts
-new GetKeyRequiredError(): GetKeyRequiredError
-```
-
-Defined in: [packages/query-db-collection/src/errors.ts:33](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L33)
-
-#### Returns
-
-[`GetKeyRequiredError`](../getkeyrequirederror.md)
-
-#### Overrides
-
-[`QueryCollectionError`](../querycollectionerror.md).[`constructor`](../QueryCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`cause`](../QueryCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`message`](../QueryCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`name`](../QueryCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`stack`](../QueryCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`prepareStackTrace`](../QueryCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`stackTraceLimit`](../QueryCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`captureStackTrace`](../QueryCollectionError.md#capturestacktrace)
diff --git a/docs/reference/query-db-collection/classes/queryclientrequirederror.md b/docs/reference/query-db-collection/classes/queryclientrequirederror.md
deleted file mode 100644
index b3854f54f..000000000
--- a/docs/reference/query-db-collection/classes/queryclientrequirederror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: QueryClientRequiredError
-title: QueryClientRequiredError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: QueryClientRequiredError
-
-Defined in: [packages/query-db-collection/src/errors.ts:25](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L25)
-
-## Extends
-
-- [`QueryCollectionError`](../querycollectionerror.md)
-
-## Constructors
-
-### new QueryClientRequiredError()
-
-```ts
-new QueryClientRequiredError(): QueryClientRequiredError
-```
-
-Defined in: [packages/query-db-collection/src/errors.ts:26](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L26)
-
-#### Returns
-
-[`QueryClientRequiredError`](../queryclientrequirederror.md)
-
-#### Overrides
-
-[`QueryCollectionError`](../querycollectionerror.md).[`constructor`](../QueryCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`cause`](../QueryCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`message`](../QueryCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`name`](../QueryCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`stack`](../QueryCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`prepareStackTrace`](../QueryCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`stackTraceLimit`](../QueryCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`captureStackTrace`](../QueryCollectionError.md#capturestacktrace)
diff --git a/docs/reference/query-db-collection/classes/querycollectionerror.md b/docs/reference/query-db-collection/classes/querycollectionerror.md
deleted file mode 100644
index bc8f0deea..000000000
--- a/docs/reference/query-db-collection/classes/querycollectionerror.md
+++ /dev/null
@@ -1,195 +0,0 @@
----
-id: QueryCollectionError
-title: QueryCollectionError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: QueryCollectionError
-
-Defined in: [packages/query-db-collection/src/errors.ts:4](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L4)
-
-## Extends
-
-- `TanStackDBError`
-
-## Extended by
-
-- [`QueryKeyRequiredError`](../querykeyrequirederror.md)
-- [`QueryFnRequiredError`](../queryfnrequirederror.md)
-- [`QueryClientRequiredError`](../queryclientrequirederror.md)
-- [`GetKeyRequiredError`](../getkeyrequirederror.md)
-
-## Constructors
-
-### new QueryCollectionError()
-
-```ts
-new QueryCollectionError(message): QueryCollectionError
-```
-
-Defined in: [packages/query-db-collection/src/errors.ts:5](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L5)
-
-#### Parameters
-
-##### message
-
-`string`
-
-#### Returns
-
-[`QueryCollectionError`](../querycollectionerror.md)
-
-#### Overrides
-
-```ts
-TanStackDBError.constructor
-```
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-```ts
-TanStackDBError.cause
-```
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-```ts
-TanStackDBError.message
-```
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-```ts
-TanStackDBError.name
-```
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-```ts
-TanStackDBError.stack
-```
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-```ts
-TanStackDBError.prepareStackTrace
-```
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-```ts
-TanStackDBError.stackTraceLimit
-```
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-```ts
-TanStackDBError.captureStackTrace
-```
diff --git a/docs/reference/query-db-collection/classes/queryfnrequirederror.md b/docs/reference/query-db-collection/classes/queryfnrequirederror.md
deleted file mode 100644
index 52f73c486..000000000
--- a/docs/reference/query-db-collection/classes/queryfnrequirederror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: QueryFnRequiredError
-title: QueryFnRequiredError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: QueryFnRequiredError
-
-Defined in: [packages/query-db-collection/src/errors.ts:18](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L18)
-
-## Extends
-
-- [`QueryCollectionError`](../querycollectionerror.md)
-
-## Constructors
-
-### new QueryFnRequiredError()
-
-```ts
-new QueryFnRequiredError(): QueryFnRequiredError
-```
-
-Defined in: [packages/query-db-collection/src/errors.ts:19](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L19)
-
-#### Returns
-
-[`QueryFnRequiredError`](../queryfnrequirederror.md)
-
-#### Overrides
-
-[`QueryCollectionError`](../querycollectionerror.md).[`constructor`](../QueryCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`cause`](../QueryCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`message`](../QueryCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`name`](../QueryCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`stack`](../QueryCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`prepareStackTrace`](../QueryCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`stackTraceLimit`](../QueryCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`captureStackTrace`](../QueryCollectionError.md#capturestacktrace)
diff --git a/docs/reference/query-db-collection/classes/querykeyrequirederror.md b/docs/reference/query-db-collection/classes/querykeyrequirederror.md
deleted file mode 100644
index 015c86192..000000000
--- a/docs/reference/query-db-collection/classes/querykeyrequirederror.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: QueryKeyRequiredError
-title: QueryKeyRequiredError
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Class: QueryKeyRequiredError
-
-Defined in: [packages/query-db-collection/src/errors.ts:11](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L11)
-
-## Extends
-
-- [`QueryCollectionError`](../querycollectionerror.md)
-
-## Constructors
-
-### new QueryKeyRequiredError()
-
-```ts
-new QueryKeyRequiredError(): QueryKeyRequiredError
-```
-
-Defined in: [packages/query-db-collection/src/errors.ts:12](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/errors.ts#L12)
-
-#### Returns
-
-[`QueryKeyRequiredError`](../querykeyrequirederror.md)
-
-#### Overrides
-
-[`QueryCollectionError`](../querycollectionerror.md).[`constructor`](../QueryCollectionError.md#constructors)
-
-## Properties
-
-### cause?
-
-```ts
-optional cause: unknown;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es2022.error.d.ts:26
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`cause`](../QueryCollectionError.md#cause)
-
-***
-
-### message
-
-```ts
-message: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1077
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`message`](../QueryCollectionError.md#message-1)
-
-***
-
-### name
-
-```ts
-name: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1076
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`name`](../QueryCollectionError.md#name)
-
-***
-
-### stack?
-
-```ts
-optional stack: string;
-```
-
-Defined in: node\_modules/.pnpm/typescript@5.8.2/node\_modules/typescript/lib/lib.es5.d.ts:1078
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`stack`](../QueryCollectionError.md#stack)
-
-***
-
-### prepareStackTrace()?
-
-```ts
-static optional prepareStackTrace: (err, stackTraces) => any;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:143
-
-Optional override for formatting stack traces
-
-#### Parameters
-
-##### err
-
-`Error`
-
-##### stackTraces
-
-`CallSite`[]
-
-#### Returns
-
-`any`
-
-#### See
-
-https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`prepareStackTrace`](../QueryCollectionError.md#preparestacktrace)
-
-***
-
-### stackTraceLimit
-
-```ts
-static stackTraceLimit: number;
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:145
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`stackTraceLimit`](../QueryCollectionError.md#stacktracelimit)
-
-## Methods
-
-### captureStackTrace()
-
-```ts
-static captureStackTrace(targetObject, constructorOpt?): void
-```
-
-Defined in: node\_modules/.pnpm/@types+node@22.13.10/node\_modules/@types/node/globals.d.ts:136
-
-Create .stack property on a target object
-
-#### Parameters
-
-##### targetObject
-
-`object`
-
-##### constructorOpt?
-
-`Function`
-
-#### Returns
-
-`void`
-
-#### Inherited from
-
-[`QueryCollectionError`](../querycollectionerror.md).[`captureStackTrace`](../QueryCollectionError.md#capturestacktrace)
diff --git a/docs/reference/query-db-collection/functions/queryCollectionOptions.md b/docs/reference/query-db-collection/functions/queryCollectionOptions.md
new file mode 100644
index 000000000..3aab0096f
--- /dev/null
+++ b/docs/reference/query-db-collection/functions/queryCollectionOptions.md
@@ -0,0 +1,550 @@
+---
+id: queryCollectionOptions
+title: queryCollectionOptions
+---
+
+# Function: queryCollectionOptions()
+
+## Call Signature
+
+```ts
+function queryCollectionOptions<T, TQueryFn, TError, TQueryKey, TKey, TQueryData>(config): CollectionConfig<InferSchemaOutput<T>, TKey, T, QueryCollectionUtils<InferSchemaOutput<T>, TKey, InferSchemaInput<T>, TError>> & object;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:394](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L394)
+
+Creates query collection options for use with a standard Collection.
+This integrates TanStack Query with TanStack DB for automatic synchronization.
+
+Supports automatic type inference following the priority order:
+1. Schema inference (highest priority)
+2. QueryFn return type inference (second priority)
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+Type of the schema if a schema is provided otherwise it is the type of the values returned by the queryFn
+
+#### TQueryFn
+
+`TQueryFn` *extends* (`context`) => `Promise`\<`any`\>
+
+#### TError
+
+`TError` = `unknown`
+
+The type of errors that can occur during queries
+
+#### TQueryKey
+
+`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
+
+The type of the query key
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the item keys
+
+#### TQueryData
+
+`TQueryData` = `Awaited`\<`ReturnType`\<`TQueryFn`\>\>
+
+### Parameters
+
+#### config
+
+[`QueryCollectionConfig`](../interfaces/QueryCollectionConfig.md)\<`InferSchemaOutput`\<`T`\>, `TQueryFn`, `TError`, `TQueryKey`, `TKey`, `T`, `Awaited`\<`ReturnType`\<`TQueryFn`\>\>\> & `object`
+
+Configuration options for the Query collection
+
+### Returns
+
+`CollectionConfig`\<`InferSchemaOutput`\<`T`\>, `TKey`, `T`, [`QueryCollectionUtils`](../interfaces/QueryCollectionUtils.md)\<`InferSchemaOutput`\<`T`\>, `TKey`, `InferSchemaInput`\<`T`\>, `TError`\>\> & `object`
+
+Collection options with utilities for direct writes and manual operations
+
+### Examples
+
+```ts
+// Type inferred from queryFn return type (NEW!)
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => {
+      const response = await fetch('/api/todos')
+      return response.json() as Todo[] // Type automatically inferred!
+    },
+    queryClient,
+    getKey: (item) => item.id, // item is typed as Todo
+  })
+)
+```
+
+```ts
+// Explicit type
+const todosCollection = createCollection<Todo>(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    queryClient,
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// Schema inference
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    queryClient,
+    schema: todoSchema, // Type inferred from schema
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// With persistence handlers
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: fetchTodos,
+    queryClient,
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      await api.createTodos(transaction.mutations.map(m => m.modified))
+    },
+    onUpdate: async ({ transaction }) => {
+      await api.updateTodos(transaction.mutations)
+    },
+    onDelete: async ({ transaction }) => {
+      await api.deleteTodos(transaction.mutations.map(m => m.key))
+    }
+  })
+)
+```
+
+```ts
+// The select option extracts the items array from a response with metadata
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    select: (data) => data.items, // Extract the array of items
+    queryClient,
+    schema: todoSchema,
+    getKey: (item) => item.id,
+  })
+)
+```
+
+## Call Signature
+
+```ts
+function queryCollectionOptions<T, TQueryFn, TError, TQueryKey, TKey, TQueryData>(config): CollectionConfig<T, TKey, never, QueryCollectionUtils<T, TKey, T, TError>> & object;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:429](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L429)
+
+Creates query collection options for use with a standard Collection.
+This integrates TanStack Query with TanStack DB for automatic synchronization.
+
+Supports automatic type inference following the priority order:
+1. Schema inference (highest priority)
+2. QueryFn return type inference (second priority)
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+Type of the schema if a schema is provided otherwise it is the type of the values returned by the queryFn
+
+#### TQueryFn
+
+`TQueryFn` *extends* (`context`) => `Promise`\<`any`\> = (`context`) => `Promise`\<`any`\>
+
+#### TError
+
+`TError` = `unknown`
+
+The type of errors that can occur during queries
+
+#### TQueryKey
+
+`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
+
+The type of the query key
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the item keys
+
+#### TQueryData
+
+`TQueryData` = `Awaited`\<`ReturnType`\<`TQueryFn`\>\>
+
+### Parameters
+
+#### config
+
+[`QueryCollectionConfig`](../interfaces/QueryCollectionConfig.md)\<`T`, `TQueryFn`, `TError`, `TQueryKey`, `TKey`, `never`, `TQueryData`\> & `object`
+
+Configuration options for the Query collection
+
+### Returns
+
+`CollectionConfig`\<`T`, `TKey`, `never`, [`QueryCollectionUtils`](../interfaces/QueryCollectionUtils.md)\<`T`, `TKey`, `T`, `TError`\>\> & `object`
+
+Collection options with utilities for direct writes and manual operations
+
+### Examples
+
+```ts
+// Type inferred from queryFn return type (NEW!)
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => {
+      const response = await fetch('/api/todos')
+      return response.json() as Todo[] // Type automatically inferred!
+    },
+    queryClient,
+    getKey: (item) => item.id, // item is typed as Todo
+  })
+)
+```
+
+```ts
+// Explicit type
+const todosCollection = createCollection<Todo>(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    queryClient,
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// Schema inference
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    queryClient,
+    schema: todoSchema, // Type inferred from schema
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// With persistence handlers
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: fetchTodos,
+    queryClient,
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      await api.createTodos(transaction.mutations.map(m => m.modified))
+    },
+    onUpdate: async ({ transaction }) => {
+      await api.updateTodos(transaction.mutations)
+    },
+    onDelete: async ({ transaction }) => {
+      await api.deleteTodos(transaction.mutations.map(m => m.key))
+    }
+  })
+)
+```
+
+```ts
+// The select option extracts the items array from a response with metadata
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    select: (data) => data.items, // Extract the array of items
+    queryClient,
+    schema: todoSchema,
+    getKey: (item) => item.id,
+  })
+)
+```
+
+## Call Signature
+
+```ts
+function queryCollectionOptions<T, TError, TQueryKey, TKey>(config): CollectionConfig<InferSchemaOutput<T>, TKey, T, QueryCollectionUtils<InferSchemaOutput<T>, TKey, InferSchemaInput<T>, TError>> & object;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:462](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L462)
+
+Creates query collection options for use with a standard Collection.
+This integrates TanStack Query with TanStack DB for automatic synchronization.
+
+Supports automatic type inference following the priority order:
+1. Schema inference (highest priority)
+2. QueryFn return type inference (second priority)
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+Type of the schema if a schema is provided otherwise it is the type of the values returned by the queryFn
+
+#### TError
+
+`TError` = `unknown`
+
+The type of errors that can occur during queries
+
+#### TQueryKey
+
+`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
+
+The type of the query key
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the item keys
+
+### Parameters
+
+#### config
+
+[`QueryCollectionConfig`](../interfaces/QueryCollectionConfig.md)\<`InferSchemaOutput`\<`T`\>, (`context`) => `Promise`\<`InferSchemaOutput`\<`T`\>[]\>, `TError`, `TQueryKey`, `TKey`, `T`, `InferSchemaOutput`\<`T`\>[]\> & `object`
+
+Configuration options for the Query collection
+
+### Returns
+
+`CollectionConfig`\<`InferSchemaOutput`\<`T`\>, `TKey`, `T`, [`QueryCollectionUtils`](../interfaces/QueryCollectionUtils.md)\<`InferSchemaOutput`\<`T`\>, `TKey`, `InferSchemaInput`\<`T`\>, `TError`\>\> & `object`
+
+Collection options with utilities for direct writes and manual operations
+
+### Examples
+
+```ts
+// Type inferred from queryFn return type (NEW!)
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => {
+      const response = await fetch('/api/todos')
+      return response.json() as Todo[] // Type automatically inferred!
+    },
+    queryClient,
+    getKey: (item) => item.id, // item is typed as Todo
+  })
+)
+```
+
+```ts
+// Explicit type
+const todosCollection = createCollection<Todo>(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    queryClient,
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// Schema inference
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    queryClient,
+    schema: todoSchema, // Type inferred from schema
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// With persistence handlers
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: fetchTodos,
+    queryClient,
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      await api.createTodos(transaction.mutations.map(m => m.modified))
+    },
+    onUpdate: async ({ transaction }) => {
+      await api.updateTodos(transaction.mutations)
+    },
+    onDelete: async ({ transaction }) => {
+      await api.deleteTodos(transaction.mutations.map(m => m.key))
+    }
+  })
+)
+```
+
+```ts
+// The select option extracts the items array from a response with metadata
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    select: (data) => data.items, // Extract the array of items
+    queryClient,
+    schema: todoSchema,
+    getKey: (item) => item.id,
+  })
+)
+```
+
+## Call Signature
+
+```ts
+function queryCollectionOptions<T, TError, TQueryKey, TKey>(config): CollectionConfig<T, TKey, never, QueryCollectionUtils<T, TKey, T, TError>> & object;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:496](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L496)
+
+Creates query collection options for use with a standard Collection.
+This integrates TanStack Query with TanStack DB for automatic synchronization.
+
+Supports automatic type inference following the priority order:
+1. Schema inference (highest priority)
+2. QueryFn return type inference (second priority)
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+Type of the schema if a schema is provided otherwise it is the type of the values returned by the queryFn
+
+#### TError
+
+`TError` = `unknown`
+
+The type of errors that can occur during queries
+
+#### TQueryKey
+
+`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
+
+The type of the query key
+
+#### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the item keys
+
+### Parameters
+
+#### config
+
+[`QueryCollectionConfig`](../interfaces/QueryCollectionConfig.md)\<`T`, (`context`) => `Promise`\<`T`[]\>, `TError`, `TQueryKey`, `TKey`, `never`, `T`[]\> & `object`
+
+Configuration options for the Query collection
+
+### Returns
+
+`CollectionConfig`\<`T`, `TKey`, `never`, [`QueryCollectionUtils`](../interfaces/QueryCollectionUtils.md)\<`T`, `TKey`, `T`, `TError`\>\> & `object`
+
+Collection options with utilities for direct writes and manual operations
+
+### Examples
+
+```ts
+// Type inferred from queryFn return type (NEW!)
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => {
+      const response = await fetch('/api/todos')
+      return response.json() as Todo[] // Type automatically inferred!
+    },
+    queryClient,
+    getKey: (item) => item.id, // item is typed as Todo
+  })
+)
+```
+
+```ts
+// Explicit type
+const todosCollection = createCollection<Todo>(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    queryClient,
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// Schema inference
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    queryClient,
+    schema: todoSchema, // Type inferred from schema
+    getKey: (item) => item.id,
+  })
+)
+```
+
+```ts
+// With persistence handlers
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: fetchTodos,
+    queryClient,
+    getKey: (item) => item.id,
+    onInsert: async ({ transaction }) => {
+      await api.createTodos(transaction.mutations.map(m => m.modified))
+    },
+    onUpdate: async ({ transaction }) => {
+      await api.updateTodos(transaction.mutations)
+    },
+    onDelete: async ({ transaction }) => {
+      await api.deleteTodos(transaction.mutations.map(m => m.key))
+    }
+  })
+)
+```
+
+```ts
+// The select option extracts the items array from a response with metadata
+const todosCollection = createCollection(
+  queryCollectionOptions({
+    queryKey: ['todos'],
+    queryFn: async () => fetch('/api/todos').then(r => r.json()),
+    select: (data) => data.items, // Extract the array of items
+    queryClient,
+    schema: todoSchema,
+    getKey: (item) => item.id,
+  })
+)
+```
diff --git a/docs/reference/query-db-collection/functions/querycollectionoptions.md b/docs/reference/query-db-collection/functions/querycollectionoptions.md
deleted file mode 100644
index abe359100..000000000
--- a/docs/reference/query-db-collection/functions/querycollectionoptions.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-id: queryCollectionOptions
-title: queryCollectionOptions
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Function: queryCollectionOptions()
-
-```ts
-function queryCollectionOptions<TItem, TError, TQueryKey, TKey, TInsertInput>(config): CollectionConfig<TItem, string | number, StandardSchemaV1<unknown, unknown>, TItem> & object
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:277](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L277)
-
-Creates query collection options for use with a standard Collection
-
-## Type Parameters
-
-• **TItem** *extends* `object`
-
-• **TError** = `unknown`
-
-• **TQueryKey** *extends* readonly `unknown`[] = readonly `unknown`[]
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-• **TInsertInput** *extends* `object` = `TItem`
-
-## Parameters
-
-### config
-
-[`QueryCollectionConfig`](../../interfaces/querycollectionconfig.md)\<`TItem`, `TError`, `TQueryKey`\>
-
-Configuration options for the Query collection
-
-## Returns
-
-`CollectionConfig`\<`TItem`, `string` \| `number`, `StandardSchemaV1`\<`unknown`, `unknown`\>, `TItem`\> & `object`
-
-Collection options with utilities
diff --git a/docs/reference/query-db-collection/index.md b/docs/reference/query-db-collection/index.md
index 22c9cbe6f..569ee31dd 100644
--- a/docs/reference/query-db-collection/index.md
+++ b/docs/reference/query-db-collection/index.md
@@ -3,23 +3,35 @@ id: "@tanstack/query-db-collection"
 title: "@tanstack/query-db-collection"
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # @tanstack/query-db-collection
 
 ## Classes
 
-- [GetKeyRequiredError](../classes/getkeyrequirederror.md)
-- [QueryClientRequiredError](../classes/queryclientrequirederror.md)
-- [QueryCollectionError](../classes/querycollectionerror.md)
-- [QueryFnRequiredError](../classes/queryfnrequirederror.md)
-- [QueryKeyRequiredError](../classes/querykeyrequirederror.md)
+- [DeleteOperationItemNotFoundError](classes/DeleteOperationItemNotFoundError.md)
+- [DuplicateKeyInBatchError](classes/DuplicateKeyInBatchError.md)
+- [GetKeyRequiredError](classes/GetKeyRequiredError.md)
+- [InvalidItemStructureError](classes/InvalidItemStructureError.md)
+- [InvalidSyncOperationError](classes/InvalidSyncOperationError.md)
+- [ItemNotFoundError](classes/ItemNotFoundError.md)
+- [MissingKeyFieldError](classes/MissingKeyFieldError.md)
+- [QueryClientRequiredError](classes/QueryClientRequiredError.md)
+- [QueryCollectionError](classes/QueryCollectionError.md)
+- [QueryFnRequiredError](classes/QueryFnRequiredError.md)
+- [QueryKeyRequiredError](classes/QueryKeyRequiredError.md)
+- [SyncNotInitializedError](classes/SyncNotInitializedError.md)
+- [UnknownOperationTypeError](classes/UnknownOperationTypeError.md)
+- [UpdateOperationItemNotFoundError](classes/UpdateOperationItemNotFoundError.md)
 
 ## Interfaces
 
-- [QueryCollectionConfig](../interfaces/querycollectionconfig.md)
-- [QueryCollectionUtils](../interfaces/querycollectionutils.md)
+- [QueryCollectionConfig](interfaces/QueryCollectionConfig.md)
+- [QueryCollectionMeta](interfaces/QueryCollectionMeta.md)
+- [QueryCollectionUtils](interfaces/QueryCollectionUtils.md)
+
+## Type Aliases
+
+- [SyncOperation](type-aliases/SyncOperation.md)
 
 ## Functions
 
-- [queryCollectionOptions](../functions/querycollectionoptions.md)
+- [queryCollectionOptions](functions/queryCollectionOptions.md)
diff --git a/docs/reference/query-db-collection/interfaces/QueryCollectionConfig.md b/docs/reference/query-db-collection/interfaces/QueryCollectionConfig.md
new file mode 100644
index 000000000..710db1ee9
--- /dev/null
+++ b/docs/reference/query-db-collection/interfaces/QueryCollectionConfig.md
@@ -0,0 +1,196 @@
+---
+id: QueryCollectionConfig
+title: QueryCollectionConfig
+---
+
+# Interface: QueryCollectionConfig\<T, TQueryFn, TError, TQueryKey, TKey, TSchema, TQueryData\>
+
+Defined in: [packages/query-db-collection/src/query.ts:60](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L60)
+
+Configuration options for creating a Query Collection
+
+## Extends
+
+- `BaseCollectionConfig`\<`T`, `TKey`, `TSchema`\>
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `object`
+
+The explicit type of items stored in the collection
+
+### TQueryFn
+
+`TQueryFn` *extends* (`context`) => `Promise`\<`any`\> = (`context`) => `Promise`\<`any`\>
+
+The queryFn type
+
+### TError
+
+`TError` = `unknown`
+
+The type of errors that can occur during queries
+
+### TQueryKey
+
+`TQueryKey` *extends* `QueryKey` = `QueryKey`
+
+The type of the query key
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the item keys
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `never`
+
+The schema type for validation
+
+### TQueryData
+
+`TQueryData` = `Awaited`\<`ReturnType`\<`TQueryFn`\>\>
+
+## Properties
+
+### enabled?
+
+```ts
+optional enabled: boolean;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:86](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L86)
+
+Whether the query should automatically run (default: true)
+
+***
+
+### meta?
+
+```ts
+optional meta: Record<string, unknown>;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:136](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L136)
+
+Metadata to pass to the query.
+Available in queryFn via context.meta
+
+#### Example
+
+```ts
+// Using meta for error context
+queryFn: async (context) => {
+  try {
+    return await api.getTodos(userId)
+  } catch (error) {
+    // Use meta for better error messages
+    throw new Error(
+      context.meta?.errorMessage || 'Failed to load todos'
+    )
+  }
+},
+meta: {
+  errorMessage: `Failed to load todos for user ${userId}`
+}
+```
+
+***
+
+### queryClient
+
+```ts
+queryClient: QueryClient;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:82](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L82)
+
+The TanStack Query client instance
+
+***
+
+### queryFn
+
+```ts
+queryFn: TQueryFn extends (context) => Promise<any[]> ? (context) => Promise<T[]> : TQueryFn;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:74](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L74)
+
+Function that fetches data from the server. Must return the complete collection state
+
+***
+
+### queryKey
+
+```ts
+queryKey: TQueryKey | TQueryKeyBuilder<TQueryKey>;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:72](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L72)
+
+The query key used by TanStack Query to identify this query
+
+***
+
+### refetchInterval?
+
+```ts
+optional refetchInterval: number | false | (query) => number | false | undefined;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:87](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L87)
+
+***
+
+### retry?
+
+```ts
+optional retry: RetryValue<TError>;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:94](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L94)
+
+***
+
+### retryDelay?
+
+```ts
+optional retryDelay: RetryDelayValue<TError>;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:101](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L101)
+
+***
+
+### select()?
+
+```ts
+optional select: (data) => T[];
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:80](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L80)
+
+#### Parameters
+
+##### data
+
+`TQueryData`
+
+#### Returns
+
+`T`[]
+
+***
+
+### staleTime?
+
+```ts
+optional staleTime: StaleTimeFunction<T[], TError, T[], TQueryKey>;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:108](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L108)
diff --git a/docs/reference/query-db-collection/interfaces/QueryCollectionMeta.md b/docs/reference/query-db-collection/interfaces/QueryCollectionMeta.md
new file mode 100644
index 000000000..7c2527c39
--- /dev/null
+++ b/docs/reference/query-db-collection/interfaces/QueryCollectionMeta.md
@@ -0,0 +1,43 @@
+---
+id: QueryCollectionMeta
+title: QueryCollectionMeta
+---
+
+# Interface: QueryCollectionMeta
+
+Defined in: [packages/query-db-collection/src/global.ts:30](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/global.ts#L30)
+
+Base interface for Query Collection meta properties.
+Users can extend this interface to add their own custom properties while
+preserving loadSubsetOptions.
+
+## Example
+
+```typescript
+declare module "@tanstack/query-db-collection" {
+  interface QueryCollectionMeta {
+    myCustomProperty: string
+    userId?: number
+  }
+}
+```
+
+## Extends
+
+- `Record`\<`string`, `unknown`\>
+
+## Indexable
+
+```ts
+[key: string]: unknown
+```
+
+## Properties
+
+### loadSubsetOptions
+
+```ts
+loadSubsetOptions: LoadSubsetOptions;
+```
+
+Defined in: [packages/query-db-collection/src/global.ts:31](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/global.ts#L31)
diff --git a/docs/reference/query-db-collection/interfaces/QueryCollectionUtils.md b/docs/reference/query-db-collection/interfaces/QueryCollectionUtils.md
new file mode 100644
index 000000000..2385eca11
--- /dev/null
+++ b/docs/reference/query-db-collection/interfaces/QueryCollectionUtils.md
@@ -0,0 +1,288 @@
+---
+id: QueryCollectionUtils
+title: QueryCollectionUtils
+---
+
+# Interface: QueryCollectionUtils\<TItem, TKey, TInsertInput, TError\>
+
+Defined in: [packages/query-db-collection/src/query.ts:155](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L155)
+
+Utility methods available on Query Collections for direct writes and manual operations.
+Direct writes bypass the normal query/mutation flow and write directly to the synced data store.
+
+## Extends
+
+- `UtilsRecord`
+
+## Type Parameters
+
+### TItem
+
+`TItem` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+The type of items stored in the collection
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+The type of the item keys
+
+### TInsertInput
+
+`TInsertInput` *extends* `object` = `TItem`
+
+The type accepted for insert operations
+
+### TError
+
+`TError` = `unknown`
+
+The type of errors that can occur during queries
+
+## Indexable
+
+```ts
+[key: string]: any
+```
+
+## Properties
+
+### clearError()
+
+```ts
+clearError: () => Promise<void>;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:200](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L200)
+
+Clear the error state and trigger a refetch of the query
+
+#### Returns
+
+`Promise`\<`void`\>
+
+Promise that resolves when the refetch completes successfully
+
+#### Throws
+
+Error if the refetch fails
+
+***
+
+### dataUpdatedAt
+
+```ts
+dataUpdatedAt: number;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:191](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L191)
+
+Get timestamp of last successful data update (in milliseconds)
+
+***
+
+### errorCount
+
+```ts
+errorCount: number;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:183](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L183)
+
+Get the number of consecutive sync failures.
+Incremented only when query fails completely (not per retry attempt); reset on success.
+
+***
+
+### fetchStatus
+
+```ts
+fetchStatus: "idle" | "fetching" | "paused";
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:193](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L193)
+
+Get current fetch status
+
+***
+
+### isError
+
+```ts
+isError: boolean;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:178](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L178)
+
+Check if the collection is in an error state
+
+***
+
+### isFetching
+
+```ts
+isFetching: boolean;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:185](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L185)
+
+Check if query is currently fetching (initial or background)
+
+***
+
+### isLoading
+
+```ts
+isLoading: boolean;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:189](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L189)
+
+Check if query is loading for the first time (no data yet)
+
+***
+
+### isRefetching
+
+```ts
+isRefetching: boolean;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:187](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L187)
+
+Check if query is refetching in background (not initial fetch)
+
+***
+
+### lastError
+
+```ts
+lastError: TError | undefined;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:176](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L176)
+
+Get the last error encountered by the query (if any); reset on success
+
+***
+
+### refetch
+
+```ts
+refetch: RefetchFn;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:162](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L162)
+
+Manually trigger a refetch of the query
+
+***
+
+### writeBatch()
+
+```ts
+writeBatch: (callback) => void;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:172](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L172)
+
+Execute multiple write operations as a single atomic batch to the synced data store
+
+#### Parameters
+
+##### callback
+
+() => `void`
+
+#### Returns
+
+`void`
+
+***
+
+### writeDelete()
+
+```ts
+writeDelete: (keys) => void;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:168](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L168)
+
+Delete one or more items directly from the synced data store without triggering a query refetch or optimistic update
+
+#### Parameters
+
+##### keys
+
+`TKey` | `TKey`[]
+
+#### Returns
+
+`void`
+
+***
+
+### writeInsert()
+
+```ts
+writeInsert: (data) => void;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:164](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L164)
+
+Insert one or more items directly into the synced data store without triggering a query refetch or optimistic update
+
+#### Parameters
+
+##### data
+
+`TInsertInput` | `TInsertInput`[]
+
+#### Returns
+
+`void`
+
+***
+
+### writeUpdate()
+
+```ts
+writeUpdate: (updates) => void;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:166](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L166)
+
+Update one or more items directly in the synced data store without triggering a query refetch or optimistic update
+
+#### Parameters
+
+##### updates
+
+`Partial`\<`TItem`\> | `Partial`\<`TItem`\>[]
+
+#### Returns
+
+`void`
+
+***
+
+### writeUpsert()
+
+```ts
+writeUpsert: (data) => void;
+```
+
+Defined in: [packages/query-db-collection/src/query.ts:170](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L170)
+
+Insert or update one or more items directly in the synced data store without triggering a query refetch or optimistic update
+
+#### Parameters
+
+##### data
+
+`Partial`\<`TItem`\> | `Partial`\<`TItem`\>[]
+
+#### Returns
+
+`void`
diff --git a/docs/reference/query-db-collection/interfaces/querycollectionconfig.md b/docs/reference/query-db-collection/interfaces/querycollectionconfig.md
deleted file mode 100644
index 56f6a76b0..000000000
--- a/docs/reference/query-db-collection/interfaces/querycollectionconfig.md
+++ /dev/null
@@ -1,427 +0,0 @@
----
-id: QueryCollectionConfig
-title: QueryCollectionConfig
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: QueryCollectionConfig\<TItem, TError, TQueryKey\>
-
-Defined in: [packages/query-db-collection/src/query.ts:32](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L32)
-
-## Type Parameters
-
-• **TItem** *extends* `object`
-
-• **TError** = `unknown`
-
-• **TQueryKey** *extends* `QueryKey` = `QueryKey`
-
-## Properties
-
-### enabled?
-
-```ts
-optional enabled: boolean;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:42](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L42)
-
-***
-
-### getKey()
-
-```ts
-getKey: (item) => string | number;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:74](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L74)
-
-#### Parameters
-
-##### item
-
-`TItem`
-
-#### Returns
-
-`string` \| `number`
-
-***
-
-### id?
-
-```ts
-optional id: string;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:73](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L73)
-
-***
-
-### meta?
-
-```ts
-optional meta: Record<string, unknown>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:242](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L242)
-
-Metadata to pass to the query.
-Available in queryFn via context.meta
-
-#### Example
-
-```ts
-// Using meta for error context
-queryFn: async (context) => {
-  try {
-    return await api.getTodos(userId)
-  } catch (error) {
-    // Use meta for better error messages
-    throw new Error(
-      context.meta?.errorMessage || 'Failed to load todos'
-    )
-  }
-},
-meta: {
-  errorMessage: `Failed to load todos for user ${userId}`
-}
-```
-
-***
-
-### onDelete?
-
-```ts
-optional onDelete: DeleteMutationFn<TItem>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:219](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L219)
-
-Optional asynchronous handler function called before a delete operation
-
-#### Param
-
-Object containing transaction and collection information
-
-#### Returns
-
-Promise resolving to void or { refetch?: boolean } to control refetching
-
-#### Examples
-
-```ts
-// Basic query collection delete handler
-onDelete: async ({ transaction }) => {
-  const mutation = transaction.mutations[0]
-  await api.deleteTodo(mutation.original.id)
-  // Automatically refetches query after delete
-}
-```
-
-```ts
-// Delete handler with refetch control
-onDelete: async ({ transaction }) => {
-  const mutation = transaction.mutations[0]
-  await api.deleteTodo(mutation.original.id)
-  return { refetch: false } // Skip automatic refetch
-}
-```
-
-```ts
-// Delete handler with multiple items
-onDelete: async ({ transaction }) => {
-  const keysToDelete = transaction.mutations.map(m => m.key)
-  await api.deleteTodos(keysToDelete)
-  // Will refetch query to get updated data
-}
-```
-
-```ts
-// Delete handler with related collection refetch
-onDelete: async ({ transaction, collection }) => {
-  const mutation = transaction.mutations[0]
-  await api.deleteTodo(mutation.original.id)
-
-  // Refetch related collections when this item is deleted
-  await Promise.all([
-    collection.utils.refetch(), // Refetch this collection
-    usersCollection.utils.refetch(), // Refetch users
-    projectsCollection.utils.refetch() // Refetch projects
-  ])
-
-  return { refetch: false } // Skip automatic refetch since we handled it manually
-}
-```
-
-***
-
-### onInsert?
-
-```ts
-optional onInsert: InsertMutationFn<TItem>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:120](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L120)
-
-Optional asynchronous handler function called before an insert operation
-
-#### Param
-
-Object containing transaction and collection information
-
-#### Returns
-
-Promise resolving to void or { refetch?: boolean } to control refetching
-
-#### Examples
-
-```ts
-// Basic query collection insert handler
-onInsert: async ({ transaction }) => {
-  const newItem = transaction.mutations[0].modified
-  await api.createTodo(newItem)
-  // Automatically refetches query after insert
-}
-```
-
-```ts
-// Insert handler with refetch control
-onInsert: async ({ transaction }) => {
-  const newItem = transaction.mutations[0].modified
-  await api.createTodo(newItem)
-  return { refetch: false } // Skip automatic refetch
-}
-```
-
-```ts
-// Insert handler with multiple items
-onInsert: async ({ transaction }) => {
-  const items = transaction.mutations.map(m => m.modified)
-  await api.createTodos(items)
-  // Will refetch query to get updated data
-}
-```
-
-```ts
-// Insert handler with error handling
-onInsert: async ({ transaction }) => {
-  try {
-    const newItem = transaction.mutations[0].modified
-    await api.createTodo(newItem)
-  } catch (error) {
-    console.error('Insert failed:', error)
-    throw error // Transaction will rollback optimistic changes
-  }
-}
-```
-
-***
-
-### onUpdate?
-
-```ts
-optional onUpdate: UpdateMutationFn<TItem>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:173](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L173)
-
-Optional asynchronous handler function called before an update operation
-
-#### Param
-
-Object containing transaction and collection information
-
-#### Returns
-
-Promise resolving to void or { refetch?: boolean } to control refetching
-
-#### Examples
-
-```ts
-// Basic query collection update handler
-onUpdate: async ({ transaction }) => {
-  const mutation = transaction.mutations[0]
-  await api.updateTodo(mutation.original.id, mutation.changes)
-  // Automatically refetches query after update
-}
-```
-
-```ts
-// Update handler with multiple items
-onUpdate: async ({ transaction }) => {
-  const updates = transaction.mutations.map(m => ({
-    id: m.key,
-    changes: m.changes
-  }))
-  await api.updateTodos(updates)
-  // Will refetch query to get updated data
-}
-```
-
-```ts
-// Update handler with manual refetch
-onUpdate: async ({ transaction, collection }) => {
-  const mutation = transaction.mutations[0]
-  await api.updateTodo(mutation.original.id, mutation.changes)
-
-  // Manually trigger refetch
-  await collection.utils.refetch()
-
-  return { refetch: false } // Skip automatic refetch
-}
-```
-
-```ts
-// Update handler with related collection refetch
-onUpdate: async ({ transaction, collection }) => {
-  const mutation = transaction.mutations[0]
-  await api.updateTodo(mutation.original.id, mutation.changes)
-
-  // Refetch related collections when this item changes
-  await Promise.all([
-    collection.utils.refetch(), // Refetch this collection
-    usersCollection.utils.refetch(), // Refetch users
-    tagsCollection.utils.refetch() // Refetch tags
-  ])
-
-  return { refetch: false } // Skip automatic refetch since we handled it manually
-}
-```
-
-***
-
-### queryClient
-
-```ts
-queryClient: QueryClient;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:39](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L39)
-
-***
-
-### queryFn()
-
-```ts
-queryFn: (context) => Promise<TItem[]>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:38](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L38)
-
-#### Parameters
-
-##### context
-
-###### client
-
-`QueryClient`
-
-###### direction?
-
-`unknown`
-
-**Deprecated**
-
-if you want access to the direction, you can add it to the pageParam
-
-###### meta
-
-`undefined` \| `Record`\<`string`, `unknown`\>
-
-###### pageParam?
-
-`unknown`
-
-###### queryKey
-
-`TQueryKey`
-
-###### signal
-
-`AbortSignal`
-
-#### Returns
-
-`Promise`\<`TItem`[]\>
-
-***
-
-### queryKey
-
-```ts
-queryKey: TQueryKey;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:37](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L37)
-
-***
-
-### refetchInterval?
-
-```ts
-optional refetchInterval: number | false | (query) => undefined | number | false;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:43](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L43)
-
-***
-
-### retry?
-
-```ts
-optional retry: RetryValue<TError>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:50](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L50)
-
-***
-
-### retryDelay?
-
-```ts
-optional retryDelay: RetryDelayValue<TError>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:57](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L57)
-
-***
-
-### schema?
-
-```ts
-optional schema: StandardSchemaV1<unknown, unknown>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:75](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L75)
-
-***
-
-### staleTime?
-
-```ts
-optional staleTime: StaleTimeFunction<TItem[], TError, TItem[], TQueryKey>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:64](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L64)
-
-***
-
-### startSync?
-
-```ts
-optional startSync: boolean;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:77](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L77)
-
-***
-
-### sync?
-
-```ts
-optional sync: SyncConfig<TItem, string | number>;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:76](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L76)
diff --git a/docs/reference/query-db-collection/interfaces/querycollectionutils.md b/docs/reference/query-db-collection/interfaces/querycollectionutils.md
deleted file mode 100644
index ec5573237..000000000
--- a/docs/reference/query-db-collection/interfaces/querycollectionutils.md
+++ /dev/null
@@ -1,140 +0,0 @@
----
-id: QueryCollectionUtils
-title: QueryCollectionUtils
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Interface: QueryCollectionUtils\<TItem, TKey, TInsertInput\>
-
-Defined in: [packages/query-db-collection/src/query.ts:256](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L256)
-
-Write operation types for batch operations
-
-## Extends
-
-- `UtilsRecord`
-
-## Type Parameters
-
-• **TItem** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-• **TInsertInput** *extends* `object` = `TItem`
-
-## Indexable
-
-```ts
-[key: string]: Fn
-```
-
-## Properties
-
-### refetch
-
-```ts
-refetch: RefetchFn;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:261](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L261)
-
-***
-
-### writeBatch()
-
-```ts
-writeBatch: (operations) => void;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:266](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L266)
-
-#### Parameters
-
-##### operations
-
-[`SyncOperation`](../../type-aliases/syncoperation.md)\<`TItem`, `TKey`, `TInsertInput`\>[]
-
-#### Returns
-
-`void`
-
-***
-
-### writeDelete()
-
-```ts
-writeDelete: (keys) => void;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:264](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L264)
-
-#### Parameters
-
-##### keys
-
-`TKey` | `TKey`[]
-
-#### Returns
-
-`void`
-
-***
-
-### writeInsert()
-
-```ts
-writeInsert: (data) => void;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:262](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L262)
-
-#### Parameters
-
-##### data
-
-`TInsertInput` | `TInsertInput`[]
-
-#### Returns
-
-`void`
-
-***
-
-### writeUpdate()
-
-```ts
-writeUpdate: (updates) => void;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:263](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L263)
-
-#### Parameters
-
-##### updates
-
-`Partial`\<`TItem`\> | `Partial`\<`TItem`\>[]
-
-#### Returns
-
-`void`
-
-***
-
-### writeUpsert()
-
-```ts
-writeUpsert: (data) => void;
-```
-
-Defined in: [packages/query-db-collection/src/query.ts:265](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/query.ts#L265)
-
-#### Parameters
-
-##### data
-
-`Partial`\<`TItem`\> | `Partial`\<`TItem`\>[]
-
-#### Returns
-
-`void`
diff --git a/docs/reference/query-db-collection/type-aliases/SyncOperation.md b/docs/reference/query-db-collection/type-aliases/SyncOperation.md
new file mode 100644
index 000000000..9cb0b5eb9
--- /dev/null
+++ b/docs/reference/query-db-collection/type-aliases/SyncOperation.md
@@ -0,0 +1,42 @@
+---
+id: SyncOperation
+title: SyncOperation
+---
+
+# Type Alias: SyncOperation\<TRow, TKey, TInsertInput\>
+
+```ts
+type SyncOperation<TRow, TKey, TInsertInput> = 
+  | {
+  data: TInsertInput | TInsertInput[];
+  type: "insert";
+}
+  | {
+  data: Partial<TRow> | Partial<TRow>[];
+  type: "update";
+}
+  | {
+  key: TKey | TKey[];
+  type: "delete";
+}
+  | {
+  data: Partial<TRow> | Partial<TRow>[];
+  type: "upsert";
+};
+```
+
+Defined in: [packages/query-db-collection/src/manual-sync.ts:20](https://github.com/TanStack/db/blob/main/packages/query-db-collection/src/manual-sync.ts#L20)
+
+## Type Parameters
+
+### TRow
+
+`TRow` *extends* `object`
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TInsertInput
+
+`TInsertInput` *extends* `object` = `TRow`
diff --git a/docs/reference/rxdb-db-collection/functions/rxdbCollectionOptions.md b/docs/reference/rxdb-db-collection/functions/rxdbCollectionOptions.md
new file mode 100644
index 000000000..adf36b74a
--- /dev/null
+++ b/docs/reference/rxdb-db-collection/functions/rxdbCollectionOptions.md
@@ -0,0 +1,66 @@
+---
+id: rxdbCollectionOptions
+title: rxdbCollectionOptions
+---
+
+# Function: rxdbCollectionOptions()
+
+## Call Signature
+
+```ts
+function rxdbCollectionOptions<T>(config): CollectionConfig<InferSchemaOutput<T>, string, T, UtilsRecord> & object;
+```
+
+Defined in: [rxdb.ts:89](https://github.com/TanStack/db/blob/main/packages/rxdb-db-collection/src/rxdb.ts#L89)
+
+Creates RxDB collection options for use with a standard Collection
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `StandardSchemaV1`\<`unknown`, `unknown`\>
+
+### Parameters
+
+#### config
+
+[`RxDBCollectionConfig`](../type-aliases/RxDBCollectionConfig.md)\<`InferSchemaOutput`\<`T`\>, `T`\>
+
+Configuration options for the RxDB collection
+
+### Returns
+
+`CollectionConfig`\<`InferSchemaOutput`\<`T`\>, `string`, `T`, `UtilsRecord`\> & `object`
+
+Collection options with utilities
+
+## Call Signature
+
+```ts
+function rxdbCollectionOptions<T>(config): CollectionConfig<T, string, never, UtilsRecord> & object;
+```
+
+Defined in: [rxdb.ts:96](https://github.com/TanStack/db/blob/main/packages/rxdb-db-collection/src/rxdb.ts#L96)
+
+Creates RxDB collection options for use with a standard Collection
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### config
+
+`Omit`\<`BaseCollectionConfig`\<`T`, `string`, `never`, `UtilsRecord`, `any`\>, `"onInsert"` \| `"onUpdate"` \| `"onDelete"` \| `"getKey"`\> & `object` & `object`
+
+Configuration options for the RxDB collection
+
+### Returns
+
+`CollectionConfig`\<`T`, `string`, `never`, `UtilsRecord`\> & `object`
+
+Collection options with utilities
diff --git a/docs/reference/rxdb-db-collection/functions/stripRxdbFields.md b/docs/reference/rxdb-db-collection/functions/stripRxdbFields.md
new file mode 100644
index 000000000..989b3dde6
--- /dev/null
+++ b/docs/reference/rxdb-db-collection/functions/stripRxdbFields.md
@@ -0,0 +1,28 @@
+---
+id: stripRxdbFields
+title: stripRxdbFields
+---
+
+# Function: stripRxdbFields()
+
+```ts
+function stripRxdbFields<T>(obj): T;
+```
+
+Defined in: [helper.ts:8](https://github.com/TanStack/db/blob/main/packages/rxdb-db-collection/src/helper.ts#L8)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `Record`\<`string`, `unknown`\>
+
+## Parameters
+
+### obj
+
+`T`
+
+## Returns
+
+`T`
diff --git a/docs/reference/rxdb-db-collection/index.md b/docs/reference/rxdb-db-collection/index.md
new file mode 100644
index 000000000..4ab546bdc
--- /dev/null
+++ b/docs/reference/rxdb-db-collection/index.md
@@ -0,0 +1,19 @@
+---
+id: "@tanstack/rxdb-db-collection"
+title: "@tanstack/rxdb-db-collection"
+---
+
+# @tanstack/rxdb-db-collection
+
+## Type Aliases
+
+- [RxDBCollectionConfig](type-aliases/RxDBCollectionConfig.md)
+
+## Variables
+
+- [OPEN\_RXDB\_SUBSCRIPTIONS](variables/OPEN_RXDB_SUBSCRIPTIONS.md)
+
+## Functions
+
+- [rxdbCollectionOptions](functions/rxdbCollectionOptions.md)
+- [stripRxdbFields](functions/stripRxdbFields.md)
diff --git a/docs/reference/rxdb-db-collection/type-aliases/RxDBCollectionConfig.md b/docs/reference/rxdb-db-collection/type-aliases/RxDBCollectionConfig.md
new file mode 100644
index 000000000..447463e90
--- /dev/null
+++ b/docs/reference/rxdb-db-collection/type-aliases/RxDBCollectionConfig.md
@@ -0,0 +1,68 @@
+---
+id: RxDBCollectionConfig
+title: RxDBCollectionConfig
+---
+
+# Type Alias: RxDBCollectionConfig\<T, TSchema\>
+
+```ts
+type RxDBCollectionConfig<T, TSchema> = Omit<BaseCollectionConfig<T, string, TSchema>, "onInsert" | "onUpdate" | "onDelete" | "getKey"> & object;
+```
+
+Defined in: [rxdb.ts:49](https://github.com/TanStack/db/blob/main/packages/rxdb-db-collection/src/rxdb.ts#L49)
+
+Configuration interface for RxDB collection options
+
+## Type Declaration
+
+### rxCollection
+
+```ts
+rxCollection: RxCollection<T, unknown, unknown, unknown>;
+```
+
+The RxCollection from a RxDB Database instance.
+
+### syncBatchSize?
+
+```ts
+optional syncBatchSize: number;
+```
+
+The maximum number of documents to read from the RxDB collection
+in a single batch during the initial sync between RxDB and the
+in-memory TanStack DB collection.
+
+#### Remarks
+
+- Defaults to `1000` if not specified.
+- Larger values reduce the number of round trips to the storage
+  engine but increase memory usage per batch.
+- Smaller values may lower memory usage and allow earlier
+  streaming of initial results, at the cost of more query calls.
+
+Adjust this depending on your expected collection size and
+performance characteristics of the chosen RxDB storage adapter.
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+The explicit type of items in the collection (highest priority). Use the document type of your RxCollection here.
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `never`
+
+The schema type for validation and type inference (second priority)
+
+## Remarks
+
+Type resolution follows a priority order:
+1. If you provide an explicit type via generic parameter, it will be used
+2. If no explicit type is provided but a schema is, the schema's output type will be inferred
+
+You should provide EITHER an explicit type OR a schema, but not both, as they would conflict.
+Notice that primary keys in RxDB must always be a string.
diff --git a/docs/reference/rxdb-db-collection/variables/OPEN_RXDB_SUBSCRIPTIONS.md b/docs/reference/rxdb-db-collection/variables/OPEN_RXDB_SUBSCRIPTIONS.md
new file mode 100644
index 000000000..12525d564
--- /dev/null
+++ b/docs/reference/rxdb-db-collection/variables/OPEN_RXDB_SUBSCRIPTIONS.md
@@ -0,0 +1,14 @@
+---
+id: OPEN_RXDB_SUBSCRIPTIONS
+title: OPEN_RXDB_SUBSCRIPTIONS
+---
+
+# Variable: OPEN\_RXDB\_SUBSCRIPTIONS
+
+```ts
+const OPEN_RXDB_SUBSCRIPTIONS: WeakMap<RxCollection, Set<Subscription>>;
+```
+
+Defined in: [rxdb.ts:31](https://github.com/TanStack/db/blob/main/packages/rxdb-db-collection/src/rxdb.ts#L31)
+
+Used in tests to ensure proper cleanup
diff --git a/docs/reference/type-aliases/changelistener.md b/docs/reference/type-aliases/ChangeListener.md
similarity index 71%
rename from docs/reference/type-aliases/changelistener.md
rename to docs/reference/type-aliases/ChangeListener.md
index 5944ecddb..55554da4c 100644
--- a/docs/reference/type-aliases/changelistener.md
+++ b/docs/reference/type-aliases/ChangeListener.md
@@ -3,29 +3,31 @@ id: ChangeListener
 title: ChangeListener
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: ChangeListener()\<T, TKey\>
 
 ```ts
 type ChangeListener<T, TKey> = (changes) => void;
 ```
 
-Defined in: [packages/db/src/types.ts:627](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L627)
+Defined in: [packages/db/src/types.ts:863](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L863)
 
 Function type for listening to collection changes
 
 ## Type Parameters
 
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
 
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
+`TKey` *extends* `string` \| `number` = `string` \| `number`
 
 ## Parameters
 
 ### changes
 
-[`ChangeMessage`](../../interfaces/changemessage.md)\<`T`, `TKey`\>[]
+[`ChangeMessage`](../interfaces/ChangeMessage.md)\<`T`, `TKey`\>[]
 
 Array of change messages describing what happened
 
diff --git a/docs/reference/type-aliases/ChangeMessageOrDeleteKeyMessage.md b/docs/reference/type-aliases/ChangeMessageOrDeleteKeyMessage.md
new file mode 100644
index 000000000..6ab1778d0
--- /dev/null
+++ b/docs/reference/type-aliases/ChangeMessageOrDeleteKeyMessage.md
@@ -0,0 +1,24 @@
+---
+id: ChangeMessageOrDeleteKeyMessage
+title: ChangeMessageOrDeleteKeyMessage
+---
+
+# Type Alias: ChangeMessageOrDeleteKeyMessage\<T, TKey\>
+
+```ts
+type ChangeMessageOrDeleteKeyMessage<T, TKey> = 
+  | Omit<ChangeMessage<T>, "key">
+| DeleteKeyMessage<TKey>;
+```
+
+Defined in: [packages/db/src/types.ts:375](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L375)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
diff --git a/docs/reference/type-aliases/ChangesPayload.md b/docs/reference/type-aliases/ChangesPayload.md
new file mode 100644
index 000000000..83d5f300d
--- /dev/null
+++ b/docs/reference/type-aliases/ChangesPayload.md
@@ -0,0 +1,18 @@
+---
+id: ChangesPayload
+title: ChangesPayload
+---
+
+# Type Alias: ChangesPayload\<T\>
+
+```ts
+type ChangesPayload<T> = ChangeMessage<T>[];
+```
+
+Defined in: [packages/db/src/types.ts:742](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L742)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
diff --git a/docs/reference/type-aliases/CleanupFn.md b/docs/reference/type-aliases/CleanupFn.md
new file mode 100644
index 000000000..a5e5cd695
--- /dev/null
+++ b/docs/reference/type-aliases/CleanupFn.md
@@ -0,0 +1,16 @@
+---
+id: CleanupFn
+title: CleanupFn
+---
+
+# Type Alias: CleanupFn()
+
+```ts
+type CleanupFn = () => void;
+```
+
+Defined in: [packages/db/src/types.ts:318](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L318)
+
+## Returns
+
+`void`
diff --git a/docs/reference/type-aliases/ClearStorageFn.md b/docs/reference/type-aliases/ClearStorageFn.md
new file mode 100644
index 000000000..05751d091
--- /dev/null
+++ b/docs/reference/type-aliases/ClearStorageFn.md
@@ -0,0 +1,18 @@
+---
+id: ClearStorageFn
+title: ClearStorageFn
+---
+
+# Type Alias: ClearStorageFn()
+
+```ts
+type ClearStorageFn = () => void;
+```
+
+Defined in: [packages/db/src/local-storage.ts:90](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L90)
+
+Type for the clear utility function
+
+## Returns
+
+`void`
diff --git a/docs/reference/type-aliases/CollectionConfigSingleRowOption.md b/docs/reference/type-aliases/CollectionConfigSingleRowOption.md
new file mode 100644
index 000000000..3c9283c9c
--- /dev/null
+++ b/docs/reference/type-aliases/CollectionConfigSingleRowOption.md
@@ -0,0 +1,31 @@
+---
+id: CollectionConfigSingleRowOption
+title: CollectionConfigSingleRowOption
+---
+
+# Type Alias: CollectionConfigSingleRowOption\<T, TKey, TSchema, TUtils\>
+
+```ts
+type CollectionConfigSingleRowOption<T, TKey, TSchema, TUtils> = CollectionConfig<T, TKey, TSchema, TUtils> & MaybeSingleResult;
+```
+
+Defined in: [packages/db/src/types.ts:735](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L735)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TSchema
+
+`TSchema` *extends* `StandardSchemaV1` = `never`
+
+### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](UtilsRecord.md) = \{
+\}
diff --git a/docs/reference/type-aliases/collectionstatus.md b/docs/reference/type-aliases/CollectionStatus.md
similarity index 58%
rename from docs/reference/type-aliases/collectionstatus.md
rename to docs/reference/type-aliases/CollectionStatus.md
index cc1992735..b5543c2e7 100644
--- a/docs/reference/type-aliases/collectionstatus.md
+++ b/docs/reference/type-aliases/CollectionStatus.md
@@ -3,15 +3,13 @@ id: CollectionStatus
 title: CollectionStatus
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: CollectionStatus
 
 ```ts
-type CollectionStatus = "idle" | "loading" | "initialCommit" | "ready" | "error" | "cleaned-up";
+type CollectionStatus = "idle" | "loading" | "ready" | "error" | "cleaned-up";
 ```
 
-Defined in: [packages/db/src/types.ts:335](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L335)
+Defined in: [packages/db/src/types.ts:485](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L485)
 
 Collection status values for lifecycle management
 
@@ -28,6 +26,6 @@ if (collection.status === "loading") {
 
 ```ts
 // Status transitions
-// idle → loading → initialCommit → ready
+// idle → loading → ready (when markReady() is called)
 // Any status can transition to → error or cleaned-up
 ```
diff --git a/docs/reference/type-aliases/CursorExpressions.md b/docs/reference/type-aliases/CursorExpressions.md
new file mode 100644
index 000000000..9dc585805
--- /dev/null
+++ b/docs/reference/type-aliases/CursorExpressions.md
@@ -0,0 +1,60 @@
+---
+id: CursorExpressions
+title: CursorExpressions
+---
+
+# Type Alias: CursorExpressions
+
+```ts
+type CursorExpressions = object;
+```
+
+Defined in: [packages/db/src/types.ts:264](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L264)
+
+Cursor expressions for pagination, passed separately from the main `where` clause.
+The sync layer can choose to use cursor-based pagination (combining these with the where)
+or offset-based pagination (ignoring these and using the `offset` parameter).
+
+Neither expression includes the main `where` clause - they are cursor-specific only.
+
+## Properties
+
+### lastKey?
+
+```ts
+optional lastKey: string | number;
+```
+
+Defined in: [packages/db/src/types.ts:282](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L282)
+
+The key of the last item that was loaded.
+Can be used by sync layers for tracking or deduplication.
+
+***
+
+### whereCurrent
+
+```ts
+whereCurrent: BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/types.ts:277](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L277)
+
+Expression for rows equal to the current cursor value (first orderBy column only).
+Used to handle tie-breaking/duplicates at the boundary.
+Example: eq(col1, v1) or for Dates: and(gte(col1, v1), lt(col1, v1+1ms))
+
+***
+
+### whereFrom
+
+```ts
+whereFrom: BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/types.ts:271](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L271)
+
+Expression for rows greater than (after) the cursor value.
+For multi-column orderBy, this is a composite cursor using OR of conditions.
+Example for [col1 ASC, col2 DESC] with values [v1, v2]:
+  or(gt(col1, v1), and(eq(col1, v1), lt(col2, v2)))
diff --git a/docs/reference/type-aliases/DeleteKeyMessage.md b/docs/reference/type-aliases/DeleteKeyMessage.md
new file mode 100644
index 000000000..bf2c1a4e1
--- /dev/null
+++ b/docs/reference/type-aliases/DeleteKeyMessage.md
@@ -0,0 +1,26 @@
+---
+id: DeleteKeyMessage
+title: DeleteKeyMessage
+---
+
+# Type Alias: DeleteKeyMessage\<TKey\>
+
+```ts
+type DeleteKeyMessage<TKey> = Omit<ChangeMessage<any, TKey>, "value" | "previousValue" | "type"> & object;
+```
+
+Defined in: [packages/db/src/types.ts:370](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L370)
+
+## Type Declaration
+
+### type
+
+```ts
+type: "delete";
+```
+
+## Type Parameters
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
diff --git a/docs/reference/type-aliases/DeleteMutationFn.md b/docs/reference/type-aliases/DeleteMutationFn.md
new file mode 100644
index 000000000..f4458323f
--- /dev/null
+++ b/docs/reference/type-aliases/DeleteMutationFn.md
@@ -0,0 +1,40 @@
+---
+id: DeleteMutationFn
+title: DeleteMutationFn
+---
+
+# Type Alias: DeleteMutationFn()\<T, TKey, TUtils, TReturn\>
+
+```ts
+type DeleteMutationFn<T, TKey, TUtils, TReturn> = (params) => Promise<TReturn>;
+```
+
+Defined in: [packages/db/src/types.ts:463](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L463)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](UtilsRecord.md) = [`UtilsRecord`](UtilsRecord.md)
+
+### TReturn
+
+`TReturn` = `any`
+
+## Parameters
+
+### params
+
+[`DeleteMutationFnParams`](DeleteMutationFnParams.md)\<`T`, `TKey`, `TUtils`\>
+
+## Returns
+
+`Promise`\<`TReturn`\>
diff --git a/docs/reference/type-aliases/DeleteMutationFnParams.md b/docs/reference/type-aliases/DeleteMutationFnParams.md
new file mode 100644
index 000000000..f3821d576
--- /dev/null
+++ b/docs/reference/type-aliases/DeleteMutationFnParams.md
@@ -0,0 +1,46 @@
+---
+id: DeleteMutationFnParams
+title: DeleteMutationFnParams
+---
+
+# Type Alias: DeleteMutationFnParams\<T, TKey, TUtils\>
+
+```ts
+type DeleteMutationFnParams<T, TKey, TUtils> = object;
+```
+
+Defined in: [packages/db/src/types.ts:440](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L440)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](UtilsRecord.md) = [`UtilsRecord`](UtilsRecord.md)
+
+## Properties
+
+### collection
+
+```ts
+collection: Collection<T, TKey, TUtils>;
+```
+
+Defined in: [packages/db/src/types.ts:446](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L446)
+
+***
+
+### transaction
+
+```ts
+transaction: TransactionWithMutations<T, "delete">;
+```
+
+Defined in: [packages/db/src/types.ts:445](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L445)
diff --git a/docs/reference/type-aliases/ExtractContext.md b/docs/reference/type-aliases/ExtractContext.md
new file mode 100644
index 000000000..a5918bbf4
--- /dev/null
+++ b/docs/reference/type-aliases/ExtractContext.md
@@ -0,0 +1,18 @@
+---
+id: ExtractContext
+title: ExtractContext
+---
+
+# Type Alias: ExtractContext\<T\>
+
+```ts
+type ExtractContext<T> = T extends BaseQueryBuilder<infer TContext> ? TContext : T extends QueryBuilder<infer TContext> ? TContext : never;
+```
+
+Defined in: [packages/db/src/query/builder/index.ts:900](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L900)
+
+## Type Parameters
+
+### T
+
+`T`
diff --git a/docs/reference/type-aliases/FieldPath.md b/docs/reference/type-aliases/FieldPath.md
new file mode 100644
index 000000000..0dfa258e0
--- /dev/null
+++ b/docs/reference/type-aliases/FieldPath.md
@@ -0,0 +1,15 @@
+---
+id: FieldPath
+title: FieldPath
+---
+
+# Type Alias: FieldPath
+
+```ts
+type FieldPath = (string | number)[];
+```
+
+Defined in: [packages/db/src/query/expression-helpers.ts:39](https://github.com/TanStack/db/blob/main/packages/db/src/query/expression-helpers.ts#L39)
+
+Represents a simple field path extracted from an expression.
+Can include string keys for object properties and numbers for array indices.
diff --git a/docs/reference/type-aliases/fn.md b/docs/reference/type-aliases/Fn.md
similarity index 52%
rename from docs/reference/type-aliases/fn.md
rename to docs/reference/type-aliases/Fn.md
index 1b2d8e7a7..e79a1aca2 100644
--- a/docs/reference/type-aliases/fn.md
+++ b/docs/reference/type-aliases/Fn.md
@@ -3,15 +3,13 @@ id: Fn
 title: Fn
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: Fn()
 
 ```ts
 type Fn = (...args) => any;
 ```
 
-Defined in: [packages/db/src/types.ts:81](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L81)
+Defined in: [packages/db/src/types.ts:67](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L67)
 
 Represents a utility function that can be attached to a collection
 
diff --git a/docs/reference/type-aliases/GetResult.md b/docs/reference/type-aliases/GetResult.md
new file mode 100644
index 000000000..eaa044ea0
--- /dev/null
+++ b/docs/reference/type-aliases/GetResult.md
@@ -0,0 +1,42 @@
+---
+id: GetResult
+title: GetResult
+---
+
+# Type Alias: GetResult\<TContext\>
+
+```ts
+type GetResult<TContext> = Prettify<TContext["result"] extends object ? TContext["result"] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]]>;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:678](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L678)
+
+GetResult - Determines the final result type of a query
+
+This type implements the logic for what a query returns based on its current state:
+
+**Priority Order**:
+1. **Explicit Result**: If `select()` was called, use the projected type
+2. **Join Query**: If joins exist, return all tables with proper optionality
+3. **Single Table**: Return just the main table from `from()`
+
+**Examples**:
+```typescript
+// Single table query:
+from({ users }).where(...) // → User[]
+
+// Join query without select:
+from({ users }).leftJoin({ orders }, ...) // → { users: User, orders: Order | undefined }[]
+
+// Query with select:
+from({ users }).select({ id: users.id, name: users.name }) // → { id: number, name: string }[]
+```
+
+The `Prettify` wrapper ensures clean type display in IDEs by flattening
+complex intersection types into readable object types.
+
+## Type Parameters
+
+### TContext
+
+`TContext` *extends* [`Context`](../interfaces/Context.md)
diff --git a/docs/reference/type-aliases/getstoragesizefn.md b/docs/reference/type-aliases/GetStorageSizeFn.md
similarity index 50%
rename from docs/reference/type-aliases/getstoragesizefn.md
rename to docs/reference/type-aliases/GetStorageSizeFn.md
index c1f43dd4c..2008fbbd6 100644
--- a/docs/reference/type-aliases/getstoragesizefn.md
+++ b/docs/reference/type-aliases/GetStorageSizeFn.md
@@ -3,15 +3,13 @@ id: GetStorageSizeFn
 title: GetStorageSizeFn
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: GetStorageSizeFn()
 
 ```ts
 type GetStorageSizeFn = () => number;
 ```
 
-Defined in: [packages/db/src/local-storage.ts:127](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L127)
+Defined in: [packages/db/src/local-storage.ts:95](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L95)
 
 Type for the getStorageSize utility function
 
diff --git a/docs/reference/type-aliases/indexconstructor.md b/docs/reference/type-aliases/IndexConstructor.md
similarity index 58%
rename from docs/reference/type-aliases/indexconstructor.md
rename to docs/reference/type-aliases/IndexConstructor.md
index 2213ada81..37b7a182a 100644
--- a/docs/reference/type-aliases/indexconstructor.md
+++ b/docs/reference/type-aliases/IndexConstructor.md
@@ -3,21 +3,21 @@ id: IndexConstructor
 title: IndexConstructor
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: IndexConstructor()\<TKey\>
 
 ```ts
 type IndexConstructor<TKey> = (id, expression, name?, options?) => BaseIndex<TKey>;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:106](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L106)
+Defined in: [packages/db/src/indexes/base-index.ts:201](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L201)
 
 Type for index constructor
 
 ## Type Parameters
 
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
 
 ## Parameters
 
@@ -27,7 +27,7 @@ Type for index constructor
 
 ### expression
 
-`BasicExpression`
+[`BasicExpression`](../@tanstack/namespaces/IR/type-aliases/BasicExpression.md)
 
 ### name?
 
@@ -39,4 +39,4 @@ Type for index constructor
 
 ## Returns
 
-[`BaseIndex`](../../classes/baseindex.md)\<`TKey`\>
+[`BaseIndex`](../classes/BaseIndex.md)\<`TKey`\>
diff --git a/docs/reference/type-aliases/IndexOperation.md b/docs/reference/type-aliases/IndexOperation.md
new file mode 100644
index 000000000..3dbce14d1
--- /dev/null
+++ b/docs/reference/type-aliases/IndexOperation.md
@@ -0,0 +1,14 @@
+---
+id: IndexOperation
+title: IndexOperation
+---
+
+# Type Alias: IndexOperation
+
+```ts
+type IndexOperation = typeof comparisonFunctions[number];
+```
+
+Defined in: [packages/db/src/indexes/base-index.ts:11](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L11)
+
+Type for index operation values
diff --git a/docs/reference/type-aliases/indexresolver.md b/docs/reference/type-aliases/IndexResolver.md
similarity index 61%
rename from docs/reference/type-aliases/indexresolver.md
rename to docs/reference/type-aliases/IndexResolver.md
index 9d84e2fb6..8dcd5c3e5 100644
--- a/docs/reference/type-aliases/indexresolver.md
+++ b/docs/reference/type-aliases/IndexResolver.md
@@ -3,8 +3,6 @@ id: IndexResolver
 title: IndexResolver
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: IndexResolver\<TKey\>
 
 ```ts
@@ -13,10 +11,12 @@ type IndexResolver<TKey> =
 | () => Promise<IndexConstructor<TKey>>;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:117](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L117)
+Defined in: [packages/db/src/indexes/base-index.ts:212](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L212)
 
 Index resolver can be either a class constructor or async loader
 
 ## Type Parameters
 
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
diff --git a/docs/reference/type-aliases/InferResultType.md b/docs/reference/type-aliases/InferResultType.md
new file mode 100644
index 000000000..dcb111c85
--- /dev/null
+++ b/docs/reference/type-aliases/InferResultType.md
@@ -0,0 +1,20 @@
+---
+id: InferResultType
+title: InferResultType
+---
+
+# Type Alias: InferResultType\<TContext\>
+
+```ts
+type InferResultType<TContext> = TContext extends SingleResult ? GetResult<TContext> | undefined : GetResult<TContext>[];
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:648](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L648)
+
+Utility type to infer the query result size (single row or an array)
+
+## Type Parameters
+
+### TContext
+
+`TContext` *extends* [`Context`](../interfaces/Context.md)
diff --git a/docs/reference/type-aliases/inferschemainput.md b/docs/reference/type-aliases/InferSchemaInput.md
similarity index 69%
rename from docs/reference/type-aliases/inferschemainput.md
rename to docs/reference/type-aliases/InferSchemaInput.md
index f931fec20..1e6ad08ff 100644
--- a/docs/reference/type-aliases/inferschemainput.md
+++ b/docs/reference/type-aliases/InferSchemaInput.md
@@ -3,15 +3,13 @@ id: InferSchemaInput
 title: InferSchemaInput
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: InferSchemaInput\<T\>
 
 ```ts
 type InferSchemaInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> extends object ? StandardSchemaV1.InferInput<T> : Record<string, unknown> : Record<string, unknown>;
 ```
 
-Defined in: [packages/db/src/types.ts:25](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L25)
+Defined in: [packages/db/src/types.ts:56](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L56)
 
 **`Internal`**
 
@@ -21,4 +19,6 @@ Helper type to extract the input type from a standard schema
 
 ## Type Parameters
 
-• **T**
+### T
+
+`T`
diff --git a/docs/reference/type-aliases/inferschemaoutput.md b/docs/reference/type-aliases/InferSchemaOutput.md
similarity index 69%
rename from docs/reference/type-aliases/inferschemaoutput.md
rename to docs/reference/type-aliases/InferSchemaOutput.md
index d586b3244..7b170e663 100644
--- a/docs/reference/type-aliases/inferschemaoutput.md
+++ b/docs/reference/type-aliases/InferSchemaOutput.md
@@ -3,15 +3,13 @@ id: InferSchemaOutput
 title: InferSchemaOutput
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: InferSchemaOutput\<T\>
 
 ```ts
 type InferSchemaOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> extends object ? StandardSchemaV1.InferOutput<T> : Record<string, unknown> : Record<string, unknown>;
 ```
 
-Defined in: [packages/db/src/types.ts:14](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L14)
+Defined in: [packages/db/src/types.ts:45](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L45)
 
 **`Internal`**
 
@@ -21,4 +19,6 @@ Helper type to extract the output type from a standard schema
 
 ## Type Parameters
 
-• **T**
+### T
+
+`T`
diff --git a/docs/reference/type-aliases/initialquerybuilder.md b/docs/reference/type-aliases/InitialQueryBuilder.md
similarity index 61%
rename from docs/reference/type-aliases/initialquerybuilder.md
rename to docs/reference/type-aliases/InitialQueryBuilder.md
index a3d6f83ec..88ba624d9 100644
--- a/docs/reference/type-aliases/initialquerybuilder.md
+++ b/docs/reference/type-aliases/InitialQueryBuilder.md
@@ -3,12 +3,10 @@ id: InitialQueryBuilder
 title: InitialQueryBuilder
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: InitialQueryBuilder
 
 ```ts
 type InitialQueryBuilder = Pick<BaseQueryBuilder<Context>, "from">;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:756](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L756)
+Defined in: [packages/db/src/query/builder/index.ts:886](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L886)
diff --git a/docs/reference/type-aliases/InputRow.md b/docs/reference/type-aliases/InputRow.md
new file mode 100644
index 000000000..58fc37ce3
--- /dev/null
+++ b/docs/reference/type-aliases/InputRow.md
@@ -0,0 +1,14 @@
+---
+id: InputRow
+title: InputRow
+---
+
+# Type Alias: InputRow
+
+```ts
+type InputRow = [unknown, Record<string, unknown>];
+```
+
+Defined in: [packages/db/src/types.ts:749](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L749)
+
+An input row from a collection
diff --git a/docs/reference/type-aliases/InsertMutationFn.md b/docs/reference/type-aliases/InsertMutationFn.md
new file mode 100644
index 000000000..e78617fb5
--- /dev/null
+++ b/docs/reference/type-aliases/InsertMutationFn.md
@@ -0,0 +1,40 @@
+---
+id: InsertMutationFn
+title: InsertMutationFn
+---
+
+# Type Alias: InsertMutationFn()\<T, TKey, TUtils, TReturn\>
+
+```ts
+type InsertMutationFn<T, TKey, TUtils, TReturn> = (params) => Promise<TReturn>;
+```
+
+Defined in: [packages/db/src/types.ts:449](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L449)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](UtilsRecord.md) = [`UtilsRecord`](UtilsRecord.md)
+
+### TReturn
+
+`TReturn` = `any`
+
+## Parameters
+
+### params
+
+[`InsertMutationFnParams`](InsertMutationFnParams.md)\<`T`, `TKey`, `TUtils`\>
+
+## Returns
+
+`Promise`\<`TReturn`\>
diff --git a/docs/reference/type-aliases/InsertMutationFnParams.md b/docs/reference/type-aliases/InsertMutationFnParams.md
new file mode 100644
index 000000000..9c3c5fad0
--- /dev/null
+++ b/docs/reference/type-aliases/InsertMutationFnParams.md
@@ -0,0 +1,46 @@
+---
+id: InsertMutationFnParams
+title: InsertMutationFnParams
+---
+
+# Type Alias: InsertMutationFnParams\<T, TKey, TUtils\>
+
+```ts
+type InsertMutationFnParams<T, TKey, TUtils> = object;
+```
+
+Defined in: [packages/db/src/types.ts:432](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L432)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](UtilsRecord.md) = [`UtilsRecord`](UtilsRecord.md)
+
+## Properties
+
+### collection
+
+```ts
+collection: Collection<T, TKey, TUtils>;
+```
+
+Defined in: [packages/db/src/types.ts:438](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L438)
+
+***
+
+### transaction
+
+```ts
+transaction: TransactionWithMutations<T, "insert">;
+```
+
+Defined in: [packages/db/src/types.ts:437](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L437)
diff --git a/docs/reference/type-aliases/keyednamespacedrow.md b/docs/reference/type-aliases/KeyedNamespacedRow.md
similarity index 59%
rename from docs/reference/type-aliases/keyednamespacedrow.md
rename to docs/reference/type-aliases/KeyedNamespacedRow.md
index 8891adb30..cfd820ed1 100644
--- a/docs/reference/type-aliases/keyednamespacedrow.md
+++ b/docs/reference/type-aliases/KeyedNamespacedRow.md
@@ -3,15 +3,13 @@ id: KeyedNamespacedRow
 title: KeyedNamespacedRow
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: KeyedNamespacedRow
 
 ```ts
 type KeyedNamespacedRow = [unknown, NamespacedRow];
 ```
 
-Defined in: [packages/db/src/types.ts:561](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L561)
+Defined in: [packages/db/src/types.ts:772](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L772)
 
 A keyed namespaced row is a row with a key and a namespaced row
 This is the main representation of a row in a query pipeline
diff --git a/docs/reference/type-aliases/keyedstream.md b/docs/reference/type-aliases/KeyedStream.md
similarity index 53%
rename from docs/reference/type-aliases/keyedstream.md
rename to docs/reference/type-aliases/KeyedStream.md
index 5dff756ab..dbc41e13c 100644
--- a/docs/reference/type-aliases/keyedstream.md
+++ b/docs/reference/type-aliases/KeyedStream.md
@@ -3,15 +3,13 @@ id: KeyedStream
 title: KeyedStream
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: KeyedStream
 
 ```ts
 type KeyedStream = IStreamBuilder<InputRow>;
 ```
 
-Defined in: [packages/db/src/types.ts:544](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L544)
+Defined in: [packages/db/src/types.ts:755](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L755)
 
 A keyed stream is a stream of rows
 This is used as the inputs from a collection to a query
diff --git a/docs/reference/type-aliases/LiveQueryCollectionUtils.md b/docs/reference/type-aliases/LiveQueryCollectionUtils.md
new file mode 100644
index 000000000..468fa1bf5
--- /dev/null
+++ b/docs/reference/type-aliases/LiveQueryCollectionUtils.md
@@ -0,0 +1,74 @@
+---
+id: LiveQueryCollectionUtils
+title: LiveQueryCollectionUtils
+---
+
+# Type Alias: LiveQueryCollectionUtils
+
+```ts
+type LiveQueryCollectionUtils = UtilsRecord & object;
+```
+
+Defined in: [packages/db/src/query/live/collection-config-builder.ts:39](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/collection-config-builder.ts#L39)
+
+## Type Declaration
+
+### \[LIVE\_QUERY\_INTERNAL\]
+
+```ts
+[LIVE_QUERY_INTERNAL]: LiveQueryInternalUtils;
+```
+
+### getRunCount()
+
+```ts
+getRunCount: () => number;
+```
+
+#### Returns
+
+`number`
+
+### getWindow()
+
+```ts
+getWindow: () => 
+  | {
+  limit: number;
+  offset: number;
+}
+  | undefined;
+```
+
+Gets the current window (offset and limit) for an ordered query.
+
+#### Returns
+
+  \| \{
+  `limit`: `number`;
+  `offset`: `number`;
+\}
+  \| `undefined`
+
+The current window settings, or `undefined` if the query is not windowed
+
+### setWindow()
+
+```ts
+setWindow: (options) => true | Promise<void>;
+```
+
+Sets the offset and limit of an ordered query.
+Is a no-op if the query is not ordered.
+
+#### Parameters
+
+##### options
+
+`WindowOptions`
+
+#### Returns
+
+`true` \| `Promise`\<`void`\>
+
+`true` if no subset loading was triggered, or `Promise<void>` that resolves when the subset has been loaded
diff --git a/docs/reference/type-aliases/LoadSubsetFn.md b/docs/reference/type-aliases/LoadSubsetFn.md
new file mode 100644
index 000000000..862a82163
--- /dev/null
+++ b/docs/reference/type-aliases/LoadSubsetFn.md
@@ -0,0 +1,22 @@
+---
+id: LoadSubsetFn
+title: LoadSubsetFn
+---
+
+# Type Alias: LoadSubsetFn()
+
+```ts
+type LoadSubsetFn = (options) => true | Promise<void>;
+```
+
+Defined in: [packages/db/src/types.ts:314](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L314)
+
+## Parameters
+
+### options
+
+[`LoadSubsetOptions`](LoadSubsetOptions.md)
+
+## Returns
+
+`true` \| `Promise`\<`void`\>
diff --git a/docs/reference/type-aliases/LoadSubsetOptions.md b/docs/reference/type-aliases/LoadSubsetOptions.md
new file mode 100644
index 000000000..8e8cfe27c
--- /dev/null
+++ b/docs/reference/type-aliases/LoadSubsetOptions.md
@@ -0,0 +1,95 @@
+---
+id: LoadSubsetOptions
+title: LoadSubsetOptions
+---
+
+# Type Alias: LoadSubsetOptions
+
+```ts
+type LoadSubsetOptions = object;
+```
+
+Defined in: [packages/db/src/types.ts:285](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L285)
+
+## Properties
+
+### cursor?
+
+```ts
+optional cursor: CursorExpressions;
+```
+
+Defined in: [packages/db/src/types.ts:297](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L297)
+
+Cursor expressions for cursor-based pagination.
+These are separate from `where` - the sync layer should combine them if using cursor-based pagination.
+Neither expression includes the main `where` clause.
+
+***
+
+### limit?
+
+```ts
+optional limit: number;
+```
+
+Defined in: [packages/db/src/types.ts:291](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L291)
+
+The limit of the data to load
+
+***
+
+### offset?
+
+```ts
+optional offset: number;
+```
+
+Defined in: [packages/db/src/types.ts:302](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L302)
+
+Row offset for offset-based pagination.
+The sync layer can use this instead of `cursor` if it prefers offset-based pagination.
+
+***
+
+### orderBy?
+
+```ts
+optional orderBy: OrderBy;
+```
+
+Defined in: [packages/db/src/types.ts:289](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L289)
+
+The order by clause to sort the data
+
+***
+
+### subscription?
+
+```ts
+optional subscription: Subscription;
+```
+
+Defined in: [packages/db/src/types.ts:311](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L311)
+
+The subscription that triggered the load.
+Advanced sync implementations can use this for:
+- LRU caching keyed by subscription
+- Reference counting to track active subscriptions
+- Subscribing to subscription events (e.g., finalization/unsubscribe)
+
+#### Optional
+
+Available when called from CollectionSubscription, may be undefined for direct calls
+
+***
+
+### where?
+
+```ts
+optional where: BasicExpression<boolean>;
+```
+
+Defined in: [packages/db/src/types.ts:287](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L287)
+
+The where expression to filter the data (does NOT include cursor expressions)
diff --git a/docs/reference/type-aliases/MakeOptional.md b/docs/reference/type-aliases/MakeOptional.md
new file mode 100644
index 000000000..ac0a71b74
--- /dev/null
+++ b/docs/reference/type-aliases/MakeOptional.md
@@ -0,0 +1,22 @@
+---
+id: MakeOptional
+title: MakeOptional
+---
+
+# Type Alias: MakeOptional\<T, K\>
+
+```ts
+type MakeOptional<T, K> = Omit<T, K> & Partial<Pick<T, K>>;
+```
+
+Defined in: [packages/db/src/types.ts:942](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L942)
+
+## Type Parameters
+
+### T
+
+`T`
+
+### K
+
+`K` *extends* keyof `T`
diff --git a/docs/reference/type-aliases/MaybeSingleResult.md b/docs/reference/type-aliases/MaybeSingleResult.md
new file mode 100644
index 000000000..d86ed4fd0
--- /dev/null
+++ b/docs/reference/type-aliases/MaybeSingleResult.md
@@ -0,0 +1,24 @@
+---
+id: MaybeSingleResult
+title: MaybeSingleResult
+---
+
+# Type Alias: MaybeSingleResult
+
+```ts
+type MaybeSingleResult = object;
+```
+
+Defined in: [packages/db/src/types.ts:727](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L727)
+
+## Properties
+
+### singleResult?
+
+```ts
+optional singleResult: true;
+```
+
+Defined in: [packages/db/src/types.ts:731](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L731)
+
+If enabled the collection will return a single object instead of an array
diff --git a/docs/reference/type-aliases/MutationFn.md b/docs/reference/type-aliases/MutationFn.md
new file mode 100644
index 000000000..33ff9dcf1
--- /dev/null
+++ b/docs/reference/type-aliases/MutationFn.md
@@ -0,0 +1,28 @@
+---
+id: MutationFn
+title: MutationFn
+---
+
+# Type Alias: MutationFn()\<T\>
+
+```ts
+type MutationFn<T> = (params) => Promise<any>;
+```
+
+Defined in: [packages/db/src/types.ts:127](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L127)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+## Parameters
+
+### params
+
+[`MutationFnParams`](MutationFnParams.md)\<`T`\>
+
+## Returns
+
+`Promise`\<`any`\>
diff --git a/docs/reference/type-aliases/MutationFnParams.md b/docs/reference/type-aliases/MutationFnParams.md
new file mode 100644
index 000000000..7df30d800
--- /dev/null
+++ b/docs/reference/type-aliases/MutationFnParams.md
@@ -0,0 +1,30 @@
+---
+id: MutationFnParams
+title: MutationFnParams
+---
+
+# Type Alias: MutationFnParams\<T\>
+
+```ts
+type MutationFnParams<T> = object;
+```
+
+Defined in: [packages/db/src/types.ts:123](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L123)
+
+Configuration options for creating a new transaction
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+## Properties
+
+### transaction
+
+```ts
+transaction: TransactionWithMutations<T>;
+```
+
+Defined in: [packages/db/src/types.ts:124](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L124)
diff --git a/docs/reference/type-aliases/namespacedandkeyedstream.md b/docs/reference/type-aliases/NamespacedAndKeyedStream.md
similarity index 64%
rename from docs/reference/type-aliases/namespacedandkeyedstream.md
rename to docs/reference/type-aliases/NamespacedAndKeyedStream.md
index 3917b71b7..4c952ad84 100644
--- a/docs/reference/type-aliases/namespacedandkeyedstream.md
+++ b/docs/reference/type-aliases/NamespacedAndKeyedStream.md
@@ -3,15 +3,13 @@ id: NamespacedAndKeyedStream
 title: NamespacedAndKeyedStream
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: NamespacedAndKeyedStream
 
 ```ts
 type NamespacedAndKeyedStream = IStreamBuilder<KeyedNamespacedRow>;
 ```
 
-Defined in: [packages/db/src/types.ts:568](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L568)
+Defined in: [packages/db/src/types.ts:779](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L779)
 
 A namespaced and keyed stream is a stream of rows
 This is used throughout a query pipeline and as the output from a query without
diff --git a/docs/reference/type-aliases/namespacedrow.md b/docs/reference/type-aliases/NamespacedRow.md
similarity index 55%
rename from docs/reference/type-aliases/namespacedrow.md
rename to docs/reference/type-aliases/NamespacedRow.md
index b55ea35a8..2d7acd058 100644
--- a/docs/reference/type-aliases/namespacedrow.md
+++ b/docs/reference/type-aliases/NamespacedRow.md
@@ -3,14 +3,12 @@ id: NamespacedRow
 title: NamespacedRow
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: NamespacedRow
 
 ```ts
 type NamespacedRow = Record<string, Record<string, unknown>>;
 ```
 
-Defined in: [packages/db/src/types.ts:555](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L555)
+Defined in: [packages/db/src/types.ts:766](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L766)
 
 A namespaced row is a row withing a pipeline that had each table wrapped in its alias
diff --git a/docs/reference/type-aliases/nonemptyarray.md b/docs/reference/type-aliases/NonEmptyArray.md
similarity index 50%
rename from docs/reference/type-aliases/nonemptyarray.md
rename to docs/reference/type-aliases/NonEmptyArray.md
index 415fd304f..3ff5d7dfa 100644
--- a/docs/reference/type-aliases/nonemptyarray.md
+++ b/docs/reference/type-aliases/NonEmptyArray.md
@@ -3,18 +3,18 @@ id: NonEmptyArray
 title: NonEmptyArray
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: NonEmptyArray\<T\>
 
 ```ts
 type NonEmptyArray<T> = [T, ...T[]];
 ```
 
-Defined in: [packages/db/src/types.ts:148](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L148)
+Defined in: [packages/db/src/types.ts:134](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L134)
 
 Represents a non-empty array (at least one element)
 
 ## Type Parameters
 
-• **T**
+### T
+
+`T`
diff --git a/docs/reference/type-aliases/NonSingleResult.md b/docs/reference/type-aliases/NonSingleResult.md
new file mode 100644
index 000000000..bd198e148
--- /dev/null
+++ b/docs/reference/type-aliases/NonSingleResult.md
@@ -0,0 +1,22 @@
+---
+id: NonSingleResult
+title: NonSingleResult
+---
+
+# Type Alias: NonSingleResult
+
+```ts
+type NonSingleResult = object;
+```
+
+Defined in: [packages/db/src/types.ts:723](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L723)
+
+## Properties
+
+### singleResult?
+
+```ts
+optional singleResult: never;
+```
+
+Defined in: [packages/db/src/types.ts:724](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L724)
diff --git a/docs/reference/type-aliases/OperationType.md b/docs/reference/type-aliases/OperationType.md
new file mode 100644
index 000000000..2f9b1f6c7
--- /dev/null
+++ b/docs/reference/type-aliases/OperationType.md
@@ -0,0 +1,12 @@
+---
+id: OperationType
+title: OperationType
+---
+
+# Type Alias: OperationType
+
+```ts
+type OperationType = "insert" | "update" | "delete";
+```
+
+Defined in: [packages/db/src/types.ts:203](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L203)
diff --git a/docs/reference/type-aliases/OperatorName.md b/docs/reference/type-aliases/OperatorName.md
new file mode 100644
index 000000000..6535be23f
--- /dev/null
+++ b/docs/reference/type-aliases/OperatorName.md
@@ -0,0 +1,12 @@
+---
+id: OperatorName
+title: OperatorName
+---
+
+# Type Alias: OperatorName
+
+```ts
+type OperatorName = typeof operators[number];
+```
+
+Defined in: [packages/db/src/query/builder/functions.ts:378](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L378)
diff --git a/docs/reference/type-aliases/OptimisticChangeMessage.md b/docs/reference/type-aliases/OptimisticChangeMessage.md
new file mode 100644
index 000000000..05fa24929
--- /dev/null
+++ b/docs/reference/type-aliases/OptimisticChangeMessage.md
@@ -0,0 +1,24 @@
+---
+id: OptimisticChangeMessage
+title: OptimisticChangeMessage
+---
+
+# Type Alias: OptimisticChangeMessage\<T, TKey\>
+
+```ts
+type OptimisticChangeMessage<T, TKey> = 
+  | ChangeMessage<T> & object
+  | DeleteKeyMessage<TKey> & object;
+```
+
+Defined in: [packages/db/src/types.ts:380](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L380)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
diff --git a/docs/reference/type-aliases/querybuilder.md b/docs/reference/type-aliases/QueryBuilder.md
similarity index 55%
rename from docs/reference/type-aliases/querybuilder.md
rename to docs/reference/type-aliases/QueryBuilder.md
index 2e67b8f34..a865d1d9f 100644
--- a/docs/reference/type-aliases/querybuilder.md
+++ b/docs/reference/type-aliases/QueryBuilder.md
@@ -3,16 +3,16 @@ id: QueryBuilder
 title: QueryBuilder
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: QueryBuilder\<TContext\>
 
 ```ts
 type QueryBuilder<TContext> = Omit<BaseQueryBuilder<TContext>, "from" | "_getQuery">;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:760](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L760)
+Defined in: [packages/db/src/query/builder/index.ts:890](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L890)
 
 ## Type Parameters
 
-• **TContext** *extends* [`Context`](../../interfaces/context.md)
+### TContext
+
+`TContext` *extends* [`Context`](../interfaces/Context.md)
diff --git a/docs/reference/type-aliases/QueryResult.md b/docs/reference/type-aliases/QueryResult.md
new file mode 100644
index 000000000..ceab243c9
--- /dev/null
+++ b/docs/reference/type-aliases/QueryResult.md
@@ -0,0 +1,18 @@
+---
+id: QueryResult
+title: QueryResult
+---
+
+# Type Alias: QueryResult\<T\>
+
+```ts
+type QueryResult<T> = GetResult<ExtractContext<T>>;
+```
+
+Defined in: [packages/db/src/query/builder/index.ts:908](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L908)
+
+## Type Parameters
+
+### T
+
+`T`
diff --git a/docs/reference/type-aliases/Ref.md b/docs/reference/type-aliases/Ref.md
new file mode 100644
index 000000000..a346b0dc0
--- /dev/null
+++ b/docs/reference/type-aliases/Ref.md
@@ -0,0 +1,39 @@
+---
+id: Ref
+title: Ref
+---
+
+# Type Alias: Ref\<T\>
+
+```ts
+type Ref<T> = { [K in keyof T]: IsNonExactOptional<T[K]> extends true ? IsNonExactNullable<T[K]> extends true ? IsPlainObject<NonNullable<T[K]>> extends true ? Ref<NonNullable<T[K]>> | undefined : RefLeaf<NonNullable<T[K]>> | undefined : IsPlainObject<NonUndefined<T[K]>> extends true ? Ref<NonUndefined<T[K]>> | undefined : RefLeaf<NonUndefined<T[K]>> | undefined : IsNonExactNullable<T[K]> extends true ? IsPlainObject<NonNull<T[K]>> extends true ? Ref<NonNull<T[K]>> | null : RefLeaf<NonNull<T[K]>> | null : IsPlainObject<T[K]> extends true ? Ref<T[K]> : RefLeaf<T[K]> } & RefLeaf<T>;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:496](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L496)
+
+Ref - The user-facing ref interface for the query builder
+
+This is a clean type that represents a reference to a value in the query,
+designed for optimal IDE experience without internal implementation details.
+It provides a recursive interface that allows nested property access while
+preserving optionality and nullability correctly.
+
+When spread in select clauses, it correctly produces the underlying data type
+without Ref wrappers, enabling clean spread operations.
+
+Example usage:
+```typescript
+// Clean interface - no internal properties visible
+const users: Ref<{ id: number; profile?: { bio: string } }> = { ... }
+users.id // Ref<number> - clean display
+users.profile?.bio // Ref<string> - nested optional access works
+
+// Spread operations work cleanly:
+select(({ user }) => ({ ...user })) // Returns User type, not Ref types
+```
+
+## Type Parameters
+
+### T
+
+`T` = `any`
diff --git a/docs/reference/type-aliases/resolvetransactionchanges.md b/docs/reference/type-aliases/ResolveTransactionChanges.md
similarity index 62%
rename from docs/reference/type-aliases/resolvetransactionchanges.md
rename to docs/reference/type-aliases/ResolveTransactionChanges.md
index fba10405b..fa6a413cb 100644
--- a/docs/reference/type-aliases/resolvetransactionchanges.md
+++ b/docs/reference/type-aliases/ResolveTransactionChanges.md
@@ -3,21 +3,23 @@ id: ResolveTransactionChanges
 title: ResolveTransactionChanges
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: ResolveTransactionChanges\<T, TOperation\>
 
 ```ts
 type ResolveTransactionChanges<T, TOperation> = TOperation extends "delete" ? T : Partial<T>;
 ```
 
-Defined in: [packages/db/src/types.ts:94](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L94)
+Defined in: [packages/db/src/types.ts:80](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L80)
 
 ## Type Parameters
 
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TOperation
 
-• **TOperation** *extends* [`OperationType`](../operationtype.md) = [`OperationType`](../operationtype.md)
+`TOperation` *extends* [`OperationType`](OperationType.md) = [`OperationType`](OperationType.md)
 
 ## Remarks
 
diff --git a/docs/reference/type-aliases/resultstream.md b/docs/reference/type-aliases/ResultStream.md
similarity index 63%
rename from docs/reference/type-aliases/resultstream.md
rename to docs/reference/type-aliases/ResultStream.md
index 283bb2a76..543f601ca 100644
--- a/docs/reference/type-aliases/resultstream.md
+++ b/docs/reference/type-aliases/ResultStream.md
@@ -3,15 +3,13 @@ id: ResultStream
 title: ResultStream
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: ResultStream
 
 ```ts
 type ResultStream = IStreamBuilder<[unknown, [any, string | undefined]]>;
 ```
 
-Defined in: [packages/db/src/types.ts:550](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L550)
+Defined in: [packages/db/src/types.ts:761](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L761)
 
 Result stream type representing the output of compiled queries
 Always returns [key, [result, orderByIndex]] where orderByIndex is undefined for unordered queries
diff --git a/docs/reference/type-aliases/Row.md b/docs/reference/type-aliases/Row.md
new file mode 100644
index 000000000..4e9a7cff1
--- /dev/null
+++ b/docs/reference/type-aliases/Row.md
@@ -0,0 +1,18 @@
+---
+id: Row
+title: Row
+---
+
+# Type Alias: Row\<TExtensions\>
+
+```ts
+type Row<TExtensions> = Record<string, Value<TExtensions>>;
+```
+
+Defined in: [packages/db/src/types.ts:201](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L201)
+
+## Type Parameters
+
+### TExtensions
+
+`TExtensions` = `never`
diff --git a/docs/reference/type-aliases/SingleResult.md b/docs/reference/type-aliases/SingleResult.md
new file mode 100644
index 000000000..2ba7a0f10
--- /dev/null
+++ b/docs/reference/type-aliases/SingleResult.md
@@ -0,0 +1,22 @@
+---
+id: SingleResult
+title: SingleResult
+---
+
+# Type Alias: SingleResult
+
+```ts
+type SingleResult = object;
+```
+
+Defined in: [packages/db/src/types.ts:719](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L719)
+
+## Properties
+
+### singleResult
+
+```ts
+singleResult: true;
+```
+
+Defined in: [packages/db/src/types.ts:720](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L720)
diff --git a/docs/reference/type-aliases/Source.md b/docs/reference/type-aliases/Source.md
new file mode 100644
index 000000000..3d5b59b01
--- /dev/null
+++ b/docs/reference/type-aliases/Source.md
@@ -0,0 +1,29 @@
+---
+id: Source
+title: Source
+---
+
+# Type Alias: Source
+
+```ts
+type Source = object;
+```
+
+Defined in: [packages/db/src/query/builder/types.ts:75](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L75)
+
+Source - Input definition for query builder `from()` clause
+
+Maps table aliases to either:
+- `CollectionImpl`: A database collection/table
+- `QueryBuilder`: A subquery that can be used as a table
+
+Example: `{ users: usersCollection, orders: ordersCollection }`
+
+## Index Signature
+
+```ts
+[alias: string]: 
+  | CollectionImpl<any, any, {
+}, StandardSchemaV1<unknown, unknown>, any>
+| QueryBuilder<Context>
+```
diff --git a/docs/reference/type-aliases/standardschema.md b/docs/reference/type-aliases/StandardSchema.md
similarity index 69%
rename from docs/reference/type-aliases/standardschema.md
rename to docs/reference/type-aliases/StandardSchema.md
index 2766afb69..dd88681a5 100644
--- a/docs/reference/type-aliases/standardschema.md
+++ b/docs/reference/type-aliases/StandardSchema.md
@@ -3,20 +3,18 @@ id: StandardSchema
 title: StandardSchema
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: StandardSchema\<T\>
 
 ```ts
 type StandardSchema<T> = StandardSchemaV1 & object;
 ```
 
-Defined in: [packages/db/src/types.ts:250](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L250)
+Defined in: [packages/db/src/types.ts:397](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L397)
 
 The Standard Schema interface.
 This follows the standard-schema specification: https://github.com/standard-schema/standard-schema
 
-## Type declaration
+## Type Declaration
 
 ### ~standard
 
@@ -44,4 +42,6 @@ output: T;
 
 ## Type Parameters
 
-• **T**
+### T
+
+`T`
diff --git a/docs/reference/type-aliases/standardschemaalias.md b/docs/reference/type-aliases/StandardSchemaAlias.md
similarity index 50%
rename from docs/reference/type-aliases/standardschemaalias.md
rename to docs/reference/type-aliases/StandardSchemaAlias.md
index e3489a6c0..423e619e5 100644
--- a/docs/reference/type-aliases/standardschemaalias.md
+++ b/docs/reference/type-aliases/StandardSchemaAlias.md
@@ -3,18 +3,18 @@ id: StandardSchemaAlias
 title: StandardSchemaAlias
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: StandardSchemaAlias\<T\>
 
 ```ts
 type StandardSchemaAlias<T> = StandardSchema<T>;
 ```
 
-Defined in: [packages/db/src/types.ts:262](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L262)
+Defined in: [packages/db/src/types.ts:409](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L409)
 
 Type alias for StandardSchema
 
 ## Type Parameters
 
-• **T** = `unknown`
+### T
+
+`T` = `unknown`
diff --git a/docs/reference/type-aliases/storageapi.md b/docs/reference/type-aliases/StorageApi.md
similarity index 82%
rename from docs/reference/type-aliases/storageapi.md
rename to docs/reference/type-aliases/StorageApi.md
index 2379f0b39..fde4dcad5 100644
--- a/docs/reference/type-aliases/storageapi.md
+++ b/docs/reference/type-aliases/StorageApi.md
@@ -3,8 +3,6 @@ id: StorageApi
 title: StorageApi
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: StorageApi
 
 ```ts
diff --git a/docs/reference/type-aliases/storageeventapi.md b/docs/reference/type-aliases/StorageEventApi.md
similarity index 71%
rename from docs/reference/type-aliases/storageeventapi.md
rename to docs/reference/type-aliases/StorageEventApi.md
index dc2a5730a..4e3d8f10a 100644
--- a/docs/reference/type-aliases/storageeventapi.md
+++ b/docs/reference/type-aliases/StorageEventApi.md
@@ -3,8 +3,6 @@ id: StorageEventApi
 title: StorageEventApi
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Type Alias: StorageEventApi
 
 ```ts
@@ -15,7 +13,7 @@ Defined in: [packages/db/src/local-storage.ts:28](https://github.com/TanStack/db
 
 Storage event API - subset of Window for 'storage' events only
 
-## Type declaration
+## Properties
 
 ### addEventListener()
 
@@ -23,6 +21,8 @@ Storage event API - subset of Window for 'storage' events only
 addEventListener: (type, listener) => void;
 ```
 
+Defined in: [packages/db/src/local-storage.ts:29](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L29)
+
 #### Parameters
 
 ##### type
@@ -37,12 +37,16 @@ addEventListener: (type, listener) => void;
 
 `void`
 
+***
+
 ### removeEventListener()
 
 ```ts
 removeEventListener: (type, listener) => void;
 ```
 
+Defined in: [packages/db/src/local-storage.ts:33](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L33)
+
 #### Parameters
 
 ##### type
diff --git a/docs/reference/type-aliases/Strategy.md b/docs/reference/type-aliases/Strategy.md
new file mode 100644
index 000000000..561cefb37
--- /dev/null
+++ b/docs/reference/type-aliases/Strategy.md
@@ -0,0 +1,18 @@
+---
+id: Strategy
+title: Strategy
+---
+
+# Type Alias: Strategy
+
+```ts
+type Strategy = 
+  | DebounceStrategy
+  | QueueStrategy
+  | ThrottleStrategy
+  | BatchStrategy;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:113](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L113)
+
+Union type of all available strategies
diff --git a/docs/reference/type-aliases/StrategyOptions.md b/docs/reference/type-aliases/StrategyOptions.md
new file mode 100644
index 000000000..e7dd3712d
--- /dev/null
+++ b/docs/reference/type-aliases/StrategyOptions.md
@@ -0,0 +1,20 @@
+---
+id: StrategyOptions
+title: StrategyOptions
+---
+
+# Type Alias: StrategyOptions\<T\>
+
+```ts
+type StrategyOptions<T> = T extends DebounceStrategy ? DebounceStrategyOptions : T extends QueueStrategy ? QueueStrategyOptions : T extends ThrottleStrategy ? ThrottleStrategyOptions : T extends BatchStrategy ? BatchStrategyOptions : never;
+```
+
+Defined in: [packages/db/src/strategies/types.ts:122](https://github.com/TanStack/db/blob/main/packages/db/src/strategies/types.ts#L122)
+
+Extract the options type from a strategy
+
+## Type Parameters
+
+### T
+
+`T` *extends* [`Strategy`](Strategy.md)
diff --git a/docs/reference/type-aliases/StringCollationConfig.md b/docs/reference/type-aliases/StringCollationConfig.md
new file mode 100644
index 000000000..7ac99e3ab
--- /dev/null
+++ b/docs/reference/type-aliases/StringCollationConfig.md
@@ -0,0 +1,28 @@
+---
+id: StringCollationConfig
+title: StringCollationConfig
+---
+
+# Type Alias: StringCollationConfig
+
+```ts
+type StringCollationConfig = 
+  | {
+  stringSort?: "lexical";
+}
+  | {
+  locale?: string;
+  localeOptions?: object;
+  stringSort?: "locale";
+};
+```
+
+Defined in: [packages/db/src/types.ts:30](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L30)
+
+StringSortOpts - Options for string sorting behavior
+
+This discriminated union allows for two types of string sorting:
+- **Lexical**: Simple character-by-character comparison (default)
+- **Locale**: Locale-aware sorting with optional customization
+
+The union ensures that locale options are only available when locale sorting is selected.
diff --git a/docs/reference/type-aliases/SubscriptionEvents.md b/docs/reference/type-aliases/SubscriptionEvents.md
new file mode 100644
index 000000000..5361b9956
--- /dev/null
+++ b/docs/reference/type-aliases/SubscriptionEvents.md
@@ -0,0 +1,54 @@
+---
+id: SubscriptionEvents
+title: SubscriptionEvents
+---
+
+# Type Alias: SubscriptionEvents
+
+```ts
+type SubscriptionEvents = object;
+```
+
+Defined in: [packages/db/src/types.ts:241](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L241)
+
+All subscription events
+
+## Properties
+
+### status:change
+
+```ts
+status:change: SubscriptionStatusChangeEvent;
+```
+
+Defined in: [packages/db/src/types.ts:242](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L242)
+
+***
+
+### status:loadingSubset
+
+```ts
+status:loadingSubset: SubscriptionStatusEvent<"loadingSubset">;
+```
+
+Defined in: [packages/db/src/types.ts:244](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L244)
+
+***
+
+### status:ready
+
+```ts
+status:ready: SubscriptionStatusEvent<"ready">;
+```
+
+Defined in: [packages/db/src/types.ts:243](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L243)
+
+***
+
+### unsubscribed
+
+```ts
+unsubscribed: SubscriptionUnsubscribedEvent;
+```
+
+Defined in: [packages/db/src/types.ts:245](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L245)
diff --git a/docs/reference/type-aliases/SubscriptionStatus.md b/docs/reference/type-aliases/SubscriptionStatus.md
new file mode 100644
index 000000000..3b35a5491
--- /dev/null
+++ b/docs/reference/type-aliases/SubscriptionStatus.md
@@ -0,0 +1,14 @@
+---
+id: SubscriptionStatus
+title: SubscriptionStatus
+---
+
+# Type Alias: SubscriptionStatus
+
+```ts
+type SubscriptionStatus = "ready" | "loadingSubset";
+```
+
+Defined in: [packages/db/src/types.ts:208](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L208)
+
+Subscription status values
diff --git a/docs/reference/type-aliases/SyncConfigRes.md b/docs/reference/type-aliases/SyncConfigRes.md
new file mode 100644
index 000000000..e719a0a1d
--- /dev/null
+++ b/docs/reference/type-aliases/SyncConfigRes.md
@@ -0,0 +1,42 @@
+---
+id: SyncConfigRes
+title: SyncConfigRes
+---
+
+# Type Alias: SyncConfigRes
+
+```ts
+type SyncConfigRes = object;
+```
+
+Defined in: [packages/db/src/types.ts:320](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L320)
+
+## Properties
+
+### cleanup?
+
+```ts
+optional cleanup: CleanupFn;
+```
+
+Defined in: [packages/db/src/types.ts:321](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L321)
+
+***
+
+### loadSubset?
+
+```ts
+optional loadSubset: LoadSubsetFn;
+```
+
+Defined in: [packages/db/src/types.ts:322](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L322)
+
+***
+
+### unloadSubset?
+
+```ts
+optional unloadSubset: UnloadSubsetFn;
+```
+
+Defined in: [packages/db/src/types.ts:323](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L323)
diff --git a/docs/reference/type-aliases/SyncMode.md b/docs/reference/type-aliases/SyncMode.md
new file mode 100644
index 000000000..920cf35c7
--- /dev/null
+++ b/docs/reference/type-aliases/SyncMode.md
@@ -0,0 +1,12 @@
+---
+id: SyncMode
+title: SyncMode
+---
+
+# Type Alias: SyncMode
+
+```ts
+type SyncMode = "eager" | "on-demand";
+```
+
+Defined in: [packages/db/src/types.ts:497](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L497)
diff --git a/docs/reference/type-aliases/TransactionState.md b/docs/reference/type-aliases/TransactionState.md
new file mode 100644
index 000000000..2558a48d3
--- /dev/null
+++ b/docs/reference/type-aliases/TransactionState.md
@@ -0,0 +1,12 @@
+---
+id: TransactionState
+title: TransactionState
+---
+
+# Type Alias: TransactionState
+
+```ts
+type TransactionState = "pending" | "persisting" | "completed" | "failed";
+```
+
+Defined in: [packages/db/src/types.ts:62](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L62)
diff --git a/docs/reference/type-aliases/TransactionWithMutations.md b/docs/reference/type-aliases/TransactionWithMutations.md
new file mode 100644
index 000000000..e6e1dc979
--- /dev/null
+++ b/docs/reference/type-aliases/TransactionWithMutations.md
@@ -0,0 +1,51 @@
+---
+id: TransactionWithMutations
+title: TransactionWithMutations
+---
+
+# Type Alias: TransactionWithMutations\<T, TOperation\>
+
+```ts
+type TransactionWithMutations<T, TOperation> = Omit<Transaction<T>, "mutations"> & object;
+```
+
+Defined in: [packages/db/src/types.ts:140](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L140)
+
+Utility type for a Transaction with at least one mutation
+This is used internally by the Transaction.commit method
+
+## Type Declaration
+
+### mutations
+
+```ts
+mutations: NonEmptyArray<PendingMutation<T, TOperation>>;
+```
+
+We must omit the `mutations` property from `Transaction<T>` before intersecting
+because TypeScript intersects property types when the same property appears on
+both sides of an intersection.
+
+Without `Omit`:
+- `Transaction<T>` has `mutations: Array<PendingMutation<T>>`
+- The intersection would create: `Array<PendingMutation<T>> & NonEmptyArray<PendingMutation<T, TOperation>>`
+- When mapping over this array, TypeScript widens `TOperation` from the specific literal
+  (e.g., `"delete"`) to the union `OperationType` (`"insert" | "update" | "delete"`)
+- This causes `PendingMutation<T, OperationType>` to evaluate the conditional type
+  `original: TOperation extends 'insert' ? {} : T` as `{} | T` instead of just `T`
+
+With `Omit`:
+- We remove `mutations` from `Transaction<T>` first
+- Then add back `mutations: NonEmptyArray<PendingMutation<T, TOperation>>`
+- TypeScript can properly narrow `TOperation` to the specific literal type
+- This ensures `mutation.original` is correctly typed as `T` (not `{} | T`) when mapping
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TOperation
+
+`TOperation` *extends* [`OperationType`](OperationType.md) = [`OperationType`](OperationType.md)
diff --git a/docs/reference/type-aliases/UnloadSubsetFn.md b/docs/reference/type-aliases/UnloadSubsetFn.md
new file mode 100644
index 000000000..de8d803bb
--- /dev/null
+++ b/docs/reference/type-aliases/UnloadSubsetFn.md
@@ -0,0 +1,22 @@
+---
+id: UnloadSubsetFn
+title: UnloadSubsetFn
+---
+
+# Type Alias: UnloadSubsetFn()
+
+```ts
+type UnloadSubsetFn = (options) => void;
+```
+
+Defined in: [packages/db/src/types.ts:316](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L316)
+
+## Parameters
+
+### options
+
+[`LoadSubsetOptions`](LoadSubsetOptions.md)
+
+## Returns
+
+`void`
diff --git a/docs/reference/type-aliases/UpdateMutationFn.md b/docs/reference/type-aliases/UpdateMutationFn.md
new file mode 100644
index 000000000..d32142d44
--- /dev/null
+++ b/docs/reference/type-aliases/UpdateMutationFn.md
@@ -0,0 +1,40 @@
+---
+id: UpdateMutationFn
+title: UpdateMutationFn
+---
+
+# Type Alias: UpdateMutationFn()\<T, TKey, TUtils, TReturn\>
+
+```ts
+type UpdateMutationFn<T, TKey, TUtils, TReturn> = (params) => Promise<TReturn>;
+```
+
+Defined in: [packages/db/src/types.ts:456](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L456)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](UtilsRecord.md) = [`UtilsRecord`](UtilsRecord.md)
+
+### TReturn
+
+`TReturn` = `any`
+
+## Parameters
+
+### params
+
+[`UpdateMutationFnParams`](UpdateMutationFnParams.md)\<`T`, `TKey`, `TUtils`\>
+
+## Returns
+
+`Promise`\<`TReturn`\>
diff --git a/docs/reference/type-aliases/UpdateMutationFnParams.md b/docs/reference/type-aliases/UpdateMutationFnParams.md
new file mode 100644
index 000000000..7180021f6
--- /dev/null
+++ b/docs/reference/type-aliases/UpdateMutationFnParams.md
@@ -0,0 +1,46 @@
+---
+id: UpdateMutationFnParams
+title: UpdateMutationFnParams
+---
+
+# Type Alias: UpdateMutationFnParams\<T, TKey, TUtils\>
+
+```ts
+type UpdateMutationFnParams<T, TKey, TUtils> = object;
+```
+
+Defined in: [packages/db/src/types.ts:423](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L423)
+
+## Type Parameters
+
+### T
+
+`T` *extends* `object` = `Record`\<`string`, `unknown`\>
+
+### TKey
+
+`TKey` *extends* `string` \| `number` = `string` \| `number`
+
+### TUtils
+
+`TUtils` *extends* [`UtilsRecord`](UtilsRecord.md) = [`UtilsRecord`](UtilsRecord.md)
+
+## Properties
+
+### collection
+
+```ts
+collection: Collection<T, TKey, TUtils>;
+```
+
+Defined in: [packages/db/src/types.ts:429](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L429)
+
+***
+
+### transaction
+
+```ts
+transaction: TransactionWithMutations<T, "update">;
+```
+
+Defined in: [packages/db/src/types.ts:428](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L428)
diff --git a/docs/reference/type-aliases/UtilsRecord.md b/docs/reference/type-aliases/UtilsRecord.md
new file mode 100644
index 000000000..2a0a44b13
--- /dev/null
+++ b/docs/reference/type-aliases/UtilsRecord.md
@@ -0,0 +1,14 @@
+---
+id: UtilsRecord
+title: UtilsRecord
+---
+
+# Type Alias: UtilsRecord
+
+```ts
+type UtilsRecord = Record<string, any>;
+```
+
+Defined in: [packages/db/src/types.ts:72](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L72)
+
+A record of utilities (functions or getters) that can be attached to a collection
diff --git a/docs/reference/type-aliases/WritableDeep.md b/docs/reference/type-aliases/WritableDeep.md
new file mode 100644
index 000000000..a7af3ccb7
--- /dev/null
+++ b/docs/reference/type-aliases/WritableDeep.md
@@ -0,0 +1,18 @@
+---
+id: WritableDeep
+title: WritableDeep
+---
+
+# Type Alias: WritableDeep\<T\>
+
+```ts
+type WritableDeep<T> = T extends BuiltIns ? T : T extends (...arguments_) => unknown ? object extends WritableObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : (...arguments_) => ReturnType<T> & WritableObjectDeep<T> : T extends ReadonlyMap<unknown, unknown> ? WritableMapDeep<T> : T extends ReadonlySet<unknown> ? WritableSetDeep<T> : T extends ReadonlyArray<unknown> ? WritableArrayDeep<T> : T extends object ? WritableObjectDeep<T> : unknown;
+```
+
+Defined in: [packages/db/src/types.ts:923](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L923)
+
+## Type Parameters
+
+### T
+
+`T`
diff --git a/docs/reference/type-aliases/changespayload.md b/docs/reference/type-aliases/changespayload.md
deleted file mode 100644
index 6e709fdf9..000000000
--- a/docs/reference/type-aliases/changespayload.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-id: ChangesPayload
-title: ChangesPayload
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: ChangesPayload\<T\>
-
-```ts
-type ChangesPayload<T> = ChangeMessage<T>[];
-```
-
-Defined in: [packages/db/src/types.ts:531](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L531)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
diff --git a/docs/reference/type-aliases/clearstoragefn.md b/docs/reference/type-aliases/clearstoragefn.md
deleted file mode 100644
index abeb412ee..000000000
--- a/docs/reference/type-aliases/clearstoragefn.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-id: ClearStorageFn
-title: ClearStorageFn
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: ClearStorageFn()
-
-```ts
-type ClearStorageFn = () => void;
-```
-
-Defined in: [packages/db/src/local-storage.ts:122](https://github.com/TanStack/db/blob/main/packages/db/src/local-storage.ts#L122)
-
-Type for the clear utility function
-
-## Returns
-
-`void`
diff --git a/docs/reference/type-aliases/deletemutationfn.md b/docs/reference/type-aliases/deletemutationfn.md
deleted file mode 100644
index 882ffd28b..000000000
--- a/docs/reference/type-aliases/deletemutationfn.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-id: DeleteMutationFn
-title: DeleteMutationFn
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: DeleteMutationFn()\<T, TKey, TUtils\>
-
-```ts
-type DeleteMutationFn<T, TKey, TUtils> = (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/types.ts:314](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L314)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-• **TUtils** *extends* [`UtilsRecord`](../utilsrecord.md) = `Record`\<`string`, [`Fn`](../fn.md)\>
-
-## Parameters
-
-### params
-
-[`DeleteMutationFnParams`](../deletemutationfnparams.md)\<`T`, `TKey`, `TUtils`\>
-
-## Returns
-
-`Promise`\<`any`\>
diff --git a/docs/reference/type-aliases/deletemutationfnparams.md b/docs/reference/type-aliases/deletemutationfnparams.md
deleted file mode 100644
index a540efac4..000000000
--- a/docs/reference/type-aliases/deletemutationfnparams.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-id: DeleteMutationFnParams
-title: DeleteMutationFnParams
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: DeleteMutationFnParams\<T, TKey, TUtils\>
-
-```ts
-type DeleteMutationFnParams<T, TKey, TUtils> = object;
-```
-
-Defined in: [packages/db/src/types.ts:293](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L293)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-• **TUtils** *extends* [`UtilsRecord`](../utilsrecord.md) = `Record`\<`string`, [`Fn`](../fn.md)\>
-
-## Type declaration
-
-### collection
-
-```ts
-collection: Collection<T, TKey, TUtils>;
-```
-
-### transaction
-
-```ts
-transaction: TransactionWithMutations<T, "delete">;
-```
diff --git a/docs/reference/type-aliases/getresult.md b/docs/reference/type-aliases/getresult.md
deleted file mode 100644
index c29ee9fcb..000000000
--- a/docs/reference/type-aliases/getresult.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-id: GetResult
-title: GetResult
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: GetResult\<TContext\>
-
-```ts
-type GetResult<TContext> = Prettify<TContext["result"] extends object ? TContext["result"] : TContext["hasJoins"] extends true ? TContext["schema"] : TContext["schema"][TContext["fromSourceName"]]>;
-```
-
-Defined in: [packages/db/src/query/builder/types.ts:208](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L208)
-
-## Type Parameters
-
-• **TContext** *extends* [`Context`](../../interfaces/context.md)
diff --git a/docs/reference/type-aliases/indexoperation.md b/docs/reference/type-aliases/indexoperation.md
deleted file mode 100644
index a9bc0dc8b..000000000
--- a/docs/reference/type-aliases/indexoperation.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-id: IndexOperation
-title: IndexOperation
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: IndexOperation
-
-```ts
-type IndexOperation = typeof comparisonFunctions[number];
-```
-
-Defined in: [packages/db/src/indexes/base-index.ts:8](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L8)
-
-Type for index operation values
diff --git a/docs/reference/type-aliases/inputrow.md b/docs/reference/type-aliases/inputrow.md
deleted file mode 100644
index 0777afe0c..000000000
--- a/docs/reference/type-aliases/inputrow.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-id: InputRow
-title: InputRow
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: InputRow
-
-```ts
-type InputRow = [unknown, Record<string, unknown>];
-```
-
-Defined in: [packages/db/src/types.ts:538](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L538)
-
-An input row from a collection
diff --git a/docs/reference/type-aliases/insertmutationfn.md b/docs/reference/type-aliases/insertmutationfn.md
deleted file mode 100644
index 10c8ba1e0..000000000
--- a/docs/reference/type-aliases/insertmutationfn.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-id: InsertMutationFn
-title: InsertMutationFn
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: InsertMutationFn()\<T, TKey, TUtils\>
-
-```ts
-type InsertMutationFn<T, TKey, TUtils> = (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/types.ts:302](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L302)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-• **TUtils** *extends* [`UtilsRecord`](../utilsrecord.md) = `Record`\<`string`, [`Fn`](../fn.md)\>
-
-## Parameters
-
-### params
-
-[`InsertMutationFnParams`](../insertmutationfnparams.md)\<`T`, `TKey`, `TUtils`\>
-
-## Returns
-
-`Promise`\<`any`\>
diff --git a/docs/reference/type-aliases/insertmutationfnparams.md b/docs/reference/type-aliases/insertmutationfnparams.md
deleted file mode 100644
index fd89db6bb..000000000
--- a/docs/reference/type-aliases/insertmutationfnparams.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-id: InsertMutationFnParams
-title: InsertMutationFnParams
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: InsertMutationFnParams\<T, TKey, TUtils\>
-
-```ts
-type InsertMutationFnParams<T, TKey, TUtils> = object;
-```
-
-Defined in: [packages/db/src/types.ts:285](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L285)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-• **TUtils** *extends* [`UtilsRecord`](../utilsrecord.md) = `Record`\<`string`, [`Fn`](../fn.md)\>
-
-## Type declaration
-
-### collection
-
-```ts
-collection: Collection<T, TKey, TUtils>;
-```
-
-### transaction
-
-```ts
-transaction: TransactionWithMutations<T, "insert">;
-```
diff --git a/docs/reference/type-aliases/mutationfn.md b/docs/reference/type-aliases/mutationfn.md
deleted file mode 100644
index 8a1c0d7ce..000000000
--- a/docs/reference/type-aliases/mutationfn.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-id: MutationFn
-title: MutationFn
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: MutationFn()\<T\>
-
-```ts
-type MutationFn<T> = (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/types.ts:141](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L141)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-## Parameters
-
-### params
-
-[`MutationFnParams`](../mutationfnparams.md)\<`T`\>
-
-## Returns
-
-`Promise`\<`any`\>
diff --git a/docs/reference/type-aliases/mutationfnparams.md b/docs/reference/type-aliases/mutationfnparams.md
deleted file mode 100644
index c4b7f9225..000000000
--- a/docs/reference/type-aliases/mutationfnparams.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-id: MutationFnParams
-title: MutationFnParams
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: MutationFnParams\<T\>
-
-```ts
-type MutationFnParams<T> = object;
-```
-
-Defined in: [packages/db/src/types.ts:137](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L137)
-
-Configuration options for creating a new transaction
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-## Type declaration
-
-### transaction
-
-```ts
-transaction: TransactionWithMutations<T>;
-```
diff --git a/docs/reference/type-aliases/operationtype.md b/docs/reference/type-aliases/operationtype.md
deleted file mode 100644
index 9985a5c5c..000000000
--- a/docs/reference/type-aliases/operationtype.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-id: OperationType
-title: OperationType
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: OperationType
-
-```ts
-type OperationType = "insert" | "update" | "delete";
-```
-
-Defined in: [packages/db/src/types.ts:198](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L198)
diff --git a/docs/reference/type-aliases/ref.md b/docs/reference/type-aliases/ref.md
deleted file mode 100644
index 3a6d2c3cd..000000000
--- a/docs/reference/type-aliases/ref.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-id: Ref
-title: Ref
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: Ref\<T\>
-
-```ts
-type Ref<T> = RefProxyFor<T>;
-```
-
-Defined in: [packages/db/src/query/builder/types.ts:144](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L144)
-
-## Type Parameters
-
-• **T**
diff --git a/docs/reference/type-aliases/resolveinsertinput.md b/docs/reference/type-aliases/resolveinsertinput.md
deleted file mode 100644
index c7683fb7d..000000000
--- a/docs/reference/type-aliases/resolveinsertinput.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-id: ResolveInsertInput
-title: ResolveInsertInput
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: ResolveInsertInput\<TExplicit, TSchema, TFallback\>
-
-```ts
-type ResolveInsertInput<TExplicit, TSchema, TFallback> = unknown extends TExplicit ? [TSchema] extends [never] ? TFallback : InferSchemaInput<TSchema> : TExplicit extends object ? TExplicit : Record<string, unknown>;
-```
-
-Defined in: [packages/db/src/types.ts:42](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L42)
-
-**`Internal`**
-
-Helper type to determine the insert input type
-This takes the raw generics (TExplicit, TSchema, TFallback) instead of the resolved T.
-
-Priority:
-1. Explicit generic TExplicit (if not 'unknown')
-2. Schema input type (if schema provided)
-3. Fallback type TFallback
-
- This is used for collection insert type inference
-
-## Type Parameters
-
-• **TExplicit** = `unknown`
-
-• **TSchema** *extends* `StandardSchemaV1` = `never`
-
-• **TFallback** *extends* `object` = `Record`\<`string`, `unknown`\>
diff --git a/docs/reference/type-aliases/resolvetype.md b/docs/reference/type-aliases/resolvetype.md
deleted file mode 100644
index 5334091ba..000000000
--- a/docs/reference/type-aliases/resolvetype.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-id: ResolveType
-title: ResolveType
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: ResolveType\<TExplicit, TSchema, TFallback\>
-
-```ts
-type ResolveType<TExplicit, TSchema, TFallback> = unknown extends TExplicit ? [TSchema] extends [never] ? TFallback : InferSchemaOutput<TSchema> : TExplicit extends object ? TExplicit : Record<string, unknown>;
-```
-
-Defined in: [packages/db/src/types.ts:64](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L64)
-
-Helper type to determine the final type based on priority:
-1. Explicit generic TExplicit (if not 'unknown')
-2. Schema output type (if schema provided)
-3. Fallback type TFallback
-
-## Type Parameters
-
-• **TExplicit**
-
-• **TSchema** *extends* `StandardSchemaV1` = `never`
-
-• **TFallback** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-## Remarks
-
-This type is used internally to resolve the collection item type based on the provided generics and schema.
-Users should not need to use this type directly, but understanding the priority order helps when defining collections.
diff --git a/docs/reference/type-aliases/row.md b/docs/reference/type-aliases/row.md
deleted file mode 100644
index 0497fb896..000000000
--- a/docs/reference/type-aliases/row.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-id: Row
-title: Row
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: Row\<TExtensions\>
-
-```ts
-type Row<TExtensions> = Record<string, Value<TExtensions>>;
-```
-
-Defined in: [packages/db/src/types.ts:196](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L196)
-
-## Type Parameters
-
-• **TExtensions** = `never`
diff --git a/docs/reference/type-aliases/source.md b/docs/reference/type-aliases/source.md
deleted file mode 100644
index b076af522..000000000
--- a/docs/reference/type-aliases/source.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-id: Source
-title: Source
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: Source
-
-```ts
-type Source = object;
-```
-
-Defined in: [packages/db/src/query/builder/types.ts:25](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/types.ts#L25)
-
-## Index Signature
-
-```ts
-[alias: string]: 
-  | CollectionImpl<any, any, {}, StandardSchemaV1<unknown, unknown>, any>
-| QueryBuilder<Context>
-```
diff --git a/docs/reference/type-aliases/transactionstate.md b/docs/reference/type-aliases/transactionstate.md
deleted file mode 100644
index 03b28395c..000000000
--- a/docs/reference/type-aliases/transactionstate.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-id: TransactionState
-title: TransactionState
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: TransactionState
-
-```ts
-type TransactionState = "pending" | "persisting" | "completed" | "failed";
-```
-
-Defined in: [packages/db/src/types.ts:76](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L76)
diff --git a/docs/reference/type-aliases/transactionwithmutations.md b/docs/reference/type-aliases/transactionwithmutations.md
deleted file mode 100644
index 0ab4c452c..000000000
--- a/docs/reference/type-aliases/transactionwithmutations.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-id: TransactionWithMutations
-title: TransactionWithMutations
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: TransactionWithMutations\<T, TOperation\>
-
-```ts
-type TransactionWithMutations<T, TOperation> = Transaction<T> & object;
-```
-
-Defined in: [packages/db/src/types.ts:154](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L154)
-
-Utility type for a Transaction with at least one mutation
-This is used internally by the Transaction.commit method
-
-## Type declaration
-
-### mutations
-
-```ts
-mutations: NonEmptyArray<PendingMutation<T, TOperation>>;
-```
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TOperation** *extends* [`OperationType`](../operationtype.md) = [`OperationType`](../operationtype.md)
diff --git a/docs/reference/type-aliases/updatemutationfn.md b/docs/reference/type-aliases/updatemutationfn.md
deleted file mode 100644
index 257e48776..000000000
--- a/docs/reference/type-aliases/updatemutationfn.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-id: UpdateMutationFn
-title: UpdateMutationFn
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: UpdateMutationFn()\<T, TKey, TUtils\>
-
-```ts
-type UpdateMutationFn<T, TKey, TUtils> = (params) => Promise<any>;
-```
-
-Defined in: [packages/db/src/types.ts:308](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L308)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-• **TUtils** *extends* [`UtilsRecord`](../utilsrecord.md) = `Record`\<`string`, [`Fn`](../fn.md)\>
-
-## Parameters
-
-### params
-
-[`UpdateMutationFnParams`](../updatemutationfnparams.md)\<`T`, `TKey`, `TUtils`\>
-
-## Returns
-
-`Promise`\<`any`\>
diff --git a/docs/reference/type-aliases/updatemutationfnparams.md b/docs/reference/type-aliases/updatemutationfnparams.md
deleted file mode 100644
index 0cc4d6b46..000000000
--- a/docs/reference/type-aliases/updatemutationfnparams.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-id: UpdateMutationFnParams
-title: UpdateMutationFnParams
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: UpdateMutationFnParams\<T, TKey, TUtils\>
-
-```ts
-type UpdateMutationFnParams<T, TKey, TUtils> = object;
-```
-
-Defined in: [packages/db/src/types.ts:276](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L276)
-
-## Type Parameters
-
-• **T** *extends* `object` = `Record`\<`string`, `unknown`\>
-
-• **TKey** *extends* `string` \| `number` = `string` \| `number`
-
-• **TUtils** *extends* [`UtilsRecord`](../utilsrecord.md) = `Record`\<`string`, [`Fn`](../fn.md)\>
-
-## Type declaration
-
-### collection
-
-```ts
-collection: Collection<T, TKey, TUtils>;
-```
-
-### transaction
-
-```ts
-transaction: TransactionWithMutations<T, "update">;
-```
diff --git a/docs/reference/type-aliases/utilsrecord.md b/docs/reference/type-aliases/utilsrecord.md
deleted file mode 100644
index d064dc753..000000000
--- a/docs/reference/type-aliases/utilsrecord.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-id: UtilsRecord
-title: UtilsRecord
----
-
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
-# Type Alias: UtilsRecord
-
-```ts
-type UtilsRecord = Record<string, Fn>;
-```
-
-Defined in: [packages/db/src/types.ts:86](https://github.com/TanStack/db/blob/main/packages/db/src/types.ts#L86)
-
-A record of utility functions that can be attached to a collection
diff --git a/docs/reference/variables/indexoperation.md b/docs/reference/variables/IndexOperation.md
similarity index 57%
rename from docs/reference/variables/indexoperation.md
rename to docs/reference/variables/IndexOperation.md
index 4a9948cfb..e0ec16ffa 100644
--- a/docs/reference/variables/indexoperation.md
+++ b/docs/reference/variables/IndexOperation.md
@@ -3,14 +3,12 @@ id: IndexOperation
 title: IndexOperation
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Variable: IndexOperation
 
 ```ts
 const IndexOperation: readonly ["eq", "gt", "gte", "lt", "lte", "in", "like", "ilike"] = comparisonFunctions;
 ```
 
-Defined in: [packages/db/src/indexes/base-index.ts:8](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L8)
+Defined in: [packages/db/src/indexes/base-index.ts:11](https://github.com/TanStack/db/blob/main/packages/db/src/indexes/base-index.ts#L11)
 
 Operations that indexes can support, imported from available comparison functions
diff --git a/docs/reference/variables/query.md b/docs/reference/variables/Query.md
similarity index 55%
rename from docs/reference/variables/query.md
rename to docs/reference/variables/Query.md
index 7979e1e49..d53fdfc52 100644
--- a/docs/reference/variables/query.md
+++ b/docs/reference/variables/Query.md
@@ -3,12 +3,10 @@ id: Query
 title: Query
 ---
 
-<!-- DO NOT EDIT: this page is autogenerated from the type comments -->
-
 # Variable: Query
 
 ```ts
 const Query: InitialQueryBuilderConstructor = BaseQueryBuilder;
 ```
 
-Defined in: [packages/db/src/query/builder/index.ts:767](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L767)
+Defined in: [packages/db/src/query/builder/index.ts:897](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/index.ts#L897)
diff --git a/docs/reference/variables/operators.md b/docs/reference/variables/operators.md
new file mode 100644
index 000000000..1d6471cc9
--- /dev/null
+++ b/docs/reference/variables/operators.md
@@ -0,0 +1,14 @@
+---
+id: operators
+title: operators
+---
+
+# Variable: operators
+
+```ts
+const operators: readonly ["eq", "gt", "gte", "lt", "lte", "in", "like", "ilike", "and", "or", "not", "isNull", "isUndefined", "upper", "lower", "length", "concat", "add", "coalesce", "count", "avg", "sum", "min", "max"];
+```
+
+Defined in: [packages/db/src/query/builder/functions.ts:344](https://github.com/TanStack/db/blob/main/packages/db/src/query/builder/functions.ts#L344)
+
+All supported operator names in TanStack DB expressions
diff --git a/eslint.config.js b/eslint.config.js
index 1f40676a4..5c4455420 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -1,7 +1,4 @@
-import prettierPlugin from "eslint-plugin-prettier"
-import prettierConfig from "eslint-config-prettier"
-import stylisticPlugin from "@stylistic/eslint-plugin"
-import { tanstackConfig } from "@tanstack/config/eslint"
+import { tanstackConfig } from '@tanstack/eslint-config'
 
 export default [
   ...tanstackConfig,
@@ -15,31 +12,24 @@ export default [
     ],
   },
   {
-    plugins: {
-      stylistic: stylisticPlugin,
-      prettier: prettierPlugin,
-    },
     settings: {
       // import-x/* settings required for import/no-cycle.
-      "import-x/resolver": { typescript: true },
-      "import-x/extensions": [".ts", ".tsx", ".js", ".jsx", ".cjs", ".mjs"],
+      'import-x/resolver': { typescript: true },
+      'import-x/extensions': ['.ts', '.tsx', '.js', '.jsx', '.cjs', '.mjs'],
     },
     rules: {
-      "prettier/prettier": `error`,
-      "stylistic/quotes": [`error`, `backtick`],
-      "pnpm/enforce-catalog": `off`,
-      "pnpm/json-enforce-catalog": `off`,
-      ...prettierConfig.rules,
+      'pnpm/enforce-catalog': `off`,
+      'pnpm/json-enforce-catalog': `off`,
     },
   },
   {
     files: [`**/*.ts`, `**/*.tsx`],
     rules: {
-      "@typescript-eslint/no-unused-vars": [
+      '@typescript-eslint/no-unused-vars': [
         `error`,
         { argsIgnorePattern: `^_`, varsIgnorePattern: `^_` },
       ],
-      "@typescript-eslint/naming-convention": [
+      '@typescript-eslint/naming-convention': [
         `error`,
         {
           selector: `typeParameter`,
@@ -47,7 +37,7 @@ export default [
           leadingUnderscore: `allow`,
         },
       ],
-      "import/no-cycle": `error`,
+      'import/no-cycle': `error`,
     },
   },
 ]
diff --git a/examples/angular/todos/.postcssrc.json b/examples/angular/todos/.postcssrc.json
index 380d67686..e092dc7c1 100644
--- a/examples/angular/todos/.postcssrc.json
+++ b/examples/angular/todos/.postcssrc.json
@@ -1,6 +1,5 @@
 {
   "plugins": {
-    "tailwindcss": {},
-    "autoprefixer": {}
+    "@tailwindcss/postcss": {}
   }
 }
diff --git a/examples/angular/todos/CHANGELOG.md b/examples/angular/todos/CHANGELOG.md
index d8c163b81..0fca3a428 100644
--- a/examples/angular/todos/CHANGELOG.md
+++ b/examples/angular/todos/CHANGELOG.md
@@ -1,5 +1,45 @@
 # todos
 
+## 0.0.17
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+  - @tanstack/angular-db@0.1.21
+
+## 0.0.16
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+  - @tanstack/angular-db@0.1.20
+
+## 0.0.15
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+  - @tanstack/angular-db@0.1.19
+
+## 0.0.14
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+  - @tanstack/angular-db@0.1.18
+
+## 0.0.13
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+  - @tanstack/angular-db@0.1.17
+
 ## 0.0.12
 
 ### Patch Changes
diff --git a/examples/angular/todos/package.json b/examples/angular/todos/package.json
index a5ae2e80e..9305eda48 100644
--- a/examples/angular/todos/package.json
+++ b/examples/angular/todos/package.json
@@ -1,6 +1,6 @@
 {
   "name": "todos",
-  "version": "0.0.12",
+  "version": "0.0.17",
   "scripts": {
     "ng": "ng",
     "start": "ng serve",
@@ -22,32 +22,32 @@
   },
   "private": true,
   "dependencies": {
-    "@angular/common": "^20.3.6",
-    "@angular/compiler": "^20.3.6",
-    "@angular/core": "^20.3.6",
-    "@angular/forms": "^20.3.6",
-    "@angular/platform-browser": "^20.3.6",
-    "@angular/router": "^20.3.6",
-    "@tanstack/angular-db": "workspace:*",
-    "@tanstack/db": "workspace:*",
-    "rxjs": "~7.8.2",
+    "@angular/common": "^19.2.17",
+    "@angular/compiler": "^20.3.15",
+    "@angular/core": "^19.2.17",
+    "@angular/forms": "^20.3.15",
+    "@angular/platform-browser": "^19.2.17",
+    "@angular/router": "^20.3.15",
+    "@tanstack/angular-db": "^0.1.50",
+    "@tanstack/db": "^0.5.24",
+    "rxjs": "^7.8.2",
     "tslib": "^2.8.1",
-    "zone.js": "~0.15.1"
+    "zone.js": "^0.16.0"
   },
   "devDependencies": {
-    "@angular/build": "^20.3.6",
-    "@angular/cli": "^20.3.6",
-    "@angular/compiler-cli": "^20.3.6",
-    "@types/jasmine": "~5.1.12",
-    "autoprefixer": "^10.4.21",
-    "jasmine-core": "~5.12.0",
+    "@angular/build": "^20.3.13",
+    "@angular/cli": "^20.3.13",
+    "@angular/compiler-cli": "^20.3.15",
+    "@tailwindcss/postcss": "^4.1.18",
+    "@types/jasmine": "~5.1.13",
+    "jasmine-core": "~5.13.0",
     "karma": "~6.4.4",
     "karma-chrome-launcher": "~3.2.0",
     "karma-coverage": "~2.2.1",
     "karma-jasmine": "~5.1.0",
     "karma-jasmine-html-reporter": "~2.1.0",
     "postcss": "^8.5.6",
-    "tailwindcss": "^3.4.18",
-    "typescript": "~5.8.2"
+    "tailwindcss": "^4.1.18",
+    "typescript": "^5.9.2"
   }
 }
diff --git a/examples/angular/todos/src/app/app.config.ts b/examples/angular/todos/src/app/app.config.ts
index 414eeaeb8..a690ebc33 100644
--- a/examples/angular/todos/src/app/app.config.ts
+++ b/examples/angular/todos/src/app/app.config.ts
@@ -2,10 +2,10 @@ import {
   ApplicationConfig,
   provideBrowserGlobalErrorListeners,
   provideZoneChangeDetection,
-} from '@angular/core';
-import { provideRouter } from '@angular/router';
+} from '@angular/core'
+import { provideRouter } from '@angular/router'
 
-import { routes } from './app.routes';
+import { routes } from './app.routes'
 
 export const appConfig: ApplicationConfig = {
   providers: [
@@ -13,4 +13,4 @@ export const appConfig: ApplicationConfig = {
     provideZoneChangeDetection({ eventCoalescing: true }),
     provideRouter(routes),
   ],
-};
+}
diff --git a/examples/angular/todos/src/app/app.routes.ts b/examples/angular/todos/src/app/app.routes.ts
index c4dcbaef3..5281a3272 100644
--- a/examples/angular/todos/src/app/app.routes.ts
+++ b/examples/angular/todos/src/app/app.routes.ts
@@ -1,5 +1,5 @@
-import { Routes } from '@angular/router';
+import { Routes } from '@angular/router'
 
 export const routes: Routes = [
   // Add your routes here
-];
+]
diff --git a/examples/angular/todos/src/app/app.ts b/examples/angular/todos/src/app/app.ts
index 55c59b7f2..46b1609d0 100644
--- a/examples/angular/todos/src/app/app.ts
+++ b/examples/angular/todos/src/app/app.ts
@@ -1,9 +1,9 @@
-import { Component, signal } from '@angular/core';
-import { injectLiveQuery } from '@tanstack/angular-db';
-import { eq } from '@tanstack/db';
-import { todosCollection } from '../collections/todos-collection';
-import { FormsModule } from '@angular/forms';
-import { CommonModule } from '@angular/common';
+import { Component, signal } from '@angular/core'
+import { injectLiveQuery } from '@tanstack/angular-db'
+import { eq } from '@tanstack/db'
+import { todosCollection } from '../collections/todos-collection'
+import { FormsModule } from '@angular/forms'
+import { CommonModule } from '@angular/common'
 
 @Component({
   selector: 'app-root',
@@ -140,20 +140,20 @@ export class App {
   projects = [
     { id: 1, name: 'Work' },
     { id: 2, name: 'Home' },
-  ];
+  ]
 
-  selectedProjectId = signal(2);
+  selectedProjectId = signal(2)
 
   todoQuery = injectLiveQuery({
     params: () => ({ projectID: this.selectedProjectId() }),
     query: ({ params, q }) =>
       q.from({ todo: todosCollection }).where(({ todo }) => eq(todo.projectID, params.projectID)),
-  });
+  })
 
-  newTodoText = '';
+  newTodoText = ''
 
   addTodo() {
-    if (!this.newTodoText.trim()) return;
+    if (!this.newTodoText.trim()) return
 
     const newTodo = {
       id: Date.now(),
@@ -161,23 +161,23 @@ export class App {
       projectID: this.selectedProjectId(),
       completed: false,
       created_at: new Date(),
-    };
+    }
 
-    todosCollection.insert(newTodo);
-    this.newTodoText = '';
+    todosCollection.insert(newTodo)
+    this.newTodoText = ''
   }
 
   toggleTodo(id: number) {
     todosCollection.update(id, (draft: any) => {
-      draft.completed = !draft.completed;
-    });
+      draft.completed = !draft.completed
+    })
   }
 
   deleteTodo(id: number) {
-    todosCollection.delete(id);
+    todosCollection.delete(id)
   }
 
   getCompletedCount(): number {
-    return this.todoQuery.data().filter((todo) => todo.completed).length;
+    return this.todoQuery.data().filter((todo) => todo.completed).length
   }
 }
diff --git a/examples/angular/todos/src/collections/todos-collection.ts b/examples/angular/todos/src/collections/todos-collection.ts
index 1aa97d796..70e2fbb89 100644
--- a/examples/angular/todos/src/collections/todos-collection.ts
+++ b/examples/angular/todos/src/collections/todos-collection.ts
@@ -1,11 +1,11 @@
-import { createCollection, localOnlyCollectionOptions } from '@tanstack/db';
+import { createCollection, localOnlyCollectionOptions } from '@tanstack/db'
 
 interface Todo {
-  id: number;
-  text: string;
-  projectID: number;
-  completed: boolean;
-  created_at: Date;
+  id: number
+  text: string
+  projectID: number
+  completed: boolean
+  created_at: Date
 }
 
 export const todosCollection = createCollection(
@@ -42,4 +42,4 @@ export const todosCollection = createCollection(
       },
     ],
   }),
-);
+)
diff --git a/examples/angular/todos/src/main.ts b/examples/angular/todos/src/main.ts
index 190f3418d..8192dca69 100644
--- a/examples/angular/todos/src/main.ts
+++ b/examples/angular/todos/src/main.ts
@@ -1,5 +1,5 @@
-import { bootstrapApplication } from '@angular/platform-browser';
-import { appConfig } from './app/app.config';
-import { App } from './app/app';
+import { bootstrapApplication } from '@angular/platform-browser'
+import { appConfig } from './app/app.config'
+import { App } from './app/app'
 
-bootstrapApplication(App, appConfig).catch((err) => console.error(err));
+bootstrapApplication(App, appConfig).catch((err) => console.error(err))
diff --git a/examples/angular/todos/src/styles.css b/examples/angular/todos/src/styles.css
index b5c61c956..d4b507858 100644
--- a/examples/angular/todos/src/styles.css
+++ b/examples/angular/todos/src/styles.css
@@ -1,3 +1 @@
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
+@import 'tailwindcss';
diff --git a/examples/angular/todos/tailwind.config.js b/examples/angular/todos/tailwind.config.js
deleted file mode 100644
index 0cc494f78..000000000
--- a/examples/angular/todos/tailwind.config.js
+++ /dev/null
@@ -1,8 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-module.exports = {
-  content: ['./src/**/*.{html,ts}'],
-  theme: {
-    extend: {},
-  },
-  plugins: [],
-};
diff --git a/examples/react-native/offline-transactions/CHANGELOG.md b/examples/react-native/offline-transactions/CHANGELOG.md
new file mode 100644
index 000000000..7dec32109
--- /dev/null
+++ b/examples/react-native/offline-transactions/CHANGELOG.md
@@ -0,0 +1,10 @@
+# offline-transactions-react-native
+
+## 1.0.1
+
+### Patch Changes
+
+- Updated dependencies [[`b479c1d`](https://github.com/TanStack/db/commit/b479c1dadc53bbfe11fd0123d58ff0df1dde2f93), [`98e584d`](https://github.com/TanStack/db/commit/98e584d4cc1b22a967d7fe220a17719fcfb23f72), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`d5254d1`](https://github.com/TanStack/db/commit/d5254d1e3c3acf7afe0ab7957ec8efffce36cbeb)]:
+  - @tanstack/offline-transactions@1.0.11
+  - @tanstack/query-db-collection@1.0.18
+  - @tanstack/react-db@0.1.65
diff --git a/examples/react-native/offline-transactions/README.md b/examples/react-native/offline-transactions/README.md
new file mode 100644
index 000000000..addcf4dcf
--- /dev/null
+++ b/examples/react-native/offline-transactions/README.md
@@ -0,0 +1,88 @@
+# Offline Transactions - React Native Demo
+
+This example demonstrates offline-first transactions using TanStack DB on React Native / Expo.
+
+<video width="400" controls>
+  <source src="https://github.com/user-attachments/assets/c73450c6-27e1-49a7-9174-413177f5e37e" type="video/mp4">
+  Your browser does not support the video tag.
+</video>
+
+## Features
+
+- Offline transaction queuing with AsyncStorage
+- Automatic sync when coming back online
+- Network status detection using `@react-native-community/netinfo`
+- App state detection (foreground/background)
+
+## Prerequisites
+
+- Node.js 18+
+- pnpm
+- Xcode (for iOS simulator) or Android Studio (for Android emulator)
+- Expo Go app on a physical device (optional)
+
+## Setup
+
+From the monorepo root:
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build the packages
+pnpm build
+```
+
+## Running the App
+
+```bash
+# Navigate to this example
+cd examples/react-native/offline-transactions
+
+# Install dependencies (if not already done)
+pnpm install
+
+# Start the backend server (in one terminal)
+npx tsx server/index.ts
+
+# Start the Expo dev server (in another terminal)
+pnpm start
+
+# Or run directly on iOS simulator
+pnpm ios
+
+# Or run directly on Android emulator
+pnpm android
+```
+
+The backend server runs on port 3001 and is shared by all emulators/devices. This allows you to test real syncing between multiple devices.
+
+## Testing Sync Between Devices
+
+1. **Start the server** with `pnpm server`
+2. **Run the app on two emulators** (e.g., iOS + Android, or two Android emulators)
+3. **Add a todo on one device** - It syncs to the server
+4. **Pull to refresh on the other device** - You'll see the new todo
+
+## Testing Offline Mode
+
+1. **Add todos while online** - They sync immediately to the backend server
+2. **Enable airplane mode** on your device/simulator
+3. **Add more todos** - They're queued locally in AsyncStorage
+4. **Disable airplane mode** - Queued transactions sync automatically
+
+## Architecture
+
+- **AsyncStorageAdapter**: Implements `StorageAdapter` for React Native using `@react-native-async-storage/async-storage`
+- **ReactNativeOnlineDetector**: Uses `NetInfo` and `AppState` to detect connectivity changes (imported from `@tanstack/offline-transactions/react-native`)
+- **todoCollection**: TanStack DB collection with live queries
+- **Offline actions**: Create, toggle, delete todos with optimistic updates
+
+## Key Differences from Web
+
+| Web                                          | React Native                                              |
+| -------------------------------------------- | --------------------------------------------------------- |
+| IndexedDB / localStorage                     | AsyncStorage                                              |
+| `window.addEventListener('online')`          | NetInfo.addEventListener                                  |
+| `document.visibilitychange`                  | AppState.addEventListener                                 |
+| Import from `@tanstack/offline-transactions` | Import from `@tanstack/offline-transactions/react-native` |
diff --git a/examples/react-native/offline-transactions/android/.gitignore b/examples/react-native/offline-transactions/android/.gitignore
new file mode 100644
index 000000000..8a6be0771
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/.gitignore
@@ -0,0 +1,16 @@
+# OSX
+#
+.DS_Store
+
+# Android/IntelliJ
+#
+build/
+.idea
+.gradle
+local.properties
+*.iml
+*.hprof
+.cxx/
+
+# Bundle artifacts
+*.jsbundle
diff --git a/examples/react-native/offline-transactions/android/app/build.gradle b/examples/react-native/offline-transactions/android/app/build.gradle
new file mode 100644
index 000000000..860628dd9
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/build.gradle
@@ -0,0 +1,177 @@
+apply plugin: "com.android.application"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "com.facebook.react"
+
+def projectRoot = rootDir.getAbsoluteFile().getParentFile().getAbsolutePath()
+
+/**
+ * This is the configuration block to customize your React Native Android app.
+ * By default you don't need to apply any configuration, just uncomment the lines you need.
+ */
+react {
+    entryFile = file(["node", "-e", "require('expo/scripts/resolveAppEntry')", projectRoot, "android", "absolute"].execute(null, rootDir).text.trim())
+    reactNativeDir = new File(["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim()).getParentFile().getAbsoluteFile()
+    hermesCommand = new File(["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim()).getParentFile().getAbsolutePath() + "/sdks/hermesc/%OS-BIN%/hermesc"
+    codegenDir = new File(["node", "--print", "require.resolve('@react-native/codegen/package.json', { paths: [require.resolve('react-native/package.json')] })"].execute(null, rootDir).text.trim()).getParentFile().getAbsoluteFile()
+
+    enableBundleCompression = (findProperty('android.enableBundleCompression') ?: false).toBoolean()
+    // Use Expo CLI to bundle the app, this ensures the Metro config
+    // works correctly with Expo projects.
+    cliFile = new File(["node", "--print", "require.resolve('@expo/cli', { paths: [require.resolve('expo/package.json')] })"].execute(null, rootDir).text.trim())
+    bundleCommand = "export:embed"
+
+    /* Folders */
+     //   The root of your project, i.e. where "package.json" lives. Default is '../..'
+    // root = file("../../")
+    //   The folder where the react-native NPM package is. Default is ../../node_modules/react-native
+    // reactNativeDir = file("../../node_modules/react-native")
+    //   The folder where the react-native Codegen package is. Default is ../../node_modules/@react-native/codegen
+    // codegenDir = file("../../node_modules/@react-native/codegen")
+
+    /* Variants */
+    //   The list of variants to that are debuggable. For those we're going to
+    //   skip the bundling of the JS bundle and the assets. By default is just 'debug'.
+    //   If you add flavors like lite, prod, etc. you'll have to list your debuggableVariants.
+    // debuggableVariants = ["liteDebug", "prodDebug"]
+
+    /* Bundling */
+    //   A list containing the node command and its flags. Default is just 'node'.
+    // nodeExecutableAndArgs = ["node"]
+
+    //
+    //   The path to the CLI configuration file. Default is empty.
+    // bundleConfig = file(../rn-cli.config.js)
+    //
+    //   The name of the generated asset file containing your JS bundle
+    // bundleAssetName = "MyApplication.android.bundle"
+    //
+    //   The entry file for bundle generation. Default is 'index.android.js' or 'index.js'
+    // entryFile = file("../js/MyApplication.android.js")
+    //
+    //   A list of extra flags to pass to the 'bundle' commands.
+    //   See https://github.com/react-native-community/cli/blob/main/docs/commands.md#bundle
+    // extraPackagerArgs = []
+
+    /* Hermes Commands */
+    //   The hermes compiler command to run. By default it is 'hermesc'
+    // hermesCommand = "$rootDir/my-custom-hermesc/bin/hermesc"
+    //
+    //   The list of flags to pass to the Hermes compiler. By default is "-O", "-output-source-map"
+    // hermesFlags = ["-O", "-output-source-map"]
+
+    /* Autolinking */
+    autolinkLibrariesWithApp()
+}
+
+/**
+ * Set this to true to Run Proguard on Release builds to minify the Java bytecode.
+ */
+def enableProguardInReleaseBuilds = (findProperty('android.enableProguardInReleaseBuilds') ?: false).toBoolean()
+
+/**
+ * The preferred build flavor of JavaScriptCore (JSC)
+ *
+ * For example, to use the international variant, you can use:
+ * `def jscFlavor = 'org.webkit:android-jsc-intl:+'`
+ *
+ * The international variant includes ICU i18n library and necessary data
+ * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that
+ * give correct results when using with locales other than en-US. Note that
+ * this variant is about 6MiB larger per architecture than default.
+ */
+def jscFlavor = 'io.github.react-native-community:jsc-android:2026004.+'
+
+android {
+    ndkVersion rootProject.ext.ndkVersion
+
+    buildToolsVersion rootProject.ext.buildToolsVersion
+    compileSdk rootProject.ext.compileSdkVersion
+
+    namespace "com.offlinetransactionsdemo"
+    defaultConfig {
+        applicationId "com.offlinetransactionsdemo"
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode 1
+        versionName "1.0"
+    }
+    signingConfigs {
+        debug {
+            storeFile file('debug.keystore')
+            storePassword 'android'
+            keyAlias 'androiddebugkey'
+            keyPassword 'android'
+        }
+    }
+    buildTypes {
+        debug {
+            signingConfig signingConfigs.debug
+        }
+        release {
+            // Caution! In production, you need to generate your own keystore file.
+            // see https://reactnative.dev/docs/signed-apk-android.
+            signingConfig signingConfigs.debug
+            shrinkResources (findProperty('android.enableShrinkResourcesInReleaseBuilds')?.toBoolean() ?: false)
+            minifyEnabled enableProguardInReleaseBuilds
+            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+            crunchPngs (findProperty('android.enablePngCrunchInReleaseBuilds')?.toBoolean() ?: true)
+        }
+    }
+    packagingOptions {
+        jniLibs {
+            useLegacyPackaging (findProperty('expo.useLegacyPackaging')?.toBoolean() ?: false)
+        }
+    }
+    androidResources {
+        ignoreAssetsPattern '!.svn:!.git:!.ds_store:!*.scc:!CVS:!thumbs.db:!picasa.ini:!*~'
+    }
+}
+
+// Apply static values from `gradle.properties` to the `android.packagingOptions`
+// Accepts values in comma delimited lists, example:
+// android.packagingOptions.pickFirsts=/LICENSE,**/picasa.ini
+["pickFirsts", "excludes", "merges", "doNotStrip"].each { prop ->
+    // Split option: 'foo,bar' -> ['foo', 'bar']
+    def options = (findProperty("android.packagingOptions.$prop") ?: "").split(",");
+    // Trim all elements in place.
+    for (i in 0..<options.size()) options[i] = options[i].trim();
+    // `[] - ""` is essentially `[""].filter(Boolean)` removing all empty strings.
+    options -= ""
+
+    if (options.length > 0) {
+        println "android.packagingOptions.$prop += $options ($options.length)"
+        // Ex: android.packagingOptions.pickFirsts += '**/SCCS/**'
+        options.each {
+            android.packagingOptions[prop] += it
+        }
+    }
+}
+
+dependencies {
+    // The version of react-native is set by the React Native Gradle Plugin
+    implementation("com.facebook.react:react-android")
+
+    def isGifEnabled = (findProperty('expo.gif.enabled') ?: "") == "true";
+    def isWebpEnabled = (findProperty('expo.webp.enabled') ?: "") == "true";
+    def isWebpAnimatedEnabled = (findProperty('expo.webp.animated') ?: "") == "true";
+
+    if (isGifEnabled) {
+        // For animated gif support
+        implementation("com.facebook.fresco:animated-gif:${expoLibs.versions.fresco.get()}")
+    }
+
+    if (isWebpEnabled) {
+        // For webp support
+        implementation("com.facebook.fresco:webpsupport:${expoLibs.versions.fresco.get()}")
+        if (isWebpAnimatedEnabled) {
+            // Animated webp support
+            implementation("com.facebook.fresco:animated-webp:${expoLibs.versions.fresco.get()}")
+        }
+    }
+
+    if (hermesEnabled.toBoolean()) {
+        implementation("com.facebook.react:hermes-android")
+    } else {
+        implementation jscFlavor
+    }
+}
diff --git a/examples/react-native/offline-transactions/android/app/debug.keystore b/examples/react-native/offline-transactions/android/app/debug.keystore
new file mode 100644
index 000000000..364e105ed
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/debug.keystore differ
diff --git a/examples/react-native/offline-transactions/android/app/proguard-rules.pro b/examples/react-native/offline-transactions/android/app/proguard-rules.pro
new file mode 100644
index 000000000..551eb41da
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/proguard-rules.pro
@@ -0,0 +1,14 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# react-native-reanimated
+-keep class com.swmansion.reanimated.** { *; }
+-keep class com.facebook.react.turbomodule.** { *; }
+
+# Add any project specific keep options here:
diff --git a/examples/react-native/offline-transactions/android/app/src/debug/AndroidManifest.xml b/examples/react-native/offline-transactions/android/app/src/debug/AndroidManifest.xml
new file mode 100644
index 000000000..3ec2507ba
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/src/debug/AndroidManifest.xml
@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
+
+    <application android:usesCleartextTraffic="true" tools:targetApi="28" tools:ignore="GoogleAppIndexingWarning" tools:replace="android:usesCleartextTraffic" />
+</manifest>
diff --git a/examples/react-native/offline-transactions/android/app/src/main/AndroidManifest.xml b/examples/react-native/offline-transactions/android/app/src/main/AndroidManifest.xml
new file mode 100644
index 000000000..150248b6b
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/src/main/AndroidManifest.xml
@@ -0,0 +1,29 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <uses-permission android:name="android.permission.INTERNET"/>
+  <!-- OPTIONAL PERMISSIONS, REMOVE WHATEVER YOU DO NOT NEED -->
+  <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
+  <uses-permission android:name="android.permission.VIBRATE"/>
+  <!-- These require runtime permissions on M -->
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+  <!-- END OPTIONAL PERMISSIONS -->
+
+  <queries>
+    <!-- Support checking for http(s) links via the Linking API -->
+    <intent>
+      <action android:name="android.intent.action.VIEW" />
+      <category android:name="android.intent.category.BROWSABLE" />
+      <data android:scheme="https" />
+    </intent>
+  </queries>
+
+  <application android:name=".MainApplication" android:label="@string/app_name" android:icon="@mipmap/ic_launcher" android:roundIcon="@mipmap/ic_launcher_round" android:allowBackup="false" android:theme="@style/AppTheme" android:supportsRtl="true">
+    <activity android:name=".MainActivity" android:configChanges="keyboard|keyboardHidden|orientation|screenSize|screenLayout|uiMode" android:launchMode="singleTask" android:windowSoftInputMode="adjustResize" android:theme="@style/Theme.App.SplashScreen" android:exported="true">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN"/>
+        <category android:name="android.intent.category.LAUNCHER"/>
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>
diff --git a/examples/react-native/offline-transactions/android/app/src/main/java/com/tanstack/offlinetransactions/MainActivity.kt b/examples/react-native/offline-transactions/android/app/src/main/java/com/tanstack/offlinetransactions/MainActivity.kt
new file mode 100644
index 000000000..9e8421cec
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/src/main/java/com/tanstack/offlinetransactions/MainActivity.kt
@@ -0,0 +1,61 @@
+package com.tanstack.offlinetransactions
+
+import android.os.Build
+import android.os.Bundle
+
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+
+import expo.modules.ReactActivityDelegateWrapper
+
+class MainActivity : ReactActivity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    // Set the theme to AppTheme BEFORE onCreate to support
+    // coloring the background, status bar, and navigation bar.
+    // This is required for expo-splash-screen.
+    setTheme(R.style.AppTheme);
+    super.onCreate(null)
+  }
+
+  /**
+   * Returns the name of the main component registered from JavaScript. This is used to schedule
+   * rendering of the component.
+   */
+  override fun getMainComponentName(): String = "main"
+
+  /**
+   * Returns the instance of the [ReactActivityDelegate]. We use [DefaultReactActivityDelegate]
+   * which allows you to enable New Architecture with a single boolean flags [fabricEnabled]
+   */
+  override fun createReactActivityDelegate(): ReactActivityDelegate {
+    return ReactActivityDelegateWrapper(
+          this,
+          BuildConfig.IS_NEW_ARCHITECTURE_ENABLED,
+          object : DefaultReactActivityDelegate(
+              this,
+              mainComponentName,
+              fabricEnabled
+          ){})
+  }
+
+  /**
+    * Align the back button behavior with Android S
+    * where moving root activities to background instead of finishing activities.
+    * @see <a href="https://developer.android.com/reference/android/app/Activity#onBackPressed()">onBackPressed</a>
+    */
+  override fun invokeDefaultOnBackPressed() {
+      if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
+          if (!moveTaskToBack(false)) {
+              // For non-root activities, use the default implementation to finish them.
+              super.invokeDefaultOnBackPressed()
+          }
+          return
+      }
+
+      // Use the default back button implementation on Android S
+      // because it's doing more than [Activity.moveTaskToBack] in fact.
+      super.invokeDefaultOnBackPressed()
+  }
+}
diff --git a/examples/react-native/offline-transactions/android/app/src/main/java/com/tanstack/offlinetransactions/MainApplication.kt b/examples/react-native/offline-transactions/android/app/src/main/java/com/tanstack/offlinetransactions/MainApplication.kt
new file mode 100644
index 000000000..8c05a1e37
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/src/main/java/com/tanstack/offlinetransactions/MainApplication.kt
@@ -0,0 +1,57 @@
+package com.tanstack.offlinetransactions
+
+import android.app.Application
+import android.content.res.Configuration
+
+import com.facebook.react.PackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.ReactHost
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.load
+import com.facebook.react.defaults.DefaultReactNativeHost
+import com.facebook.react.soloader.OpenSourceMergedSoMapping
+import com.facebook.soloader.SoLoader
+
+import expo.modules.ApplicationLifecycleDispatcher
+import expo.modules.ReactNativeHostWrapper
+
+class MainApplication : Application(), ReactApplication {
+
+  override val reactNativeHost: ReactNativeHost = ReactNativeHostWrapper(
+        this,
+        object : DefaultReactNativeHost(this) {
+          override fun getPackages(): List<ReactPackage> {
+            val packages = PackageList(this).packages
+            // Packages that cannot be autolinked yet can be added manually here, for example:
+            // packages.add(MyReactNativePackage())
+            return packages
+          }
+
+          override fun getJSMainModuleName(): String = ".expo/.virtual-metro-entry"
+
+          override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
+
+          override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+          override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
+      }
+  )
+
+  override val reactHost: ReactHost
+    get() = ReactNativeHostWrapper.createReactHost(applicationContext, reactNativeHost)
+
+  override fun onCreate() {
+    super.onCreate()
+    SoLoader.init(this, OpenSourceMergedSoMapping)
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      // If you opted-in for the New Architecture, we load the native entry point for this app.
+      load()
+    }
+    ApplicationLifecycleDispatcher.onApplicationCreate(this)
+  }
+
+  override fun onConfigurationChanged(newConfig: Configuration) {
+    super.onConfigurationChanged(newConfig)
+    ApplicationLifecycleDispatcher.onConfigurationChanged(this, newConfig)
+  }
+}
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/drawable-hdpi/splashscreen_logo.png b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-hdpi/splashscreen_logo.png
new file mode 100644
index 000000000..31df827b1
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-hdpi/splashscreen_logo.png differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/drawable-mdpi/splashscreen_logo.png b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-mdpi/splashscreen_logo.png
new file mode 100644
index 000000000..ef243aab6
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-mdpi/splashscreen_logo.png differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/drawable-xhdpi/splashscreen_logo.png b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-xhdpi/splashscreen_logo.png
new file mode 100644
index 000000000..e9d547451
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-xhdpi/splashscreen_logo.png differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/drawable-xxhdpi/splashscreen_logo.png b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-xxhdpi/splashscreen_logo.png
new file mode 100644
index 000000000..d61da15d2
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-xxhdpi/splashscreen_logo.png differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/drawable-xxxhdpi/splashscreen_logo.png b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-xxxhdpi/splashscreen_logo.png
new file mode 100644
index 000000000..4aeed11d0
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/drawable-xxxhdpi/splashscreen_logo.png differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/drawable/ic_launcher_background.xml b/examples/react-native/offline-transactions/android/app/src/main/res/drawable/ic_launcher_background.xml
new file mode 100644
index 000000000..883b2a080
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/src/main/res/drawable/ic_launcher_background.xml
@@ -0,0 +1,6 @@
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:drawable="@color/splashscreen_background"/>
+  <item>
+    <bitmap android:gravity="center" android:src="@drawable/splashscreen_logo"/>
+  </item>
+</layer-list>
\ No newline at end of file
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/drawable/rn_edit_text_material.xml b/examples/react-native/offline-transactions/android/app/src/main/res/drawable/rn_edit_text_material.xml
new file mode 100644
index 000000000..5c25e728e
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/src/main/res/drawable/rn_edit_text_material.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2014 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<inset xmlns:android="http://schemas.android.com/apk/res/android"
+       android:insetLeft="@dimen/abc_edit_text_inset_horizontal_material"
+       android:insetRight="@dimen/abc_edit_text_inset_horizontal_material"
+       android:insetTop="@dimen/abc_edit_text_inset_top_material"
+       android:insetBottom="@dimen/abc_edit_text_inset_bottom_material"
+       >
+
+    <selector>
+        <!--
+          This file is a copy of abc_edit_text_material (https://bit.ly/3k8fX7I).
+          The item below with state_pressed="false" and state_focused="false" causes a NullPointerException.
+          NullPointerException:tempt to invoke virtual method 'android.graphics.drawable.Drawable android.graphics.drawable.Drawable$ConstantState.newDrawable(android.content.res.Resources)'
+
+          <item android:state_pressed="false" android:state_focused="false" android:drawable="@drawable/abc_textfield_default_mtrl_alpha"/>
+
+          For more info, see https://bit.ly/3CdLStv (react-native/pull/29452) and https://bit.ly/3nxOMoR.
+        -->
+        <item android:state_enabled="false" android:drawable="@drawable/abc_textfield_default_mtrl_alpha"/>
+        <item android:drawable="@drawable/abc_textfield_activated_mtrl_alpha"/>
+    </selector>
+
+</inset>
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-hdpi/ic_launcher.webp
new file mode 100644
index 000000000..a2f590828
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-hdpi/ic_launcher.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp
new file mode 100644
index 000000000..1b5239980
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-mdpi/ic_launcher.webp
new file mode 100644
index 000000000..ff10afd6e
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-mdpi/ic_launcher.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp
new file mode 100644
index 000000000..115a4c768
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xhdpi/ic_launcher.webp
new file mode 100644
index 000000000..dcd3cd808
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xhdpi/ic_launcher.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp
new file mode 100644
index 000000000..459ca609d
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp
new file mode 100644
index 000000000..8ca12fe02
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp
new file mode 100644
index 000000000..8e19b410a
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp
new file mode 100644
index 000000000..b824ebdd4
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp
new file mode 100644
index 000000000..4c19a13c2
Binary files /dev/null and b/examples/react-native/offline-transactions/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp differ
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/values/colors.xml b/examples/react-native/offline-transactions/android/app/src/main/res/values/colors.xml
new file mode 100644
index 000000000..21cc1554d
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/src/main/res/values/colors.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<resources>
+  <color name="splashscreen_background">#FFFFFF</color>
+</resources>
\ No newline at end of file
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/values/strings.xml b/examples/react-native/offline-transactions/android/app/src/main/res/values/strings.xml
new file mode 100644
index 000000000..da60a7387
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">Offline Transactions Demo</string>
+</resources>
diff --git a/examples/react-native/offline-transactions/android/app/src/main/res/values/styles.xml b/examples/react-native/offline-transactions/android/app/src/main/res/values/styles.xml
new file mode 100644
index 000000000..26f3404be
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/app/src/main/res/values/styles.xml
@@ -0,0 +1,8 @@
+<resources>
+  <style name="AppTheme" parent="Theme.AppCompat.DayNight.NoActionBar">
+    <item name="android:editTextBackground">@drawable/rn_edit_text_material</item>
+  </style>
+  <style name="Theme.App.SplashScreen" parent="AppTheme">
+    <item name="android:windowBackground">@drawable/splashscreen_logo</item>
+  </style>
+</resources>
diff --git a/examples/react-native/offline-transactions/android/build.gradle b/examples/react-native/offline-transactions/android/build.gradle
new file mode 100644
index 000000000..fa7b11e23
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/build.gradle
@@ -0,0 +1,37 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+  dependencies {
+    classpath('com.android.tools.build:gradle')
+    classpath('com.facebook.react:react-native-gradle-plugin')
+    classpath('org.jetbrains.kotlin:kotlin-gradle-plugin')
+  }
+}
+
+def reactNativeAndroidDir = new File(
+  providers.exec {
+    workingDir(rootDir)
+    commandLine("node", "--print", "require.resolve('react-native/package.json')")
+  }.standardOutput.asText.get().trim(),
+  "../android"
+)
+
+allprojects {
+  repositories {
+    maven {
+      // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+      url(reactNativeAndroidDir)
+    }
+
+    google()
+    mavenCentral()
+    maven { url 'https://www.jitpack.io' }
+  }
+}
+
+apply plugin: "expo-root-project"
+apply plugin: "com.facebook.react.rootproject"
diff --git a/examples/react-native/offline-transactions/android/gradle.properties b/examples/react-native/offline-transactions/android/gradle.properties
new file mode 100644
index 000000000..7531e9eb2
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/gradle.properties
@@ -0,0 +1,56 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx512m -XX:MaxMetaspaceSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=512m
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app's APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+
+# Enable AAPT2 PNG crunching
+android.enablePngCrunchInReleaseBuilds=true
+
+# Use this property to specify which architecture you want to build.
+# You can also override it from the CLI using
+# ./gradlew <task> -PreactNativeArchitectures=x86_64
+reactNativeArchitectures=armeabi-v7a,arm64-v8a,x86,x86_64
+
+# Use this property to enable support to the new architecture.
+# This will allow you to use TurboModules and the Fabric render in
+# your application. You should enable this flag either if you want
+# to write custom TurboModules/Fabric components OR use libraries that
+# are providing them.
+newArchEnabled=true
+
+# Use this property to enable or disable the Hermes JS engine.
+# If set to false, you will be using JSC instead.
+hermesEnabled=true
+
+# Enable GIF support in React Native images (~200 B increase)
+expo.gif.enabled=true
+# Enable webp support in React Native images (~85 KB increase)
+expo.webp.enabled=true
+# Enable animated webp support (~3.4 MB increase)
+# Disabled by default because iOS doesn't support animated webp
+expo.webp.animated=false
+
+# Enable network inspector
+EX_DEV_CLIENT_NETWORK_INSPECTOR=true
+
+# Use legacy packaging to compress native libraries in the resulting APK.
+expo.useLegacyPackaging=false
diff --git a/examples/react-native/offline-transactions/android/gradle/wrapper/gradle-wrapper.jar b/examples/react-native/offline-transactions/android/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 000000000..a4b76b953
Binary files /dev/null and b/examples/react-native/offline-transactions/android/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/examples/react-native/offline-transactions/android/gradle/wrapper/gradle-wrapper.properties b/examples/react-native/offline-transactions/android/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 000000000..37f853b1c
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/examples/react-native/offline-transactions/android/gradlew b/examples/react-native/offline-transactions/android/gradlew
new file mode 100755
index 000000000..f3b75f3b0
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/gradlew
@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/examples/react-native/offline-transactions/android/gradlew.bat b/examples/react-native/offline-transactions/android/gradlew.bat
new file mode 100644
index 000000000..9b42019c7
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/gradlew.bat
@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/examples/react-native/offline-transactions/android/settings.gradle b/examples/react-native/offline-transactions/android/settings.gradle
new file mode 100644
index 000000000..6617bce75
--- /dev/null
+++ b/examples/react-native/offline-transactions/android/settings.gradle
@@ -0,0 +1,39 @@
+pluginManagement {
+  def reactNativeGradlePlugin = new File(
+    providers.exec {
+      workingDir(rootDir)
+      commandLine("node", "--print", "require.resolve('@react-native/gradle-plugin/package.json', { paths: [require.resolve('react-native/package.json')] })")
+    }.standardOutput.asText.get().trim()
+  ).getParentFile().absolutePath
+  includeBuild(reactNativeGradlePlugin)
+  
+  def expoPluginsPath = new File(
+    providers.exec {
+      workingDir(rootDir)
+      commandLine("node", "--print", "require.resolve('expo-modules-autolinking/package.json', { paths: [require.resolve('expo/package.json')] })")
+    }.standardOutput.asText.get().trim(),
+    "../android/expo-gradle-plugin"
+  ).absolutePath
+  includeBuild(expoPluginsPath)
+}
+
+plugins {
+  id("com.facebook.react.settings")
+  id("expo-autolinking-settings")
+}
+
+extensions.configure(com.facebook.react.ReactSettingsExtension) { ex ->
+  if (System.getenv('EXPO_USE_COMMUNITY_AUTOLINKING') == '1') {
+    ex.autolinkLibrariesFromCommand()
+  } else {
+    ex.autolinkLibrariesFromCommand(expoAutolinking.rnConfigCommand)
+  }
+}
+expoAutolinking.useExpoModules()
+
+rootProject.name = 'OfflineTransactionsDemo'
+
+expoAutolinking.useExpoVersionCatalog()
+
+include ':app'
+includeBuild(expoAutolinking.reactNativeGradlePlugin)
diff --git a/examples/react-native/offline-transactions/app.json b/examples/react-native/offline-transactions/app.json
new file mode 100644
index 000000000..8178a1cda
--- /dev/null
+++ b/examples/react-native/offline-transactions/app.json
@@ -0,0 +1,29 @@
+{
+  "expo": {
+    "name": "Offline Transactions Demo",
+    "slug": "offline-transactions-demo",
+    "version": "1.0.0",
+    "orientation": "portrait",
+    "icon": "./assets/icon.png",
+    "userInterfaceStyle": "light",
+    "newArchEnabled": true,
+    "splash": {
+      "image": "./assets/splash-icon.png",
+      "resizeMode": "contain",
+      "backgroundColor": "#ffffff"
+    },
+    "ios": {
+      "supportsTablet": true,
+      "bundleIdentifier": "com.tanstack.offlinetransactions"
+    },
+    "android": {
+      "adaptiveIcon": {
+        "foregroundImage": "./assets/adaptive-icon.png",
+        "backgroundColor": "#ffffff"
+      },
+      "package": "com.tanstack.offlinetransactions"
+    },
+    "scheme": "offline-transactions",
+    "plugins": ["expo-router"]
+  }
+}
diff --git a/examples/react-native/offline-transactions/app/_layout.tsx b/examples/react-native/offline-transactions/app/_layout.tsx
new file mode 100644
index 000000000..b9d10f17b
--- /dev/null
+++ b/examples/react-native/offline-transactions/app/_layout.tsx
@@ -0,0 +1,26 @@
+// Must be first import to polyfill crypto before anything else loads
+import '../src/polyfills'
+
+import { Stack } from 'expo-router'
+import { QueryClientProvider } from '@tanstack/react-query'
+import { SafeAreaProvider } from 'react-native-safe-area-context'
+import { StatusBar } from 'expo-status-bar'
+import { queryClient } from '../src/utils/queryClient'
+
+export default function RootLayout() {
+  return (
+    <SafeAreaProvider>
+      <QueryClientProvider client={queryClient}>
+        <StatusBar style="auto" />
+        <Stack>
+          <Stack.Screen
+            name="index"
+            options={{
+              title: `Offline Transactions`,
+            }}
+          />
+        </Stack>
+      </QueryClientProvider>
+    </SafeAreaProvider>
+  )
+}
diff --git a/examples/react-native/offline-transactions/app/index.tsx b/examples/react-native/offline-transactions/app/index.tsx
new file mode 100644
index 000000000..46f1e79d8
--- /dev/null
+++ b/examples/react-native/offline-transactions/app/index.tsx
@@ -0,0 +1,10 @@
+import { SafeAreaView } from 'react-native-safe-area-context'
+import { TodoList } from '../src/components/TodoList'
+
+export default function HomeScreen() {
+  return (
+    <SafeAreaView style={{ flex: 1 }} edges={[`bottom`]}>
+      <TodoList />
+    </SafeAreaView>
+  )
+}
diff --git a/examples/react-native/offline-transactions/babel.config.js b/examples/react-native/offline-transactions/babel.config.js
new file mode 100644
index 000000000..e1e3637af
--- /dev/null
+++ b/examples/react-native/offline-transactions/babel.config.js
@@ -0,0 +1,6 @@
+module.exports = function (api) {
+  api.cache(true)
+  return {
+    presets: ['babel-preset-expo'],
+  }
+}
diff --git a/examples/react-native/offline-transactions/metro.config.js b/examples/react-native/offline-transactions/metro.config.js
new file mode 100644
index 000000000..7bed46fc6
--- /dev/null
+++ b/examples/react-native/offline-transactions/metro.config.js
@@ -0,0 +1,55 @@
+const { getDefaultConfig } = require('expo/metro-config')
+const path = require('path')
+
+const projectRoot = __dirname
+const monorepoRoot = path.resolve(projectRoot, '../../..')
+
+const config = getDefaultConfig(projectRoot)
+
+// Watch all files in the monorepo
+config.watchFolders = [monorepoRoot]
+
+// Ensure symlinks are followed (important for pnpm)
+config.resolver.unstable_enableSymlinks = true
+
+// Force all React-related packages to resolve from THIS project's node_modules
+// This prevents the "multiple copies of React" error
+const localNodeModules = path.resolve(projectRoot, 'node_modules')
+config.resolver.extraNodeModules = new Proxy(
+  {
+    react: path.resolve(localNodeModules, 'react'),
+    'react-native': path.resolve(localNodeModules, 'react-native'),
+    'react/jsx-runtime': path.resolve(localNodeModules, 'react/jsx-runtime'),
+    'react/jsx-dev-runtime': path.resolve(
+      localNodeModules,
+      'react/jsx-dev-runtime',
+    ),
+  },
+  {
+    get: (target, name) => {
+      if (target[name]) {
+        return target[name]
+      }
+      // Fall back to normal resolution for other modules
+      return path.resolve(localNodeModules, name)
+    },
+  },
+)
+
+// Block react-native 0.83 from root node_modules
+config.resolver.blockList = [
+  new RegExp(
+    `${monorepoRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/node_modules/\\.pnpm/react-native@0\\.83.*`,
+  ),
+  new RegExp(
+    `${monorepoRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/node_modules/\\.pnpm/react@(?!19\\.0\\.0).*`,
+  ),
+]
+
+// Let Metro know where to resolve packages from (local first, then root)
+config.resolver.nodeModulesPaths = [
+  localNodeModules,
+  path.resolve(monorepoRoot, 'node_modules'),
+]
+
+module.exports = config
diff --git a/examples/react-native/offline-transactions/package.json b/examples/react-native/offline-transactions/package.json
new file mode 100644
index 000000000..4b4a44aa5
--- /dev/null
+++ b/examples/react-native/offline-transactions/package.json
@@ -0,0 +1,43 @@
+{
+  "name": "offline-transactions-react-native",
+  "version": "1.0.1",
+  "private": true,
+  "main": "expo-router/entry",
+  "scripts": {
+    "start": "expo start",
+    "ios": "expo run:ios",
+    "android": "expo run:android",
+    "reset-cache": "expo start --clear",
+    "server": "npx tsx server/index.ts"
+  },
+  "dependencies": {
+    "@expo/metro-runtime": "~5.0.5",
+    "@react-native-async-storage/async-storage": "2.1.2",
+    "@react-native-community/netinfo": "11.4.1",
+    "@tanstack/offline-transactions": "^1.0.14",
+    "@tanstack/query-db-collection": "^1.0.21",
+    "@tanstack/react-db": "^0.1.68",
+    "@tanstack/react-query": "^5.90.16",
+    "expo": "~53.0.0",
+    "expo-constants": "~17.1.0",
+    "expo-linking": "~7.1.0",
+    "expo-router": "~5.1.10",
+    "expo-status-bar": "~2.2.0",
+    "metro": "0.82.5",
+    "react": "^19.2.3",
+    "react-native": "0.79.6",
+    "react-native-safe-area-context": "5.4.0",
+    "react-native-screens": "~4.11.1",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.0",
+    "@types/react": "^19.2.7",
+    "cors": "^2.8.5",
+    "express": "^5.0.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.2"
+  }
+}
diff --git a/examples/react-native/offline-transactions/server/index.ts b/examples/react-native/offline-transactions/server/index.ts
new file mode 100644
index 000000000..d7990b7a8
--- /dev/null
+++ b/examples/react-native/offline-transactions/server/index.ts
@@ -0,0 +1,112 @@
+import express from 'express'
+import cors from 'cors'
+
+const app = express()
+const PORT = 3001
+
+app.use(cors())
+app.use(express.json())
+
+// Types
+interface Todo {
+  id: string
+  text: string
+  completed: boolean
+  createdAt: string
+  updatedAt: string
+}
+
+// In-memory store
+const todosStore = new Map<string, Todo>()
+
+// Helper function to generate IDs
+function generateId(): string {
+  return Math.random().toString(36).substring(2) + Date.now().toString(36)
+}
+
+// Add some initial data
+const initialTodos = [
+  { id: '1', text: 'Learn TanStack DB', completed: false },
+  { id: '2', text: 'Build offline-first app', completed: false },
+  { id: '3', text: 'Test on React Native', completed: true },
+]
+
+initialTodos.forEach((todo) => {
+  const now = new Date().toISOString()
+  todosStore.set(todo.id, {
+    ...todo,
+    createdAt: now,
+    updatedAt: now,
+  })
+})
+
+// Simulate network delay
+const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+// GET all todos
+app.get('/api/todos', async (_req, res) => {
+  console.log('GET /api/todos')
+  await delay(200)
+  const todos = Array.from(todosStore.values()).sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+  )
+  res.json(todos)
+})
+
+// POST create todo
+app.post('/api/todos', async (req, res) => {
+  console.log('POST /api/todos', req.body)
+  await delay(200)
+
+  const { text, completed } = req.body
+  if (!text || text.trim() === '') {
+    return res.status(400).json({ error: 'Todo text is required' })
+  }
+
+  const now = new Date().toISOString()
+  const todo: Todo = {
+    id: generateId(),
+    text,
+    completed: completed ?? false,
+    createdAt: now,
+    updatedAt: now,
+  }
+  todosStore.set(todo.id, todo)
+  res.status(201).json(todo)
+})
+
+// PUT update todo
+app.put('/api/todos/:id', async (req, res) => {
+  console.log('PUT /api/todos/' + req.params.id, req.body)
+  await delay(200)
+
+  const existing = todosStore.get(req.params.id)
+  if (!existing) {
+    return res.status(404).json({ error: 'Todo not found' })
+  }
+
+  const updated: Todo = {
+    ...existing,
+    ...req.body,
+    updatedAt: new Date().toISOString(),
+  }
+  todosStore.set(req.params.id, updated)
+  res.json(updated)
+})
+
+// DELETE todo
+app.delete('/api/todos/:id', async (req, res) => {
+  console.log('DELETE /api/todos/' + req.params.id)
+  await delay(200)
+
+  if (!todosStore.delete(req.params.id)) {
+    return res.status(404).json({ error: 'Todo not found' })
+  }
+  res.json({ success: true })
+})
+
+app.listen(PORT, '0.0.0.0', () => {
+  console.log(`Server running at http://0.0.0.0:${PORT}`)
+  console.log(`\nFor Android emulator, use: http://10.0.2.2:${PORT}`)
+  console.log(`For iOS simulator, use: http://localhost:${PORT}`)
+})
diff --git a/examples/react-native/offline-transactions/src/components/TodoList.tsx b/examples/react-native/offline-transactions/src/components/TodoList.tsx
new file mode 100644
index 000000000..3f9b0ce54
--- /dev/null
+++ b/examples/react-native/offline-transactions/src/components/TodoList.tsx
@@ -0,0 +1,515 @@
+import React, { useEffect, useMemo, useState } from 'react'
+import {
+  View,
+  Text,
+  TextInput,
+  TouchableOpacity,
+  FlatList,
+  StyleSheet,
+  ActivityIndicator,
+} from 'react-native'
+import NetInfo from '@react-native-community/netinfo'
+import { useLiveQuery } from '@tanstack/react-db'
+import {
+  todoCollection,
+  createOfflineExecutor,
+  createTodoActions,
+} from '../db/todos'
+
+export function TodoList() {
+  const [newTodoText, setNewTodoText] = useState(``)
+  const [error, setError] = useState<string | null>(null)
+  const [isOnline, setIsOnline] = useState(true)
+  const [pendingCount, setPendingCount] = useState(0)
+  const [offline, setOffline] = useState<ReturnType<
+    typeof createOfflineExecutor
+  > | null>(null)
+  const [initError, setInitError] = useState<string | null>(null)
+  const [isInitialized, setIsInitialized] = useState(false)
+
+  // Initialize offline executor
+  useEffect(() => {
+    console.log(`[TodoList] Initializing...`)
+    try {
+      const executor = createOfflineExecutor()
+      setOffline(executor)
+      setIsInitialized(true)
+      console.log(`[TodoList] Executor created successfully`)
+
+      return () => {
+        executor.dispose()
+      }
+    } catch (err) {
+      console.error(`[TodoList] Failed to create executor:`, err)
+      setInitError(err instanceof Error ? err.message : `Failed to initialize`)
+      setIsInitialized(true)
+    }
+  }, [])
+
+  // Create actions based on offline executor
+  const actions = useMemo(() => createTodoActions(offline), [offline])
+
+  // Use live query to get todos
+  const queryResult = useLiveQuery((q) =>
+    q
+      .from({ todo: todoCollection })
+      .orderBy(({ todo }) => todo.createdAt, `desc`),
+  )
+  const todoList = queryResult.data ?? []
+  const isLoading = queryResult.isLoading
+
+  useEffect(() => {
+    console.log(`[TodoList] Query state:`, {
+      todoCount: todoList.length,
+      isLoading,
+    })
+  }, [todoList.length, isLoading])
+
+  // Monitor network status
+  useEffect(() => {
+    const unsubscribe = NetInfo.addEventListener((state) => {
+      const connected =
+        state.isConnected === true && state.isInternetReachable !== false
+      setIsOnline(connected)
+
+      if (connected && offline) {
+        offline.notifyOnline()
+      }
+    })
+
+    return () => unsubscribe()
+  }, [offline])
+
+  // Monitor pending transactions
+  useEffect(() => {
+    if (!offline) return
+
+    const interval = setInterval(() => {
+      setPendingCount(offline.getPendingCount())
+    }, 100)
+
+    return () => clearInterval(interval)
+  }, [offline])
+
+  const handleAddTodo = async () => {
+    if (!newTodoText.trim() || !actions.addTodo) return
+
+    try {
+      setError(null)
+      await actions.addTodo(newTodoText)
+      setNewTodoText(``)
+    } catch (err) {
+      setError(err instanceof Error ? err.message : `Failed to add todo`)
+    }
+  }
+
+  const handleToggleTodo = async (id: string) => {
+    if (!actions.toggleTodo) return
+
+    try {
+      setError(null)
+      await actions.toggleTodo(id)
+    } catch (err) {
+      setError(err instanceof Error ? err.message : `Failed to toggle todo`)
+    }
+  }
+
+  const handleDeleteTodo = async (id: string) => {
+    if (!actions.deleteTodo) return
+
+    try {
+      setError(null)
+      await actions.deleteTodo(id)
+    } catch (err) {
+      setError(err instanceof Error ? err.message : `Failed to delete todo`)
+    }
+  }
+
+  // Show init error if any
+  if (initError) {
+    return (
+      <View style={styles.container}>
+        <Text style={styles.title}>Initialization Error</Text>
+        <View style={styles.errorBox}>
+          <Text style={styles.errorText}>{initError}</Text>
+        </View>
+      </View>
+    )
+  }
+
+  // Show loading while initializing
+  if (!isInitialized) {
+    return (
+      <View style={styles.container}>
+        <Text style={styles.title}>Offline Transactions Demo</Text>
+        <View style={styles.loadingContainer}>
+          <ActivityIndicator size="large" color="#3b82f6" />
+          <Text style={styles.loadingText}>Initializing...</Text>
+        </View>
+      </View>
+    )
+  }
+
+  return (
+    <View style={styles.container}>
+      <Text style={styles.title}>Offline Transactions Demo</Text>
+      <Text style={styles.subtitle}>TanStack DB on React Native</Text>
+
+      {/* Debug info */}
+      <Text style={{ fontSize: 12, color: `#666`, marginBottom: 8 }}>
+        Init: {isInitialized ? `yes` : `no`} | Offline: {offline ? `yes` : `no`}{' '}
+        | Loading: {isLoading ? `yes` : `no`} | Todos: {todoList.length}
+      </Text>
+
+      {/* Status indicators */}
+      <View style={styles.statusRow}>
+        <View
+          style={[
+            styles.statusBadge,
+            isOnline ? styles.online : styles.offline,
+          ]}
+        >
+          <View
+            style={[
+              styles.statusDot,
+              isOnline ? styles.onlineDot : styles.offlineDot,
+            ]}
+          />
+          <Text style={styles.statusText}>
+            {isOnline ? `Online` : `Offline`}
+          </Text>
+        </View>
+
+        <View
+          style={[
+            styles.statusBadge,
+            offline?.isOfflineEnabled ? styles.enabled : styles.disabled,
+          ]}
+        >
+          <View
+            style={[
+              styles.statusDot,
+              offline?.isOfflineEnabled
+                ? styles.enabledDot
+                : styles.disabledDot,
+            ]}
+          />
+          <Text style={styles.statusText}>
+            {offline?.isOfflineEnabled ? `Offline Mode` : `Online Only`}
+          </Text>
+        </View>
+
+        {pendingCount > 0 && (
+          <View style={[styles.statusBadge, styles.pending]}>
+            <ActivityIndicator size="small" color="#b45309" />
+            <Text style={styles.statusText}>{pendingCount} pending</Text>
+          </View>
+        )}
+      </View>
+
+      {/* Error display */}
+      {error && (
+        <View style={styles.errorBox}>
+          <Text style={styles.errorText}>{error}</Text>
+        </View>
+      )}
+
+      {/* Add new todo */}
+      <View style={styles.inputRow}>
+        <TextInput
+          style={styles.input}
+          value={newTodoText}
+          onChangeText={setNewTodoText}
+          placeholder="Add a new todo..."
+          onSubmitEditing={handleAddTodo}
+          editable={!isLoading}
+        />
+        <TouchableOpacity
+          style={[
+            styles.addButton,
+            (!newTodoText.trim() || isLoading) && styles.addButtonDisabled,
+          ]}
+          onPress={handleAddTodo}
+          disabled={!newTodoText.trim() || isLoading}
+        >
+          <Text style={styles.addButtonText}>Add</Text>
+        </TouchableOpacity>
+      </View>
+
+      {/* Todo list */}
+      {isLoading && todoList.length === 0 ? (
+        <View style={styles.loadingContainer}>
+          <ActivityIndicator size="large" color="#3b82f6" />
+          <Text style={styles.loadingText}>Loading todos...</Text>
+        </View>
+      ) : todoList.length === 0 ? (
+        <View style={styles.emptyContainer}>
+          <Text style={styles.emptyText}>No todos yet. Add one above!</Text>
+          <Text style={styles.emptySubtext}>
+            Try going offline to test offline mode
+          </Text>
+        </View>
+      ) : (
+        <FlatList
+          data={todoList}
+          keyExtractor={(item) => item.id}
+          style={styles.list}
+          renderItem={({ item: todo }) => (
+            <View style={styles.todoItem}>
+              <TouchableOpacity
+                style={[
+                  styles.checkbox,
+                  todo.completed && styles.checkboxChecked,
+                ]}
+                onPress={() => handleToggleTodo(todo.id)}
+              >
+                {todo.completed && <Text style={styles.checkmark}>✓</Text>}
+              </TouchableOpacity>
+              <View style={styles.todoContent}>
+                <Text
+                  style={[
+                    styles.todoText,
+                    todo.completed && styles.todoTextCompleted,
+                  ]}
+                >
+                  {todo.text}
+                </Text>
+                <Text style={styles.todoDate}>
+                  {new Date(todo.createdAt).toLocaleDateString()}
+                </Text>
+              </View>
+              <TouchableOpacity
+                style={styles.deleteButton}
+                onPress={() => handleDeleteTodo(todo.id)}
+              >
+                <Text style={styles.deleteButtonText}>Delete</Text>
+              </TouchableOpacity>
+            </View>
+          )}
+        />
+      )}
+
+      {/* Instructions */}
+      <View style={styles.instructions}>
+        <Text style={styles.instructionsTitle}>Try this:</Text>
+        <Text style={styles.instructionsText}>
+          1. Add some todos while online
+        </Text>
+        <Text style={styles.instructionsText}>2. Enable airplane mode</Text>
+        <Text style={styles.instructionsText}>
+          3. Add more todos (queued locally)
+        </Text>
+        <Text style={styles.instructionsText}>
+          4. Disable airplane mode to sync
+        </Text>
+      </View>
+    </View>
+  )
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    padding: 16,
+    backgroundColor: `#f5f5f5`,
+  },
+  title: {
+    fontSize: 24,
+    fontWeight: `bold`,
+    color: `#111`,
+    marginBottom: 4,
+  },
+  subtitle: {
+    fontSize: 14,
+    color: `#666`,
+    marginBottom: 16,
+  },
+  statusRow: {
+    flexDirection: `row`,
+    flexWrap: `wrap`,
+    gap: 8,
+    marginBottom: 16,
+  },
+  statusBadge: {
+    flexDirection: `row`,
+    alignItems: `center`,
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderRadius: 16,
+    gap: 6,
+  },
+  statusDot: {
+    width: 8,
+    height: 8,
+    borderRadius: 4,
+  },
+  statusText: {
+    fontSize: 12,
+    fontWeight: `500`,
+  },
+  online: {
+    backgroundColor: `#dcfce7`,
+  },
+  onlineDot: {
+    backgroundColor: `#22c55e`,
+  },
+  offline: {
+    backgroundColor: `#fee2e2`,
+  },
+  offlineDot: {
+    backgroundColor: `#ef4444`,
+  },
+  enabled: {
+    backgroundColor: `#dbeafe`,
+  },
+  enabledDot: {
+    backgroundColor: `#3b82f6`,
+  },
+  disabled: {
+    backgroundColor: `#e5e5e5`,
+  },
+  disabledDot: {
+    backgroundColor: `#737373`,
+  },
+  pending: {
+    backgroundColor: `#fef3c7`,
+  },
+  errorBox: {
+    backgroundColor: `#fee2e2`,
+    borderWidth: 1,
+    borderColor: `#fca5a5`,
+    borderRadius: 8,
+    padding: 12,
+    marginBottom: 16,
+  },
+  errorText: {
+    color: `#dc2626`,
+    fontSize: 14,
+  },
+  inputRow: {
+    flexDirection: `row`,
+    gap: 8,
+    marginBottom: 16,
+  },
+  input: {
+    flex: 1,
+    backgroundColor: `#fff`,
+    borderWidth: 1,
+    borderColor: `#d1d5db`,
+    borderRadius: 8,
+    paddingHorizontal: 12,
+    paddingVertical: 10,
+    fontSize: 16,
+  },
+  addButton: {
+    backgroundColor: `#3b82f6`,
+    paddingHorizontal: 20,
+    paddingVertical: 10,
+    borderRadius: 8,
+    justifyContent: `center`,
+  },
+  addButtonDisabled: {
+    opacity: 0.5,
+  },
+  addButtonText: {
+    color: `#fff`,
+    fontWeight: `600`,
+    fontSize: 16,
+  },
+  loadingContainer: {
+    flex: 1,
+    justifyContent: `center`,
+    alignItems: `center`,
+    gap: 12,
+  },
+  loadingText: {
+    color: `#666`,
+    fontSize: 14,
+  },
+  emptyContainer: {
+    flex: 1,
+    justifyContent: `center`,
+    alignItems: `center`,
+  },
+  emptyText: {
+    color: `#666`,
+    fontSize: 16,
+  },
+  emptySubtext: {
+    color: `#999`,
+    fontSize: 12,
+    marginTop: 4,
+  },
+  list: {
+    flex: 1,
+  },
+  todoItem: {
+    flexDirection: `row`,
+    alignItems: `center`,
+    backgroundColor: `#fff`,
+    borderWidth: 1,
+    borderColor: `#e5e5e5`,
+    borderRadius: 8,
+    padding: 12,
+    marginBottom: 8,
+    gap: 12,
+  },
+  checkbox: {
+    width: 24,
+    height: 24,
+    borderWidth: 2,
+    borderColor: `#d1d5db`,
+    borderRadius: 4,
+    justifyContent: `center`,
+    alignItems: `center`,
+  },
+  checkboxChecked: {
+    backgroundColor: `#22c55e`,
+    borderColor: `#22c55e`,
+  },
+  checkmark: {
+    color: `#fff`,
+    fontSize: 14,
+    fontWeight: `bold`,
+  },
+  todoContent: {
+    flex: 1,
+  },
+  todoText: {
+    fontSize: 16,
+    color: `#111`,
+  },
+  todoTextCompleted: {
+    textDecorationLine: `line-through`,
+    color: `#999`,
+  },
+  todoDate: {
+    fontSize: 12,
+    color: `#999`,
+    marginTop: 2,
+  },
+  deleteButton: {
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+  },
+  deleteButtonText: {
+    color: `#dc2626`,
+    fontSize: 14,
+  },
+  instructions: {
+    backgroundColor: `#f0f0f0`,
+    borderRadius: 8,
+    padding: 16,
+    marginTop: 16,
+  },
+  instructionsTitle: {
+    fontWeight: `600`,
+    color: `#111`,
+    marginBottom: 8,
+  },
+  instructionsText: {
+    color: `#666`,
+    fontSize: 13,
+    marginBottom: 2,
+  },
+})
diff --git a/examples/react-native/offline-transactions/src/db/AsyncStorageAdapter.ts b/examples/react-native/offline-transactions/src/db/AsyncStorageAdapter.ts
new file mode 100644
index 000000000..cdbbb7358
--- /dev/null
+++ b/examples/react-native/offline-transactions/src/db/AsyncStorageAdapter.ts
@@ -0,0 +1,45 @@
+import AsyncStorage from '@react-native-async-storage/async-storage'
+import type { StorageAdapter } from '@tanstack/offline-transactions'
+
+/**
+ * AsyncStorage adapter for React Native offline transactions.
+ * Implements the StorageAdapter interface using @react-native-async-storage/async-storage.
+ */
+export class AsyncStorageAdapter implements StorageAdapter {
+  private prefix: string
+
+  constructor(prefix = `offline-tx:`) {
+    this.prefix = prefix
+  }
+
+  private getKey(key: string): string {
+    return `${this.prefix}${key}`
+  }
+
+  async get(key: string): Promise<string | null> {
+    return AsyncStorage.getItem(this.getKey(key))
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    await AsyncStorage.setItem(this.getKey(key), value)
+  }
+
+  async delete(key: string): Promise<void> {
+    await AsyncStorage.removeItem(this.getKey(key))
+  }
+
+  async keys(): Promise<Array<string>> {
+    const allKeys = await AsyncStorage.getAllKeys()
+    return allKeys
+      .filter((k) => k.startsWith(this.prefix))
+      .map((k) => k.slice(this.prefix.length))
+  }
+
+  async clear(): Promise<void> {
+    const keys = await this.keys()
+    const prefixedKeys = keys.map((k) => this.getKey(k))
+    if (prefixedKeys.length > 0) {
+      await AsyncStorage.multiRemove(prefixedKeys)
+    }
+  }
+}
diff --git a/examples/react-native/offline-transactions/src/db/todos.ts b/examples/react-native/offline-transactions/src/db/todos.ts
new file mode 100644
index 000000000..88a690394
--- /dev/null
+++ b/examples/react-native/offline-transactions/src/db/todos.ts
@@ -0,0 +1,169 @@
+import { createCollection } from '@tanstack/react-db'
+import { queryCollectionOptions } from '@tanstack/query-db-collection'
+import { startOfflineExecutor } from '@tanstack/offline-transactions/react-native'
+import { z } from 'zod'
+import { queryClient } from '../utils/queryClient'
+import { todoApi } from '../utils/api'
+import { AsyncStorageAdapter } from './AsyncStorageAdapter'
+import type { Todo } from '../utils/api'
+import type { PendingMutation } from '@tanstack/db'
+
+// Define schema
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  completed: z.boolean(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+})
+
+// Create the todo collection with polling to sync changes from other devices
+export const todoCollection = createCollection(
+  queryCollectionOptions({
+    id: `todos-collection`, // Explicit ID to avoid crypto.randomUUID() on RN
+    queryClient,
+    queryKey: [`todos`],
+    queryFn: async (): Promise<Array<Todo>> => {
+      const todos = await todoApi.getAll()
+      return todos
+    },
+    getKey: (item) => item.id,
+    schema: todoSchema,
+    // Poll every 3 seconds to sync changes from other devices
+    refetchInterval: 3000,
+  }),
+)
+
+// Sync function to push mutations to the "backend"
+async function syncTodos({
+  transaction,
+  idempotencyKey,
+}: {
+  transaction: { mutations: Array<PendingMutation> }
+  idempotencyKey: string
+}) {
+  const mutations = transaction.mutations
+
+  console.log(`[Sync] Processing ${mutations.length} mutations`, idempotencyKey)
+
+  for (const mutation of mutations) {
+    try {
+      switch (mutation.type) {
+        case `insert`: {
+          const todoData = mutation.modified as Todo
+          await todoApi.create({
+            text: todoData.text,
+            completed: todoData.completed,
+          })
+          break
+        }
+
+        case `update`: {
+          const todoData = mutation.modified as Partial<Todo>
+          const id = (mutation.modified as Todo).id
+          await todoApi.update(id, {
+            text: todoData.text,
+            completed: todoData.completed,
+          })
+          break
+        }
+
+        case `delete`: {
+          const id = (mutation.original as Todo).id
+          await todoApi.delete(id)
+          break
+        }
+      }
+    } catch (error) {
+      console.error(`[Sync] Error syncing mutation:`, mutation, error)
+      throw error
+    }
+  }
+
+  // Refresh the collection after sync
+  await todoCollection.utils.refetch()
+}
+
+// Create the offline executor with React Native support
+export function createOfflineExecutor() {
+  console.log(`[Offline] Creating executor with AsyncStorage adapter`)
+
+  const executor = startOfflineExecutor({
+    collections: { todos: todoCollection },
+    storage: new AsyncStorageAdapter(`offline-todos:`),
+    mutationFns: {
+      syncTodos,
+    },
+    onLeadershipChange: (isLeader) => {
+      console.log(`[Offline] Leadership changed:`, isLeader)
+    },
+    onStorageFailure: (diagnostic) => {
+      console.warn(`[Offline] Storage failure:`, diagnostic)
+    },
+  })
+
+  console.log(`[Offline] Executor mode:`, executor.mode)
+  console.log(`[Offline] Storage diagnostic:`, executor.storageDiagnostic)
+
+  return executor
+}
+
+// Helper functions to create offline actions
+export function createTodoActions(
+  offline: ReturnType<typeof createOfflineExecutor> | null,
+) {
+  if (!offline) {
+    return {
+      addTodo: null,
+      toggleTodo: null,
+      deleteTodo: null,
+    }
+  }
+
+  const addTodoAction = offline.createOfflineAction({
+    mutationFnName: `syncTodos`,
+    onMutate: (text: string) => {
+      // Use Math.random based ID generation (crypto.randomUUID not available on RN Hermes)
+      const id = `${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 10)}`
+      const newTodo = {
+        id,
+        text: text.trim(),
+        completed: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }
+      todoCollection.insert(newTodo)
+      return newTodo
+    },
+  })
+
+  const toggleTodoAction = offline.createOfflineAction({
+    mutationFnName: `syncTodos`,
+    onMutate: (id: string) => {
+      const todo = todoCollection.get(id)
+      if (!todo) return
+      todoCollection.update(id, (draft) => {
+        draft.completed = !draft.completed
+        draft.updatedAt = new Date()
+      })
+      return todo
+    },
+  })
+
+  const deleteTodoAction = offline.createOfflineAction({
+    mutationFnName: `syncTodos`,
+    onMutate: (id: string) => {
+      const todo = todoCollection.get(id)
+      if (todo) {
+        todoCollection.delete(id)
+      }
+      return todo
+    },
+  })
+
+  return {
+    addTodo: addTodoAction,
+    toggleTodo: toggleTodoAction,
+    deleteTodo: deleteTodoAction,
+  }
+}
diff --git a/examples/react-native/offline-transactions/src/polyfills.ts b/examples/react-native/offline-transactions/src/polyfills.ts
new file mode 100644
index 000000000..1c00a87f9
--- /dev/null
+++ b/examples/react-native/offline-transactions/src/polyfills.ts
@@ -0,0 +1,25 @@
+// Polyfill for crypto.randomUUID() which is not available in React Native Hermes
+if (typeof global.crypto === 'undefined') {
+  global.crypto = {} as Crypto
+}
+
+if (typeof global.crypto.randomUUID !== 'function') {
+  global.crypto.randomUUID =
+    function randomUUID(): `${string}-${string}-${string}-${string}-${string}` {
+      // Simple UUID v4 implementation
+      const hex = '0123456789abcdef'
+      let uuid = ''
+      for (let i = 0; i < 36; i++) {
+        if (i === 8 || i === 13 || i === 18 || i === 23) {
+          uuid += '-'
+        } else if (i === 14) {
+          uuid += '4' // Version 4
+        } else if (i === 19) {
+          uuid += hex[(Math.random() * 4) | 8] // Variant bits
+        } else {
+          uuid += hex[(Math.random() * 16) | 0]
+        }
+      }
+      return uuid as `${string}-${string}-${string}-${string}-${string}`
+    }
+}
diff --git a/examples/react-native/offline-transactions/src/utils/api.ts b/examples/react-native/offline-transactions/src/utils/api.ts
new file mode 100644
index 000000000..c8ee50e1b
--- /dev/null
+++ b/examples/react-native/offline-transactions/src/utils/api.ts
@@ -0,0 +1,93 @@
+import { Platform } from 'react-native'
+
+// Server URL differs by platform
+// Android emulator: 10.0.2.2 maps to host machine's localhost
+// iOS simulator: localhost works directly
+const SERVER_PORT = 3001
+const BASE_URL = Platform.select({
+  android: `http://10.0.2.2:${SERVER_PORT}`,
+  ios: `http://localhost:${SERVER_PORT}`,
+  default: `http://localhost:${SERVER_PORT}`,
+})
+
+export interface Todo {
+  id: string
+  text: string
+  completed: boolean
+  createdAt: Date
+  updatedAt: Date
+}
+
+interface TodoResponse {
+  id: string
+  text: string
+  completed: boolean
+  createdAt: string
+  updatedAt: string
+}
+
+// Convert API response to Todo with Date objects
+function parseTodo(todo: TodoResponse): Todo {
+  return {
+    ...todo,
+    createdAt: new Date(todo.createdAt),
+    updatedAt: new Date(todo.updatedAt),
+  }
+}
+
+// API client that calls the shared backend server
+export const todoApi = {
+  async getAll(): Promise<Array<Todo>> {
+    const response = await fetch(`${BASE_URL}/api/todos`)
+    if (!response.ok) {
+      throw new Error(`Failed to fetch todos: ${response.status}`)
+    }
+    const data: Array<TodoResponse> = await response.json()
+    return data.map(parseTodo)
+  },
+
+  async create(data: { text: string; completed?: boolean }): Promise<Todo> {
+    const response = await fetch(`${BASE_URL}/api/todos`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    })
+    if (!response.ok) {
+      throw new Error(`Failed to create todo: ${response.status}`)
+    }
+    const todo: TodoResponse = await response.json()
+    return parseTodo(todo)
+  },
+
+  async update(
+    id: string,
+    data: { text?: string; completed?: boolean },
+  ): Promise<Todo | null> {
+    const response = await fetch(`${BASE_URL}/api/todos/${id}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    })
+    if (response.status === 404) {
+      return null
+    }
+    if (!response.ok) {
+      throw new Error(`Failed to update todo: ${response.status}`)
+    }
+    const todo: TodoResponse = await response.json()
+    return parseTodo(todo)
+  },
+
+  async delete(id: string): Promise<boolean> {
+    const response = await fetch(`${BASE_URL}/api/todos/${id}`, {
+      method: 'DELETE',
+    })
+    if (response.status === 404) {
+      return false
+    }
+    if (!response.ok) {
+      throw new Error(`Failed to delete todo: ${response.status}`)
+    }
+    return true
+  },
+}
diff --git a/examples/react-native/offline-transactions/src/utils/queryClient.ts b/examples/react-native/offline-transactions/src/utils/queryClient.ts
new file mode 100644
index 000000000..55c589ceb
--- /dev/null
+++ b/examples/react-native/offline-transactions/src/utils/queryClient.ts
@@ -0,0 +1,10 @@
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 1000 * 60, // 1 minute
+      retry: 3,
+    },
+  },
+})
diff --git a/examples/react-native/offline-transactions/tsconfig.json b/examples/react-native/offline-transactions/tsconfig.json
new file mode 100644
index 000000000..52f606b02
--- /dev/null
+++ b/examples/react-native/offline-transactions/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "strict": true,
+    "paths": {
+      "~/*": ["./src/*"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.tsx"]
+}
diff --git a/examples/react/offline-transactions/.env.example b/examples/react/offline-transactions/.env.example
new file mode 100644
index 000000000..e7f34f35d
--- /dev/null
+++ b/examples/react/offline-transactions/.env.example
@@ -0,0 +1,3 @@
+# Honeycomb API Key
+# Get your API key from https://ui.honeycomb.io/account
+HONEYCOMB_API_KEY=your_api_key_here
diff --git a/examples/react/offline-transactions/.gitignore b/examples/react/offline-transactions/.gitignore
new file mode 100644
index 000000000..6ab0517d9
--- /dev/null
+++ b/examples/react/offline-transactions/.gitignore
@@ -0,0 +1,20 @@
+node_modules
+package-lock.json
+yarn.lock
+
+.DS_Store
+.cache
+.env
+.vercel
+.output
+.nitro
+/build/
+/api/
+/server/build
+/public/build# Sentry Config File
+.env.sentry-build-plugin
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
+.tanstack
\ No newline at end of file
diff --git a/examples/react/offline-transactions/.prettierignore b/examples/react/offline-transactions/.prettierignore
new file mode 100644
index 000000000..2be5eaa6e
--- /dev/null
+++ b/examples/react/offline-transactions/.prettierignore
@@ -0,0 +1,4 @@
+**/build
+**/public
+pnpm-lock.yaml
+routeTree.gen.ts
\ No newline at end of file
diff --git a/examples/react/offline-transactions/README.md b/examples/react/offline-transactions/README.md
new file mode 100644
index 000000000..90cba4aac
--- /dev/null
+++ b/examples/react/offline-transactions/README.md
@@ -0,0 +1,72 @@
+# Welcome to TanStack.com!
+
+This site is built with TanStack Router!
+
+- [TanStack Router Docs](https://tanstack.com/router)
+
+It's deployed automagically with Netlify!
+
+- [Netlify](https://netlify.com/)
+
+## Development
+
+From your terminal:
+
+```sh
+pnpm install
+pnpm dev
+```
+
+This starts your app in development mode, rebuilding assets on file changes.
+
+## Editing and previewing the docs of TanStack projects locally
+
+The documentations for all TanStack projects except for `React Charts` are hosted on [https://tanstack.com](https://tanstack.com), powered by this TanStack Router app.
+In production, the markdown doc pages are fetched from the GitHub repos of the projects, but in development they are read from the local file system.
+
+Follow these steps if you want to edit the doc pages of a project (in these steps we'll assume it's [`TanStack/form`](https://github.com/tanstack/form)) and preview them locally :
+
+1. Create a new directory called `tanstack`.
+
+```sh
+mkdir tanstack
+```
+
+2. Enter the directory and clone this repo and the repo of the project there.
+
+```sh
+cd tanstack
+git clone git@github.com:TanStack/tanstack.com.git
+git clone git@github.com:TanStack/form.git
+```
+
+> [!NOTE]
+> Your `tanstack` directory should look like this:
+>
+> ```
+> tanstack/
+>    |
+>    +-- form/
+>    |
+>    +-- tanstack.com/
+> ```
+
+> [!WARNING]
+> Make sure the name of the directory in your local file system matches the name of the project's repo. For example, `tanstack/form` must be cloned into `form` (this is the default) instead of `some-other-name`, because that way, the doc pages won't be found.
+
+3. Enter the `tanstack/tanstack.com` directory, install the dependencies and run the app in dev mode:
+
+```sh
+cd tanstack.com
+pnpm i
+# The app will run on https://localhost:3000 by default
+pnpm dev
+```
+
+4. Now you can visit http://localhost:3000/form/latest/docs/overview in the browser and see the changes you make in `tanstack/form/docs`.
+
+> [!NOTE]
+> The updated pages need to be manually reloaded in the browser.
+
+> [!WARNING]
+> You will need to update the `docs/config.json` file (in the project's repo) if you add a new doc page!
diff --git a/examples/react/offline-transactions/package.json b/examples/react/offline-transactions/package.json
new file mode 100644
index 000000000..c8803b3bb
--- /dev/null
+++ b/examples/react/offline-transactions/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "tanstack-start-example-basic",
+  "private": true,
+  "sideEffects": false,
+  "type": "module",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build && tsc --noEmit",
+    "start": "node .output/server/index.mjs"
+  },
+  "dependencies": {
+    "@tanstack/offline-transactions": "^1.0.14",
+    "@tanstack/query-db-collection": "^1.0.21",
+    "@tanstack/react-db": "^0.1.68",
+    "@tanstack/react-query": "^5.90.16",
+    "@tanstack/react-router": "^1.144.0",
+    "@tanstack/react-router-devtools": "^1.144.0",
+    "@tanstack/react-start": "^1.145.5",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "tailwind-merge": "^2.6.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.1.18",
+    "@types/node": "^24.6.2",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.2",
+    "chokidar": "^4.0.3",
+    "tailwindcss": "^4.1.18",
+    "typescript": "^5.9.2",
+    "vite": "^7.3.0",
+    "vite-tsconfig-paths": "^5.1.4"
+  }
+}
diff --git a/examples/react/offline-transactions/public/android-chrome-192x192.png b/examples/react/offline-transactions/public/android-chrome-192x192.png
new file mode 100644
index 000000000..09c8324f8
Binary files /dev/null and b/examples/react/offline-transactions/public/android-chrome-192x192.png differ
diff --git a/examples/react/offline-transactions/public/android-chrome-512x512.png b/examples/react/offline-transactions/public/android-chrome-512x512.png
new file mode 100644
index 000000000..11d626ea3
Binary files /dev/null and b/examples/react/offline-transactions/public/android-chrome-512x512.png differ
diff --git a/examples/react/offline-transactions/public/apple-touch-icon.png b/examples/react/offline-transactions/public/apple-touch-icon.png
new file mode 100644
index 000000000..5a9423cc0
Binary files /dev/null and b/examples/react/offline-transactions/public/apple-touch-icon.png differ
diff --git a/examples/react/offline-transactions/public/favicon-16x16.png b/examples/react/offline-transactions/public/favicon-16x16.png
new file mode 100644
index 000000000..e3389b004
Binary files /dev/null and b/examples/react/offline-transactions/public/favicon-16x16.png differ
diff --git a/examples/react/offline-transactions/public/favicon-32x32.png b/examples/react/offline-transactions/public/favicon-32x32.png
new file mode 100644
index 000000000..900c77d44
Binary files /dev/null and b/examples/react/offline-transactions/public/favicon-32x32.png differ
diff --git a/examples/react/offline-transactions/public/favicon.ico b/examples/react/offline-transactions/public/favicon.ico
new file mode 100644
index 000000000..1a1751676
Binary files /dev/null and b/examples/react/offline-transactions/public/favicon.ico differ
diff --git a/examples/react/offline-transactions/public/favicon.png b/examples/react/offline-transactions/public/favicon.png
new file mode 100644
index 000000000..1e77bc060
Binary files /dev/null and b/examples/react/offline-transactions/public/favicon.png differ
diff --git a/examples/react/offline-transactions/public/site.webmanifest b/examples/react/offline-transactions/public/site.webmanifest
new file mode 100644
index 000000000..fa99de77d
--- /dev/null
+++ b/examples/react/offline-transactions/public/site.webmanifest
@@ -0,0 +1,19 @@
+{
+  "name": "",
+  "short_name": "",
+  "icons": [
+    {
+      "src": "/android-chrome-192x192.png",
+      "sizes": "192x192",
+      "type": "image/png"
+    },
+    {
+      "src": "/android-chrome-512x512.png",
+      "sizes": "512x512",
+      "type": "image/png"
+    }
+  ],
+  "theme_color": "#ffffff",
+  "background_color": "#ffffff",
+  "display": "standalone"
+}
diff --git a/examples/react/offline-transactions/src/components/DefaultCatchBoundary.tsx b/examples/react/offline-transactions/src/components/DefaultCatchBoundary.tsx
new file mode 100644
index 000000000..ae1b64f67
--- /dev/null
+++ b/examples/react/offline-transactions/src/components/DefaultCatchBoundary.tsx
@@ -0,0 +1,53 @@
+import {
+  ErrorComponent,
+  Link,
+  rootRouteId,
+  useMatch,
+  useRouter,
+} from '@tanstack/react-router'
+import type { ErrorComponentProps } from '@tanstack/react-router'
+
+export function DefaultCatchBoundary({ error }: ErrorComponentProps) {
+  const router = useRouter()
+  const isRoot = useMatch({
+    strict: false,
+    select: (state) => state.id === rootRouteId,
+  })
+
+  console.error(`DefaultCatchBoundary Error:`, error)
+
+  return (
+    <div className="min-w-0 flex-1 p-4 flex flex-col items-center justify-center gap-6">
+      <ErrorComponent error={error} />
+      <div className="flex gap-2 items-center flex-wrap">
+        <button
+          onClick={() => {
+            router.invalidate()
+          }}
+          className={`px-2 py-1 bg-gray-600 dark:bg-gray-700 rounded text-white uppercase font-extrabold`}
+        >
+          Try Again
+        </button>
+        {isRoot ? (
+          <Link
+            to="/"
+            className={`px-2 py-1 bg-gray-600 dark:bg-gray-700 rounded text-white uppercase font-extrabold`}
+          >
+            Home
+          </Link>
+        ) : (
+          <Link
+            to="/"
+            className={`px-2 py-1 bg-gray-600 dark:bg-gray-700 rounded text-white uppercase font-extrabold`}
+            onClick={(e) => {
+              e.preventDefault()
+              window.history.back()
+            }}
+          >
+            Go Back
+          </Link>
+        )}
+      </div>
+    </div>
+  )
+}
diff --git a/examples/react/offline-transactions/src/components/NotFound.tsx b/examples/react/offline-transactions/src/components/NotFound.tsx
new file mode 100644
index 000000000..7b54fa568
--- /dev/null
+++ b/examples/react/offline-transactions/src/components/NotFound.tsx
@@ -0,0 +1,25 @@
+import { Link } from '@tanstack/react-router'
+
+export function NotFound({ children }: { children?: any }) {
+  return (
+    <div className="space-y-2 p-2">
+      <div className="text-gray-600 dark:text-gray-400">
+        {children || <p>The page you are looking for does not exist.</p>}
+      </div>
+      <p className="flex items-center gap-2 flex-wrap">
+        <button
+          onClick={() => window.history.back()}
+          className="bg-emerald-500 text-white px-2 py-1 rounded uppercase font-black text-sm"
+        >
+          Go back
+        </button>
+        <Link
+          to="/"
+          className="bg-cyan-600 text-white px-2 py-1 rounded uppercase font-black text-sm"
+        >
+          Start Over
+        </Link>
+      </p>
+    </div>
+  )
+}
diff --git a/examples/react/offline-transactions/src/components/TodoDemo.tsx b/examples/react/offline-transactions/src/components/TodoDemo.tsx
new file mode 100644
index 000000000..fcdf088da
--- /dev/null
+++ b/examples/react/offline-transactions/src/components/TodoDemo.tsx
@@ -0,0 +1,272 @@
+import React, { useEffect, useMemo, useState } from 'react'
+import { useLiveQuery } from '@tanstack/react-db'
+import { createTodoActions, todoCollection } from '~/db/todos'
+
+interface TodoDemoProps {
+  title: string
+  description: string
+  storageType: `indexeddb` | `localstorage`
+  offline: any
+}
+
+export function TodoDemo({
+  title,
+  description,
+  storageType,
+  offline,
+}: TodoDemoProps) {
+  const [newTodoText, setNewTodoText] = useState(``)
+  const [error, setError] = useState<string | null>(null)
+  const [isOnline, setIsOnline] = useState(navigator.onLine)
+  const [pendingCount, setPendingCount] = useState(0)
+
+  // Create actions based on offline executor
+  const actions = useMemo(() => createTodoActions(offline), [offline])
+  console.log({ offline, actions })
+
+  // Use live query to get todos
+  const { data: todoList = [], isLoading } = useLiveQuery((q) =>
+    q
+      .from({ todo: todoCollection })
+      .orderBy(({ todo }) => todo.createdAt, `desc`),
+  )
+
+  // Monitor online status
+  useEffect(() => {
+    const handleOnline = () => {
+      setIsOnline(true)
+      if (offline) {
+        offline.notifyOnline()
+      }
+    }
+    const handleOffline = () => setIsOnline(false)
+
+    window.addEventListener(`online`, handleOnline)
+    window.addEventListener(`offline`, handleOffline)
+
+    return () => {
+      window.removeEventListener(`online`, handleOnline)
+      window.removeEventListener(`offline`, handleOffline)
+    }
+  }, [offline])
+
+  // Monitor pending transactions
+  useEffect(() => {
+    if (!offline) return
+
+    const interval = setInterval(() => {
+      setPendingCount(offline.getPendingCount())
+    }, 100)
+
+    return () => clearInterval(interval)
+  }, [offline])
+
+  const handleAddTodo = async () => {
+    if (!newTodoText.trim()) return
+
+    try {
+      setError(null)
+      if (typeof actions.addTodo === `function`) {
+        await actions.addTodo(newTodoText)
+      } else {
+        actions.addTodo(newTodoText)
+      }
+      setNewTodoText(``)
+    } catch (err) {
+      setError(err instanceof Error ? err.message : `Failed to add todo`)
+    }
+  }
+
+  const handleToggleTodo = async (id: string) => {
+    try {
+      setError(null)
+      if (typeof actions.toggleTodo === `function`) {
+        await actions.toggleTodo(id)
+      } else {
+        actions.toggleTodo(id)
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : `Failed to toggle todo`)
+    }
+  }
+
+  const handleDeleteTodo = async (id: string) => {
+    try {
+      setError(null)
+      if (typeof actions.deleteTodo === `function`) {
+        await actions.deleteTodo(id)
+      } else {
+        actions.deleteTodo(id)
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : `Failed to delete todo`)
+    }
+  }
+
+  const handleKeyPress = (e: React.KeyboardEvent) => {
+    if (e.key === `Enter`) {
+      handleAddTodo()
+    }
+  }
+
+  const getStorageIcon = () => {
+    switch (storageType) {
+      case `indexeddb`:
+        return `🗄️`
+      case `localstorage`:
+        return `💾`
+      default:
+        return `💿`
+    }
+  }
+
+  return (
+    <div className="max-w-2xl mx-auto p-6">
+      <div className="bg-white rounded-lg shadow-lg p-6">
+        <div className="flex items-center gap-3 mb-4">
+          <span className="text-2xl">{getStorageIcon()}</span>
+          <div>
+            <h2 className="text-2xl font-bold text-gray-900">{title}</h2>
+            <p className="text-gray-600">{description}</p>
+          </div>
+        </div>
+
+        {/* Status indicators */}
+        <div className="flex flex-wrap gap-4 mb-6 text-sm">
+          <div
+            className={`flex items-center gap-2 px-3 py-1 rounded-full ${
+              isOnline
+                ? `bg-green-100 text-green-800`
+                : `bg-red-100 text-red-800`
+            }`}
+          >
+            <div
+              className={`w-2 h-2 rounded-full ${
+                isOnline ? `bg-green-500` : `bg-red-500`
+              }`}
+            />
+            {isOnline ? `Online` : `Offline`}
+          </div>
+
+          <div
+            className={`flex items-center gap-2 px-3 py-1 rounded-full ${
+              offline?.isOfflineEnabled
+                ? `bg-blue-100 text-blue-800`
+                : `bg-gray-100 text-gray-800`
+            }`}
+          >
+            <div
+              className={`w-2 h-2 rounded-full ${
+                offline?.isOfflineEnabled ? `bg-blue-500` : `bg-gray-500`
+              }`}
+            />
+            {offline?.isOfflineEnabled ? `Offline Mode Enabled` : `Online Only`}
+          </div>
+
+          {pendingCount > 0 && (
+            <div className="flex items-center gap-2 px-3 py-1 rounded-full bg-yellow-100 text-yellow-800">
+              <div className="w-2 h-2 rounded-full bg-yellow-500 animate-pulse" />
+              {pendingCount} pending sync{pendingCount !== 1 ? `s` : ``}
+            </div>
+          )}
+        </div>
+
+        {/* Error display */}
+        {error && (
+          <div className="mb-4 p-3 bg-red-100 border border-red-300 rounded-md">
+            <p className="text-red-700 text-sm">{error}</p>
+          </div>
+        )}
+
+        {/* Add new todo */}
+        <div className="flex gap-2 mb-6">
+          <input
+            type="text"
+            value={newTodoText}
+            onChange={(e) => setNewTodoText(e.target.value)}
+            onKeyPress={handleKeyPress}
+            placeholder="Add a new todo..."
+            className="flex-1 px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
+            disabled={isLoading}
+          />
+          <button
+            onClick={handleAddTodo}
+            disabled={isLoading || !newTodoText.trim()}
+            className="px-4 py-2 bg-blue-500 text-white rounded-md hover:bg-blue-600 disabled:opacity-50 disabled:cursor-not-allowed"
+          >
+            Add
+          </button>
+        </div>
+
+        {/* Todo list */}
+        <div className="space-y-2">
+          {isLoading && todoList.length === 0 ? (
+            <div className="text-center py-8 text-gray-500">
+              <div className="animate-spin w-6 h-6 border-2 border-blue-500 border-t-transparent rounded-full mx-auto mb-2" />
+              Loading todos...
+            </div>
+          ) : todoList.length === 0 ? (
+            <div className="text-center py-8 text-gray-500">
+              No todos yet. Add one above to get started!
+              <br />
+              <span className="text-xs">
+                Try going offline to see how it works
+              </span>
+            </div>
+          ) : (
+            todoList.map((todo) => {
+              return (
+                <div
+                  key={todo.id}
+                  className="flex items-center gap-3 p-3 border border-gray-200 rounded-md hover:bg-gray-50"
+                >
+                  <button
+                    onClick={() => handleToggleTodo(todo.id)}
+                    className={`w-5 h-5 rounded border-2 flex items-center justify-center ${
+                      todo.completed
+                        ? `bg-green-500 border-green-500 text-white`
+                        : `border-gray-300 hover:border-green-400`
+                    }`}
+                  >
+                    {todo.completed && <span className="text-xs">✓</span>}
+                  </button>
+                  <span
+                    className={`flex-1 ${
+                      todo.completed
+                        ? `line-through text-gray-500`
+                        : `text-gray-900`
+                    }`}
+                  >
+                    {todo.text}
+                  </span>
+                  <span className="text-xs text-gray-400">
+                    {new Date(todo.createdAt).toLocaleDateString()}
+                  </span>
+                  <button
+                    onClick={() => handleDeleteTodo(todo.id)}
+                    className="px-2 py-1 text-red-600 hover:bg-red-50 rounded text-sm"
+                  >
+                    Delete
+                  </button>
+                </div>
+              )
+            })
+          )}
+        </div>
+
+        {/* Instructions */}
+        <div className="mt-6 p-4 bg-gray-50 rounded-md">
+          <h3 className="font-medium text-gray-900 mb-2">Try this:</h3>
+          <ol className="text-sm text-gray-600 space-y-1">
+            <li>1. Add some todos while online</li>
+            <li>3. Add more todos (they'll be stored locally)</li>
+            <li>4. Go back online to see them sync</li>
+            <li>
+              5. Open this page in another tab to test multi-tab coordination
+            </li>
+          </ol>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/examples/react/offline-transactions/src/db/todos.ts b/examples/react/offline-transactions/src/db/todos.ts
new file mode 100644
index 000000000..1d8be0340
--- /dev/null
+++ b/examples/react/offline-transactions/src/db/todos.ts
@@ -0,0 +1,310 @@
+import { createCollection } from '@tanstack/react-db'
+import { queryCollectionOptions } from '@tanstack/query-db-collection'
+import {
+  IndexedDBAdapter,
+  LocalStorageAdapter,
+  startOfflineExecutor,
+} from '@tanstack/offline-transactions'
+import { z } from 'zod'
+import type { PendingMutation } from '@tanstack/db'
+import type { Todo } from '~/utils/todos'
+import { queryClient } from '~/utils/queryClient'
+
+/**
+ * A utility function to fetch data from a URL with built-in retry logic for non-200 responses.
+ *
+ * This function will automatically retry HTTP requests a specified number of times if the initial
+ * fetch fails or returns a non-200 OK status. It uses an exponential backoff strategy to increase
+ * the delay between retries, reducing the load on the server.
+ *
+ * @param url The URL to fetch.
+ * @param options A standard `RequestInit` object for the fetch request. Supports all HTTP methods.
+ * @param retryConfig An object with retry configuration.
+ * @param retryConfig.retries The number of times to retry the request (default: 6).
+ * @param retryConfig.delay The initial delay in milliseconds before the first retry (default: 1000).
+ * @param retryConfig.backoff The backoff multiplier for subsequent retries (default: 2).
+ * @returns A promise that resolves to the `Response` object if the fetch is successful.
+ * @throws An error if the maximum number of retries is exceeded.
+ */
+export async function fetchWithRetry(
+  url: string,
+  options: RequestInit = {},
+  retryConfig: { retries?: number; delay?: number; backoff?: number } = {},
+): Promise<Response> {
+  const { retries = 6, delay = 1000, backoff = 2 } = retryConfig
+
+  // Loop for the specified number of retries
+  for (let i = 0; i <= retries; i++) {
+    try {
+      const response = await fetch(url, options)
+
+      // If the response is OK, return it immediately
+      if (response.ok) {
+        return response
+      }
+
+      // If it's a non-200 response, log the status and prepare to retry
+      console.warn(
+        `Fetch attempt ${i + 1} failed with status: ${response.status}. Retrying...`,
+      )
+
+      // Wait before the next attempt, with exponential backoff
+      if (i < retries) {
+        const currentDelay = delay * Math.pow(backoff, i)
+        await new Promise((resolve) => setTimeout(resolve, currentDelay))
+      }
+    } catch (error) {
+      // Catch network errors and log a message
+      console.error(
+        `Fetch attempt ${i + 1} failed due to a network error:`,
+        error,
+      )
+
+      // Wait before the next attempt, with exponential backoff
+      if (i < retries) {
+        const currentDelay = delay * Math.pow(backoff, i)
+        await new Promise((resolve) => setTimeout(resolve, currentDelay))
+      } else {
+        // If all retries have failed, re-throw the original error
+        throw error
+      }
+    }
+  }
+
+  // If the loop completes without a successful response, throw a final error
+  throw new Error(`Failed to fetch ${url} after ${retries} retries.`)
+}
+
+// Define schema
+const todoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  completed: z.boolean(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+})
+
+// Create the todo collection
+export const todoCollection = createCollection(
+  queryCollectionOptions({
+    queryClient,
+    queryKey: [`todos`],
+    queryFn: async (): Promise<Array<Todo>> => {
+      const response = await fetchWithRetry(`/api/todos`)
+      if (!response.ok) {
+        throw new Error(`Failed to fetch todos`)
+      }
+      const data = await response.json()
+      const res = data.map((todo: any) => ({
+        ...todo,
+        createdAt: new Date(todo.createdAt),
+        updatedAt: new Date(todo.updatedAt),
+      }))
+      return res
+    },
+    getKey: (item) => item.id,
+    schema: todoSchema,
+  }),
+)
+
+// API client functions
+export const todoAPI = {
+  async syncTodos({
+    transaction,
+    idempotencyKey,
+  }: {
+    transaction: { mutations: Array<PendingMutation> }
+    idempotencyKey: string
+  }) {
+    const mutations = transaction.mutations
+
+    console.log(`sync todos`, mutations[0].changes, mutations[0].original.text)
+    for (const mutation of mutations) {
+      try {
+        switch (mutation.type) {
+          case `insert`: {
+            const todoData = mutation.modified as Todo
+            const response = await fetchWithRetry(`/api/todos`, {
+              method: `POST`,
+              headers: {
+                'Content-Type': `application/json`,
+                'Idempotency-Key': idempotencyKey,
+              },
+              body: JSON.stringify({
+                text: todoData.text,
+                completed: todoData.completed,
+              }),
+            })
+
+            if (!response.ok) {
+              throw new Error(`Failed to sync insert: ${response.statusText}`)
+            }
+            break
+          }
+
+          case `update`: {
+            const todoData = mutation.modified as Partial<Todo>
+            const response = await fetch(
+              `/api/todos/${(mutation.modified as Todo).id}`,
+              {
+                method: `PUT`,
+                headers: {
+                  'Content-Type': `application/json`,
+                  'Idempotency-Key': idempotencyKey,
+                },
+                body: JSON.stringify({
+                  text: todoData.text,
+                  completed: todoData.completed,
+                }),
+              },
+            )
+
+            if (!response.ok) {
+              throw new Error(`Failed to sync update: ${response.statusText}`)
+            }
+            break
+          }
+
+          case `delete`: {
+            const response = await fetchWithRetry(
+              `/api/todos/${(mutation.original as Todo).id}`,
+              {
+                method: `DELETE`,
+                headers: {
+                  'Idempotency-Key': idempotencyKey,
+                },
+              },
+            )
+
+            if (!response.ok) {
+              throw new Error(`Failed to sync delete: ${response.statusText}`)
+            }
+            break
+          }
+        }
+      } catch (error) {
+        console.error(`Sync error for mutation:`, mutation, error)
+        throw error
+      }
+    }
+    const start = performance.now()
+    console.time(`refresh collection ${start}`)
+    await todoCollection.utils.refetch()
+    console.timeEnd(`refresh collection ${start}`)
+  },
+}
+
+// Helper functions to create offline actions
+export function createTodoActions(offline: any) {
+  const addTodoAction = offline?.createOfflineAction({
+    mutationFnName: `syncTodos`,
+    onMutate: (text: string) => {
+      const newTodo = {
+        id: crypto.randomUUID(),
+        text: text.trim(),
+        completed: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }
+      todoCollection.insert(newTodo)
+      return newTodo
+    },
+  })
+
+  const toggleTodoAction = offline?.createOfflineAction({
+    mutationFnName: `syncTodos`,
+    onMutate: (id: string) => {
+      const todo = todoCollection.get(id)
+      if (!todo) return
+      todoCollection.update(id, (draft) => {
+        draft.completed = !draft.completed
+        draft.updatedAt = new Date()
+      })
+      return todo
+    },
+  })
+
+  const deleteTodoAction = offline?.createOfflineAction({
+    mutationFnName: `syncTodos`,
+    onMutate: (id: string) => {
+      const todo = todoCollection.get(id)
+      if (todo) {
+        todoCollection.delete(id)
+      }
+      return todo
+    },
+  })
+
+  console.log(`creating offline actions`)
+
+  return {
+    addTodo: addTodoAction,
+    toggleTodo: toggleTodoAction,
+    deleteTodo: deleteTodoAction,
+  }
+}
+
+// IndexedDB offline executor
+export async function createIndexedDBOfflineExecutor() {
+  const executor = startOfflineExecutor({
+    collections: { todos: todoCollection },
+    storage: new IndexedDBAdapter(`offline-todos-indexeddb`, `transactions`),
+    mutationFns: {
+      syncTodos: todoAPI.syncTodos,
+    },
+    onLeadershipChange: (isLeader) => {
+      console.log({ isLeader })
+      if (!isLeader) {
+        console.warn(`Running in online-only mode (another tab is the leader)`)
+      }
+    },
+    onStorageFailure: (diagnostic) => {
+      console.warn(
+        `Storage initialization failed - running in online-only mode:`,
+        {
+          code: diagnostic.code,
+          message: diagnostic.message,
+          error: diagnostic.error,
+        },
+      )
+    },
+  })
+
+  // Log diagnostic information
+  console.log(`Offline executor mode:`, executor.mode)
+  console.log(`Storage diagnostic:`, executor.storageDiagnostic)
+
+  return executor
+}
+
+// localStorage offline executor
+export async function createLocalStorageOfflineExecutor() {
+  const executor = startOfflineExecutor({
+    collections: { todos: todoCollection },
+    storage: new LocalStorageAdapter(`offline-todos-ls:`),
+    mutationFns: {
+      syncTodos: todoAPI.syncTodos,
+    },
+    onLeadershipChange: (isLeader) => {
+      if (!isLeader) {
+        console.warn(`Running in online-only mode (another tab is the leader)`)
+      }
+    },
+    onStorageFailure: (diagnostic) => {
+      console.warn(
+        `Storage initialization failed - running in online-only mode:`,
+        {
+          code: diagnostic.code,
+          message: diagnostic.message,
+          error: diagnostic.error,
+        },
+      )
+    },
+  })
+
+  // Log diagnostic information
+  console.log(`Offline executor mode:`, executor.mode)
+  console.log(`Storage diagnostic:`, executor.storageDiagnostic)
+
+  return executor
+}
diff --git a/examples/react/offline-transactions/src/routeTree.gen.ts b/examples/react/offline-transactions/src/routeTree.gen.ts
new file mode 100644
index 000000000..d594674fe
--- /dev/null
+++ b/examples/react/offline-transactions/src/routeTree.gen.ts
@@ -0,0 +1,104 @@
+/* eslint-disable */
+
+// @ts-nocheck
+
+// noinspection JSUnusedGlobalSymbols
+
+// This file was automatically generated by TanStack Router.
+// You should NOT make any changes in this file as it will be overwritten.
+// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
+
+import { Route as rootRouteImport } from './routes/__root'
+import { Route as LocalstorageRouteImport } from './routes/localstorage'
+import { Route as IndexeddbRouteImport } from './routes/indexeddb'
+import { Route as IndexRouteImport } from './routes/index'
+
+const LocalstorageRoute = LocalstorageRouteImport.update({
+  id: '/localstorage',
+  path: '/localstorage',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const IndexeddbRoute = IndexeddbRouteImport.update({
+  id: '/indexeddb',
+  path: '/indexeddb',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const IndexRoute = IndexRouteImport.update({
+  id: '/',
+  path: '/',
+  getParentRoute: () => rootRouteImport,
+} as any)
+
+export interface FileRoutesByFullPath {
+  '/': typeof IndexRoute
+  '/indexeddb': typeof IndexeddbRoute
+  '/localstorage': typeof LocalstorageRoute
+}
+export interface FileRoutesByTo {
+  '/': typeof IndexRoute
+  '/indexeddb': typeof IndexeddbRoute
+  '/localstorage': typeof LocalstorageRoute
+}
+export interface FileRoutesById {
+  __root__: typeof rootRouteImport
+  '/': typeof IndexRoute
+  '/indexeddb': typeof IndexeddbRoute
+  '/localstorage': typeof LocalstorageRoute
+}
+export interface FileRouteTypes {
+  fileRoutesByFullPath: FileRoutesByFullPath
+  fullPaths: '/' | '/indexeddb' | '/localstorage'
+  fileRoutesByTo: FileRoutesByTo
+  to: '/' | '/indexeddb' | '/localstorage'
+  id: '__root__' | '/' | '/indexeddb' | '/localstorage'
+  fileRoutesById: FileRoutesById
+}
+export interface RootRouteChildren {
+  IndexRoute: typeof IndexRoute
+  IndexeddbRoute: typeof IndexeddbRoute
+  LocalstorageRoute: typeof LocalstorageRoute
+}
+
+declare module '@tanstack/react-router' {
+  interface FileRoutesByPath {
+    '/localstorage': {
+      id: '/localstorage'
+      path: '/localstorage'
+      fullPath: '/localstorage'
+      preLoaderRoute: typeof LocalstorageRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/indexeddb': {
+      id: '/indexeddb'
+      path: '/indexeddb'
+      fullPath: '/indexeddb'
+      preLoaderRoute: typeof IndexeddbRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/': {
+      id: '/'
+      path: '/'
+      fullPath: '/'
+      preLoaderRoute: typeof IndexRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+  }
+}
+
+const rootRouteChildren: RootRouteChildren = {
+  IndexRoute: IndexRoute,
+  IndexeddbRoute: IndexeddbRoute,
+  LocalstorageRoute: LocalstorageRoute,
+}
+export const routeTree = rootRouteImport
+  ._addFileChildren(rootRouteChildren)
+  ._addFileTypes<FileRouteTypes>()
+
+import type { getRouter } from './router.tsx'
+import type { createStart } from '@tanstack/react-start'
+declare module '@tanstack/react-start' {
+  interface Register {
+    ssr: true
+    router: Awaited<ReturnType<typeof getRouter>>
+  }
+}
diff --git a/examples/react/offline-transactions/src/router.tsx b/examples/react/offline-transactions/src/router.tsx
new file mode 100644
index 000000000..d5579a802
--- /dev/null
+++ b/examples/react/offline-transactions/src/router.tsx
@@ -0,0 +1,22 @@
+import { createRouter as createTanStackRouter } from '@tanstack/react-router'
+import { routeTree } from './routeTree.gen'
+import { DefaultCatchBoundary } from './components/DefaultCatchBoundary'
+import { NotFound } from './components/NotFound'
+
+export function createRouter() {
+  const router = createTanStackRouter({
+    routeTree,
+    defaultPreload: `intent`,
+    defaultErrorComponent: DefaultCatchBoundary,
+    defaultNotFoundComponent: () => <NotFound />,
+    scrollRestoration: true,
+  })
+
+  return router
+}
+
+declare module '@tanstack/react-router' {
+  interface Register {
+    router: ReturnType<typeof createRouter>
+  }
+}
diff --git a/examples/react/offline-transactions/src/routes/__root.tsx b/examples/react/offline-transactions/src/routes/__root.tsx
new file mode 100644
index 000000000..89588bacb
--- /dev/null
+++ b/examples/react/offline-transactions/src/routes/__root.tsx
@@ -0,0 +1,124 @@
+/// <reference types="vite/client" />
+import {
+  HeadContent,
+  Link,
+  Scripts,
+  createRootRoute,
+} from '@tanstack/react-router'
+import { TanStackRouterDevtools } from '@tanstack/react-router-devtools'
+import { QueryClientProvider } from '@tanstack/react-query'
+import * as React from 'react'
+import { DefaultCatchBoundary } from '~/components/DefaultCatchBoundary'
+import { NotFound } from '~/components/NotFound'
+import appCss from '~/styles/app.css?url'
+import { seo } from '~/utils/seo'
+import { queryClient } from '~/utils/queryClient'
+
+export const Route = createRootRoute({
+  head: () => ({
+    meta: [
+      {
+        charSet: `utf-8`,
+      },
+      {
+        name: `viewport`,
+        content: `width=device-width, initial-scale=1`,
+      },
+      ...seo({
+        title: `TanStack Start | Type-Safe, Client-First, Full-Stack React Framework`,
+        description: `TanStack Start is a type-safe, client-first, full-stack React framework. `,
+      }),
+    ],
+    links: [
+      { rel: `stylesheet`, href: appCss },
+      {
+        rel: `apple-touch-icon`,
+        sizes: `180x180`,
+        href: `/apple-touch-icon.png`,
+      },
+      {
+        rel: `icon`,
+        type: `image/png`,
+        sizes: `32x32`,
+        href: `/favicon-32x32.png`,
+      },
+      {
+        rel: `icon`,
+        type: `image/png`,
+        sizes: `16x16`,
+        href: `/favicon-16x16.png`,
+      },
+      { rel: `manifest`, href: `/site.webmanifest`, color: `#fffff` },
+      { rel: `icon`, href: `/favicon.ico` },
+    ],
+    scripts: [
+      {
+        src: `/customScript.js`,
+        type: `text/javascript`,
+      },
+    ],
+  }),
+  errorComponent: DefaultCatchBoundary,
+  notFoundComponent: () => <NotFound />,
+  shellComponent: RootDocument,
+})
+
+function RootDocument({ children }: { children: React.ReactNode }) {
+  return (
+    <html>
+      <head>
+        <HeadContent />
+      </head>
+      <body>
+        <QueryClientProvider client={queryClient}>
+          <div className="bg-white shadow-sm border-b">
+            <div className="max-w-4xl mx-auto px-6 py-4">
+              <div className="flex items-center justify-between">
+                <div className="flex items-center gap-2">
+                  <span className="text-2xl">⚡</span>
+                  <span className="text-xl font-bold text-gray-900">
+                    TanStack Offline Transactions
+                  </span>
+                </div>
+                <div className="flex gap-6 text-sm">
+                  <Link
+                    to="/"
+                    activeProps={{
+                      className: `font-bold text-blue-600`,
+                    }}
+                    activeOptions={{ exact: true }}
+                    className="text-gray-600 hover:text-gray-900"
+                  >
+                    Home
+                  </Link>
+                  <Link
+                    to="/indexeddb"
+                    activeProps={{
+                      className: `font-bold text-blue-600`,
+                    }}
+                    className="text-gray-600 hover:text-gray-900"
+                  >
+                    🗄️ IndexedDB
+                  </Link>
+                  <Link
+                    to="/localstorage"
+                    activeProps={{
+                      className: `font-bold text-blue-600`,
+                    }}
+                    className="text-gray-600 hover:text-gray-900"
+                  >
+                    💾 localStorage
+                  </Link>
+                </div>
+              </div>
+            </div>
+          </div>
+          <hr />
+          {children}
+          <TanStackRouterDevtools position="bottom-right" />
+        </QueryClientProvider>
+        <Scripts />
+      </body>
+    </html>
+  )
+}
diff --git a/examples/react/offline-transactions/src/routes/api/todos.$todoId.ts b/examples/react/offline-transactions/src/routes/api/todos.$todoId.ts
new file mode 100644
index 000000000..21b293645
--- /dev/null
+++ b/examples/react/offline-transactions/src/routes/api/todos.$todoId.ts
@@ -0,0 +1,80 @@
+import { createServerFileRoute } from '@tanstack/react-start/server'
+import { json } from '@tanstack/react-start'
+import type { TodoUpdate } from '~/utils/todos'
+import { todoService } from '~/utils/todos'
+
+export const ServerRoute = createServerFileRoute(`/api/todos/$todoId`).methods({
+  GET: async ({ params, request }) => {
+    console.info(`GET /api/todos/${params.todoId} @`, request.url)
+
+    try {
+      const todo = await todoService.withDelay(() => {
+        todoService.simulateFailure(0.1)
+        return todoService.getById(params.todoId)
+      })
+
+      if (!todo) {
+        return json({ error: `Todo not found` }, { status: 404 })
+      }
+
+      return json(todo)
+    } catch (error) {
+      console.error(`Error fetching todo:`, error)
+      return json({ error: `Failed to fetch todo` }, { status: 500 })
+    }
+  },
+
+  PUT: async ({ params, request }) => {
+    console.info(`PUT /api/todos/${params.todoId} @`, request.url)
+
+    try {
+      const body = (await request.json()) as TodoUpdate
+
+      const todo = await todoService.withDelay(() => {
+        todoService.simulateFailure(0.15)
+        return todoService.update(params.todoId, body)
+      })
+
+      if (!todo) {
+        return json({ error: `Todo not found` }, { status: 404 })
+      }
+
+      return json(todo)
+    } catch (error) {
+      console.error(`Error updating todo:`, error)
+      if (error instanceof Error && error.message.includes(`Simulated`)) {
+        return json(
+          { error: `Network error - please try again` },
+          { status: 503 },
+        )
+      }
+      return json({ error: `Failed to update todo` }, { status: 500 })
+    }
+  },
+
+  DELETE: async ({ params, request }) => {
+    console.info(`DELETE /api/todos/${params.todoId} @`, request.url)
+
+    try {
+      const success = await todoService.withDelay(() => {
+        todoService.simulateFailure(0.15)
+        return todoService.delete(params.todoId)
+      })
+
+      if (!success) {
+        return json({ error: `Todo not found` }, { status: 404 })
+      }
+
+      return json({ success: true })
+    } catch (error) {
+      console.error(`Error deleting todo:`, error)
+      if (error instanceof Error && error.message.includes(`Simulated`)) {
+        return json(
+          { error: `Network error - please try again` },
+          { status: 503 },
+        )
+      }
+      return json({ error: `Failed to delete todo` }, { status: 500 })
+    }
+  },
+})
diff --git a/examples/react/offline-transactions/src/routes/api/todos.ts b/examples/react/offline-transactions/src/routes/api/todos.ts
new file mode 100644
index 000000000..8b6d1f8d7
--- /dev/null
+++ b/examples/react/offline-transactions/src/routes/api/todos.ts
@@ -0,0 +1,52 @@
+import { createServerFileRoute } from '@tanstack/react-start/server'
+import { json } from '@tanstack/react-start'
+import type { TodoInput } from '~/utils/todos'
+import { todoService } from '~/utils/todos'
+
+export const ServerRoute = createServerFileRoute(`/api/todos`).methods({
+  GET: async ({ request }) => {
+    console.info(`GET /api/todos @`, request.url)
+
+    try {
+      const todos = await todoService.withDelay(() => {
+        // Occasionally simulate failure for demo
+        todoService.simulateFailure(0.1)
+        return todoService.getAll()
+      })
+
+      return json(todos)
+    } catch (error) {
+      console.error(`Error fetching todos:`, error)
+      return json({ error: `Failed to fetch todos` }, { status: 500 })
+    }
+  },
+
+  POST: async ({ request }) => {
+    console.info(`POST /api/todos @`, request.url)
+
+    try {
+      const body = (await request.json()) as TodoInput
+
+      if (!body.text || body.text.trim() === ``) {
+        return json({ error: `Todo text is required` }, { status: 400 })
+      }
+
+      const todo = await todoService.withDelay(() => {
+        // Occasionally simulate failure for demo
+        todoService.simulateFailure(0.15)
+        return todoService.create(body)
+      })
+
+      return json(todo, { status: 201 })
+    } catch (error) {
+      console.error(`Error creating todo:`, error)
+      if (error instanceof Error && error.message.includes(`Simulated`)) {
+        return json(
+          { error: `Network error - please try again` },
+          { status: 503 },
+        )
+      }
+      return json({ error: `Failed to create todo` }, { status: 500 })
+    }
+  },
+})
diff --git a/examples/react/offline-transactions/src/routes/api/users.$userId.ts b/examples/react/offline-transactions/src/routes/api/users.$userId.ts
new file mode 100644
index 000000000..19426fbbf
--- /dev/null
+++ b/examples/react/offline-transactions/src/routes/api/users.$userId.ts
@@ -0,0 +1,28 @@
+import { createServerFileRoute } from '@tanstack/react-start/server'
+import { json } from '@tanstack/react-start'
+import type { User } from '~/utils/users'
+
+export const ServerRoute = createServerFileRoute(`/api/users/$userId`).methods({
+  GET: async ({ params, request }) => {
+    console.info(`Fetching users by id=${params.userId}... @`, request.url)
+    try {
+      const res = await fetch(
+        `https://jsonplaceholder.typicode.com/users/` + params.userId,
+      )
+      if (!res.ok) {
+        throw new Error(`Failed to fetch user`)
+      }
+
+      const user = (await res.json()) as User
+
+      return json({
+        id: user.id,
+        name: user.name,
+        email: user.email,
+      })
+    } catch (e) {
+      console.error(e)
+      return json({ error: `User not found` }, { status: 404 })
+    }
+  },
+})
diff --git a/examples/react/offline-transactions/src/routes/api/users.ts b/examples/react/offline-transactions/src/routes/api/users.ts
new file mode 100644
index 000000000..b627c2f1f
--- /dev/null
+++ b/examples/react/offline-transactions/src/routes/api/users.ts
@@ -0,0 +1,64 @@
+import {
+  createServerFileRoute,
+  getRequestHeaders,
+} from '@tanstack/react-start/server'
+import { createMiddleware, json } from '@tanstack/react-start'
+import type { User } from '~/utils/users'
+
+const userLoggerMiddleware = createMiddleware({ type: `request` }).server(
+  async ({ next, _request }) => {
+    console.info(`In: /users`)
+    console.info(`Request Headers:`, getRequestHeaders())
+    const result = await next()
+    result.response.headers.set(`x-users`, `true`)
+    console.info(`Out: /users`)
+    return result
+  },
+)
+
+const testParentMiddleware = createMiddleware({ type: `request` }).server(
+  async ({ next, _request }) => {
+    console.info(`In: testParentMiddleware`)
+    const result = await next()
+    result.response.headers.set(`x-test-parent`, `true`)
+    console.info(`Out: testParentMiddleware`)
+    return result
+  },
+)
+
+const testMiddleware = createMiddleware({ type: `request` })
+  .middleware([testParentMiddleware])
+  .server(async ({ next, _request }) => {
+    console.info(`In: testMiddleware`)
+    const result = await next()
+    result.response.headers.set(`x-test`, `true`)
+
+    // if (Math.random() > 0.5) {
+    //   throw new Response(null, {
+    //     status: 302,
+    //     headers: { Location: 'https://www.google.com' },
+    //   })
+    // }
+
+    console.info(`Out: testMiddleware`)
+    return result
+  })
+
+export const ServerRoute = createServerFileRoute(`/api/users`)
+  .middleware([testMiddleware, userLoggerMiddleware, testParentMiddleware])
+  .methods({
+    GET: async ({ request }) => {
+      console.info(`GET /api/users @`, request.url)
+      console.info(`Fetching users... @`, request.url)
+      const res = await fetch(`https://jsonplaceholder.typicode.com/users`)
+      if (!res.ok) {
+        throw new Error(`Failed to fetch users`)
+      }
+
+      const data = (await res.json()) as Array<User>
+
+      const list = data.slice(0, 10)
+
+      return json(list.map((u) => ({ id: u.id, name: u.name, email: u.email })))
+    },
+  })
diff --git a/examples/react/offline-transactions/src/routes/index.tsx b/examples/react/offline-transactions/src/routes/index.tsx
new file mode 100644
index 000000000..6e9141e5d
--- /dev/null
+++ b/examples/react/offline-transactions/src/routes/index.tsx
@@ -0,0 +1,125 @@
+import { Link, createFileRoute } from '@tanstack/react-router'
+
+export const Route = createFileRoute(`/`)({
+  component: Home,
+})
+
+function Home() {
+  return (
+    <div className="min-h-screen bg-gray-100">
+      <div className="max-w-4xl mx-auto py-12 px-6">
+        <div className="text-center mb-12">
+          <h1 className="text-4xl font-bold text-gray-900 mb-4">
+            TanStack Offline Transactions Demo
+          </h1>
+          <p className="text-xl text-gray-600 max-w-2xl mx-auto">
+            Experience offline-first development with automatic data
+            persistence, multi-tab coordination, and seamless sync when
+            connectivity returns.
+          </p>
+        </div>
+
+        <div className="grid md:grid-cols-2 gap-8 mb-12">
+          <Link to="/indexeddb">
+            <div className="bg-white rounded-lg shadow-lg p-6 hover:shadow-xl transition-shadow cursor-pointer group">
+              <div className="flex items-center mb-4">
+                <span className="text-3xl mr-3">🗄️</span>
+                <h2 className="text-2xl font-bold text-gray-900 group-hover:text-blue-600">
+                  IndexedDB Storage
+                </h2>
+              </div>
+              <p className="text-gray-600 mb-4">
+                Persistent offline storage with IndexedDB. Best performance and
+                reliability for offline-first applications.
+              </p>
+              <div className="flex flex-wrap gap-2">
+                <span className="px-2 py-1 bg-green-100 text-green-800 text-xs rounded">
+                  High Storage Limit
+                </span>
+                <span className="px-2 py-1 bg-blue-100 text-blue-800 text-xs rounded">
+                  Structured Data
+                </span>
+                <span className="px-2 py-1 bg-purple-100 text-purple-800 text-xs rounded">
+                  Async API
+                </span>
+              </div>
+            </div>
+          </Link>
+
+          <Link to="/localstorage">
+            <div className="bg-white rounded-lg shadow-lg p-6 hover:shadow-xl transition-shadow cursor-pointer group">
+              <div className="flex items-center mb-4">
+                <span className="text-3xl mr-3">💾</span>
+                <h2 className="text-2xl font-bold text-gray-900 group-hover:text-blue-600">
+                  localStorage Fallback
+                </h2>
+              </div>
+              <p className="text-gray-600 mb-4">
+                Reliable fallback storage using localStorage. Works everywhere
+                but with storage limitations.
+              </p>
+              <div className="flex flex-wrap gap-2">
+                <span className="px-2 py-1 bg-yellow-100 text-yellow-800 text-xs rounded">
+                  Universal Support
+                </span>
+                <span className="px-2 py-1 bg-orange-100 text-orange-800 text-xs rounded">
+                  Sync API
+                </span>
+                <span className="px-2 py-1 bg-red-100 text-red-800 text-xs rounded">
+                  Limited Storage
+                </span>
+              </div>
+            </div>
+          </Link>
+        </div>
+
+        <div className="bg-white rounded-lg shadow-lg p-8">
+          <h2 className="text-2xl font-bold text-gray-900 mb-6">
+            Features Demonstrated
+          </h2>
+          <div className="grid md:grid-cols-2 gap-6">
+            <div>
+              <h3 className="text-lg font-semibold text-gray-800 mb-3">
+                📦 Outbox Pattern
+              </h3>
+              <p className="text-gray-600 text-sm">
+                Mutations are persisted before being applied, ensuring zero data
+                loss during offline periods.
+              </p>
+            </div>
+
+            <div>
+              <h3 className="text-lg font-semibold text-gray-800 mb-3">
+                🔄 Automatic Retry
+              </h3>
+              <p className="text-gray-600 text-sm">
+                Failed operations are retried with exponential backoff when
+                connectivity is restored.
+              </p>
+            </div>
+
+            <div>
+              <h3 className="text-lg font-semibold text-gray-800 mb-3">
+                👥 Multi-tab Coordination
+              </h3>
+              <p className="text-gray-600 text-sm">
+                Leader election ensures only one tab manages offline storage,
+                preventing conflicts.
+              </p>
+            </div>
+
+            <div>
+              <h3 className="text-lg font-semibold text-gray-800 mb-3">
+                ⚡ Optimistic Updates
+              </h3>
+              <p className="text-gray-600 text-sm">
+                UI updates immediately while mutations sync in the background,
+                providing snappy user experience.
+              </p>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/examples/react/offline-transactions/src/routes/indexeddb.tsx b/examples/react/offline-transactions/src/routes/indexeddb.tsx
new file mode 100644
index 000000000..de3b88db9
--- /dev/null
+++ b/examples/react/offline-transactions/src/routes/indexeddb.tsx
@@ -0,0 +1,37 @@
+import { createFileRoute } from '@tanstack/react-router'
+import { useEffect, useState } from 'react'
+import { TodoDemo } from '~/components/TodoDemo'
+import { createIndexedDBOfflineExecutor } from '~/db/todos'
+
+export const Route = createFileRoute(`/indexeddb`)({
+  component: IndexedDBDemo,
+})
+
+function IndexedDBDemo() {
+  const [offline, setOffline] = useState<any>(null)
+
+  useEffect(() => {
+    let offlineExecutor: any
+
+    createIndexedDBOfflineExecutor().then((executor) => {
+      offlineExecutor = executor
+      console.log({ offlineExecutor })
+      setOffline(executor)
+    })
+
+    return () => {
+      offlineExecutor?.dispose()
+    }
+  }, [])
+
+  return (
+    <div className="min-h-screen bg-gray-100 py-8">
+      <TodoDemo
+        title="IndexedDB Storage Demo"
+        description="Persistent offline storage with IndexedDB. Data survives browser restarts and provides the best offline experience."
+        storageType="indexeddb"
+        offline={offline}
+      />
+    </div>
+  )
+}
diff --git a/examples/react/offline-transactions/src/routes/localstorage.tsx b/examples/react/offline-transactions/src/routes/localstorage.tsx
new file mode 100644
index 000000000..91ee02bff
--- /dev/null
+++ b/examples/react/offline-transactions/src/routes/localstorage.tsx
@@ -0,0 +1,36 @@
+import { createFileRoute } from '@tanstack/react-router'
+import { useEffect, useState } from 'react'
+import { TodoDemo } from '~/components/TodoDemo'
+import { createLocalStorageOfflineExecutor } from '~/db/todos'
+
+export const Route = createFileRoute(`/localstorage`)({
+  component: LocalStorageDemo,
+})
+
+function LocalStorageDemo() {
+  const [offline, setOffline] = useState<any>(null)
+
+  useEffect(() => {
+    let offlineExecutor: any
+
+    createLocalStorageOfflineExecutor().then((executor) => {
+      offlineExecutor = executor
+      setOffline(executor)
+    })
+
+    return () => {
+      offlineExecutor?.dispose()
+    }
+  }, [])
+
+  return (
+    <div className="min-h-screen bg-gray-100 py-8">
+      <TodoDemo
+        title="localStorage Storage Demo"
+        description="Fallback offline storage with localStorage. Limited storage but works everywhere."
+        storageType="localstorage"
+        offline={offline}
+      />
+    </div>
+  )
+}
diff --git a/examples/react/offline-transactions/src/styles/app.css b/examples/react/offline-transactions/src/styles/app.css
new file mode 100644
index 000000000..857e5045e
--- /dev/null
+++ b/examples/react/offline-transactions/src/styles/app.css
@@ -0,0 +1,20 @@
+@import 'tailwindcss';
+
+@layer base {
+  html {
+    color-scheme: light dark;
+  }
+
+  * {
+    @apply border-gray-200 dark:border-gray-800;
+  }
+
+  html,
+  body {
+    @apply text-gray-900 bg-gray-50 dark:bg-gray-950 dark:text-gray-200;
+  }
+
+  .using-mouse * {
+    outline: none !important;
+  }
+}
diff --git a/examples/react/offline-transactions/src/utils/loggingMiddleware.tsx b/examples/react/offline-transactions/src/utils/loggingMiddleware.tsx
new file mode 100644
index 000000000..336587007
--- /dev/null
+++ b/examples/react/offline-transactions/src/utils/loggingMiddleware.tsx
@@ -0,0 +1,41 @@
+import { createMiddleware } from '@tanstack/react-start'
+
+const preLogMiddleware = createMiddleware({ type: `function` })
+  .client(async (ctx) => {
+    const clientTime = new Date()
+
+    return ctx.next({
+      context: {
+        clientTime,
+      },
+      sendContext: {
+        clientTime,
+      },
+    })
+  })
+  .server(async (ctx) => {
+    const serverTime = new Date()
+
+    return ctx.next({
+      sendContext: {
+        serverTime,
+        durationToServer:
+          serverTime.getTime() - ctx.context.clientTime.getTime(),
+      },
+    })
+  })
+
+export const logMiddleware = createMiddleware({ type: `function` })
+  .middleware([preLogMiddleware])
+  .client(async (ctx) => {
+    const res = await ctx.next()
+
+    const now = new Date()
+    console.log(`Client Req/Res:`, {
+      duration: now.getTime() - res.context.clientTime.getTime(),
+      durationToServer: res.context.durationToServer,
+      durationFromServer: now.getTime() - res.context.serverTime.getTime(),
+    })
+
+    return res
+  })
diff --git a/examples/react/offline-transactions/src/utils/queryClient.ts b/examples/react/offline-transactions/src/utils/queryClient.ts
new file mode 100644
index 000000000..5ca414ef7
--- /dev/null
+++ b/examples/react/offline-transactions/src/utils/queryClient.ts
@@ -0,0 +1,10 @@
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 1000 * 60 * 5, // 5 minutes
+      gcTime: 1000 * 60 * 30, // 30 minutes
+    },
+  },
+})
diff --git a/examples/react/offline-transactions/src/utils/seo.ts b/examples/react/offline-transactions/src/utils/seo.ts
new file mode 100644
index 000000000..bbbdd34ad
--- /dev/null
+++ b/examples/react/offline-transactions/src/utils/seo.ts
@@ -0,0 +1,33 @@
+export const seo = ({
+  title,
+  description,
+  keywords,
+  image,
+}: {
+  title: string
+  description?: string
+  image?: string
+  keywords?: string
+}) => {
+  const tags = [
+    { title },
+    { name: `description`, content: description },
+    { name: `keywords`, content: keywords },
+    { name: `twitter:title`, content: title },
+    { name: `twitter:description`, content: description },
+    { name: `twitter:creator`, content: `@tannerlinsley` },
+    { name: `twitter:site`, content: `@tannerlinsley` },
+    { name: `og:type`, content: `website` },
+    { name: `og:title`, content: title },
+    { name: `og:description`, content: description },
+    ...(image
+      ? [
+          { name: `twitter:image`, content: image },
+          { name: `twitter:card`, content: `summary_large_image` },
+          { name: `og:image`, content: image },
+        ]
+      : []),
+  ]
+
+  return tags
+}
diff --git a/examples/react/offline-transactions/src/utils/todos.ts b/examples/react/offline-transactions/src/utils/todos.ts
new file mode 100644
index 000000000..419683556
--- /dev/null
+++ b/examples/react/offline-transactions/src/utils/todos.ts
@@ -0,0 +1,92 @@
+export interface Todo {
+  id: string
+  text: string
+  completed: boolean
+  createdAt: Date
+  updatedAt: Date
+}
+
+export interface TodoInput {
+  text: string
+  completed?: boolean
+}
+
+export interface TodoUpdate {
+  text?: string
+  completed?: boolean
+}
+
+// In-memory storage for the demo
+const todosStore = new Map<string, Todo>()
+
+// Helper function to generate IDs
+function generateId(): string {
+  return Math.random().toString(36).substring(2) + Date.now().toString(36)
+}
+
+export const todoService = {
+  getAll(): Array<Todo> {
+    return Array.from(todosStore.values()).sort(
+      (a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+    )
+  },
+
+  getById(id: string): Todo | undefined {
+    return todosStore.get(id)
+  },
+
+  create(input: TodoInput): Todo {
+    const now = new Date()
+    const todo: Todo = {
+      id: generateId(),
+      text: input.text,
+      completed: input.completed ?? false,
+      createdAt: now,
+      updatedAt: now,
+    }
+    todosStore.set(todo.id, todo)
+    return todo
+  },
+
+  update(id: string, updates: TodoUpdate): Todo | null {
+    const existing = todosStore.get(id)
+    if (!existing) {
+      return null
+    }
+
+    const updated: Todo = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date(),
+    }
+    todosStore.set(id, updated)
+    return updated
+  },
+
+  delete(id: string): boolean {
+    return todosStore.delete(id)
+  },
+
+  clear(): void {
+    todosStore.clear()
+  },
+
+  // For demo purposes - simulate network delays
+  async withDelay<T>(fn: () => T, delay = 500): Promise<T> {
+    await new Promise((resolve) => setTimeout(resolve, delay))
+    return fn()
+  },
+
+  // For demo purposes - simulate random failures
+  simulateFailure(probability = 0.2): void {
+    if (Math.random() < probability) {
+      throw new Error(`Simulated network failure`)
+    }
+  },
+}
+
+// Add some initial data for demo
+todoService.create({ text: `Learn TanStack DB` })
+todoService.create({ text: `Build offline-first app` })
+todoService.create({ text: `Test multi-tab coordination`, completed: true })
diff --git a/examples/react/offline-transactions/tsconfig.json b/examples/react/offline-transactions/tsconfig.json
new file mode 100644
index 000000000..3a9fb7cd7
--- /dev/null
+++ b/examples/react/offline-transactions/tsconfig.json
@@ -0,0 +1,22 @@
+{
+  "include": ["**/*.ts", "**/*.tsx"],
+  "compilerOptions": {
+    "strict": true,
+    "esModuleInterop": true,
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "target": "ES2022",
+    "allowJs": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./src/*"]
+    },
+    "noEmit": true
+  }
+}
diff --git a/examples/react/offline-transactions/vite.config.ts b/examples/react/offline-transactions/vite.config.ts
new file mode 100644
index 000000000..402e2d611
--- /dev/null
+++ b/examples/react/offline-transactions/vite.config.ts
@@ -0,0 +1,80 @@
+import path from 'node:path'
+import { tanstackStart } from '@tanstack/react-start/plugin/vite'
+import { defineConfig } from 'vite'
+import tsConfigPaths from 'vite-tsconfig-paths'
+import viteReact from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import chokidar from 'chokidar'
+
+function watchWorkspacePackages() {
+  return {
+    name: `watch-workspace-packages`,
+    configureServer(server: any) {
+      const watchPaths = [
+        path.resolve(__dirname, `../../../packages/db/dist`),
+        path.resolve(__dirname, `../../../packages/offline-transactions/dist`),
+      ]
+
+      console.log(`[watch-workspace] Starting to watch paths:`)
+      watchPaths.forEach((p) => console.log(`  - ${p}`))
+      console.log(`[watch-workspace] Current directory: ${__dirname}`)
+      console.log(`[watch-workspace] Resolved paths:`)
+      watchPaths.forEach((p) => console.log(`  - ${path.resolve(p)}`))
+
+      const watcher = chokidar.watch(watchPaths, {
+        ignored: /node_modules/,
+        persistent: true,
+      })
+
+      watcher.on(`ready`, () => {
+        console.log(
+          `[watch-workspace] Initial scan complete. Watching for changes...`,
+        )
+        const watchedPaths = watcher.getWatched()
+        console.log(`[watch-workspace] Currently watching:`, watchedPaths)
+      })
+
+      watcher.on(`add`, (filePath) => {
+        console.log(`[watch-workspace] File added: ${filePath}`)
+        server.ws.send({
+          type: `full-reload`,
+        })
+      })
+
+      watcher.on(`change`, (filePath) => {
+        console.log(`[watch-workspace] File changed: ${filePath}`)
+        server.ws.send({
+          type: `full-reload`,
+        })
+      })
+
+      watcher.on(`error`, (error) => {
+        console.error(`[watch-workspace] Watcher error:`, error)
+      })
+    },
+  }
+}
+
+export default defineConfig({
+  server: {
+    port: 3000,
+    watch: {
+      ignored: [`!**/node_modules/@tanstack/**`],
+    },
+  },
+  optimizeDeps: {
+    exclude: [`@tanstack/db`, `@tanstack/offline-transactions`],
+  },
+  plugins: [
+    watchWorkspacePackages(),
+    tsConfigPaths({
+      projects: [`./tsconfig.json`],
+    }),
+    tanstackStart({
+      customViteReactPlugin: true,
+      mode: `spa`, // SPA mode for client-side only offline features
+    }),
+    viteReact(),
+    tailwindcss(),
+  ],
+})
diff --git a/examples/react/paced-mutations-demo/CHANGELOG.md b/examples/react/paced-mutations-demo/CHANGELOG.md
new file mode 100644
index 000000000..5364f9eba
--- /dev/null
+++ b/examples/react/paced-mutations-demo/CHANGELOG.md
@@ -0,0 +1,48 @@
+# @tanstack/db-example-paced-mutations-demo
+
+## 0.0.7
+
+### Patch Changes
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+  - @tanstack/react-db@0.1.43
+
+## 0.0.6
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+  - @tanstack/react-db@0.1.42
+
+## 0.0.5
+
+### Patch Changes
+
+- Updated dependencies [[`5b6437b`](https://github.com/TanStack/db/commit/5b6437b5c316740c77b7ab7ebd41565a375c7f2e)]:
+  - @tanstack/react-db@0.1.41
+
+## 0.0.4
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+  - @tanstack/react-db@0.1.40
+
+## 0.0.3
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+  - @tanstack/react-db@0.1.39
+
+## 0.0.2
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+  - @tanstack/react-db@0.1.38
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..c17c2768b
--- /dev/null
+++ b/examples/react/paced-mutations-demo/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@tanstack/db-example-paced-mutations-demo",
+  "version": "0.0.7",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@tanstack/db": "^0.5.24",
+    "@tanstack/react-db": "^0.1.68",
+    "mitt": "^3.0.1",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.2",
+    "typescript": "^5.9.2",
+    "vite": "^7.3.0"
+  }
+}
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..26781446c
--- /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..e315d3e3d
--- /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..950701bda
--- /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..9ffcc6757
--- /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/projects/.env.example b/examples/react/projects/.env.example
index 232094023..6b0e9f5f2 100644
--- a/examples/react/projects/.env.example
+++ b/examples/react/projects/.env.example
@@ -3,4 +3,4 @@
 DATABASE_URL=postgresql://postgres:password@localhost:54321/projects
 
 # Create a secret for better-auth
-BETTER_AUTH_SECRET=
+BETTER_AUTH_SECRET=example-secret-for-development-only
diff --git a/examples/react/projects/README.md b/examples/react/projects/README.md
index 3bfe71853..7a122431d 100644
--- a/examples/react/projects/README.md
+++ b/examples/react/projects/README.md
@@ -78,7 +78,7 @@ Now that you have two routes you can use a `Link` component to navigate between
 To use SPA (Single Page Application) navigation you will need to import the `Link` component from `@tanstack/react-router`.
 
 ```tsx
-import { Link } from "@tanstack/react-router"
+import { Link } from '@tanstack/react-router'
 ```
 
 Then anywhere in your JSX you can use it like so:
@@ -98,10 +98,10 @@ In the File Based Routing setup the layout is located in `src/routes/__root.tsx`
 Here is an example layout that includes a header:
 
 ```tsx
-import { Outlet, createRootRoute } from "@tanstack/react-router"
-import { TanStackRouterDevtools } from "@tanstack/react-router-devtools"
+import { Outlet, createRootRoute } from '@tanstack/react-router'
+import { TanStackRouterDevtools } from '@tanstack/react-router-devtools'
 
-import { Link } from "@tanstack/react-router"
+import { Link } from '@tanstack/react-router'
 
 export const Route = createRootRoute({
   component: () => (
@@ -132,9 +132,9 @@ For example:
 ```tsx
 const peopleRoute = createRoute({
   getParentRoute: () => rootRoute,
-  path: "/people",
+  path: '/people',
   loader: async () => {
-    const response = await fetch("https://swapi.dev/api/people")
+    const response = await fetch('https://swapi.dev/api/people')
     return response.json() as Promise<{
       results: {
         name: string
@@ -180,16 +180,16 @@ Built on a TypeScript implementation of differential dataflow, TanStack DB provi
 This example uses Query Collections for server-state synchronization with tRPC:
 
 ```tsx
-import { createCollection } from "@tanstack/react-db"
-import { queryCollectionOptions } from "@tanstack/query-db-collection"
-import { QueryClient } from "@tanstack/query-core"
+import { createCollection } from '@tanstack/react-db'
+import { queryCollectionOptions } from '@tanstack/query-db-collection'
+import { QueryClient } from '@tanstack/query-core'
 
 const queryClient = new QueryClient()
 
 export const todoCollection = createCollection(
   queryCollectionOptions<Todo>({
-    id: "todos",
-    queryKey: ["todos"],
+    id: 'todos',
+    queryKey: ['todos'],
     queryFn: async () => {
       const todos = await trpc.todos.getAll.query()
       return todos.map((todo) => ({
@@ -224,7 +224,7 @@ const AddTodo = () => {
       onClick={() =>
         todoCollection.insert({
           id: crypto.randomUUID(),
-          text: "🔥 Make app faster",
+          text: '🔥 Make app faster',
           completed: false,
         })
       }
@@ -238,7 +238,7 @@ const AddTodo = () => {
 Use live queries to read data reactively across collections:
 
 ```tsx
-import { useLiveQuery } from "@tanstack/react-db"
+import { useLiveQuery } from '@tanstack/react-db'
 
 const Todos = () => {
   // Read data using live queries with cross-collection joins
@@ -246,12 +246,12 @@ const Todos = () => {
     query
       .from({ t: todoCollection })
       .join({
-        type: "inner",
+        type: 'inner',
         from: { l: listCollection },
         on: [`@l.id`, `=`, `@t.list_id`],
       })
-      .where("@l.active", "=", true)
-      .select("@t.id", "@t.text", "@t.status", "@l.name")
+      .where('@l.active', '=', true)
+      .select('@t.id', '@t.text', '@t.status', '@l.name')
   )
 
   return (
diff --git a/examples/react/projects/docker-compose.yaml b/examples/react/projects/docker-compose.yaml
index 6da89ad48..42a8aca0d 100644
--- a/examples/react/projects/docker-compose.yaml
+++ b/examples/react/projects/docker-compose.yaml
@@ -1,5 +1,5 @@
-version: "3.3"
-name: "tanstack-start-db-projects"
+version: '3.3'
+name: 'tanstack-start-db-projects'
 
 services:
   postgres:
diff --git a/examples/react/projects/drizzle.config.ts b/examples/react/projects/drizzle.config.ts
index 6a6f388fd..30ae9a282 100644
--- a/examples/react/projects/drizzle.config.ts
+++ b/examples/react/projects/drizzle.config.ts
@@ -1,5 +1,5 @@
-import "dotenv/config"
-import { defineConfig } from "drizzle-kit"
+import 'dotenv/config'
+import { defineConfig } from 'drizzle-kit'
 
 export default defineConfig({
   out: `./src/db/out`,
diff --git a/examples/react/projects/eslint.config.mjs b/examples/react/projects/eslint.config.mjs
index e3c217b91..29a94ce29 100644
--- a/examples/react/projects/eslint.config.mjs
+++ b/examples/react/projects/eslint.config.mjs
@@ -1,19 +1,19 @@
-import js from "@eslint/js"
-import tsParser from "@typescript-eslint/parser"
-import tsPlugin from "@typescript-eslint/eslint-plugin"
-import reactPlugin from "eslint-plugin-react"
-import prettierPlugin from "eslint-plugin-prettier"
-import prettierConfig from "eslint-config-prettier"
-import globals from "globals"
-import { includeIgnoreFile } from "@eslint/compat"
-import { fileURLToPath } from "url"
+import js from '@eslint/js'
+import tsParser from '@typescript-eslint/parser'
+import tsPlugin from '@typescript-eslint/eslint-plugin'
+import reactPlugin from 'eslint-plugin-react'
+import prettierPlugin from 'eslint-plugin-prettier'
+import prettierConfig from 'eslint-config-prettier'
+import globals from 'globals'
+import { includeIgnoreFile } from '@eslint/compat'
+import { fileURLToPath } from 'url'
 
-const gitignorePath = fileURLToPath(new URL(".gitignore", import.meta.url))
+const gitignorePath = fileURLToPath(new URL('.gitignore', import.meta.url))
 
 export default [
-  includeIgnoreFile(gitignorePath, "Imported .gitignore patterns"),
+  includeIgnoreFile(gitignorePath, 'Imported .gitignore patterns'),
   {
-    files: ["src/**/*.{js,jsx,ts,tsx,mjs}"],
+    files: ['src/**/*.{js,jsx,ts,tsx,mjs}'],
     languageOptions: {
       ecmaVersion: 2022,
       sourceType: `module`,
@@ -35,7 +35,7 @@ export default [
       },
     },
     plugins: {
-      "@typescript-eslint": tsPlugin,
+      '@typescript-eslint': tsPlugin,
       react: reactPlugin,
       prettier: prettierPlugin,
     },
@@ -44,12 +44,12 @@ export default [
       ...tsPlugin.configs.recommended.rules,
       ...reactPlugin.configs.recommended.rules,
       ...prettierConfig.rules,
-      "prettier/prettier": `error`,
-      "react/react-in-jsx-scope": `off`,
-      "react/jsx-uses-react": `off`,
-      "no-undef": `off`,
-      "@typescript-eslint/no-undef": "off",
-      "@typescript-eslint/no-unused-vars": [
+      'prettier/prettier': `error`,
+      'react/react-in-jsx-scope': `off`,
+      'react/jsx-uses-react': `off`,
+      'no-undef': `off`,
+      '@typescript-eslint/no-undef': 'off',
+      '@typescript-eslint/no-unused-vars': [
         `error`,
         {
           argsIgnorePattern: `^_`,
diff --git a/examples/react/projects/package.json b/examples/react/projects/package.json
index 1b7be2f9e..6aa1dbf1a 100644
--- a/examples/react/projects/package.json
+++ b/examples/react/projects/package.json
@@ -15,52 +15,52 @@
     "format:check": "prettier --check ."
   },
   "dependencies": {
-    "@tailwindcss/vite": "^4.1.14",
-    "@tanstack/query-core": "^5.90.5",
-    "@tanstack/query-db-collection": "^0.2.32",
-    "@tanstack/react-db": "^0.1.33",
-    "@tanstack/react-router": "^1.133.15",
-    "@tanstack/react-router-devtools": "^1.133.15",
+    "@tailwindcss/vite": "^4.1.18",
+    "@tanstack/query-core": "^5.90.16",
+    "@tanstack/query-db-collection": "^1.0.21",
+    "@tanstack/react-db": "^0.1.68",
+    "@tanstack/react-router": "^1.144.0",
+    "@tanstack/react-router-devtools": "^1.144.0",
     "@tanstack/react-router-with-query": "^1.130.17",
-    "@tanstack/react-start": "^1.133.15",
-    "@tanstack/router-plugin": "^1.133.15",
-    "@trpc/client": "^11.6.0",
-    "@trpc/server": "^11.6.0",
+    "@tanstack/react-start": "^1.145.5",
+    "@tanstack/router-plugin": "^1.145.4",
+    "@trpc/client": "^11.8.1",
+    "@trpc/server": "^11.8.1",
     "better-auth": "^1.3.26",
     "dotenv": "^17.2.3",
-    "drizzle-orm": "^0.44.6",
+    "drizzle-orm": "^0.45.1",
     "drizzle-zod": "^0.8.3",
     "pg": "^8.16.3",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0",
-    "tailwindcss": "^4.1.14",
-    "vite": "^6.3.5",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "tailwindcss": "^4.1.18",
+    "vite": "^7.3.0",
     "vite-tsconfig-paths": "^5.1.4",
     "zod": "^4.1.11"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.4.0",
-    "@eslint/js": "^9.38.0",
+    "@eslint/compat": "^1.4.1",
+    "@eslint/js": "^9.39.2",
     "@testing-library/dom": "^10.4.1",
-    "@testing-library/react": "^16.3.0",
-    "@types/pg": "^8.15.5",
-    "@types/react": "^19.2.2",
-    "@types/react-dom": "^19.2.2",
-    "@typescript-eslint/eslint-plugin": "^8.46.1",
-    "@typescript-eslint/parser": "^8.46.1",
-    "@vitejs/plugin-react": "^5.0.4",
+    "@testing-library/react": "^16.3.1",
+    "@types/pg": "^8.16.0",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
+    "@vitejs/plugin-react": "^5.1.2",
     "concurrently": "^9.2.1",
-    "drizzle-kit": "^0.31.5",
-    "eslint": "^9.38.0",
+    "drizzle-kit": "^0.31.8",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-react": "^7.37.5",
-    "globals": "^16.4.0",
-    "jsdom": "^27.0.0",
-    "prettier": "^3.6.2",
-    "tsx": "^4.20.6",
+    "globals": "^16.5.0",
+    "jsdom": "^27.4.0",
+    "prettier": "^3.7.4",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.2",
-    "vite": "^6.4.1",
+    "vite": "^7.3.0",
     "vitest": "^3.2.4",
     "web-vitals": "^5.1.0"
   }
diff --git a/examples/react/projects/src/db/auth-schema.ts b/examples/react/projects/src/db/auth-schema.ts
index c0ff607e2..ac78b4658 100644
--- a/examples/react/projects/src/db/auth-schema.ts
+++ b/examples/react/projects/src/db/auth-schema.ts
@@ -1,61 +1,61 @@
-import { pgTable, text, timestamp, boolean } from "drizzle-orm/pg-core"
+import { pgTable, text, timestamp, boolean } from 'drizzle-orm/pg-core'
 
-export const users = pgTable("users", {
-  id: text("id").primaryKey(),
-  name: text("name").notNull(),
-  email: text("email").notNull().unique(),
-  emailVerified: boolean("email_verified")
+export const users = pgTable('users', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  email: text('email').notNull().unique(),
+  emailVerified: boolean('email_verified')
     .$defaultFn(() => false)
     .notNull(),
-  image: text("image"),
-  createdAt: timestamp("created_at")
+  image: text('image'),
+  createdAt: timestamp('created_at')
     .$defaultFn(() => /* @__PURE__ */ new Date())
     .notNull(),
-  updatedAt: timestamp("updated_at")
+  updatedAt: timestamp('updated_at')
     .$defaultFn(() => /* @__PURE__ */ new Date())
     .notNull(),
 })
 
-export const sessions = pgTable("sessions", {
-  id: text("id").primaryKey(),
-  expiresAt: timestamp("expires_at").notNull(),
-  token: text("token").notNull().unique(),
-  createdAt: timestamp("created_at").notNull(),
-  updatedAt: timestamp("updated_at").notNull(),
-  ipAddress: text("ip_address"),
-  userAgent: text("user_agent"),
-  userId: text("user_id")
+export const sessions = pgTable('sessions', {
+  id: text('id').primaryKey(),
+  expiresAt: timestamp('expires_at').notNull(),
+  token: text('token').notNull().unique(),
+  createdAt: timestamp('created_at').notNull(),
+  updatedAt: timestamp('updated_at').notNull(),
+  ipAddress: text('ip_address'),
+  userAgent: text('user_agent'),
+  userId: text('user_id')
     .notNull()
-    .references(() => users.id, { onDelete: "cascade" }),
+    .references(() => users.id, { onDelete: 'cascade' }),
 })
 
-export const accounts = pgTable("accounts", {
-  id: text("id").primaryKey(),
-  accountId: text("account_id").notNull(),
-  providerId: text("provider_id").notNull(),
-  userId: text("user_id")
+export const accounts = pgTable('accounts', {
+  id: text('id').primaryKey(),
+  accountId: text('account_id').notNull(),
+  providerId: text('provider_id').notNull(),
+  userId: text('user_id')
     .notNull()
-    .references(() => users.id, { onDelete: "cascade" }),
-  accessToken: text("access_token"),
-  refreshToken: text("refresh_token"),
-  idToken: text("id_token"),
-  accessTokenExpiresAt: timestamp("access_token_expires_at"),
-  refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
-  scope: text("scope"),
-  password: text("password"),
-  createdAt: timestamp("created_at").notNull(),
-  updatedAt: timestamp("updated_at").notNull(),
+    .references(() => users.id, { onDelete: 'cascade' }),
+  accessToken: text('access_token'),
+  refreshToken: text('refresh_token'),
+  idToken: text('id_token'),
+  accessTokenExpiresAt: timestamp('access_token_expires_at'),
+  refreshTokenExpiresAt: timestamp('refresh_token_expires_at'),
+  scope: text('scope'),
+  password: text('password'),
+  createdAt: timestamp('created_at').notNull(),
+  updatedAt: timestamp('updated_at').notNull(),
 })
 
-export const verifications = pgTable("verifications", {
-  id: text("id").primaryKey(),
-  identifier: text("identifier").notNull(),
-  value: text("value").notNull(),
-  expiresAt: timestamp("expires_at").notNull(),
-  createdAt: timestamp("created_at").$defaultFn(
+export const verifications = pgTable('verifications', {
+  id: text('id').primaryKey(),
+  identifier: text('identifier').notNull(),
+  value: text('value').notNull(),
+  expiresAt: timestamp('expires_at').notNull(),
+  createdAt: timestamp('created_at').$defaultFn(
     () => /* @__PURE__ */ new Date()
   ),
-  updatedAt: timestamp("updated_at").$defaultFn(
+  updatedAt: timestamp('updated_at').$defaultFn(
     () => /* @__PURE__ */ new Date()
   ),
 })
diff --git a/examples/react/projects/src/db/connection.ts b/examples/react/projects/src/db/connection.ts
index 5a8ea8beb..2712baa58 100644
--- a/examples/react/projects/src/db/connection.ts
+++ b/examples/react/projects/src/db/connection.ts
@@ -1,4 +1,4 @@
-import "dotenv/config"
-import { drizzle } from "drizzle-orm/node-postgres"
+import 'dotenv/config'
+import { drizzle } from 'drizzle-orm/node-postgres'
 
 export const db = drizzle(process.env.DATABASE_URL!, { casing: `snake_case` })
diff --git a/examples/react/projects/src/db/out/meta/0000_snapshot.json b/examples/react/projects/src/db/out/meta/0000_snapshot.json
index 1adb2bfa7..37908ea08 100644
--- a/examples/react/projects/src/db/out/meta/0000_snapshot.json
+++ b/examples/react/projects/src/db/out/meta/0000_snapshot.json
@@ -64,12 +64,8 @@
           "name": "projects_owner_id_users_id_fk",
           "tableFrom": "projects",
           "tableTo": "users",
-          "columnsFrom": [
-            "owner_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -147,12 +143,8 @@
           "name": "todos_user_id_users_id_fk",
           "tableFrom": "todos",
           "tableTo": "users",
-          "columnsFrom": [
-            "user_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         },
@@ -160,12 +152,8 @@
           "name": "todos_project_id_projects_id_fk",
           "tableFrom": "todos",
           "tableTo": "projects",
-          "columnsFrom": [
-            "project_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["project_id"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -265,12 +253,8 @@
           "name": "accounts_user_id_users_id_fk",
           "tableFrom": "accounts",
           "tableTo": "users",
-          "columnsFrom": [
-            "user_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -340,12 +324,8 @@
           "name": "sessions_user_id_users_id_fk",
           "tableFrom": "sessions",
           "tableTo": "users",
-          "columnsFrom": [
-            "user_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -355,9 +335,7 @@
         "sessions_token_unique": {
           "name": "sessions_token_unique",
           "nullsNotDistinct": false,
-          "columns": [
-            "token"
-          ]
+          "columns": ["token"]
         }
       },
       "policies": {},
@@ -418,9 +396,7 @@
         "users_email_unique": {
           "name": "users_email_unique",
           "nullsNotDistinct": false,
-          "columns": [
-            "email"
-          ]
+          "columns": ["email"]
         }
       },
       "policies": {},
@@ -488,4 +464,4 @@
     "schemas": {},
     "tables": {}
   }
-}
\ No newline at end of file
+}
diff --git a/examples/react/projects/src/db/out/meta/_journal.json b/examples/react/projects/src/db/out/meta/_journal.json
index 5f5b938e6..55bf81962 100644
--- a/examples/react/projects/src/db/out/meta/_journal.json
+++ b/examples/react/projects/src/db/out/meta/_journal.json
@@ -10,4 +10,4 @@
       "breakpoints": true
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/examples/react/projects/src/db/schema.ts b/examples/react/projects/src/db/schema.ts
index 34df19e6a..cdd205c0a 100644
--- a/examples/react/projects/src/db/schema.ts
+++ b/examples/react/projects/src/db/schema.ts
@@ -5,11 +5,11 @@ import {
   timestamp,
   varchar,
   text,
-} from "drizzle-orm/pg-core"
-import { createSchemaFactory } from "drizzle-zod"
-import { z } from "zod"
-export * from "./auth-schema"
-import { users } from "./auth-schema"
+} from 'drizzle-orm/pg-core'
+import { createSchemaFactory } from 'drizzle-zod'
+import { z } from 'zod'
+export * from './auth-schema'
+import { users } from './auth-schema'
 
 const { createInsertSchema, createSelectSchema, createUpdateSchema } =
   createSchemaFactory({ zodInstance: z })
@@ -18,11 +18,11 @@ export const projectsTable = pgTable(`projects`, {
   id: integer().primaryKey().generatedAlwaysAsIdentity(),
   name: varchar({ length: 255 }).notNull(),
   description: text(),
-  shared_user_ids: text("shared_user_ids").array().notNull().default([]),
+  shared_user_ids: text('shared_user_ids').array().notNull().default([]),
   created_at: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  owner_id: text("owner_id")
+  owner_id: text('owner_id')
     .notNull()
-    .references(() => users.id, { onDelete: "cascade" }),
+    .references(() => users.id, { onDelete: 'cascade' }),
 })
 
 export const todosTable = pgTable(`todos`, {
@@ -30,13 +30,13 @@ export const todosTable = pgTable(`todos`, {
   text: varchar({ length: 500 }).notNull(),
   completed: boolean().notNull().default(false),
   created_at: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  user_id: text("user_id")
+  user_id: text('user_id')
     .notNull()
-    .references(() => users.id, { onDelete: "cascade" }),
-  project_id: integer("project_id")
+    .references(() => users.id, { onDelete: 'cascade' }),
+  project_id: integer('project_id')
     .notNull()
-    .references(() => projectsTable.id, { onDelete: "cascade" }),
-  user_ids: text("user_ids").array().notNull().default([]),
+    .references(() => projectsTable.id, { onDelete: 'cascade' }),
+  user_ids: text('user_ids').array().notNull().default([]),
 })
 
 export const selectProjectSchema = createSelectSchema(projectsTable)
diff --git a/examples/react/projects/src/lib/auth-client.ts b/examples/react/projects/src/lib/auth-client.ts
index 8665c3b11..939114361 100644
--- a/examples/react/projects/src/lib/auth-client.ts
+++ b/examples/react/projects/src/lib/auth-client.ts
@@ -1,2 +1,2 @@
-import { createAuthClient } from "better-auth/react"
+import { createAuthClient } from 'better-auth/react'
 export const authClient = createAuthClient()
diff --git a/examples/react/projects/src/lib/auth.ts b/examples/react/projects/src/lib/auth.ts
index f423c5fdc..22426df53 100644
--- a/examples/react/projects/src/lib/auth.ts
+++ b/examples/react/projects/src/lib/auth.ts
@@ -1,11 +1,11 @@
-import { betterAuth } from "better-auth"
-import { drizzleAdapter } from "better-auth/adapters/drizzle"
-import { db } from "@/db/connection" // your drizzle instance
-import * as schema from "@/db/auth-schema"
+import { betterAuth } from 'better-auth'
+import { drizzleAdapter } from 'better-auth/adapters/drizzle'
+import { db } from '@/db/connection' // your drizzle instance
+import * as schema from '@/db/auth-schema'
 
 export const auth = betterAuth({
   database: drizzleAdapter(db, {
-    provider: "pg",
+    provider: 'pg',
     usePlural: true,
     schema,
     // debugLogs: true,
@@ -13,10 +13,10 @@ export const auth = betterAuth({
   emailAndPassword: {
     enabled: true,
     // Disable signup in production, allow in dev
-    disableSignUp: process.env.NODE_ENV === "production",
-    minPasswordLength: process.env.NODE_ENV === "production" ? 8 : 1,
+    disableSignUp: process.env.NODE_ENV === 'production',
+    minPasswordLength: process.env.NODE_ENV === 'production' ? 8 : 1,
   },
   trustedOrigins: [
-    "http://localhost:5173", // Vite dev server
+    'http://localhost:5173', // Vite dev server
   ],
 })
diff --git a/examples/react/projects/src/lib/collections.ts b/examples/react/projects/src/lib/collections.ts
index 336466dbe..235969dd2 100644
--- a/examples/react/projects/src/lib/collections.ts
+++ b/examples/react/projects/src/lib/collections.ts
@@ -1,20 +1,20 @@
-import { createCollection } from "@tanstack/react-db"
-import { queryCollectionOptions } from "@tanstack/query-db-collection"
-import { QueryClient } from "@tanstack/query-core"
+import { createCollection } from '@tanstack/react-db'
+import { queryCollectionOptions } from '@tanstack/query-db-collection'
+import { QueryClient } from '@tanstack/query-core'
 import {
   selectTodoSchema,
   selectProjectSchema,
   selectUsersSchema,
-} from "@/db/schema"
-import { trpc } from "@/lib/trpc-client"
+} from '@/db/schema'
+import { trpc } from '@/lib/trpc-client'
 
 // Create a query client for query collections
 const queryClient = new QueryClient()
 
 export const usersCollection = createCollection(
   queryCollectionOptions({
-    id: "users",
-    queryKey: ["users"],
+    id: 'users',
+    queryKey: ['users'],
     // Poll for updates every 5 seconds
     refetchInterval: 5000,
     queryFn: async () => {
@@ -32,8 +32,8 @@ export const usersCollection = createCollection(
 )
 export const projectCollection = createCollection(
   queryCollectionOptions({
-    id: "projects",
-    queryKey: ["projects"],
+    id: 'projects',
+    queryKey: ['projects'],
     // Poll for updates every 5 seconds
     refetchInterval: 5000,
     queryFn: async () => {
@@ -78,8 +78,8 @@ export const projectCollection = createCollection(
 
 export const todoCollection = createCollection(
   queryCollectionOptions({
-    id: "todos",
-    queryKey: ["todos"],
+    id: 'todos',
+    queryKey: ['todos'],
     // Poll for updates every 5 seconds
     refetchInterval: 5000,
     queryFn: async () => {
diff --git a/examples/react/projects/src/lib/trpc-client.ts b/examples/react/projects/src/lib/trpc-client.ts
index d03bf6922..11b29a321 100644
--- a/examples/react/projects/src/lib/trpc-client.ts
+++ b/examples/react/projects/src/lib/trpc-client.ts
@@ -1,13 +1,13 @@
-import { createTRPCProxyClient, httpBatchLink } from "@trpc/client"
-import type { AppRouter } from "@/routes/api/trpc/$"
+import { createTRPCProxyClient, httpBatchLink } from '@trpc/client'
+import type { AppRouter } from '@/routes/api/trpc/$'
 
 export const trpc = createTRPCProxyClient<AppRouter>({
   links: [
     httpBatchLink({
-      url: "/api/trpc",
+      url: '/api/trpc',
       async headers() {
         return {
-          cookie: typeof document !== "undefined" ? document.cookie : "",
+          cookie: typeof document !== 'undefined' ? document.cookie : '',
         }
       },
     }),
diff --git a/examples/react/projects/src/lib/trpc.ts b/examples/react/projects/src/lib/trpc.ts
index 8843140d1..98e498464 100644
--- a/examples/react/projects/src/lib/trpc.ts
+++ b/examples/react/projects/src/lib/trpc.ts
@@ -1,6 +1,6 @@
-import { initTRPC, TRPCError } from "@trpc/server"
-import { auth } from "@/lib/auth"
-import { db } from "@/db/connection"
+import { initTRPC, TRPCError } from '@trpc/server'
+import { auth } from '@/lib/auth'
+import { db } from '@/db/connection'
 
 export type Context = {
   session: Awaited<ReturnType<typeof auth.api.getSession>>
@@ -15,7 +15,7 @@ export const middleware = t.middleware
 
 export const isAuthed = middleware(async ({ ctx, next }) => {
   if (!ctx.session?.user) {
-    throw new TRPCError({ code: "UNAUTHORIZED" })
+    throw new TRPCError({ code: 'UNAUTHORIZED' })
   }
   return next({
     ctx: {
diff --git a/examples/react/projects/src/lib/trpc/projects.ts b/examples/react/projects/src/lib/trpc/projects.ts
index fd9de7132..dcf6e7a45 100644
--- a/examples/react/projects/src/lib/trpc/projects.ts
+++ b/examples/react/projects/src/lib/trpc/projects.ts
@@ -1,12 +1,12 @@
-import { router, authedProcedure } from "@/lib/trpc"
-import { z } from "zod"
-import { TRPCError } from "@trpc/server"
-import { eq, and, sql } from "drizzle-orm"
+import { router, authedProcedure } from '@/lib/trpc'
+import { z } from 'zod'
+import { TRPCError } from '@trpc/server'
+import { eq, and, sql } from 'drizzle-orm'
 import {
   projectsTable,
   createProjectSchema,
   updateProjectSchema,
-} from "@/db/schema"
+} from '@/db/schema'
 
 export const projectsRouter = router({
   getAll: authedProcedure.query(async ({ ctx }) => {
@@ -24,8 +24,8 @@ export const projectsRouter = router({
     .mutation(async ({ ctx, input }) => {
       if (input.owner_id !== ctx.session.user.id) {
         throw new TRPCError({
-          code: "FORBIDDEN",
-          message: "You can only create projects you own",
+          code: 'FORBIDDEN',
+          message: 'You can only create projects you own',
         })
       }
 
@@ -58,9 +58,9 @@ export const projectsRouter = router({
 
       if (!updatedItem) {
         throw new TRPCError({
-          code: "NOT_FOUND",
+          code: 'NOT_FOUND',
           message:
-            "Project not found or you do not have permission to update it",
+            'Project not found or you do not have permission to update it',
         })
       }
 
@@ -82,9 +82,9 @@ export const projectsRouter = router({
 
       if (!deletedItem) {
         throw new TRPCError({
-          code: "NOT_FOUND",
+          code: 'NOT_FOUND',
           message:
-            "Project not found or you do not have permission to delete it",
+            'Project not found or you do not have permission to delete it',
         })
       }
 
diff --git a/examples/react/projects/src/lib/trpc/todos.ts b/examples/react/projects/src/lib/trpc/todos.ts
index 127d36cca..d6825804e 100644
--- a/examples/react/projects/src/lib/trpc/todos.ts
+++ b/examples/react/projects/src/lib/trpc/todos.ts
@@ -1,8 +1,8 @@
-import { router, authedProcedure } from "@/lib/trpc"
-import { z } from "zod"
-import { TRPCError } from "@trpc/server"
-import { eq, and, arrayContains } from "drizzle-orm"
-import { todosTable, createTodoSchema, updateTodoSchema } from "@/db/schema"
+import { router, authedProcedure } from '@/lib/trpc'
+import { z } from 'zod'
+import { TRPCError } from '@trpc/server'
+import { eq, and, arrayContains } from 'drizzle-orm'
+import { todosTable, createTodoSchema, updateTodoSchema } from '@/db/schema'
 
 export const todosRouter = router({
   getAll: authedProcedure.query(async ({ ctx }) => {
@@ -44,8 +44,8 @@ export const todosRouter = router({
 
       if (!updatedItem) {
         throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Todo not found or you do not have permission to update it",
+          code: 'NOT_FOUND',
+          message: 'Todo not found or you do not have permission to update it',
         })
       }
 
@@ -67,8 +67,8 @@ export const todosRouter = router({
 
       if (!deletedItem) {
         throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Todo not found or you do not have permission to delete it",
+          code: 'NOT_FOUND',
+          message: 'Todo not found or you do not have permission to delete it',
         })
       }
 
diff --git a/examples/react/projects/src/lib/trpc/users.ts b/examples/react/projects/src/lib/trpc/users.ts
index 86f887753..13c730bdd 100644
--- a/examples/react/projects/src/lib/trpc/users.ts
+++ b/examples/react/projects/src/lib/trpc/users.ts
@@ -1,7 +1,7 @@
-import { router, authedProcedure } from "@/lib/trpc"
-import { z } from "zod"
-import { TRPCError } from "@trpc/server"
-import { users } from "@/db/schema"
+import { router, authedProcedure } from '@/lib/trpc'
+import { z } from 'zod'
+import { TRPCError } from '@trpc/server'
+import { users } from '@/db/schema'
 
 export const usersRouter = router({
   getAll: authedProcedure.query(async ({ ctx }) => {
@@ -11,7 +11,7 @@ export const usersRouter = router({
 
   create: authedProcedure.input(z.any()).mutation(async () => {
     throw new TRPCError({
-      code: "FORBIDDEN",
+      code: 'FORBIDDEN',
       message: "Can't create new users through API",
     })
   }),
@@ -20,7 +20,7 @@ export const usersRouter = router({
     .input(z.object({ id: z.string(), data: z.any() }))
     .mutation(async () => {
       throw new TRPCError({
-        code: "FORBIDDEN",
+        code: 'FORBIDDEN',
         message: "Can't edit users through API",
       })
     }),
@@ -29,7 +29,7 @@ export const usersRouter = router({
     .input(z.object({ id: z.string() }))
     .mutation(async () => {
       throw new TRPCError({
-        code: "FORBIDDEN",
+        code: 'FORBIDDEN',
         message: "Can't delete users through API",
       })
     }),
diff --git a/examples/react/projects/src/router.tsx b/examples/react/projects/src/router.tsx
index e025c0f7f..50504c678 100644
--- a/examples/react/projects/src/router.tsx
+++ b/examples/react/projects/src/router.tsx
@@ -1,9 +1,9 @@
-import { createRouter as createTanstackRouter } from "@tanstack/react-router"
+import { createRouter as createTanstackRouter } from '@tanstack/react-router'
 
 // Import the generated route tree
-import { routeTree } from "./routeTree.gen"
+import { routeTree } from './routeTree.gen'
 
-import "./styles.css"
+import './styles.css'
 
 // Create a new router instance
 export function getRouter() {
diff --git a/examples/react/projects/src/routes/__root.tsx b/examples/react/projects/src/routes/__root.tsx
index bb4aa1c89..477a34019 100644
--- a/examples/react/projects/src/routes/__root.tsx
+++ b/examples/react/projects/src/routes/__root.tsx
@@ -1,13 +1,13 @@
-import * as React from "react"
+import * as React from 'react'
 import {
   HeadContent,
   Outlet,
   Scripts,
   createRootRoute,
-} from "@tanstack/react-router"
-import { TanStackRouterDevtools } from "@tanstack/react-router-devtools"
+} from '@tanstack/react-router'
+import { TanStackRouterDevtools } from '@tanstack/react-router-devtools'
 
-import appCss from "../styles.css?url"
+import appCss from '../styles.css?url'
 
 export const Route = createRootRoute({
   head: () => ({
diff --git a/examples/react/projects/src/routes/_authenticated.tsx b/examples/react/projects/src/routes/_authenticated.tsx
index 749668ea4..c119ed40c 100644
--- a/examples/react/projects/src/routes/_authenticated.tsx
+++ b/examples/react/projects/src/routes/_authenticated.tsx
@@ -1,13 +1,13 @@
-import { useEffect, useState } from "react"
+import { useEffect, useState } from 'react'
 import {
   Link,
   Outlet,
   createFileRoute,
   useNavigate,
-} from "@tanstack/react-router"
-import { useLiveQuery } from "@tanstack/react-db"
-import { authClient } from "@/lib/auth-client"
-import { projectCollection } from "@/lib/collections"
+} from '@tanstack/react-router'
+import { useLiveQuery } from '@tanstack/react-db'
+import { authClient } from '@/lib/auth-client'
+import { projectCollection } from '@/lib/collections'
 
 export const Route = createFileRoute(`/_authenticated`)({
   component: AuthenticatedLayout,
diff --git a/examples/react/projects/src/routes/_authenticated/index.tsx b/examples/react/projects/src/routes/_authenticated/index.tsx
index bc3990cd2..a8f8cb9ab 100644
--- a/examples/react/projects/src/routes/_authenticated/index.tsx
+++ b/examples/react/projects/src/routes/_authenticated/index.tsx
@@ -1,8 +1,8 @@
-import { useEffect } from "react"
-import { createFileRoute, redirect, useNavigate } from "@tanstack/react-router"
-import { useLiveQuery } from "@tanstack/react-db"
-import { projectCollection, todoCollection } from "@/lib/collections"
-import { authClient } from "@/lib/auth-client"
+import { useEffect } from 'react'
+import { createFileRoute, redirect, useNavigate } from '@tanstack/react-router'
+import { useLiveQuery } from '@tanstack/react-db'
+import { projectCollection, todoCollection } from '@/lib/collections'
+import { authClient } from '@/lib/auth-client'
 
 export const Route = createFileRoute(`/_authenticated/`)({
   component: IndexRedirect,
diff --git a/examples/react/projects/src/routes/_authenticated/project/$projectId.tsx b/examples/react/projects/src/routes/_authenticated/project/$projectId.tsx
index 3a648964f..7c3084f23 100644
--- a/examples/react/projects/src/routes/_authenticated/project/$projectId.tsx
+++ b/examples/react/projects/src/routes/_authenticated/project/$projectId.tsx
@@ -1,13 +1,13 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { eq, useLiveQuery } from "@tanstack/react-db"
-import { useState } from "react"
-import type { Todo } from "@/db/schema"
-import { authClient } from "@/lib/auth-client"
+import { createFileRoute } from '@tanstack/react-router'
+import { eq, useLiveQuery } from '@tanstack/react-db'
+import { useState } from 'react'
+import type { Todo } from '@/db/schema'
+import { authClient } from '@/lib/auth-client'
 import {
   projectCollection,
   todoCollection,
   usersCollection,
-} from "@/lib/collections"
+} from '@/lib/collections'
 
 export const Route = createFileRoute(`/_authenticated/project/$projectId`)({
   component: ProjectPage,
diff --git a/examples/react/projects/src/routes/api/auth.ts b/examples/react/projects/src/routes/api/auth.ts
index c8d288f8b..4b3b9bfbf 100644
--- a/examples/react/projects/src/routes/api/auth.ts
+++ b/examples/react/projects/src/routes/api/auth.ts
@@ -1,5 +1,5 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { auth } from "@/lib/auth"
+import { createFileRoute } from '@tanstack/react-router'
+import { auth } from '@/lib/auth'
 
 const serve = ({ request }: { request: Request }) => {
   return auth.handler(request)
diff --git a/examples/react/projects/src/routes/api/trpc/$.ts b/examples/react/projects/src/routes/api/trpc/$.ts
index e7438e56b..eb6071a4a 100644
--- a/examples/react/projects/src/routes/api/trpc/$.ts
+++ b/examples/react/projects/src/routes/api/trpc/$.ts
@@ -1,11 +1,11 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { fetchRequestHandler } from "@trpc/server/adapters/fetch"
-import { router } from "@/lib/trpc"
-import { projectsRouter } from "@/lib/trpc/projects"
-import { todosRouter } from "@/lib/trpc/todos"
-import { usersRouter } from "@/lib/trpc/users"
-import { db } from "@/db/connection"
-import { auth } from "@/lib/auth"
+import { createFileRoute } from '@tanstack/react-router'
+import { fetchRequestHandler } from '@trpc/server/adapters/fetch'
+import { router } from '@/lib/trpc'
+import { projectsRouter } from '@/lib/trpc/projects'
+import { todosRouter } from '@/lib/trpc/todos'
+import { usersRouter } from '@/lib/trpc/users'
+import { db } from '@/db/connection'
+import { auth } from '@/lib/auth'
 
 export const appRouter = router({
   projects: projectsRouter,
diff --git a/examples/react/projects/src/routes/login.tsx b/examples/react/projects/src/routes/login.tsx
index 09512463c..1f2a039c1 100644
--- a/examples/react/projects/src/routes/login.tsx
+++ b/examples/react/projects/src/routes/login.tsx
@@ -1,7 +1,7 @@
-import { useState } from "react"
-import { createFileRoute } from "@tanstack/react-router"
-import type { FormEvent } from "react"
-import { authClient } from "@/lib/auth-client"
+import { useState } from 'react'
+import { createFileRoute } from '@tanstack/react-router'
+import type { FormEvent } from 'react'
+import { authClient } from '@/lib/auth-client'
 
 export const Route = createFileRoute(`/login`)({
   component: Layout,
diff --git a/examples/react/projects/src/start.tsx b/examples/react/projects/src/start.tsx
index de7b170ed..9e8694bab 100644
--- a/examples/react/projects/src/start.tsx
+++ b/examples/react/projects/src/start.tsx
@@ -1,4 +1,4 @@
-import { createStart } from "@tanstack/react-start"
+import { createStart } from '@tanstack/react-start'
 
 export const startInstance = createStart(() => {
   return {
diff --git a/examples/react/projects/src/styles.css b/examples/react/projects/src/styles.css
index 80cb92ada..06f1bca4b 100644
--- a/examples/react/projects/src/styles.css
+++ b/examples/react/projects/src/styles.css
@@ -1,15 +1,15 @@
-@import "tailwindcss";
+@import 'tailwindcss';
 
 body {
   @apply m-0;
   font-family:
-    -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu",
-    "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif;
+    -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;
 }
 
 code {
   font-family:
-    source-code-pro, Menlo, Monaco, Consolas, "Courier New", monospace;
+    source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
 }
diff --git a/examples/react/projects/vite.config.ts b/examples/react/projects/vite.config.ts
index 6708900ed..7307fb0e8 100644
--- a/examples/react/projects/vite.config.ts
+++ b/examples/react/projects/vite.config.ts
@@ -1,8 +1,8 @@
-import { defineConfig } from "vite"
-import { tanstackStart } from "@tanstack/react-start/plugin/vite"
-import viteTsConfigPaths from "vite-tsconfig-paths"
-import tailwindcss from "@tailwindcss/vite"
-import react from "@vitejs/plugin-react"
+import { defineConfig } from 'vite'
+import { tanstackStart } from '@tanstack/react-start/plugin/vite'
+import viteTsConfigPaths from 'vite-tsconfig-paths'
+import tailwindcss from '@tailwindcss/vite'
+import react from '@vitejs/plugin-react'
 
 const config = defineConfig({
   plugins: [
diff --git a/examples/react/todo/CHANGELOG.md b/examples/react/todo/CHANGELOG.md
index 8c3c7da0a..7ce4bd1d5 100644
--- a/examples/react/todo/CHANGELOG.md
+++ b/examples/react/todo/CHANGELOG.md
@@ -1,5 +1,126 @@
 # examples/react/todo
 
+## 0.1.24
+
+### Patch Changes
+
+- Updated dependencies [[`1afb027`](https://github.com/TanStack/db/commit/1afb027dbf3e34292a418fc549f799c4e0ce8922), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`58f119a`](https://github.com/TanStack/db/commit/58f119ac4f1b05dbfff8617f59f53973abdb1920), [`8f746db`](https://github.com/TanStack/db/commit/8f746db61ff160eae9834e0b9d83c40ef315ae12), [`7aceffa`](https://github.com/TanStack/db/commit/7aceffa46e746cff3dee51230dd2f9e09cb24137)]:
+  - @tanstack/electric-db-collection@0.2.0
+  - @tanstack/query-db-collection@1.0.0
+  - @tanstack/react-db@0.1.44
+  - @tanstack/trailbase-db-collection@0.1.44
+
+## 0.1.23
+
+### Patch Changes
+
+- Updated dependencies [[`503f0b2`](https://github.com/TanStack/db/commit/503f0b2311f3054cda65b10b933d34b03eef6b04), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/query-db-collection@0.3.0
+  - @tanstack/electric-db-collection@0.1.44
+  - @tanstack/react-db@0.1.43
+  - @tanstack/trailbase-db-collection@0.1.42
+
+## 0.1.22
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/electric-db-collection@0.1.43
+  - @tanstack/query-db-collection@0.2.42
+  - @tanstack/react-db@0.1.42
+  - @tanstack/trailbase-db-collection@0.1.41
+
+## 0.1.21
+
+### Patch Changes
+
+- Updated dependencies [[`5b6437b`](https://github.com/TanStack/db/commit/5b6437b5c316740c77b7ab7ebd41565a375c7f2e)]:
+  - @tanstack/react-db@0.1.41
+
+## 0.1.20
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/electric-db-collection@0.1.42
+  - @tanstack/query-db-collection@0.2.41
+  - @tanstack/react-db@0.1.40
+  - @tanstack/trailbase-db-collection@0.1.40
+
+## 0.1.19
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/electric-db-collection@0.1.41
+  - @tanstack/query-db-collection@0.2.40
+  - @tanstack/react-db@0.1.39
+  - @tanstack/trailbase-db-collection@0.1.39
+
+## 0.1.18
+
+### Patch Changes
+
+- Updated dependencies [[`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/react-db@0.1.38
+  - @tanstack/electric-db-collection@0.1.40
+  - @tanstack/query-db-collection@0.2.39
+  - @tanstack/trailbase-db-collection@0.1.38
+
+## 0.1.17
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/electric-db-collection@0.1.39
+  - @tanstack/query-db-collection@0.2.38
+  - @tanstack/react-db@0.1.37
+  - @tanstack/trailbase-db-collection@0.1.37
+
+## 0.1.16
+
+### Patch Changes
+
+- Updated dependencies [[`c2a5c28`](https://github.com/TanStack/db/commit/c2a5c28919733ee33cbd57903d3ed81656a0d842)]:
+  - @tanstack/query-db-collection@0.2.37
+
+## 0.1.15
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/electric-db-collection@0.1.38
+  - @tanstack/query-db-collection@0.2.36
+  - @tanstack/react-db@0.1.36
+  - @tanstack/trailbase-db-collection@0.1.36
+
+## 0.1.14
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/electric-db-collection@0.1.37
+  - @tanstack/query-db-collection@0.2.35
+  - @tanstack/react-db@0.1.35
+  - @tanstack/trailbase-db-collection@0.1.35
+
+## 0.1.13
+
+### Patch Changes
+
+- Updated dependencies [[`16dbfe3`](https://github.com/TanStack/db/commit/16dbfe34d5a5c075211453566f3a0453aa0ee76f), [`5950583`](https://github.com/TanStack/db/commit/595058384c88730f325ac23415bdb0643eea89fa)]:
+  - @tanstack/query-db-collection@0.2.34
+
+## 0.1.12
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/electric-db-collection@0.1.36
+  - @tanstack/query-db-collection@0.2.33
+  - @tanstack/react-db@0.1.34
+  - @tanstack/trailbase-db-collection@0.1.34
+
 ## 0.1.11
 
 ### Patch Changes
diff --git a/examples/react/todo/docker-compose.yml b/examples/react/todo/docker-compose.yml
index 9b6ddcffe..cb03bb1b3 100644
--- a/examples/react/todo/docker-compose.yml
+++ b/examples/react/todo/docker-compose.yml
@@ -1,4 +1,4 @@
-version: "3.8"
+version: '3.8'
 services:
   postgres:
     image: postgres:17-alpine
@@ -7,7 +7,7 @@ services:
       POSTGRES_USER: postgres
       POSTGRES_PASSWORD: postgres
     ports:
-      - "54322:5432"
+      - '54322:5432'
     volumes:
       - ./postgres.conf:/etc/postgresql/postgresql.conf:ro
     tmpfs:
@@ -18,7 +18,7 @@ services:
       - -c
       - config_file=/etc/postgresql/postgresql.conf
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      test: ['CMD-SHELL', 'pg_isready -U postgres']
       interval: 5s
       timeout: 5s
       retries: 5
@@ -37,11 +37,11 @@ services:
   trailbase:
     image: trailbase/trailbase:latest
     ports:
-      - "${PORT:-4000}:4000"
+      - '${PORT:-4000}:4000'
     restart: unless-stopped
     volumes:
       - ./traildepot:/app/traildepot
-    command: "/app/trail --data-dir /app/traildepot run --address 0.0.0.0:4000 --dev"
+    command: '/app/trail --data-dir /app/traildepot run --address 0.0.0.0:4000 --dev'
 
 volumes:
   postgres_data:
diff --git a/examples/react/todo/drizzle.config.ts b/examples/react/todo/drizzle.config.ts
index 550633431..486be88c9 100644
--- a/examples/react/todo/drizzle.config.ts
+++ b/examples/react/todo/drizzle.config.ts
@@ -1,4 +1,4 @@
-import type { Config } from "drizzle-kit"
+import type { Config } from 'drizzle-kit'
 
 export default {
   schema: `./src/db/schema.ts`,
diff --git a/examples/react/todo/package.json b/examples/react/todo/package.json
index bbf47b067..ffaf9ef0e 100644
--- a/examples/react/todo/package.json
+++ b/examples/react/todo/package.json
@@ -1,49 +1,49 @@
 {
   "name": "@tanstack/db-example-react-todo",
   "private": true,
-  "version": "0.1.11",
+  "version": "0.1.24",
   "dependencies": {
-    "@tanstack/electric-db-collection": "workspace:^",
-    "@tanstack/query-core": "^5.90.5",
-    "@tanstack/query-db-collection": "workspace:*",
-    "@tanstack/react-db": "workspace:*",
-    "@tanstack/react-router": "^1.133.15",
-    "@tanstack/react-start": "^1.133.15",
-    "@tanstack/trailbase-db-collection": "workspace:^",
+    "@tanstack/electric-db-collection": "^0.2.30",
+    "@tanstack/query-core": "^5.90.16",
+    "@tanstack/query-db-collection": "^1.0.21",
+    "@tanstack/react-db": "^0.1.68",
+    "@tanstack/react-router": "^1.144.0",
+    "@tanstack/react-start": "^1.145.5",
+    "@tanstack/trailbase-db-collection": "^0.1.68",
     "cors": "^2.8.5",
-    "drizzle-orm": "^0.44.6",
+    "drizzle-orm": "^0.45.1",
     "drizzle-zod": "^0.8.3",
-    "express": "^4.21.2",
+    "express": "^5.0.1",
     "postgres": "^3.4.7",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0",
-    "tailwindcss": "^4.1.14",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "tailwindcss": "^4.1.18",
     "trailbase": "^0.8.0",
     "vite-tsconfig-paths": "^5.1.4",
     "zod": "^4.1.11"
   },
   "devDependencies": {
-    "@eslint/js": "^9.38.0",
-    "@tailwindcss/vite": "^4.1.14",
+    "@eslint/js": "^9.39.2",
+    "@tailwindcss/vite": "^4.1.18",
     "@types/cors": "^2.8.19",
-    "@types/express": "^4.17.23",
-    "@types/node": "^24.5.2",
-    "@types/pg": "^8.15.5",
-    "@types/react": "^19.2.2",
-    "@types/react-dom": "^19.2.2",
-    "@typescript-eslint/eslint-plugin": "^8.46.1",
-    "@typescript-eslint/parser": "^8.46.1",
-    "@vitejs/plugin-react": "^5.0.3",
+    "@types/express": "^5.0.0",
+    "@types/node": "^24.6.2",
+    "@types/pg": "^8.16.0",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
+    "@vitejs/plugin-react": "^5.1.2",
     "concurrently": "^9.2.1",
-    "dotenv": "^17.2.2",
-    "drizzle-kit": "^0.31.5",
-    "eslint": "^9.38.0",
+    "dotenv": "^17.2.3",
+    "drizzle-kit": "^0.31.8",
+    "eslint": "^9.39.2",
     "eslint-plugin-react-hooks": "^5.2.0",
-    "eslint-plugin-react-refresh": "^0.4.24",
+    "eslint-plugin-react-refresh": "^0.4.26",
     "pg": "^8.16.3",
-    "tsx": "^4.20.6",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.2",
-    "vite": "^6.1.1"
+    "vite": "^7.3.0"
   },
   "scripts": {
     "build": "vite build",
diff --git a/examples/react/todo/scripts/migrate.ts b/examples/react/todo/scripts/migrate.ts
index ee0089f38..d58ebc44e 100644
--- a/examples/react/todo/scripts/migrate.ts
+++ b/examples/react/todo/scripts/migrate.ts
@@ -1,7 +1,7 @@
-import { drizzle } from "drizzle-orm/node-postgres"
-import { migrate } from "drizzle-orm/node-postgres/migrator"
-import pkg from "pg"
-import * as dotenv from "dotenv"
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { migrate } from 'drizzle-orm/node-postgres/migrator'
+import pkg from 'pg'
+import * as dotenv from 'dotenv'
 
 dotenv.config()
 
diff --git a/examples/react/todo/src/api/server.ts b/examples/react/todo/src/api/server.ts
index 4aa55431d..948d2442e 100644
--- a/examples/react/todo/src/api/server.ts
+++ b/examples/react/todo/src/api/server.ts
@@ -1,14 +1,14 @@
-import express from "express"
-import cors from "cors"
-import { sql } from "../db/postgres"
+import express from 'express'
+import cors from 'cors'
+import { sql } from '../db/postgres'
 import {
   validateInsertConfig,
   validateInsertTodo,
   validateUpdateConfig,
   validateUpdateTodo,
-} from "../db/validation"
-import type { Express } from "express"
-import type { Txid } from "@tanstack/electric-db-collection"
+} from '../db/validation'
+import type { Express } from 'express'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Create Express app
 const app: Express = express()
diff --git a/examples/react/todo/src/components/NotFound.tsx b/examples/react/todo/src/components/NotFound.tsx
index 2e892fafd..60caed4d7 100644
--- a/examples/react/todo/src/components/NotFound.tsx
+++ b/examples/react/todo/src/components/NotFound.tsx
@@ -1,4 +1,4 @@
-import { Link } from "@tanstack/react-router"
+import { Link } from '@tanstack/react-router'
 
 export function NotFound() {
   return (
diff --git a/examples/react/todo/src/components/TodoApp.tsx b/examples/react/todo/src/components/TodoApp.tsx
index 1a1e152d8..9a0225436 100644
--- a/examples/react/todo/src/components/TodoApp.tsx
+++ b/examples/react/todo/src/components/TodoApp.tsx
@@ -1,10 +1,11 @@
-import React, { useState } from "react"
-import { Link } from "@tanstack/react-router"
-import type { FormEvent } from "react"
-import type { Collection } from "@tanstack/react-db"
+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, Transaction } from '@tanstack/react-db'
 
-import type { SelectConfig, SelectTodo } from "@/db/validation"
-import { getComplementaryColor } from "@/lib/color"
+import type { SelectConfig, SelectTodo } from '@/db/validation'
+import { getComplementaryColor } from '@/lib/color'
 
 interface TodoAppProps {
   todos: Array<SelectTodo>
@@ -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`)
@@ -129,8 +165,8 @@ export function TodoApp({
                   todosToToggle.map((todo) => todo.id),
                   (drafts) =>
                     drafts.forEach(
-                      (draft) => (draft.completed = !draft.completed)
-                    )
+                      (draft) => (draft.completed = !draft.completed),
+                    ),
                 )
               }}
             >
diff --git a/examples/react/todo/src/db/index.ts b/examples/react/todo/src/db/index.ts
index 5a856e693..fbd0af99d 100644
--- a/examples/react/todo/src/db/index.ts
+++ b/examples/react/todo/src/db/index.ts
@@ -1,6 +1,6 @@
-import { drizzle } from "drizzle-orm/node-postgres"
-import { Pool } from "pg"
-import * as schema from "./schema"
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { Pool } from 'pg'
+import * as schema from './schema'
 
 // Create a PostgreSQL pool
 const pool = new Pool({
diff --git a/examples/react/todo/src/db/postgres.ts b/examples/react/todo/src/db/postgres.ts
index 674348433..9a0c0437c 100644
--- a/examples/react/todo/src/db/postgres.ts
+++ b/examples/react/todo/src/db/postgres.ts
@@ -1,4 +1,4 @@
-import postgres from "postgres"
+import postgres from 'postgres'
 
 // Create a postgres instance
 export const sql = postgres({
diff --git a/examples/react/todo/src/db/schema.ts b/examples/react/todo/src/db/schema.ts
index 4bf9e0d0a..bed8f98a8 100644
--- a/examples/react/todo/src/db/schema.ts
+++ b/examples/react/todo/src/db/schema.ts
@@ -1,4 +1,4 @@
-import { boolean, pgTable, serial, text, timestamp } from "drizzle-orm/pg-core"
+import { boolean, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core'
 
 export const todos = pgTable(`todos`, {
   id: serial(`id`).primaryKey(),
diff --git a/examples/react/todo/src/db/validation.ts b/examples/react/todo/src/db/validation.ts
index 404afd0d4..2fa8408af 100644
--- a/examples/react/todo/src/db/validation.ts
+++ b/examples/react/todo/src/db/validation.ts
@@ -1,6 +1,6 @@
-import { createInsertSchema, createSelectSchema } from "drizzle-zod"
-import { config, todos } from "./schema"
-import type { z } from "zod"
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
+import { config, todos } from './schema'
+import type { z } from 'zod'
 
 // Auto-generated schemas from Drizzle schema (omit auto-generated fields)
 export const insertTodoSchema = createInsertSchema(todos).omit({
diff --git a/examples/react/todo/src/index.css b/examples/react/todo/src/index.css
index 5211a0414..6dafed23c 100644
--- a/examples/react/todo/src/index.css
+++ b/examples/react/todo/src/index.css
@@ -1,4 +1,4 @@
-@import "tailwindcss";
+@import 'tailwindcss';
 
 html,
 body {
@@ -21,7 +21,7 @@ button {
 
 body {
   font:
-    14px "Helvetica Neue",
+    14px 'Helvetica Neue',
     Helvetica,
     Arial,
     sans-serif;
diff --git a/examples/react/todo/src/lib/api.ts b/examples/react/todo/src/lib/api.ts
index c6e070b31..e066cdbe6 100644
--- a/examples/react/todo/src/lib/api.ts
+++ b/examples/react/todo/src/lib/api.ts
@@ -1,4 +1,4 @@
-import type { SelectConfig, SelectTodo } from "../db/validation"
+import type { SelectConfig, SelectTodo } from '../db/validation'
 
 // API helper for todos and config
 const API_BASE_URL = `/api`
@@ -19,11 +19,11 @@ export const api = {
       return response.json()
     },
     create: async (
-      todo: Partial<SelectTodo>
+      todo: Partial<SelectTodo>,
     ): Promise<{ todo: SelectTodo; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/todos`, {
         method: `POST`,
-        headers: { "Content-Type": `application/json` },
+        headers: { 'Content-Type': `application/json` },
         body: JSON.stringify(todo),
       })
       if (!response.ok)
@@ -32,11 +32,11 @@ export const api = {
     },
     update: async (
       id: unknown,
-      changes: Partial<SelectTodo>
+      changes: Partial<SelectTodo>,
     ): Promise<{ todo: SelectTodo; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/todos/${id}`, {
         method: `PUT`,
-        headers: { "Content-Type": `application/json` },
+        headers: { 'Content-Type': `application/json` },
         body: JSON.stringify(changes),
       })
       if (!response.ok)
@@ -44,7 +44,7 @@ export const api = {
       return response.json()
     },
     delete: async (
-      id: unknown
+      id: unknown,
     ): Promise<{ success: boolean; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/todos/${id}`, {
         method: `DELETE`,
@@ -70,11 +70,11 @@ export const api = {
       return response.json()
     },
     create: async (
-      config: Partial<SelectConfig>
+      config: Partial<SelectConfig>,
     ): Promise<{ config: SelectConfig; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/config`, {
         method: `POST`,
-        headers: { "Content-Type": `application/json` },
+        headers: { 'Content-Type': `application/json` },
         body: JSON.stringify(config),
       })
       if (!response.ok)
@@ -83,11 +83,11 @@ export const api = {
     },
     update: async (
       id: number,
-      changes: Partial<SelectConfig>
+      changes: Partial<SelectConfig>,
     ): Promise<{ config: SelectConfig; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/config/${id}`, {
         method: `PUT`,
-        headers: { "Content-Type": `application/json` },
+        headers: { 'Content-Type': `application/json` },
         body: JSON.stringify(changes),
       })
       if (!response.ok)
diff --git a/examples/react/todo/src/lib/collections.ts b/examples/react/todo/src/lib/collections.ts
index 5e41bac92..e8154c5a2 100644
--- a/examples/react/todo/src/lib/collections.ts
+++ b/examples/react/todo/src/lib/collections.ts
@@ -1,12 +1,12 @@
-import { createCollection } from "@tanstack/react-db"
-import { electricCollectionOptions } from "@tanstack/electric-db-collection"
-import { queryCollectionOptions } from "@tanstack/query-db-collection"
-import { trailBaseCollectionOptions } from "@tanstack/trailbase-db-collection"
-import { QueryClient } from "@tanstack/query-core"
-import { initClient } from "trailbase"
-import { selectConfigSchema, selectTodoSchema } from "../db/validation"
-import { api } from "./api"
-import type { SelectConfig, SelectTodo } from "../db/validation"
+import { createCollection } from '@tanstack/react-db'
+import { electricCollectionOptions } from '@tanstack/electric-db-collection'
+import { queryCollectionOptions } from '@tanstack/query-db-collection'
+import { trailBaseCollectionOptions } from '@tanstack/trailbase-db-collection'
+import { QueryClient } from '@tanstack/query-core'
+import { initClient } from 'trailbase'
+import { selectConfigSchema, selectTodoSchema } from '../db/validation'
+import { api } from './api'
+import type { SelectConfig, SelectTodo } from '../db/validation'
 
 // Create a query client for query collections
 const queryClient = new QueryClient()
@@ -48,7 +48,7 @@ export const electricTodoCollection = createCollection(
           }
           const response = await api.todos.update(original.id, changes)
           return response.txid
-        })
+        }),
       )
       return { txid: txids }
     },
@@ -61,11 +61,11 @@ export const electricTodoCollection = createCollection(
           }
           const response = await api.todos.delete(original.id)
           return response.txid
-        })
+        }),
       )
       return { txid: txids }
     },
-  })
+  }),
 )
 
 // Query Todo Collection
@@ -102,7 +102,7 @@ export const queryTodoCollection = createCollection(
             throw new Error(`Original todo not found for update`)
           }
           return await api.todos.update(original.id, changes)
-        })
+        }),
       )
     },
     onDelete: async ({ transaction }) => {
@@ -113,10 +113,10 @@ export const queryTodoCollection = createCollection(
             throw new Error(`Original todo not found for delete`)
           }
           await api.todos.delete(original.id)
-        })
+        }),
       )
     },
-  })
+  }),
 )
 
 type Todo = {
@@ -132,7 +132,6 @@ export const trailBaseTodoCollection = createCollection(
   trailBaseCollectionOptions<SelectTodo, Todo>({
     id: `todos`,
     getKey: (item) => item.id,
-    schema: selectTodoSchema,
     recordApi: trailBaseClient.records(`todos`),
     // Re-using the example's drizzle-schema requires remapping the items.
     parse: {
@@ -143,7 +142,7 @@ export const trailBaseTodoCollection = createCollection(
       created_at: (date) => Math.floor(date.valueOf() / 1000),
       updated_at: (date) => Math.floor(date.valueOf() / 1000),
     },
-  })
+  }),
 )
 
 // Electric Config Collection
@@ -175,11 +174,11 @@ export const electricConfigCollection = createCollection(
           }
           const response = await api.config.update(original.id, changes)
           return response.txid
-        })
+        }),
       )
       return { txid: txids }
     },
-  })
+  }),
 )
 
 // Query Config Collection
@@ -213,11 +212,11 @@ export const queryConfigCollection = createCollection(
           }
           const response = await api.config.update(original.id, changes)
           return response.txid
-        })
+        }),
       )
       return { txid: txids }
     },
-  })
+  }),
 )
 
 type Config = {
@@ -233,7 +232,6 @@ export const trailBaseConfigCollection = createCollection(
   trailBaseCollectionOptions<SelectConfig, Config>({
     id: `config`,
     getKey: (item) => item.id,
-    schema: selectConfigSchema,
     recordApi: trailBaseClient.records(`config`),
     // Re-using the example's drizzle-schema requires remapping the items.
     parse: {
@@ -244,5 +242,5 @@ export const trailBaseConfigCollection = createCollection(
       created_at: (date) => Math.floor(date.valueOf() / 1000),
       updated_at: (date) => Math.floor(date.valueOf() / 1000),
     },
-  })
+  }),
 )
diff --git a/examples/react/todo/src/main.tsx b/examples/react/todo/src/main.tsx
index 0218796d3..5368d1602 100644
--- a/examples/react/todo/src/main.tsx
+++ b/examples/react/todo/src/main.tsx
@@ -1,13 +1,13 @@
-import { StrictMode } from "react"
-import { createRoot } from "react-dom/client"
-import { RouterProvider } from "@tanstack/react-router"
-import { getRouter } from "./router"
-import "./index.css"
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { RouterProvider } from '@tanstack/react-router'
+import { getRouter } from './router'
+import './index.css'
 
 const router = getRouter()
 
 createRoot(document.getElementById(`root`)!).render(
   <StrictMode>
     <RouterProvider router={router} />
-  </StrictMode>
+  </StrictMode>,
 )
diff --git a/examples/react/todo/src/router.tsx b/examples/react/todo/src/router.tsx
index 75e151354..e4dfe3766 100644
--- a/examples/react/todo/src/router.tsx
+++ b/examples/react/todo/src/router.tsx
@@ -1,10 +1,10 @@
-import { createRouter as createTanstackRouter } from "@tanstack/react-router"
+import { createRouter as createTanstackRouter } from '@tanstack/react-router'
 
 // Import the generated route tree
-import { routeTree } from "./routeTree.gen"
-import { NotFound } from "./components/NotFound"
+import { routeTree } from './routeTree.gen'
+import { NotFound } from './components/NotFound'
 
-import "./styles.css"
+import './styles.css'
 
 // Create a new router instance
 export function getRouter() {
diff --git a/examples/react/todo/src/routes/__root.tsx b/examples/react/todo/src/routes/__root.tsx
index 94dd0b516..e57101152 100644
--- a/examples/react/todo/src/routes/__root.tsx
+++ b/examples/react/todo/src/routes/__root.tsx
@@ -1,12 +1,12 @@
-import * as React from "react"
+import * as React from 'react'
 import {
   HeadContent,
   Outlet,
   Scripts,
   createRootRoute,
-} from "@tanstack/react-router"
+} from '@tanstack/react-router'
 
-import appCss from "../styles.css?url"
+import appCss from '../styles.css?url'
 
 export const Route = createRootRoute({
   head: () => ({
diff --git a/examples/react/todo/src/routes/api/config.$id.ts b/examples/react/todo/src/routes/api/config.$id.ts
index 9acfec234..f60ef9a64 100644
--- a/examples/react/todo/src/routes/api/config.$id.ts
+++ b/examples/react/todo/src/routes/api/config.$id.ts
@@ -1,8 +1,8 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { json } from "@tanstack/react-start"
-import { sql } from "../../db/postgres"
-import { validateUpdateConfig } from "../../db/validation"
-import type { Txid } from "@tanstack/electric-db-collection"
+import { createFileRoute } from '@tanstack/react-router'
+import { json } from '@tanstack/react-start'
+import { sql } from '../../db/postgres'
+import { validateUpdateConfig } from '../../db/validation'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Generate a transaction ID
 async function generateTxId(tx: any): Promise<Txid> {
@@ -36,7 +36,7 @@ export const Route = createFileRoute(`/api/config/$id`)({
               error: `Failed to fetch config`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
@@ -76,7 +76,7 @@ export const Route = createFileRoute(`/api/config/$id`)({
               error: `Failed to update config`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
@@ -111,7 +111,7 @@ export const Route = createFileRoute(`/api/config/$id`)({
               error: `Failed to delete config`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
diff --git a/examples/react/todo/src/routes/api/config.ts b/examples/react/todo/src/routes/api/config.ts
index 2224720c2..c4ae48cc1 100644
--- a/examples/react/todo/src/routes/api/config.ts
+++ b/examples/react/todo/src/routes/api/config.ts
@@ -1,8 +1,8 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { json } from "@tanstack/react-start"
-import { sql } from "../../db/postgres"
-import { validateInsertConfig } from "../../db/validation"
-import type { Txid } from "@tanstack/electric-db-collection"
+import { createFileRoute } from '@tanstack/react-router'
+import { json } from '@tanstack/react-start'
+import { sql } from '../../db/postgres'
+import { validateInsertConfig } from '../../db/validation'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Generate a transaction ID
 async function generateTxId(tx: any): Promise<Txid> {
@@ -30,7 +30,7 @@ export const Route = createFileRoute(`/api/config`)({
               error: `Failed to fetch config`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
@@ -59,7 +59,7 @@ export const Route = createFileRoute(`/api/config`)({
               error: `Failed to create config`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
diff --git a/examples/react/todo/src/routes/api/todos.$id.ts b/examples/react/todo/src/routes/api/todos.$id.ts
index 12b4cf9e2..5f57126cd 100644
--- a/examples/react/todo/src/routes/api/todos.$id.ts
+++ b/examples/react/todo/src/routes/api/todos.$id.ts
@@ -1,8 +1,8 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { json } from "@tanstack/react-start"
-import { sql } from "../../db/postgres"
-import { validateUpdateTodo } from "../../db/validation"
-import type { Txid } from "@tanstack/electric-db-collection"
+import { createFileRoute } from '@tanstack/react-router'
+import { json } from '@tanstack/react-start'
+import { sql } from '../../db/postgres'
+import { validateUpdateTodo } from '../../db/validation'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Generate a transaction ID
 async function generateTxId(tx: any): Promise<Txid> {
@@ -36,7 +36,7 @@ export const Route = createFileRoute(`/api/todos/$id`)({
               error: `Failed to fetch todo`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
@@ -76,7 +76,7 @@ export const Route = createFileRoute(`/api/todos/$id`)({
               error: `Failed to update todo`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
@@ -111,7 +111,7 @@ export const Route = createFileRoute(`/api/todos/$id`)({
               error: `Failed to delete todo`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
diff --git a/examples/react/todo/src/routes/api/todos.ts b/examples/react/todo/src/routes/api/todos.ts
index 72b45f3e8..22fe77953 100644
--- a/examples/react/todo/src/routes/api/todos.ts
+++ b/examples/react/todo/src/routes/api/todos.ts
@@ -1,8 +1,8 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { json } from "@tanstack/react-start"
-import { sql } from "../../db/postgres"
-import { validateInsertTodo } from "../../db/validation"
-import type { Txid } from "@tanstack/electric-db-collection"
+import { createFileRoute } from '@tanstack/react-router'
+import { json } from '@tanstack/react-start'
+import { sql } from '../../db/postgres'
+import { validateInsertTodo } from '../../db/validation'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Generate a transaction ID
 async function generateTxId(tx: any): Promise<Txid> {
@@ -34,7 +34,7 @@ export const Route = createFileRoute(`/api/todos`)({
               error: `Failed to fetch todos`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
@@ -62,7 +62,7 @@ export const Route = createFileRoute(`/api/todos`)({
               error: `Failed to create todo`,
               details: error instanceof Error ? error.message : String(error),
             },
-            { status: 500 }
+            { status: 500 },
           )
         }
       },
diff --git a/examples/react/todo/src/routes/electric.tsx b/examples/react/todo/src/routes/electric.tsx
index 8d4f068f6..61629b81f 100644
--- a/examples/react/todo/src/routes/electric.tsx
+++ b/examples/react/todo/src/routes/electric.tsx
@@ -1,10 +1,13 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { useLiveQuery } from "@tanstack/react-db"
+import * as React from 'react'
+import { createFileRoute } from '@tanstack/react-router'
+import { useLiveQuery } from '@tanstack/react-db'
 import {
   electricConfigCollection,
   electricTodoCollection,
-} from "../lib/collections"
-import { TodoApp } from "../components/TodoApp"
+} 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,
@@ -24,13 +27,47 @@ function ElectricPage() {
   const { data: todos } = useLiveQuery((q) =>
     q
       .from({ todo: electricTodoCollection })
-      .orderBy(({ todo }) => todo.created_at, `asc`)
+      .orderBy(({ todo }) => todo.created_at, `asc`),
   )
 
   const { data: configData } = useLiveQuery((q) =>
-    q.from({ config: electricConfigCollection })
+    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 +75,7 @@ function ElectricPage() {
       todoCollection={electricTodoCollection}
       configCollection={electricConfigCollection}
       title="todos (electric)"
+      configMutationFn={configMutationFn}
     />
   )
 }
diff --git a/examples/react/todo/src/routes/index.tsx b/examples/react/todo/src/routes/index.tsx
index 37a2a8798..34e259689 100644
--- a/examples/react/todo/src/routes/index.tsx
+++ b/examples/react/todo/src/routes/index.tsx
@@ -1,4 +1,5 @@
-import { Link, createFileRoute } from "@tanstack/react-router"
+import * as React from 'react'
+import { Link, createFileRoute } from '@tanstack/react-router'
 
 export const Route = createFileRoute(`/`)({
   component: HomePage,
diff --git a/examples/react/todo/src/routes/query.tsx b/examples/react/todo/src/routes/query.tsx
index 129ab0cd4..62c0ad37d 100644
--- a/examples/react/todo/src/routes/query.tsx
+++ b/examples/react/todo/src/routes/query.tsx
@@ -1,7 +1,10 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { useLiveQuery } from "@tanstack/react-db"
-import { queryConfigCollection, queryTodoCollection } from "../lib/collections"
-import { TodoApp } from "../components/TodoApp"
+import * as React from 'react'
+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,
@@ -21,13 +24,42 @@ function QueryPage() {
   const { data: todos } = useLiveQuery((q) =>
     q
       .from({ todo: queryTodoCollection })
-      .orderBy(({ todo }) => todo.created_at, `asc`)
+      .orderBy(({ todo }) => todo.created_at, `asc`),
   )
 
   const { data: configData } = useLiveQuery((q) =>
-    q.from({ config: queryConfigCollection })
+    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 +67,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..96e05e11a 100644
--- a/examples/react/todo/src/routes/trailbase.tsx
+++ b/examples/react/todo/src/routes/trailbase.tsx
@@ -1,10 +1,11 @@
-import { createFileRoute } from "@tanstack/react-router"
-import { useLiveQuery } from "@tanstack/react-db"
+import * as React from 'react'
+import { createFileRoute } from '@tanstack/react-router'
+import { useLiveQuery } from '@tanstack/react-db'
 import {
   trailBaseConfigCollection,
   trailBaseTodoCollection,
-} from "../lib/collections"
-import { TodoApp } from "../components/TodoApp"
+} from '../lib/collections'
+import { TodoApp } from '../components/TodoApp'
 
 export const Route = createFileRoute(`/trailbase`)({
   component: TrailBasePage,
@@ -24,13 +25,20 @@ function TrailBasePage() {
   const { data: todos } = useLiveQuery((q) =>
     q
       .from({ todo: trailBaseTodoCollection })
-      .orderBy(({ todo }) => todo.created_at, `asc`)
+      .orderBy(({ todo }) => todo.created_at, `asc`),
   )
 
   const { data: configData } = useLiveQuery((q) =>
-    q.from({ config: trailBaseConfigCollection })
+    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/examples/react/todo/src/server.ts b/examples/react/todo/src/server.ts
index 1f8997f3e..130fbb5a9 100644
--- a/examples/react/todo/src/server.ts
+++ b/examples/react/todo/src/server.ts
@@ -1,4 +1,4 @@
-import handler from "@tanstack/react-start/server-entry"
+import handler from '@tanstack/react-start/server-entry'
 
 export default {
   fetch(request: Request) {
diff --git a/examples/react/todo/src/start.tsx b/examples/react/todo/src/start.tsx
index de7b170ed..9e8694bab 100644
--- a/examples/react/todo/src/start.tsx
+++ b/examples/react/todo/src/start.tsx
@@ -1,4 +1,4 @@
-import { createStart } from "@tanstack/react-start"
+import { createStart } from '@tanstack/react-start'
 
 export const startInstance = createStart(() => {
   return {
diff --git a/examples/react/todo/src/styles.css b/examples/react/todo/src/styles.css
index 80cb92ada..06f1bca4b 100644
--- a/examples/react/todo/src/styles.css
+++ b/examples/react/todo/src/styles.css
@@ -1,15 +1,15 @@
-@import "tailwindcss";
+@import 'tailwindcss';
 
 body {
   @apply m-0;
   font-family:
-    -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu",
-    "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif;
+    -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;
 }
 
 code {
   font-family:
-    source-code-pro, Menlo, Monaco, Consolas, "Courier New", monospace;
+    source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
 }
diff --git a/examples/react/todo/vite.config.ts b/examples/react/todo/vite.config.ts
index ab0b541fd..3bf6a06e3 100644
--- a/examples/react/todo/vite.config.ts
+++ b/examples/react/todo/vite.config.ts
@@ -1,8 +1,8 @@
-import { defineConfig } from "vite"
-import react from "@vitejs/plugin-react"
-import tailwindcss from "@tailwindcss/vite"
-import { tanstackStart } from "@tanstack/react-start/plugin/vite"
-import viteTsConfigPaths from "vite-tsconfig-paths"
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import { tanstackStart } from '@tanstack/react-start/plugin/vite'
+import viteTsConfigPaths from 'vite-tsconfig-paths'
 
 // https://vitejs.dev/config/
 export default defineConfig({
diff --git a/examples/solid/todo/CHANGELOG.md b/examples/solid/todo/CHANGELOG.md
index 6e0c2b2e0..0b802264e 100644
--- a/examples/solid/todo/CHANGELOG.md
+++ b/examples/solid/todo/CHANGELOG.md
@@ -1,5 +1,15 @@
 # examples/react/todo
 
+## 0.0.34
+
+### Patch Changes
+
+- Updated dependencies [[`d9c663c`](https://github.com/TanStack/db/commit/d9c663c1874b1717d72bf289277d45e875e36bc2)]:
+  - @tanstack/solid-db@0.2.0
+  - @tanstack/electric-db-collection@0.2.24
+  - @tanstack/query-db-collection@1.0.16
+  - @tanstack/trailbase-db-collection@0.1.64
+
 ## 0.0.33
 
 ### Patch Changes
diff --git a/examples/solid/todo/docker-compose.yml b/examples/solid/todo/docker-compose.yml
index 9b6ddcffe..cb03bb1b3 100644
--- a/examples/solid/todo/docker-compose.yml
+++ b/examples/solid/todo/docker-compose.yml
@@ -1,4 +1,4 @@
-version: "3.8"
+version: '3.8'
 services:
   postgres:
     image: postgres:17-alpine
@@ -7,7 +7,7 @@ services:
       POSTGRES_USER: postgres
       POSTGRES_PASSWORD: postgres
     ports:
-      - "54322:5432"
+      - '54322:5432'
     volumes:
       - ./postgres.conf:/etc/postgresql/postgresql.conf:ro
     tmpfs:
@@ -18,7 +18,7 @@ services:
       - -c
       - config_file=/etc/postgresql/postgresql.conf
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      test: ['CMD-SHELL', 'pg_isready -U postgres']
       interval: 5s
       timeout: 5s
       retries: 5
@@ -37,11 +37,11 @@ services:
   trailbase:
     image: trailbase/trailbase:latest
     ports:
-      - "${PORT:-4000}:4000"
+      - '${PORT:-4000}:4000'
     restart: unless-stopped
     volumes:
       - ./traildepot:/app/traildepot
-    command: "/app/trail --data-dir /app/traildepot run --address 0.0.0.0:4000 --dev"
+    command: '/app/trail --data-dir /app/traildepot run --address 0.0.0.0:4000 --dev'
 
 volumes:
   postgres_data:
diff --git a/examples/solid/todo/drizzle.config.ts b/examples/solid/todo/drizzle.config.ts
index 550633431..486be88c9 100644
--- a/examples/solid/todo/drizzle.config.ts
+++ b/examples/solid/todo/drizzle.config.ts
@@ -1,4 +1,4 @@
-import type { Config } from "drizzle-kit"
+import type { Config } from 'drizzle-kit'
 
 export default {
   schema: `./src/db/schema.ts`,
diff --git a/examples/solid/todo/package.json b/examples/solid/todo/package.json
index 46adbc1d5..ada20dcac 100644
--- a/examples/solid/todo/package.json
+++ b/examples/solid/todo/package.json
@@ -1,44 +1,44 @@
 {
   "name": "@tanstack/db-example-solid-todo",
   "private": true,
-  "version": "0.0.33",
+  "version": "0.0.34",
   "dependencies": {
-    "@tanstack/electric-db-collection": "^0.1.35",
-    "@tanstack/query-core": "^5.90.5",
-    "@tanstack/query-db-collection": "^0.2.32",
-    "@tanstack/solid-db": "^0.1.33",
-    "@tanstack/solid-router": "^1.133.15",
-    "@tanstack/solid-start": "^1.133.15",
-    "@tanstack/trailbase-db-collection": "^0.1.33",
+    "@tanstack/electric-db-collection": "^0.2.30",
+    "@tanstack/query-core": "^5.90.16",
+    "@tanstack/query-db-collection": "^1.0.21",
+    "@tanstack/solid-db": "^0.2.4",
+    "@tanstack/solid-router": "^1.144.0",
+    "@tanstack/solid-start": "^1.145.5",
+    "@tanstack/trailbase-db-collection": "^0.1.68",
     "cors": "^2.8.5",
-    "drizzle-orm": "^0.44.6",
+    "drizzle-orm": "^0.45.1",
     "drizzle-zod": "^0.8.3",
-    "express": "^4.21.2",
+    "express": "^5.0.1",
     "postgres": "^3.4.7",
-    "solid-js": "^1.9.9",
-    "tailwindcss": "^4.1.14",
+    "solid-js": "^1.9.10",
+    "tailwindcss": "^4.1.18",
     "trailbase": "^0.8.0",
     "vite-tsconfig-paths": "^5.1.4"
   },
   "devDependencies": {
-    "@eslint/js": "^9.38.0",
-    "@tailwindcss/vite": "^4.1.14",
+    "@eslint/js": "^9.39.2",
+    "@tailwindcss/vite": "^4.1.18",
     "@types/cors": "^2.8.19",
-    "@types/express": "^4.17.23",
-    "@types/node": "^22.18.1",
-    "@types/pg": "^8.15.5",
-    "@typescript-eslint/eslint-plugin": "^8.46.1",
-    "@typescript-eslint/parser": "^8.46.1",
+    "@types/express": "^5.0.0",
+    "@types/node": "^24.6.2",
+    "@types/pg": "^8.16.0",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
     "concurrently": "^9.2.1",
-    "dotenv": "^16.6.1",
-    "drizzle-kit": "^0.31.5",
-    "eslint": "^9.38.0",
+    "dotenv": "^17.2.3",
+    "drizzle-kit": "^0.31.8",
+    "eslint": "^9.39.2",
     "eslint-plugin-solid": "^0.14.5",
     "pg": "^8.16.3",
-    "tsx": "^4.20.6",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.2",
-    "vite": "^6.3.6",
-    "vite-plugin-solid": "^2.11.9"
+    "vite": "^7.3.0",
+    "vite-plugin-solid": "^2.11.10"
   },
   "scripts": {
     "build": "vite build",
diff --git a/examples/solid/todo/scripts/migrate.ts b/examples/solid/todo/scripts/migrate.ts
index ee0089f38..d58ebc44e 100644
--- a/examples/solid/todo/scripts/migrate.ts
+++ b/examples/solid/todo/scripts/migrate.ts
@@ -1,7 +1,7 @@
-import { drizzle } from "drizzle-orm/node-postgres"
-import { migrate } from "drizzle-orm/node-postgres/migrator"
-import pkg from "pg"
-import * as dotenv from "dotenv"
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { migrate } from 'drizzle-orm/node-postgres/migrator'
+import pkg from 'pg'
+import * as dotenv from 'dotenv'
 
 dotenv.config()
 
diff --git a/examples/solid/todo/src/api/server.ts b/examples/solid/todo/src/api/server.ts
index 4aa55431d..948d2442e 100644
--- a/examples/solid/todo/src/api/server.ts
+++ b/examples/solid/todo/src/api/server.ts
@@ -1,14 +1,14 @@
-import express from "express"
-import cors from "cors"
-import { sql } from "../db/postgres"
+import express from 'express'
+import cors from 'cors'
+import { sql } from '../db/postgres'
 import {
   validateInsertConfig,
   validateInsertTodo,
   validateUpdateConfig,
   validateUpdateTodo,
-} from "../db/validation"
-import type { Express } from "express"
-import type { Txid } from "@tanstack/electric-db-collection"
+} from '../db/validation'
+import type { Express } from 'express'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Create Express app
 const app: Express = express()
diff --git a/examples/solid/todo/src/components/NotFound.tsx b/examples/solid/todo/src/components/NotFound.tsx
index 04619d4e8..3304c4195 100644
--- a/examples/solid/todo/src/components/NotFound.tsx
+++ b/examples/solid/todo/src/components/NotFound.tsx
@@ -1,4 +1,4 @@
-import { Link } from "@tanstack/solid-router"
+import { Link } from '@tanstack/solid-router'
 
 export function NotFound() {
   return (
diff --git a/examples/solid/todo/src/components/TodoApp.tsx b/examples/solid/todo/src/components/TodoApp.tsx
index 1e69d592c..c8cc0df58 100644
--- a/examples/solid/todo/src/components/TodoApp.tsx
+++ b/examples/solid/todo/src/components/TodoApp.tsx
@@ -1,8 +1,8 @@
-import { Link } from "@tanstack/solid-router"
-import { For, Show, createSignal } from "solid-js"
-import type { JSX } from "solid-js"
-import type { Collection } from "@tanstack/solid-db"
-import type { SelectConfig, SelectTodo } from "../db/validation"
+import { Link } from '@tanstack/solid-router'
+import { For, Show, createSignal } from 'solid-js'
+import type { JSX } from 'solid-js'
+import type { Collection } from '@tanstack/solid-db'
+import type { SelectConfig, SelectTodo } from '../db/validation'
 
 interface TodoAppProps {
   todos: Array<SelectTodo>
@@ -121,7 +121,7 @@ export function TodoApp(props: TodoAppProps) {
   return (
     <div
       class="min-h-screen flex items-start justify-center overflow-auto py-8"
-      style={{ "background-color": backgroundColor }}
+      style={{ 'background-color': backgroundColor }}
     >
       <div style={{ width: `550px` }} class="mx-auto relative">
         <div class="text-center mb-8">
@@ -193,9 +193,9 @@ export function TodoApp(props: TodoAppProps) {
                     todosToToggle.map((todo) => todo.id),
                     (drafts) => {
                       drafts.forEach(
-                        (draft) => (draft.completed = !allCompleted)
+                        (draft) => (draft.completed = !allCompleted),
                       )
-                    }
+                    },
                   )
                 }}
               >
@@ -262,7 +262,7 @@ export function TodoApp(props: TodoAppProps) {
                   <button
                     onClick={() => {
                       props.todoCollection.delete(
-                        completedTodos.map((todo) => todo.id)
+                        completedTodos.map((todo) => todo.id),
                       )
                     }}
                     class="text-inherit hover:underline"
diff --git a/examples/solid/todo/src/db/index.ts b/examples/solid/todo/src/db/index.ts
index 5a856e693..fbd0af99d 100644
--- a/examples/solid/todo/src/db/index.ts
+++ b/examples/solid/todo/src/db/index.ts
@@ -1,6 +1,6 @@
-import { drizzle } from "drizzle-orm/node-postgres"
-import { Pool } from "pg"
-import * as schema from "./schema"
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { Pool } from 'pg'
+import * as schema from './schema'
 
 // Create a PostgreSQL pool
 const pool = new Pool({
diff --git a/examples/solid/todo/src/db/postgres.ts b/examples/solid/todo/src/db/postgres.ts
index 674348433..9a0c0437c 100644
--- a/examples/solid/todo/src/db/postgres.ts
+++ b/examples/solid/todo/src/db/postgres.ts
@@ -1,4 +1,4 @@
-import postgres from "postgres"
+import postgres from 'postgres'
 
 // Create a postgres instance
 export const sql = postgres({
diff --git a/examples/solid/todo/src/db/schema.ts b/examples/solid/todo/src/db/schema.ts
index 4bf9e0d0a..bed8f98a8 100644
--- a/examples/solid/todo/src/db/schema.ts
+++ b/examples/solid/todo/src/db/schema.ts
@@ -1,4 +1,4 @@
-import { boolean, pgTable, serial, text, timestamp } from "drizzle-orm/pg-core"
+import { boolean, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core'
 
 export const todos = pgTable(`todos`, {
   id: serial(`id`).primaryKey(),
diff --git a/examples/solid/todo/src/db/validation.ts b/examples/solid/todo/src/db/validation.ts
index 2aaab77b5..2fa8408af 100644
--- a/examples/solid/todo/src/db/validation.ts
+++ b/examples/solid/todo/src/db/validation.ts
@@ -1,34 +1,24 @@
-import { createInsertSchema, createSelectSchema } from "drizzle-zod"
-import { z } from "zod"
-import { config, todos } from "./schema"
-
-// Date transformation schema - handles Date objects, ISO strings, and parseable date strings
-const dateStringToDate = z
-  .union([
-    z.date(), // Already a Date object
-    z
-      .string()
-      .datetime()
-      .transform((str) => new Date(str)), // ISO datetime string
-    z.string().transform((str) => new Date(str)), // Any parseable date string
-  ])
-  .optional()
-
-// Auto-generated schemas from Drizzle schema with date transformation
-export const insertTodoSchema = createInsertSchema(todos, {
-  created_at: dateStringToDate,
-  updated_at: dateStringToDate,
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
+import { config, todos } from './schema'
+import type { z } from 'zod'
+
+// Auto-generated schemas from Drizzle schema (omit auto-generated fields)
+export const insertTodoSchema = createInsertSchema(todos).omit({
+  id: true,
+  created_at: true,
+  updated_at: true,
 })
 export const selectTodoSchema = createSelectSchema(todos)
 
 // Partial schema for updates
 export const updateTodoSchema = insertTodoSchema.partial().strict()
 
-// Config schemas with date transformation
-export const insertConfigSchema = createInsertSchema(config, {
-  created_at: dateStringToDate,
-  updated_at: dateStringToDate,
-}).strict()
+// Config schemas (omit auto-generated fields)
+export const insertConfigSchema = createInsertSchema(config).omit({
+  id: true,
+  created_at: true,
+  updated_at: true,
+})
 export const selectConfigSchema = createSelectSchema(config)
 export const updateConfigSchema = insertConfigSchema.partial().strict()
 
diff --git a/examples/solid/todo/src/index.css b/examples/solid/todo/src/index.css
index 5211a0414..6dafed23c 100644
--- a/examples/solid/todo/src/index.css
+++ b/examples/solid/todo/src/index.css
@@ -1,4 +1,4 @@
-@import "tailwindcss";
+@import 'tailwindcss';
 
 html,
 body {
@@ -21,7 +21,7 @@ button {
 
 body {
   font:
-    14px "Helvetica Neue",
+    14px 'Helvetica Neue',
     Helvetica,
     Arial,
     sans-serif;
diff --git a/examples/solid/todo/src/lib/api.ts b/examples/solid/todo/src/lib/api.ts
index c6e070b31..e066cdbe6 100644
--- a/examples/solid/todo/src/lib/api.ts
+++ b/examples/solid/todo/src/lib/api.ts
@@ -1,4 +1,4 @@
-import type { SelectConfig, SelectTodo } from "../db/validation"
+import type { SelectConfig, SelectTodo } from '../db/validation'
 
 // API helper for todos and config
 const API_BASE_URL = `/api`
@@ -19,11 +19,11 @@ export const api = {
       return response.json()
     },
     create: async (
-      todo: Partial<SelectTodo>
+      todo: Partial<SelectTodo>,
     ): Promise<{ todo: SelectTodo; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/todos`, {
         method: `POST`,
-        headers: { "Content-Type": `application/json` },
+        headers: { 'Content-Type': `application/json` },
         body: JSON.stringify(todo),
       })
       if (!response.ok)
@@ -32,11 +32,11 @@ export const api = {
     },
     update: async (
       id: unknown,
-      changes: Partial<SelectTodo>
+      changes: Partial<SelectTodo>,
     ): Promise<{ todo: SelectTodo; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/todos/${id}`, {
         method: `PUT`,
-        headers: { "Content-Type": `application/json` },
+        headers: { 'Content-Type': `application/json` },
         body: JSON.stringify(changes),
       })
       if (!response.ok)
@@ -44,7 +44,7 @@ export const api = {
       return response.json()
     },
     delete: async (
-      id: unknown
+      id: unknown,
     ): Promise<{ success: boolean; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/todos/${id}`, {
         method: `DELETE`,
@@ -70,11 +70,11 @@ export const api = {
       return response.json()
     },
     create: async (
-      config: Partial<SelectConfig>
+      config: Partial<SelectConfig>,
     ): Promise<{ config: SelectConfig; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/config`, {
         method: `POST`,
-        headers: { "Content-Type": `application/json` },
+        headers: { 'Content-Type': `application/json` },
         body: JSON.stringify(config),
       })
       if (!response.ok)
@@ -83,11 +83,11 @@ export const api = {
     },
     update: async (
       id: number,
-      changes: Partial<SelectConfig>
+      changes: Partial<SelectConfig>,
     ): Promise<{ config: SelectConfig; txid: number }> => {
       const response = await fetch(`${API_BASE_URL}/config/${id}`, {
         method: `PUT`,
-        headers: { "Content-Type": `application/json` },
+        headers: { 'Content-Type': `application/json` },
         body: JSON.stringify(changes),
       })
       if (!response.ok)
diff --git a/examples/solid/todo/src/lib/collections.ts b/examples/solid/todo/src/lib/collections.ts
index 8b4aeb3f4..e252809e5 100644
--- a/examples/solid/todo/src/lib/collections.ts
+++ b/examples/solid/todo/src/lib/collections.ts
@@ -1,12 +1,12 @@
-import { createCollection } from "@tanstack/solid-db"
-import { electricCollectionOptions } from "@tanstack/electric-db-collection"
-import { queryCollectionOptions } from "@tanstack/query-db-collection"
-import { trailBaseCollectionOptions } from "@tanstack/trailbase-db-collection"
-import { QueryClient } from "@tanstack/query-core"
-import { initClient } from "trailbase"
-import { selectConfigSchema, selectTodoSchema } from "../db/validation"
-import { api } from "./api"
-import type { SelectConfig, SelectTodo } from "../db/validation"
+import { createCollection } from '@tanstack/solid-db'
+import { electricCollectionOptions } from '@tanstack/electric-db-collection'
+import { queryCollectionOptions } from '@tanstack/query-db-collection'
+import { trailBaseCollectionOptions } from '@tanstack/trailbase-db-collection'
+import { QueryClient } from '@tanstack/query-core'
+import { initClient } from 'trailbase'
+import { selectConfigSchema, selectTodoSchema } from '../db/validation'
+import { api } from './api'
+import type { SelectConfig, SelectTodo } from '../db/validation'
 
 // Create a query client for query collections
 const queryClient = new QueryClient()
@@ -45,7 +45,7 @@ export const electricTodoCollection = createCollection(
           const { original, changes } = mutation
           const response = await api.todos.update(original.id, changes)
           return response.txid
-        })
+        }),
       )
       return { txid: txids }
     },
@@ -55,11 +55,11 @@ export const electricTodoCollection = createCollection(
           const { original } = mutation
           const response = await api.todos.delete(original.id)
           return response.txid
-        })
+        }),
       )
       return { txid: txids }
     },
-  })
+  }),
 )
 
 // Query Todo Collection
@@ -93,7 +93,7 @@ export const queryTodoCollection = createCollection(
         transaction.mutations.map(async (mutation) => {
           const { original, changes } = mutation
           return await api.todos.update(original.id, changes)
-        })
+        }),
       )
     },
     onDelete: async ({ transaction }) => {
@@ -101,10 +101,10 @@ export const queryTodoCollection = createCollection(
         transaction.mutations.map(async (mutation) => {
           const { original } = mutation
           await api.todos.delete(original.id)
-        })
+        }),
       )
     },
-  })
+  }),
 )
 
 type Todo = {
@@ -120,7 +120,6 @@ export const trailBaseTodoCollection = createCollection(
   trailBaseCollectionOptions<SelectTodo, Todo>({
     id: `todos`,
     getKey: (item) => item.id,
-    schema: selectTodoSchema,
     recordApi: trailBaseClient.records(`todos`),
     // Re-using the example's drizzle-schema requires remapping the items.
     parse: {
@@ -131,7 +130,7 @@ export const trailBaseTodoCollection = createCollection(
       created_at: (date) => Math.floor(date.valueOf() / 1000),
       updated_at: (date) => Math.floor(date.valueOf() / 1000),
     },
-  })
+  }),
 )
 
 // Electric Config Collection
@@ -160,11 +159,11 @@ export const electricConfigCollection = createCollection(
           const { original, changes } = mutation
           const response = await api.config.update(original.id, changes)
           return response.txid
-        })
+        }),
       )
       return { txid: txids }
     },
-  })
+  }),
 )
 
 // Query Config Collection
@@ -195,11 +194,11 @@ export const queryConfigCollection = createCollection(
           const { original, changes } = mutation
           const response = await api.config.update(original.id, changes)
           return response.txid
-        })
+        }),
       )
       return { txid: txids }
     },
-  })
+  }),
 )
 
 type Config = {
@@ -215,7 +214,6 @@ export const trailBaseConfigCollection = createCollection(
   trailBaseCollectionOptions<SelectConfig, Config>({
     id: `config`,
     getKey: (item) => item.id,
-    schema: selectConfigSchema,
     recordApi: trailBaseClient.records(`config`),
     // Re-using the example's drizzle-schema requires remapping the items.
     parse: {
@@ -226,5 +224,5 @@ export const trailBaseConfigCollection = createCollection(
       created_at: (date) => Math.floor(date.valueOf() / 1000),
       updated_at: (date) => Math.floor(date.valueOf() / 1000),
     },
-  })
+  }),
 )
diff --git a/examples/solid/todo/src/main.tsx b/examples/solid/todo/src/main.tsx
deleted file mode 100644
index c165ede70..000000000
--- a/examples/solid/todo/src/main.tsx
+++ /dev/null
@@ -1,11 +0,0 @@
-import { RouterProvider } from "@tanstack/solid-router"
-import { createRouter } from "./router"
-import "./index.css"
-import { render } from "solid-js/web"
-
-const router = createRouter()
-
-render(
-  () => <RouterProvider router={router} />,
-  document.getElementById(`root`)!
-)
diff --git a/examples/solid/todo/src/routeTree.gen.ts b/examples/solid/todo/src/routeTree.gen.ts
index 149aec6dc..e567fc6d2 100644
--- a/examples/solid/todo/src/routeTree.gen.ts
+++ b/examples/solid/todo/src/routeTree.gen.ts
@@ -8,19 +8,15 @@
 // You should NOT make any changes in this file as it will be overwritten.
 // Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
 
-import { createServerRootRoute } from '@tanstack/solid-start/server'
-
 import { Route as rootRouteImport } from './routes/__root'
 import { Route as TrailbaseRouteImport } from './routes/trailbase'
 import { Route as QueryRouteImport } from './routes/query'
 import { Route as ElectricRouteImport } from './routes/electric'
 import { Route as IndexRouteImport } from './routes/index'
-import { ServerRoute as ApiTodosServerRouteImport } from './routes/api/todos'
-import { ServerRoute as ApiConfigServerRouteImport } from './routes/api/config'
-import { ServerRoute as ApiTodosIdServerRouteImport } from './routes/api/todos.$id'
-import { ServerRoute as ApiConfigIdServerRouteImport } from './routes/api/config.$id'
-
-const rootServerRouteImport = createServerRootRoute()
+import { Route as ApiTodosRouteImport } from './routes/api/todos'
+import { Route as ApiConfigRouteImport } from './routes/api/config'
+import { Route as ApiTodosIdRouteImport } from './routes/api/todos.$id'
+import { Route as ApiConfigIdRouteImport } from './routes/api/config.$id'
 
 const TrailbaseRoute = TrailbaseRouteImport.update({
   id: '/trailbase',
@@ -42,25 +38,25 @@ const IndexRoute = IndexRouteImport.update({
   path: '/',
   getParentRoute: () => rootRouteImport,
 } as any)
-const ApiTodosServerRoute = ApiTodosServerRouteImport.update({
+const ApiTodosRoute = ApiTodosRouteImport.update({
   id: '/api/todos',
   path: '/api/todos',
-  getParentRoute: () => rootServerRouteImport,
+  getParentRoute: () => rootRouteImport,
 } as any)
-const ApiConfigServerRoute = ApiConfigServerRouteImport.update({
+const ApiConfigRoute = ApiConfigRouteImport.update({
   id: '/api/config',
   path: '/api/config',
-  getParentRoute: () => rootServerRouteImport,
+  getParentRoute: () => rootRouteImport,
 } as any)
-const ApiTodosIdServerRoute = ApiTodosIdServerRouteImport.update({
+const ApiTodosIdRoute = ApiTodosIdRouteImport.update({
   id: '/$id',
   path: '/$id',
-  getParentRoute: () => ApiTodosServerRoute,
+  getParentRoute: () => ApiTodosRoute,
 } as any)
-const ApiConfigIdServerRoute = ApiConfigIdServerRouteImport.update({
+const ApiConfigIdRoute = ApiConfigIdRouteImport.update({
   id: '/$id',
   path: '/$id',
-  getParentRoute: () => ApiConfigServerRoute,
+  getParentRoute: () => ApiConfigRoute,
 } as any)
 
 export interface FileRoutesByFullPath {
@@ -68,12 +64,20 @@ export interface FileRoutesByFullPath {
   '/electric': typeof ElectricRoute
   '/query': typeof QueryRoute
   '/trailbase': typeof TrailbaseRoute
+  '/api/config': typeof ApiConfigRouteWithChildren
+  '/api/todos': typeof ApiTodosRouteWithChildren
+  '/api/config/$id': typeof ApiConfigIdRoute
+  '/api/todos/$id': typeof ApiTodosIdRoute
 }
 export interface FileRoutesByTo {
   '/': typeof IndexRoute
   '/electric': typeof ElectricRoute
   '/query': typeof QueryRoute
   '/trailbase': typeof TrailbaseRoute
+  '/api/config': typeof ApiConfigRouteWithChildren
+  '/api/todos': typeof ApiTodosRouteWithChildren
+  '/api/config/$id': typeof ApiConfigIdRoute
+  '/api/todos/$id': typeof ApiTodosIdRoute
 }
 export interface FileRoutesById {
   __root__: typeof rootRouteImport
@@ -81,56 +85,51 @@ export interface FileRoutesById {
   '/electric': typeof ElectricRoute
   '/query': typeof QueryRoute
   '/trailbase': typeof TrailbaseRoute
+  '/api/config': typeof ApiConfigRouteWithChildren
+  '/api/todos': typeof ApiTodosRouteWithChildren
+  '/api/config/$id': typeof ApiConfigIdRoute
+  '/api/todos/$id': typeof ApiTodosIdRoute
 }
 export interface FileRouteTypes {
   fileRoutesByFullPath: FileRoutesByFullPath
-  fullPaths: '/' | '/electric' | '/query' | '/trailbase'
+  fullPaths:
+    | '/'
+    | '/electric'
+    | '/query'
+    | '/trailbase'
+    | '/api/config'
+    | '/api/todos'
+    | '/api/config/$id'
+    | '/api/todos/$id'
   fileRoutesByTo: FileRoutesByTo
-  to: '/' | '/electric' | '/query' | '/trailbase'
-  id: '__root__' | '/' | '/electric' | '/query' | '/trailbase'
-  fileRoutesById: FileRoutesById
-}
-export interface RootRouteChildren {
-  IndexRoute: typeof IndexRoute
-  ElectricRoute: typeof ElectricRoute
-  QueryRoute: typeof QueryRoute
-  TrailbaseRoute: typeof TrailbaseRoute
-}
-export interface FileServerRoutesByFullPath {
-  '/api/config': typeof ApiConfigServerRouteWithChildren
-  '/api/todos': typeof ApiTodosServerRouteWithChildren
-  '/api/config/$id': typeof ApiConfigIdServerRoute
-  '/api/todos/$id': typeof ApiTodosIdServerRoute
-}
-export interface FileServerRoutesByTo {
-  '/api/config': typeof ApiConfigServerRouteWithChildren
-  '/api/todos': typeof ApiTodosServerRouteWithChildren
-  '/api/config/$id': typeof ApiConfigIdServerRoute
-  '/api/todos/$id': typeof ApiTodosIdServerRoute
-}
-export interface FileServerRoutesById {
-  __root__: typeof rootServerRouteImport
-  '/api/config': typeof ApiConfigServerRouteWithChildren
-  '/api/todos': typeof ApiTodosServerRouteWithChildren
-  '/api/config/$id': typeof ApiConfigIdServerRoute
-  '/api/todos/$id': typeof ApiTodosIdServerRoute
-}
-export interface FileServerRouteTypes {
-  fileServerRoutesByFullPath: FileServerRoutesByFullPath
-  fullPaths: '/api/config' | '/api/todos' | '/api/config/$id' | '/api/todos/$id'
-  fileServerRoutesByTo: FileServerRoutesByTo
-  to: '/api/config' | '/api/todos' | '/api/config/$id' | '/api/todos/$id'
+  to:
+    | '/'
+    | '/electric'
+    | '/query'
+    | '/trailbase'
+    | '/api/config'
+    | '/api/todos'
+    | '/api/config/$id'
+    | '/api/todos/$id'
   id:
     | '__root__'
+    | '/'
+    | '/electric'
+    | '/query'
+    | '/trailbase'
     | '/api/config'
     | '/api/todos'
     | '/api/config/$id'
     | '/api/todos/$id'
-  fileServerRoutesById: FileServerRoutesById
+  fileRoutesById: FileRoutesById
 }
-export interface RootServerRouteChildren {
-  ApiConfigServerRoute: typeof ApiConfigServerRouteWithChildren
-  ApiTodosServerRoute: typeof ApiTodosServerRouteWithChildren
+export interface RootRouteChildren {
+  IndexRoute: typeof IndexRoute
+  ElectricRoute: typeof ElectricRoute
+  QueryRoute: typeof QueryRoute
+  TrailbaseRoute: typeof TrailbaseRoute
+  ApiConfigRoute: typeof ApiConfigRouteWithChildren
+  ApiTodosRoute: typeof ApiTodosRouteWithChildren
 }
 
 declare module '@tanstack/solid-router' {
@@ -163,63 +162,59 @@ declare module '@tanstack/solid-router' {
       preLoaderRoute: typeof IndexRouteImport
       parentRoute: typeof rootRouteImport
     }
-  }
-}
-declare module '@tanstack/solid-start/server' {
-  interface ServerFileRoutesByPath {
     '/api/todos': {
       id: '/api/todos'
       path: '/api/todos'
       fullPath: '/api/todos'
-      preLoaderRoute: typeof ApiTodosServerRouteImport
-      parentRoute: typeof rootServerRouteImport
+      preLoaderRoute: typeof ApiTodosRouteImport
+      parentRoute: typeof rootRouteImport
     }
     '/api/config': {
       id: '/api/config'
       path: '/api/config'
       fullPath: '/api/config'
-      preLoaderRoute: typeof ApiConfigServerRouteImport
-      parentRoute: typeof rootServerRouteImport
+      preLoaderRoute: typeof ApiConfigRouteImport
+      parentRoute: typeof rootRouteImport
     }
     '/api/todos/$id': {
       id: '/api/todos/$id'
       path: '/$id'
       fullPath: '/api/todos/$id'
-      preLoaderRoute: typeof ApiTodosIdServerRouteImport
-      parentRoute: typeof ApiTodosServerRoute
+      preLoaderRoute: typeof ApiTodosIdRouteImport
+      parentRoute: typeof ApiTodosRoute
     }
     '/api/config/$id': {
       id: '/api/config/$id'
       path: '/$id'
       fullPath: '/api/config/$id'
-      preLoaderRoute: typeof ApiConfigIdServerRouteImport
-      parentRoute: typeof ApiConfigServerRoute
+      preLoaderRoute: typeof ApiConfigIdRouteImport
+      parentRoute: typeof ApiConfigRoute
     }
   }
 }
 
-interface ApiConfigServerRouteChildren {
-  ApiConfigIdServerRoute: typeof ApiConfigIdServerRoute
+interface ApiConfigRouteChildren {
+  ApiConfigIdRoute: typeof ApiConfigIdRoute
 }
 
-const ApiConfigServerRouteChildren: ApiConfigServerRouteChildren = {
-  ApiConfigIdServerRoute: ApiConfigIdServerRoute,
+const ApiConfigRouteChildren: ApiConfigRouteChildren = {
+  ApiConfigIdRoute: ApiConfigIdRoute,
 }
 
-const ApiConfigServerRouteWithChildren = ApiConfigServerRoute._addFileChildren(
-  ApiConfigServerRouteChildren,
+const ApiConfigRouteWithChildren = ApiConfigRoute._addFileChildren(
+  ApiConfigRouteChildren,
 )
 
-interface ApiTodosServerRouteChildren {
-  ApiTodosIdServerRoute: typeof ApiTodosIdServerRoute
+interface ApiTodosRouteChildren {
+  ApiTodosIdRoute: typeof ApiTodosIdRoute
 }
 
-const ApiTodosServerRouteChildren: ApiTodosServerRouteChildren = {
-  ApiTodosIdServerRoute: ApiTodosIdServerRoute,
+const ApiTodosRouteChildren: ApiTodosRouteChildren = {
+  ApiTodosIdRoute: ApiTodosIdRoute,
 }
 
-const ApiTodosServerRouteWithChildren = ApiTodosServerRoute._addFileChildren(
-  ApiTodosServerRouteChildren,
+const ApiTodosRouteWithChildren = ApiTodosRoute._addFileChildren(
+  ApiTodosRouteChildren,
 )
 
 const rootRouteChildren: RootRouteChildren = {
@@ -227,14 +222,19 @@ const rootRouteChildren: RootRouteChildren = {
   ElectricRoute: ElectricRoute,
   QueryRoute: QueryRoute,
   TrailbaseRoute: TrailbaseRoute,
+  ApiConfigRoute: ApiConfigRouteWithChildren,
+  ApiTodosRoute: ApiTodosRouteWithChildren,
 }
 export const routeTree = rootRouteImport
   ._addFileChildren(rootRouteChildren)
   ._addFileTypes<FileRouteTypes>()
-const rootServerRouteChildren: RootServerRouteChildren = {
-  ApiConfigServerRoute: ApiConfigServerRouteWithChildren,
-  ApiTodosServerRoute: ApiTodosServerRouteWithChildren,
+
+import type { getRouter } from './router.tsx'
+import type { startInstance } from './start.tsx'
+declare module '@tanstack/solid-start' {
+  interface Register {
+    ssr: true
+    router: Awaited<ReturnType<typeof getRouter>>
+    config: Awaited<ReturnType<typeof startInstance.getOptions>>
+  }
 }
-export const serverRouteTree = rootServerRouteImport
-  ._addFileChildren(rootServerRouteChildren)
-  ._addFileTypes<FileServerRouteTypes>()
diff --git a/examples/solid/todo/src/router.tsx b/examples/solid/todo/src/router.tsx
index df1b297ce..35abef268 100644
--- a/examples/solid/todo/src/router.tsx
+++ b/examples/solid/todo/src/router.tsx
@@ -1,26 +1,17 @@
-import { createRouter as createTanstackRouter } from "@tanstack/solid-router"
+import { createRouter as createTanstackRouter } from '@tanstack/solid-router'
 
 // Import the generated route tree
-import { routeTree } from "./routeTree.gen"
-import { NotFound } from "./components/NotFound"
+import { routeTree } from './routeTree.gen'
+import { NotFound } from './components/NotFound'
 
-import "./styles.css"
+import './styles.css'
 
 // Create a new router instance
-export const createRouter = () => {
-  const router = createTanstackRouter({
+export function getRouter() {
+  return createTanstackRouter({
     routeTree,
     scrollRestoration: true,
     defaultPreloadStaleTime: 0,
     defaultNotFoundComponent: NotFound,
   })
-
-  return router
-}
-
-// Register the router instance for type safety
-declare module "@tanstack/solid-router" {
-  interface Register {
-    router: ReturnType<typeof createRouter>
-  }
 }
diff --git a/examples/solid/todo/src/routes/__root.tsx b/examples/solid/todo/src/routes/__root.tsx
index 33569b3b9..dde228f17 100644
--- a/examples/solid/todo/src/routes/__root.tsx
+++ b/examples/solid/todo/src/routes/__root.tsx
@@ -1,6 +1,12 @@
-import { Outlet, createRootRoute } from "@tanstack/solid-router"
-
-import appCss from "../styles.css?url"
+import {
+  HeadContent,
+  Outlet,
+  Scripts,
+  createRootRoute,
+} from '@tanstack/solid-router'
+import { HydrationScript } from 'solid-js/web'
+import appCss from '../styles.css?url'
+import type { ParentProps } from 'solid-js'
 
 export const Route = createRootRoute({
   head: () => ({
@@ -23,6 +29,21 @@ export const Route = createRootRoute({
       },
     ],
   }),
-
+  shellComponent: RootDocument,
   component: () => <Outlet />,
 })
+
+function RootDocument(props: ParentProps) {
+  return (
+    <html lang="en">
+      <head>
+        <HeadContent />
+        <HydrationScript />
+      </head>
+      <body>
+        {props.children}
+        <Scripts />
+      </body>
+    </html>
+  )
+}
diff --git a/examples/solid/todo/src/routes/api/config.$id.ts b/examples/solid/todo/src/routes/api/config.$id.ts
index 829b73dc6..160aee8b1 100644
--- a/examples/solid/todo/src/routes/api/config.$id.ts
+++ b/examples/solid/todo/src/routes/api/config.$id.ts
@@ -1,8 +1,8 @@
-import { createServerFileRoute } from "@tanstack/solid-start/server"
-import { json } from "@tanstack/solid-start"
-import { sql } from "../../db/postgres"
-import { validateUpdateConfig } from "../../db/validation"
-import type { Txid } from "@tanstack/electric-db-collection"
+import { createFileRoute } from '@tanstack/solid-router'
+import { json } from '@tanstack/solid-start'
+import { sql } from '../../db/postgres'
+import { validateUpdateConfig } from '../../db/validation'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Generate a transaction ID
 async function generateTxId(tx: any): Promise<Txid> {
@@ -16,101 +16,105 @@ async function generateTxId(tx: any): Promise<Txid> {
   return parseInt(txid, 10)
 }
 
-export const ServerRoute = createServerFileRoute(`/api/config/$id`).methods({
-  GET: async ({ params }) => {
-    try {
-      const { id } = params
-      const [config] = await sql`SELECT * FROM config WHERE id = ${id}`
-
-      if (!config) {
-        return json({ error: `Config not found` }, { status: 404 })
-      }
-
-      return json(config)
-    } catch (error) {
-      console.error(`Error fetching config:`, error)
-      return json(
-        {
-          error: `Failed to fetch config`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
-  },
-  PUT: async ({ params, request }) => {
-    try {
-      const { id } = params
-      const body = await request.json()
-      const configData = validateUpdateConfig(body)
-
-      let txid!: Txid
-      const updatedConfig = await sql.begin(async (tx) => {
-        txid = await generateTxId(tx)
-
-        const [result] = await tx`
+export const Route = createFileRoute(`/api/config/$id`)({
+  server: {
+    handlers: {
+      GET: async ({ params }) => {
+        try {
+          const { id } = params
+          const [config] = await sql`SELECT * FROM config WHERE id = ${id}`
+
+          if (!config) {
+            return json({ error: `Config not found` }, { status: 404 })
+          }
+
+          return json(config)
+        } catch (error) {
+          console.error(`Error fetching config:`, error)
+          return json(
+            {
+              error: `Failed to fetch config`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
+        }
+      },
+      PUT: async ({ params, request }) => {
+        try {
+          const { id } = params
+          const body = await request.json()
+          const configData = validateUpdateConfig(body)
+
+          let txid!: Txid
+          const updatedConfig = await sql.begin(async (tx) => {
+            txid = await generateTxId(tx)
+
+            const [result] = await tx`
           UPDATE config
           SET ${tx(configData)}
           WHERE id = ${id}
           RETURNING *
         `
 
-        if (!result) {
-          throw new Error(`Config not found`)
+            if (!result) {
+              throw new Error(`Config not found`)
+            }
+
+            return result
+          })
+
+          return json({ config: updatedConfig, txid })
+        } catch (error) {
+          if (error instanceof Error && error.message === `Config not found`) {
+            return json({ error: `Config not found` }, { status: 404 })
+          }
+
+          console.error(`Error updating config:`, error)
+          return json(
+            {
+              error: `Failed to update config`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
         }
+      },
+      DELETE: async ({ params }) => {
+        try {
+          const { id } = params
 
-        return result
-      })
-
-      return json({ config: updatedConfig, txid })
-    } catch (error) {
-      if (error instanceof Error && error.message === `Config not found`) {
-        return json({ error: `Config not found` }, { status: 404 })
-      }
-
-      console.error(`Error updating config:`, error)
-      return json(
-        {
-          error: `Failed to update config`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
-  },
-  DELETE: async ({ params }) => {
-    try {
-      const { id } = params
-
-      let txid!: Txid
-      await sql.begin(async (tx) => {
-        txid = await generateTxId(tx)
+          let txid!: Txid
+          await sql.begin(async (tx) => {
+            txid = await generateTxId(tx)
 
-        const [result] = await tx`
+            const [result] = await tx`
           DELETE FROM config
           WHERE id = ${id}
           RETURNING id
         `
 
-        if (!result) {
-          throw new Error(`Config not found`)
+            if (!result) {
+              throw new Error(`Config not found`)
+            }
+          })
+
+          return json({ success: true, txid })
+        } catch (error) {
+          if (error instanceof Error && error.message === `Config not found`) {
+            return json({ error: `Config not found` }, { status: 404 })
+          }
+
+          console.error(`Error deleting config:`, error)
+          return json(
+            {
+              error: `Failed to delete config`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
         }
-      })
-
-      return json({ success: true, txid })
-    } catch (error) {
-      if (error instanceof Error && error.message === `Config not found`) {
-        return json({ error: `Config not found` }, { status: 404 })
-      }
-
-      console.error(`Error deleting config:`, error)
-      return json(
-        {
-          error: `Failed to delete config`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
+      },
+    },
   },
 })
diff --git a/examples/solid/todo/src/routes/api/config.ts b/examples/solid/todo/src/routes/api/config.ts
index e5b9fd724..cd0cd5657 100644
--- a/examples/solid/todo/src/routes/api/config.ts
+++ b/examples/solid/todo/src/routes/api/config.ts
@@ -1,8 +1,8 @@
-import { createServerFileRoute } from "@tanstack/solid-start/server"
-import { json } from "@tanstack/solid-start"
-import { sql } from "../../db/postgres"
-import { validateInsertConfig } from "../../db/validation"
-import type { Txid } from "@tanstack/electric-db-collection"
+import { createFileRoute } from '@tanstack/solid-router'
+import { json } from '@tanstack/solid-start'
+import { sql } from '../../db/postgres'
+import { validateInsertConfig } from '../../db/validation'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Generate a transaction ID
 async function generateTxId(tx: any): Promise<Txid> {
@@ -16,49 +16,53 @@ async function generateTxId(tx: any): Promise<Txid> {
   return parseInt(txid, 10)
 }
 
-export const ServerRoute = createServerFileRoute(`/api/config`).methods({
-  GET: async ({ request: _request }) => {
-    try {
-      const config = await sql`SELECT * FROM config`
-      return json(config)
-    } catch (error) {
-      console.error(`Error fetching config:`, error)
-      return json(
-        {
-          error: `Failed to fetch config`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
-  },
-  POST: async ({ request }) => {
-    try {
-      const body = await request.json()
-      console.log(`POST /api/config`, body)
-      const configData = validateInsertConfig(body)
+export const Route = createFileRoute(`/api/config`)({
+  server: {
+    handlers: {
+      GET: async ({ request: _request }) => {
+        try {
+          const config = await sql`SELECT * FROM config`
+          return json(config)
+        } catch (error) {
+          console.error(`Error fetching config:`, error)
+          return json(
+            {
+              error: `Failed to fetch config`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
+        }
+      },
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json()
+          console.log(`POST /api/config`, body)
+          const configData = validateInsertConfig(body)
 
-      let txid!: Txid
-      const newConfig = await sql.begin(async (tx) => {
-        txid = await generateTxId(tx)
+          let txid!: Txid
+          const newConfig = await sql.begin(async (tx) => {
+            txid = await generateTxId(tx)
 
-        const [result] = await tx`
+            const [result] = await tx`
           INSERT INTO config ${tx(configData)}
           RETURNING *
         `
-        return result
-      })
+            return result
+          })
 
-      return json({ config: newConfig, txid }, { status: 201 })
-    } catch (error) {
-      console.error(`Error creating config:`, error)
-      return json(
-        {
-          error: `Failed to create config`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
+          return json({ config: newConfig, txid }, { status: 201 })
+        } catch (error) {
+          console.error(`Error creating config:`, error)
+          return json(
+            {
+              error: `Failed to create config`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
+        }
+      },
+    },
   },
 })
diff --git a/examples/solid/todo/src/routes/api/todos.$id.ts b/examples/solid/todo/src/routes/api/todos.$id.ts
index d1ec5c187..3b2b742cd 100644
--- a/examples/solid/todo/src/routes/api/todos.$id.ts
+++ b/examples/solid/todo/src/routes/api/todos.$id.ts
@@ -1,8 +1,8 @@
-import { createServerFileRoute } from "@tanstack/solid-start/server"
-import { json } from "@tanstack/solid-start"
-import { sql } from "../../db/postgres"
-import { validateUpdateTodo } from "../../db/validation"
-import type { Txid } from "@tanstack/electric-db-collection"
+import { createFileRoute } from '@tanstack/solid-router'
+import { json } from '@tanstack/solid-start'
+import { sql } from '../../db/postgres'
+import { validateUpdateTodo } from '../../db/validation'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Generate a transaction ID
 async function generateTxId(tx: any): Promise<Txid> {
@@ -16,101 +16,105 @@ async function generateTxId(tx: any): Promise<Txid> {
   return parseInt(txid, 10)
 }
 
-export const ServerRoute = createServerFileRoute(`/api/todos/$id`).methods({
-  GET: async ({ params }) => {
-    try {
-      const { id } = params
-      const [todo] = await sql`SELECT * FROM todos WHERE id = ${id}`
-
-      if (!todo) {
-        return json({ error: `Todo not found` }, { status: 404 })
-      }
-
-      return json(todo)
-    } catch (error) {
-      console.error(`Error fetching todo:`, error)
-      return json(
-        {
-          error: `Failed to fetch todo`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
-  },
-  PUT: async ({ params, request }) => {
-    try {
-      const { id } = params
-      const body = await request.json()
-      const todoData = validateUpdateTodo(body)
-
-      let txid!: Txid
-      const updatedTodo = await sql.begin(async (tx) => {
-        txid = await generateTxId(tx)
-
-        const [result] = await tx`
+export const Route = createFileRoute(`/api/todos/$id`)({
+  server: {
+    handlers: {
+      GET: async ({ params }) => {
+        try {
+          const { id } = params
+          const [todo] = await sql`SELECT * FROM todos WHERE id = ${id}`
+
+          if (!todo) {
+            return json({ error: `Todo not found` }, { status: 404 })
+          }
+
+          return json(todo)
+        } catch (error) {
+          console.error(`Error fetching todo:`, error)
+          return json(
+            {
+              error: `Failed to fetch todo`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
+        }
+      },
+      PUT: async ({ params, request }) => {
+        try {
+          const { id } = params
+          const body = await request.json()
+          const todoData = validateUpdateTodo(body)
+
+          let txid!: Txid
+          const updatedTodo = await sql.begin(async (tx) => {
+            txid = await generateTxId(tx)
+
+            const [result] = await tx`
           UPDATE todos
           SET ${tx(todoData)}
           WHERE id = ${id}
           RETURNING *
         `
 
-        if (!result) {
-          throw new Error(`Todo not found`)
+            if (!result) {
+              throw new Error(`Todo not found`)
+            }
+
+            return result
+          })
+
+          return json({ todo: updatedTodo, txid })
+        } catch (error) {
+          if (error instanceof Error && error.message === `Todo not found`) {
+            return json({ error: `Todo not found` }, { status: 404 })
+          }
+
+          console.error(`Error updating todo:`, error)
+          return json(
+            {
+              error: `Failed to update todo`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
         }
+      },
+      DELETE: async ({ params }) => {
+        try {
+          const { id } = params
 
-        return result
-      })
-
-      return json({ todo: updatedTodo, txid })
-    } catch (error) {
-      if (error instanceof Error && error.message === `Todo not found`) {
-        return json({ error: `Todo not found` }, { status: 404 })
-      }
-
-      console.error(`Error updating todo:`, error)
-      return json(
-        {
-          error: `Failed to update todo`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
-  },
-  DELETE: async ({ params }) => {
-    try {
-      const { id } = params
-
-      let txid!: Txid
-      await sql.begin(async (tx) => {
-        txid = await generateTxId(tx)
+          let txid!: Txid
+          await sql.begin(async (tx) => {
+            txid = await generateTxId(tx)
 
-        const [result] = await tx`
+            const [result] = await tx`
           DELETE FROM todos
           WHERE id = ${id}
           RETURNING id
         `
 
-        if (!result) {
-          throw new Error(`Todo not found`)
+            if (!result) {
+              throw new Error(`Todo not found`)
+            }
+          })
+
+          return json({ success: true, txid })
+        } catch (error) {
+          if (error instanceof Error && error.message === `Todo not found`) {
+            return json({ error: `Todo not found` }, { status: 404 })
+          }
+
+          console.error(`Error deleting todo:`, error)
+          return json(
+            {
+              error: `Failed to delete todo`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
         }
-      })
-
-      return json({ success: true, txid })
-    } catch (error) {
-      if (error instanceof Error && error.message === `Todo not found`) {
-        return json({ error: `Todo not found` }, { status: 404 })
-      }
-
-      console.error(`Error deleting todo:`, error)
-      return json(
-        {
-          error: `Failed to delete todo`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
+      },
+    },
   },
 })
diff --git a/examples/solid/todo/src/routes/api/todos.ts b/examples/solid/todo/src/routes/api/todos.ts
index ab4e6aeb2..b28c649c1 100644
--- a/examples/solid/todo/src/routes/api/todos.ts
+++ b/examples/solid/todo/src/routes/api/todos.ts
@@ -1,8 +1,8 @@
-import { createServerFileRoute } from "@tanstack/solid-start/server"
-import { json } from "@tanstack/solid-start"
-import { sql } from "../../db/postgres"
-import { validateInsertTodo } from "../../db/validation"
-import type { Txid } from "@tanstack/electric-db-collection"
+import { createFileRoute } from '@tanstack/solid-router'
+import { json } from '@tanstack/solid-start'
+import { sql } from '../../db/postgres'
+import { validateInsertTodo } from '../../db/validation'
+import type { Txid } from '@tanstack/electric-db-collection'
 
 // Generate a transaction ID
 async function generateTxId(tx: any): Promise<Txid> {
@@ -20,48 +20,52 @@ async function generateTxId(tx: any): Promise<Txid> {
   return parseInt(txid, 10)
 }
 
-export const ServerRoute = createServerFileRoute(`/api/todos`).methods({
-  GET: async ({ request: _request }) => {
-    try {
-      const todos = await sql`SELECT * FROM todos`
-      return json(todos)
-    } catch (error) {
-      console.error(`Error fetching todos:`, error)
-      return json(
-        {
-          error: `Failed to fetch todos`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
-  },
-  POST: async ({ request }) => {
-    try {
-      const body = await request.json()
-      const todoData = validateInsertTodo(body)
+export const Route = createFileRoute(`/api/todos`)({
+  server: {
+    handlers: {
+      GET: async ({ request: _request }) => {
+        try {
+          const todos = await sql`SELECT * FROM todos`
+          return json(todos)
+        } catch (error) {
+          console.error(`Error fetching todos:`, error)
+          return json(
+            {
+              error: `Failed to fetch todos`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
+        }
+      },
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json()
+          const todoData = validateInsertTodo(body)
 
-      let txid!: Txid
-      const newTodo = await sql.begin(async (tx) => {
-        txid = await generateTxId(tx)
+          let txid!: Txid
+          const newTodo = await sql.begin(async (tx) => {
+            txid = await generateTxId(tx)
 
-        const [result] = await tx`
+            const [result] = await tx`
           INSERT INTO todos ${tx(todoData)}
           RETURNING *
         `
-        return result
-      })
+            return result
+          })
 
-      return json({ todo: newTodo, txid }, { status: 201 })
-    } catch (error) {
-      console.error(`Error creating todo:`, error)
-      return json(
-        {
-          error: `Failed to create todo`,
-          details: error instanceof Error ? error.message : String(error),
-        },
-        { status: 500 }
-      )
-    }
+          return json({ todo: newTodo, txid }, { status: 201 })
+        } catch (error) {
+          console.error(`Error creating todo:`, error)
+          return json(
+            {
+              error: `Failed to create todo`,
+              details: error instanceof Error ? error.message : String(error),
+            },
+            { status: 500 },
+          )
+        }
+      },
+    },
   },
 })
diff --git a/examples/solid/todo/src/routes/electric.tsx b/examples/solid/todo/src/routes/electric.tsx
index 0908e09a8..63442e719 100644
--- a/examples/solid/todo/src/routes/electric.tsx
+++ b/examples/solid/todo/src/routes/electric.tsx
@@ -1,10 +1,11 @@
-import { createFileRoute } from "@tanstack/solid-router"
-import { useLiveQuery } from "@tanstack/solid-db"
+import { createFileRoute } from '@tanstack/solid-router'
+import { useLiveQuery } from '@tanstack/solid-db'
+import { Suspense } from 'solid-js'
 import {
   electricConfigCollection,
   electricTodoCollection,
-} from "../lib/collections"
-import { TodoApp } from "../components/TodoApp"
+} from '../lib/collections'
+import { TodoApp } from '../components/TodoApp'
 
 export const Route = createFileRoute(`/electric`)({
   component: ElectricPage,
@@ -21,23 +22,25 @@ export const Route = createFileRoute(`/electric`)({
 
 function ElectricPage() {
   // Get data using live queries with Electric collections
-  const { data: todos } = useLiveQuery((q) =>
+  const todos = useLiveQuery((q) =>
     q
       .from({ todo: electricTodoCollection })
-      .orderBy(({ todo }) => todo.created_at, `asc`)
+      .orderBy(({ todo }) => todo.created_at, `asc`),
   )
 
-  const { data: configData } = useLiveQuery((q) =>
-    q.from({ config: electricConfigCollection })
+  const configData = useLiveQuery((q) =>
+    q.from({ config: electricConfigCollection }),
   )
 
   return (
-    <TodoApp
-      todos={todos}
-      configData={configData}
-      todoCollection={electricTodoCollection}
-      configCollection={electricConfigCollection}
-      title="todos (electric)"
-    />
+    <Suspense fallback="Loading...">
+      <TodoApp
+        todos={todos()}
+        configData={configData()}
+        todoCollection={electricTodoCollection}
+        configCollection={electricConfigCollection}
+        title="todos (electric)"
+      />
+    </Suspense>
   )
 }
diff --git a/examples/solid/todo/src/routes/index.tsx b/examples/solid/todo/src/routes/index.tsx
index 584243c5d..dee31989a 100644
--- a/examples/solid/todo/src/routes/index.tsx
+++ b/examples/solid/todo/src/routes/index.tsx
@@ -1,4 +1,4 @@
-import { Link, createFileRoute } from "@tanstack/solid-router"
+import { Link, createFileRoute } from '@tanstack/solid-router'
 
 export const Route = createFileRoute(`/`)({
   component: HomePage,
diff --git a/examples/solid/todo/src/routes/query.tsx b/examples/solid/todo/src/routes/query.tsx
index 8423d82b4..5523668ac 100644
--- a/examples/solid/todo/src/routes/query.tsx
+++ b/examples/solid/todo/src/routes/query.tsx
@@ -1,7 +1,8 @@
-import { createFileRoute } from "@tanstack/solid-router"
-import { useLiveQuery } from "@tanstack/solid-db"
-import { queryConfigCollection, queryTodoCollection } from "../lib/collections"
-import { TodoApp } from "../components/TodoApp"
+import { createFileRoute } from '@tanstack/solid-router'
+import { useLiveQuery } from '@tanstack/solid-db'
+import { Suspense } from 'solid-js'
+import { queryConfigCollection, queryTodoCollection } from '../lib/collections'
+import { TodoApp } from '../components/TodoApp'
 
 export const Route = createFileRoute(`/query`)({
   component: QueryPage,
@@ -18,23 +19,25 @@ export const Route = createFileRoute(`/query`)({
 
 function QueryPage() {
   // Get data using live queries with Query collections
-  const { data: todos } = useLiveQuery((q) =>
+  const todos = useLiveQuery((q) =>
     q
       .from({ todo: queryTodoCollection })
-      .orderBy(({ todo }) => todo.created_at, `asc`)
+      .orderBy(({ todo }) => todo.created_at, `asc`),
   )
 
-  const { data: configData } = useLiveQuery((q) =>
-    q.from({ config: queryConfigCollection })
+  const configData = useLiveQuery((q) =>
+    q.from({ config: queryConfigCollection }),
   )
 
   return (
-    <TodoApp
-      todos={todos}
-      configData={configData}
-      todoCollection={queryTodoCollection}
-      configCollection={queryConfigCollection}
-      title="todos (query)"
-    />
+    <Suspense fallback="Loading...">
+      <TodoApp
+        todos={todos()}
+        configData={configData()}
+        todoCollection={queryTodoCollection}
+        configCollection={queryConfigCollection}
+        title="todos (query)"
+      />
+    </Suspense>
   )
 }
diff --git a/examples/solid/todo/src/routes/trailbase.tsx b/examples/solid/todo/src/routes/trailbase.tsx
index ed35fca34..c9f450ea4 100644
--- a/examples/solid/todo/src/routes/trailbase.tsx
+++ b/examples/solid/todo/src/routes/trailbase.tsx
@@ -1,10 +1,10 @@
-import { createFileRoute } from "@tanstack/solid-router"
-import { useLiveQuery } from "@tanstack/solid-db"
+import { createFileRoute } from '@tanstack/solid-router'
+import { useLiveQuery } from '@tanstack/solid-db'
 import {
   trailBaseConfigCollection,
   trailBaseTodoCollection,
-} from "../lib/collections"
-import { TodoApp } from "../components/TodoApp"
+} from '../lib/collections'
+import { TodoApp } from '../components/TodoApp'
 
 export const Route = createFileRoute(`/trailbase`)({
   component: TrailBasePage,
@@ -24,11 +24,11 @@ function TrailBasePage() {
   const { data: todos } = useLiveQuery((q) =>
     q
       .from({ todo: trailBaseTodoCollection })
-      .orderBy(({ todo }) => todo.created_at, `asc`)
+      .orderBy(({ todo }) => todo.created_at, `asc`),
   )
 
   const { data: configData } = useLiveQuery((q) =>
-    q.from({ config: trailBaseConfigCollection })
+    q.from({ config: trailBaseConfigCollection }),
   )
 
   return (
diff --git a/examples/solid/todo/src/server.ts b/examples/solid/todo/src/server.ts
new file mode 100644
index 000000000..3682c04c2
--- /dev/null
+++ b/examples/solid/todo/src/server.ts
@@ -0,0 +1,7 @@
+import handler from '@tanstack/solid-start/server-entry'
+
+export default {
+  fetch(request: Request) {
+    return handler.fetch(request)
+  },
+}
diff --git a/examples/solid/todo/src/start.tsx b/examples/solid/todo/src/start.tsx
new file mode 100644
index 000000000..9c70dc5c4
--- /dev/null
+++ b/examples/solid/todo/src/start.tsx
@@ -0,0 +1,7 @@
+import { createStart } from '@tanstack/solid-start'
+
+export const startInstance = createStart(() => {
+  return {
+    defaultSsr: false,
+  }
+})
diff --git a/examples/solid/todo/src/styles.css b/examples/solid/todo/src/styles.css
index 80cb92ada..06f1bca4b 100644
--- a/examples/solid/todo/src/styles.css
+++ b/examples/solid/todo/src/styles.css
@@ -1,15 +1,15 @@
-@import "tailwindcss";
+@import 'tailwindcss';
 
 body {
   @apply m-0;
   font-family:
-    -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu",
-    "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif;
+    -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;
 }
 
 code {
   font-family:
-    source-code-pro, Menlo, Monaco, Consolas, "Courier New", monospace;
+    source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
 }
diff --git a/examples/solid/todo/vite.config.ts b/examples/solid/todo/vite.config.ts
index 44199b888..620fb5e6d 100644
--- a/examples/solid/todo/vite.config.ts
+++ b/examples/solid/todo/vite.config.ts
@@ -1,8 +1,8 @@
-import { defineConfig } from "vite"
-import solid from "vite-plugin-solid"
-import tailwindcss from "@tailwindcss/vite"
-import { tanstackStart } from "@tanstack/solid-start/plugin/vite"
-import viteTsConfigPaths from "vite-tsconfig-paths"
+import { defineConfig } from 'vite'
+import solid from 'vite-plugin-solid'
+import tailwindcss from '@tailwindcss/vite'
+import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
+import viteTsConfigPaths from 'vite-tsconfig-paths'
 
 // https://vitejs.dev/config/
 export default defineConfig({
@@ -13,11 +13,9 @@ export default defineConfig({
     }),
     tailwindcss(),
     tanstackStart({
-      customViteSolidPlugin: true,
-      spa: {
-        prerender: { enabled: false },
-        enabled: true,
-      },
+      srcDirectory: `src`,
+      start: { entry: `./start.tsx` },
+      server: { entry: `./server.ts` },
     }),
     solid({ ssr: true }),
   ],
diff --git a/package.json b/package.json
index 6be9d8530..cead7ae34 100644
--- a/package.json
+++ b/package.json
@@ -3,55 +3,63 @@
   "private": true,
   "repository": {
     "type": "git",
-    "url": "https://github.com/tanstack/db.git"
+    "url": "git+https://github.com/TanStack/db.git"
   },
-  "packageManager": "pnpm@10.18.3",
+  "packageManager": "pnpm@10.27.0",
   "type": "module",
+  "pnpm": {
+    "overrides": {
+      "metro": "0.82.5"
+    }
+  },
   "scripts": {
     "build": "pnpm --filter \"./packages/**\" build",
+    "build:minified": "pnpm --filter \"./packages/**\" build:minified",
     "changeset": "changeset",
     "changeset:publish": "changeset publish",
-    "changeset:version": "changeset version && pnpm install --no-frozen-lockfile",
-    "docs:generate": "node scripts/generateDocs.js",
-    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,json,md}\"",
+    "changeset:version": "changeset version && tsx scripts/update-example-deps.ts && pnpm install --no-frozen-lockfile",
+    "format": "prettier --experimental-cli --ignore-unknown '**/*' --write",
     "lint": "pnpm --filter \"./packages/**\" lint",
     "lint-all": "eslint . --fix",
     "prepare": "husky",
     "test": "pnpm --filter \"./packages/**\" test",
-    "test:verify-links": "node scripts/verify-links.ts"
+    "test:docs": "node scripts/verify-links.ts",
+    "test:sherif": "sherif -i zod",
+    "generate-docs": "node scripts/generate-docs.ts"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.29.7",
-    "@eslint/js": "^9.38.0",
-    "@stylistic/eslint-plugin": "^4.4.1",
+    "@changesets/cli": "^2.29.8",
+    "@eslint/js": "^9.39.2",
+    "@fast-check/vitest": "^0.2.0",
     "@svitejs/changesets-changelog-github-compact": "^1.2.0",
-    "@tanstack/config": "^0.22.0",
+    "@tanstack/eslint-config": "0.3.4",
+    "@tanstack/typedoc-config": "0.3.3",
+    "@tanstack/vite-config": "0.4.3",
     "@testing-library/jest-dom": "^6.9.1",
     "@types/node": "^24.6.2",
-    "@types/react": "^19.2.2",
-    "@types/react-dom": "^19.2.2",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
     "@types/use-sync-external-store": "^1.5.0",
-    "@typescript-eslint/eslint-plugin": "^8.46.1",
-    "@typescript-eslint/parser": "^8.46.1",
-    "@vitejs/plugin-react": "^5.0.4",
-    "eslint": "^9.38.0",
-    "eslint-config-prettier": "^10.1.8",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
+    "@vitejs/plugin-react": "^5.1.2",
+    "eslint": "^9.39.2",
     "eslint-import-resolver-typescript": "^4.4.4",
-    "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-react": "^7.37.5",
+    "fast-check": "^3.23.0",
     "husky": "^9.1.7",
-    "jsdom": "^27.0.1",
-    "knip": "^5.66.1",
+    "jsdom": "^27.4.0",
+    "knip": "^5.79.0",
     "lint-staged": "^15.5.2",
-    "markdown-link-extractor": "^4.0.2",
-    "mitt": "^3.0.1",
-    "prettier": "^3.6.2",
-    "publint": "^0.3.14",
-    "sherif": "^1.6.1",
+    "markdown-link-extractor": "^4.0.3",
+    "prettier": "^3.7.4",
+    "publint": "^0.3.16",
+    "sherif": "^1.9.0",
     "shx": "^0.4.0",
     "tinyglobby": "^0.2.15",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.2",
-    "vite": "^7.1.10",
+    "vite": "^7.3.0",
     "vitest": "^3.2.4",
     "zod": "^3.25.76"
   },
diff --git a/packages/angular-db/CHANGELOG.md b/packages/angular-db/CHANGELOG.md
index 139e5fddc..5e4b7b063 100644
--- a/packages/angular-db/CHANGELOG.md
+++ b/packages/angular-db/CHANGELOG.md
@@ -1,5 +1,249 @@
 # @tanstack/angular-db
 
+## 0.1.50
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 0.1.49
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 0.1.48
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 0.1.47
+
+### Patch Changes
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 0.1.46
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 0.1.45
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 0.1.44
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 0.1.43
+
+### Patch Changes
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 0.1.42
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 0.1.41
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 0.1.40
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 0.1.39
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 0.1.38
+
+### Patch Changes
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 0.1.37
+
+### Patch Changes
+
+- Fixed `isReady` to return `true` for disabled queries in `useLiveQuery`/`injectLiveQuery` across all framework packages. When a query function returns `null` or `undefined` (disabling the query), there's no async operation to wait for, so the hook should be considered "ready" immediately. ([#886](https://github.com/TanStack/db/pull/886))
+
+  Additionally, all frameworks now have proper TypeScript overloads that explicitly support returning `undefined | null` from query functions, making the disabled query pattern type-safe.
+
+  This fixes the common pattern where users conditionally enable queries and don't want to show loading states when the query is disabled.
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 0.1.36
+
+### Patch Changes
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/db@0.5.10
+
+## 0.1.35
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+
+## 0.1.34
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+
+## 0.1.33
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+
+## 0.1.32
+
+### Patch Changes
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 0.1.31
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 0.1.30
+
+### Patch Changes
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 0.1.29
+
+### Patch Changes
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 0.1.28
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+
+## 0.1.27
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 0.1.26
+
+### Patch Changes
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.1.25
+
+### Patch Changes
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.1.24
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.1.23
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.1.22
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+
+## 0.1.21
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+
+## 0.1.20
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+
+## 0.1.19
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+
+## 0.1.18
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+
+## 0.1.17
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+
 ## 0.1.16
 
 ### Patch Changes
diff --git a/packages/angular-db/package.json b/packages/angular-db/package.json
index b30556162..e6cdf0534 100644
--- a/packages/angular-db/package.json
+++ b/packages/angular-db/package.json
@@ -1,12 +1,12 @@
 {
   "name": "@tanstack/angular-db",
+  "version": "0.1.50",
   "description": "Angular integration for @tanstack/db",
-  "version": "0.1.16",
   "author": "Ethan McDaniel",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/TanStack/db.git",
+    "url": "git+https://github.com/TanStack/db.git",
     "directory": "packages/angular-db"
   },
   "homepage": "https://tanstack.com/db",
@@ -15,20 +15,16 @@
     "angular",
     "typescript"
   ],
-  "packageManager": "pnpm@10.18.3",
-  "dependencies": {
-    "@tanstack/db": "workspace:*"
-  },
-  "devDependencies": {
-    "@angular/common": "^19.2.15",
-    "@angular/compiler": "^19.2.15",
-    "@angular/core": "^19.2.15",
-    "@angular/platform-browser": "^19.2.15",
-    "@angular/platform-browser-dynamic": "^19.2.15",
-    "@vitest/coverage-istanbul": "^3.2.4",
-    "rxjs": "^7.8.2",
-    "zone.js": "^0.15.1"
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "vitest --run",
+    "lint": "eslint . --fix"
   },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -42,23 +38,26 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
+  "dependencies": {
+    "@tanstack/db": "workspace:*"
+  },
   "peerDependencies": {
     "@angular/core": ">=16.0.0",
     "rxjs": ">=6.0.0"
   },
-  "scripts": {
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "test": "npx vitest --run",
-    "lint": "eslint . --fix"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "devDependencies": {
+    "@angular/common": "^19.2.17",
+    "@angular/compiler": "^20.3.15",
+    "@angular/core": "^19.2.17",
+    "@angular/platform-browser": "^19.2.17",
+    "@angular/platform-browser-dynamic": "^19.2.17",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "rxjs": "^7.8.2",
+    "zone.js": "^0.16.0"
+  }
 }
diff --git a/packages/angular-db/src/index.ts b/packages/angular-db/src/index.ts
index b2080b3e4..e96a70de2 100644
--- a/packages/angular-db/src/index.ts
+++ b/packages/angular-db/src/index.ts
@@ -5,8 +5,8 @@ import {
   effect,
   inject,
   signal,
-} from "@angular/core"
-import { createLiveQueryCollection } from "@tanstack/db"
+} from '@angular/core'
+import { BaseQueryBuilder, createLiveQueryCollection } from '@tanstack/db'
 import type {
   ChangeMessage,
   Collection,
@@ -16,8 +16,8 @@ import type {
   InitialQueryBuilder,
   LiveQueryCollectionConfig,
   QueryBuilder,
-} from "@tanstack/db"
-import type { Signal } from "@angular/core"
+} from '@tanstack/db'
+import type { Signal } from '@angular/core'
 
 /**
  * The result of calling `injectLiveQuery`.
@@ -32,10 +32,10 @@ export interface InjectLiveQueryResult<
   state: Signal<Map<TKey, TResult>>
   /** A signal containing the results as an array */
   data: Signal<Array<TResult>>
-  /** A signal containing the underlying collection instance */
-  collection: Signal<Collection<TResult, TKey, TUtils>>
+  /** A signal containing the underlying collection instance (null for disabled queries) */
+  collection: Signal<Collection<TResult, TKey, TUtils> | null>
   /** A signal containing the current status of the collection */
-  status: Signal<CollectionStatus>
+  status: Signal<CollectionStatus | `disabled`>
   /** A signal indicating whether the collection is currently loading */
   isLoading: Signal<boolean>
   /** A signal indicating whether the collection is ready */
@@ -58,18 +58,33 @@ export function injectLiveQuery<
     q: InitialQueryBuilder
   }) => QueryBuilder<TContext>
 }): InjectLiveQueryResult<GetResult<TContext>>
+export function injectLiveQuery<
+  TContext extends Context,
+  TParams extends any,
+>(options: {
+  params: () => TParams
+  query: (args: {
+    params: TParams
+    q: InitialQueryBuilder
+  }) => QueryBuilder<TContext> | undefined | null
+}): InjectLiveQueryResult<GetResult<TContext>>
 export function injectLiveQuery<TContext extends Context>(
-  queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>
+  queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,
 ): InjectLiveQueryResult<GetResult<TContext>>
 export function injectLiveQuery<TContext extends Context>(
-  config: LiveQueryCollectionConfig<TContext>
+  queryFn: (
+    q: InitialQueryBuilder,
+  ) => QueryBuilder<TContext> | undefined | null,
+): InjectLiveQueryResult<GetResult<TContext>>
+export function injectLiveQuery<TContext extends Context>(
+  config: LiveQueryCollectionConfig<TContext>,
 ): InjectLiveQueryResult<GetResult<TContext>>
 export function injectLiveQuery<
   TResult extends object,
   TKey extends string | number,
   TUtils extends Record<string, any>,
 >(
-  liveQueryCollection: Collection<TResult, TKey, TUtils>
+  liveQueryCollection: Collection<TResult, TKey, TUtils>,
 ): InjectLiveQueryResult<TResult, TKey, TUtils>
 export function injectLiveQuery(opts: any) {
   assertInInjectionContext(injectLiveQuery)
@@ -89,6 +104,15 @@ export function injectLiveQuery(opts: any) {
     }
 
     if (typeof opts === `function`) {
+      // Check if query function returns null/undefined (disabled query)
+      const queryBuilder = new BaseQueryBuilder() as InitialQueryBuilder
+      const result = opts(queryBuilder)
+
+      if (result === undefined || result === null) {
+        // Disabled query - return null
+        return null
+      }
+
       return createLiveQueryCollection({
         query: opts,
         startSync: true,
@@ -106,6 +130,16 @@ export function injectLiveQuery(opts: any) {
     if (isReactiveQueryOptions) {
       const { params, query } = opts
       const currentParams = params()
+
+      // Check if query function returns null/undefined (disabled query)
+      const queryBuilder = new BaseQueryBuilder() as InitialQueryBuilder
+      const result = query({ params: currentParams, q: queryBuilder })
+
+      if (result === undefined || result === null) {
+        // Disabled query - return null
+        return null
+      }
+
       return createLiveQueryCollection({
         query: (q) => query({ params: currentParams, q }),
         startSync: true,
@@ -123,10 +157,12 @@ export function injectLiveQuery(opts: any) {
 
   const state = signal(new Map<string | number, any>())
   const data = signal<Array<any>>([])
-  const status = signal<CollectionStatus>(`idle`)
+  const status = signal<CollectionStatus | `disabled`>(
+    collection() ? `idle` : `disabled`,
+  )
 
   const syncDataFromCollection = (
-    currentCollection: Collection<any, any, any>
+    currentCollection: Collection<any, any, any>,
   ) => {
     const newState = new Map(currentCollection.entries())
     const newData = Array.from(currentCollection.values())
@@ -145,7 +181,12 @@ export function injectLiveQuery(opts: any) {
   effect((onCleanup) => {
     const currentCollection = collection()
 
+    // Handle null collection (disabled query)
     if (!currentCollection) {
+      status.set(`disabled` as const)
+      state.set(new Map())
+      data.set([])
+      cleanup()
       return
     }
 
@@ -165,7 +206,7 @@ export function injectLiveQuery(opts: any) {
     const subscription = currentCollection.subscribeChanges(
       (_: Array<ChangeMessage<any>>) => {
         syncDataFromCollection(currentCollection)
-      }
+      },
     )
     unsub = subscription.unsubscribe.bind(subscription)
 
@@ -185,7 +226,7 @@ export function injectLiveQuery(opts: any) {
     collection,
     status,
     isLoading: computed(() => status() === `loading`),
-    isReady: computed(() => status() === `ready`),
+    isReady: computed(() => status() === `ready` || status() === `disabled`),
     isIdle: computed(() => status() === `idle`),
     isError: computed(() => status() === `error`),
     isCleanedUp: computed(() => status() === `cleaned-up`),
diff --git a/packages/angular-db/tests/inject-live-query.test.ts b/packages/angular-db/tests/inject-live-query.test.ts
index 6579bd0a3..2f4db01ca 100644
--- a/packages/angular-db/tests/inject-live-query.test.ts
+++ b/packages/angular-db/tests/inject-live-query.test.ts
@@ -1,21 +1,21 @@
-import { DestroyRef, inject, signal } from "@angular/core"
-import { TestBed } from "@angular/core/testing"
-import { describe, expect, it } from "vitest"
+import { DestroyRef, inject, signal } from '@angular/core'
+import { TestBed } from '@angular/core/testing'
+import { describe, expect, it } from 'vitest'
 import {
   createCollection,
   createLiveQueryCollection,
   eq,
   gt,
-} from "@tanstack/db"
-import { injectLiveQuery } from "../src/index"
-import { mockSyncCollectionOptions } from "../../db/tests/utils"
+} from '@tanstack/db'
+import { injectLiveQuery } from '../src/index'
+import { mockSyncCollectionOptions } from '../../db/tests/utils'
 import type {
   Collection,
   CollectionStatus,
   Context,
   LiveQueryCollectionConfig,
   QueryBuilder,
-} from "@tanstack/db"
+} from '@tanstack/db'
 
 // Import the same test utilities as Vue
 
@@ -65,7 +65,7 @@ async function waitForAngularUpdate() {
 
 function createMockCollection<T extends object, K extends string | number>(
   initial: Array<T & Record<`id`, K>> = [],
-  initialStatus: CollectionStatus = `ready`
+  initialStatus: CollectionStatus = `ready`,
 ): Collection<T, K, Record<string, never>> & {
   __setStatus: (s: CollectionStatus) => void
   __replaceAll: (rows: Array<T & Record<`id`, K>>) => void
@@ -167,7 +167,7 @@ describe(`injectLiveQuery`, () => {
     expect(() => {
       injectLiveQuery(() => ({}) as unknown as QueryBuilder<Context>)
     }).toThrow(
-      /NG0203:|injectLiveQuery\(\) can only be used within an injection context/i
+      /NG0203:|injectLiveQuery\(\) can only be used within an injection context/i,
     )
   })
 
@@ -178,7 +178,7 @@ describe(`injectLiveQuery`, () => {
           id: `test-persons-angular`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const { state, data } = injectLiveQuery((q) =>
@@ -189,7 +189,7 @@ describe(`injectLiveQuery`, () => {
             id: persons.id,
             name: persons.name,
             age: persons.age,
-          }))
+          })),
       )
 
       await waitForAngularUpdate()
@@ -210,7 +210,7 @@ describe(`injectLiveQuery`, () => {
     await TestBed.runInInjectionContext(async () => {
       const col = createMockCollection<{ id: number; name: string }, number>(
         [{ id: 1, name: `A` }],
-        `ready`
+        `ready`,
       )
 
       const result = injectLiveQuery(col)
@@ -233,7 +233,7 @@ describe(`injectLiveQuery`, () => {
     await TestBed.runInInjectionContext(async () => {
       const col = createMockCollection<{ id: number; name: string }, number>(
         [{ id: 1, name: `A` }],
-        `ready`
+        `ready`,
       )
       const result = injectLiveQuery(col)
 
@@ -266,7 +266,7 @@ describe(`injectLiveQuery`, () => {
     await TestBed.runInInjectionContext(async () => {
       const col = createMockCollection<{ id: number; name: string }, number>(
         [],
-        `idle`
+        `idle`,
       )
       const { status, isReady, isLoading, isError, isCleanedUp } =
         injectLiveQuery(col)
@@ -303,7 +303,7 @@ describe(`injectLiveQuery`, () => {
           id: `test-persons-2-angular`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const { state, data } = injectLiveQuery((q) =>
@@ -314,7 +314,7 @@ describe(`injectLiveQuery`, () => {
             id: c.id,
             name: c.name,
           }))
-          .orderBy(({ collection: c }) => c.id, `asc`)
+          .orderBy(({ collection: c }) => c.id, `asc`),
       )
 
       await waitForAngularUpdate()
@@ -369,7 +369,7 @@ describe(`injectLiveQuery`, () => {
             id: `4`,
             name: `Kyle Doe`,
           }),
-        ])
+        ]),
       )
     })
   })
@@ -382,7 +382,7 @@ describe(`injectLiveQuery`, () => {
           id: `reuse-test-angular`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const config: LiveQueryCollectionConfig<Context> = {
@@ -414,7 +414,7 @@ describe(`injectLiveQuery`, () => {
       })
 
       expect(col2).toBe(col1)
-    }
+    },
   )
 
   it(`creates a new collection when deps change`, async () => {
@@ -423,7 +423,7 @@ describe(`injectLiveQuery`, () => {
         id: `deps-change-test-angular`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const config: LiveQueryCollectionConfig<Context> = {
@@ -464,7 +464,7 @@ describe(`injectLiveQuery`, () => {
     await TestBed.runInInjectionContext(async () => {
       const col = createMockCollection<{ id: number; name: string }, number>(
         [],
-        `ready`
+        `ready`,
       )
 
       const a = injectLiveQuery(col)
@@ -481,7 +481,7 @@ describe(`injectLiveQuery`, () => {
     await TestBed.runInInjectionContext(async () => {
       const col = createMockCollection<{ id: number; name: string }, number>(
         [{ id: 1, name: `A` }],
-        `ready`
+        `ready`,
       )
 
       const destroyRef = inject(DestroyRef)
@@ -500,7 +500,7 @@ describe(`injectLiveQuery`, () => {
     await TestBed.runInInjectionContext(async () => {
       const col = createMockCollection<{ id: number; name: string }, number>(
         [],
-        `ready`
+        `ready`,
       )
       const res = injectLiveQuery(col)
 
@@ -517,7 +517,7 @@ describe(`injectLiveQuery`, () => {
           id: `query-fn-test-angular`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const res = injectLiveQuery((q) =>
@@ -527,7 +527,7 @@ describe(`injectLiveQuery`, () => {
           .select(({ persons }) => ({
             id: persons.id,
             name: persons.name,
-          }))
+          })),
       )
 
       await waitForAngularUpdate()
@@ -546,7 +546,7 @@ describe(`injectLiveQuery`, () => {
           id: `config-test-angular`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const config: LiveQueryCollectionConfig<Context> = {
@@ -574,7 +574,7 @@ describe(`injectLiveQuery`, () => {
     await TestBed.runInInjectionContext(async () => {
       const col = createMockCollection<{ id: number; name: string }, number>(
         [],
-        `ready`
+        `ready`,
       )
       const res = injectLiveQuery(col)
 
@@ -591,7 +591,7 @@ describe(`injectLiveQuery`, () => {
           id: `reactive-params-test-angular`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const projectId = signal(1)
@@ -630,7 +630,7 @@ describe(`injectLiveQuery`, () => {
             name: `John Smith`,
             team: `team1`,
           }),
-        ])
+        ]),
       )
 
       projectId.set(2)
@@ -653,7 +653,7 @@ describe(`injectLiveQuery`, () => {
           id: `reactive-update-test-angular`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const selectedProjectId = signal(2)
@@ -700,7 +700,7 @@ describe(`injectLiveQuery`, () => {
             name: `John Smith`,
             team: `team1`,
           }),
-        ])
+        ]),
       )
     })
   })
@@ -712,7 +712,7 @@ describe(`injectLiveQuery`, () => {
           id: `pre-created-collection-test-angular`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       // Create a live query collection beforehand
@@ -1031,4 +1031,119 @@ describe(`injectLiveQuery`, () => {
       })
     })
   })
+
+  describe(`disabled queries`, () => {
+    it(`should handle query function returning undefined with proper state`, async () => {
+      await TestBed.runInInjectionContext(async () => {
+        const collection = createCollection(
+          mockSyncCollectionOptions<Person>({
+            id: `disabled-test-undefined-angular`,
+            getKey: (person: Person) => person.id,
+            initialData: initialPersons,
+          }),
+        )
+
+        const enabled = signal(false)
+
+        const result = injectLiveQuery({
+          params: () => ({ enabled: enabled() }),
+          query: ({ params, q }) => {
+            if (!params.enabled) return undefined
+            return q
+              .from({ persons: collection })
+              .where(({ persons }) => eq(persons.isActive, true))
+              .select(({ persons }) => ({
+                id: persons.id,
+                name: persons.name,
+              }))
+          },
+        })
+
+        await waitForAngularUpdate()
+
+        // When disabled, status should be 'disabled' and isReady should be true
+        expect(result.status()).toBe(`disabled`)
+        expect(result.isReady()).toBe(true)
+        expect(result.isLoading()).toBe(false)
+        expect(result.isIdle()).toBe(false)
+        expect(result.isError()).toBe(false)
+        expect(result.collection()).toBeNull()
+        expect(result.data()).toEqual([])
+        expect(result.state().size).toBe(0)
+
+        // Enable the query
+        enabled.set(true)
+        await waitForAngularUpdate()
+
+        // Should now be ready with data
+        expect(result.status()).toBe(`ready`)
+        expect(result.isReady()).toBe(true)
+        expect(result.isLoading()).toBe(false)
+        expect(result.collection()).not.toBeNull()
+        expect(result.data().length).toBeGreaterThan(0)
+      })
+    })
+
+    it(`should handle query function returning null with proper state`, async () => {
+      await TestBed.runInInjectionContext(async () => {
+        const collection = createCollection(
+          mockSyncCollectionOptions<Person>({
+            id: `disabled-test-null-angular`,
+            getKey: (person: Person) => person.id,
+            initialData: initialPersons,
+          }),
+        )
+
+        const enabled = signal(false)
+
+        const result = injectLiveQuery({
+          params: () => ({ enabled: enabled() }),
+          query: ({ params, q }) => {
+            if (!params.enabled) return null
+            return q
+              .from({ persons: collection })
+              .where(({ persons }) => gt(persons.age, 25))
+              .select(({ persons }) => ({
+                id: persons.id,
+                name: persons.name,
+                age: persons.age,
+              }))
+          },
+        })
+
+        await waitForAngularUpdate()
+
+        // When disabled, status should be 'disabled' and isReady should be true
+        expect(result.status()).toBe(`disabled`)
+        expect(result.isReady()).toBe(true)
+        expect(result.isLoading()).toBe(false)
+        expect(result.isIdle()).toBe(false)
+        expect(result.isError()).toBe(false)
+        expect(result.collection()).toBeNull()
+        expect(result.data()).toEqual([])
+        expect(result.state().size).toBe(0)
+
+        // Enable the query
+        enabled.set(true)
+        await waitForAngularUpdate()
+
+        // Should now be ready with data
+        expect(result.status()).toBe(`ready`)
+        expect(result.isReady()).toBe(true)
+        expect(result.isLoading()).toBe(false)
+        expect(result.collection()).not.toBeNull()
+        expect(result.data().length).toBeGreaterThan(0)
+
+        // Disable again
+        enabled.set(false)
+        await waitForAngularUpdate()
+
+        // Should go back to disabled state
+        expect(result.status()).toBe(`disabled`)
+        expect(result.isReady()).toBe(true)
+        expect(result.collection()).toBeNull()
+        expect(result.data()).toEqual([])
+      })
+    })
+  })
 })
diff --git a/packages/angular-db/tests/test-setup.ts b/packages/angular-db/tests/test-setup.ts
index 97e72cf84..6c5fc708c 100644
--- a/packages/angular-db/tests/test-setup.ts
+++ b/packages/angular-db/tests/test-setup.ts
@@ -1,12 +1,12 @@
-import "zone.js"
-import "zone.js/testing"
-import { getTestBed } from "@angular/core/testing"
+import 'zone.js'
+import 'zone.js/testing'
+import { getTestBed } from '@angular/core/testing'
 import {
   BrowserDynamicTestingModule,
   platformBrowserDynamicTesting,
-} from "@angular/platform-browser-dynamic/testing"
+} from '@angular/platform-browser-dynamic/testing'
 
 getTestBed().initTestEnvironment(
   BrowserDynamicTestingModule,
-  platformBrowserDynamicTesting()
+  platformBrowserDynamicTesting(),
 )
diff --git a/packages/angular-db/vite.config.ts b/packages/angular-db/vite.config.ts
index 9ced2401a..2ae761c92 100644
--- a/packages/angular-db/vite.config.ts
+++ b/packages/angular-db/vite.config.ts
@@ -1,6 +1,6 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import packageJson from './package.json'
 
 const config = defineConfig({
   test: {
@@ -18,5 +18,5 @@ export default mergeConfig(
   tanstackViteConfig({
     entry: `./src/index.ts`,
     srcDir: `./src`,
-  })
+  }),
 )
diff --git a/packages/db-collection-e2e/CHANGELOG.md b/packages/db-collection-e2e/CHANGELOG.md
new file mode 100644
index 000000000..d30a8bf19
--- /dev/null
+++ b/packages/db-collection-e2e/CHANGELOG.md
@@ -0,0 +1,140 @@
+# @tanstack/db-collection-e2e
+
+## 0.0.14
+
+### Patch Changes
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd), [`f458e05`](https://github.com/TanStack/db/commit/f458e05bb6f5b577ba1d1032a48b46cf860f3c9d)]:
+  - @tanstack/db@0.5.11
+  - @tanstack/query-db-collection@1.0.6
+  - @tanstack/electric-db-collection@0.2.12
+
+## 0.0.13
+
+### Patch Changes
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`aebd0fa`](https://github.com/TanStack/db/commit/aebd0fa43345ea28dcdb3f446cdd393de1d1e4b7), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/electric-db-collection@0.2.11
+  - @tanstack/db@0.5.10
+  - @tanstack/query-db-collection@1.0.5
+
+## 0.0.12
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+  - @tanstack/electric-db-collection@0.2.10
+  - @tanstack/query-db-collection@1.0.5
+
+## 0.0.11
+
+### Patch Changes
+
+- Updated dependencies [[`03842c6`](https://github.com/TanStack/db/commit/03842c633eb990448d26d80025d26184c8de58f2)]:
+  - @tanstack/electric-db-collection@0.2.9
+
+## 0.0.10
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+  - @tanstack/electric-db-collection@0.2.8
+  - @tanstack/query-db-collection@1.0.5
+
+## 0.0.9
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+  - @tanstack/electric-db-collection@0.2.7
+  - @tanstack/query-db-collection@1.0.5
+
+## 0.0.8
+
+### Patch Changes
+
+- Updated dependencies [[`a540d7c`](https://github.com/TanStack/db/commit/a540d7c34042d69cf1f81d1219df5f3f3d57e200), [`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/query-db-collection@1.0.5
+  - @tanstack/db@0.5.6
+  - @tanstack/electric-db-collection@0.2.6
+
+## 0.0.7
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/query-db-collection@1.0.4
+  - @tanstack/db@0.5.5
+  - @tanstack/electric-db-collection@0.2.5
+
+## 0.0.6
+
+### Patch Changes
+
+- Fix progressive mode to use fetchSnapshot and atomic swap ([#852](https://github.com/TanStack/db/pull/852))
+
+  Progressive mode was broken because `requestSnapshot()` injected snapshots into the stream in causally correct position, which didn't work properly with the `full` mode stream. This release fixes progressive mode by:
+
+  **Core Changes:**
+  - Use `fetchSnapshot()` during initial sync to fetch and apply snapshots immediately in sync transactions
+  - Buffer all stream messages during initial sync (renamed flag to `isBufferingInitialSync`)
+  - Perform atomic swap on first `up-to-date`: truncate snapshot data → apply buffered messages → mark ready
+  - Track txids/snapshots only after atomic swap (enables correct optimistic transaction confirmation)
+
+  **Test Infrastructure:**
+  - Added `ELECTRIC_TEST_HOOKS` symbol for test control (hidden from public API)
+  - Added `progressiveTestControl.releaseInitialSync()` to E2E test config for explicit transition control
+  - Created comprehensive progressive mode E2E test suite (8 tests):
+    - Explicit snapshot phase and atomic swap validation
+    - Txid tracking behavior (Electric-only)
+    - Multiple concurrent snapshots with deduplication
+    - Incremental updates after swap
+    - Predicate handling and resilience tests
+
+  **Bug Fixes:**
+  - Fixed type errors in test files
+  - All 166 unit tests + 95 E2E tests passing
+
+- Updated dependencies [[`f66f2cf`](https://github.com/TanStack/db/commit/f66f2cf944bbcc1a34ad7e340de2e78f5e27e666), [`e657a7d`](https://github.com/TanStack/db/commit/e657a7dad71dff6fb3dd24c2824f5b86d9f92cd5), [`f15b2a7`](https://github.com/TanStack/db/commit/f15b2a7081a2a21bd23ba3657fac44fc9c2f39a8), [`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/query-db-collection@1.0.3
+  - @tanstack/electric-db-collection@0.2.4
+  - @tanstack/db@0.5.4
+
+## 0.0.5
+
+### Patch Changes
+
+- Updated dependencies [[`a90f95e`](https://github.com/TanStack/db/commit/a90f95eaeb7cc334955ae5e8ffb98940fce1ecf1), [`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/query-db-collection@1.0.2
+  - @tanstack/db@0.5.3
+  - @tanstack/electric-db-collection@0.2.3
+
+## 0.0.4
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+  - @tanstack/electric-db-collection@0.2.2
+  - @tanstack/query-db-collection@1.0.1
+
+## 0.0.3
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38), [`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/query-db-collection@1.0.1
+  - @tanstack/db@0.5.1
+  - @tanstack/electric-db-collection@0.2.1
+
+## 0.0.2
+
+### Patch Changes
+
+- Updated dependencies [[`1afb027`](https://github.com/TanStack/db/commit/1afb027dbf3e34292a418fc549f799c4e0ce8922), [`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`58f119a`](https://github.com/TanStack/db/commit/58f119ac4f1b05dbfff8617f59f53973abdb1920), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`8f746db`](https://github.com/TanStack/db/commit/8f746db61ff160eae9834e0b9d83c40ef315ae12), [`7aceffa`](https://github.com/TanStack/db/commit/7aceffa46e746cff3dee51230dd2f9e09cb24137), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/electric-db-collection@0.2.0
+  - @tanstack/db@0.5.0
+  - @tanstack/query-db-collection@1.0.0
diff --git a/packages/db-collection-e2e/README.md b/packages/db-collection-e2e/README.md
new file mode 100644
index 000000000..b027b14c7
--- /dev/null
+++ b/packages/db-collection-e2e/README.md
@@ -0,0 +1,489 @@
+# @tanstack/db-collection-e2e
+
+Shared end-to-end test suite for TanStack DB collections with query-driven sync and on-demand loading.
+
+## Overview
+
+This package provides a comprehensive e2e test suite that can be reused across different collection implementations (Electric, Query, etc.). It tests:
+
+- Predicate push-down and filtering
+- Pagination, ordering, and window management
+- Multi-collection joins with mixed syncModes
+- Deduplication of concurrent loadSubset calls
+- String collation configurations
+- Mutations with on-demand mode
+- Live updates (for sync-enabled collections)
+
+## Architecture
+
+### Package Structure
+
+```
+db-collection-e2e/
+├── docker/                   # Docker Compose for test infrastructure
+│   ├── docker-compose.yml    # Postgres + Electric
+│   └── postgres.conf         # Optimized for fast tests
+├── src/
+│   ├── types.ts              # TypeScript interfaces
+│   ├── fixtures/             # Test data and schemas
+│   │   ├── seed-data.ts      # Generate ~100 records per table
+│   │   └── test-schema.ts    # SQL schema definitions
+│   ├── suites/               # Test suite modules
+│   │   ├── predicates.test.ts
+│   │   ├── pagination.test.ts
+│   │   ├── joins.test.ts
+│   │   ├── deduplication.test.ts
+│   │   ├── collation.test.ts
+│   │   ├── mutations.test.ts
+│   │   ├── live-updates.test.ts
+│   │   └── regressions.test.ts
+│   └── utils/                # Helper functions
+│       ├── helpers.ts        # Common utilities
+│       └── assertions.ts     # Custom assertions
+└── support/                  # Vitest setup
+    ├── global-setup.ts       # Health checks, DB init
+    └── test-context.ts       # Vitest fixtures
+```
+
+## Getting Started
+
+### Prerequisites
+
+- Docker and Docker Compose
+- Node.js 20+
+- pnpm 10+
+
+### Installation
+
+From the repository root:
+
+```bash
+pnpm install
+```
+
+### Running Tests Locally
+
+1. **Start Docker services:**
+
+```bash
+cd packages/db-collection-e2e/docker
+docker compose up -d
+```
+
+2. **Run tests:**
+
+```bash
+cd packages/db-collection-e2e
+pnpm test
+```
+
+3. **Stop Docker services:**
+
+```bash
+cd packages/db-collection-e2e/docker
+docker compose down
+```
+
+## Test Data Schema
+
+The test suite uses three related tables:
+
+### Users Table (~100 records)
+
+```typescript
+interface User {
+  id: string // UUID
+  name: string // For collation testing
+  email: string | null
+  age: number
+  isActive: boolean
+  createdAt: Date
+  metadata: object | null // JSON field
+  deletedAt: Date | null // Soft delete
+}
+```
+
+### Posts Table (~100 records)
+
+```typescript
+interface Post {
+  id: string
+  userId: string // FK to User
+  title: string
+  content: string | null
+  viewCount: number
+  publishedAt: Date | null
+  deletedAt: Date | null
+}
+```
+
+### Comments Table (~100 records)
+
+```typescript
+interface Comment {
+  id: string
+  postId: string // FK to Post
+  userId: string // FK to User
+  text: string
+  createdAt: Date
+  deletedAt: Date | null
+}
+```
+
+### Data Distributions
+
+Seed data includes:
+
+- Mix of null/non-null values
+- Various string cases (uppercase, lowercase, special chars)
+- Date ranges (past, present, future)
+- Numeric ranges (negative, zero, positive)
+- Some soft-deleted records (~10%)
+
+## Integrating with Your Collection
+
+### 1. Create Setup File
+
+Create `e2e/setup.ts` in your collection package. See real examples:
+
+- Electric: `packages/electric-db-collection/e2e/setup.ts`
+- Query: `packages/query-db-collection/e2e/setup.ts`
+
+Example structure:
+
+```typescript
+import { createCollection } from '@tanstack/db'
+import { yourCollectionOptions } from '../src'
+import type {
+  E2ETestConfig,
+  User,
+  Post,
+  Comment,
+} from '../../db-collection-e2e/src/types'
+
+export async function createYourE2EConfig(options: {
+  schema: string
+  usersTable: string
+  postsTable: string
+  commentsTable: string
+}): Promise<E2ETestConfig> {
+  // Create collections for both syncModes (eager and on-demand)
+  const eagerUsers = createCollection(
+    yourCollectionOptions({
+      id: `your-e2e-users-eager-${Date.now()}`,
+      syncMode: 'eager',
+      getKey: (item: User) => item.id,
+      startSync: false,
+    }),
+  )
+
+  const onDemandUsers = createCollection(
+    yourCollectionOptions({
+      id: `your-e2e-users-ondemand-${Date.now()}`,
+      syncMode: 'on-demand',
+      getKey: (item: User) => item.id,
+      startSync: false,
+    }),
+  )
+
+  // ... create posts and comments collections similarly
+
+  return {
+    collections: {
+      eager: { users: eagerUsers, posts: eagerPosts, comments: eagerComments },
+      onDemand: {
+        users: onDemandUsers,
+        posts: onDemandPosts,
+        comments: onDemandComments,
+      },
+    },
+    setup: async () => {
+      // Optional setup hook
+    },
+    teardown: async () => {
+      await Promise.all([
+        eagerUsers.cleanup(),
+        eagerPosts.cleanup(),
+        eagerComments.cleanup(),
+        onDemandUsers.cleanup(),
+        onDemandPosts.cleanup(),
+        onDemandComments.cleanup(),
+      ])
+    },
+  }
+}
+```
+
+### 2. Create E2E Test File
+
+Create `e2e/your-collection.e2e.test.ts`:
+
+```typescript
+import { describe, it, expect } from 'vitest'
+import { createCollection } from '@tanstack/db'
+import { yourCollectionOptions } from '../src'
+
+describe('Your Collection E2E', () => {
+  it('should create collection', async () => {
+    const collection = createCollection(
+      yourCollectionOptions({
+        id: 'test-collection',
+        getKey: (item: any) => item.id,
+        startSync: false,
+      }),
+    )
+
+    expect(collection).toBeDefined()
+    expect(collection._sync.loadSubset).toBeDefined()
+
+    await collection.cleanup()
+  })
+})
+```
+
+### 3. Update Vitest Config
+
+Update your `vite.config.ts` to include e2e tests:
+
+```typescript
+const config = defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts', 'e2e/**/*.e2e.test.ts'],
+    // Remove dir: './tests' if present
+  },
+})
+```
+
+### 4. Run Tests
+
+```bash
+cd packages/your-collection
+pnpm test
+```
+
+The e2e tests will run alongside your regular tests.
+
+## Test Suites
+
+All test suites are implemented in `src/suites/*.suite.ts` files and exported as factory functions.
+
+### Predicates Suite (`predicates.suite.ts`)
+
+Tests basic where clause functionality with ~20 test scenarios:
+
+**Example Test:**
+
+```typescript
+it('should filter with eq() on number field', async () => {
+  const query = createLiveQueryCollection((q) =>
+    q.from({ user: usersCollection }).where(({ user }) => eq(user.age, 25)),
+  )
+  await query.preload()
+
+  const results = Array.from(query.state.values())
+  assertAllItemsMatch(query, (u) => u.age === 25)
+})
+```
+
+**Covers:**
+
+- `eq()`, `gt()`, `gte()`, `lt()`, `lte()` with all data types
+- `inArray()` with arrays
+- `isNull()`, `not(isNull())` for null checks
+- Complex boolean logic with `and()`, `or()`, `not()`
+- Predicate pushdown verification
+
+### Pagination Suite (`pagination.suite.ts`)
+
+Tests ordering and pagination with ~15 test scenarios:
+
+**Example Test:**
+
+```typescript
+it('should sort ascending by single field', async () => {
+  const query = createLiveQueryCollection((q) =>
+    q.from({ user: usersCollection }).orderBy(({ user }) => user.age, 'asc'),
+  )
+  await query.preload()
+
+  const results = Array.from(query.state.values())
+  assertSorted(results, 'age', 'asc')
+})
+```
+
+**Covers:**
+
+- Basic `orderBy` (asc/desc) on various field types
+- Multiple `orderBy` fields
+- `limit` and `offset` for pagination
+- Edge cases (limit=0, offset beyond dataset)
+- Performance verification (only requested page loaded)
+
+### Joins Suite (`joins.suite.ts`)
+
+Tests multi-collection joins with ~12 test scenarios:
+
+**Example Test:**
+
+```typescript
+it('should join Users and Posts', async () => {
+  const query = createLiveQueryCollection((q) =>
+    q
+      .from({ user: usersCollection })
+      .join({ post: postsCollection }, ({ user, post }) =>
+        eq(user.id, post.userId),
+      )
+      .select(({ user, post }) => ({
+        id: post.id,
+        userName: user.name,
+        postTitle: post.title,
+      })),
+  )
+  await query.preload()
+
+  expect(query.size).toBeGreaterThan(0)
+})
+```
+
+**Covers:**
+
+- Two-collection joins (Users + Posts)
+- Three-collection joins (Users + Posts + Comments)
+- Mixed syncModes (eager + on-demand)
+- Predicates on joined collections
+- Left joins and ordering on joined results
+- Pagination on joined results
+
+### Deduplication Suite
+
+Tests concurrent loadSubset calls:
+
+- Identical predicates called simultaneously
+- Overlapping predicates (subset relationships)
+- Queries during active loading
+- Deduplication callback verification
+
+### Collation Suite
+
+Tests string collation:
+
+- Default collation behavior
+- Custom `defaultStringCollation`
+- Query-level collation override
+- Case-sensitive vs case-insensitive
+
+### Mutations Suite
+
+Tests data mutations:
+
+- Insert, update, delete operations
+- Soft delete pattern
+- Concurrent mutations
+- Reactive query updates
+
+### Live Updates Suite (Optional)
+
+Tests reactive updates (for sync-enabled collections):
+
+- Backend data changes
+- Updates during loadSubset
+- Multiple watchers
+- Subscription lifecycle
+
+### Regression Suite
+
+Tests for known bugs:
+
+- Initial state sent multiple times (#7214245)
+- Race conditions in multi-join
+- Missing data in change tracking
+- LoadSubset naming changes (#9874949)
+
+## Configuration
+
+### Environment Variables
+
+- `ELECTRIC_URL` - Electric server URL (default: `http://localhost:3000`)
+- `POSTGRES_HOST` - Postgres host (default: `localhost`)
+- `POSTGRES_PORT` - Postgres port (default: `54321`)
+- `POSTGRES_USER` - Postgres user (default: `postgres`)
+- `POSTGRES_PASSWORD` - Postgres password (default: `password`)
+- `POSTGRES_DB` - Postgres database (default: `e2e_test`)
+
+### Docker Configuration
+
+The Docker Compose setup uses:
+
+- Postgres 16 Alpine with tmpfs for speed
+- Electric canary image
+- Health checks with 10s timeout
+- Optimized postgres.conf for testing
+
+## Troubleshooting
+
+### Docker services not starting
+
+```bash
+# Check service status
+docker compose ps
+
+# View logs
+docker compose logs
+
+# Restart services
+docker compose restart
+```
+
+### Tests timing out
+
+- Increase `timeout` in `vite.config.ts`
+- Check Docker resource limits
+- Verify network connectivity
+
+### Database connection errors
+
+- Ensure Docker services are healthy
+- Check environment variables
+- Verify ports are not in use
+
+### Test isolation issues
+
+Tests use unique table names per test to prevent collisions:
+
+```
+"users_taskId_random"
+```
+
+If you see data from other tests, check that cleanup is working properly.
+
+## Performance
+
+Target execution time: **< 5 minutes** for entire suite
+
+Optimizations:
+
+- tmpfs for Postgres data directory
+- Serial execution (`fileParallelism: false`)
+- Minimal test data (~300 records total)
+- Optimized Postgres configuration
+- Health checks with fast intervals
+
+## Contributing
+
+When adding new test suites:
+
+1. Create new file in `src/suites/`
+2. Export test factory function
+3. Add to main exports in `src/index.ts`
+4. Update README with test suite description
+5. Ensure execution time stays < 5 minutes
+
+## License
+
+MIT
+
+## Related
+
+- [RFC #676](https://github.com/TanStack/db/discussions/676) - Query-driven sync RFC
+- [PR #763](https://github.com/TanStack/db/pull/763) - Implementation PR
+- [TanStack DB Documentation](https://tanstack.com/db)
diff --git a/packages/db-collection-e2e/docker/docker-compose.yml b/packages/db-collection-e2e/docker/docker-compose.yml
new file mode 100644
index 000000000..441aa5e48
--- /dev/null
+++ b/packages/db-collection-e2e/docker/docker-compose.yml
@@ -0,0 +1,42 @@
+name: 'tanstack-db-e2e'
+
+services:
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_DB: e2e_test
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: password
+    ports:
+      - '54321:5432'
+    volumes:
+      - ./postgres.conf:/etc/postgresql/postgresql.conf:ro
+    tmpfs:
+      - /var/lib/postgresql/data # Speed optimization: in-memory storage
+      - /tmp
+    command:
+      - postgres
+      - -c
+      - config_file=/etc/postgresql/postgresql.conf
+    healthcheck:
+      test: ['CMD-SHELL', 'pg_isready -U postgres']
+      interval: 2s
+      timeout: 10s
+      retries: 5
+
+  electric:
+    image: electricsql/electric:canary
+    environment:
+      DATABASE_URL: postgresql://postgres:password@postgres:5432/e2e_test?sslmode=disable
+      ELECTRIC_INSECURE: true
+      ELECTRIC_FEATURE_FLAGS: 'allow_subqueries,tagged_subqueries'
+    ports:
+      - '3000:3000'
+    depends_on:
+      postgres:
+        condition: service_healthy
+    healthcheck:
+      test: ['CMD-SHELL', 'curl -f http://localhost:3000/v1/health || exit 1']
+      interval: 2s
+      timeout: 10s
+      retries: 5
diff --git a/packages/db-collection-e2e/docker/postgres.conf b/packages/db-collection-e2e/docker/postgres.conf
new file mode 100644
index 000000000..7a5643d1b
--- /dev/null
+++ b/packages/db-collection-e2e/docker/postgres.conf
@@ -0,0 +1,23 @@
+# PostgreSQL configuration for e2e tests
+# Optimized for fast test execution
+
+# Connection settings
+listen_addresses = '*'
+max_connections = 100
+shared_buffers = 128MB
+
+# Write-Ahead Logging
+wal_level = logical
+max_wal_senders = 10
+max_replication_slots = 10
+
+# Performance
+fsync = off # Safe for testing, NOT for production
+synchronous_commit = off # Safe for testing, NOT for production
+full_page_writes = off # Safe for testing, NOT for production
+
+# Logging (minimal for tests)
+log_statement = 'none'
+log_duration = off
+log_min_duration_statement = -1
+
diff --git a/packages/db-collection-e2e/package.json b/packages/db-collection-e2e/package.json
new file mode 100644
index 000000000..e62b17f60
--- /dev/null
+++ b/packages/db-collection-e2e/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@tanstack/db-collection-e2e",
+  "private": true,
+  "description": "End-to-end test suite for TanStack DB collections",
+  "scripts": {
+    "test": "echo 'This package contains shared test suites. Run tests from electric-db-collection or query-db-collection packages.'",
+    "docker:up": "docker compose -f docker/docker-compose.yml up -d",
+    "docker:down": "docker compose -f docker/docker-compose.yml down --volumes",
+    "docker:logs": "docker compose -f docker/docker-compose.yml logs -f"
+  },
+  "type": "module",
+  "dependencies": {
+    "@tanstack/db": "workspace:*",
+    "@tanstack/electric-db-collection": "workspace:*",
+    "@tanstack/query-db-collection": "workspace:*",
+    "pg": "^8.16.3"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.16.0",
+    "@vitest/ui": "^3.2.4",
+    "typescript": "^5.9.2",
+    "vite": "^7.3.0",
+    "vitest": "^3.2.4"
+  }
+}
diff --git a/packages/db-collection-e2e/src/fixtures/seed-data.ts b/packages/db-collection-e2e/src/fixtures/seed-data.ts
new file mode 100644
index 000000000..98b979404
--- /dev/null
+++ b/packages/db-collection-e2e/src/fixtures/seed-data.ts
@@ -0,0 +1,236 @@
+import type { Comment, Post, SeedDataResult, User } from '../types'
+
+// Cache UUIDs for deterministic behavior across test runs
+const uuidCache = new Map<string, string>()
+
+/**
+ * Generate deterministic valid UUIDs for testing
+ */
+function generateId(prefix: string, index: number): string {
+  const key = `${prefix}-${index}`
+  if (!uuidCache.has(key)) {
+    // Generate a real UUID but make it deterministic for the same prefix+index
+    const hex = index.toString(16).padStart(8, `0`)
+    // Create a valid UUID v4 format
+    uuidCache.set(
+      key,
+      `${hex.slice(0, 8)}-0000-4000-8000-${hex.padStart(12, `0`)}`,
+    )
+  }
+  return uuidCache.get(key)!
+}
+
+/**
+ * Generate seed data with proper distributions for testing
+ *
+ * Data characteristics:
+ * - ~100 users with varied attributes
+ * - ~100 posts distributed across users
+ * - ~100 comments distributed across posts
+ * - Mix of null/non-null values
+ * - Various string cases (uppercase, lowercase, special chars)
+ * - Date ranges (past, present, future)
+ * - Numeric ranges (negative, zero, positive)
+ * - Some soft-deleted records
+ */
+export function generateSeedData(): SeedDataResult {
+  const users: Array<User> = []
+  const posts: Array<Post> = []
+  const comments: Array<Comment> = []
+
+  const now = new Date()
+  const oneDay = 24 * 60 * 60 * 1000
+  const oneYear = 365 * oneDay
+
+  // Generate 100 users with varied distributions
+  for (let i = 0; i < 100; i++) {
+    const id = generateId(`user`, i)
+
+    // Name variations for collation testing
+    const names = [
+      `Alice ${i}`,
+      `bob ${i}`,
+      `Charlie ${i}`,
+      `DIANA ${i}`,
+      `Eve ${i}`,
+      `Frank ${i}`,
+      `Grace ${i}`,
+      `henry ${i}`,
+      `Ivy ${i}`,
+      `Jack ${i}`,
+      `Kate ${i}`,
+      `liam ${i}`,
+      `Mia ${i}`,
+      `Noah ${i}`,
+      `Olivia ${i}`,
+      `PAUL ${i}`,
+      `Quinn ${i}`,
+      `Rose ${i}`,
+      `sam ${i}`,
+      `Tina ${i}`,
+    ]
+    const name = names[i % names.length]
+
+    // Email: 70% have emails, 30% null
+    const email = i % 10 < 7 ? `user${i}@example.com` : null
+
+    // Age distribution: 18-80, with some edge cases
+    const age = i === 0 ? 0 : i === 1 ? -5 : i === 2 ? 150 : 18 + (i % 63)
+
+    // IsActive: 80% true, 20% false
+    const isActive = i % 5 !== 0
+
+    // CreatedAt: distributed over past year
+    const createdAt = new Date(now.getTime() - Math.random() * oneYear)
+
+    // Metadata: 40% have metadata, 60% null
+    const metadata =
+      i % 5 < 2 ? { score: i * 10, level: Math.floor(i / 10) } : null
+
+    // DeletedAt: 10% soft deleted
+    const deletedAt =
+      i % 10 === 0
+        ? new Date(now.getTime() - Math.random() * oneDay * 30)
+        : null
+
+    users.push({
+      id: id,
+      name: name!,
+      email,
+      age,
+      isActive,
+      createdAt,
+      metadata,
+      deletedAt,
+    })
+  }
+
+  // Generate 100 posts distributed across users
+  for (let i = 0; i < 100; i++) {
+    const id = generateId(`post`, i)
+
+    // Distribute posts across users (some users have multiple posts)
+    const userId = users[i % users.length]!.id
+
+    // Title variations
+    const titles = [
+      `Introduction to ${i}`,
+      `Deep Dive: Topic ${i}`,
+      `Quick Guide ${i}`,
+      `ANNOUNCEMENT: ${i}`,
+      `tutorial ${i}`,
+      `Best Practices ${i}`,
+    ]
+    const title = titles[i % titles.length]!
+
+    // Content: 70% have content, 30% null
+    const content =
+      i % 10 < 7
+        ? `This is the content for post ${i}. Lorem ipsum dolor sit amet.`
+        : null
+
+    // ViewCount: varied distribution
+    const viewCount = i === 0 ? 0 : i === 1 ? -10 : i * 42
+
+    // LargeViewCount: BigInt field with values exceeding MAX_SAFE_INTEGER for some posts
+    // This tests BigInt serialization in predicates
+    // Base value: 9007199254740992n (Number.MAX_SAFE_INTEGER + 1)
+    const largeViewCount =
+      i < 10
+        ? BigInt(`9007199254740992`) + BigInt(i) // First 10 posts have very large values
+        : BigInt(i * 1000) // Other posts have smaller bigint values
+
+    // PublishedAt: 80% published, 20% null (drafts)
+    const publishedAt =
+      i % 5 !== 0 ? new Date(now.getTime() - Math.random() * oneYear) : null
+
+    // DeletedAt: 5% soft deleted
+    const deletedAt =
+      i % 20 === 0
+        ? new Date(now.getTime() - Math.random() * oneDay * 10)
+        : null
+
+    posts.push({
+      id,
+      userId,
+      title,
+      content,
+      viewCount,
+      largeViewCount,
+      publishedAt,
+      deletedAt,
+    })
+  }
+
+  // Generate 100 comments distributed across posts
+  for (let i = 0; i < 100; i++) {
+    const id = generateId(`comment`, i)
+
+    // Distribute comments across posts (some posts have multiple comments)
+    const postId = posts[i % posts.length]!.id
+    const userId = users[(i * 3) % users.length]!.id
+
+    // Text variations
+    const texts = [
+      `Great post! Comment ${i}`,
+      `I disagree with comment ${i}`,
+      `question about ${i}`,
+      `AMAZING WORK ${i}`,
+      `thanks for sharing ${i}`,
+      `Very helpful comment ${i}`,
+    ]
+    const text = texts[i % texts.length]!
+
+    // CreatedAt: distributed over past 6 months
+    const createdAt = new Date(now.getTime() - Math.random() * (oneYear / 2))
+
+    // DeletedAt: 8% soft deleted
+    const deletedAt =
+      i % 13 === 0 ? new Date(now.getTime() - Math.random() * oneDay * 5) : null
+
+    comments.push({
+      id,
+      postId,
+      userId,
+      text,
+      createdAt,
+      deletedAt,
+    })
+  }
+
+  return {
+    users,
+    posts,
+    comments,
+    userIds: users.map((u) => u.id),
+    postIds: posts.map((p) => p.id),
+    commentIds: comments.map((c) => c.id),
+  }
+}
+
+/**
+ * Get expected counts for different predicate scenarios
+ */
+export function getExpectedCounts(seedData: SeedDataResult) {
+  return {
+    // Users
+    totalUsers: seedData.users.length,
+    activeUsers: seedData.users.filter((u) => u.isActive).length,
+    deletedUsers: seedData.users.filter((u) => u.deletedAt !== null).length,
+    usersWithEmail: seedData.users.filter((u) => u.email !== null).length,
+    usersWithoutEmail: seedData.users.filter((u) => u.email === null).length,
+    usersWithMetadata: seedData.users.filter((u) => u.metadata !== null).length,
+
+    // Posts
+    totalPosts: seedData.posts.length,
+    publishedPosts: seedData.posts.filter((p) => p.publishedAt !== null).length,
+    draftPosts: seedData.posts.filter((p) => p.publishedAt === null).length,
+    deletedPosts: seedData.posts.filter((p) => p.deletedAt !== null).length,
+    postsWithContent: seedData.posts.filter((p) => p.content !== null).length,
+
+    // Comments
+    totalComments: seedData.comments.length,
+    deletedComments: seedData.comments.filter((c) => c.deletedAt !== null)
+      .length,
+  }
+}
diff --git a/packages/db-collection-e2e/src/fixtures/test-schema.ts b/packages/db-collection-e2e/src/fixtures/test-schema.ts
new file mode 100644
index 000000000..c3a3605dc
--- /dev/null
+++ b/packages/db-collection-e2e/src/fixtures/test-schema.ts
@@ -0,0 +1,106 @@
+/**
+ * SQL schema definitions for test tables
+ */
+
+export const USERS_TABLE_SCHEMA = `
+  id UUID PRIMARY KEY,
+  name TEXT NOT NULL,
+  email TEXT,
+  age INTEGER NOT NULL,
+  "isActive" BOOLEAN NOT NULL DEFAULT true,
+  "createdAt" TIMESTAMP NOT NULL DEFAULT NOW(),
+  metadata JSONB,
+  "deletedAt" TIMESTAMP
+`
+
+export const POSTS_TABLE_SCHEMA = `
+  id UUID PRIMARY KEY,
+  "userId" UUID NOT NULL,
+  title TEXT NOT NULL,
+  content TEXT,
+  "viewCount" INTEGER NOT NULL DEFAULT 0,
+  "publishedAt" TIMESTAMP,
+  "deletedAt" TIMESTAMP
+`
+
+export const COMMENTS_TABLE_SCHEMA = `
+  id UUID PRIMARY KEY,
+  "postId" UUID NOT NULL,
+  "userId" UUID NOT NULL,
+  text TEXT NOT NULL,
+  "createdAt" TIMESTAMP NOT NULL DEFAULT NOW(),
+  "deletedAt" TIMESTAMP
+`
+
+/**
+ * Helper to create all test tables
+ */
+export async function createTestTables(
+  dbClient: { query: (sql: string) => Promise<void> },
+  tableNames: {
+    users: string
+    posts: string
+    comments: string
+  },
+): Promise<void> {
+  await dbClient.query(`
+    CREATE TABLE IF NOT EXISTS ${tableNames.users} (${USERS_TABLE_SCHEMA});
+  `)
+
+  await dbClient.query(`
+    CREATE TABLE IF NOT EXISTS ${tableNames.posts} (${POSTS_TABLE_SCHEMA});
+  `)
+
+  await dbClient.query(`
+    CREATE TABLE IF NOT EXISTS ${tableNames.comments} (${COMMENTS_TABLE_SCHEMA});
+  `)
+}
+
+/**
+ * Helper to drop all test tables
+ */
+export async function dropTestTables(
+  dbClient: { query: (sql: string) => Promise<void> },
+  tableNames: {
+    users: string
+    posts: string
+    comments: string
+  },
+): Promise<void> {
+  await dbClient.query(`DROP TABLE IF EXISTS ${tableNames.comments}`)
+  await dbClient.query(`DROP TABLE IF EXISTS ${tableNames.posts}`)
+  await dbClient.query(`DROP TABLE IF EXISTS ${tableNames.users}`)
+}
+
+/**
+ * Type-safe table column mappings
+ */
+export const USER_COLUMNS = {
+  id: `id`,
+  name: `name`,
+  email: `email`,
+  age: `age`,
+  isActive: `isActive`,
+  createdAt: `createdAt`,
+  metadata: `metadata`,
+  deletedAt: `deletedAt`,
+} as const
+
+export const POST_COLUMNS = {
+  id: `id`,
+  userId: `userId`,
+  title: `title`,
+  content: `content`,
+  viewCount: `viewCount`,
+  publishedAt: `publishedAt`,
+  deletedAt: `deletedAt`,
+} as const
+
+export const COMMENT_COLUMNS = {
+  id: `id`,
+  postId: `postId`,
+  userId: `userId`,
+  text: `text`,
+  createdAt: `createdAt`,
+  deletedAt: `deletedAt`,
+} as const
diff --git a/packages/db-collection-e2e/src/index.ts b/packages/db-collection-e2e/src/index.ts
new file mode 100644
index 000000000..bccff24e2
--- /dev/null
+++ b/packages/db-collection-e2e/src/index.ts
@@ -0,0 +1,29 @@
+/**
+ * @tanstack/db-collection-e2e
+ *
+ * Shared end-to-end test suite for TanStack DB collections
+ */
+
+export * from './types'
+export * from './fixtures/test-schema'
+export * from './fixtures/seed-data'
+export * from './utils/helpers'
+export * from './utils/assertions'
+
+// Export specific utilities for convenience
+export {
+  waitFor,
+  waitForQueryData,
+  waitForCollectionSize,
+} from './utils/helpers'
+
+// Export test suite creators
+export { createPredicatesTestSuite } from './suites/predicates.suite'
+export { createPaginationTestSuite } from './suites/pagination.suite'
+export { createJoinsTestSuite } from './suites/joins.suite'
+export { createDeduplicationTestSuite } from './suites/deduplication.suite'
+export { createCollationTestSuite } from './suites/collation.suite'
+export { createMutationsTestSuite } from './suites/mutations.suite'
+export { createLiveUpdatesTestSuite } from './suites/live-updates.suite'
+export { createProgressiveTestSuite } from './suites/progressive.suite'
+export { createMovesTestSuite } from './suites/moves.suite'
diff --git a/packages/db-collection-e2e/src/suites/collation.suite.ts b/packages/db-collection-e2e/src/suites/collation.suite.ts
new file mode 100644
index 000000000..52bbc873b
--- /dev/null
+++ b/packages/db-collection-e2e/src/suites/collation.suite.ts
@@ -0,0 +1,146 @@
+/**
+ * Collation Test Suite
+ *
+ * Tests string collation configuration and behavior
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createLiveQueryCollection, eq } from '@tanstack/db'
+import { waitForQueryData } from '../utils/helpers'
+import type { E2ETestConfig } from '../types'
+
+export function createCollationTestSuite(
+  getConfig: () => Promise<E2ETestConfig>,
+) {
+  describe(`Collation Suite`, () => {
+    describe(`Default Collation`, () => {
+      it(`should use default collation for string comparisons`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.name, `asc`),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+
+        await query.cleanup()
+      })
+
+      it(`should handle case-sensitive comparisons by default`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Different case variations should be treated as different
+        const query = createLiveQueryCollection(
+          (q) =>
+            q
+              .from({ user: usersCollection })
+              .where(({ user }) => eq(user.name, `alice 0`)), // lowercase
+        )
+
+        await query.preload()
+
+        const results = Array.from(query.state.values())
+        // Should NOT match because seed data has "Alice 0" (capitalized) and default is case-sensitive
+        expect(results.length).toBe(0)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Custom Collection-Level Collation`, () => {
+      it(`should use custom defaultStringCollation at collection level`, async () => {
+        const config = await getConfig()
+
+        // Test will use collection with custom collation if provided
+        const query = createLiveQueryCollection({
+          query: (q) => q.from({ user: config.collections.onDemand.users }),
+          defaultStringCollation: {
+            stringSort: `lexical`,
+          },
+        })
+
+        await query.preload()
+
+        expect(query.compareOptions.stringSort).toBe(`lexical`)
+
+        await query.cleanup()
+      })
+
+      it(`should support locale-based collation`, async () => {
+        const config = await getConfig()
+
+        const query = createLiveQueryCollection({
+          query: (q) => q.from({ user: config.collections.onDemand.users }),
+          defaultStringCollation: {
+            stringSort: `locale`,
+            locale: `de-DE`,
+          },
+        })
+
+        await query.preload()
+
+        expect(query.compareOptions.stringSort).toBe(`locale`)
+        // Type narrow: when stringSort is 'locale', locale property exists
+        if (query.compareOptions.stringSort === `locale`) {
+          expect(query.compareOptions.locale).toBe(`de-DE`)
+        }
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Query-Level Collation Override`, () => {
+      it(`should override collection collation at query level`, async () => {
+        const config = await getConfig()
+
+        const query = createLiveQueryCollection({
+          query: (q) => q.from({ user: config.collections.onDemand.users }),
+          defaultStringCollation: {
+            stringSort: `lexical`,
+          },
+        })
+
+        await query.preload()
+
+        expect(query.compareOptions.stringSort).toBe(`lexical`)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Collation in OrderBy`, () => {
+      it(`should respect collation when sorting strings`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.name, `asc`),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+
+        // Verify sorted (actual sort order depends on collation)
+        for (let i = 1; i < results.length; i++) {
+          // Just verify it's sorted, regardless of collation
+          expect(results[i - 1]!.name).toBeTruthy()
+        }
+
+        await query.cleanup()
+      })
+    })
+  })
+}
diff --git a/packages/db-collection-e2e/src/suites/deduplication.suite.ts b/packages/db-collection-e2e/src/suites/deduplication.suite.ts
new file mode 100644
index 000000000..14c59d2ee
--- /dev/null
+++ b/packages/db-collection-e2e/src/suites/deduplication.suite.ts
@@ -0,0 +1,350 @@
+/**
+ * Deduplication Test Suite
+ *
+ * Tests concurrent loadSubset calls and deduplication behavior
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createLiveQueryCollection, eq, gt, isNull, lt } from '@tanstack/db'
+import { waitForQueryData } from '../utils/helpers'
+import type { E2ETestConfig } from '../types'
+
+export function createDeduplicationTestSuite(
+  getConfig: () => Promise<E2ETestConfig>,
+) {
+  describe(`Deduplication Suite`, () => {
+    describe(`Identical Predicates`, () => {
+      it(`should deduplicate identical concurrent queries`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Create two identical queries
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.age, 25)),
+        )
+
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.age, 25)),
+        )
+
+        // Execute concurrently
+        await Promise.all([query1.preload(), query2.preload()])
+        await Promise.all([
+          waitForQueryData(query1, { minSize: 1 }),
+          waitForQueryData(query2, { minSize: 1 }),
+        ])
+
+        // Both should have same results
+        expect(query1.size).toBe(query2.size)
+        expect(query1.size).toBeGreaterThan(0)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
+      })
+
+      it(`should deduplicate multiple identical queries`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Create 5 identical queries
+        const queries = Array.from({ length: 5 }, () =>
+          createLiveQueryCollection((q) =>
+            q
+              .from({ user: usersCollection })
+              .where(({ user }) => gt(user.age, 30)),
+          ),
+        )
+
+        // Execute all concurrently
+        await Promise.all(queries.map((q) => q.preload()))
+
+        // All should have same results
+        const firstSize = queries[0]?.size
+        expect(firstSize).toBeDefined()
+        queries.forEach((q) => {
+          expect(q.size).toBe(firstSize!)
+        })
+
+        await Promise.all(queries.map((q) => q.cleanup()))
+      })
+    })
+
+    describe(`Overlapping Predicates`, () => {
+      it(`should handle subset predicates correctly`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Query 1: age > 25 (superset)
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 25)),
+        )
+
+        // Query 2: age > 30 (subset of Query 1)
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 30)),
+        )
+
+        // Execute concurrently
+        await Promise.all([query1.preload(), query2.preload()])
+
+        // Query 2 results should be subset of Query 1
+        expect(query2.size).toBeLessThanOrEqual(query1.size)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
+      })
+
+      it(`should handle non-overlapping predicates correctly`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Query 1: age > 50
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 50)),
+        )
+
+        // Query 2: age < 30
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => lt(user.age, 30)),
+        )
+
+        // Execute concurrently
+        await Promise.all([query1.preload(), query2.preload()])
+        await Promise.all([
+          waitForQueryData(query1, { minSize: 1 }),
+          waitForQueryData(query2, { minSize: 1 }),
+        ])
+
+        // Both should execute independently
+        expect(query1.size).toBeGreaterThan(0)
+        expect(query2.size).toBeGreaterThan(0)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
+      })
+    })
+
+    describe(`Queries During Loading`, () => {
+      it(`should handle queries arriving during active load`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Start first query
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.isActive, true)),
+        )
+
+        // Immediately start identical second query
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.isActive, true)),
+        )
+
+        // Both should complete successfully
+        await Promise.all([query1.preload(), query2.preload()])
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
+      })
+
+      it(`should handle query arriving mid-flight with different predicate`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 25)),
+        )
+
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 50)),
+        )
+
+        await Promise.all([query1.preload(), query2.preload()])
+
+        // Both execute correctly
+        expect(query1.size).toBeGreaterThanOrEqual(query2.size)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
+      })
+    })
+
+    describe(`Deduplication with Limit/Offset`, () => {
+      it(`should handle queries with same limit/offset`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(10)
+            .offset(0),
+        )
+
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(10)
+            .offset(0),
+        )
+
+        await Promise.all([query1.preload(), query2.preload()])
+        await waitForQueryData(query1, { minSize: 10 })
+        await waitForQueryData(query2, { minSize: 10 })
+
+        expect(query1.size).toBe(query2.size)
+        expect(query1.size).toBe(10)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
+      })
+
+      it(`should handle queries with different limits`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(10),
+        )
+
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(20),
+        )
+
+        await Promise.all([query1.preload(), query2.preload()])
+        await waitForQueryData(query1, { minSize: 10 })
+        await waitForQueryData(query2, { minSize: 20 })
+
+        expect(query1.size).toBe(10)
+        expect(query2.size).toBe(20)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
+      })
+
+      it(`should handle queries with different offsets`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(10)
+            .offset(0),
+        )
+
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(10)
+            .offset(10),
+        )
+
+        await Promise.all([query1.preload(), query2.preload()])
+        await waitForQueryData(query1, { minSize: 10 })
+        await waitForQueryData(query2, { minSize: 10 })
+
+        expect(query1.size).toBe(10)
+        expect(query2.size).toBe(10)
+
+        // Results should be different
+        const ids1 = Array.from(query1.state.values()).map((u) => u.id)
+        const ids2 = Array.from(query2.state.values()).map((u) => u.id)
+        expect(ids1).not.toEqual(ids2)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
+      })
+    })
+
+    describe(`Race Conditions`, () => {
+      it(`should handle rapid concurrent query bursts`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Create 20 identical queries
+        const queries = Array.from({ length: 20 }, () =>
+          createLiveQueryCollection((q) =>
+            q
+              .from({ user: usersCollection })
+              .where(({ user }) => eq(user.isActive, true)),
+          ),
+        )
+
+        // Execute all simultaneously
+        await Promise.all(queries.map((q) => q.preload()))
+
+        // All should have same results
+        const firstSize = queries[0]?.size
+        expect(firstSize).toBeDefined()
+        queries.forEach((q) => {
+          expect(q.size).toBe(firstSize!)
+        })
+
+        await Promise.all(queries.map((q) => q.cleanup()))
+      })
+
+      it(`should not corrupt data with concurrent queries`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Execute many concurrent queries with different predicates
+        const queries = [
+          createLiveQueryCollection((q) =>
+            q
+              .from({ user: usersCollection })
+              .where(({ user }) => eq(user.age, 25)),
+          ),
+          createLiveQueryCollection((q) =>
+            q
+              .from({ user: usersCollection })
+              .where(({ user }) => gt(user.age, 50)),
+          ),
+          createLiveQueryCollection((q) =>
+            q
+              .from({ user: usersCollection })
+              .where(({ user }) => eq(user.isActive, true)),
+          ),
+          createLiveQueryCollection((q) =>
+            q
+              .from({ user: usersCollection })
+              .where(({ user }) => isNull(user.email)),
+          ),
+        ]
+
+        await Promise.all(queries.map((q) => q.preload()))
+        await Promise.all(
+          queries.map((q) => waitForQueryData(q, { minSize: 1 })),
+        )
+
+        // Each query should have valid results
+        queries.forEach((q) => {
+          expect(q.size).toBeGreaterThan(0)
+        })
+
+        await Promise.all(queries.map((q) => q.cleanup()))
+      })
+    })
+  })
+}
diff --git a/packages/db-collection-e2e/src/suites/joins.suite.ts b/packages/db-collection-e2e/src/suites/joins.suite.ts
new file mode 100644
index 000000000..5f25bb20b
--- /dev/null
+++ b/packages/db-collection-e2e/src/suites/joins.suite.ts
@@ -0,0 +1,376 @@
+/**
+ * Joins Test Suite
+ *
+ * Tests multi-collection joins with various syncMode combinations
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createLiveQueryCollection, eq, gt, isNull } from '@tanstack/db'
+import { waitFor, waitForQueryData } from '../utils/helpers'
+import type { E2ETestConfig } from '../types'
+
+export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
+  describe(`Joins Suite`, () => {
+    describe(`Two-Collection Joins`, () => {
+      it(`should join Users and Posts`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+        const postsCollection = config.collections.onDemand.posts
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .join({ post: postsCollection }, ({ user, post }) =>
+              eq(user.id, post.userId),
+            )
+            .select(({ user, post }) => ({
+              id: post!.id,
+              userName: user.name,
+              postTitle: post!.title,
+            })),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        expect(results[0]!).toHaveProperty(`userName`)
+        expect(results[0]!).toHaveProperty(`postTitle`)
+
+        await query.cleanup()
+      })
+
+      it(`should join with predicates on both collections`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+        const postsCollection = config.collections.onDemand.posts
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.isActive, true))
+            .join({ post: postsCollection }, ({ user, post }) =>
+              eq(user.id, post.userId),
+            )
+            .where(({ post }) => gt(post!.viewCount, 10))
+            .select(({ user, post }) => ({
+              id: post!.id,
+              userName: user.name,
+              postTitle: post!.title,
+              viewCount: post!.viewCount,
+            })),
+        )
+
+        await query.preload()
+
+        const results = Array.from(query.state.values())
+        // Verify predicates applied
+        results.forEach((r) => {
+          expect(r.viewCount).toBeGreaterThan(10)
+        })
+
+        await query.cleanup()
+      })
+
+      it(
+        `should join with one eager, one on-demand`,
+        { timeout: 60000 },
+        async () => {
+          const config = await getConfig()
+          const usersEager = config.collections.eager.users
+          const postsOnDemand = config.collections.onDemand.posts
+
+          const query = createLiveQueryCollection((q) =>
+            q
+              .from({ user: usersEager })
+              .join({ post: postsOnDemand }, ({ user, post }) =>
+                eq(user.id, post.userId),
+              )
+              .select(({ user, post }) => ({
+                id: post!.id,
+                userName: user.name,
+                postTitle: post!.title,
+              })),
+          )
+
+          await query.preload()
+          // Joins with eager + on-demand collections may need more time to load data from multiple sources
+          // Use longer timeout for CI environments which can be slower
+          await waitForQueryData(query, { minSize: 1, timeout: 50000 })
+
+          const results = Array.from(query.state.values())
+          expect(results.length).toBeGreaterThan(0)
+
+          await query.cleanup()
+        },
+      )
+
+      it(`should join with ordering across collections`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+        const postsCollection = config.collections.onDemand.posts
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .join({ post: postsCollection }, ({ user, post }) =>
+              eq(user.id, post.userId),
+            )
+            .orderBy(({ post }) => post!.viewCount, `desc`)
+            .select(({ user, post }) => ({
+              id: post!.id,
+              userName: user.name,
+              postTitle: post!.title,
+              viewCount: post!.viewCount,
+            })),
+        )
+
+        await query.preload()
+
+        // For joins with ordering, we need to wait for sufficient data in BOTH collections
+        // Wait for the posts collection to load enough data (not just the query results)
+        await waitFor(() => postsCollection.size >= 100, {
+          timeout: 5000,
+          interval: 50,
+          message: `Posts collection did not fully load (got ${postsCollection.size}/100)`,
+        })
+
+        // Also wait for query to have data
+        await waitForQueryData(query, { minSize: 50, timeout: 5000 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+
+        // All results MUST have viewCount field (verifies join completed successfully)
+        expect(results.every((r) => typeof r.viewCount === `number`)).toBe(true)
+
+        // Verify sorting by viewCount (descending)
+        for (let i = 1; i < results.length; i++) {
+          const prevCount = results[i - 1]!.viewCount
+          const currCount = results[i]!.viewCount
+          expect(prevCount).toBeGreaterThanOrEqual(currCount)
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should join with pagination`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+        const postsCollection = config.collections.onDemand.posts
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .join({ post: postsCollection }, ({ user, post }) =>
+              eq(user.id, post.userId),
+            )
+            .orderBy(({ post }) => post!.id, `asc`)
+            .limit(10)
+            .offset(5)
+            .select(({ user, post }) => ({
+              id: post!.id,
+              userName: user.name,
+              postTitle: post!.title,
+            })),
+        )
+
+        await query.preload()
+
+        expect(query.size).toBeLessThanOrEqual(10)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Three-Collection Joins`, () => {
+      it(`should join Users + Posts + Comments`, async () => {
+        const config = await getConfig()
+        const { users, posts, comments } = config.collections.onDemand
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: users })
+            .join({ post: posts }, ({ user, post }) => eq(user.id, post.userId))
+            .join({ comment: comments }, ({ post, comment }) =>
+              eq(post!.id, comment.postId),
+            )
+            .select(({ user, post, comment }) => ({
+              id: comment!.id,
+              userName: user.name,
+              postTitle: post!.title,
+              commentText: comment!.text,
+            })),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        expect(results[0]!).toHaveProperty(`userName`)
+        expect(results[0]!).toHaveProperty(`postTitle`)
+        expect(results[0]!).toHaveProperty(`commentText`)
+
+        await query.cleanup()
+      })
+
+      it(`should handle predicates on all three collections`, async () => {
+        const config = await getConfig()
+        const { users, posts, comments } = config.collections.onDemand
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: users })
+            .where(({ user }) => eq(user.isActive, true))
+            .join({ post: posts }, ({ user, post }) => eq(user.id, post.userId))
+            .where(({ post }) => isNull(post!.deletedAt))
+            .join({ comment: comments }, ({ post, comment }) =>
+              eq(post!.id, comment.postId),
+            )
+            .where(({ comment }) => isNull(comment!.deletedAt))
+            .select(({ user, post, comment }) => ({
+              id: comment!.id,
+              userName: user.name,
+              postTitle: post!.title,
+              commentText: comment!.text,
+            })),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        // All results should match all predicates and return some rows
+        expect(results.length).toBeGreaterThan(0)
+
+        await query.cleanup()
+      })
+
+      it(
+        `should handle mixed syncModes in 3-way join`,
+        { timeout: 60000 },
+        async () => {
+          const config = await getConfig()
+          const usersEager = config.collections.eager.users
+          const postsOnDemand = config.collections.onDemand.posts
+          const commentsOnDemand = config.collections.onDemand.comments
+
+          const query = createLiveQueryCollection((q) =>
+            q
+              .from({ user: usersEager })
+              .join({ post: postsOnDemand }, ({ user, post }) =>
+                eq(user.id, post.userId),
+              )
+              .join({ comment: commentsOnDemand }, ({ post, comment }) =>
+                eq(post!.id, comment.postId),
+              )
+              .select(({ user, post, comment }) => ({
+                id: comment!.id,
+                userName: user.name,
+                postTitle: post!.title,
+                commentText: comment!.text,
+              })),
+          )
+
+          await query.preload()
+          // 3-way joins with mixed eager + on-demand collections need more time
+          // Use longer timeout for CI environments which can be slower
+          await waitForQueryData(query, { minSize: 1, timeout: 50000 })
+
+          const results = Array.from(query.state.values())
+          expect(results.length).toBeGreaterThan(0)
+
+          await query.cleanup()
+        },
+      )
+    })
+
+    describe(`Predicate Pushdown in Joins`, () => {
+      it(`should push predicates to correct collections`, async () => {
+        const config = await getConfig()
+        const { users, posts } = config.collections.onDemand
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: users })
+            .join({ post: posts }, ({ user, post }) => eq(user.id, post.userId))
+            .where(({ post }) => gt(post!.viewCount, 50))
+            .select(({ user, post }) => ({
+              id: post!.id,
+              userName: user.name,
+              postTitle: post!.title,
+              viewCount: post!.viewCount,
+            })),
+        )
+
+        await query.preload()
+
+        const results = Array.from(query.state.values())
+        // Verify predicate applied
+        results.forEach((r) => {
+          expect(r.viewCount).toBeGreaterThan(50)
+        })
+
+        await query.cleanup()
+      })
+
+      it(`should not over-fetch in joined collections`, async () => {
+        const config = await getConfig()
+        const { users, posts } = config.collections.onDemand
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: users })
+            .where(({ user }) => gt(user.age, 30))
+            .join({ post: posts }, ({ user, post }) => eq(user.id, post.userId))
+            .select(({ user, post }) => ({
+              id: post!.id,
+              userName: user.name,
+              userAge: user.age,
+              postTitle: post!.title,
+            })),
+        )
+
+        await query.preload()
+
+        const results = Array.from(query.state.values())
+        // All users should be > 30
+        results.forEach((r) => {
+          expect(r.userAge).toBeGreaterThan(30)
+        })
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Left Joins`, () => {
+      it(`should handle left joins correctly`, async () => {
+        const config = await getConfig()
+        const { users, posts } = config.collections.onDemand
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: users })
+            .leftJoin({ post: posts }, ({ user, post }) =>
+              eq(user.id, post.userId),
+            )
+            .select(({ user, post }) => ({
+              id: user.id,
+              userName: user.name,
+              postTitle: post!.title, // May be null for users without posts
+            })),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+
+        await query.cleanup()
+      })
+    })
+  })
+}
diff --git a/packages/db-collection-e2e/src/suites/live-updates.suite.ts b/packages/db-collection-e2e/src/suites/live-updates.suite.ts
new file mode 100644
index 000000000..5b1f790e5
--- /dev/null
+++ b/packages/db-collection-e2e/src/suites/live-updates.suite.ts
@@ -0,0 +1,285 @@
+/**
+ * Live Updates Test Suite (Optional, Electric-specific)
+ *
+ * Tests reactive updates for sync-enabled collections
+ */
+
+import { randomUUID } from 'node:crypto'
+import { describe, expect, it } from 'vitest'
+import { createLiveQueryCollection, gt } from '@tanstack/db'
+import { waitFor, waitForQueryData } from '../utils/helpers'
+import type { E2ETestConfig } from '../types'
+
+export function createLiveUpdatesTestSuite(
+  getConfig: () => Promise<E2ETestConfig>,
+) {
+  describe(`Live Updates Suite`, () => {
+    describe(`Reactive Updates`, () => {
+      it(`should receive updates when backend data changes`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 30)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+        const initialSize = query.size
+        expect(initialSize).toBeGreaterThan(0)
+
+        // Insert a new user with age > 30
+        const newUserId = randomUUID()
+        await config.mutations.insertUser({
+          id: newUserId,
+          name: `Live Update User`,
+          email: null,
+          age: 45,
+          isActive: true,
+          createdAt: new Date(),
+          metadata: null,
+          deletedAt: null,
+        })
+
+        // Query should reactively update
+        await waitFor(() => query.size > initialSize, {
+          timeout: 5000,
+          message: `Query did not receive live update`,
+        })
+
+        expect(query.size).toBe(initialSize + 1)
+
+        // Clean up the inserted row
+        await config.mutations.deleteUser(newUserId)
+
+        // Wait for deletion to propagate if using async replication (e.g., Electric)
+        if (config.hasReplicationLag) {
+          await waitFor(
+            () => !config.collections.onDemand.users.has(newUserId),
+            {
+              timeout: 5000,
+              message: `Deletion of user ${newUserId} did not propagate`,
+            },
+          )
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should add new records that match query predicate`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 30)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+        const initialSize = query.size
+        expect(initialSize).toBeGreaterThan(0)
+
+        // Insert record with age=35 (matches predicate)
+        const newUserId = randomUUID()
+        await config.mutations.insertUser({
+          id: newUserId,
+          name: `Matching User`,
+          email: null,
+          age: 35,
+          isActive: true,
+          createdAt: new Date(),
+          metadata: null,
+          deletedAt: null,
+        })
+
+        // Should appear in query results reactively
+        await waitFor(() => query.size > initialSize, {
+          timeout: 5000,
+          message: `New matching record did not appear`,
+        })
+
+        expect(query.size).toBe(initialSize + 1)
+
+        // Clean up the inserted row
+        await config.mutations.deleteUser(newUserId)
+
+        // Wait for deletion to propagate if using async replication (e.g., Electric)
+        if (config.hasReplicationLag) {
+          await waitFor(
+            () => !config.collections.onDemand.users.has(newUserId),
+            {
+              timeout: 5000,
+              message: `Deletion of user ${newUserId} did not propagate`,
+            },
+          )
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should remove records that no longer match predicate`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 30)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+        const initialSize = query.size
+        expect(initialSize).toBeGreaterThan(0)
+
+        // Get a user currently in the query and update to not match
+        const queryUsers = Array.from(query.state.values())
+        const userToUpdate = queryUsers[0]
+
+        if (userToUpdate) {
+          // Update age to 25 (no longer matches age > 30)
+          await config.mutations.updateUser(userToUpdate.id, { age: 25 })
+
+          // Should be removed from query results
+          await waitFor(() => query.size < initialSize, {
+            timeout: 5000,
+            message: `Updated record was not removed from query`,
+          })
+
+          expect(query.size).toBe(initialSize - 1)
+        }
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Subscription Lifecycle`, () => {
+      it(`should receive updates when subscribed`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection }),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        let changeCount = 0
+        const subscription = query.subscribeChanges(() => {
+          changeCount++
+        })
+
+        // Insert a new user
+        const newUserId = randomUUID()
+        await config.mutations.insertUser({
+          id: newUserId,
+          name: `Subscription Test User`,
+          email: `sub@example.com`,
+          age: 28,
+          isActive: true,
+          createdAt: new Date(),
+          metadata: null,
+          deletedAt: null,
+        })
+
+        // Should receive change notification
+        await waitFor(() => changeCount > 0, {
+          timeout: 5000,
+          message: `No change notifications received`,
+        })
+
+        expect(changeCount).toBeGreaterThan(0)
+
+        subscription.unsubscribe()
+
+        // Clean up the inserted row
+        await config.mutations.deleteUser(newUserId)
+
+        // Wait for deletion to propagate if using async replication (e.g., Electric)
+        if (config.hasReplicationLag) {
+          await waitFor(
+            () => !config.collections.onDemand.users.has(newUserId),
+            {
+              timeout: 5000,
+              message: `Deletion of user ${newUserId} did not propagate`,
+            },
+          )
+        }
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Update Existing Records`, () => {
+      it(`should update existing records in query results`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection }),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        // Get a user and update it
+        const users = Array.from(query.state.values())
+        const userToUpdate = users[0]
+
+        if (userToUpdate) {
+          const originalAge = userToUpdate.age
+
+          // Update the user's age
+          await config.mutations.updateUser(userToUpdate.id, {
+            age: originalAge + 10,
+          })
+
+          // Wait for update to sync
+          await waitFor(
+            () => {
+              const updated = query.get(userToUpdate.id)
+              return updated?.age === originalAge + 10
+            },
+            { timeout: 5000, message: `Update did not sync to query` },
+          )
+
+          // Verify the update
+          const updatedUser = query.get(userToUpdate.id)
+          expect(updatedUser?.age).toBe(originalAge + 10)
+        }
+
+        await query.cleanup()
+      })
+    })
+  })
+}
diff --git a/packages/db-collection-e2e/src/suites/moves.suite.ts b/packages/db-collection-e2e/src/suites/moves.suite.ts
new file mode 100644
index 000000000..cfc7fda40
--- /dev/null
+++ b/packages/db-collection-e2e/src/suites/moves.suite.ts
@@ -0,0 +1,756 @@
+/**
+ * Tags Test Suite
+ *
+ * Tests Electric collection tag behavior with subqueries
+ * Only Electric collection supports tags (via shapes with subqueries)
+ */
+
+import { randomUUID } from 'node:crypto'
+import { beforeAll, describe, expect, it } from 'vitest'
+import { createCollection } from '@tanstack/db'
+import { electricCollectionOptions } from '@tanstack/electric-db-collection'
+import { waitFor } from '../utils/helpers'
+import type { E2ETestConfig } from '../types'
+import type { Client } from 'pg'
+import type { Collection } from '@tanstack/db'
+import type { ElectricCollectionUtils } from '@tanstack/electric-db-collection'
+
+interface TagsTestConfig extends E2ETestConfig {
+  tagsTestSetup: {
+    dbClient: Client
+    baseUrl: string
+    testSchema: string
+    usersTable: string
+    postsTable: string
+  }
+}
+
+type SyncMode = 'eager' | 'on-demand' | 'progressive'
+
+export function createMovesTestSuite(getConfig: () => Promise<TagsTestConfig>) {
+  describe(`Moves Suite`, () => {
+    let usersTable: string
+    let postsTable: string
+    let dbClient: Client
+    let baseUrl: string
+    let testSchema: string
+    let config: TagsTestConfig
+
+    beforeAll(async () => {
+      config = await getConfig()
+      const setup = config.tagsTestSetup
+      dbClient = setup.dbClient
+      baseUrl = setup.baseUrl
+      testSchema = setup.testSchema
+      usersTable = setup.usersTable
+      postsTable = setup.postsTable
+    })
+
+    // Helper to create a collection on posts table with WHERE clause that has nested subquery
+    // This creates a shape: posts WHERE userId IN (SELECT id FROM users WHERE isActive = true)
+    // When a user's isActive changes, posts will move in/out of this shape
+    function createPostsByActiveUsersCollection(
+      syncMode: SyncMode,
+      id?: string,
+    ): Collection<any, string, ElectricCollectionUtils, any, any> {
+      // Remove quotes from table names for the WHERE clause SQL
+      const usersTableUnquoted = usersTable.replace(/"/g, ``)
+      const collectionId =
+        id || `tags-posts-active-users-${syncMode}-${Date.now()}`
+
+      return createCollection(
+        electricCollectionOptions({
+          id: collectionId,
+          shapeOptions: {
+            url: `${baseUrl}/v1/shape`,
+            params: {
+              table: `${testSchema}.${postsTable}`,
+              // WHERE clause with nested subquery
+              // Posts will move in/out when users' isActive changes
+              // Column reference should be just the column name, not the full table path
+              where: `"userId" IN (SELECT id FROM ${testSchema}.${usersTableUnquoted} WHERE "isActive" = true)`,
+            },
+          },
+          syncMode,
+          getKey: (item: any) => item.id,
+          startSync: syncMode !== 'progressive',
+        }),
+      ) as any
+    }
+
+    // Helper to wait for collection to be ready
+    async function waitForReady(
+      collection: Collection<any, any, any, any, any>,
+      syncMode: SyncMode,
+    ) {
+      if (syncMode === 'progressive') {
+        // For progressive mode, start sync explicitly
+        collection.startSyncImmediate()
+      }
+      await collection.preload()
+      await waitFor(() => collection.status === `ready`, {
+        timeout: 30000,
+        message: `Collection did not become ready`,
+      })
+    }
+
+    // Helper to wait for a specific item to appear
+    async function waitForItem(
+      collection: Collection<any, any, any, any, any>,
+      itemId: string,
+      timeout: number = 10000,
+    ) {
+      await waitFor(() => collection.has(itemId), {
+        timeout,
+        message: `Item ${itemId} did not appear in collection`,
+      })
+    }
+
+    // Helper to wait for a specific item to disappear
+    async function waitForItemRemoved(
+      collection: Collection<any, any, any, any, any>,
+      itemId: string,
+      timeout: number = 2000,
+    ) {
+      await waitFor(() => !collection.has(itemId), {
+        timeout,
+        message: `Item ${itemId} was not removed from collection`,
+      })
+    }
+
+    // Helper to wait for users to be synced to Electric/TanStack DB
+    async function waitForUsersSynced(
+      userIds: Array<string>,
+      timeout: number = 10000,
+    ) {
+      // Use eager collection since it continuously syncs all data
+      const usersCollection = config.collections.eager.users
+      await waitFor(
+        () => {
+          return userIds.every((userId) => usersCollection.has(userId))
+        },
+        {
+          timeout,
+          message: `Users ${userIds.join(', ')} did not sync to collection`,
+        },
+      )
+    }
+
+    // Helper function to run all tests for a given sync mode
+    function runTestsForSyncMode(syncMode: SyncMode) {
+      describe(`${syncMode} mode`, () => {
+        it(`Initial snapshot contains only posts from active users`, async () => {
+          // Create collection on posts with WHERE clause: userId IN (SELECT id FROM users WHERE isActive = true)
+          const collection = createPostsByActiveUsersCollection(syncMode)
+
+          if (!config.mutations) {
+            throw new Error(`Mutations not configured`)
+          }
+
+          // Insert 2 active users and 1 inactive user
+          const userId1 = randomUUID()
+          const userId2 = randomUUID()
+          const userId3 = randomUUID()
+
+          await config.mutations.insertUser({
+            id: userId1,
+            name: `Active User 1`,
+            email: `user1@test.com`,
+            age: 25,
+            isActive: true,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          await config.mutations.insertUser({
+            id: userId2,
+            name: `Active User 2`,
+            email: `user2@test.com`,
+            age: 30,
+            isActive: true,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          await config.mutations.insertUser({
+            id: userId3,
+            name: `Inactive User`,
+            email: `user3@test.com`,
+            age: 42,
+            isActive: false,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          // Wait for all 3 users to be synced to Electric before inserting posts
+          // This ensures the subquery in the WHERE clause can properly evaluate
+          await waitForUsersSynced([userId1, userId2, userId3])
+
+          // Insert posts for these users
+          const postId1 = randomUUID()
+          const postId2 = randomUUID()
+          const postId3 = randomUUID()
+
+          await config.mutations.insertPost({
+            id: postId1,
+            userId: userId1,
+            title: `Post 1`,
+            content: `Content 1`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          await config.mutations.insertPost({
+            id: postId2,
+            userId: userId2,
+            title: `Post 2`,
+            content: `Content 2`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          await config.mutations.insertPost({
+            id: postId3,
+            userId: userId3,
+            title: `Post 3`,
+            content: `Content 3`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          // Wait for collection to sync
+          await waitForReady(collection, syncMode)
+
+          // Wait for both posts to appear (users are active, so posts match the subquery)
+          await waitForItem(collection, postId1)
+          await waitForItem(collection, postId2)
+
+          // Verify only posts 1 and 2 are in the collection
+          expect(collection.has(postId1)).toBe(true)
+          expect(collection.has(postId2)).toBe(true)
+          expect(collection.has(postId3)).toBe(false)
+
+          // Wait a bit to make sure post 3 is not coming in later
+          await new Promise((resolve) => setTimeout(resolve, 50))
+          expect(collection.has(postId3)).toBe(false)
+
+          // Note: Tags are internal to Electric and may not be directly accessible
+          // The test verifies that posts with matching conditions appear in snapshot
+
+          // Clean up
+          await dbClient.query(`DELETE FROM ${postsTable}`)
+          await dbClient.query(`DELETE FROM ${usersTable}`)
+          await collection.cleanup()
+        })
+
+        it(`Move-in: row becomes eligible for subquery`, async () => {
+          const collection = createPostsByActiveUsersCollection(syncMode)
+          await waitForReady(collection, syncMode)
+
+          if (!config.mutations) {
+            throw new Error(`Mutations not configured`)
+          }
+
+          // Insert user with isActive = false
+          const userId = randomUUID()
+          await config.mutations.insertUser({
+            id: userId,
+            name: `Inactive User`,
+            email: `inactive@test.com`,
+            age: 25,
+            isActive: false,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          // Wait for user to be synced to Electric before inserting post
+          await waitForUsersSynced([userId])
+
+          // Insert post for this user
+          const postId = randomUUID()
+          await config.mutations.insertPost({
+            id: postId,
+            userId,
+            title: `Inactive User Post`,
+            content: `Content`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          // Wait a bit to ensure post doesn't appear (user is inactive, so post doesn't match subquery)
+          await new Promise((resolve) => setTimeout(resolve, 500))
+          expect(collection.has(postId)).toBe(false)
+
+          // Update user to isActive = true (move-in for the post)
+          await config.mutations.updateUser(userId, { isActive: true })
+
+          // Wait for post to appear (move-in)
+          await waitForItem(collection, postId, 1000)
+          expect(collection.has(postId)).toBe(true)
+          expect(collection.get(postId)?.title).toBe(`Inactive User Post`)
+
+          // Clean up
+          await dbClient.query(`DELETE FROM ${postsTable} WHERE id = $1`, [
+            postId,
+          ])
+          await config.mutations.deleteUser(userId)
+          await collection.cleanup()
+        })
+
+        it(`Move-out: row becomes ineligible for subquery`, async () => {
+          const collection = createPostsByActiveUsersCollection(syncMode)
+          await waitForReady(collection, syncMode)
+
+          if (!config.mutations) {
+            throw new Error(`Mutations not configured`)
+          }
+
+          // Insert user with isActive = true
+          const userId = randomUUID()
+          await config.mutations.insertUser({
+            id: userId,
+            name: `Active User`,
+            email: `active@test.com`,
+            age: 25,
+            isActive: true,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          // Wait for user to be synced to Electric before inserting post
+          await waitForUsersSynced([userId])
+
+          // Insert post for this user
+          const postId = randomUUID()
+          await config.mutations.insertPost({
+            id: postId,
+            userId,
+            title: `Active User Post`,
+            content: `Content`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          // Wait for post to appear (user is active, so post matches subquery)
+          await waitForItem(collection, postId)
+          expect(collection.has(postId)).toBe(true)
+
+          // Update user to isActive = false (move-out for the post)
+          await config.mutations.updateUser(userId, { isActive: false })
+
+          // Wait for post to be removed (move-out)
+          await waitForItemRemoved(collection, postId)
+          expect(collection.has(postId)).toBe(false)
+
+          // Clean up
+          await dbClient.query(`DELETE FROM ${postsTable} WHERE id = $1`, [
+            postId,
+          ])
+          await config.mutations.deleteUser(userId)
+          await collection.cleanup()
+        })
+
+        it(`Move-out → move-in cycle`, async () => {
+          const collection = createPostsByActiveUsersCollection(syncMode)
+          await waitForReady(collection, syncMode)
+
+          if (!config.mutations) {
+            throw new Error(`Mutations not configured`)
+          }
+
+          // Insert user with isActive = true
+          const userId = randomUUID()
+          await config.mutations.insertUser({
+            id: userId,
+            name: `Flapping User`,
+            email: `flapping@test.com`,
+            age: 25,
+            isActive: true,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          // Wait for user to be synced to Electric before inserting post
+          await waitForUsersSynced([userId])
+
+          // Insert post for this user
+          const postId = randomUUID()
+          await config.mutations.insertPost({
+            id: postId,
+            userId,
+            title: `Flapping Post`,
+            content: `Content`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          await waitForItem(collection, postId)
+          expect(collection.has(postId)).toBe(true)
+
+          // Move-out: isActive = false
+          await config.mutations.updateUser(userId, { isActive: false })
+          await waitForItemRemoved(collection, postId, 15000)
+          expect(collection.has(postId)).toBe(false)
+
+          // Move-in: isActive = true
+          await config.mutations.updateUser(userId, { isActive: true })
+          await waitForItem(collection, postId, 15000)
+          expect(collection.has(postId)).toBe(true)
+
+          // Clean up
+          await dbClient.query(`DELETE FROM ${postsTable} WHERE id = $1`, [
+            postId,
+          ])
+          await config.mutations.deleteUser(userId)
+          await collection.cleanup()
+        })
+
+        it(`Tags-only update (row stays within subquery)`, async () => {
+          const collection = createPostsByActiveUsersCollection(syncMode)
+          await waitForReady(collection, syncMode)
+
+          if (!config.mutations) {
+            throw new Error(`Mutations not configured`)
+          }
+
+          // Insert user with isActive = true
+          const userId = randomUUID()
+          await config.mutations.insertUser({
+            id: userId,
+            name: `Active User`,
+            email: `active@test.com`,
+            age: 25,
+            isActive: true,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          // Wait for user to be synced to Electric before inserting post
+          await waitForUsersSynced([userId])
+
+          // Insert post for this user
+          const postId = randomUUID()
+          await config.mutations.insertPost({
+            id: postId,
+            userId,
+            title: `Tagged Post`,
+            content: `Content`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          await waitForItem(collection, postId)
+          expect(collection.has(postId)).toBe(true)
+
+          // Update post title (tags might change but post stays in subquery since user is still active)
+          await dbClient.query(
+            `UPDATE ${postsTable} SET title = $1 WHERE id = $2`,
+            [`Updated Tagged Post`, postId],
+          )
+
+          // Wait a bit and verify post still exists
+          await new Promise((resolve) => setTimeout(resolve, 500))
+          expect(collection.has(postId)).toBe(true)
+          expect(collection.get(postId)?.title).toBe(`Updated Tagged Post`)
+
+          // Clean up
+          await dbClient.query(`DELETE FROM ${postsTable} WHERE id = $1`, [
+            postId,
+          ])
+          await config.mutations.deleteUser(userId)
+          await collection.cleanup()
+        })
+
+        it(`Database DELETE leads to row being removed from collection`, async () => {
+          const collection = createPostsByActiveUsersCollection(syncMode)
+          await waitForReady(collection, syncMode)
+
+          if (!config.mutations) {
+            throw new Error(`Mutations not configured`)
+          }
+
+          // Insert user with isActive = true
+          const userId = randomUUID()
+          await config.mutations.insertUser({
+            id: userId,
+            name: `Active User`,
+            email: `active@test.com`,
+            age: 25,
+            isActive: true,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          // Wait for user to be synced to Electric before inserting post
+          await waitForUsersSynced([userId])
+
+          // Insert post for this user
+          const postId = randomUUID()
+          await config.mutations.insertPost({
+            id: postId,
+            userId,
+            title: `To Be Deleted`,
+            content: `Content`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          await waitForItem(collection, postId)
+          expect(collection.has(postId)).toBe(true)
+
+          // Delete post in Postgres
+          await dbClient.query(`DELETE FROM ${postsTable} WHERE id = $1`, [
+            postId,
+          ])
+
+          // Wait for post to be removed
+          await waitForItemRemoved(collection, postId)
+          expect(collection.has(postId)).toBe(false)
+
+          // Clean up
+          await config.mutations.deleteUser(userId)
+          await collection.cleanup()
+        })
+
+        it(`Snapshot after move-out should not re-include removed rows`, async () => {
+          if (!config.mutations) {
+            throw new Error(`Mutations not configured`)
+          }
+
+          // Create first collection
+          const collection1 = createPostsByActiveUsersCollection(syncMode)
+          await waitForReady(collection1, syncMode)
+
+          // Insert user with isActive = true
+          const userId = randomUUID()
+          await config.mutations.insertUser({
+            id: userId,
+            name: `Snapshot Test User`,
+            email: `snapshot@test.com`,
+            age: 25,
+            isActive: true,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          // Wait for user to be synced to Electric before inserting post
+          await waitForUsersSynced([userId])
+
+          // Insert post for this user
+          const postId = randomUUID()
+          await config.mutations.insertPost({
+            id: postId,
+            userId,
+            title: `Snapshot Test Post`,
+            content: `Content`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          await waitForItem(collection1, postId)
+          expect(collection1.has(postId)).toBe(true)
+
+          // Update user → post moves out
+          await config.mutations.updateUser(userId, { isActive: false })
+
+          await waitForItemRemoved(collection1, postId)
+          expect(collection1.has(postId)).toBe(false)
+
+          // Clean up first collection
+          await collection1.cleanup()
+
+          // Create fresh collection (new subscription)
+          const collection2 = createPostsByActiveUsersCollection(syncMode)
+          await waitForReady(collection2, syncMode)
+
+          // Wait a bit to ensure snapshot is complete
+          await new Promise((resolve) => setTimeout(resolve, 1000))
+
+          // Snapshot should NOT include the removed post (user is inactive)
+          expect(collection2.has(postId)).toBe(false)
+
+          // Clean up
+          await dbClient.query(`DELETE FROM ${postsTable} WHERE id = $1`, [
+            postId,
+          ])
+          await config.mutations.deleteUser(userId)
+          await collection2.cleanup()
+        })
+
+        it(`Multi-row transaction: some rows move in, some move out`, async () => {
+          const collection = createPostsByActiveUsersCollection(syncMode)
+          await waitForReady(collection, syncMode)
+
+          if (!config.mutations) {
+            throw new Error(`Mutations not configured`)
+          }
+
+          // Insert 3 users all with isActive = true
+          const userId1 = randomUUID()
+          const userId2 = randomUUID()
+          const userId3 = randomUUID()
+
+          await config.mutations.insertUser({
+            id: userId1,
+            name: `User 1`,
+            email: `user1@test.com`,
+            age: 25,
+            isActive: false,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          await config.mutations.insertUser({
+            id: userId2,
+            name: `User 2`,
+            email: `user2@test.com`,
+            age: 30,
+            isActive: true,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          await config.mutations.insertUser({
+            id: userId3,
+            name: `User 3`,
+            email: `user3@test.com`,
+            age: 35,
+            isActive: true,
+            createdAt: new Date(),
+            metadata: null,
+            deletedAt: null,
+          })
+
+          // Wait for all 3 users to be synced to Electric before inserting posts
+          // This ensures the subquery in the WHERE clause can properly evaluate
+          await waitForUsersSynced([userId1, userId2, userId3])
+
+          // Insert posts for these users
+          const postId1 = randomUUID()
+          const postId2 = randomUUID()
+          const postId3 = randomUUID()
+
+          await config.mutations.insertPost({
+            id: postId1,
+            userId: userId1,
+            title: `Post 1`,
+            content: `Content 1`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          await config.mutations.insertPost({
+            id: postId2,
+            userId: userId2,
+            title: `Post 2`,
+            content: `Content 2`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          await config.mutations.insertPost({
+            id: postId3,
+            userId: userId3,
+            title: `Post 3`,
+            content: `Content 3`,
+            viewCount: 0,
+            largeViewCount: BigInt(0),
+            publishedAt: null,
+            deletedAt: null,
+          })
+
+          // Wait for posts 2 and 3 to appear
+          await waitForItem(collection, postId2)
+          await waitForItem(collection, postId3)
+
+          expect(collection.has(postId1)).toBe(false)
+
+          // In one SQL transaction:
+          // user1: isActive → true (post1 moves in)
+          // post2: title change (stays in since user2 is still active)
+          // user3: isActive → false (post3 moves out)
+          await dbClient.query(`BEGIN`)
+          try {
+            await dbClient.query(
+              `UPDATE ${usersTable} SET "isActive" = $1 WHERE id = $2`,
+              [true, userId1],
+            )
+            await dbClient.query(
+              `UPDATE ${postsTable} SET title = $1 WHERE id = $2`,
+              [`Updated Post 2`, postId2],
+            )
+            await dbClient.query(
+              `UPDATE ${usersTable} SET "isActive" = $1 WHERE id = $2`,
+              [false, userId3],
+            )
+            await dbClient.query(`COMMIT`)
+          } catch (error) {
+            await dbClient.query(`ROLLBACK`)
+            throw error
+          }
+
+          // Wait for changes to propagate
+          await waitForItemRemoved(collection, postId3)
+          await new Promise((resolve) => setTimeout(resolve, 1000))
+          expect(collection.has(postId1)).toBe(true) // post1: moved in (user1 active)
+          expect(collection.has(postId2)).toBe(true) // post2: still in (user2 active)
+          expect(collection.get(postId2)?.title).toBe(`Updated Post 2`)
+          expect(collection.has(postId3)).toBe(false) // post3: moved out (user3 inactive)
+
+          // Clean up
+          await dbClient.query(`DELETE FROM ${postsTable} WHERE id = $1`, [
+            postId1,
+          ])
+          await dbClient.query(`DELETE FROM ${postsTable} WHERE id = $1`, [
+            postId2,
+          ])
+          await dbClient.query(`DELETE FROM ${postsTable} WHERE id = $1`, [
+            postId3,
+          ])
+          await config.mutations.deleteUser(userId1)
+          await config.mutations.deleteUser(userId2)
+          await config.mutations.deleteUser(userId3)
+          await collection.cleanup()
+        })
+      })
+    }
+
+    // Run tests for each sync mode
+    runTestsForSyncMode('eager')
+    runTestsForSyncMode('on-demand')
+    runTestsForSyncMode('progressive')
+  })
+}
diff --git a/packages/db-collection-e2e/src/suites/mutations.suite.ts b/packages/db-collection-e2e/src/suites/mutations.suite.ts
new file mode 100644
index 000000000..17a73d4c6
--- /dev/null
+++ b/packages/db-collection-e2e/src/suites/mutations.suite.ts
@@ -0,0 +1,318 @@
+/**
+ * Mutations Test Suite
+ *
+ * Tests data mutations with on-demand syncMode
+ */
+
+import { randomUUID } from 'node:crypto'
+import { describe, expect, it } from 'vitest'
+import { createLiveQueryCollection, eq, gt, isNull } from '@tanstack/db'
+import { waitFor, waitForQueryData } from '../utils/helpers'
+import type { E2ETestConfig } from '../types'
+
+export function createMutationsTestSuite(
+  getConfig: () => Promise<E2ETestConfig>,
+) {
+  describe(`Mutations Suite`, () => {
+    describe(`Insert Mutations`, () => {
+      it(`should insert new record via collection`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        // Load initial data
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection }),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+        const initialSize = query.size
+        expect(initialSize).toBeGreaterThan(0)
+
+        // Perform actual INSERT via backend
+        const newUserId = randomUUID()
+        await config.mutations.insertUser({
+          id: newUserId,
+          name: `Test User`,
+          email: `test@example.com`,
+          age: 42,
+          isActive: true,
+          createdAt: new Date(),
+          metadata: null,
+          deletedAt: null,
+        })
+
+        // Wait for sync to propagate the new record (Electric only)
+        await waitFor(() => query.size > initialSize, {
+          timeout: 5000,
+          message: `New record did not appear in query`,
+        })
+
+        expect(query.size).toBe(initialSize + 1)
+
+        // Clean up the inserted row
+        await config.mutations.deleteUser(newUserId)
+
+        // Wait for deletion to propagate if using async replication (e.g., Electric)
+        // Check the eager collection since it continuously syncs all data
+        if (config.hasReplicationLag) {
+          await waitFor(() => !config.collections.eager.users.has(newUserId), {
+            timeout: 5000,
+            message: `Deletion of user ${newUserId} did not propagate`,
+          })
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should handle insert appearing in matching queries`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 30)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+        const initialSize = query.size
+        expect(initialSize).toBeGreaterThan(0)
+
+        // Insert record that MATCHES predicate (age > 30)
+        const newUserId = randomUUID()
+        await config.mutations.insertUser({
+          id: newUserId,
+          name: `Test Match User`,
+          email: `match@example.com`,
+          age: 50,
+          isActive: true,
+          createdAt: new Date(),
+          metadata: null,
+          deletedAt: null,
+        })
+
+        // Wait for sync to propagate (Electric only)
+        await waitFor(() => query.size > initialSize, {
+          timeout: 5000,
+          message: `Matching insert did not appear in query`,
+        })
+
+        expect(query.size).toBe(initialSize + 1)
+
+        // Clean up the inserted row
+        await config.mutations.deleteUser(newUserId)
+
+        // Wait for deletion to propagate if using async replication (e.g., Electric)
+        // Check the eager collection since it continuously syncs all data
+        if (config.hasReplicationLag) {
+          await waitFor(() => !config.collections.eager.users.has(newUserId), {
+            timeout: 5000,
+            message: `Deletion of user ${newUserId} did not propagate`,
+          })
+        }
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Update Mutations`, () => {
+      it(`should handle update that makes record match predicate`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 30)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+        const initialSize = query.size
+        expect(initialSize).toBeGreaterThan(0)
+
+        // Find a user with age <= 30 in the full collection
+        const allUsers = Array.from(usersCollection.state.values())
+        const userToUpdate = allUsers.find((u) => u.age <= 30)
+
+        if (userToUpdate) {
+          // Update age to 35 (matches predicate)
+          await config.mutations.updateUser(userToUpdate.id, { age: 35 })
+
+          // Wait for Electric to sync and query to show updated record
+          await waitFor(() => query.size > initialSize, {
+            timeout: 5000,
+            message: `Updated record did not appear in query`,
+          })
+
+          expect(query.size).toBe(initialSize + 1)
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should handle update that makes record unmatch predicate`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 30)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+        const initialSize = query.size
+        expect(initialSize).toBeGreaterThan(0)
+
+        // Get a user currently in the query (age > 30)
+        const queryUsers = Array.from(query.state.values())
+        const userToUpdate = queryUsers[0]
+
+        if (userToUpdate) {
+          // Update age to 25 (no longer matches predicate)
+          await config.mutations.updateUser(userToUpdate.id, { age: 25 })
+
+          // Wait for Electric to sync and query to remove record
+          await waitFor(() => query.size < initialSize, {
+            timeout: 5000,
+            message: `Updated record was not removed from query`,
+          })
+
+          expect(query.size).toBe(initialSize - 1)
+        }
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Delete Mutations`, () => {
+      it(`should handle delete removing record from query`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection }),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+        const initialSize = query.size
+        expect(initialSize).toBeGreaterThan(0)
+
+        // Get a user and delete it
+        const users = Array.from(query.state.values())
+        const userToDelete = users[0]
+
+        if (userToDelete) {
+          await config.mutations.deleteUser(userToDelete.id)
+
+          // Wait for delete to sync
+          await waitFor(() => query.size < initialSize, {
+            timeout: 5000,
+            message: `Delete did not sync to query`,
+          })
+
+          expect(query.size).toBe(initialSize - 1)
+        }
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Soft Delete Pattern`, () => {
+      it(`should filter out soft-deleted records`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => isNull(user.deletedAt)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        // All results should not be soft-deleted
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        results.forEach((u) => {
+          expect(u.deletedAt).toBeNull()
+        })
+
+        await query.cleanup()
+      })
+
+      it(`should include soft-deleted records when not filtered`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection }),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        // Should include both deleted and non-deleted
+        const results = Array.from(query.state.values())
+        const hasNotDeleted = results.some((u) => u.deletedAt === null)
+
+        expect(hasNotDeleted).toBe(true)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Mutation with Queries`, () => {
+      it(`should maintain query state during data changes`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.isActive, true))
+            .orderBy(({ user }) => user.age, `asc`)
+            .limit(10),
+        )
+
+        await query.preload()
+
+        // Test structure: Mutations should maintain pagination state
+        expect(query.size).toBeLessThanOrEqual(10)
+
+        await query.cleanup()
+      })
+    })
+  })
+}
diff --git a/packages/db-collection-e2e/src/suites/pagination.suite.ts b/packages/db-collection-e2e/src/suites/pagination.suite.ts
new file mode 100644
index 000000000..7ccf2c60b
--- /dev/null
+++ b/packages/db-collection-e2e/src/suites/pagination.suite.ts
@@ -0,0 +1,951 @@
+/**
+ * Pagination Test Suite
+ *
+ * Tests ordering, limits, offsets, and window management
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createLiveQueryCollection, eq } from '@tanstack/db'
+import {
+  assertAllItemsMatch,
+  assertCollectionSize,
+  assertSorted,
+} from '../utils/assertions'
+import { waitForQueryData } from '../utils/helpers'
+import type { E2ETestConfig } from '../types'
+
+export function createPaginationTestSuite(
+  getConfig: () => Promise<E2ETestConfig>,
+) {
+  describe(`Pagination Suite`, () => {
+    describe(`OrderBy`, () => {
+      it(`should sort ascending by single field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.age, `asc`),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertSorted(results, `age`, `asc`)
+
+        await query.cleanup()
+      })
+
+      it(`should sort descending by single field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.age, `desc`),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertSorted(results, `age`, `desc`)
+
+        await query.cleanup()
+      })
+
+      it(`should sort by string field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.name, `asc`),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+
+        // Verify it's sorted (don't assert exact order due to collation differences)
+        // Just verify we got results and they're in some order
+        expect(results[0]!).toHaveProperty(`name`)
+
+        await query.cleanup()
+      })
+
+      it(`should sort by date field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.createdAt, `desc`),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertSorted(results, `createdAt`, `desc`)
+
+        await query.cleanup()
+      })
+
+      it(`should sort by multiple fields`, async () => {
+        const config = await getConfig()
+        const postsCollection = config.collections.onDemand.posts
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ post: postsCollection })
+            .orderBy(({ post }) => [post.userId, post.viewCount]),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+
+        // Verify multi-field sort (userId first, then viewCount within each userId)
+        for (let i = 1; i < results.length; i++) {
+          const prev = results[i - 1]!
+          const curr = results[i]!
+
+          // If userId is same, viewCount should be ascending
+          if (prev.userId === curr.userId) {
+            expect(prev.viewCount).toBeLessThanOrEqual(curr.viewCount)
+          }
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should sort by multiple fields with chained orderBy`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.isActive, `desc`)
+            .orderBy(({ user }) => user.age, `asc`),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+
+        // Verify multi-field sort (isActive desc first, then age asc within each isActive)
+        for (let i = 1; i < results.length; i++) {
+          const prev = results[i - 1]!
+          const curr = results[i]!
+
+          // isActive should be descending (true before false)
+          if (prev.isActive !== curr.isActive) {
+            // true (1) should come before false (0) in desc order
+            expect(prev.isActive ? 1 : 0).toBeGreaterThanOrEqual(
+              curr.isActive ? 1 : 0,
+            )
+          } else {
+            // If isActive is same, age should be ascending
+            expect(prev.age).toBeLessThanOrEqual(curr.age)
+          }
+        }
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Multi-Column OrderBy with Incremental Loading`, () => {
+      it(`should correctly paginate with multi-column orderBy and limit`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // First page - get first 10 users sorted by isActive desc, age asc
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.isActive, `desc`)
+            .orderBy(({ user }) => user.age, `asc`)
+            .limit(10),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 10 })
+
+        const results = Array.from(query.state.values())
+        expect(results).toHaveLength(10)
+
+        // Verify the ordering is correct
+        for (let i = 1; i < results.length; i++) {
+          const prev = results[i - 1]!
+          const curr = results[i]!
+
+          if (prev.isActive !== curr.isActive) {
+            expect(prev.isActive ? 1 : 0).toBeGreaterThanOrEqual(
+              curr.isActive ? 1 : 0,
+            )
+          } else {
+            expect(prev.age).toBeLessThanOrEqual(curr.age)
+          }
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should load subsequent pages correctly with multi-column orderBy`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Get first 15 users
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.isActive, `desc`)
+            .orderBy(({ user }) => user.age, `asc`)
+            .limit(15),
+        )
+
+        await query1.preload()
+        await waitForQueryData(query1, { minSize: 15 })
+
+        const firstPage = Array.from(query1.state.values())
+        expect(firstPage).toHaveLength(15)
+
+        // Get first 30 users (expanding the window)
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.isActive, `desc`)
+            .orderBy(({ user }) => user.age, `asc`)
+            .limit(30),
+        )
+
+        await query2.preload()
+        await waitForQueryData(query2, { minSize: 30 })
+
+        const expandedPage = Array.from(query2.state.values())
+        expect(expandedPage).toHaveLength(30)
+
+        // The first 15 items should be the same in both queries
+        for (let i = 0; i < 15; i++) {
+          expect(expandedPage[i]!.id).toBe(firstPage[i]!.id)
+        }
+
+        // Verify ordering is maintained throughout
+        for (let i = 1; i < expandedPage.length; i++) {
+          const prev = expandedPage[i - 1]!
+          const curr = expandedPage[i]!
+
+          if (prev.isActive !== curr.isActive) {
+            expect(prev.isActive ? 1 : 0).toBeGreaterThanOrEqual(
+              curr.isActive ? 1 : 0,
+            )
+          } else {
+            expect(prev.age).toBeLessThanOrEqual(curr.age)
+          }
+        }
+
+        await query1.cleanup()
+        await query2.cleanup()
+      })
+
+      it(`should handle multi-column orderBy with duplicate values in first column`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Sort by isActive (only 2 values: true/false) then by age
+        // This tests the case where many rows have the same first column value
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.isActive, `desc`)
+            .orderBy(({ user }) => user.age, `asc`)
+            .limit(50),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 50 })
+
+        const results = Array.from(query.state.values())
+        expect(results).toHaveLength(50)
+
+        // Count how many active users we got
+        const activeUsers = results.filter((u) => u.isActive)
+        const inactiveUsers = results.filter((u) => !u.isActive)
+
+        // Since isActive desc, all active users should come first
+        // All active users should be at the start
+        let foundInactive = false
+        for (const user of results) {
+          if (!user.isActive) {
+            foundInactive = true
+          } else if (foundInactive) {
+            // Found active after inactive - this is wrong
+            throw new Error(
+              `Found active user after inactive user in desc order`,
+            )
+          }
+        }
+
+        // Verify age is ascending within each group
+        if (activeUsers.length > 1) {
+          for (let i = 1; i < activeUsers.length; i++) {
+            expect(activeUsers[i - 1]!.age).toBeLessThanOrEqual(
+              activeUsers[i]!.age,
+            )
+          }
+        }
+
+        if (inactiveUsers.length > 1) {
+          for (let i = 1; i < inactiveUsers.length; i++) {
+            expect(inactiveUsers[i - 1]!.age).toBeLessThanOrEqual(
+              inactiveUsers[i]!.age,
+            )
+          }
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should handle multi-column orderBy with mixed directions`, async () => {
+        const config = await getConfig()
+        const postsCollection = config.collections.onDemand.posts
+
+        // Sort by userId ascending, viewCount descending
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ post: postsCollection })
+            .orderBy(({ post }) => post.userId, `asc`)
+            .orderBy(({ post }) => post.viewCount, `desc`)
+            .limit(20),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 20 })
+
+        const results = Array.from(query.state.values())
+        expect(results).toHaveLength(20)
+
+        // Verify ordering
+        for (let i = 1; i < results.length; i++) {
+          const prev = results[i - 1]!
+          const curr = results[i]!
+
+          if (prev.userId < curr.userId) {
+            // userId ascending - this is correct
+            continue
+          } else if (prev.userId === curr.userId) {
+            // Same userId, viewCount should be descending
+            expect(prev.viewCount).toBeGreaterThanOrEqual(curr.viewCount)
+          } else {
+            // userId decreased - this is wrong
+            throw new Error(
+              `userId should be ascending but ${prev.userId} > ${curr.userId}`,
+            )
+          }
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should handle three-column orderBy`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Sort by isActive desc, age asc, name asc
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.isActive, `desc`)
+            .orderBy(({ user }) => user.age, `asc`)
+            .orderBy(({ user }) => user.name, `asc`)
+            .limit(25),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 25 })
+
+        const results = Array.from(query.state.values())
+        expect(results).toHaveLength(25)
+
+        // Verify basic ordering (isActive desc, age asc)
+        for (let i = 1; i < results.length; i++) {
+          const prev = results[i - 1]!
+          const curr = results[i]!
+
+          if (prev.isActive !== curr.isActive) {
+            expect(prev.isActive ? 1 : 0).toBeGreaterThanOrEqual(
+              curr.isActive ? 1 : 0,
+            )
+          } else if (prev.age !== curr.age) {
+            expect(prev.age).toBeLessThanOrEqual(curr.age)
+          }
+          // For name, we don't strictly check due to collation differences
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should use setWindow to page through multi-column orderBy results`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Create query with multi-column orderBy and limit
+        // Using age (number) and name (string) to avoid boolean comparison issues
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.age, `asc`)
+            .orderBy(({ user }) => user.name, `asc`)
+            .limit(10),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 10 })
+
+        // Get first page
+        const firstPage = Array.from(query.state.values())
+        expect(firstPage).toHaveLength(10)
+
+        // Verify first page ordering (age asc, then name asc)
+        for (let i = 1; i < firstPage.length; i++) {
+          const prev = firstPage[i - 1]!
+          const curr = firstPage[i]!
+          if (prev.age !== curr.age) {
+            expect(prev.age).toBeLessThanOrEqual(curr.age)
+          } else {
+            expect(prev.name.localeCompare(curr.name)).toBeLessThanOrEqual(0)
+          }
+        }
+
+        // Move to second page using setWindow
+        // IMPORTANT: setWindow returns a Promise when loading is required,
+        // or `true` if data is already available. We verify loading occurs.
+        const setWindowResult = query.utils.setWindow({ offset: 10, limit: 10 })
+
+        // In on-demand mode, moving to offset 10 should trigger loading
+        // since only the first 10 records were initially loaded
+        if (setWindowResult !== true) {
+          // Loading was triggered - wait for it to complete
+          await setWindowResult
+        }
+        await waitForQueryData(query, { minSize: 10 })
+
+        // Get second page
+        const secondPage = Array.from(query.state.values())
+        expect(secondPage).toHaveLength(10)
+
+        // Verify second page ordering
+        for (let i = 1; i < secondPage.length; i++) {
+          const prev = secondPage[i - 1]!
+          const curr = secondPage[i]!
+          if (prev.age !== curr.age) {
+            expect(prev.age).toBeLessThanOrEqual(curr.age)
+          } else {
+            expect(prev.name.localeCompare(curr.name)).toBeLessThanOrEqual(0)
+          }
+        }
+
+        // CRITICAL: Pages should not overlap - this proves new data was loaded
+        // If the backend didn't return new data, we'd see duplicates or missing records
+        const firstPageIds = new Set(firstPage.map((u) => u.id))
+        const secondPageIds = new Set(secondPage.map((u) => u.id))
+        for (const id of secondPageIds) {
+          expect(firstPageIds.has(id)).toBe(false)
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should use setWindow to move backwards with multi-column orderBy`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Start at offset 20
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.age, `asc`)
+            .orderBy(({ user }) => user.name, `asc`)
+            .limit(10)
+            .offset(20),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 10 })
+
+        const laterPage = Array.from(query.state.values())
+        expect(laterPage).toHaveLength(10)
+
+        // Move backwards to offset 10
+        const setWindowResult = query.utils.setWindow({ offset: 10, limit: 10 })
+        if (setWindowResult !== true) {
+          await setWindowResult
+        }
+        await waitForQueryData(query, { minSize: 10 })
+
+        const earlierPage = Array.from(query.state.values())
+        expect(earlierPage).toHaveLength(10)
+
+        // Earlier page should have different users
+        const laterPageIds = new Set(laterPage.map((u) => u.id))
+        const earlierPageIds = new Set(earlierPage.map((u) => u.id))
+        for (const id of earlierPageIds) {
+          expect(laterPageIds.has(id)).toBe(false)
+        }
+
+        // Verify ordering on earlier page (age asc, name asc)
+        for (let i = 1; i < earlierPage.length; i++) {
+          const prev = earlierPage[i - 1]!
+          const curr = earlierPage[i]!
+          if (prev.age !== curr.age) {
+            expect(prev.age).toBeLessThanOrEqual(curr.age)
+          } else {
+            expect(prev.name.localeCompare(curr.name)).toBeLessThanOrEqual(0)
+          }
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should use setWindow with mixed direction multi-column orderBy`, async () => {
+        const config = await getConfig()
+        const postsCollection = config.collections.onDemand.posts
+
+        // Sort by userId ascending, viewCount descending
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ post: postsCollection })
+            .orderBy(({ post }) => post.userId, `asc`)
+            .orderBy(({ post }) => post.viewCount, `desc`)
+            .limit(10),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 10 })
+
+        const firstPage = Array.from(query.state.values())
+        expect(firstPage).toHaveLength(10)
+
+        // Move to second page
+        const setWindowResult = query.utils.setWindow({ offset: 10, limit: 10 })
+        if (setWindowResult !== true) {
+          await setWindowResult
+        }
+        await waitForQueryData(query, { minSize: 10 })
+
+        const secondPage = Array.from(query.state.values())
+        expect(secondPage).toHaveLength(10)
+
+        // Verify ordering on second page (userId asc, viewCount desc)
+        for (let i = 1; i < secondPage.length; i++) {
+          const prev = secondPage[i - 1]!
+          const curr = secondPage[i]!
+
+          if (prev.userId < curr.userId) {
+            // userId ascending - correct
+            continue
+          } else if (prev.userId === curr.userId) {
+            // Same userId, viewCount should be descending
+            expect(prev.viewCount).toBeGreaterThanOrEqual(curr.viewCount)
+          } else {
+            throw new Error(
+              `userId should be ascending but ${prev.userId} > ${curr.userId}`,
+            )
+          }
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should handle setWindow across duplicate first-column values`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Age has limited unique values in test data, so many duplicates in first column
+        // This tests that the composite cursor correctly handles paging across duplicates
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.age, `asc`)
+            .orderBy(({ user }) => user.name, `asc`)
+            .limit(20),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 20 })
+
+        const firstPage = Array.from(query.state.values())
+        expect(firstPage).toHaveLength(20)
+
+        // Move to second page - this crosses the boundary where first column value changes
+        const setWindowResult = query.utils.setWindow({ offset: 20, limit: 20 })
+        if (setWindowResult !== true) {
+          await setWindowResult
+        }
+        await waitForQueryData(query, { minSize: 20 })
+
+        const secondPage = Array.from(query.state.values())
+        expect(secondPage).toHaveLength(20)
+
+        // Verify ordering is maintained across the page boundary
+        for (let i = 1; i < secondPage.length; i++) {
+          const prev = secondPage[i - 1]!
+          const curr = secondPage[i]!
+          if (prev.age !== curr.age) {
+            expect(prev.age).toBeLessThanOrEqual(curr.age)
+          } else {
+            expect(prev.name.localeCompare(curr.name)).toBeLessThanOrEqual(0)
+          }
+        }
+
+        // Pages should not overlap
+        const firstPageIds = new Set(firstPage.map((u) => u.id))
+        for (const user of secondPage) {
+          expect(firstPageIds.has(user.id)).toBe(false)
+        }
+
+        // Move to third page to ensure continued paging works
+        const setWindowResult2 = query.utils.setWindow({
+          offset: 40,
+          limit: 20,
+        })
+        if (setWindowResult2 !== true) {
+          await setWindowResult2
+        }
+        await waitForQueryData(query, { minSize: 1 })
+
+        const thirdPage = Array.from(query.state.values())
+        expect(thirdPage.length).toBeGreaterThan(0)
+        expect(thirdPage.length).toBeLessThanOrEqual(20)
+
+        // Third page should not overlap with first or second
+        const secondPageIds = new Set(secondPage.map((u) => u.id))
+        for (const user of thirdPage) {
+          expect(firstPageIds.has(user.id)).toBe(false)
+          expect(secondPageIds.has(user.id)).toBe(false)
+        }
+
+        await query.cleanup()
+      })
+
+      it(`should trigger backend loading when paging with multi-column orderBy`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Use a small limit to ensure we need to load more data when paging
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.age, `asc`)
+            .orderBy(({ user }) => user.name, `asc`)
+            .limit(5),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 5 })
+
+        // Get first page - only 5 records loaded
+        const firstPage = Array.from(query.state.values())
+        expect(firstPage).toHaveLength(5)
+        const lastItemFirstPage = firstPage[firstPage.length - 1]!
+
+        // Move to second page - this MUST trigger backend loading
+        // since we only have 5 records and need records at offset 5
+        const setWindowResult = query.utils.setWindow({ offset: 5, limit: 5 })
+
+        // CRITICAL ASSERTION: In on-demand mode, setWindow should return a Promise
+        // when we need to load data we don't have yet. This proves loading was triggered.
+        // If it returned `true`, it would mean data was already available (no loading needed).
+        expect(
+          setWindowResult === true || setWindowResult instanceof Promise,
+        ).toBe(true)
+
+        if (setWindowResult !== true) {
+          // Wait for loading to complete
+          await setWindowResult
+        }
+        await waitForQueryData(query, { minSize: 5 })
+
+        // Get second page
+        const secondPage = Array.from(query.state.values())
+        expect(secondPage).toHaveLength(5)
+
+        // Verify we got different records (proves new data was loaded from backend)
+        const firstPageIds = new Set(firstPage.map((u) => u.id))
+        for (const user of secondPage) {
+          expect(firstPageIds.has(user.id)).toBe(false)
+        }
+
+        // Verify ordering continues correctly from where first page ended
+        const firstItemSecondPage = secondPage[0]!
+
+        // The first item of page 2 should come after the last item of page 1
+        // in the sort order (age asc, name asc)
+        if (lastItemFirstPage.age === firstItemSecondPage.age) {
+          // Same age value, so name should be greater or equal
+          expect(
+            firstItemSecondPage.name.localeCompare(lastItemFirstPage.name),
+          ).toBeGreaterThanOrEqual(0)
+        } else {
+          // Different age, page 2 first should have greater or equal age
+          expect(firstItemSecondPage.age).toBeGreaterThanOrEqual(
+            lastItemFirstPage.age,
+          )
+        }
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Limit`, () => {
+      it(`should limit to specific number of records`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(10),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 10 })
+
+        assertCollectionSize(query, 10)
+
+        await query.cleanup()
+      })
+
+      it(`should handle limit=0`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(0),
+        )
+
+        await query.preload()
+
+        assertCollectionSize(query, 0)
+
+        await query.cleanup()
+      })
+
+      it(`should handle limit larger than dataset`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(1000),
+        )
+
+        await query.preload()
+
+        // Should return all records (100 from seed data)
+        expect(query.size).toBeLessThanOrEqual(100)
+
+        await query.cleanup()
+      })
+
+      it(`should combine limit with orderBy`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.age, `asc`)
+            .limit(5),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 5 })
+
+        assertCollectionSize(query, 5)
+        const results = Array.from(query.state.values())
+        assertSorted(results, `age`, `asc`)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Offset`, () => {
+      it(`should skip records with offset`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(100) // Need limit with offset
+            .offset(20),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 80 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBe(80) // 100 - 20 = 80
+
+        await query.cleanup()
+      })
+
+      it(`should combine offset with limit (pagination)`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(10)
+            .offset(20),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 10 })
+
+        assertCollectionSize(query, 10)
+
+        await query.cleanup()
+      })
+
+      it(`should handle offset beyond dataset`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(100)
+            .offset(200),
+        )
+
+        await query.preload()
+
+        assertCollectionSize(query, 0)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Complex Pagination Scenarios`, () => {
+      it(`should paginate with predicates`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.isActive, true))
+            .orderBy(({ user }) => user.age, `asc`)
+            .limit(10)
+            .offset(5),
+        )
+
+        await query.preload()
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeLessThanOrEqual(10)
+        assertAllItemsMatch(query, (u) => u.isActive === true)
+        assertSorted(results, `age`, `asc`)
+
+        await query.cleanup()
+      })
+
+      it(`should handle pagination edge cases - last page with fewer records`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection(
+          (q) =>
+            q
+              .from({ user: usersCollection })
+              .orderBy(({ user }) => user.id, `asc`)
+              .limit(10)
+              .offset(95), // Last 5 records
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        expect(query.size).toBeLessThanOrEqual(10)
+        expect(query.size).toBeGreaterThan(0)
+
+        await query.cleanup()
+      })
+
+      it(`should handle single record pages`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(1)
+            .offset(0),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        assertCollectionSize(query, 1)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Performance Verification`, () => {
+      it(`should only load requested page (not entire dataset)`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .orderBy(({ user }) => user.id, `asc`)
+            .limit(10)
+            .offset(20),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 10 })
+
+        // Verify we got exactly 10 records
+        assertCollectionSize(query, 10)
+
+        // In on-demand mode, the underlying collection should ideally only load
+        // the requested page, not all 100 records
+        // (This depends on Electric's predicate pushdown implementation)
+
+        await query.cleanup()
+      })
+    })
+  })
+}
diff --git a/packages/db-collection-e2e/src/suites/predicates.suite.ts b/packages/db-collection-e2e/src/suites/predicates.suite.ts
new file mode 100644
index 000000000..0ea3a9947
--- /dev/null
+++ b/packages/db-collection-e2e/src/suites/predicates.suite.ts
@@ -0,0 +1,953 @@
+/**
+ * Predicates Test Suite
+ *
+ * Tests basic where clause functionality with all comparison operators
+ * across different data types.
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  and,
+  createLiveQueryCollection,
+  eq,
+  gt,
+  gte,
+  ilike,
+  inArray,
+  isNull,
+  like,
+  lower,
+  lt,
+  lte,
+  not,
+  or,
+} from '@tanstack/db'
+import { assertAllItemsMatch, assertCollectionSize } from '../utils/assertions'
+import { waitForQueryData } from '../utils/helpers'
+import type { E2ETestConfig } from '../types'
+
+export function createPredicatesTestSuite(
+  getConfig: () => Promise<E2ETestConfig>,
+) {
+  describe(`Predicates Suite`, () => {
+    describe(`Equality Operators`, () => {
+      it(`should filter with eq() on string field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.name, `Alice 0`)),
+        )
+
+        await query.preload()
+
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        expect(results.every((u) => u.name === `Alice 0`)).toBe(true)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with eq() on number field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.age, 25)),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (u) => u.age === 25)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with eq() on boolean field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.isActive, true)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertAllItemsMatch(query, (u) => u.isActive === true)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with eq() on UUID field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const testUserId = `00000000-0000-4000-8000-000000000000` // User ID for index 0
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.id, testUserId)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        assertCollectionSize(query, 1)
+        const result = Array.from(query.state.values())[0]
+        expect(result?.id).toBe(testUserId)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with isNull() for null values`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => isNull(user.email)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertAllItemsMatch(query, (u) => u.email === null)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Inequality Operators`, () => {
+      it(`should filter with not(eq()) on string field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => not(eq(user.name, `Alice 0`))),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertAllItemsMatch(query, (u) => u.name !== `Alice 0`)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with not(isNull()) for non-null values`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => not(isNull(user.email))),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertAllItemsMatch(query, (u) => u.email !== null)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Comparison Operators`, () => {
+      it(`should filter with gt() on number field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 50)),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (u) => u.age > 50)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with gte() on number field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gte(user.age, 50)),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (u) => u.age >= 50)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with lt() on number field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => lt(user.age, 30)),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (u) => u.age < 30)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with lte() on number field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => lte(user.age, 30)),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (u) => u.age <= 30)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with gt() on viewCount field`, async () => {
+        const config = await getConfig()
+        const postsCollection = config.collections.onDemand.posts
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ post: postsCollection })
+            .where(({ post }) => gt(post.viewCount, 100)),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (p) => p.viewCount > 100)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with eq() on BIGINT field using JavaScript BigInt`, async () => {
+        const config = await getConfig()
+        const postsCollection = config.collections.onDemand.posts
+
+        // Target the first post which has largeViewCount = 9007199254740992n (MAX_SAFE_INTEGER + 1)
+        const targetBigInt = BigInt(`9007199254740992`)
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ post: postsCollection })
+            .where(({ post }) => eq(post.largeViewCount, targetBigInt)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBe(1)
+        // Post 0 has largeViewCount = 9007199254740992n
+        // Database may return as bigint or string depending on driver
+        assertAllItemsMatch(query, (p) => {
+          const value = String(p.largeViewCount)
+          return value === targetBigInt.toString()
+        })
+
+        await query.cleanup()
+      })
+
+      it(`should filter with gt() on BIGINT field using JavaScript BigInt`, async () => {
+        const config = await getConfig()
+        const postsCollection = config.collections.onDemand.posts
+
+        // Filter for posts with largeViewCount > 9007199254740995
+        // This should match posts 4-9 (indices 4,5,6,7,8,9 have values 9007199254740996-9007199254741001)
+        const thresholdBigInt = BigInt(`9007199254740995`)
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ post: postsCollection })
+            .where(({ post }) => gt(post.largeViewCount, thresholdBigInt)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        // All results should have largeViewCount > threshold
+        assertAllItemsMatch(query, (p) => {
+          const value =
+            typeof p.largeViewCount === `bigint`
+              ? p.largeViewCount
+              : BigInt(p.largeViewCount)
+          return value > thresholdBigInt
+        })
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`String Pattern Matching Operators`, () => {
+      it(`should filter with like() operator (case-sensitive)`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => like(user.name, `Alice%`)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        // Should match names starting with "Alice" (case-sensitive)
+        assertAllItemsMatch(query, (u) => u.name.startsWith(`Alice`))
+
+        await query.cleanup()
+      })
+
+      it(`should filter with ilike() operator (case-insensitive)`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => ilike(user.name, `alice%`)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        // Should match names starting with "Alice" (case-insensitive)
+        assertAllItemsMatch(query, (u) =>
+          u.name.toLowerCase().startsWith(`alice`),
+        )
+
+        await query.cleanup()
+      })
+
+      it(`should filter with like() with wildcard pattern (% at end)`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => like(user.email, `%@example.com`)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        // Should match emails ending with @example.com
+        assertAllItemsMatch(
+          query,
+          (u) => u.email?.endsWith(`@example.com`) ?? false,
+        )
+
+        await query.cleanup()
+      })
+
+      it(`should filter with like() with wildcard pattern (% in middle)`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => like(user.email, `user%0@example.com`)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        // Should match emails like user0@example.com, user10@example.com, user20@example.com, etc.
+        assertAllItemsMatch(
+          query,
+          (u) => (u.email?.match(/^user.*0@example\.com$/) ?? null) !== null,
+        )
+
+        await query.cleanup()
+      })
+
+      it(`should filter with like() with lower() function`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => like(lower(user.name), `%alice%`)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        // Should match names containing "alice" (case-insensitive via lower())
+        assertAllItemsMatch(query, (u) =>
+          u.name.toLowerCase().includes(`alice`),
+        )
+
+        await query.cleanup()
+      })
+
+      it(`should filter with ilike() with lower() function`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => ilike(lower(user.name), `%bob%`)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        // Should match names containing "bob" (case-insensitive)
+        assertAllItemsMatch(query, (u) => u.name.toLowerCase().includes(`bob`))
+
+        await query.cleanup()
+      })
+
+      it(`should filter with or() combining multiple like() conditions (search pattern)`, async () => {
+        const config = await getConfig()
+        const postsCollection = config.collections.onDemand.posts
+
+        // This mimics the user's exact query pattern with multiple fields
+        // User's pattern: like(lower(offers.title), `%${searchLower}%`) OR like(lower(offers.human_id), `%${searchLower}%`)
+        const searchTerm = `Introduction`
+        const searchLower = searchTerm.toLowerCase()
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ post: postsCollection })
+            .where(({ post }) =>
+              or(
+                like(lower(post.title), `%${searchLower}%`),
+                like(lower(post.content ?? ``), `%${searchLower}%`),
+              ),
+            ),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        // Should match posts with title or content containing "introduction" (case-insensitive)
+        assertAllItemsMatch(
+          query,
+          (p) =>
+            p.title.toLowerCase().includes(searchLower) ||
+            (p.content?.toLowerCase().includes(searchLower) ?? false),
+        )
+
+        await query.cleanup()
+      })
+
+      it(`should filter with like() and orderBy`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => like(lower(user.name), `%alice%`))
+            .orderBy(({ user }) => user.name, `asc`),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertAllItemsMatch(query, (u) =>
+          u.name.toLowerCase().includes(`alice`),
+        )
+
+        // Verify ordering
+        const names = results.map((u) => u.name)
+        const sortedNames = [...names].sort((a, b) => a.localeCompare(b))
+        expect(names).toEqual(sortedNames)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with like() and limit`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => like(lower(user.name), `%alice%`))
+            .orderBy(({ user }) => user.name, `asc`) // Required when using LIMIT
+            .limit(5),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        // Should respect limit
+        expect(results.length).toBeLessThanOrEqual(5)
+        assertAllItemsMatch(query, (u) =>
+          u.name.toLowerCase().includes(`alice`),
+        )
+
+        await query.cleanup()
+      })
+
+      it(`should handle like() with pattern matching no records`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => like(user.name, `NonExistent%`)),
+        )
+
+        await query.preload()
+
+        assertCollectionSize(query, 0)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`In Operator`, () => {
+      it(`should filter with inArray() on string array`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) =>
+              inArray(user.name, [`Alice 0`, `bob 1`, `Charlie 2`]),
+            ),
+        )
+
+        await query.preload()
+
+        const validNames = new Set([`Alice 0`, `bob 1`, `Charlie 2`])
+        assertAllItemsMatch(query, (u) => validNames.has(u.name))
+
+        await query.cleanup()
+      })
+
+      it(`should filter with inArray() on number array`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => inArray(user.age, [25, 30, 35])),
+        )
+
+        await query.preload()
+
+        const validAges = new Set([25, 30, 35])
+        assertAllItemsMatch(query, (u) => validAges.has(u.age))
+
+        await query.cleanup()
+      })
+
+      it(`should filter with inArray() on UUID array`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const userIds = [
+          `00000000-0000-4000-8000-000000000000`, // User ID for index 0
+          `00000001-0000-4000-8000-000000000001`, // User ID for index 1
+          `00000002-0000-4000-8000-000000000002`, // User ID for index 2
+        ]
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => inArray(user.id, userIds)),
+        )
+
+        await query.preload()
+
+        const validIds = new Set(userIds)
+        assertAllItemsMatch(query, (u) => validIds.has(u.id))
+
+        await query.cleanup()
+      })
+
+      it(`should handle empty inArray()`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => inArray(user.id, [])),
+        )
+
+        await query.preload()
+
+        assertCollectionSize(query, 0)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with inArray() on BIGINT array using JavaScript BigInt`, async () => {
+        const config = await getConfig()
+        const postsCollection = config.collections.onDemand.posts
+
+        // Target posts 0 and 1 which have largeViewCount values:
+        // Post 0: 9007199254740992n, Post 1: 9007199254740993n
+        const targetBigInts = [
+          BigInt(`9007199254740992`),
+          BigInt(`9007199254740993`),
+        ]
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ post: postsCollection })
+            .where(({ post }) => inArray(post.largeViewCount, targetBigInts)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 2 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBe(2)
+
+        // Verify both matching posts are returned
+        const targetStrings = targetBigInts.map((b) => b.toString())
+        assertAllItemsMatch(query, (p) => {
+          const value =
+            typeof p.largeViewCount === `bigint`
+              ? p.largeViewCount.toString()
+              : String(p.largeViewCount)
+          return targetStrings.includes(value)
+        })
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Null Operators`, () => {
+      it(`should filter with isNull() on nullable field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => isNull(user.email)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertAllItemsMatch(query, (u) => u.email === null)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with not(isNull()) on nullable field`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => not(isNull(user.email))),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertAllItemsMatch(query, (u) => u.email !== null)
+
+        await query.cleanup()
+      })
+
+      it(`should filter with isNull() on deletedAt (soft delete pattern)`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => isNull(user.deletedAt)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertAllItemsMatch(query, (u) => u.deletedAt === null)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Boolean Logic`, () => {
+      it(`should combine predicates with and()`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) =>
+              and(gt(user.age, 25), eq(user.isActive, true)),
+            ),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (u) => u.age > 25 && u.isActive === true)
+
+        await query.cleanup()
+      })
+
+      it(`should combine predicates with or()`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => or(eq(user.age, 25), eq(user.age, 30))),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (u) => u.age === 25 || u.age === 30)
+
+        await query.cleanup()
+      })
+
+      it(`should handle complex nested logic`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) =>
+              and(
+                or(eq(user.age, 25), eq(user.age, 30)),
+                eq(user.isActive, true),
+              ),
+            ),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(
+          query,
+          (u) => (u.age === 25 || u.age === 30) && u.isActive === true,
+        )
+
+        await query.cleanup()
+      })
+
+      it(`should handle NOT operator`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => not(eq(user.isActive, true))),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (u) => u.isActive !== true)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Predicate Pushdown Verification`, () => {
+      it(`should only load data matching predicate (no over-fetching)`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.age, 25)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        // Verify that the underlying collection didn't load ALL users
+        // In on-demand mode, it should only load age=25 users
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        expect(results.length).toBeLessThan(100) // Shouldn't load all 100 users
+
+        await query.cleanup()
+      })
+
+      it(`should not load deleted records when filtering them out`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => isNull(user.deletedAt)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        assertAllItemsMatch(query, (u) => u.deletedAt === null)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Multiple where() Calls`, () => {
+      it(`should AND multiple where() calls together`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => gt(user.age, 25))
+            .where(({ user }) => eq(user.isActive, true)),
+        )
+
+        await query.preload()
+
+        assertAllItemsMatch(query, (u) => u.age > 25 && u.isActive === true)
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Edge Cases`, () => {
+      it(`should handle query with no where clause on on-demand collection`, async () => {
+        // NOTE: Electric has a bug where empty subset requests don't load data
+        // We work around this by injecting "true = true" when there's no where clause
+        // This is always true so doesn't filter data, just tricks Electric into loading
+
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Query with NO where clause - loads all data
+        const query = createLiveQueryCollection(
+          (q) => q.from({ user: usersCollection }),
+          // No where, no limit, no orderBy
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 50 })
+
+        // Should load significant data (true = true workaround for Electric)
+        expect(query.size).toBeGreaterThan(0)
+        expect(query.size).toBe(usersCollection.size) // Query shows all collection data
+
+        await query.cleanup()
+      })
+
+      it(`should handle predicate matching no records`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => eq(user.age, 999)),
+        )
+
+        await query.preload()
+
+        assertCollectionSize(query, 0)
+
+        await query.cleanup()
+      })
+
+      it(`should handle complex AND with no matches`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection }).where(({ user }) =>
+            and(
+              eq(user.age, 25),
+              eq(user.age, 30), // Impossible: age can't be both 25 and 30
+            ),
+          ),
+        )
+
+        await query.preload()
+
+        assertCollectionSize(query, 0)
+
+        await query.cleanup()
+      })
+    })
+  })
+}
diff --git a/packages/db-collection-e2e/src/suites/progressive.suite.ts b/packages/db-collection-e2e/src/suites/progressive.suite.ts
new file mode 100644
index 000000000..dcfa31cfc
--- /dev/null
+++ b/packages/db-collection-e2e/src/suites/progressive.suite.ts
@@ -0,0 +1,580 @@
+/**
+ * Progressive Mode Test Suite
+ *
+ * Tests progressive sync mode behavior including:
+ * - Snapshot loading during initial sync
+ * - Atomic swap on first up-to-date
+ * - Incremental updates after swap
+ * - Txid tracking behavior
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createLiveQueryCollection, eq, gt } from '@tanstack/db'
+import { waitFor, waitForQueryData } from '../utils/helpers'
+import type { E2ETestConfig, User } from '../types'
+import type { Collection } from '@tanstack/db'
+import type { ElectricCollectionUtils } from '@tanstack/electric-db-collection'
+
+export function createProgressiveTestSuite(
+  getConfig: () => Promise<E2ETestConfig>,
+) {
+  describe(`Progressive Mode Suite`, () => {
+    describe(`Basic Progressive Mode`, () => {
+      it(`should explicitly validate snapshot phase and atomic swap transition`, async () => {
+        const config = await getConfig()
+        if (!config.collections.progressive || !config.progressiveTestControl) {
+          return // Skip if progressive collections or test control not available
+        }
+        const progressiveUsers = config.collections.progressive.users
+
+        // Start sync for this test
+        progressiveUsers.startSyncImmediate()
+
+        // === PHASE 1: SNAPSHOT PHASE ===
+        // Collection might already be ready from a previous test
+        // (progressive collections are shared and not cleaned up between tests)
+        await new Promise((resolve) => setTimeout(resolve, 50))
+
+        const initialStatus = progressiveUsers.status
+
+        // If already ready, we can't test the explicit transition
+        if (initialStatus === `ready`) {
+          console.log(
+            `Progressive collection already ready, skipping explicit transition test`,
+          )
+          return
+        }
+
+        // Should be loading or idle (hook prevents marking ready)
+        expect([`idle`, `loading`]).toContain(initialStatus)
+
+        // Create a query - this triggers fetchSnapshot
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: progressiveUsers })
+            .where(({ user }) => eq(user.age, 25)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1, timeout: 10000 })
+
+        // Validate snapshot data
+        const snapshotQuerySize = query.size
+        const snapshotItems = Array.from(query.values())
+
+        expect(snapshotQuerySize).toBeGreaterThan(0)
+        snapshotItems.forEach((user) => {
+          expect(user.age).toBe(25)
+          expect(user.id).toBeDefined()
+          expect(user.name).toBeDefined()
+        })
+
+        // Collection should STILL be loading (paused before atomic swap)
+        expect(progressiveUsers.status).toBe(`loading`)
+
+        // Collection has snapshot data
+        const snapshotCollectionSize = progressiveUsers.size
+        expect(snapshotCollectionSize).toBeGreaterThan(0)
+
+        // === PHASE 2: TRIGGER ATOMIC SWAP ===
+        config.progressiveTestControl.releaseInitialSync()
+
+        // === PHASE 3: POST-SWAP (FULLY SYNCED) ===
+        // Wait for ready (atomic swap complete)
+        await waitFor(() => progressiveUsers.status === `ready`, {
+          timeout: 30000,
+          message: `Progressive collection did not complete sync`,
+        })
+
+        // Collection now has full dataset (more than just snapshot)
+        const finalCollectionSize = progressiveUsers.size
+        expect(finalCollectionSize).toBeGreaterThan(snapshotQuerySize)
+
+        // Query still works with consistent data
+        const finalQueryItems = Array.from(query.values())
+        finalQueryItems.forEach((user) => {
+          expect(user.age).toBe(25) // Still matches predicate
+          expect(user.id).toBeDefined()
+        })
+
+        // Verify original snapshot items are still present after swap
+        snapshotItems.forEach((originalUser) => {
+          const foundInCollection = progressiveUsers.get(originalUser.id)
+          expect(foundInCollection).toBeDefined()
+          expect(foundInCollection?.age).toBe(25)
+        })
+
+        await query.cleanup()
+      })
+
+      it(`should load snapshots during initial sync and perform atomic swap`, async () => {
+        const config = await getConfig()
+        if (!config.collections.progressive) {
+          return // Skip if progressive collections not available
+        }
+        const progressiveUsers = config.collections.progressive.users
+
+        // Start sync for this test
+        progressiveUsers.startSyncImmediate()
+
+        // Query a subset (triggers snapshot fetch)
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: progressiveUsers })
+            .where(({ user }) => eq(user.age, 25)),
+        )
+
+        await query.preload()
+
+        // Wait for query to have snapshot data
+        await waitForQueryData(query, { minSize: 1, timeout: 10000 })
+
+        // Collection should still be loading if test control is active
+        const wasStillLoading = progressiveUsers.status === `loading`
+
+        // Release the initial sync to allow atomic swap
+        if (config.progressiveTestControl) {
+          config.progressiveTestControl.releaseInitialSync()
+        }
+
+        const beforeSwapSize = query.size
+        const beforeSwapItems = Array.from(query.values())
+
+        // Verify all items match the predicate
+        beforeSwapItems.forEach((user) => {
+          expect(user.age).toBe(25)
+          expect(user.id).toBeDefined()
+          expect(user.name).toBeDefined()
+        })
+
+        if (wasStillLoading) {
+          // If we caught it during snapshot phase, wait for atomic swap
+          await waitFor(() => progressiveUsers.status === `ready`, {
+            timeout: 30000,
+            message: `Progressive collection did not complete sync`,
+          })
+
+          // After atomic swap, verify data is consistent
+          // The query should have the same data (from full sync)
+          const afterSwapItems = Array.from(query.values())
+          expect(afterSwapItems.length).toBeGreaterThanOrEqual(beforeSwapSize)
+
+          // All original items should still be present
+          beforeSwapItems.forEach((originalUser) => {
+            const stillPresent = afterSwapItems.some(
+              (u) => u.id === originalUser.id,
+            )
+            expect(stillPresent).toBe(true)
+          })
+        } else {
+          // Already ready - verify final state is correct
+          expect(progressiveUsers.status).toBe(`ready`)
+        }
+
+        // Final validation: all items still match predicate
+        Array.from(query.values()).forEach((user) => {
+          expect(user.age).toBe(25)
+        })
+
+        await query.cleanup()
+      })
+
+      it(`should handle multiple snapshots with different predicates`, async () => {
+        const config = await getConfig()
+        if (!config.collections.progressive) {
+          return // Skip if progressive collections not available
+        }
+        const progressiveUsers = config.collections.progressive.users
+
+        // Start sync for this test
+        progressiveUsers.startSyncImmediate()
+
+        // Create multiple queries with different predicates
+        const query1 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: progressiveUsers })
+            .where(({ user }) => eq(user.age, 25)),
+        )
+
+        const query2 = createLiveQueryCollection((q) =>
+          q
+            .from({ user: progressiveUsers })
+            .where(({ user }) => gt(user.age, 30)),
+        )
+
+        await Promise.all([query1.preload(), query2.preload()])
+
+        // Wait for both to load snapshots
+        await Promise.all([
+          waitForQueryData(query1, { minSize: 1, timeout: 10000 }),
+          waitForQueryData(query2, { minSize: 1, timeout: 10000 }),
+        ])
+
+        // Release initial sync to allow atomic swap
+        if (config.progressiveTestControl) {
+          config.progressiveTestControl.releaseInitialSync()
+        }
+
+        expect(query1.size).toBeGreaterThan(0)
+        expect(query2.size).toBeGreaterThan(0)
+
+        // Verify data correctness
+        const query1Snapshot = Array.from(query1.values())
+        const query2Snapshot = Array.from(query2.values())
+
+        query1Snapshot.forEach((user) => {
+          expect(user.age).toBe(25)
+        })
+        query2Snapshot.forEach((user) => {
+          expect(user.age).toBeGreaterThan(30)
+        })
+
+        // Wait for full sync
+        await waitFor(() => progressiveUsers.status === `ready`, {
+          timeout: 30000,
+          message: `Progressive collection did not complete sync`,
+        })
+
+        // Both queries should still have data after swap with same predicates
+        expect(query1.size).toBeGreaterThan(0)
+        expect(query2.size).toBeGreaterThan(0)
+
+        // Verify predicates still match after swap
+        Array.from(query1.values()).forEach((user) => {
+          expect(user.age).toBe(25)
+        })
+        Array.from(query2.values()).forEach((user) => {
+          expect(user.age).toBeGreaterThan(30)
+        })
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
+      })
+    })
+
+    describe(`Incremental Updates After Swap`, () => {
+      it(`should receive incremental updates after atomic swap`, async () => {
+        const config = await getConfig()
+        if (!config.collections.progressive || !config.mutations?.insertUser) {
+          return // Skip if progressive collections or mutations not available
+        }
+        const progressiveUsers = config.collections.progressive.users
+
+        // Release initial sync immediately (we don't care about snapshot phase for this test)
+        if (config.progressiveTestControl) {
+          config.progressiveTestControl.releaseInitialSync()
+        }
+
+        // Wait for full sync
+        await waitFor(() => progressiveUsers.status === `ready`, {
+          timeout: 30000,
+          message: `Progressive collection did not complete sync`,
+        })
+
+        const initialSize = progressiveUsers.size
+
+        // Insert new data
+        const newUser = {
+          id: crypto.randomUUID(),
+          name: `Progressive Test User`,
+          email: `progressive@test.com`,
+          age: 35,
+          isActive: true,
+          createdAt: new Date(),
+          metadata: null,
+          deletedAt: null,
+        }
+
+        await config.mutations.insertUser(newUser)
+
+        // Wait for incremental update
+        if (config.hasReplicationLag) {
+          await waitFor(() => progressiveUsers.size > initialSize, {
+            timeout: 10000,
+            message: `New user not synced via incremental update`,
+          })
+        }
+
+        expect(progressiveUsers.size).toBeGreaterThan(initialSize)
+
+        // Verify the new user is in the collection with correct data
+        const foundUser = progressiveUsers.get(newUser.id)
+        expect(foundUser).toBeDefined()
+        expect(foundUser?.id).toBe(newUser.id)
+        expect(foundUser?.name).toBe(newUser.name)
+        expect(foundUser?.email).toBe(newUser.email)
+        expect(foundUser?.age).toBe(newUser.age)
+      })
+    })
+
+    describe(`Predicate Handling`, () => {
+      it(`should correctly handle predicates during and after snapshot phase`, async () => {
+        const config = await getConfig()
+        if (!config.collections.progressive) {
+          return // Skip if progressive collections not available
+        }
+        const progressiveUsers = config.collections.progressive.users
+
+        // Create query with predicate during snapshot phase
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: progressiveUsers })
+            .where(({ user }) => gt(user.age, 25))
+            .orderBy(({ user }) => [user.age, `asc`])
+            .limit(5),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1, timeout: 10000 })
+
+        const snapshotPhaseSize = query.size
+
+        // Release initial sync to allow atomic swap
+        if (config.progressiveTestControl) {
+          config.progressiveTestControl.releaseInitialSync()
+        }
+
+        // Wait for atomic swap
+        await waitFor(() => progressiveUsers.status === `ready`, {
+          timeout: 30000,
+          message: `Progressive collection did not complete sync`,
+        })
+
+        // Verify predicate still works after swap
+        const afterSwapSize = query.size
+        const afterSwapItems = Array.from(query.values())
+
+        // Size should be reasonable (at least what we had in snapshot phase)
+        expect(afterSwapSize).toBeGreaterThanOrEqual(snapshotPhaseSize)
+
+        // All items should match the predicate
+        afterSwapItems.forEach((user) => {
+          expect(user.age).toBeGreaterThan(25)
+        })
+
+        // Should respect limit
+        expect(afterSwapSize).toBeLessThanOrEqual(5)
+
+        await query.cleanup()
+      })
+
+      it(`should deduplicate snapshot requests during snapshot phase`, async () => {
+        const config = await getConfig()
+        if (!config.collections.progressive) {
+          return // Skip if progressive collections not available
+        }
+        const progressiveUsers = config.collections.progressive.users
+
+        // Create multiple identical queries (should be deduplicated)
+        const queries = Array.from({ length: 3 }, () =>
+          createLiveQueryCollection((q) =>
+            q
+              .from({ user: progressiveUsers })
+              .where(({ user }) => eq(user.age, 30)),
+          ),
+        )
+
+        // Execute concurrently
+        await Promise.all(queries.map((q) => q.preload()))
+
+        // Wait for data
+        await Promise.all(
+          queries.map((q) =>
+            waitForQueryData(q, { minSize: 1, timeout: 10000 }),
+          ),
+        )
+
+        // Release initial sync to allow completion
+        if (config.progressiveTestControl) {
+          config.progressiveTestControl.releaseInitialSync()
+        }
+
+        // All should have the same size and same data
+        const sizes = queries.map((q) => q.size)
+        expect(new Set(sizes).size).toBe(1) // All sizes are identical
+
+        // Verify all queries have identical data (deduplication working)
+        const firstQueryData = Array.from(queries[0]!.values())
+        const firstQueryIds = new Set(firstQueryData.map((u) => u.id))
+
+        queries.forEach((query) => {
+          const queryData = Array.from(query.values())
+          queryData.forEach((user) => {
+            expect(user.age).toBe(30) // All match predicate
+            expect(firstQueryIds.has(user.id)).toBe(true) // Same items
+          })
+        })
+
+        await Promise.all(queries.map((q) => q.cleanup()))
+      })
+    })
+
+    describe(`Txid Tracking Behavior (Electric only)`, () => {
+      it(`should not track txids during snapshot phase but track them after atomic swap`, async () => {
+        const config = await getConfig()
+        if (
+          !config.collections.progressive ||
+          !config.mutations?.insertUser ||
+          !config.getTxid
+        ) {
+          return // Skip if progressive collections, mutations, or getTxid not available
+        }
+        const progressiveUsers = config.collections.progressive
+          .users as Collection<User, string, ElectricCollectionUtils>
+
+        // awaitTxId is guaranteed to exist on ElectricCollectionUtils
+        // This test is Electric-only via the describe block name
+
+        // Start sync but don't release yet (stay in snapshot phase)
+        progressiveUsers.startSyncImmediate()
+        await new Promise((resolve) => setTimeout(resolve, 100))
+
+        // Should be in loading state (snapshot phase)
+        if (progressiveUsers.status !== `loading`) {
+          console.log(
+            `Collection already ready, cannot test snapshot phase txid behavior`,
+          )
+          return
+        }
+
+        // === PHASE 1: INSERT DURING SNAPSHOT PHASE ===
+        const snapshotPhaseUser = {
+          id: crypto.randomUUID(),
+          name: `Snapshot Phase User`,
+          email: `snapshot@test.com`,
+          age: 28,
+          isActive: true,
+          createdAt: new Date(),
+          metadata: null,
+          deletedAt: null,
+        }
+
+        // Insert user and track when awaitTxId completes
+        let txidResolved = false
+
+        // Start the insert
+        await config.mutations.insertUser(snapshotPhaseUser)
+
+        // Get the txid from postgres
+        const txid = await config.getTxid()
+
+        if (!txid) {
+          console.log(`Could not get txid, skipping txid tracking validation`)
+          config.progressiveTestControl?.releaseInitialSync()
+          return
+        }
+
+        // Start awaiting the txid (should NOT resolve during snapshot phase)
+        progressiveUsers.utils.awaitTxId(txid, 60000).then(() => {
+          txidResolved = true
+        })
+
+        // Wait a moment for sync to process
+        await new Promise((resolve) => setTimeout(resolve, 500))
+
+        // Txid should NOT have resolved yet (snapshot phase, txids not tracked)
+        expect(txidResolved).toBe(false)
+
+        // Query for the user (triggers fetchSnapshot with this user)
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: progressiveUsers })
+            .where(({ user }) => eq(user.id, snapshotPhaseUser.id)),
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1, timeout: 10000 })
+
+        // User should be in snapshot data
+        expect(query.size).toBe(1)
+        expect(query.get(snapshotPhaseUser.id)).toBeDefined()
+
+        // But collection is still in snapshot phase
+        expect(progressiveUsers.status).toBe(`loading`)
+
+        // Txid should STILL not have resolved (snapshot doesn't track txids)
+        expect(txidResolved).toBe(false)
+
+        // === PHASE 2: TRIGGER ATOMIC SWAP ===
+        if (config.progressiveTestControl) {
+          config.progressiveTestControl.releaseInitialSync()
+        }
+
+        // Wait for atomic swap to complete
+        await waitFor(() => progressiveUsers.status === `ready`, {
+          timeout: 30000,
+          message: `Progressive collection did not complete sync`,
+        })
+
+        // NOW txid should resolve (buffered messages include txids)
+        await waitFor(() => txidResolved, {
+          timeout: 5000,
+          message: `Txid did not resolve after atomic swap`,
+        })
+
+        expect(txidResolved).toBe(true)
+
+        // === PHASE 3: VERIFY TXID TRACKING POST-SWAP ===
+        // User should still be present after atomic swap
+        expect(progressiveUsers.get(snapshotPhaseUser.id)).toBeDefined()
+
+        // Now insert another user and verify txid tracking works
+        const postSwapUser = {
+          id: crypto.randomUUID(),
+          name: `Post Swap User`,
+          email: `postswap@test.com`,
+          age: 29,
+          isActive: true,
+          createdAt: new Date(),
+          metadata: null,
+          deletedAt: null,
+        }
+
+        await config.mutations.insertUser(postSwapUser)
+
+        // Wait for incremental update (txid tracking should work now)
+        if (config.hasReplicationLag) {
+          await waitFor(() => progressiveUsers.has(postSwapUser.id), {
+            timeout: 10000,
+            message: `Post-swap user not synced via incremental update`,
+          })
+        }
+
+        // Both users should be present
+        expect(progressiveUsers.get(snapshotPhaseUser.id)).toBeDefined()
+        expect(progressiveUsers.get(postSwapUser.id)).toBeDefined()
+
+        await query.cleanup()
+      })
+    })
+
+    describe(`Progressive Mode Resilience`, () => {
+      it(`should handle cleanup and restart during snapshot phase`, async () => {
+        const config = await getConfig()
+        if (!config.collections.progressive) {
+          return // Skip if progressive collections not available
+        }
+        const progressiveUsers = config.collections.progressive.users
+
+        // This test verifies the collection can be cleaned up even during snapshot phase
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: progressiveUsers })
+            .where(({ user }) => eq(user.age, 25)),
+        )
+
+        await query.preload()
+
+        // Release initial sync
+        if (config.progressiveTestControl) {
+          config.progressiveTestControl.releaseInitialSync()
+        }
+
+        // Don't wait for data, just cleanup immediately
+        await query.cleanup()
+
+        // Should not throw
+        expect(true).toBe(true)
+      })
+    })
+  })
+}
diff --git a/packages/db-collection-e2e/src/types.ts b/packages/db-collection-e2e/src/types.ts
new file mode 100644
index 000000000..6587dac57
--- /dev/null
+++ b/packages/db-collection-e2e/src/types.ts
@@ -0,0 +1,110 @@
+import type { Collection } from '@tanstack/db'
+
+/**
+ * Test data schema types
+ */
+export interface User {
+  id: string // UUID
+  name: string // For collation testing
+  email: string | null
+  age: number
+  isActive: boolean
+  createdAt: Date
+  metadata: Record<string, unknown> | null // JSON field
+  deletedAt: Date | null // Soft delete
+}
+
+export interface Post {
+  id: string
+  userId: string // FK to User
+  title: string
+  content: string | null
+  viewCount: number
+  largeViewCount: bigint // BIGINT field for testing large number serialization
+  publishedAt: Date | null
+  deletedAt: Date | null
+}
+
+export interface Comment {
+  id: string
+  postId: string // FK to Post
+  userId: string // FK to User
+  text: string
+  createdAt: Date
+  deletedAt: Date | null
+}
+
+/**
+ * Seed data result
+ */
+export interface SeedDataResult {
+  users: Array<User>
+  posts: Array<Post>
+  comments: Array<Comment>
+  userIds: Array<string>
+  postIds: Array<string>
+  commentIds: Array<string>
+}
+
+/**
+ * Test configuration for e2e tests
+ */
+export interface E2ETestConfig {
+  collections: {
+    eager: {
+      users: Collection<User>
+      posts: Collection<Post>
+      comments: Collection<Comment>
+    }
+    onDemand: {
+      users: Collection<User>
+      posts: Collection<Post>
+      comments: Collection<Comment>
+    }
+    progressive?: {
+      users: Collection<User>
+      posts: Collection<Post>
+      comments: Collection<Comment>
+    }
+  }
+
+  // Mutation helpers using collection APIs (works for both Electric and Query)
+  // Note: Requires collections to have onInsert/onUpdate/onDelete handlers configured
+  mutations?: {
+    insertUser: (user: User) => Promise<void>
+    updateUser: (id: string, updates: Partial<User>) => Promise<void>
+    deleteUser: (id: string) => Promise<void>
+    insertPost: (post: Post) => Promise<void>
+  }
+
+  // Helper to get txid for Electric txid tracking tests (Electric only)
+  getTxid?: () => Promise<number | null>
+
+  // Indicates if the backend has replication lag (e.g., Electric sync)
+  // When true, tests will wait for mutations to propagate before proceeding
+  hasReplicationLag?: boolean
+
+  // Test control for progressive mode (Electric only)
+  // Allows explicit control over when initial sync completes for deterministic testing
+  progressiveTestControl?: {
+    releaseInitialSync: () => void
+  }
+
+  // Lifecycle hooks
+  setup: () => Promise<void>
+  teardown: () => Promise<void>
+  beforeEach?: () => Promise<void>
+  afterEach?: () => Promise<void>
+}
+
+/**
+ * Database client interface (pg Client)
+ */
+export interface DbClient {
+  connect: () => Promise<void>
+  end: () => Promise<void>
+  query: (
+    sql: string,
+    values?: Array<unknown>,
+  ) => Promise<{ rows: Array<unknown> }>
+}
diff --git a/packages/db-collection-e2e/src/utils/assertions.ts b/packages/db-collection-e2e/src/utils/assertions.ts
new file mode 100644
index 000000000..b0c7afccc
--- /dev/null
+++ b/packages/db-collection-e2e/src/utils/assertions.ts
@@ -0,0 +1,182 @@
+import { expect } from 'vitest'
+import { getLoadedIds } from './helpers'
+import type { Collection } from '@tanstack/db'
+
+/**
+ * Assert that a collection has loaded exactly the expected items (no more, no less)
+ */
+export function assertLoadedExactly<T extends { id: string }>(
+  collection: Collection<T>,
+  expectedIds: Array<string>,
+  message?: string,
+) {
+  const loadedIds = getLoadedIds(collection)
+  const loadedSet = new Set(loadedIds)
+  const expectedSet = new Set(expectedIds)
+
+  // Check for extra items
+  const extraIds = loadedIds.filter((id) => !expectedSet.has(id))
+  if (extraIds.length > 0) {
+    throw new Error(
+      message ??
+        `Collection has extra items: ${extraIds.join(`, `)} (expected only: ${expectedIds.join(`, `)})`,
+    )
+  }
+
+  // Check for missing items
+  const missingIds = expectedIds.filter((id) => !loadedSet.has(id))
+  if (missingIds.length > 0) {
+    throw new Error(
+      message ??
+        `Collection is missing items: ${missingIds.join(`, `)} (loaded: ${loadedIds.join(`, `)})`,
+    )
+  }
+}
+
+/**
+ * Assert that a collection has loaded at least the expected items (may have more)
+ */
+export function assertLoadedAtLeast<T extends { id: string }>(
+  collection: Collection<T>,
+  expectedIds: Array<string>,
+  message?: string,
+) {
+  const loadedIds = getLoadedIds(collection)
+  const loadedSet = new Set(loadedIds)
+
+  const missingIds = expectedIds.filter((id) => !loadedSet.has(id))
+  if (missingIds.length > 0) {
+    throw new Error(
+      message ??
+        `Collection is missing items: ${missingIds.join(`, `)} (loaded: ${loadedIds.join(`, `)})`,
+    )
+  }
+}
+
+/**
+ * Assert that a collection has NOT loaded any of the specified items
+ */
+export function assertNotLoaded<T extends { id: string }>(
+  collection: Collection<T>,
+  forbiddenIds: Array<string>,
+  message?: string,
+) {
+  const loadedIds = getLoadedIds(collection)
+  const loadedSet = new Set(loadedIds)
+
+  const foundIds = forbiddenIds.filter((id) => loadedSet.has(id))
+  if (foundIds.length > 0) {
+    throw new Error(
+      message ?? `Collection should not have loaded: ${foundIds.join(`, `)}`,
+    )
+  }
+}
+
+/**
+ * Assert that a collection's size matches expected
+ */
+export function assertCollectionSize<T extends object>(
+  collection: Collection<T>,
+  expectedSize: number,
+  message?: string,
+) {
+  expect(collection.size, message).toBe(expectedSize)
+}
+
+/**
+ * Assert that all items in a collection match a predicate
+ */
+export function assertAllItemsMatch<T extends object>(
+  collection: Collection<T>,
+  predicate: (item: T) => boolean,
+  message?: string,
+) {
+  const items = Array.from(collection.state.values())
+  const failingItems = items.filter((item) => !predicate(item))
+
+  if (failingItems.length > 0) {
+    throw new Error(
+      message ??
+        `${failingItems.length} item(s) did not match predicate: ${JSON.stringify(failingItems[0])}`,
+    )
+  }
+}
+
+/**
+ * Assert that items are sorted correctly
+ */
+export function assertSorted<T, K extends keyof T>(
+  items: Array<T>,
+  field: K,
+  direction: `asc` | `desc` = `asc`,
+  message?: string,
+) {
+  for (let i = 1; i < items.length; i++) {
+    const prev = items[i - 1]![field]
+    const curr = items[i]![field]
+
+    if (direction === `asc`) {
+      if (prev > curr) {
+        throw new Error(
+          message ??
+            `Items not sorted ascending by ${String(field)}: ${prev} > ${curr} at index ${i}`,
+        )
+      }
+    } else {
+      if (prev < curr) {
+        throw new Error(
+          message ??
+            `Items not sorted descending by ${String(field)}: ${prev} < ${curr} at index ${i}`,
+        )
+      }
+    }
+  }
+}
+
+/**
+ * Assert that predicate pushdown occurred (no over-fetching)
+ * This checks that the collection didn't load more data than necessary
+ */
+export function assertNoPushdownViolation<T extends { id: string }>(
+  collection: Collection<T>,
+  expectedMaxIds: Array<string>,
+  message?: string,
+) {
+  const loadedIds = getLoadedIds(collection)
+  const expectedSet = new Set(expectedMaxIds)
+
+  // Check if any loaded IDs are not in expected set
+  const extraIds = loadedIds.filter((id) => !expectedSet.has(id))
+
+  if (extraIds.length > 0) {
+    throw new Error(
+      message ??
+        `Predicate pushdown violation: Collection loaded ${extraIds.length} extra item(s) that don't match the predicate`,
+    )
+  }
+}
+
+/**
+ * Assert that deduplication occurred
+ */
+export function assertDeduplicationOccurred(
+  actualLoads: number,
+  deduplicatedLoads: number,
+  expectedActualLoads: number,
+  message?: string,
+) {
+  expect(actualLoads, message ?? `Actual loads`).toBe(expectedActualLoads)
+  expect(deduplicatedLoads, message ?? `Deduplicated loads`).toBeGreaterThan(0)
+}
+
+/**
+ * Assert that NO deduplication occurred (all requests were unique)
+ */
+export function assertNoDeduplication(
+  actualLoads: number,
+  deduplicatedLoads: number,
+  message?: string,
+) {
+  expect(deduplicatedLoads, message ?? `Deduplicated loads`).toBe(0)
+  expect(actualLoads, message ?? `Actual loads`).toBeGreaterThan(0)
+}
diff --git a/packages/db-collection-e2e/src/utils/helpers.ts b/packages/db-collection-e2e/src/utils/helpers.ts
new file mode 100644
index 000000000..75c590c5d
--- /dev/null
+++ b/packages/db-collection-e2e/src/utils/helpers.ts
@@ -0,0 +1,206 @@
+import type { Collection } from '@tanstack/db'
+
+/**
+ * Wait for a condition to be true with timeout
+ */
+export async function waitFor(
+  condition: () => boolean | Promise<boolean>,
+  options: {
+    timeout?: number
+    interval?: number
+    message?: string
+  } = {},
+): Promise<void> {
+  const {
+    timeout = 5000,
+    interval = 50,
+    message = `Condition not met`,
+  } = options
+
+  const start = Date.now()
+  while (Date.now() - start < timeout) {
+    if (await condition()) {
+      return
+    }
+    await sleep(interval)
+  }
+
+  throw new Error(`${message} (timeout after ${timeout}ms)`)
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/**
+ * Get all loaded item IDs from a collection
+ */
+export function getLoadedIds<T extends { id: string }>(
+  collection: Collection<T>,
+): Array<string> {
+  return Array.from(collection.state.values()).map((item) => item.id)
+}
+
+/**
+ * Get count of loaded items in a collection
+ */
+export function getLoadedCount<T extends object>(
+  collection: Collection<T>,
+): number {
+  return collection.size
+}
+
+/**
+ * Check if a collection has loaded specific IDs
+ */
+export function hasLoadedIds<T extends { id: string }>(
+  collection: Collection<T>,
+  ids: Array<string>,
+): boolean {
+  const loadedIds = getLoadedIds(collection)
+  return ids.every((id) => loadedIds.includes(id))
+}
+
+/**
+ * Check if a collection has ONLY loaded specific IDs (no extras)
+ */
+export function hasOnlyLoadedIds<T extends { id: string }>(
+  collection: Collection<T>,
+  ids: Array<string>,
+): boolean {
+  const loadedIds = getLoadedIds(collection)
+  const idsSet = new Set(ids)
+
+  // Check that all loaded IDs are in expected IDs
+  if (!loadedIds.every((id) => idsSet.has(id))) {
+    return false
+  }
+
+  // Check that all expected IDs are loaded
+  if (!ids.every((id) => loadedIds.includes(id))) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Wait for a collection to reach a specific size
+ */
+export async function waitForCollectionSize<T extends object>(
+  collection: Collection<T>,
+  expectedSize: number,
+  timeout = 5000,
+): Promise<void> {
+  await waitFor(() => collection.size === expectedSize, {
+    timeout,
+    message: `Collection size did not reach ${expectedSize} (current: ${collection.size})`,
+  })
+}
+
+/**
+ * Wait for collection to finish loading (status === 'ready')
+ */
+export async function waitForCollectionReady<T extends object>(
+  collection: Collection<T>,
+  timeout = 5000,
+): Promise<void> {
+  await waitFor(() => collection.status === `ready`, {
+    timeout,
+    message: `Collection did not reach 'ready' status (current: ${collection.status})`,
+  })
+}
+
+/**
+ * Wait for a query to have data after preload.
+ * This is necessary for on-demand collections where Electric streams
+ * snapshot data asynchronously after loadSubset is triggered.
+ */
+export async function waitForQueryData<T extends object>(
+  query: Collection<T>,
+  options: {
+    minSize?: number
+    timeout?: number
+  } = {},
+): Promise<void> {
+  const { minSize = 1, timeout = 2000 } = options
+
+  await waitFor(() => query.size >= minSize, {
+    timeout,
+    interval: 10,
+    message: `Query did not load data (expected >= ${minSize}, got ${query.size})`,
+  })
+}
+
+/**
+ * Create a deduplication counter for testing
+ */
+export function createDeduplicationCounter() {
+  let actualLoads = 0
+  let deduplicatedLoads = 0
+
+  return {
+    onLoad: () => {
+      actualLoads++
+    },
+    onDeduplicate: () => {
+      deduplicatedLoads++
+    },
+    getActualLoads: () => actualLoads,
+    getDeduplicatedLoads: () => deduplicatedLoads,
+    getTotalAttempts: () => actualLoads + deduplicatedLoads,
+    reset: () => {
+      actualLoads = 0
+      deduplicatedLoads = 0
+    },
+  }
+}
+
+/**
+ * Sort array of objects by a field
+ */
+export function sortBy<T, K extends keyof T>(
+  array: Array<T>,
+  field: K,
+  direction: `asc` | `desc` = `asc`,
+): Array<T> {
+  return [...array].sort((a, b) => {
+    const aVal = a[field]
+    const bVal = b[field]
+
+    if (aVal < bVal) return direction === `asc` ? -1 : 1
+    if (aVal > bVal) return direction === `asc` ? 1 : -1
+    return 0
+  })
+}
+
+/**
+ * Filter array by predicate function
+ */
+export function filterBy<T>(
+  array: Array<T>,
+  predicate: (item: T) => boolean,
+): Array<T> {
+  return array.filter(predicate)
+}
+
+/**
+ * Paginate array
+ */
+export function paginate<T>(
+  array: Array<T>,
+  options: { limit?: number; offset?: number } = {},
+): Array<T> {
+  const { limit, offset = 0 } = options
+
+  let result = array.slice(offset)
+
+  if (limit !== undefined) {
+    result = result.slice(0, limit)
+  }
+
+  return result
+}
diff --git a/packages/db-collection-e2e/support/global-setup.ts b/packages/db-collection-e2e/support/global-setup.ts
new file mode 100644
index 000000000..57fa7663b
--- /dev/null
+++ b/packages/db-collection-e2e/support/global-setup.ts
@@ -0,0 +1,152 @@
+import type { GlobalSetupContext } from 'vitest/node'
+import { Client, type ClientConfig } from 'pg'
+
+const ELECTRIC_URL = process.env.ELECTRIC_URL ?? 'http://localhost:3000'
+const POSTGRES_HOST = process.env.POSTGRES_HOST ?? 'localhost'
+const POSTGRES_PORT = parseInt(process.env.POSTGRES_PORT ?? '54321')
+const POSTGRES_USER = process.env.POSTGRES_USER ?? 'postgres'
+const POSTGRES_PASSWORD = process.env.POSTGRES_PASSWORD ?? 'password'
+const POSTGRES_DB = process.env.POSTGRES_DB ?? 'e2e_test'
+const TEST_SCHEMA = 'e2e_test'
+
+// Module augmentation for type-safe context injection
+declare module 'vitest' {
+  export interface ProvidedContext {
+    baseUrl: string
+    testSchema: string
+    postgresConfig: {
+      host: string
+      port: number
+      user: string
+      password: string
+      database: string
+    }
+  }
+}
+
+/**
+ * Create a PostgreSQL client with default e2e test configuration
+ */
+export function makePgClient(overrides: ClientConfig = {}): Client {
+  return new Client({
+    host: POSTGRES_HOST,
+    port: POSTGRES_PORT,
+    user: POSTGRES_USER,
+    password: POSTGRES_PASSWORD,
+    database: POSTGRES_DB,
+    options: `-csearch_path=${TEST_SCHEMA}`,
+    ...overrides,
+  })
+}
+
+/**
+ * Wait for Electric server to be ready
+ */
+async function waitForElectric(url: string): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Timed out waiting for Electric to be active at ${url}`))
+    }, 10000)
+
+    const check = async (): Promise<void> => {
+      try {
+        const res = await fetch(`${url}/v1/health`)
+        if (res.ok) {
+          const data = (await res.json()) as { status: string }
+          if (data.status === 'active') {
+            clearTimeout(timeout)
+            return resolve()
+          }
+        }
+        setTimeout(() => void check(), 100)
+      } catch {
+        setTimeout(() => void check(), 100)
+      }
+    }
+
+    void check()
+  })
+}
+
+/**
+ * Wait for Postgres to be ready
+ */
+async function waitForPostgres(client: Client): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Timed out waiting for Postgres'))
+    }, 10000)
+
+    const check = async (): Promise<void> => {
+      try {
+        await client.connect()
+        clearTimeout(timeout)
+        return resolve()
+      } catch {
+        setTimeout(() => void check(), 100)
+      }
+    }
+
+    void check()
+  })
+}
+
+/**
+ * Global setup for e2e test suite
+ *
+ * This runs once before all tests and:
+ * 1. Waits for Electric server to be healthy
+ * 2. Connects to Postgres
+ * 3. Creates test schema
+ * 4. Provides context to all tests
+ * 5. Returns cleanup function
+ */
+export default async function ({ provide }: GlobalSetupContext) {
+  console.log('🚀 Starting e2e test suite global setup...')
+
+  // Wait for Electric server to be ready
+  console.log(`⏳ Waiting for Electric at ${ELECTRIC_URL}...`)
+  await waitForElectric(ELECTRIC_URL)
+  console.log('✓ Electric is ready')
+
+  // Connect to Postgres
+  console.log(
+    `⏳ Connecting to Postgres at ${POSTGRES_HOST}:${POSTGRES_PORT}...`,
+  )
+  const client = makePgClient()
+  await waitForPostgres(client)
+  console.log('✓ Postgres is ready')
+
+  // Create test schema
+  console.log(`⏳ Creating test schema: ${TEST_SCHEMA}...`)
+  await client.query(`CREATE SCHEMA IF NOT EXISTS ${TEST_SCHEMA}`)
+  console.log('✓ Test schema created')
+
+  // Provide context values to all tests
+  provide('baseUrl', ELECTRIC_URL)
+  provide('testSchema', TEST_SCHEMA)
+  provide('postgresConfig', {
+    host: POSTGRES_HOST,
+    port: POSTGRES_PORT,
+    user: POSTGRES_USER,
+    password: POSTGRES_PASSWORD,
+    database: POSTGRES_DB,
+  })
+
+  console.log('✅ Global setup complete\n')
+
+  // Return cleanup function (runs once after all tests)
+  return async () => {
+    console.log('\n🧹 Running global teardown...')
+    try {
+      await client.query(`DROP SCHEMA IF EXISTS ${TEST_SCHEMA} CASCADE`)
+      console.log('✓ Test schema dropped')
+    } catch (error) {
+      console.error('Error dropping test schema:', error)
+    } finally {
+      await client.end()
+      console.log('✓ Postgres connection closed')
+      console.log('✅ Global teardown complete')
+    }
+  }
+}
diff --git a/packages/db-collection-e2e/support/test-context.ts b/packages/db-collection-e2e/support/test-context.ts
new file mode 100644
index 000000000..aab8f787f
--- /dev/null
+++ b/packages/db-collection-e2e/support/test-context.ts
@@ -0,0 +1,236 @@
+import { test, inject } from 'vitest'
+import { Client } from 'pg'
+import { makePgClient } from './global-setup'
+import type { SeedDataResult } from '../src/types'
+import { generateSeedData } from '../src/fixtures/seed-data'
+
+/**
+ * Base fixture with database client and abort controller
+ */
+export const testWithDb = test.extend<{
+  dbClient: Client
+  aborter: AbortController
+  baseUrl: string
+  testSchema: string
+  tableName: (base: string) => string
+}>({
+  dbClient: async ({}, use) => {
+    const schema = inject('testSchema')
+    const client = makePgClient({
+      options: `-csearch_path=${schema}`,
+    })
+    await client.connect()
+
+    // Ensure schema is set
+    await client.query(`SET search_path TO ${schema}`)
+
+    await use(client)
+    await client.end()
+  },
+
+  aborter: async ({}, use) => {
+    const controller = new AbortController()
+    await use(controller)
+    controller.abort('Test complete')
+  },
+
+  baseUrl: async ({}, use) => {
+    await use(inject('baseUrl'))
+  },
+
+  testSchema: async ({}, use) => {
+    await use(inject('testSchema'))
+  },
+
+  tableName: async ({ task }, use) => {
+    // Generate unique table names based on task ID and random suffix
+    await use((base: string) => {
+      const taskId = task.id.replace(/[^a-zA-Z0-9]/g, '_')
+      const random = Math.random().toString(16).slice(2, 8)
+      return `"${base}_${taskId}_${random}"`
+    })
+  },
+})
+
+/**
+ * Extended fixture with test tables (Users, Posts, Comments)
+ */
+export const testWithTables = testWithDb.extend<{
+  usersTable: string
+  postsTable: string
+  commentsTable: string
+  dropTables: () => Promise<void>
+}>({
+  usersTable: async ({ dbClient, tableName, task }, use) => {
+    const name = tableName('users')
+    const taskFile = task.file?.name.replace(/'/g, '`') ?? 'unknown'
+    const taskName = task.name.replace(/'/g, '`')
+
+    await dbClient.query(`
+      DROP TABLE IF EXISTS ${name};
+      CREATE TABLE ${name} (
+        id UUID PRIMARY KEY,
+        name TEXT NOT NULL,
+        email TEXT,
+        age INTEGER NOT NULL,
+        is_active BOOLEAN NOT NULL DEFAULT true,
+        created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+        metadata JSONB,
+        deleted_at TIMESTAMP
+      );
+      COMMENT ON TABLE ${name} IS 'Created for ${taskFile} - ${taskName}';
+    `)
+
+    await use(name)
+
+    try {
+      await dbClient.query(`DROP TABLE IF EXISTS ${name}`)
+    } catch (error) {
+      console.error(`Error dropping table ${name}:`, error)
+    }
+  },
+
+  postsTable: async ({ dbClient, tableName, usersTable, task }, use) => {
+    const name = tableName('posts')
+    const taskFile = task.file?.name.replace(/'/g, '`') ?? 'unknown'
+    const taskName = task.name.replace(/'/g, '`')
+
+    await dbClient.query(`
+      DROP TABLE IF EXISTS ${name};
+      CREATE TABLE ${name} (
+        id UUID PRIMARY KEY,
+        user_id UUID NOT NULL,
+        title TEXT NOT NULL,
+        content TEXT,
+        view_count INTEGER NOT NULL DEFAULT 0,
+        published_at TIMESTAMP,
+        deleted_at TIMESTAMP
+      );
+      COMMENT ON TABLE ${name} IS 'Created for ${taskFile} - ${taskName}';
+    `)
+
+    await use(name)
+
+    try {
+      await dbClient.query(`DROP TABLE IF EXISTS ${name}`)
+    } catch (error) {
+      console.error(`Error dropping table ${name}:`, error)
+    }
+  },
+
+  commentsTable: async (
+    { dbClient, tableName, postsTable, usersTable, task },
+    use,
+  ) => {
+    const name = tableName('comments')
+    const taskFile = task.file?.name.replace(/'/g, '`') ?? 'unknown'
+    const taskName = task.name.replace(/'/g, '`')
+
+    await dbClient.query(`
+      DROP TABLE IF EXISTS ${name};
+      CREATE TABLE ${name} (
+        id UUID PRIMARY KEY,
+        post_id UUID NOT NULL,
+        user_id UUID NOT NULL,
+        text TEXT NOT NULL,
+        created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+        deleted_at TIMESTAMP
+      );
+      COMMENT ON TABLE ${name} IS 'Created for ${taskFile} - ${taskName}';
+    `)
+
+    await use(name)
+
+    try {
+      await dbClient.query(`DROP TABLE IF EXISTS ${name}`)
+    } catch (error) {
+      console.error(`Error dropping table ${name}:`, error)
+    }
+  },
+
+  dropTables: async (
+    { dbClient, usersTable, postsTable, commentsTable },
+    use,
+  ) => {
+    await use(async () => {
+      try {
+        await dbClient.query(`DROP TABLE IF EXISTS ${commentsTable}`)
+        await dbClient.query(`DROP TABLE IF EXISTS ${postsTable}`)
+        await dbClient.query(`DROP TABLE IF EXISTS ${usersTable}`)
+      } catch (error) {
+        console.error('Error dropping tables:', error)
+      }
+    })
+  },
+})
+
+/**
+ * Extended fixture with seeded test data
+ */
+export const testWithSeedData = testWithTables.extend<{
+  seedData: SeedDataResult
+  insertSeedData: () => Promise<void>
+}>({
+  seedData: async ({}, use) => {
+    const seed = generateSeedData()
+    await use(seed)
+  },
+
+  insertSeedData: async (
+    { dbClient, usersTable, postsTable, commentsTable, seedData },
+    use,
+  ) => {
+    await use(async () => {
+      // Insert users
+      for (const user of seedData.users) {
+        await dbClient.query(
+          `INSERT INTO ${usersTable} (id, name, email, age, is_active, created_at, metadata, deleted_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+          [
+            user.id,
+            user.name,
+            user.email,
+            user.age,
+            user.isActive,
+            user.createdAt,
+            user.metadata ? JSON.stringify(user.metadata) : null,
+            user.deletedAt,
+          ],
+        )
+      }
+
+      // Insert posts
+      for (const post of seedData.posts) {
+        await dbClient.query(
+          `INSERT INTO ${postsTable} (id, user_id, title, content, view_count, published_at, deleted_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+          [
+            post.id,
+            post.userId,
+            post.title,
+            post.content,
+            post.viewCount,
+            post.publishedAt,
+            post.deletedAt,
+          ],
+        )
+      }
+
+      // Insert comments
+      for (const comment of seedData.comments) {
+        await dbClient.query(
+          `INSERT INTO ${commentsTable} (id, post_id, user_id, text, created_at, deleted_at)
+           VALUES ($1, $2, $3, $4, $5, $6)`,
+          [
+            comment.id,
+            comment.postId,
+            comment.userId,
+            comment.text,
+            comment.createdAt,
+            comment.deletedAt,
+          ],
+        )
+      }
+    })
+  },
+})
diff --git a/packages/db-collection-e2e/tsconfig.json b/packages/db-collection-e2e/tsconfig.json
new file mode 100644
index 000000000..7c90fdfe9
--- /dev/null
+++ b/packages/db-collection-e2e/tsconfig.json
@@ -0,0 +1,26 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "types": ["vitest/globals", "node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "paths": {
+      "@tanstack/db": ["../db/src"],
+      "@tanstack/db-ivm": ["../db-ivm/src"],
+      "@tanstack/electric-db-collection": ["../electric-db-collection"],
+      "@tanstack/query-db-collection": ["../query-db-collection"]
+    }
+  },
+  "include": ["src/**/*", "support/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/packages/db-collection-e2e/vite.config.ts b/packages/db-collection-e2e/vite.config.ts
new file mode 100644
index 000000000..14475c28f
--- /dev/null
+++ b/packages/db-collection-e2e/vite.config.ts
@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globalSetup: './support/global-setup.ts',
+    fileParallelism: false, // Critical: Serial execution for shared database
+    timeout: 30000,
+    environment: 'jsdom',
+    coverage: {
+      provider: 'istanbul',
+      reporter: ['text', 'json', 'html'],
+      include: ['**/src/**'],
+    },
+  },
+})
diff --git a/packages/db-collections/package.json b/packages/db-collections/package.json
new file mode 100644
index 000000000..074afba15
--- /dev/null
+++ b/packages/db-collections/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "db-collections",
+  "version": "0.0.0",
+  "private": true
+}
diff --git a/packages/db-ivm/CHANGELOG.md b/packages/db-ivm/CHANGELOG.md
index 571175e93..edb12e419 100644
--- a/packages/db-ivm/CHANGELOG.md
+++ b/packages/db-ivm/CHANGELOG.md
@@ -1,5 +1,47 @@
 # @tanstack/db-ivm
 
+## 0.1.17
+
+### Patch Changes
+
+- Add string support to `min()` and `max()` aggregate functions. These functions now work with strings using lexicographic comparison, matching standard SQL behavior. ([#1120](https://github.com/TanStack/db/pull/1120))
+
+## 0.1.16
+
+### Patch Changes
+
+- Add `groupedOrderByWithFractionalIndex` operator. This operator groups elements by a provided `groupKeyFn` and applies ordering and limits independently to each group. Each group maintains its own sorted collection with independent limit/offset, which is useful for hierarchical data projections where child collections need to enforce limits within each parent's slice of the stream rather than across the entire dataset. ([#997](https://github.com/TanStack/db/pull/997))
+
+## 0.1.15
+
+### Patch Changes
+
+- Adds a GroupedTopKWithFractionalIndexOperator that maintains separate topK windows for each group. ([#993](https://github.com/TanStack/db/pull/993))
+
+## 0.1.14
+
+### Patch Changes
+
+- Use row keys for stable tie-breaking in ORDER BY operations instead of hash-based object IDs. ([#957](https://github.com/TanStack/db/pull/957))
+
+  Previously, when multiple rows had equal ORDER BY values, tie-breaking used `globalObjectIdGenerator.getId(key)` which could produce hash collisions and wasn't stable across page reloads for object references. Now, the row key (which is always `string | number` and unique per row) is used directly for tie-breaking, ensuring deterministic and stable ordering.
+
+  This also simplifies the internal `TaggedValue` type from a 3-tuple `[K, V, Tag]` to a 2-tuple `[K, V]`, removing unnecessary complexity.
+
+## 0.1.13
+
+### Patch Changes
+
+- Fix Uint8Array/Buffer comparison to work by content instead of reference. This enables proper equality checks for binary IDs like ULIDs in WHERE clauses using the `eq` function. ([#779](https://github.com/TanStack/db/pull/779))
+
+- Fix bug with setWindow on ordered queries that have no limit. ([#763](https://github.com/TanStack/db/pull/763))
+
+## 0.1.12
+
+### Patch Changes
+
+- Fix bug with setWindow on ordered queries that have no limit. ([#701](https://github.com/TanStack/db/pull/701))
+
 ## 0.1.11
 
 ### Patch Changes
@@ -12,9 +54,9 @@
   const users = createLiveQueryCollection((q) =>
     q
       .from({ user: usersCollection })
-      .orderBy(({ user }) => user.name, "asc")
+      .orderBy(({ user }) => user.name, 'asc')
       .limit(10)
-      .offset(0)
+      .offset(0),
   )
 
   users.utils.setWindow({ offset: 10, limit: 10 })
diff --git a/packages/db-ivm/README.md b/packages/db-ivm/README.md
index b753df6d6..17dd83440 100644
--- a/packages/db-ivm/README.md
+++ b/packages/db-ivm/README.md
@@ -11,7 +11,7 @@ The API is almost identical to D2TS, but without the need to specify a version w
 Here's a simple example that demonstrates the core concepts:
 
 ```typescript
-import { D2, map, filter, debug, MultiSet } from "@tanstack/db-ivm"
+import { D2, map, filter, debug, MultiSet } from '@tanstack/db-ivm'
 
 // Create a new D2 graph
 const graph = new D2()
@@ -28,7 +28,7 @@ const input = graph.newInput<number>()
 const output = input.pipe(
   map((x) => x + 5),
   filter((x) => x % 2 === 0),
-  debug("output")
+  debug('output'),
 )
 
 // Finalize the pipeline, after this point we can no longer add operators or
@@ -46,7 +46,7 @@ input.sendData(
     [1, 1],
     [2, 1],
     [3, 1],
-  ])
+  ]),
 )
 
 // Process the data
diff --git a/packages/db-ivm/package.json b/packages/db-ivm/package.json
index 2fb5d3e89..b5e5d6833 100644
--- a/packages/db-ivm/package.json
+++ b/packages/db-ivm/package.json
@@ -1,15 +1,33 @@
 {
   "name": "@tanstack/db-ivm",
+  "version": "0.1.17",
   "description": "Incremental View Maintenance for TanStack DB based on Differential Dataflow",
-  "version": "0.1.11",
-  "dependencies": {
-    "fractional-indexing": "^3.2.0",
-    "sorted-btree": "^1.8.1"
+  "author": "Sam Willis",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/db.git",
+    "directory": "packages/db-ivm"
   },
-  "devDependencies": {
-    "@types/debug": "^4.1.12",
-    "@vitest/coverage-istanbul": "^3.2.4"
+  "homepage": "https://tanstack.com/db",
+  "keywords": [
+    "electric",
+    "sql",
+    "optimistic",
+    "typescript",
+    "ivm",
+    "differential-dataflow"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "lint": "eslint . --fix",
+    "test": "vitest --run"
   },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -23,39 +41,20 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
-  "packageManager": "pnpm@10.18.3",
+  "dependencies": {
+    "fractional-indexing": "^3.2.0",
+    "sorted-btree": "^1.8.1"
+  },
   "peerDependencies": {
     "typescript": ">=4.7"
   },
-  "author": "Sam Willis",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/TanStack/db.git",
-    "directory": "packages/db-ivm"
-  },
-  "homepage": "https://tanstack.com/db",
-  "keywords": [
-    "electric",
-    "sql",
-    "optimistic",
-    "typescript",
-    "ivm",
-    "differential-dataflow"
-  ],
-  "scripts": {
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "lint": "eslint . --fix",
-    "test": "npx vitest --run"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@vitest/coverage-istanbul": "^3.2.4"
+  }
 }
diff --git a/packages/db-ivm/src/d2.ts b/packages/db-ivm/src/d2.ts
index b3149de73..8451b2aff 100644
--- a/packages/db-ivm/src/d2.ts
+++ b/packages/db-ivm/src/d2.ts
@@ -1,11 +1,11 @@
-import { DifferenceStreamWriter } from "./graph.js"
+import { DifferenceStreamWriter } from './graph.js'
 import type {
   BinaryOperator,
   DifferenceStreamReader,
   UnaryOperator,
-} from "./graph.js"
-import type { MultiSet, MultiSetArray } from "./multiset.js"
-import type { ID2, IStreamBuilder, PipedOperator } from "./types.js"
+} from './graph.js'
+import type { MultiSet, MultiSetArray } from './multiset.js'
+import type { ID2, IStreamBuilder, PipedOperator } from './types.js'
 
 export class D2 implements ID2 {
   #operators: Array<UnaryOperator<any> | BinaryOperator<any>> = []
diff --git a/packages/db-ivm/src/graph.ts b/packages/db-ivm/src/graph.ts
index a39027a64..5263bb643 100644
--- a/packages/db-ivm/src/graph.ts
+++ b/packages/db-ivm/src/graph.ts
@@ -1,10 +1,10 @@
-import { MultiSet } from "./multiset.js"
-import type { MultiSetArray } from "./multiset.js"
+import { MultiSet } from './multiset.js'
+import type { MultiSetArray } from './multiset.js'
 import type {
   IDifferenceStreamReader,
   IDifferenceStreamWriter,
   IOperator,
-} from "./types.js"
+} from './types.js'
 
 /**
  * A read handle to a dataflow edge that receives data from a writer.
@@ -61,7 +61,7 @@ export abstract class Operator<T> implements IOperator<T> {
   constructor(
     public id: number,
     inputs: Array<DifferenceStreamReader<T>>,
-    output: DifferenceStreamWriter<T>
+    output: DifferenceStreamWriter<T>,
   ) {
     this.inputs = inputs
     this.output = output
@@ -84,7 +84,7 @@ export abstract class UnaryOperator<Tin, Tout = Tin> extends Operator<
   constructor(
     public id: number,
     inputA: DifferenceStreamReader<Tin>,
-    output: DifferenceStreamWriter<Tout>
+    output: DifferenceStreamWriter<Tout>,
   ) {
     super(id, [inputA], output)
   }
@@ -103,7 +103,7 @@ export abstract class BinaryOperator<T> extends Operator<T> {
     public id: number,
     inputA: DifferenceStreamReader<T>,
     inputB: DifferenceStreamReader<T>,
-    output: DifferenceStreamWriter<T>
+    output: DifferenceStreamWriter<T>,
   ) {
     super(id, [inputA, inputB], output)
   }
diff --git a/packages/db-ivm/src/hashing/hash.ts b/packages/db-ivm/src/hashing/hash.ts
index 0c7aa1d02..d1b9d0a6a 100644
--- a/packages/db-ivm/src/hashing/hash.ts
+++ b/packages/db-ivm/src/hashing/hash.ts
@@ -1,5 +1,5 @@
-import { MurmurHashStream, randomHash } from "./murmur.js"
-import type { Hasher } from "./murmur.js"
+import { MurmurHashStream, randomHash } from './murmur.js'
+import type { Hasher } from './murmur.js'
 
 /*
  * Implementation of structural hashing based on the Composites polyfill implementation:
@@ -17,6 +17,12 @@ const OBJECT_MARKER = randomHash()
 const ARRAY_MARKER = randomHash()
 const MAP_MARKER = randomHash()
 const SET_MARKER = randomHash()
+const UINT8ARRAY_MARKER = randomHash()
+
+// Maximum byte length for Uint8Arrays to hash by content instead of reference
+// Arrays smaller than this will be hashed by content, allowing proper equality comparisons
+// for small arrays like ULIDs (16 bytes) while still avoiding performance costs for large arrays
+const UINT8ARRAY_CONTENT_HASH_THRESHOLD = 128
 
 const hashCache = new WeakMap<object, number>()
 
@@ -35,6 +41,24 @@ function hashObject(input: object): number {
   let valueHash: number | undefined
   if (input instanceof Date) {
     valueHash = hashDate(input)
+  } else if (
+    // Check if input is a Uint8Array or Buffer
+    (typeof Buffer !== `undefined` && input instanceof Buffer) ||
+    input instanceof Uint8Array
+  ) {
+    // For small Uint8Arrays/Buffers (e.g., ULIDs, UUIDs), hash by content
+    // to enable proper equality comparisons. For large arrays, hash by reference
+    // to avoid performance costs.
+    if (input.byteLength <= UINT8ARRAY_CONTENT_HASH_THRESHOLD) {
+      valueHash = hashUint8Array(input)
+    } else {
+      // Deeply hashing large arrays would be too costly
+      // so we track them by reference and cache them in a weak map
+      return cachedReferenceHash(input)
+    }
+  } else if (input instanceof File) {
+    // Files are always hashed by reference due to their potentially large size
+    return cachedReferenceHash(input)
   } else {
     let plainObjectInput = input
     let marker = OBJECT_MARKER
@@ -53,17 +77,6 @@ function hashObject(input: object): number {
       plainObjectInput = [...input.entries()]
     }
 
-    if (
-      (typeof Buffer !== `undefined` && input instanceof Buffer) ||
-      input instanceof Uint8Array ||
-      input instanceof File
-    ) {
-      // Deeply hashing these objects would be too costly
-      // but we also don't want to ignore them
-      // so we track them by reference and cache them in a weak map
-      return cachedReferenceHash(input)
-    }
-
     valueHash = hashPlainObject(plainObjectInput, marker)
   }
 
@@ -78,6 +91,18 @@ function hashDate(input: Date): number {
   return hasher.digest()
 }
 
+function hashUint8Array(input: Uint8Array): number {
+  const hasher = new MurmurHashStream()
+  hasher.update(UINT8ARRAY_MARKER)
+  // Hash the byte length first to differentiate arrays of different sizes
+  hasher.update(input.byteLength)
+  // Hash each byte in the array
+  for (let i = 0; i < input.byteLength; i++) {
+    hasher.writeByte(input[i]!)
+  }
+  return hasher.digest()
+}
+
 function hashPlainObject(input: object, marker: number): number {
   const hasher = new MurmurHashStream()
 
@@ -125,7 +150,7 @@ function updateHasher(hasher: Hasher, input: unknown): void {
       return
     default:
       console.warn(
-        `Ignored input during hashing because it is of type ${typeof input} which is not supported`
+        `Ignored input during hashing because it is of type ${typeof input} which is not supported`,
       )
   }
 }
diff --git a/packages/db-ivm/src/hashing/index.ts b/packages/db-ivm/src/hashing/index.ts
index d44008b0c..ea3875536 100644
--- a/packages/db-ivm/src/hashing/index.ts
+++ b/packages/db-ivm/src/hashing/index.ts
@@ -1,2 +1,2 @@
-export { hash } from "./hash.js"
-export type { Hash, Hasher } from "./murmur.js"
+export { hash } from './hash.js'
+export type { Hash, Hasher } from './murmur.js'
diff --git a/packages/db-ivm/src/hashing/murmur.ts b/packages/db-ivm/src/hashing/murmur.ts
index a90b9b72c..9ce68be31 100644
--- a/packages/db-ivm/src/hashing/murmur.ts
+++ b/packages/db-ivm/src/hashing/murmur.ts
@@ -51,7 +51,7 @@ export class MurmurHashStream implements Hasher {
     this.hash = Math.imul(this.hash, 5) + 0xe6546b64
   }
 
-  private _writeByte(byte: number): void {
+  writeByte(byte: number): void {
     this.carry |= (byte & 0xff) << (8 * this.carryBytes)
     this.carryBytes++
     this.length++
@@ -74,8 +74,8 @@ export class MurmurHashStream implements Hasher {
 
         for (let i = 0; i < description.length; i++) {
           const code = description.charCodeAt(i)
-          this._writeByte(code & 0xff)
-          this._writeByte((code >>> 8) & 0xff)
+          this.writeByte(code & 0xff)
+          this.writeByte((code >>> 8) & 0xff)
         }
         return
       }
@@ -83,20 +83,20 @@ export class MurmurHashStream implements Hasher {
         this.update(STRING_MARKER)
         for (let i = 0; i < chunk.length; i++) {
           const code = chunk.charCodeAt(i)
-          this._writeByte(code & 0xff)
-          this._writeByte((code >>> 8) & 0xff)
+          this.writeByte(code & 0xff)
+          this.writeByte((code >>> 8) & 0xff)
         }
         return
       case `number`:
         dv.setFloat64(0, chunk, true) // fixed little-endian
-        this._writeByte(u8[0]!)
-        this._writeByte(u8[1]!)
-        this._writeByte(u8[2]!)
-        this._writeByte(u8[3]!)
-        this._writeByte(u8[4]!)
-        this._writeByte(u8[5]!)
-        this._writeByte(u8[6]!)
-        this._writeByte(u8[7]!)
+        this.writeByte(u8[0]!)
+        this.writeByte(u8[1]!)
+        this.writeByte(u8[2]!)
+        this.writeByte(u8[3]!)
+        this.writeByte(u8[4]!)
+        this.writeByte(u8[5]!)
+        this.writeByte(u8[6]!)
+        this.writeByte(u8[7]!)
         return
       case `bigint`: {
         let value = chunk
@@ -107,10 +107,10 @@ export class MurmurHashStream implements Hasher {
           this.update(BIG_INT_MARKER)
         }
         while (value > 0n) {
-          this._writeByte(Number(value & 0xffn))
+          this.writeByte(Number(value & 0xffn))
           value >>= 8n
         }
-        if (chunk === 0n) this._writeByte(0)
+        if (chunk === 0n) this.writeByte(0)
         return
       }
       default:
diff --git a/packages/db-ivm/src/index.ts b/packages/db-ivm/src/index.ts
index 5a605a1be..cae148b46 100644
--- a/packages/db-ivm/src/index.ts
+++ b/packages/db-ivm/src/index.ts
@@ -1,4 +1,5 @@
-export * from "./d2.js"
-export * from "./multiset.js"
-export * from "./operators/index.js"
-export * from "./types.js"
+export * from './d2.js'
+export * from './multiset.js'
+export * from './operators/index.js'
+export * from './types.js'
+export { compareKeys, serializeValue } from './utils.js'
diff --git a/packages/db-ivm/src/indexes.ts b/packages/db-ivm/src/indexes.ts
index 7dcb349ba..07c0fa5d5 100644
--- a/packages/db-ivm/src/indexes.ts
+++ b/packages/db-ivm/src/indexes.ts
@@ -33,9 +33,9 @@
  * Prefixes extracted from array values: `['prefix', 'suffix']` → prefix='prefix'
  */
 
-import { MultiSet } from "./multiset.js"
-import { hash } from "./hashing/index.js"
-import type { Hash } from "./hashing/index.js"
+import { MultiSet } from './multiset.js'
+import { hash } from './hashing/index.js'
+import type { Hash } from './hashing/index.js'
 
 // We use a symbol to represent the absence of a prefix, unprefixed values a stored
 // against this key.
@@ -183,7 +183,7 @@ export class Index<TKey, TValue, TPrefix = any> {
     return `Index(${JSON.stringify(
       [...this.entries()],
       undefined,
-      indent ? 2 : undefined
+      indent ? 2 : undefined,
     )})`
   }
 
@@ -325,7 +325,7 @@ export class Index<TKey, TValue, TPrefix = any> {
         key,
         mapOrSingleValue,
         value,
-        multiplicity
+        multiplicity,
       )
       return
     }
@@ -362,7 +362,7 @@ export class Index<TKey, TValue, TPrefix = any> {
     key: TKey,
     currentSingleValue: SingleValue<TValue>,
     newValue: TValue,
-    multiplicity: number
+    multiplicity: number,
   ) {
     const [currentValue, currentMultiplicity] = currentSingleValue
 
@@ -438,7 +438,7 @@ export class Index<TKey, TValue, TPrefix = any> {
    * @returns A multiset of the joined values.
    */
   join<TValue2>(
-    other: Index<TKey, TValue2>
+    other: Index<TKey, TValue2>,
   ): MultiSet<[TKey, [TValue, TValue2]]> {
     const result: Array<[[TKey, [TValue, TValue2]], number]> = []
     // We want to iterate over the smaller of the two indexes to reduce the
@@ -499,7 +499,7 @@ function getPrefix<TValue, TPrefix>(value: TValue): TPrefix | NO_PREFIX {
  * @returns True if the value is a single value, false otherwise.
  */
 function isSingleValue<TValue>(
-  value: SingleValue<TValue> | unknown
+  value: SingleValue<TValue> | unknown,
 ): value is SingleValue<TValue> {
   return Array.isArray(value)
 }
diff --git a/packages/db-ivm/src/multiset.ts b/packages/db-ivm/src/multiset.ts
index 44ba297ed..601e948cf 100644
--- a/packages/db-ivm/src/multiset.ts
+++ b/packages/db-ivm/src/multiset.ts
@@ -2,8 +2,8 @@ import {
   DefaultMap,
   chunkedArrayPush,
   globalObjectIdGenerator,
-} from "./utils.js"
-import { hash } from "./hashing/index.js"
+} from './utils.js'
+import { hash } from './hashing/index.js'
 
 export type MultiSetArray<T> = Array<[T, number]>
 export type KeyedData<T> = [key: string, value: T]
@@ -35,7 +35,7 @@ export class MultiSet<T> {
    */
   map<U>(f: (data: T) => U): MultiSet<U> {
     return new MultiSet(
-      this.#inner.map(([data, multiplicity]) => [f(data), multiplicity])
+      this.#inner.map(([data, multiplicity]) => [f(data), multiplicity]),
     )
   }
 
@@ -51,7 +51,7 @@ export class MultiSet<T> {
    */
   negate(): MultiSet<T> {
     return new MultiSet(
-      this.#inner.map(([data, multiplicity]) => [data, -multiplicity])
+      this.#inner.map(([data, multiplicity]) => [data, -multiplicity]),
     )
   }
 
@@ -142,7 +142,7 @@ export class MultiSet<T> {
       const compositeKey = key + `|` + valueId
       consolidated.set(
         compositeKey,
-        (consolidated.get(compositeKey) || 0) + multiplicity
+        (consolidated.get(compositeKey) || 0) + multiplicity,
       )
 
       // Store the original data for the first occurrence
diff --git a/packages/db-ivm/src/operators/concat.ts b/packages/db-ivm/src/operators/concat.ts
index 075320842..6b4be4033 100644
--- a/packages/db-ivm/src/operators/concat.ts
+++ b/packages/db-ivm/src/operators/concat.ts
@@ -1,6 +1,6 @@
-import { BinaryOperator, DifferenceStreamWriter } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
+import { BinaryOperator, DifferenceStreamWriter } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
 
 /**
  * Operator that concatenates two input streams
@@ -22,7 +22,7 @@ export class ConcatOperator<T, T2> extends BinaryOperator<T | T2> {
  * @param other - The other stream to concatenate
  */
 export function concat<T, T2>(
-  other: IStreamBuilder<T2>
+  other: IStreamBuilder<T2>,
 ): PipedOperator<T, T | T2> {
   return (stream: IStreamBuilder<T | T2>): IStreamBuilder<T | T2> => {
     if (stream.graph !== other.graph) {
@@ -30,13 +30,13 @@ export function concat<T, T2>(
     }
     const output = new StreamBuilder<T | T2>(
       stream.graph,
-      new DifferenceStreamWriter<T | T2>()
+      new DifferenceStreamWriter<T | T2>(),
     )
     const operator = new ConcatOperator<T, T2>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       other.connectReader(),
-      output.writer
+      output.writer,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/consolidate.ts b/packages/db-ivm/src/operators/consolidate.ts
index cb3b3c492..b5356b4f4 100644
--- a/packages/db-ivm/src/operators/consolidate.ts
+++ b/packages/db-ivm/src/operators/consolidate.ts
@@ -1,7 +1,7 @@
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { MultiSet } from "../multiset.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { MultiSet } from '../multiset.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
 
 /**
  * Operator that consolidates collections
@@ -36,12 +36,12 @@ export function consolidate<T>(): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new ConsolidateOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
-      output.writer
+      output.writer,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/count.ts b/packages/db-ivm/src/operators/count.ts
index c54ed6234..0fa79b401 100644
--- a/packages/db-ivm/src/operators/count.ts
+++ b/packages/db-ivm/src/operators/count.ts
@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { ReduceOperator } from "./reduce.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { DifferenceStreamWriter } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { ReduceOperator } from './reduce.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 /**
  * Operator that counts elements by key (version-free)
@@ -11,7 +11,7 @@ export class CountOperator<K, V> extends ReduceOperator<K, V, number> {
   constructor(
     id: number,
     inputA: DifferenceStreamReader<[K, V]>,
-    output: DifferenceStreamWriter<[K, number]>
+    output: DifferenceStreamWriter<[K, number]>,
   ) {
     const countInner = (vals: Array<[V, number]>): Array<[number, number]> => {
       let totalCount = 0
@@ -34,16 +34,16 @@ export function count<
   T,
 >() {
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<KType, number>> => {
     const output = new StreamBuilder<KeyValue<KType, number>>(
       stream.graph,
-      new DifferenceStreamWriter<KeyValue<KType, number>>()
+      new DifferenceStreamWriter<KeyValue<KType, number>>(),
     )
     const operator = new CountOperator<KType, VType>(
       stream.graph.getNextOperatorId(),
       stream.connectReader() as DifferenceStreamReader<KeyValue<KType, VType>>,
-      output.writer
+      output.writer,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/debug.ts b/packages/db-ivm/src/operators/debug.ts
index 0d660c95f..56ca2177a 100644
--- a/packages/db-ivm/src/operators/debug.ts
+++ b/packages/db-ivm/src/operators/debug.ts
@@ -1,7 +1,7 @@
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
 
 /**
  * Operator that logs debug information about the stream
@@ -15,7 +15,7 @@ export class DebugOperator<T> extends UnaryOperator<T> {
     inputA: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<T>,
     name: string,
-    indent: boolean = false
+    indent: boolean = false,
   ) {
     super(id, inputA, output)
     this.#name = name
@@ -37,19 +37,19 @@ export class DebugOperator<T> extends UnaryOperator<T> {
  */
 export function debug<T>(
   name: string,
-  indent: boolean = false
+  indent: boolean = false,
 ): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new DebugOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
       name,
-      indent
+      indent,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/distinct.ts b/packages/db-ivm/src/operators/distinct.ts
index f1880858d..721f380c3 100644
--- a/packages/db-ivm/src/operators/distinct.ts
+++ b/packages/db-ivm/src/operators/distinct.ts
@@ -1,10 +1,10 @@
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { hash } from "../hashing/index.js"
-import { MultiSet } from "../multiset.js"
-import type { Hash } from "../hashing/index.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { hash } from '../hashing/index.js'
+import { MultiSet } from '../multiset.js'
+import type { Hash } from '../hashing/index.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 type Multiplicity = number
 
@@ -23,7 +23,7 @@ export class DistinctOperator<
     id: number,
     input: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<KeyValue<number, GetValue<T>>>,
-    by: (value: T) => any = (value: T) => value
+    by: (value: T) => any = (value: T) => value,
   ) {
     super(id, input, output)
     this.#by = by
@@ -83,18 +83,18 @@ export class DistinctOperator<
  * Removes duplicate values
  */
 export function distinct<T extends KeyValue<any, any>>(
-  by: (value: T) => any = (value: T) => value
+  by: (value: T) => any = (value: T) => value,
 ) {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new DistinctOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
-      by
+      by,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/filter.ts b/packages/db-ivm/src/operators/filter.ts
index b34777505..9e0fccf2a 100644
--- a/packages/db-ivm/src/operators/filter.ts
+++ b/packages/db-ivm/src/operators/filter.ts
@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter, LinearUnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that filters elements from the input stream
@@ -14,7 +14,7 @@ export class FilterOperator<T> extends LinearUnaryOperator<T, T> {
     id: number,
     inputA: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<T>,
-    f: (data: T) => boolean
+    f: (data: T) => boolean,
   ) {
     super(id, inputA, output)
     this.#f = f
@@ -33,13 +33,13 @@ export function filter<T>(f: (data: T) => boolean): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new FilterOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
-      f
+      f,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/filterBy.ts b/packages/db-ivm/src/operators/filterBy.ts
index d7129761f..3112c1d59 100644
--- a/packages/db-ivm/src/operators/filterBy.ts
+++ b/packages/db-ivm/src/operators/filterBy.ts
@@ -1,7 +1,7 @@
-import { map } from "./map.js"
-import { innerJoin } from "./join.js"
-import { consolidate } from "./consolidate.js"
-import type { IStreamBuilder, KeyValue, PipedOperator } from "../types.js"
+import { map } from './map.js'
+import { innerJoin } from './join.js'
+import { consolidate } from './consolidate.js'
+import type { IStreamBuilder, KeyValue, PipedOperator } from '../types.js'
 
 /**
  * Filters the elements of a keyed stream, by keys of another stream.
@@ -15,16 +15,16 @@ export function filterBy<
   V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, unknown>>
+  other: IStreamBuilder<KeyValue<K, unknown>>,
 ): PipedOperator<T, KeyValue<K, V1>> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<K, V1>> => {
     const otherKeys = other.pipe(
-      map(([key, _]) => [key, null] as KeyValue<K, null>)
+      map(([key, _]) => [key, null] as KeyValue<K, null>),
     )
     return stream.pipe(
       innerJoin(otherKeys),
       map(([key, [value, _]]) => [key, value] as KeyValue<K, V1>),
-      consolidate()
+      consolidate(),
     )
   }
 }
diff --git a/packages/db-ivm/src/operators/groupBy.ts b/packages/db-ivm/src/operators/groupBy.ts
index e931500e5..9c2fe1e35 100644
--- a/packages/db-ivm/src/operators/groupBy.ts
+++ b/packages/db-ivm/src/operators/groupBy.ts
@@ -1,6 +1,7 @@
-import { map } from "./map.js"
-import { reduce } from "./reduce.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { serializeValue } from '../utils.js'
+import { map } from './map.js'
+import { reduce } from './reduce.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 type GroupKey = Record<string, unknown>
 
@@ -26,7 +27,7 @@ type AggregatesReturnType<T, A> = {
 }
 
 function isPipedAggregateFunction<T, R>(
-  aggregate: AggregateFunction<T, R>
+  aggregate: AggregateFunction<T, R>,
 ): aggregate is PipedAggregateFunction<T, R> {
   return `pipe` in aggregate
 }
@@ -45,20 +46,20 @@ export function groupBy<
 
   const basicAggregates = Object.fromEntries(
     Object.entries(aggregates).filter(
-      ([_, aggregate]) => !isPipedAggregateFunction(aggregate)
-    )
+      ([_, aggregate]) => !isPipedAggregateFunction(aggregate),
+    ),
   ) as Record<string, BasicAggregateFunction<T, any, any>>
 
   // @ts-expect-error - TODO: we don't use this yet, but we will
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const pipedAggregates = Object.fromEntries(
     Object.entries(aggregates).filter(([_, aggregate]) =>
-      isPipedAggregateFunction(aggregate)
-    )
+      isPipedAggregateFunction(aggregate),
+    ),
   ) as Record<string, PipedAggregateFunction<T, any>>
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<string, ResultType>> => {
     // Special key to store the original key object
     const KEY_SENTINEL = `__original_key__`
@@ -67,7 +68,7 @@ export function groupBy<
     const withKeysAndValues = stream.pipe(
       map((data) => {
         const key = keyExtractor(data)
-        const keyString = JSON.stringify(key)
+        const keyString = serializeValue(key)
 
         // Create values object with pre-aggregated values
         const values: Record<string, unknown> = {}
@@ -81,7 +82,7 @@ export function groupBy<
         }
 
         return [keyString, values] as KeyValue<string, Record<string, unknown>>
-      })
+      }),
     )
 
     // Then reduce to compute aggregates
@@ -107,13 +108,13 @@ export function groupBy<
         // Apply each aggregate function
         for (const [name, aggregate] of Object.entries(basicAggregates)) {
           const preValues = values.map(
-            ([v, m]) => [v[name], m] as [any, number]
+            ([v, m]) => [v[name], m] as [any, number],
           )
           result[name] = aggregate.reduce(preValues)
         }
 
         return [[result, 1]]
-      })
+      }),
     )
 
     // Finally map to extract the key and include all values
@@ -139,7 +140,7 @@ export function groupBy<
 
         // Return with the string key instead of the object
         return [keyString, result] as KeyValue<string, ResultType>
-      })
+      }),
     )
   }
 }
@@ -148,7 +149,7 @@ export function groupBy<
  * Creates a sum aggregate function
  */
 export function sum<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, number> {
   return {
     preMap: (data: T) => valueExtractor(data),
@@ -166,7 +167,7 @@ export function sum<T>(
  * Creates a count aggregate function
  */
 export function count<T>(
-  valueExtractor: (value: T) => any = (v) => v
+  valueExtractor: (value: T) => any = (v) => v,
 ): AggregateFunction<T, number, number> {
   return {
     // Count only not-null values (the `== null` comparison gives true for both null and undefined)
@@ -185,7 +186,7 @@ export function count<T>(
  * Creates an average aggregate function
  */
 export function avg<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, { sum: number; count: number }> {
   return {
     preMap: (data: T) => ({
@@ -210,7 +211,7 @@ export function avg<T>(
   }
 }
 
-type CanMinMax = number | Date | bigint
+type CanMinMax = number | Date | bigint | string
 
 /**
  * Creates a min aggregate function that computes the minimum value in a group
@@ -222,10 +223,10 @@ export function min<T extends CanMinMax>(): AggregateFunction<
   T | undefined
 >
 export function min<T, V extends CanMinMax>(
-  valueExtractor: (value: T) => V
+  valueExtractor: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined>
 export function min<T, V extends CanMinMax>(
-  valueExtractor?: (value: T) => V
+  valueExtractor?: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined> {
   const extractor = valueExtractor ?? ((v: T) => v as unknown as V)
   return {
@@ -252,10 +253,10 @@ export function max<T extends CanMinMax>(): AggregateFunction<
   T | undefined
 >
 export function max<T, V extends CanMinMax>(
-  valueExtractor: (value: T) => V
+  valueExtractor: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined>
 export function max<T, V extends CanMinMax>(
-  valueExtractor?: (value: T) => V
+  valueExtractor?: (value: T) => V,
 ): AggregateFunction<T, V | undefined, V | undefined> {
   const extractor = valueExtractor ?? ((v: T) => v as unknown as V)
   return {
@@ -278,7 +279,7 @@ export function max<T, V extends CanMinMax>(
  * @param valueExtractor Function to extract a numeric value from each data entry
  */
 export function median<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, Array<number>> {
   return {
     preMap: (data: T) => [valueExtractor(data)],
@@ -326,7 +327,7 @@ export function median<T>(
  * @param valueExtractor Function to extract a value from each data entry
  */
 export function mode<T>(
-  valueExtractor: (value: T) => number = (v) => v as unknown as number
+  valueExtractor: (value: T) => number = (v) => v as unknown as number,
 ): AggregateFunction<T, number, Map<number, number>> {
   return {
     preMap: (data: T) => {
diff --git a/packages/db-ivm/src/operators/groupedOrderBy.ts b/packages/db-ivm/src/operators/groupedOrderBy.ts
new file mode 100644
index 000000000..901e05c7c
--- /dev/null
+++ b/packages/db-ivm/src/operators/groupedOrderBy.ts
@@ -0,0 +1,95 @@
+import { groupedTopKWithFractionalIndex } from './groupedTopKWithFractionalIndex.js'
+import { consolidate } from './consolidate.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
+
+export interface GroupedOrderByOptions<Ve> {
+  comparator?: (a: Ve, b: Ve) => number
+  limit?: number
+  offset?: number
+}
+
+export interface GroupedOrderByWithFractionalIndexOptions<
+  Ve,
+  KeyType = unknown,
+  ValueType = unknown,
+> extends GroupedOrderByOptions<Ve> {
+  setSizeCallback?: (getSize: () => number) => void
+  setWindowFn?: (
+    windowFn: (options: { offset?: number; limit?: number }) => void,
+  ) => void
+  /**
+   * Function to extract a group key from the element's key and value.
+   * Elements with the same group key will be sorted and limited together.
+   */
+  groupKeyFn: (key: KeyType, value: ValueType) => unknown
+}
+
+/**
+ * Orders the elements per group and limits the number of results per group, with optional offset and
+ * annotates the value with a fractional index.
+ * This requires a keyed stream, and uses the `groupedTopKWithFractionalIndex` operator to order elements within each group.
+ *
+ * Elements are grouped by the provided groupKeyFn, and each group maintains its own sorted collection
+ * with independent limit/offset.
+ *
+ * @param valueExtractor - A function that extracts the value to order by from the element
+ * @param options - Configuration including groupKeyFn, comparator, limit, and offset
+ * @returns A piped operator that orders the elements per group and limits the number of results per group
+ */
+export function groupedOrderByWithFractionalIndex<
+  T extends KeyValue<unknown, unknown>,
+  Ve = unknown,
+>(
+  valueExtractor: (
+    value: T extends KeyValue<unknown, infer V> ? V : never,
+  ) => Ve,
+  options: GroupedOrderByWithFractionalIndexOptions<
+    Ve,
+    T extends KeyValue<infer K, unknown> ? K : never,
+    T extends KeyValue<unknown, infer V> ? V : never
+  >,
+) {
+  type KeyType = T extends KeyValue<infer K, unknown> ? K : never
+  type ValueType = T extends KeyValue<unknown, infer V> ? V : never
+
+  const limit = options.limit ?? Infinity
+  const offset = options.offset ?? 0
+  const setSizeCallback = options.setSizeCallback
+  const setWindowFn = options.setWindowFn
+  const groupKeyFn = options.groupKeyFn
+  const comparator =
+    options.comparator ??
+    ((a, b) => {
+      // Default to JS like ordering
+      if (a === b) return 0
+      if (a < b) return -1
+      return 1
+    })
+
+  return (
+    stream: IStreamBuilder<T>,
+  ): IStreamBuilder<[KeyType, [ValueType, string]]> => {
+    // Cast to the expected key type for groupedTopKWithFractionalIndex
+    type StreamKey = KeyType extends string | number ? KeyType : string | number
+
+    return stream.pipe(
+      groupedTopKWithFractionalIndex<StreamKey, ValueType>(
+        (a: ValueType, b: ValueType) =>
+          comparator(valueExtractor(a), valueExtractor(b)),
+        {
+          limit,
+          offset,
+          setSizeCallback,
+          setWindowFn,
+          groupKeyFn: groupKeyFn as (
+            key: StreamKey,
+            value: ValueType,
+          ) => unknown,
+        },
+      ) as (
+        stream: IStreamBuilder<T>,
+      ) => IStreamBuilder<[KeyType, [ValueType, string]]>,
+      consolidate(),
+    )
+  }
+}
diff --git a/packages/db-ivm/src/operators/groupedTopKWithFractionalIndex.ts b/packages/db-ivm/src/operators/groupedTopKWithFractionalIndex.ts
new file mode 100644
index 000000000..47e7a309b
--- /dev/null
+++ b/packages/db-ivm/src/operators/groupedTopKWithFractionalIndex.ts
@@ -0,0 +1,192 @@
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { MultiSet } from '../multiset.js'
+import { TopKState, handleMoveIn, handleMoveOut } from './topKState.js'
+import { TopKArray, createKeyedComparator } from './topKArray.js'
+import type { IndexedValue, TopK } from './topKArray.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+
+export interface GroupedTopKWithFractionalIndexOptions<K, T> {
+  limit?: number
+  offset?: number
+  setSizeCallback?: (getSize: () => number) => void
+  setWindowFn?: (
+    windowFn: (options: { offset?: number; limit?: number }) => void,
+  ) => void
+  /**
+   * Function to extract a group key from the element's key and value.
+   * Elements with the same group key will be sorted and limited together.
+   */
+  groupKeyFn: (key: K, value: T) => unknown
+}
+
+/**
+ * Operator for grouped fractional indexed topK operations.
+ * This operator maintains separate topK windows for each group,
+ * allowing per-group limits and ordering.
+ *
+ * The input is a keyed stream [K, T] and outputs [K, IndexedValue<T>].
+ * Elements are grouped by the groupKeyFn, and each group maintains
+ * its own sorted collection with independent limit/offset.
+ */
+export class GroupedTopKWithFractionalIndexOperator<
+  K extends string | number,
+  T,
+> extends UnaryOperator<[K, T], [K, IndexedValue<T>]> {
+  #groupStates: Map<unknown, TopKState<K, T>> = new Map()
+  #groupKeyFn: (key: K, value: T) => unknown
+  #comparator: (a: [K, T], b: [K, T]) => number
+  #offset: number
+  #limit: number
+
+  constructor(
+    id: number,
+    inputA: DifferenceStreamReader<[K, T]>,
+    output: DifferenceStreamWriter<[K, IndexedValue<T>]>,
+    comparator: (a: T, b: T) => number,
+    options: GroupedTopKWithFractionalIndexOptions<K, T>,
+  ) {
+    super(id, inputA, output)
+    this.#groupKeyFn = options.groupKeyFn
+    this.#limit = options.limit ?? Infinity
+    this.#offset = options.offset ?? 0
+    this.#comparator = createKeyedComparator(comparator)
+    options.setSizeCallback?.(() => this.#getTotalSize())
+    options.setWindowFn?.(this.#moveTopK.bind(this))
+  }
+
+  /**
+   * Creates a new TopK data structure for a group.
+   * Can be overridden in subclasses to use different implementations (e.g., B+ tree).
+   */
+  protected createTopK(
+    offset: number,
+    limit: number,
+    comparator: (a: [K, T], b: [K, T]) => number,
+  ): TopK<[K, T]> {
+    return new TopKArray(offset, limit, comparator)
+  }
+
+  #getTotalSize(): number {
+    let size = 0
+    for (const state of this.#groupStates.values()) {
+      size += state.size
+    }
+    return size
+  }
+
+  #getOrCreateGroupState(groupKey: unknown): TopKState<K, T> {
+    let state = this.#groupStates.get(groupKey)
+    if (!state) {
+      const topK = this.createTopK(this.#offset, this.#limit, this.#comparator)
+      state = new TopKState(topK)
+      this.#groupStates.set(groupKey, state)
+    }
+    return state
+  }
+
+  #cleanupGroupIfEmpty(groupKey: unknown, state: TopKState<K, T>): void {
+    if (state.isEmpty) {
+      this.#groupStates.delete(groupKey)
+    }
+  }
+
+  /**
+   * Moves the topK window for all groups based on the provided offset and limit.
+   * Any changes to the topK are sent to the output.
+   */
+  #moveTopK({ offset, limit }: { offset?: number; limit?: number }): void {
+    if (offset !== undefined) {
+      this.#offset = offset
+    }
+    if (limit !== undefined) {
+      this.#limit = limit
+    }
+
+    const result: Array<[[K, IndexedValue<T>], number]> = []
+    let hasChanges = false
+
+    for (const state of this.#groupStates.values()) {
+      const diff = state.move({ offset: this.#offset, limit: this.#limit }) // TODO: think we should just pass offset and limit
+
+      diff.moveIns.forEach((moveIn) => handleMoveIn(moveIn, result))
+      diff.moveOuts.forEach((moveOut) => handleMoveOut(moveOut, result))
+
+      if (diff.changes) {
+        hasChanges = true
+      }
+    }
+
+    if (hasChanges) {
+      this.output.sendData(new MultiSet(result))
+    }
+  }
+
+  run(): void {
+    const result: Array<[[K, IndexedValue<T>], number]> = []
+    for (const message of this.inputMessages()) {
+      for (const [item, multiplicity] of message.getInner()) {
+        const [key, value] = item
+        this.#processElement(key, value, multiplicity, result)
+      }
+    }
+
+    if (result.length > 0) {
+      this.output.sendData(new MultiSet(result))
+    }
+  }
+
+  #processElement(
+    key: K,
+    value: T,
+    multiplicity: number,
+    result: Array<[[K, IndexedValue<T>], number]>,
+  ): void {
+    const groupKey = this.#groupKeyFn(key, value)
+    const state = this.#getOrCreateGroupState(groupKey)
+
+    const changes = state.processElement(key, value, multiplicity)
+    handleMoveIn(changes.moveIn, result)
+    handleMoveOut(changes.moveOut, result)
+
+    // Cleanup empty groups to prevent memory leaks
+    this.#cleanupGroupIfEmpty(groupKey, state)
+  }
+}
+
+/**
+ * Limits the number of results per group based on a comparator, with optional offset.
+ * Uses fractional indexing to minimize the number of changes when elements move positions.
+ * Each element is assigned a fractional index that is lexicographically sortable.
+ * When elements move, only the indices of the moved elements are updated, not all elements.
+ *
+ * This operator groups elements by the provided groupKeyFn and applies the limit/offset
+ * independently to each group.
+ *
+ * @param comparator - A function that compares two elements for ordering
+ * @param options - Configuration including groupKeyFn, limit, and offset
+ * @returns A piped operator that orders elements per group and limits results per group
+ */
+export function groupedTopKWithFractionalIndex<K extends string | number, T>(
+  comparator: (a: T, b: T) => number,
+  options: GroupedTopKWithFractionalIndexOptions<K, T>,
+): PipedOperator<[K, T], [K, IndexedValue<T>]> {
+  return (
+    stream: IStreamBuilder<[K, T]>,
+  ): IStreamBuilder<[K, IndexedValue<T>]> => {
+    const output = new StreamBuilder<[K, IndexedValue<T>]>(
+      stream.graph,
+      new DifferenceStreamWriter<[K, IndexedValue<T>]>(),
+    )
+    const operator = new GroupedTopKWithFractionalIndexOperator<K, T>(
+      stream.graph.getNextOperatorId(),
+      stream.connectReader(),
+      output.writer,
+      comparator,
+      options,
+    )
+    stream.graph.addOperator(operator)
+    return output
+  }
+}
diff --git a/packages/db-ivm/src/operators/index.ts b/packages/db-ivm/src/operators/index.ts
index f7619dc28..13acf130b 100644
--- a/packages/db-ivm/src/operators/index.ts
+++ b/packages/db-ivm/src/operators/index.ts
@@ -1,19 +1,21 @@
-export * from "./pipe.js"
-export * from "./map.js"
-export * from "./tap.js"
-export * from "./filter.js"
-export * from "./negate.js"
-export * from "./concat.js"
-export * from "./debug.js"
-export * from "./output.js"
-export * from "./consolidate.js"
-export * from "./join.js"
-export * from "./reduce.js"
-export * from "./count.js"
-export * from "./distinct.js"
-export * from "./keying.js"
-export * from "./topK.js"
-export * from "./topKWithFractionalIndex.js"
-export * from "./orderBy.js"
-export * from "./filterBy.js"
-export { groupBy, groupByOperators } from "./groupBy.js"
+export * from './pipe.js'
+export * from './map.js'
+export * from './tap.js'
+export * from './filter.js'
+export * from './negate.js'
+export * from './concat.js'
+export * from './debug.js'
+export * from './output.js'
+export * from './consolidate.js'
+export * from './join.js'
+export * from './reduce.js'
+export * from './count.js'
+export * from './distinct.js'
+export * from './keying.js'
+export * from './topK.js'
+export * from './topKWithFractionalIndex.js'
+export * from './groupedTopKWithFractionalIndex.js'
+export * from './orderBy.js'
+export * from './groupedOrderBy.js'
+export * from './filterBy.js'
+export { groupBy, groupByOperators } from './groupBy.js'
diff --git a/packages/db-ivm/src/operators/join.ts b/packages/db-ivm/src/operators/join.ts
index 36f710b2f..58b62620f 100644
--- a/packages/db-ivm/src/operators/join.ts
+++ b/packages/db-ivm/src/operators/join.ts
@@ -48,12 +48,12 @@
  * - **Bag semantics**: Proper multiplicity handling including negatives
  */
 
-import { BinaryOperator, DifferenceStreamWriter } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { MultiSet } from "../multiset.js"
-import { Index } from "../indexes.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { IStreamBuilder, KeyValue, PipedOperator } from "../types.js"
+import { BinaryOperator, DifferenceStreamWriter } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { MultiSet } from '../multiset.js'
+import { Index } from '../indexes.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, KeyValue, PipedOperator } from '../types.js'
 
 /**
  * Type of join to perform
@@ -75,7 +75,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
     inputA: DifferenceStreamReader<[K, V1]>,
     inputB: DifferenceStreamReader<[K, V2]>,
     output: DifferenceStreamWriter<any>,
-    mode: JoinType = `inner`
+    mode: JoinType = `inner`,
   ) {
     super(id, inputA, inputB, output)
     this.#mode = mode
@@ -84,10 +84,10 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   run(): void {
     // Build deltas from input messages
     const deltaA = Index.fromMultiSets<K, V1>(
-      this.inputAMessages() as Array<MultiSet<[K, V1]>>
+      this.inputAMessages() as Array<MultiSet<[K, V1]>>,
     )
     const deltaB = Index.fromMultiSets<K, V2>(
-      this.inputBMessages() as Array<MultiSet<[K, V2]>>
+      this.inputBMessages() as Array<MultiSet<[K, V2]>>,
     )
 
     // Early-out if nothing changed
@@ -130,7 +130,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   private emitInnerResults(
     deltaA: Index<K, V1>,
     deltaB: Index<K, V2>,
-    results: MultiSet<any>
+    results: MultiSet<any>,
   ): void {
     // Emit the three standard delta terms: ΔA⋈B_old, A_old⋈ΔB, ΔA⋈ΔB
     if (deltaA.size > 0) results.extend(deltaA.join(this.#indexB))
@@ -141,7 +141,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   private emitLeftOuterResults(
     deltaA: Index<K, V1>,
     deltaB: Index<K, V2>,
-    results: MultiSet<any>
+    results: MultiSet<any>,
   ): void {
     // Emit unmatched left rows from deltaA
     if (deltaA.size > 0) {
@@ -184,7 +184,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
           if (multiplicity !== 0) {
             results.add(
               [key, [value, null]],
-              transitioningToMatched ? -multiplicity : +multiplicity
+              transitioningToMatched ? -multiplicity : +multiplicity,
             )
           }
         }
@@ -195,7 +195,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   private emitRightOuterResults(
     deltaA: Index<K, V1>,
     deltaB: Index<K, V2>,
-    results: MultiSet<any>
+    results: MultiSet<any>,
   ): void {
     // Emit unmatched right rows from deltaB
     if (deltaB.size > 0) {
@@ -238,7 +238,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
           if (multiplicity !== 0) {
             results.add(
               [key, [null, value]],
-              transitioningToMatched ? -multiplicity : +multiplicity
+              transitioningToMatched ? -multiplicity : +multiplicity,
             )
           }
         }
@@ -259,24 +259,24 @@ export function join<
   T,
 >(
   other: IStreamBuilder<KeyValue<K, V2>>,
-  type: JoinType = `inner`
+  type: JoinType = `inner`,
 ): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<K, [V1 | null, V2 | null]>> => {
     if (stream.graph !== other.graph) {
       throw new Error(`Cannot join streams from different graphs`)
     }
     const output = new StreamBuilder<KeyValue<K, [V1 | null, V2 | null]>>(
       stream.graph,
-      new DifferenceStreamWriter<KeyValue<K, [V1 | null, V2 | null]>>()
+      new DifferenceStreamWriter<KeyValue<K, [V1 | null, V2 | null]>>(),
     )
     const operator = new JoinOperator<K, V1, V2>(
       stream.graph.getNextOperatorId(),
       stream.connectReader() as DifferenceStreamReader<KeyValue<K, V1>>,
       other.connectReader(),
       output.writer,
-      type
+      type,
     )
     stream.graph.addOperator(operator)
     return output
@@ -293,7 +293,7 @@ export function innerJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1, V2]>> {
   return join(other, `inner`) as unknown as PipedOperator<
     T,
@@ -311,7 +311,7 @@ export function antiJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1, null]>> {
   return join(other, `anti`) as unknown as PipedOperator<
     T,
@@ -329,7 +329,7 @@ export function leftJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1, V2 | null]>> {
   return join(other, `left`) as unknown as PipedOperator<
     T,
@@ -347,7 +347,7 @@ export function rightJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1 | null, V2]>> {
   return join(other, `right`) as unknown as PipedOperator<
     T,
@@ -365,7 +365,7 @@ export function fullJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {
   return join(other, `full`) as unknown as PipedOperator<
     T,
diff --git a/packages/db-ivm/src/operators/keying.ts b/packages/db-ivm/src/operators/keying.ts
index 62b67d7a1..e4387445e 100644
--- a/packages/db-ivm/src/operators/keying.ts
+++ b/packages/db-ivm/src/operators/keying.ts
@@ -1,5 +1,5 @@
-import { map } from "./map.js"
-import type { PipedOperator } from "../types.js"
+import { map } from './map.js'
+import type { PipedOperator } from '../types.js'
 
 /**
  * Type for a keyed value
@@ -11,7 +11,7 @@ export type Keyed<K, V> = [K, V]
  * @param keyFn - Function to generate the key for each value
  */
 export function keyBy<T, K>(
-  keyFn: (value: T) => K
+  keyFn: (value: T) => K,
 ): PipedOperator<T, Keyed<K, T>> {
   return map((value: T): Keyed<K, T> => [keyFn(value), value])
 }
@@ -28,7 +28,7 @@ export function unkey<K, V>(): PipedOperator<Keyed<K, V>, V> {
  * @param keyFn - Function to generate the new key for each value
  */
 export function rekey<K1, K2, V>(
-  keyFn: (value: V) => K2
+  keyFn: (value: V) => K2,
 ): PipedOperator<Keyed<K1, V>, Keyed<K2, V>> {
   return map(([_, value]: Keyed<K1, V>): Keyed<K2, V> => [keyFn(value), value])
 }
diff --git a/packages/db-ivm/src/operators/map.ts b/packages/db-ivm/src/operators/map.ts
index 2aed5b1f0..a136155b6 100644
--- a/packages/db-ivm/src/operators/map.ts
+++ b/packages/db-ivm/src/operators/map.ts
@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter, LinearUnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that applies a function to each element in the input stream
@@ -14,7 +14,7 @@ export class MapOperator<T, U> extends LinearUnaryOperator<T, U> {
     id: number,
     inputA: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<U>,
-    f: (data: T) => U
+    f: (data: T) => U,
   ) {
     super(id, inputA, output)
     this.#f = f
@@ -33,13 +33,13 @@ export function map<T, O>(f: (data: T) => O): PipedOperator<T, O> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<O> => {
     const output = new StreamBuilder<O>(
       stream.graph,
-      new DifferenceStreamWriter<O>()
+      new DifferenceStreamWriter<O>(),
     )
     const operator = new MapOperator<T, O>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
-      f
+      f,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/negate.ts b/packages/db-ivm/src/operators/negate.ts
index 8962c210f..d45029aba 100644
--- a/packages/db-ivm/src/operators/negate.ts
+++ b/packages/db-ivm/src/operators/negate.ts
@@ -1,7 +1,7 @@
-import { DifferenceStreamWriter, LinearUnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that negates the multiplicities in the input stream
@@ -19,12 +19,12 @@ export function negate<T>(): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new NegateOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
-      output.writer
+      output.writer,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/orderBy.ts b/packages/db-ivm/src/operators/orderBy.ts
index ce399b3bc..0bf7c4bef 100644
--- a/packages/db-ivm/src/operators/orderBy.ts
+++ b/packages/db-ivm/src/operators/orderBy.ts
@@ -1,9 +1,9 @@
-import { topK, topKWithIndex } from "./topK.js"
-import { topKWithFractionalIndex } from "./topKWithFractionalIndex.js"
-import { map } from "./map.js"
-import { innerJoin } from "./join.js"
-import { consolidate } from "./consolidate.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { topK, topKWithIndex } from './topK.js'
+import { topKWithFractionalIndex } from './topKWithFractionalIndex.js'
+import { map } from './map.js'
+import { innerJoin } from './join.js'
+import { consolidate } from './consolidate.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 export interface OrderByOptions<Ve> {
   comparator?: (a: Ve, b: Ve) => number
@@ -14,7 +14,7 @@ export interface OrderByOptions<Ve> {
 type OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {
   setSizeCallback?: (getSize: () => number) => void
   setWindowFn?: (
-    windowFn: (options: { offset?: number; limit?: number }) => void
+    windowFn: (options: { offset?: number; limit?: number }) => void,
   ) => void
 }
 
@@ -28,9 +28,9 @@ type OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {
  */
 export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByOptions<Ve>
+  options?: OrderByOptions<Ve>,
 ) {
   const limit = options?.limit ?? Infinity
   const offset = options?.offset ?? 0
@@ -54,10 +54,10 @@ export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
             [
               key,
               valueExtractor(
-                value as T extends KeyValue<unknown, infer V> ? V : never
+                value as T extends KeyValue<unknown, infer V> ? V : never,
               ),
             ],
-          ] as KeyValue<null, [KeyType, Ve]>
+          ] as KeyValue<null, [KeyType, Ve]>,
       ),
       topK((a, b) => comparator(a[1], b[1]), { limit, offset }),
       map(([_, [key]]) => [key, null] as KeyValue<KeyType, null>),
@@ -65,7 +65,7 @@ export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
       map(([key, value]) => {
         return [key, value[1]] as T
       }),
-      consolidate()
+      consolidate(),
     )
   }
 }
@@ -84,9 +84,9 @@ export function orderByWithIndex<
   Ve = unknown,
 >(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByOptions<Ve>
+  options?: OrderByOptions<Ve>,
 ) {
   const limit = options?.limit ?? Infinity
   const offset = options?.offset ?? 0
@@ -100,7 +100,7 @@ export function orderByWithIndex<
     })
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<
     KeyValue<
       T extends KeyValue<infer K, unknown> ? K : never,
@@ -118,10 +118,10 @@ export function orderByWithIndex<
             [
               key,
               valueExtractor(
-                value as T extends KeyValue<unknown, infer V> ? V : never
+                value as T extends KeyValue<unknown, infer V> ? V : never,
               ),
             ],
-          ] as KeyValue<null, [KeyType, Ve]>
+          ] as KeyValue<null, [KeyType, Ve]>,
       ),
       topKWithIndex((a, b) => comparator(a[1], b[1]), { limit, offset }),
       map(([_, [[key], index]]) => [key, index] as KeyValue<KeyType, number>),
@@ -129,7 +129,7 @@ export function orderByWithIndex<
       map(([key, [index, value]]) => {
         return [key, [value, index]] as KeyValue<KeyType, [ValueType, number]>
       }),
-      consolidate()
+      consolidate(),
     )
   }
 }
@@ -140,9 +140,9 @@ export function orderByWithFractionalIndexBase<
 >(
   topKFunction: typeof topKWithFractionalIndex,
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByWithFractionalIndexOptions<Ve>
+  options?: OrderByWithFractionalIndexOptions<Ve>,
 ) {
   type KeyType = T extends KeyValue<infer K, unknown> ? K : never
   type ValueType = T extends KeyValue<unknown, infer V> ? V : never
@@ -161,7 +161,7 @@ export function orderByWithFractionalIndexBase<
     })
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<[KeyType, [ValueType, string]]> => {
     return stream.pipe(
       topKFunction(
@@ -172,9 +172,9 @@ export function orderByWithFractionalIndexBase<
           offset,
           setSizeCallback,
           setWindowFn,
-        }
+        },
       ),
-      consolidate()
+      consolidate(),
     )
   }
 }
@@ -193,13 +193,13 @@ export function orderByWithFractionalIndex<
   Ve = unknown,
 >(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByWithFractionalIndexOptions<Ve>
+  options?: OrderByWithFractionalIndexOptions<Ve>,
 ) {
   return orderByWithFractionalIndexBase(
     topKWithFractionalIndex,
     valueExtractor,
-    options
+    options,
   )
 }
diff --git a/packages/db-ivm/src/operators/orderByBTree.ts b/packages/db-ivm/src/operators/orderByBTree.ts
index a933f1cf4..db95b2dea 100644
--- a/packages/db-ivm/src/operators/orderByBTree.ts
+++ b/packages/db-ivm/src/operators/orderByBTree.ts
@@ -1,20 +1,20 @@
-import { orderByWithFractionalIndexBase } from "./orderBy.js"
-import { topKWithFractionalIndexBTree } from "./topKWithFractionalIndexBTree.js"
-import type { KeyValue } from "../types.js"
-import type { OrderByOptions } from "./orderBy.js"
+import { orderByWithFractionalIndexBase } from './orderBy.js'
+import { topKWithFractionalIndexBTree } from './topKWithFractionalIndexBTree.js'
+import type { KeyValue } from '../types.js'
+import type { OrderByOptions } from './orderBy.js'
 
 export function orderByWithFractionalIndexBTree<
   T extends KeyValue<unknown, unknown>,
   Ve = unknown,
 >(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByOptions<Ve>
+  options?: OrderByOptions<Ve>,
 ) {
   return orderByWithFractionalIndexBase(
     topKWithFractionalIndexBTree,
     valueExtractor,
-    options
+    options,
   )
 }
diff --git a/packages/db-ivm/src/operators/output.ts b/packages/db-ivm/src/operators/output.ts
index 5217b3d66..2e9795e86 100644
--- a/packages/db-ivm/src/operators/output.ts
+++ b/packages/db-ivm/src/operators/output.ts
@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that outputs the messages in the stream
@@ -14,7 +14,7 @@ export class OutputOperator<T> extends UnaryOperator<T> {
     id: number,
     inputA: DifferenceStreamReader<T>,
     outputWriter: DifferenceStreamWriter<T>,
-    fn: (data: MultiSet<T>) => void
+    fn: (data: MultiSet<T>) => void,
   ) {
     super(id, inputA, outputWriter)
     this.#fn = fn
@@ -33,18 +33,18 @@ export class OutputOperator<T> extends UnaryOperator<T> {
  * @param fn - The function to call with each message
  */
 export function output<T>(
-  fn: (data: MultiSet<T>) => void
+  fn: (data: MultiSet<T>) => void,
 ): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const outputStream = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new OutputOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       outputStream.writer,
-      fn
+      fn,
     )
     stream.graph.addOperator(operator)
     return outputStream
diff --git a/packages/db-ivm/src/operators/pipe.ts b/packages/db-ivm/src/operators/pipe.ts
index 68b2ba954..87efbe3ed 100644
--- a/packages/db-ivm/src/operators/pipe.ts
+++ b/packages/db-ivm/src/operators/pipe.ts
@@ -1,4 +1,4 @@
-import type { IStreamBuilder, PipedOperator } from "../types.js"
+import type { IStreamBuilder, PipedOperator } from '../types.js'
 
 // Don't judge, this is the only way to type this function.
 // rxjs has very similar code to type its pipe function
diff --git a/packages/db-ivm/src/operators/reduce.ts b/packages/db-ivm/src/operators/reduce.ts
index 4301dced5..3a8690e01 100644
--- a/packages/db-ivm/src/operators/reduce.ts
+++ b/packages/db-ivm/src/operators/reduce.ts
@@ -1,9 +1,9 @@
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { MultiSet } from "../multiset.js"
-import { Index } from "../indexes.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { MultiSet } from '../multiset.js'
+import { Index } from '../indexes.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 /**
  * Base operator for reduction operations (version-free)
@@ -17,7 +17,7 @@ export class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {
     id: number,
     inputA: DifferenceStreamReader<[K, V1]>,
     output: DifferenceStreamWriter<[K, V2]>,
-    f: (values: Array<[V1, number]>) => Array<[V2, number]>
+    f: (values: Array<[V1, number]>) => Array<[V2, number]>,
   ) {
     super(id, inputA, output)
     this.#f = f
@@ -109,13 +109,13 @@ export function reduce<
   return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<KType, R>> => {
     const output = new StreamBuilder<KeyValue<KType, R>>(
       stream.graph,
-      new DifferenceStreamWriter<KeyValue<KType, R>>()
+      new DifferenceStreamWriter<KeyValue<KType, R>>(),
     )
     const operator = new ReduceOperator<KType, V1Type, R>(
       stream.graph.getNextOperatorId(),
       stream.connectReader() as DifferenceStreamReader<KeyValue<KType, V1Type>>,
       output.writer,
-      f
+      f,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/tap.ts b/packages/db-ivm/src/operators/tap.ts
index 20c59fd5a..a6fb09e9f 100644
--- a/packages/db-ivm/src/operators/tap.ts
+++ b/packages/db-ivm/src/operators/tap.ts
@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter, LinearUnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that applies a function to each multi-set in the input stream
@@ -14,7 +14,7 @@ export class TapOperator<T> extends LinearUnaryOperator<T, T> {
     id: number,
     inputA: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<T>,
-    f: (data: MultiSet<T>) => void
+    f: (data: MultiSet<T>) => void,
   ) {
     super(id, inputA, output)
     this.#f = f
@@ -36,13 +36,13 @@ export function tap<T>(f: (data: MultiSet<T>) => void): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new TapOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
-      f
+      f,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/operators/topK.ts b/packages/db-ivm/src/operators/topK.ts
index 77aae1bc2..6ff21d888 100644
--- a/packages/db-ivm/src/operators/topK.ts
+++ b/packages/db-ivm/src/operators/topK.ts
@@ -1,6 +1,6 @@
-import { MultiSet } from "../multiset.js"
-import { reduce } from "./reduce.js"
-import type { IStreamBuilder, KeyValue, PipedOperator } from "../types"
+import { MultiSet } from '../multiset.js'
+import { reduce } from './reduce.js'
+import type { IStreamBuilder, KeyValue, PipedOperator } from '../types'
 
 interface TopKOptions {
   limit?: number
@@ -24,7 +24,7 @@ export function topK<
   T,
 >(
   comparator: (a: V1Type, b: V1Type) => number,
-  options?: TopKOptions
+  options?: TopKOptions,
 ): PipedOperator<T, T> {
   const limit = options?.limit ?? Infinity
   const offset = options?.offset ?? 0
@@ -38,7 +38,7 @@ export function topK<
           .getInner()
           .sort((a, b) => comparator(a[0] as V1Type, b[0] as V1Type))
         return sortedValues.slice(offset, offset + limit)
-      })
+      }),
     )
     return reduced as IStreamBuilder<T>
   }
@@ -62,13 +62,13 @@ export function topKWithIndex<
   T,
 >(
   comparator: (a: V1Type, b: V1Type) => number,
-  options?: TopKOptions
+  options?: TopKOptions,
 ): PipedOperator<T, KeyValue<KType, [V1Type, number]>> {
   const limit = options?.limit ?? Infinity
   const offset = options?.offset ?? 0
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<KType, [V1Type, number]>> => {
     const reduced = stream.pipe(
       reduce<KType, V1Type, [V1Type, number], T>((values) => {
@@ -84,7 +84,7 @@ export function topKWithIndex<
             multiplicity,
           ])
         return sortedValues
-      })
+      }),
     )
     return reduced
   }
diff --git a/packages/db-ivm/src/operators/topKArray.ts b/packages/db-ivm/src/operators/topKArray.ts
new file mode 100644
index 000000000..e78bd5bce
--- /dev/null
+++ b/packages/db-ivm/src/operators/topKArray.ts
@@ -0,0 +1,255 @@
+import { generateKeyBetween } from 'fractional-indexing'
+import { binarySearch, compareKeys, diffHalfOpen } from '../utils.js'
+import type { HRange } from '../utils.js'
+
+// Abstraction for fractionally indexed values
+export type FractionalIndex = string
+export type IndexedValue<V> = [V, FractionalIndex]
+
+export function indexedValue<V>(
+  value: V,
+  index: FractionalIndex,
+): IndexedValue<V> {
+  return [value, index]
+}
+
+export function getValue<V>(indexedVal: IndexedValue<V>): V {
+  return indexedVal[0]
+}
+
+export function getIndex<V>(indexedVal: IndexedValue<V>): FractionalIndex {
+  return indexedVal[1]
+}
+
+/**
+ * Creates a comparator for [key, value] tuples that first compares values,
+ * then uses the row key as a stable tie-breaker.
+ */
+export function createKeyedComparator<K extends string | number, T>(
+  comparator: (a: T, b: T) => number,
+): (a: [K, T], b: [K, T]) => number {
+  return ([aKey, aVal], [bKey, bVal]) => {
+    // First compare on the value
+    const valueComparison = comparator(aVal, bVal)
+    if (valueComparison !== 0) {
+      return valueComparison
+    }
+    // If the values are equal, use the row key as tie-breaker
+    // This provides stable, deterministic ordering since keys are string | number
+    return compareKeys(aKey, bKey)
+  }
+}
+
+export type TopKChanges<V> = {
+  /** Indicates which element moves into the topK (if any) */
+  moveIn: IndexedValue<V> | null
+  /** Indicates which element moves out of the topK (if any) */
+  moveOut: IndexedValue<V> | null
+}
+
+export type TopKMoveChanges<V> = {
+  /** Flag that marks whether there were any changes to the topK */
+  changes: boolean
+  /** Indicates which elements move into the topK (if any) */
+  moveIns: Array<IndexedValue<V>>
+  /** Indicates which elements move out of the topK (if any) */
+  moveOuts: Array<IndexedValue<V>>
+}
+
+/**
+ * A topK data structure that supports insertions and deletions
+ * and returns changes to the topK.
+ */
+export interface TopK<V> {
+  size: number
+  insert: (value: V) => TopKChanges<V>
+  delete: (value: V) => TopKChanges<V>
+}
+
+/**
+ * Implementation of a topK data structure.
+ * Uses a sorted array internally to store the values and keeps a topK window over that array.
+ * Inserts and deletes are O(n) operations because worst case an element is inserted/deleted
+ * at the start of the array which causes all the elements to shift to the right/left.
+ */
+export class TopKArray<V> implements TopK<V> {
+  #sortedValues: Array<IndexedValue<V>> = []
+  #comparator: (a: V, b: V) => number
+  #topKStart: number
+  #topKEnd: number
+
+  constructor(
+    offset: number,
+    limit: number,
+    comparator: (a: V, b: V) => number,
+  ) {
+    this.#topKStart = offset
+    this.#topKEnd = offset + limit
+    this.#comparator = comparator
+  }
+
+  get size(): number {
+    const offset = this.#topKStart
+    const limit = this.#topKEnd - this.#topKStart
+    const available = this.#sortedValues.length - offset
+    return Math.max(0, Math.min(limit, available))
+  }
+
+  /**
+   * Moves the topK window
+   */
+  move({
+    offset,
+    limit,
+  }: {
+    offset?: number
+    limit?: number
+  }): TopKMoveChanges<V> {
+    const oldOffset = this.#topKStart
+    const oldLimit = this.#topKEnd - this.#topKStart
+
+    // `this.#topKEnd` can be `Infinity` if it has no limit
+    // but `diffHalfOpen` expects a finite range
+    // so we restrict it to the size of the topK if topKEnd is infinite
+    const oldRange: HRange = [
+      this.#topKStart,
+      this.#topKEnd === Infinity ? this.#topKStart + this.size : this.#topKEnd,
+    ]
+
+    this.#topKStart = offset ?? oldOffset
+    this.#topKEnd = this.#topKStart + (limit ?? oldLimit) // can be `Infinity` if limit is `Infinity`
+
+    // Also handle `Infinity` in the newRange
+    const newRange: HRange = [
+      this.#topKStart,
+      this.#topKEnd === Infinity
+        ? Math.max(this.#topKStart + this.size, oldRange[1]) // since the new limit is Infinity we need to take everything (so we need to take the biggest (finite) topKEnd)
+        : this.#topKEnd,
+    ]
+    const { onlyInA, onlyInB } = diffHalfOpen(oldRange, newRange)
+
+    const moveIns: Array<IndexedValue<V>> = []
+    onlyInB.forEach((index) => {
+      const value = this.#sortedValues[index]
+      if (value) {
+        moveIns.push(value)
+      }
+    })
+
+    const moveOuts: Array<IndexedValue<V>> = []
+    onlyInA.forEach((index) => {
+      const value = this.#sortedValues[index]
+      if (value) {
+        moveOuts.push(value)
+      }
+    })
+
+    // It could be that there are changes (i.e. moveIns or moveOuts)
+    // but that the collection is lazy so we don't have the data yet that needs to move in/out
+    // so `moveIns` and `moveOuts` will be empty but `changes` will be true
+    // this will tell the caller that it needs to run the graph to load more data
+    return { moveIns, moveOuts, changes: onlyInA.length + onlyInB.length > 0 }
+  }
+
+  insert(value: V): TopKChanges<V> {
+    const result: TopKChanges<V> = { moveIn: null, moveOut: null }
+
+    // Lookup insert position
+    const index = this.#findIndex(value)
+    // Generate fractional index based on the fractional indices of the elements before and after it
+    const indexBefore =
+      index === 0 ? null : getIndex(this.#sortedValues[index - 1]!)
+    const indexAfter =
+      index === this.#sortedValues.length
+        ? null
+        : getIndex(this.#sortedValues[index]!)
+    const fractionalIndex = generateKeyBetween(indexBefore, indexAfter)
+
+    // Insert the value at the correct position
+    const val = indexedValue(value, fractionalIndex)
+    // Splice is O(n) where n = all elements in the collection (i.e. n >= k) !
+    this.#sortedValues.splice(index, 0, val)
+
+    // Check if the topK changed
+    if (index < this.#topKEnd) {
+      // The inserted element is either before the top K or within the top K
+      // If it is before the top K then it moves the element that was right before the topK into the topK
+      // If it is within the top K then the inserted element moves into the top K
+      // In both cases the last element of the old top K now moves out of the top K
+      const moveInIndex = Math.max(index, this.#topKStart)
+      if (moveInIndex < this.#sortedValues.length) {
+        // We actually have a topK
+        // because in some cases there may not be enough elements in the array to reach the start of the topK
+        // e.g. [1, 2, 3] with K = 2 and offset = 3 does not have a topK
+        result.moveIn = this.#sortedValues[moveInIndex]!
+
+        // We need to remove the element that falls out of the top K
+        // The element that falls out of the top K has shifted one to the right
+        // because of the element we inserted, so we find it at index topKEnd
+        if (this.#topKEnd < this.#sortedValues.length) {
+          result.moveOut = this.#sortedValues[this.#topKEnd]!
+        }
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Deletes a value that may or may not be in the topK.
+   * IMPORTANT: this assumes that the value is present in the collection
+   *            if it's not the case it will remove the element
+   *            that is on the position where the provided `value` would be.
+   */
+  delete(value: V): TopKChanges<V> {
+    const result: TopKChanges<V> = { moveIn: null, moveOut: null }
+
+    // Lookup delete position
+    const index = this.#findIndex(value)
+    // Remove the value at that position
+    const [removedElem] = this.#sortedValues.splice(index, 1)
+
+    // Check if the topK changed
+    if (index < this.#topKEnd) {
+      // The removed element is either before the top K or within the top K
+      // If it is before the top K then the first element of the topK moves out of the topK
+      // If it is within the top K then the removed element moves out of the topK
+      result.moveOut = removedElem!
+      if (index < this.#topKStart) {
+        // The removed element is before the topK
+        // so actually, the first element of the topK moves out of the topK
+        // and not the element that we removed
+        // The first element of the topK is now at index topKStart - 1
+        // since we removed an element before the topK
+        const moveOutIndex = this.#topKStart - 1
+        if (moveOutIndex < this.#sortedValues.length) {
+          result.moveOut = this.#sortedValues[moveOutIndex]!
+        } else {
+          // No value is moving out of the topK
+          // because there are no elements in the topK
+          result.moveOut = null
+        }
+      }
+
+      // Since we removed an element that was before or in the topK
+      // the first element after the topK moved one position to the left
+      // and thus falls into the topK now
+      const moveInIndex = this.#topKEnd - 1
+      if (moveInIndex < this.#sortedValues.length) {
+        result.moveIn = this.#sortedValues[moveInIndex]!
+      }
+    }
+
+    return result
+  }
+
+  // TODO: see if there is a way to refactor the code for insert and delete in the topK above
+  //       because they are very similar, one is shifting the topK window to the left and the other is shifting it to the right
+  //       so i have the feeling there is a common pattern here and we can implement both cases using that pattern
+
+  #findIndex(value: V): number {
+    return binarySearch(this.#sortedValues, indexedValue(value, ``), (a, b) =>
+      this.#comparator(getValue(a), getValue(b)),
+    )
+  }
+}
diff --git a/packages/db-ivm/src/operators/topKState.ts b/packages/db-ivm/src/operators/topKState.ts
new file mode 100644
index 000000000..e5dadd213
--- /dev/null
+++ b/packages/db-ivm/src/operators/topKState.ts
@@ -0,0 +1,111 @@
+import { TopKArray } from './topKArray.js'
+import type {
+  IndexedValue,
+  TopK,
+  TopKChanges,
+  TopKMoveChanges,
+} from './topKArray.js'
+
+/**
+ * Helper class that manages the state for a single topK window.
+ * Encapsulates the multiplicity tracking and topK data structure,
+ * providing a clean interface for processing elements and moving the window.
+ *
+ * This class is used by both TopKWithFractionalIndexOperator (single instance)
+ * and GroupedTopKWithFractionalIndexOperator (one instance per group).
+ */
+export class TopKState<K extends string | number, T> {
+  #multiplicities: Map<K, number> = new Map()
+  #topK: TopK<[K, T]>
+
+  constructor(topK: TopK<[K, T]>) {
+    this.#topK = topK
+  }
+
+  get size(): number {
+    return this.#topK.size
+  }
+
+  get isEmpty(): boolean {
+    return this.#multiplicities.size === 0 && this.#topK.size === 0
+  }
+
+  /**
+   * Process an element update (insert or delete based on multiplicity change).
+   * Returns the changes to the topK window.
+   */
+  processElement(key: K, value: T, multiplicity: number): TopKChanges<[K, T]> {
+    const { oldMultiplicity, newMultiplicity } = this.#updateMultiplicity(
+      key,
+      multiplicity,
+    )
+
+    if (oldMultiplicity <= 0 && newMultiplicity > 0) {
+      // The value was invisible but should now be visible
+      return this.#topK.insert([key, value])
+    } else if (oldMultiplicity > 0 && newMultiplicity <= 0) {
+      // The value was visible but should now be invisible
+      return this.#topK.delete([key, value])
+    }
+    // The value was invisible and remains invisible,
+    // or was visible and remains visible - no topK change
+    return { moveIn: null, moveOut: null }
+  }
+
+  /**
+   * Move the topK window. Only works with TopKArray implementation.
+   */
+  move(options: { offset?: number; limit?: number }): TopKMoveChanges<[K, T]> {
+    if (!(this.#topK instanceof TopKArray)) {
+      throw new Error(
+        `Cannot move B+-tree implementation of TopK with fractional index`,
+      )
+    }
+    return this.#topK.move(options)
+  }
+
+  #updateMultiplicity(
+    key: K,
+    multiplicity: number,
+  ): { oldMultiplicity: number; newMultiplicity: number } {
+    if (multiplicity === 0) {
+      const current = this.#multiplicities.get(key) ?? 0
+      return { oldMultiplicity: current, newMultiplicity: current }
+    }
+
+    const oldMultiplicity = this.#multiplicities.get(key) ?? 0
+    const newMultiplicity = oldMultiplicity + multiplicity
+    if (newMultiplicity === 0) {
+      this.#multiplicities.delete(key)
+    } else {
+      this.#multiplicities.set(key, newMultiplicity)
+    }
+    return { oldMultiplicity, newMultiplicity }
+  }
+}
+
+/**
+ * Handles a moveIn change by adding it to the result array.
+ */
+export function handleMoveIn<K extends string | number, T>(
+  moveIn: IndexedValue<[K, T]> | null,
+  result: Array<[[K, IndexedValue<T>], number]>,
+): void {
+  if (moveIn) {
+    const [[key, value], index] = moveIn
+    result.push([[key, [value, index]], 1])
+  }
+}
+
+/**
+ * Handles a moveOut change by adding it to the result array.
+ */
+export function handleMoveOut<K extends string | number, T>(
+  moveOut: IndexedValue<[K, T]> | null,
+  result: Array<[[K, IndexedValue<T>], number]>,
+): void {
+  if (moveOut) {
+    const [[key, value], index] = moveOut
+    result.push([[key, [value, index]], -1])
+  }
+}
diff --git a/packages/db-ivm/src/operators/topKWithFractionalIndex.ts b/packages/db-ivm/src/operators/topKWithFractionalIndex.ts
index 3b75521e3..740c3b840 100644
--- a/packages/db-ivm/src/operators/topKWithFractionalIndex.ts
+++ b/packages/db-ivm/src/operators/topKWithFractionalIndex.ts
@@ -1,277 +1,57 @@
-import { generateKeyBetween } from "fractional-indexing"
-import { DifferenceStreamWriter, UnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { MultiSet } from "../multiset.js"
-import {
-  binarySearch,
-  diffHalfOpen,
-  globalObjectIdGenerator,
-} from "../utils.js"
-import type { HRange } from "../utils.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { MultiSet } from '../multiset.js'
+import { TopKState, handleMoveIn, handleMoveOut } from './topKState.js'
+import { TopKArray, createKeyedComparator } from './topKArray.js'
+import type { IndexedValue, TopK } from './topKArray.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
 
 export interface TopKWithFractionalIndexOptions {
   limit?: number
   offset?: number
   setSizeCallback?: (getSize: () => number) => void
   setWindowFn?: (
-    windowFn: (options: { offset?: number; limit?: number }) => void
+    windowFn: (options: { offset?: number; limit?: number }) => void,
   ) => void
 }
 
-export type TopKChanges<V> = {
-  /** Indicates which element moves into the topK (if any) */
-  moveIn: IndexedValue<V> | null
-  /** Indicates which element moves out of the topK (if any) */
-  moveOut: IndexedValue<V> | null
-}
-
-export type TopKMoveChanges<V> = {
-  /** Flag that marks whether there were any changes to the topK */
-  changes: boolean
-  /** Indicates which elements move into the topK (if any) */
-  moveIns: Array<IndexedValue<V>>
-  /** Indicates which elements move out of the topK (if any) */
-  moveOuts: Array<IndexedValue<V>>
-}
-
-/**
- * A topK data structure that supports insertions and deletions
- * and returns changes to the topK.
- */
-export interface TopK<V> {
-  size: number
-  insert: (value: V) => TopKChanges<V>
-  delete: (value: V) => TopKChanges<V>
-}
-
-/**
- * Implementation of a topK data structure.
- * Uses a sorted array internally to store the values and keeps a topK window over that array.
- * Inserts and deletes are O(n) operations because worst case an element is inserted/deleted
- * at the start of the array which causes all the elements to shift to the right/left.
- */
-class TopKArray<V> implements TopK<V> {
-  #sortedValues: Array<IndexedValue<V>> = []
-  #comparator: (a: V, b: V) => number
-  #topKStart: number
-  #topKEnd: number
-
-  constructor(
-    offset: number,
-    limit: number,
-    comparator: (a: V, b: V) => number
-  ) {
-    this.#topKStart = offset
-    this.#topKEnd = offset + limit
-    this.#comparator = comparator
-  }
-
-  get size(): number {
-    const offset = this.#topKStart
-    const limit = this.#topKEnd - this.#topKStart
-    const available = this.#sortedValues.length - offset
-    return Math.max(0, Math.min(limit, available))
-  }
-
-  /**
-   * Moves the topK window
-   */
-  move({
-    offset,
-    limit,
-  }: {
-    offset?: number
-    limit?: number
-  }): TopKMoveChanges<V> {
-    const oldOffset = this.#topKStart
-    const oldLimit = this.#topKEnd - this.#topKStart
-    const oldRange: HRange = [this.#topKStart, this.#topKEnd]
-
-    this.#topKStart = offset ?? oldOffset
-    this.#topKEnd = this.#topKStart + (limit ?? oldLimit)
-
-    const newRange: HRange = [this.#topKStart, this.#topKEnd]
-    const { onlyInA, onlyInB } = diffHalfOpen(oldRange, newRange)
-
-    const moveIns: Array<IndexedValue<V>> = []
-    onlyInB.forEach((index) => {
-      const value = this.#sortedValues[index]
-      if (value) {
-        moveIns.push(value)
-      }
-    })
-
-    const moveOuts: Array<IndexedValue<V>> = []
-    onlyInA.forEach((index) => {
-      const value = this.#sortedValues[index]
-      if (value) {
-        moveOuts.push(value)
-      }
-    })
-
-    // It could be that there are changes (i.e. moveIns or moveOuts)
-    // but that the collection is lazy so we don't have the data yet that needs to move in/out
-    // so `moveIns` and `moveOuts` will be empty but `changes` will be true
-    // this will tell the caller that it needs to run the graph to load more data
-    return { moveIns, moveOuts, changes: onlyInA.length + onlyInB.length > 0 }
-  }
-
-  insert(value: V): TopKChanges<V> {
-    const result: TopKChanges<V> = { moveIn: null, moveOut: null }
-
-    // Lookup insert position
-    const index = this.#findIndex(value)
-    // Generate fractional index based on the fractional indices of the elements before and after it
-    const indexBefore =
-      index === 0 ? null : getIndex(this.#sortedValues[index - 1]!)
-    const indexAfter =
-      index === this.#sortedValues.length
-        ? null
-        : getIndex(this.#sortedValues[index]!)
-    const fractionalIndex = generateKeyBetween(indexBefore, indexAfter)
-
-    // Insert the value at the correct position
-    const val = indexedValue(value, fractionalIndex)
-    // Splice is O(n) where n = all elements in the collection (i.e. n >= k) !
-    this.#sortedValues.splice(index, 0, val)
-
-    // Check if the topK changed
-    if (index < this.#topKEnd) {
-      // The inserted element is either before the top K or within the top K
-      // If it is before the top K then it moves the element that was right before the topK into the topK
-      // If it is within the top K then the inserted element moves into the top K
-      // In both cases the last element of the old top K now moves out of the top K
-      const moveInIndex = Math.max(index, this.#topKStart)
-      if (moveInIndex < this.#sortedValues.length) {
-        // We actually have a topK
-        // because in some cases there may not be enough elements in the array to reach the start of the topK
-        // e.g. [1, 2, 3] with K = 2 and offset = 3 does not have a topK
-        result.moveIn = this.#sortedValues[moveInIndex]!
-
-        // We need to remove the element that falls out of the top K
-        // The element that falls out of the top K has shifted one to the right
-        // because of the element we inserted, so we find it at index topKEnd
-        if (this.#topKEnd < this.#sortedValues.length) {
-          result.moveOut = this.#sortedValues[this.#topKEnd]!
-        }
-      }
-    }
-
-    return result
-  }
-
-  /**
-   * Deletes a value that may or may not be in the topK.
-   * IMPORTANT: this assumes that the value is present in the collection
-   *            if it's not the case it will remove the element
-   *            that is on the position where the provided `value` would be.
-   */
-  delete(value: V): TopKChanges<V> {
-    const result: TopKChanges<V> = { moveIn: null, moveOut: null }
-
-    // Lookup delete position
-    const index = this.#findIndex(value)
-    // Remove the value at that position
-    const [removedElem] = this.#sortedValues.splice(index, 1)
-
-    // Check if the topK changed
-    if (index < this.#topKEnd) {
-      // The removed element is either before the top K or within the top K
-      // If it is before the top K then the first element of the topK moves out of the topK
-      // If it is within the top K then the removed element moves out of the topK
-      result.moveOut = removedElem!
-      if (index < this.#topKStart) {
-        // The removed element is before the topK
-        // so actually, the first element of the topK moves out of the topK
-        // and not the element that we removed
-        // The first element of the topK is now at index topKStart - 1
-        // since we removed an element before the topK
-        const moveOutIndex = this.#topKStart - 1
-        if (moveOutIndex < this.#sortedValues.length) {
-          result.moveOut = this.#sortedValues[moveOutIndex]!
-        } else {
-          // No value is moving out of the topK
-          // because there are no elements in the topK
-          result.moveOut = null
-        }
-      }
-
-      // Since we removed an element that was before or in the topK
-      // the first element after the topK moved one position to the left
-      // and thus falls into the topK now
-      const moveInIndex = this.#topKEnd - 1
-      if (moveInIndex < this.#sortedValues.length) {
-        result.moveIn = this.#sortedValues[moveInIndex]!
-      }
-    }
-
-    return result
-  }
-
-  // TODO: see if there is a way to refactor the code for insert and delete in the topK above
-  //       because they are very similar, one is shifting the topK window to the left and the other is shifting it to the right
-  //       so i have the feeling there is a common pattern here and we can implement both cases using that pattern
-
-  #findIndex(value: V): number {
-    return binarySearch(this.#sortedValues, indexedValue(value, ``), (a, b) =>
-      this.#comparator(getValue(a), getValue(b))
-    )
-  }
-}
-
 /**
  * Operator for fractional indexed topK operations
  * This operator maintains fractional indices for sorted elements
  * and only updates indices when elements move position
  */
-export class TopKWithFractionalIndexOperator<K, T> extends UnaryOperator<
-  [K, T],
-  [K, IndexedValue<T>]
-> {
-  #index: Map<K, number> = new Map() // maps keys to their multiplicity
-
-  /**
-   * topK data structure that supports insertions and deletions
-   * and returns changes to the topK.
-   */
-  #topK: TopK<TaggedValue<K, T>>
+export class TopKWithFractionalIndexOperator<
+  K extends string | number,
+  T,
+> extends UnaryOperator<[K, T], [K, IndexedValue<T>]> {
+  #state: TopKState<K, T>
 
   constructor(
     id: number,
     inputA: DifferenceStreamReader<[K, T]>,
     output: DifferenceStreamWriter<[K, IndexedValue<T>]>,
     comparator: (a: T, b: T) => number,
-    options: TopKWithFractionalIndexOptions
+    options: TopKWithFractionalIndexOptions,
   ) {
     super(id, inputA, output)
     const limit = options.limit ?? Infinity
     const offset = options.offset ?? 0
-    const compareTaggedValues = (
-      a: TaggedValue<K, T>,
-      b: TaggedValue<K, T>
-    ) => {
-      // First compare on the value
-      const valueComparison = comparator(getVal(a), getVal(b))
-      if (valueComparison !== 0) {
-        return valueComparison
-      }
-      // If the values are equal, compare on the tag (object identity)
-      const tieBreakerA = getTag(a)
-      const tieBreakerB = getTag(b)
-      return tieBreakerA - tieBreakerB
-    }
-    this.#topK = this.createTopK(offset, limit, compareTaggedValues)
-    options.setSizeCallback?.(() => this.#topK.size)
+    const topK = this.createTopK(
+      offset,
+      limit,
+      createKeyedComparator(comparator),
+    )
+    this.#state = new TopKState(topK)
+    options.setSizeCallback?.(() => this.#state.size)
     options.setWindowFn?.(this.moveTopK.bind(this))
   }
 
   protected createTopK(
     offset: number,
     limit: number,
-    comparator: (a: TaggedValue<K, T>, b: TaggedValue<K, T>) => number
-  ): TopK<TaggedValue<K, T>> {
+    comparator: (a: [K, T], b: [K, T]) => number,
+  ): TopK<[K, T]> {
     return new TopKArray(offset, limit, comparator)
   }
 
@@ -280,18 +60,11 @@ export class TopKWithFractionalIndexOperator<K, T> extends UnaryOperator<
    * Any changes to the topK are sent to the output.
    */
   moveTopK({ offset, limit }: { offset?: number; limit?: number }) {
-    if (!(this.#topK instanceof TopKArray)) {
-      throw new Error(
-        `Cannot move B+-tree implementation of TopK with fractional index`
-      )
-    }
-
     const result: Array<[[K, IndexedValue<T>], number]> = []
+    const diff = this.#state.move({ offset, limit })
 
-    const diff = this.#topK.move({ offset, limit })
-
-    diff.moveIns.forEach((moveIn) => this.handleMoveIn(moveIn, result))
-    diff.moveOuts.forEach((moveOut) => this.handleMoveOut(moveOut, result))
+    diff.moveIns.forEach((moveIn) => handleMoveIn(moveIn, result))
+    diff.moveOuts.forEach((moveOut) => handleMoveOut(moveOut, result))
 
     if (diff.changes) {
       // There are changes to the topK
@@ -319,78 +92,11 @@ export class TopKWithFractionalIndexOperator<K, T> extends UnaryOperator<
     key: K,
     value: T,
     multiplicity: number,
-    result: Array<[[K, IndexedValue<T>], number]>
+    result: Array<[[K, IndexedValue<T>], number]>,
   ): void {
-    const { oldMultiplicity, newMultiplicity } = this.addKey(key, multiplicity)
-
-    let res: TopKChanges<TaggedValue<K, T>> = {
-      moveIn: null,
-      moveOut: null,
-    }
-    if (oldMultiplicity <= 0 && newMultiplicity > 0) {
-      // The value was invisible but should now be visible
-      // Need to insert it into the array of sorted values
-      const taggedValue = tagValue(key, value)
-      res = this.#topK.insert(taggedValue)
-    } else if (oldMultiplicity > 0 && newMultiplicity <= 0) {
-      // The value was visible but should now be invisible
-      // Need to remove it from the array of sorted values
-      const taggedValue = tagValue(key, value)
-      res = this.#topK.delete(taggedValue)
-    } else {
-      // The value was invisible and it remains invisible
-      // or it was visible and remains visible
-      // so it doesn't affect the topK
-    }
-
-    this.handleMoveIn(res.moveIn, result)
-    this.handleMoveOut(res.moveOut, result)
-
-    return
-  }
-
-  private handleMoveIn(
-    moveIn: IndexedValue<TaggedValue<K, T>> | null,
-    result: Array<[[K, IndexedValue<T>], number]>
-  ) {
-    if (moveIn) {
-      const index = getIndex(moveIn)
-      const taggedValue = getValue(moveIn)
-      const k = getKey(taggedValue)
-      const val = getVal(taggedValue)
-      result.push([[k, [val, index]], 1])
-    }
-  }
-
-  private handleMoveOut(
-    moveOut: IndexedValue<TaggedValue<K, T>> | null,
-    result: Array<[[K, IndexedValue<T>], number]>
-  ) {
-    if (moveOut) {
-      const index = getIndex(moveOut)
-      const taggedValue = getValue(moveOut)
-      const k = getKey(taggedValue)
-      const val = getVal(taggedValue)
-      result.push([[k, [val, index]], -1])
-    }
-  }
-
-  private getMultiplicity(key: K): number {
-    return this.#index.get(key) ?? 0
-  }
-
-  private addKey(
-    key: K,
-    multiplicity: number
-  ): { oldMultiplicity: number; newMultiplicity: number } {
-    const oldMultiplicity = this.getMultiplicity(key)
-    const newMultiplicity = oldMultiplicity + multiplicity
-    if (newMultiplicity === 0) {
-      this.#index.delete(key)
-    } else {
-      this.#index.set(key, newMultiplicity)
-    }
-    return { oldMultiplicity, newMultiplicity }
+    const changes = this.#state.processElement(key, value, multiplicity)
+    handleMoveIn(changes.moveIn, result)
+    handleMoveOut(changes.moveOut, result)
   }
 }
 
@@ -404,65 +110,27 @@ export class TopKWithFractionalIndexOperator<K, T> extends UnaryOperator<
  * @param options - An optional object containing limit and offset properties
  * @returns A piped operator that orders the elements and limits the number of results
  */
-export function topKWithFractionalIndex<KType, T>(
+export function topKWithFractionalIndex<KType extends string | number, T>(
   comparator: (a: T, b: T) => number,
-  options?: TopKWithFractionalIndexOptions
+  options?: TopKWithFractionalIndexOptions,
 ): PipedOperator<[KType, T], [KType, IndexedValue<T>]> {
   const opts = options || {}
 
   return (
-    stream: IStreamBuilder<[KType, T]>
+    stream: IStreamBuilder<[KType, T]>,
   ): IStreamBuilder<[KType, IndexedValue<T>]> => {
     const output = new StreamBuilder<[KType, IndexedValue<T>]>(
       stream.graph,
-      new DifferenceStreamWriter<[KType, IndexedValue<T>]>()
+      new DifferenceStreamWriter<[KType, IndexedValue<T>]>(),
     )
     const operator = new TopKWithFractionalIndexOperator<KType, T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
       comparator,
-      opts
+      opts,
     )
     stream.graph.addOperator(operator)
     return output
   }
 }
-
-// Abstraction for fractionally indexed values
-export type FractionalIndex = string
-export type IndexedValue<V> = [V, FractionalIndex]
-
-export function indexedValue<V>(
-  value: V,
-  index: FractionalIndex
-): IndexedValue<V> {
-  return [value, index]
-}
-
-export function getValue<V>(indexedVal: IndexedValue<V>): V {
-  return indexedVal[0]
-}
-
-export function getIndex<V>(indexedVal: IndexedValue<V>): FractionalIndex {
-  return indexedVal[1]
-}
-
-export type Tag = number
-export type TaggedValue<K, V> = [K, V, Tag]
-
-function tagValue<K, V>(key: K, value: V): TaggedValue<K, V> {
-  return [key, value, globalObjectIdGenerator.getId(key)]
-}
-
-function getKey<K, V>(tieBreakerTaggedValue: TaggedValue<K, V>): K {
-  return tieBreakerTaggedValue[0]
-}
-
-function getVal<K, V>(tieBreakerTaggedValue: TaggedValue<K, V>): V {
-  return tieBreakerTaggedValue[1]
-}
-
-function getTag<K, V>(tieBreakerTaggedValue: TaggedValue<K, V>): Tag {
-  return tieBreakerTaggedValue[2]
-}
diff --git a/packages/db-ivm/src/operators/topKWithFractionalIndexBTree.ts b/packages/db-ivm/src/operators/topKWithFractionalIndexBTree.ts
index 7b094d7c4..3ca29ac1c 100644
--- a/packages/db-ivm/src/operators/topKWithFractionalIndexBTree.ts
+++ b/packages/db-ivm/src/operators/topKWithFractionalIndexBTree.ts
@@ -1,20 +1,11 @@
-import { generateKeyBetween } from "fractional-indexing"
-import { DifferenceStreamWriter } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import {
-  TopKWithFractionalIndexOperator,
-  getIndex,
-  getValue,
-  indexedValue,
-} from "./topKWithFractionalIndex.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type {
-  IndexedValue,
-  TaggedValue,
-  TopK,
-  TopKChanges,
-  TopKWithFractionalIndexOptions,
-} from "./topKWithFractionalIndex.js"
+import { generateKeyBetween } from 'fractional-indexing'
+import { DifferenceStreamWriter } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { TopKWithFractionalIndexOperator } from './topKWithFractionalIndex.js'
+import { getIndex, getValue, indexedValue } from './topKArray.js'
+import type { IndexedValue, TopK, TopKChanges } from './topKArray.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { TopKWithFractionalIndexOptions } from './topKWithFractionalIndex.js'
 
 interface BTree<Key, Value> {
   nextLowerPair: (key: Key) => [Key, Value] | undefined
@@ -30,7 +21,7 @@ interface BTreeClass {
   new <Key, Value>(
     entries?: Array<[Key, Value]>,
     compare?: (a: Key, b: Key) => number,
-    maxNodeSize?: number
+    maxNodeSize?: number,
   ): BTree<Key, Value>
 }
 
@@ -61,11 +52,11 @@ class TopKTree<V> implements TopK<V> {
   constructor(
     offset: number,
     limit: number,
-    comparator: (a: V, b: V) => number
+    comparator: (a: V, b: V) => number,
   ) {
     if (BTree === undefined) {
       throw new Error(
-        `B+ tree not loaded. You need to call loadBTree() before using TopKTree.`
+        `B+ tree not loaded. You need to call loadBTree() before using TopKTree.`,
       )
     }
 
@@ -243,17 +234,17 @@ class TopKTree<V> implements TopK<V> {
  * and only updates indices when elements move position
  */
 export class TopKWithFractionalIndexBTreeOperator<
-  K,
+  K extends string | number,
   T,
 > extends TopKWithFractionalIndexOperator<K, T> {
   protected override createTopK(
     offset: number,
     limit: number,
-    comparator: (a: TaggedValue<K, T>, b: TaggedValue<K, T>) => number
-  ): TopK<TaggedValue<K, T>> {
+    comparator: (a: [K, T], b: [K, T]) => number,
+  ): TopK<[K, T]> {
     if (BTree === undefined) {
       throw new Error(
-        `B+ tree not loaded. You need to call loadBTree() before using TopKWithFractionalIndexBTreeOperator.`
+        `B+ tree not loaded. You need to call loadBTree() before using TopKWithFractionalIndexBTreeOperator.`,
       )
     }
     return new TopKTree(offset, limit, comparator)
@@ -275,31 +266,31 @@ export class TopKWithFractionalIndexBTreeOperator<
  * @param options - An optional object containing limit and offset properties
  * @returns A piped operator that orders the elements and limits the number of results
  */
-export function topKWithFractionalIndexBTree<KType, T>(
+export function topKWithFractionalIndexBTree<KType extends string | number, T>(
   comparator: (a: T, b: T) => number,
-  options?: TopKWithFractionalIndexOptions
+  options?: TopKWithFractionalIndexOptions,
 ): PipedOperator<[KType, T], [KType, IndexedValue<T>]> {
   const opts = options || {}
 
   if (BTree === undefined) {
     throw new Error(
-      `B+ tree not loaded. You need to call loadBTree() before using topKWithFractionalIndexBTree.`
+      `B+ tree not loaded. You need to call loadBTree() before using topKWithFractionalIndexBTree.`,
     )
   }
 
   return (
-    stream: IStreamBuilder<[KType, T]>
+    stream: IStreamBuilder<[KType, T]>,
   ): IStreamBuilder<[KType, IndexedValue<T>]> => {
     const output = new StreamBuilder<[KType, IndexedValue<T>]>(
       stream.graph,
-      new DifferenceStreamWriter<[KType, IndexedValue<T>]>()
+      new DifferenceStreamWriter<[KType, IndexedValue<T>]>(),
     )
     const operator = new TopKWithFractionalIndexBTreeOperator<KType, T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
       comparator,
-      opts
+      opts,
     )
     stream.graph.addOperator(operator)
     return output
diff --git a/packages/db-ivm/src/types.ts b/packages/db-ivm/src/types.ts
index b1a8e71d3..da36bec3f 100644
--- a/packages/db-ivm/src/types.ts
+++ b/packages/db-ivm/src/types.ts
@@ -1,10 +1,10 @@
-import type { MultiSet, MultiSetArray } from "./multiset.js"
+import type { MultiSet, MultiSetArray } from './multiset.js'
 import type {
   BinaryOperator,
   DifferenceStreamReader,
   DifferenceStreamWriter,
   UnaryOperator,
-} from "./graph.js"
+} from './graph.js'
 
 export type KeyValue<K, V> = [K, V]
 
@@ -44,25 +44,25 @@ export interface IStreamBuilder<T> {
   pipe: (<O>(o1: PipedOperator<T, O>) => IStreamBuilder<O>) &
     (<T2, O>(
       o1: PipedOperator<T, T2>,
-      o2: PipedOperator<T2, O>
+      o2: PipedOperator<T2, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, O>(
       o1: PipedOperator<T, T2>,
       o2: PipedOperator<T2, T3>,
-      o3: PipedOperator<T3, O>
+      o3: PipedOperator<T3, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, O>(
       o1: PipedOperator<T, T2>,
       o2: PipedOperator<T2, T3>,
       o3: PipedOperator<T3, T4>,
-      o4: PipedOperator<T4, O>
+      o4: PipedOperator<T4, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, O>(
       o1: PipedOperator<T, T2>,
       o2: PipedOperator<T2, T3>,
       o3: PipedOperator<T3, T4>,
       o4: PipedOperator<T4, T5>,
-      o5: PipedOperator<T5, O>
+      o5: PipedOperator<T5, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, O>(
       o1: PipedOperator<T, T2>,
@@ -70,7 +70,7 @@ export interface IStreamBuilder<T> {
       o3: PipedOperator<T3, T4>,
       o4: PipedOperator<T4, T5>,
       o5: PipedOperator<T5, T6>,
-      o6: PipedOperator<T6, O>
+      o6: PipedOperator<T6, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, O>(
       o1: PipedOperator<T, T2>,
@@ -79,7 +79,7 @@ export interface IStreamBuilder<T> {
       o4: PipedOperator<T4, T5>,
       o5: PipedOperator<T5, T6>,
       o6: PipedOperator<T6, T7>,
-      o7: PipedOperator<T7, O>
+      o7: PipedOperator<T7, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, T8, O>(
       o1: PipedOperator<T, T2>,
@@ -89,7 +89,7 @@ export interface IStreamBuilder<T> {
       o5: PipedOperator<T5, T6>,
       o6: PipedOperator<T6, T7>,
       o7: PipedOperator<T7, T8>,
-      o8: PipedOperator<T8, O>
+      o8: PipedOperator<T8, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, T8, T9, O>(
       o1: PipedOperator<T, T2>,
@@ -100,7 +100,7 @@ export interface IStreamBuilder<T> {
       o6: PipedOperator<T6, T7>,
       o7: PipedOperator<T7, T8>,
       o8: PipedOperator<T8, T9>,
-      o9: PipedOperator<T9, O>
+      o9: PipedOperator<T9, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, T8, T9, T10, O>(
       o1: PipedOperator<T, T2>,
@@ -112,7 +112,7 @@ export interface IStreamBuilder<T> {
       o7: PipedOperator<T7, T8>,
       o8: PipedOperator<T8, T9>,
       o9: PipedOperator<T9, T10>,
-      o10: PipedOperator<T10, O>
+      o10: PipedOperator<T10, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O>(
       o1: PipedOperator<T, T2>,
@@ -125,7 +125,7 @@ export interface IStreamBuilder<T> {
       o8: PipedOperator<T8, T9>,
       o9: PipedOperator<T9, T10>,
       o10: PipedOperator<T10, T11>,
-      o11: PipedOperator<T11, O>
+      o11: PipedOperator<T11, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O>(
       o1: PipedOperator<T, T2>,
@@ -139,7 +139,7 @@ export interface IStreamBuilder<T> {
       o9: PipedOperator<T9, T10>,
       o10: PipedOperator<T10, T11>,
       o11: PipedOperator<T11, T12>,
-      o12: PipedOperator<T12, O>
+      o12: PipedOperator<T12, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O>(
       o1: PipedOperator<T, T2>,
@@ -154,7 +154,7 @@ export interface IStreamBuilder<T> {
       o10: PipedOperator<T10, T11>,
       o11: PipedOperator<T11, T12>,
       o12: PipedOperator<T12, T13>,
-      o13: PipedOperator<T13, O>
+      o13: PipedOperator<T13, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, O>(
       o1: PipedOperator<T, T2>,
@@ -170,7 +170,7 @@ export interface IStreamBuilder<T> {
       o11: PipedOperator<T11, T12>,
       o12: PipedOperator<T12, T13>,
       o13: PipedOperator<T13, T14>,
-      o14: PipedOperator<T14, O>
+      o14: PipedOperator<T14, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, O>(
       o1: PipedOperator<T, T2>,
@@ -187,7 +187,7 @@ export interface IStreamBuilder<T> {
       o12: PipedOperator<T12, T13>,
       o13: PipedOperator<T13, T14>,
       o14: PipedOperator<T14, T15>,
-      o15: PipedOperator<T15, O>
+      o15: PipedOperator<T15, O>,
     ) => IStreamBuilder<O>) &
     (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, O>(
       o1: PipedOperator<T, T2>,
@@ -205,7 +205,7 @@ export interface IStreamBuilder<T> {
       o13: PipedOperator<T13, T14>,
       o14: PipedOperator<T14, T15>,
       o15: PipedOperator<T15, T16>,
-      o16: PipedOperator<T16, O>
+      o16: PipedOperator<T16, O>,
     ) => IStreamBuilder<O>) &
     (<
       T2,
@@ -242,7 +242,7 @@ export interface IStreamBuilder<T> {
       o14: PipedOperator<T14, T15>,
       o15: PipedOperator<T15, T16>,
       o16: PipedOperator<T16, T17>,
-      o17: PipedOperator<T17, O>
+      o17: PipedOperator<T17, O>,
     ) => IStreamBuilder<O>) &
     (<
       T2,
@@ -281,7 +281,7 @@ export interface IStreamBuilder<T> {
       o15: PipedOperator<T15, T16>,
       o16: PipedOperator<T16, T17>,
       o17: PipedOperator<T17, T18>,
-      o18: PipedOperator<T18, O>
+      o18: PipedOperator<T18, O>,
     ) => IStreamBuilder<O>) &
     (<
       T2,
@@ -322,7 +322,7 @@ export interface IStreamBuilder<T> {
       o16: PipedOperator<T16, T17>,
       o17: PipedOperator<T17, T18>,
       o18: PipedOperator<T18, T19>,
-      o19: PipedOperator<T19, O>
+      o19: PipedOperator<T19, O>,
     ) => IStreamBuilder<O>) &
     (<
       T2,
@@ -365,11 +365,11 @@ export interface IStreamBuilder<T> {
       o17: PipedOperator<T17, T18>,
       o18: PipedOperator<T18, T19>,
       o19: PipedOperator<T19, T20>,
-      o20: PipedOperator<T20, O>
+      o20: PipedOperator<T20, O>,
     ) => IStreamBuilder<O>) &
     (<O>(...operators: Array<PipedOperator<any, any>>) => IStreamBuilder<O>)
 }
 
 export type PipedOperator<I, O> = (
-  stream: IStreamBuilder<I>
+  stream: IStreamBuilder<I>,
 ) => IStreamBuilder<O>
diff --git a/packages/db-ivm/src/utils.ts b/packages/db-ivm/src/utils.ts
index 8ba01bb52..70cfda48c 100644
--- a/packages/db-ivm/src/utils.ts
+++ b/packages/db-ivm/src/utils.ts
@@ -4,7 +4,7 @@
  */
 export function assert(
   condition: unknown,
-  message?: string
+  message?: string,
 ): asserts condition {
   if (!condition) {
     throw new Error(message || `Assertion failed`)
@@ -17,7 +17,7 @@ export function assert(
 export class DefaultMap<K, V> extends Map<K, V> {
   constructor(
     private defaultValue: () => V,
-    entries?: Iterable<[K, V]>
+    entries?: Iterable<[K, V]>,
   ) {
     super(entries)
   }
@@ -60,7 +60,7 @@ export function chunkedArrayPush(array: Array<unknown>, other: Array<unknown>) {
 export function binarySearch<T>(
   array: Array<T>,
   value: T,
-  comparator: (a: T, b: T) => number
+  comparator: (a: T, b: T) => number,
 ): number {
   let low = 0
   let high = array.length
@@ -138,7 +138,7 @@ export function* concatIterable<T>(
 
 export function* mapIterable<T, U>(
   it: Iterable<T>,
-  fn: (t: T) => U
+  fn: (t: T) => U,
 ): Iterable<U> {
   for (const t of it) {
     yield fn(t)
@@ -177,3 +177,35 @@ function range(start: number, end: number): Array<number> {
   for (let i = start; i < end; i++) out.push(i)
   return out
 }
+
+/**
+ * Compares two keys (string | number) in a consistent, deterministic way.
+ * Handles mixed types by ordering strings before numbers.
+ */
+export function compareKeys(a: string | number, b: string | number): number {
+  // Same type: compare directly
+  if (typeof a === typeof b) {
+    if (a < b) return -1
+    if (a > b) return 1
+    return 0
+  }
+  // Different types: strings come before numbers
+  return typeof a === `string` ? -1 : 1
+}
+
+/**
+ * Serializes a value for use as a key, handling BigInt and Date values that JSON.stringify cannot handle.
+ * Uses JSON.stringify with a replacer function to convert BigInt values to strings and Date values to ISO strings.
+ * This is used for creating string keys in groupBy operations.
+ */
+export function serializeValue(value: unknown): string {
+  return JSON.stringify(value, (_, val) => {
+    if (typeof val === 'bigint') {
+      return val.toString()
+    }
+    if (val instanceof Date) {
+      return val.toISOString()
+    }
+    return val
+  })
+}
diff --git a/packages/db-ivm/tests/graph.test.ts b/packages/db-ivm/tests/graph.test.ts
index 562b88d5b..b3e2de187 100644
--- a/packages/db-ivm/tests/graph.test.ts
+++ b/packages/db-ivm/tests/graph.test.ts
@@ -1,7 +1,7 @@
-import { beforeEach, describe, expect, test } from "vitest"
-import { DifferenceStreamWriter } from "../src/graph.js"
-import { MultiSet } from "../src/multiset.js"
-import type { DifferenceStreamReader } from "../src/graph.js"
+import { beforeEach, describe, expect, test } from 'vitest'
+import { DifferenceStreamWriter } from '../src/graph.js'
+import { MultiSet } from '../src/multiset.js'
+import type { DifferenceStreamReader } from '../src/graph.js'
 
 describe(`DifferenceStreamReader and DifferenceStreamWriter`, () => {
   let writer: DifferenceStreamWriter<number>
diff --git a/packages/db-ivm/tests/hash.property.test.ts b/packages/db-ivm/tests/hash.property.test.ts
new file mode 100644
index 000000000..bafffa2bf
--- /dev/null
+++ b/packages/db-ivm/tests/hash.property.test.ts
@@ -0,0 +1,334 @@
+import { describe, expect } from 'vitest'
+import { fc, test as fcTest } from '@fast-check/vitest'
+import { hash } from '../src/hashing/hash'
+
+/**
+ * Property-based tests for hash function
+ *
+ * Key properties:
+ * 1. Determinism: hash(x) always returns the same value
+ * 2. Structural equality: equal structures should have the same hash
+ * 3. Property order independence: objects with same properties in different order have same hash
+ * 4. Number normalization: -0 and 0 have same hash, NaN has consistent hash
+ * 5. Type markers: different types should generally produce different hashes
+ */
+
+// Arbitraries for generating test values
+const arbitraryPrimitive = fc.oneof(
+  fc.string(),
+  fc.integer(),
+  fc.double({ noNaN: true }),
+  fc.boolean(),
+  fc.constant(null),
+  fc.constant(undefined),
+)
+
+const arbitraryDate = fc.date({ noInvalidDate: true })
+
+const arbitraryUint8Array = fc.uint8Array({ minLength: 0, maxLength: 128 })
+
+const arbitrarySimpleObject = fc.dictionary(fc.string(), fc.integer(), {
+  maxKeys: 5,
+})
+
+const arbitrarySimpleArray = fc.array(fc.integer(), { maxLength: 10 })
+
+describe(`hash property-based tests`, () => {
+  describe(`determinism`, () => {
+    fcTest.prop([arbitraryPrimitive])(
+      `hash is deterministic for primitives`,
+      (value) => {
+        const first = hash(value)
+        const second = hash(value)
+        expect(first).toBe(second)
+      },
+    )
+
+    fcTest.prop([arbitrarySimpleObject])(
+      `hash is deterministic for objects`,
+      (obj) => {
+        const first = hash(obj)
+        const second = hash(obj)
+        expect(first).toBe(second)
+      },
+    )
+
+    fcTest.prop([arbitrarySimpleArray])(
+      `hash is deterministic for arrays`,
+      (arr) => {
+        const first = hash(arr)
+        const second = hash(arr)
+        expect(first).toBe(second)
+      },
+    )
+
+    fcTest.prop([arbitraryDate])(`hash is deterministic for dates`, (date) => {
+      const first = hash(date)
+      const second = hash(date)
+      expect(first).toBe(second)
+    })
+
+    fcTest.prop([arbitraryUint8Array])(
+      `hash is deterministic for Uint8Arrays`,
+      (arr) => {
+        const first = hash(arr)
+        const second = hash(arr)
+        expect(first).toBe(second)
+      },
+    )
+  })
+
+  describe(`structural equality`, () => {
+    fcTest.prop([arbitrarySimpleObject])(
+      `cloned objects have same hash`,
+      (obj) => {
+        const clone = { ...obj }
+        expect(hash(clone)).toBe(hash(obj))
+      },
+    )
+
+    fcTest.prop([arbitrarySimpleArray])(
+      `cloned arrays have same hash`,
+      (arr) => {
+        const clone = [...arr]
+        expect(hash(clone)).toBe(hash(arr))
+      },
+    )
+
+    fcTest.prop([arbitraryDate])(
+      `dates with same time have same hash`,
+      (date) => {
+        const clone = new Date(date.getTime())
+        expect(hash(clone)).toBe(hash(date))
+      },
+    )
+
+    fcTest.prop([arbitraryUint8Array])(
+      `Uint8Arrays with same content have same hash`,
+      (arr) => {
+        const clone = new Uint8Array(arr)
+        expect(hash(clone)).toBe(hash(arr))
+      },
+    )
+
+    fcTest.prop([
+      fc.array(fc.tuple(fc.string(), fc.integer()), { maxLength: 5 }),
+    ])(`Maps with same entries have same hash`, (entries) => {
+      const map1 = new Map(entries)
+      const map2 = new Map(entries)
+      expect(hash(map1)).toBe(hash(map2))
+    })
+
+    fcTest.prop([fc.array(fc.integer(), { maxLength: 10 })])(
+      `Sets with same values have same hash`,
+      (arr) => {
+        const set1 = new Set(arr)
+        const set2 = new Set(arr)
+        expect(hash(set1)).toBe(hash(set2))
+      },
+    )
+  })
+
+  describe(`property order independence`, () => {
+    fcTest.prop([
+      fc.tuple(
+        fc.string().filter((s) => s !== `` && s !== `__proto__`),
+        fc.integer(),
+        fc.string().filter((s) => s !== `` && s !== `__proto__`),
+        fc.integer(),
+      ),
+    ])(
+      `objects with same properties in different order have same hash`,
+      ([key1, val1, key2, val2]) => {
+        // Skip if keys are the same
+        if (key1 === key2) return
+
+        const obj1 = { [key1]: val1, [key2]: val2 }
+        const obj2 = { [key2]: val2, [key1]: val1 }
+        expect(hash(obj1)).toBe(hash(obj2))
+      },
+    )
+
+    fcTest.prop([
+      fc.dictionary(
+        fc.string().filter((s) => s !== `__proto__`),
+        fc.integer(),
+        { minKeys: 2, maxKeys: 5 },
+      ),
+    ])(`object hash is independent of property insertion order`, (obj) => {
+      const keys = Object.keys(obj)
+      const reversedKeys = [...keys].reverse()
+
+      // Create new object with reversed key order
+      const reversed: Record<string, number> = {}
+      for (const key of reversedKeys) {
+        reversed[key] = obj[key]!
+      }
+
+      expect(hash(reversed)).toBe(hash(obj))
+    })
+  })
+
+  describe(`number normalization`, () => {
+    fcTest.prop([fc.constant(0)])(`0 and -0 have the same hash`, () => {
+      expect(hash(0)).toBe(hash(-0))
+    })
+
+    fcTest.prop([fc.constant(NaN)])(`NaN has consistent hash`, () => {
+      const first = hash(NaN)
+      const second = hash(NaN)
+      expect(first).toBe(second)
+    })
+
+    fcTest.prop([fc.integer()])(`integers hash consistently`, (n) => {
+      expect(hash(n)).toBe(hash(n))
+    })
+
+    fcTest.prop([fc.double({ noNaN: true, noDefaultInfinity: true })])(
+      `doubles hash consistently`,
+      (n) => {
+        expect(hash(n)).toBe(hash(n))
+      },
+    )
+  })
+
+  describe(`type distinction`, () => {
+    fcTest.prop([fc.array(fc.integer(), { minLength: 0, maxLength: 5 })])(
+      `array and object with same indices have different hashes`,
+      (arr) => {
+        // Create object with same numeric keys
+        const obj: Record<string, number> = {}
+        arr.forEach((val, idx) => {
+          obj[String(idx)] = val
+        })
+
+        // Arrays and objects should generally have different hashes due to markers
+        // but for empty ones, both might hash the same
+        if (arr.length > 0) {
+          expect(hash(arr)).not.toBe(hash(obj))
+        }
+      },
+    )
+
+    fcTest.prop([fc.integer()])(
+      `number and string representation have different hashes`,
+      (n) => {
+        expect(hash(n)).not.toBe(hash(String(n)))
+      },
+    )
+
+    fcTest.prop([fc.boolean()])(
+      `boolean and its string representation have different hashes`,
+      (b) => {
+        expect(hash(b)).not.toBe(hash(String(b)))
+      },
+    )
+
+    fcTest.prop([fc.date({ noInvalidDate: true })])(
+      `date and its timestamp have different hashes`,
+      (date) => {
+        expect(hash(date)).not.toBe(hash(date.getTime()))
+      },
+    )
+
+    fcTest.prop([fc.array(fc.integer(), { minLength: 1, maxLength: 5 })])(
+      `array and Set with same values have different hashes`,
+      (arr) => {
+        const set = new Set(arr)
+        expect(hash(arr)).not.toBe(hash(set))
+      },
+    )
+  })
+
+  describe(`nested structures`, () => {
+    fcTest.prop([
+      fc.array(fc.array(fc.integer(), { maxLength: 3 }), { maxLength: 3 }),
+    ])(`nested arrays hash consistently`, (nested) => {
+      const clone = nested.map((inner) => [...inner])
+      expect(hash(clone)).toBe(hash(nested))
+    })
+
+    fcTest.prop([
+      fc.dictionary(
+        fc.string(),
+        fc.dictionary(fc.string(), fc.integer(), { maxKeys: 3 }),
+        { maxKeys: 3 },
+      ),
+    ])(`nested objects hash consistently`, (nested) => {
+      const clone = Object.fromEntries(
+        Object.entries(nested).map(([k, v]) => [k, { ...v }]),
+      )
+      expect(hash(clone)).toBe(hash(nested))
+    })
+  })
+
+  describe(`hash produces numbers`, () => {
+    fcTest.prop([arbitraryPrimitive])(
+      `hash returns a number for primitives`,
+      (value) => {
+        expect(typeof hash(value)).toBe(`number`)
+        expect(Number.isFinite(hash(value))).toBe(true)
+      },
+    )
+
+    fcTest.prop([arbitrarySimpleObject])(
+      `hash returns a number for objects`,
+      (obj) => {
+        expect(typeof hash(obj)).toBe(`number`)
+        expect(Number.isFinite(hash(obj))).toBe(true)
+      },
+    )
+
+    fcTest.prop([arbitrarySimpleArray])(
+      `hash returns a number for arrays`,
+      (arr) => {
+        expect(typeof hash(arr)).toBe(`number`)
+        expect(Number.isFinite(hash(arr))).toBe(true)
+      },
+    )
+  })
+
+  describe(`inequality detection`, () => {
+    fcTest.prop([fc.integer(), fc.integer()])(
+      `different integers have different hashes (most of the time)`,
+      (a, b) => {
+        // Hash collisions are possible, so we only check that equal values have equal hashes
+        if (a === b) {
+          expect(hash(a)).toBe(hash(b))
+        }
+        // We don't assert different values have different hashes due to collisions
+      },
+    )
+
+    fcTest.prop([fc.string(), fc.string()])(
+      `equal strings have equal hashes`,
+      (a, b) => {
+        if (a === b) {
+          expect(hash(a)).toBe(hash(b))
+        }
+      },
+    )
+
+    fcTest.prop([
+      fc.array(fc.integer(), { minLength: 1, maxLength: 10 }),
+      fc.integer(),
+    ])(`arrays with extra element have different hashes`, (arr, extra) => {
+      const extended = [...arr, extra]
+      expect(hash(arr)).not.toBe(hash(extended))
+    })
+
+    fcTest.prop([
+      fc.dictionary(fc.string(), fc.integer(), { minKeys: 1, maxKeys: 5 }),
+      fc.string(),
+      fc.integer(),
+    ])(
+      `objects with extra property have different hashes`,
+      (obj, newKey, newValue) => {
+        if (!(newKey in obj)) {
+          const extended = { ...obj, [newKey]: newValue }
+          expect(hash(obj)).not.toBe(hash(extended))
+        }
+      },
+    )
+  })
+})
diff --git a/packages/db-ivm/tests/indexes.test.ts b/packages/db-ivm/tests/indexes.test.ts
index 7994cad30..cad25daad 100644
--- a/packages/db-ivm/tests/indexes.test.ts
+++ b/packages/db-ivm/tests/indexes.test.ts
@@ -1,5 +1,5 @@
-import { beforeEach, describe, expect, test } from "vitest"
-import { Index } from "../src/indexes.js"
+import { beforeEach, describe, expect, test } from 'vitest'
+import { Index } from '../src/indexes.js'
 
 describe(`Index`, () => {
   let index: Index<string, number>
diff --git a/packages/db-ivm/tests/multiset.test.ts b/packages/db-ivm/tests/multiset.test.ts
index b640452cf..7dde5d80c 100644
--- a/packages/db-ivm/tests/multiset.test.ts
+++ b/packages/db-ivm/tests/multiset.test.ts
@@ -1,5 +1,5 @@
-import { beforeEach, describe, expect, it } from "vitest"
-import { MultiSet } from "../src/multiset.js"
+import { beforeEach, describe, expect, it } from 'vitest'
+import { MultiSet } from '../src/multiset.js'
 
 describe(`MultiSet`, () => {
   describe(`basic operations`, () => {
diff --git a/packages/db-ivm/tests/operators/concat.test.ts b/packages/db-ivm/tests/operators/concat.test.ts
index 9098d4569..c940bf7d1 100644
--- a/packages/db-ivm/tests/operators/concat.test.ts
+++ b/packages/db-ivm/tests/operators/concat.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { concat, output } from "../../src/operators/index.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { concat, output } from '../../src/operators/index.js'
 
 describe(`Operators`, () => {
   describe(`Concat operation`, () => {
@@ -15,7 +15,7 @@ describe(`Operators`, () => {
         concat(input2),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -24,14 +24,14 @@ describe(`Operators`, () => {
         new MultiSet([
           [1, 1],
           [2, 1],
-        ])
+        ]),
       )
 
       input2.sendData(
         new MultiSet([
           [3, 1],
           [4, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -58,7 +58,7 @@ describe(`Operators`, () => {
         concat(input2),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -67,14 +67,14 @@ describe(`Operators`, () => {
         new MultiSet([
           [1, -1],
           [2, 2],
-        ])
+        ]),
       )
 
       input2.sendData(
         new MultiSet([
           [3, -2],
           [4, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -101,7 +101,7 @@ describe(`Operators`, () => {
         concat(input2),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -110,14 +110,14 @@ describe(`Operators`, () => {
         new MultiSet([
           [1, 1],
           [2, 1],
-        ])
+        ]),
       )
 
       input2.sendData(
         new MultiSet([
           [`a`, 1],
           [`b`, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -144,7 +144,7 @@ describe(`Operators`, () => {
         concat(input2),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -154,7 +154,7 @@ describe(`Operators`, () => {
           [1, 1],
           [2, 1],
           [3, 1],
-        ])
+        ]),
       )
 
       input2.sendData(
@@ -162,7 +162,7 @@ describe(`Operators`, () => {
           [2, 2],
           [3, -1],
           [4, 1],
-        ])
+        ]),
       )
 
       graph.run()
diff --git a/packages/db-ivm/tests/operators/consolidate.test.ts b/packages/db-ivm/tests/operators/consolidate.test.ts
index f05104be4..cb3ecc282 100644
--- a/packages/db-ivm/tests/operators/consolidate.test.ts
+++ b/packages/db-ivm/tests/operators/consolidate.test.ts
@@ -1,8 +1,8 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { consolidate } from "../../src/operators/consolidate.js"
-import { output } from "../../src/operators/output.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { consolidate } from '../../src/operators/consolidate.js'
+import { output } from '../../src/operators/output.js'
 
 describe(`Operators`, () => {
   describe(`Consolidate operation`, () => {
@@ -20,7 +20,7 @@ function testConsolidate() {
       consolidate(),
       output((message) => {
         messages.push(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -29,19 +29,19 @@ function testConsolidate() {
       new MultiSet([
         [1, 1],
         [2, 1],
-      ])
+      ]),
     )
     input.sendData(
       new MultiSet([
         [3, 1],
         [4, 1],
-      ])
+      ]),
     )
     input.sendData(
       new MultiSet([
         [3, 2],
         [2, -1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -65,7 +65,7 @@ function testConsolidate() {
       consolidate(),
       output((message) => {
         messages.push(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -74,13 +74,13 @@ function testConsolidate() {
       new MultiSet([
         [1, 1],
         [2, 2],
-      ])
+      ]),
     )
     input.sendData(
       new MultiSet([
         [1, -1],
         [2, -2],
-      ])
+      ]),
     )
     graph.run()
 
@@ -98,7 +98,7 @@ function testConsolidate() {
       consolidate(),
       output((message) => {
         messages.push(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -107,7 +107,7 @@ function testConsolidate() {
       new MultiSet([
         [1, 1],
         [2, 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -115,7 +115,7 @@ function testConsolidate() {
       new MultiSet([
         [2, 1],
         [3, 1],
-      ])
+      ]),
     )
     graph.run()
 
diff --git a/packages/db-ivm/tests/operators/count.test.ts b/packages/db-ivm/tests/operators/count.test.ts
index a9cb74c1e..941c3a0db 100644
--- a/packages/db-ivm/tests/operators/count.test.ts
+++ b/packages/db-ivm/tests/operators/count.test.ts
@@ -1,13 +1,13 @@
-import { describe, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { count } from "../../src/operators/count.js"
-import { output } from "../../src/operators/output.js"
+import { describe, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { count } from '../../src/operators/count.js'
+import { output } from '../../src/operators/output.js'
 import {
   KeyedMessageTracker,
   assertKeyedResults,
   assertOnlyKeysAffected,
-} from "../test-utils.js"
+} from '../test-utils.js'
 
 describe(`Operators`, () => {
   describe(`Count operation`, () => {
@@ -25,7 +25,7 @@ function testCount() {
       count(),
       output((message) => {
         tracker.addMessage(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -38,7 +38,7 @@ function testCount() {
         [[2, `d`], 1],
         [[3, `x`], 1],
         [[3, `y`], -1],
-      ])
+      ]),
     )
     input.sendData(new MultiSet([[[3, `z`], 1]]))
     graph.run()
@@ -57,7 +57,7 @@ function testCount() {
         [2, 3], // 3 values for key 2
         [3, 1], // 1 value for key 3 (1 + (-1) + 1 = 1)
       ],
-      6 // Expected message count
+      6, // Expected message count
     )
   })
 
@@ -70,7 +70,7 @@ function testCount() {
       count(),
       output((message) => {
         tracker.addMessage(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -79,7 +79,7 @@ function testCount() {
       new MultiSet([
         [[1, `a`], -1],
         [[1, `b`], -2],
-      ])
+      ]),
     )
     graph.run()
 
@@ -89,7 +89,7 @@ function testCount() {
     assertOnlyKeysAffected(
       `count with all negative multiplicities`,
       result.messages,
-      [1]
+      [1],
     )
 
     // Assert the final materialized results are correct
@@ -99,7 +99,7 @@ function testCount() {
       [
         [1, -3], // -1 + (-2) = -3
       ],
-      2 // Expected message count
+      2, // Expected message count
     )
   })
 
@@ -112,7 +112,7 @@ function testCount() {
       count(),
       output((message) => {
         tracker.addMessage(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -121,7 +121,7 @@ function testCount() {
       new MultiSet([
         [[`one`, `a`], 1],
         [[`one`, `b`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -129,7 +129,7 @@ function testCount() {
       new MultiSet([
         [[`one`, `c`], 1],
         [[`two`, `a`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -149,7 +149,7 @@ function testCount() {
         [`one`, 3], // 2 + 1 = 3
         [`two`, 1], // 1
       ],
-      5 // Expected message count
+      5, // Expected message count
     )
   })
 
@@ -162,7 +162,7 @@ function testCount() {
       count(),
       output((message) => {
         tracker.addMessage(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -176,7 +176,7 @@ function testCount() {
         [[`b`, `item2`], 1],
         [[`b`, `item3`], 1],
         [[`c`, `item1`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -188,7 +188,7 @@ function testCount() {
       new MultiSet([
         [[`a`, `item3`], 1], // Add to 'a' (2 -> 3)
         [[`c`, `item1`], -1], // Remove from 'c' (1 -> 0)
-      ])
+      ]),
     )
     graph.run()
 
@@ -208,7 +208,7 @@ function testCount() {
         [`a`, 3], // Count increased from 2 to 3
         [`c`, 0], // Count decreased from 1 to 0
       ],
-      4 // Expected message count: remove old 'a', add new 'a', remove old 'c', add new 'c'
+      4, // Expected message count: remove old 'a', add new 'a', remove old 'c', add new 'c'
     )
   })
 }
diff --git a/packages/db-ivm/tests/operators/debug.test.ts b/packages/db-ivm/tests/operators/debug.test.ts
index 4fdb25aaa..765a3369b 100644
--- a/packages/db-ivm/tests/operators/debug.test.ts
+++ b/packages/db-ivm/tests/operators/debug.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, test, vi } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { debug } from "../../src/operators/index.js"
+import { describe, expect, test, vi } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { debug } from '../../src/operators/index.js'
 
 describe(`Operators`, () => {
   describe(`Debug operation`, () => {
@@ -19,13 +19,13 @@ describe(`Operators`, () => {
           [1, 1],
           [2, 1],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
 
       expect(consoleSpy).toHaveBeenCalledWith(
-        `debug test data: MultiSet([[1,1],[2,1],[3,1]])`
+        `debug test data: MultiSet([[1,1],[2,1],[3,1]])`,
       )
     })
 
@@ -43,13 +43,13 @@ describe(`Operators`, () => {
           [1, 1],
           [2, 1],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
 
       expect(consoleSpy).toHaveBeenCalledWith(
-        `debug test data: MultiSet([\n  [\n    1,\n    1\n  ],\n  [\n    2,\n    1\n  ],\n  [\n    3,\n    1\n  ]\n])`
+        `debug test data: MultiSet([\n  [\n    1,\n    1\n  ],\n  [\n    2,\n    1\n  ],\n  [\n    3,\n    1\n  ]\n])`,
       )
     })
 
@@ -67,13 +67,13 @@ describe(`Operators`, () => {
           [1, -1],
           [2, -2],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
 
       expect(consoleSpy).toHaveBeenCalledWith(
-        `debug test data: MultiSet([[1,-1],[2,-2],[3,1]])`
+        `debug test data: MultiSet([[1,-1],[2,-2],[3,1]])`,
       )
     })
   })
diff --git a/packages/db-ivm/tests/operators/distinct.test.ts b/packages/db-ivm/tests/operators/distinct.test.ts
index aa865e25c..23f36a775 100644
--- a/packages/db-ivm/tests/operators/distinct.test.ts
+++ b/packages/db-ivm/tests/operators/distinct.test.ts
@@ -1,10 +1,10 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { distinct } from "../../src/operators/distinct.js"
-import { output } from "../../src/operators/output.js"
-import { MessageTracker, assertResults } from "../test-utils.js"
-import { hash } from "../../src/hashing/index.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { distinct } from '../../src/operators/distinct.js'
+import { output } from '../../src/operators/output.js'
+import { MessageTracker, assertResults } from '../test-utils.js'
+import { hash } from '../../src/hashing/index.js'
 
 describe(`Operators`, () => {
   describe(`Efficient distinct operation`, () => {
@@ -22,7 +22,7 @@ function testDistinct() {
       distinct(),
       output((message) => {
         messages.push(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -32,7 +32,7 @@ function testDistinct() {
         [[1, `a`], 2],
         [[2, `b`], 1],
         [[2, `c`], 2],
-      ])
+      ]),
     )
     graph.run()
 
@@ -58,7 +58,7 @@ function testDistinct() {
       distinct(([_, value]) => value.country),
       output((message) => {
         messages.push(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -70,7 +70,7 @@ function testDistinct() {
         [[2, { name: `Kevin`, country: `Belgium` }], 1],
         [[3, { name: `Garry`, country: `UK` }], 1],
         [[4, { name: `Kyle`, country: `USA` }], 1],
-      ])
+      ]),
     )
 
     graph.run()
@@ -86,7 +86,7 @@ function testDistinct() {
         [`Portugal`, 1],
         [`UK`, 1],
         [`USA`, 1],
-      ].sort()
+      ].sort(),
     )
   })
 
@@ -99,7 +99,7 @@ function testDistinct() {
       distinct(),
       output((message) => {
         tracker.addMessage(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -110,7 +110,7 @@ function testDistinct() {
         [[1, `a`], 1],
         [[1, `b`], 1],
         [[1, `a`], 1], // Duplicate, should only result in 1
-      ])
+      ]),
     )
     graph.run()
 
@@ -122,7 +122,7 @@ function testDistinct() {
         [hash([1, `a`]), `a`],
         [hash([1, `b`]), `b`],
       ], // Should have both distinct values
-      4 // Max expected messages
+      4, // Max expected messages
     )
 
     tracker.reset()
@@ -133,7 +133,7 @@ function testDistinct() {
         [[1, `b`], -1], // Remove 'b'
         [[1, `c`], 2], // Add 'c' (multiplicity should be capped at 1)
         [[1, `a`], -1], // Remove 'a'
-      ])
+      ]),
     )
     graph.run()
 
@@ -142,7 +142,7 @@ function testDistinct() {
       `distinct with updates - second batch`,
       secondResult,
       [[hash([1, `c`]), `c`]], // Should only have 'c' remaining
-      4 // Max expected messages
+      4, // Max expected messages
     )
 
     tracker.reset()
@@ -156,7 +156,7 @@ function testDistinct() {
       `distinct with updates - third batch`,
       thirdResult,
       [], // Should have no remaining distinct values
-      2 // Max expected messages
+      2, // Max expected messages
     )
   })
 
@@ -169,7 +169,7 @@ function testDistinct() {
       distinct(),
       output((message) => {
         messages.push(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -179,7 +179,7 @@ function testDistinct() {
         [[`key1`, 1], 2],
         [[`key1`, 2], 3],
         [[`key2`, 1], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -203,7 +203,7 @@ function testDistinct() {
       distinct(),
       output((message) => {
         tracker.addMessage(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -216,7 +216,7 @@ function testDistinct() {
         [[`key2`, 1], 1], // Add ['key2', 1] with multiplicity 1 -> should become 1 (distinct)
         [[`key1`, 2], -3], // Remove all ['key1', 2] (total was 3) -> should be removed from distinct
         [[`key2`, 1], 1], // Add more ['key2', 1] -> still 1 in distinct
-      ])
+      ]),
     )
     graph.run()
 
@@ -228,7 +228,7 @@ function testDistinct() {
         [hash([`key1`, 1]), 1], // Should remain (multiplicity 2 -> 1 in distinct)
         [hash([`key2`, 1]), 1], // Should remain (multiplicity 2 -> 1 in distinct)
       ],
-      6 // Max expected messages (generous upper bound)
+      6, // Max expected messages (generous upper bound)
     )
   })
 }
diff --git a/packages/db-ivm/tests/operators/filter.test.ts b/packages/db-ivm/tests/operators/filter.test.ts
index 7ba3196c5..005ddcd5c 100644
--- a/packages/db-ivm/tests/operators/filter.test.ts
+++ b/packages/db-ivm/tests/operators/filter.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { filter, map, output } from "../../src/operators/index.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { filter, map, output } from '../../src/operators/index.js'
 
 describe(`Operators`, () => {
   describe(`Filter operation`, () => {
@@ -14,7 +14,7 @@ describe(`Operators`, () => {
         filter((x) => x % 2 === 0),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -24,7 +24,7 @@ describe(`Operators`, () => {
           [1, 1],
           [2, 1],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -41,7 +41,7 @@ describe(`Operators`, () => {
         filter((x) => x > 2 && x < 5),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -53,7 +53,7 @@ describe(`Operators`, () => {
           [3, 1],
           [4, 1],
           [5, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -76,7 +76,7 @@ describe(`Operators`, () => {
         filter((x) => x % 4 === 0),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -87,7 +87,7 @@ describe(`Operators`, () => {
           [2, 1],
           [3, 1],
           [4, 1],
-        ])
+        ]),
       )
 
       graph.run()
diff --git a/packages/db-ivm/tests/operators/filterBy.test.ts b/packages/db-ivm/tests/operators/filterBy.test.ts
index 83b908cb3..12b55234b 100644
--- a/packages/db-ivm/tests/operators/filterBy.test.ts
+++ b/packages/db-ivm/tests/operators/filterBy.test.ts
@@ -1,8 +1,8 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { filterBy, output } from "../../src/operators/index.js"
-import type { KeyValue } from "../../src/types.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { filterBy, output } from '../../src/operators/index.js'
+import type { KeyValue } from '../../src/types.js'
 
 describe(`Operators`, () => {
   describe(`FilterBy operation`, () => {
@@ -21,7 +21,7 @@ describe(`Operators`, () => {
         filterBy(inputB),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -31,7 +31,7 @@ describe(`Operators`, () => {
         new MultiSet<KeyValue<number, string>>([
           [[1, `apple`], 1],
           [[2, `banana`], 1],
-        ])
+        ]),
       )
 
       // Send filter keys to the filter stream
@@ -54,7 +54,7 @@ describe(`Operators`, () => {
         filterBy(inputB),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -64,7 +64,7 @@ describe(`Operators`, () => {
         new MultiSet<KeyValue<number, string>>([
           [[1, `apple`], 1],
           [[2, `banana`], 1],
-        ])
+        ]),
       )
 
       // Send empty filter data
@@ -86,7 +86,7 @@ describe(`Operators`, () => {
         filterBy(inputB),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -97,7 +97,7 @@ describe(`Operators`, () => {
           [[1, `apple`], 1],
           [[2, `banana`], 1],
           [[3, `cherry`], 1],
-        ])
+        ]),
       )
 
       // Send filter keys
@@ -105,7 +105,7 @@ describe(`Operators`, () => {
         new MultiSet<KeyValue<number, boolean>>([
           [[2, true], 1],
           [[3, false], 1], // Value doesn't matter, only key presence
-        ])
+        ]),
       )
 
       graph.run()
@@ -129,7 +129,7 @@ describe(`Operators`, () => {
         filterBy(inputB),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -141,7 +141,7 @@ describe(`Operators`, () => {
           [[2, `banana`], 1],
           [[3, `cherry`], 1],
           [[4, `date`], 1],
-        ])
+        ]),
       )
 
       // Send initial filter keys
@@ -149,7 +149,7 @@ describe(`Operators`, () => {
         new MultiSet<KeyValue<number, boolean>>([
           [[1, true], 1],
           [[3, true], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -167,7 +167,7 @@ describe(`Operators`, () => {
         new MultiSet<KeyValue<number, boolean>>([
           [[2, true], 1],
           [[4, true], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -191,7 +191,7 @@ describe(`Operators`, () => {
         filterBy(inputB),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -202,7 +202,7 @@ describe(`Operators`, () => {
           [[1, `apple`], 1],
           [[2, `banana`], -1],
           [[3, `cherry`], 1],
-        ])
+        ]),
       )
 
       // Send filter keys
@@ -211,7 +211,7 @@ describe(`Operators`, () => {
           [[1, true], 1],
           [[2, true], 1],
           [[3, true], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -236,7 +236,7 @@ describe(`Operators`, () => {
         filterBy(inputB),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -247,7 +247,7 @@ describe(`Operators`, () => {
           [[1, `apple`], 1],
           [[2, `banana`], 1],
           [[3, `cherry`], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -260,7 +260,7 @@ describe(`Operators`, () => {
         new MultiSet<KeyValue<number, boolean>>([
           [[2, true], 1],
           [[3, false], 1],
-        ])
+        ]),
       )
 
       graph.run()
diff --git a/packages/db-ivm/tests/operators/groupBy.test.ts b/packages/db-ivm/tests/operators/groupBy.test.ts
index 1a569dcd1..fbe50fb33 100644
--- a/packages/db-ivm/tests/operators/groupBy.test.ts
+++ b/packages/db-ivm/tests/operators/groupBy.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
 import {
   avg,
   count,
@@ -10,8 +10,8 @@ import {
   min,
   mode,
   sum,
-} from "../../src/operators/groupBy.js"
-import { output } from "../../src/operators/index.js"
+} from '../../src/operators/groupBy.js'
+import { output } from '../../src/operators/index.js'
 
 describe(`Operators`, () => {
   describe(`GroupBy operation`, () => {
@@ -27,7 +27,7 @@ describe(`Operators`, () => {
         groupBy((data) => ({ category: data.category })),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -38,7 +38,7 @@ describe(`Operators`, () => {
           [{ category: `A`, amount: 10 }, 1],
           [{ category: `A`, amount: 20 }, 1],
           [{ category: `B`, amount: 30 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -85,7 +85,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -96,7 +96,7 @@ describe(`Operators`, () => {
           [{ category: `A`, amount: 10 }, 1],
           [{ category: `A`, amount: 20 }, 1],
           [{ category: `B`, amount: 30 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -150,12 +150,12 @@ describe(`Operators`, () => {
           {
             total: sum((data) => data.amount),
             count: count(),
-          }
+          },
         ),
         output((message) => {
           latestMessage = message
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -167,7 +167,7 @@ describe(`Operators`, () => {
           [{ category: `A`, region: `East`, amount: 20 }, 1],
           [{ category: `A`, region: `West`, amount: 30 }, 1],
           [{ category: `B`, region: `East`, amount: 40 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -220,7 +220,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [{ category: `A`, region: `East`, amount: 15 }, 1],
           [{ category: `B`, region: `West`, amount: 25 }, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -270,7 +270,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [{ category: `A`, region: `East`, amount: 20 }, -1], // Remove one of the A/East records
-        ])
+        ]),
       )
       graph.run()
 
@@ -321,12 +321,12 @@ describe(`Operators`, () => {
           {
             countNotNull: count((data) => data.amount),
             count: count(),
-          }
+          },
         ),
         output((message) => {
           latestMessage = message
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -338,7 +338,7 @@ describe(`Operators`, () => {
           [{ category: `B`, amount: 10 }, 1],
           [{ category: `A`, amount: null }, 1],
           [{ category: `B`, amount: null }, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -391,7 +391,7 @@ describe(`Operators`, () => {
         output((message) => {
           latestMessage = message
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -402,7 +402,7 @@ describe(`Operators`, () => {
           [{ category: `A`, amount: 10 }, 1],
           [{ category: `A`, amount: 20 }, 1],
           [{ category: `B`, amount: 30 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -441,7 +441,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [{ category: `A`, amount: 30 }, 1],
           [{ category: `C`, amount: 50 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -487,7 +487,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [{ category: `A`, amount: 10 }, -1], // Remove the first A record
-        ])
+        ]),
       )
       graph.run()
 
@@ -537,7 +537,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -550,7 +550,7 @@ describe(`Operators`, () => {
           [{ category: `A`, amount: 5, date: new Date(`2025/12/12`) }, 1],
           [{ category: `B`, amount: 30, date: new Date(`2025/12/12`) }, 1],
           [{ category: `B`, amount: 15, date: new Date(`2025/12/13`) }, 1],
-        ])
+        ]),
       )
 
       // Run the graph to process all messages
@@ -605,7 +605,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -626,7 +626,7 @@ describe(`Operators`, () => {
           [{ category: `B`, amount: 10 }, 1],
           [{ category: `B`, amount: 15 }, 1],
           [{ category: `B`, amount: 20 }, 1],
-        ])
+        ]),
       )
 
       // Run the graph to process all messages
@@ -676,7 +676,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -688,7 +688,7 @@ describe(`Operators`, () => {
           [{ category: `A`, amount: 20 }, 1],
           [{ category: `B`, amount: 30 }, 1],
           [{ category: `C`, amount: 40 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -699,7 +699,7 @@ describe(`Operators`, () => {
 
       // Find the group for category A
       const categoryAGroup = result.find(
-        ([key]: any) => key[0] === `{"category":"A"}`
+        ([key]: any) => key[0] === `{"category":"A"}`,
       )
       expect(categoryAGroup).toBeDefined()
       expect(categoryAGroup[0][1].total).toBe(30) // Sum of 10 + 20
@@ -709,7 +709,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [{ category: `A`, amount: 10 }, -1],
           [{ category: `A`, amount: 20 }, -1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -737,7 +737,7 @@ describe(`Operators`, () => {
       // Verify no new group with total: 0 was created by checking that
       // we don't have any positive weight entries for category A
       const positiveCategoryAEntries = result.filter(
-        ([key, , weight]: any) => key[0] === `{"category":"A"}` && weight > 0
+        ([key, , weight]: any) => key[0] === `{"category":"A"}` && weight > 0,
       )
       expect(positiveCategoryAEntries).toHaveLength(0)
     })
@@ -761,11 +761,11 @@ describe(`Operators`, () => {
             total: sum((data) => data.amount),
             count: count(),
             average: avg((data) => data.amount),
-          }
+          },
         ),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -777,7 +777,7 @@ describe(`Operators`, () => {
           [{ category: `A`, region: `East`, amount: 20 }, 1],
           [{ category: `A`, region: `West`, amount: 30 }, 1],
           [{ category: `B`, region: `East`, amount: 40 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -788,7 +788,7 @@ describe(`Operators`, () => {
 
       // Find the group for category A, region East
       const categoryAEastGroup = result.find(
-        ([key]: any) => key[0] === `{"category":"A","region":"East"}`
+        ([key]: any) => key[0] === `{"category":"A","region":"East"}`,
       )
       expect(categoryAEastGroup).toBeDefined()
       expect(categoryAEastGroup[0][1]).toEqual({
@@ -804,7 +804,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [{ category: `A`, region: `East`, amount: 10 }, -1],
           [{ category: `A`, region: `East`, amount: 20 }, -1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -834,7 +834,7 @@ describe(`Operators`, () => {
       // Verify no new group with zero/empty values was created
       const positiveCategoryAEastEntries = result.filter(
         ([key, , weight]: any) =>
-          key[0] === `{"category":"A","region":"East"}` && weight > 0
+          key[0] === `{"category":"A","region":"East"}` && weight > 0,
       )
       expect(positiveCategoryAEastEntries).toHaveLength(0)
     })
@@ -853,7 +853,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -864,7 +864,7 @@ describe(`Operators`, () => {
           [{ category: `A`, amount: 10 }, 1],
           [{ category: `A`, amount: 20 }, 1],
           [{ category: `B`, amount: 30 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -875,7 +875,7 @@ describe(`Operators`, () => {
 
       // Find the group for category A
       const categoryAGroup = result.find(
-        ([key]: any) => key[0] === `{"category":"A"}`
+        ([key]: any) => key[0] === `{"category":"A"}`,
       )
       expect(categoryAGroup).toBeDefined()
       expect(categoryAGroup[0][1].total).toBe(30) // Sum of 10 + 20
@@ -885,7 +885,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [{ category: `A`, amount: 10 }, -1],
           [{ category: `A`, amount: 20 }, -1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -910,7 +910,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [{ category: `A`, amount: 50 }, 1],
           [{ category: `A`, amount: 25 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -982,11 +982,11 @@ describe(`Operators`, () => {
             average: avg((data) => data.amount),
             minimum: min((data) => data.amount),
             maximum: max((data) => data.amount),
-          }
+          },
         ),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -998,7 +998,7 @@ describe(`Operators`, () => {
           [{ category: `A`, region: `East`, amount: 20 }, 1],
           [{ category: `A`, region: `East`, amount: 30 }, 1],
           [{ category: `B`, region: `West`, amount: 100 }, 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -1009,7 +1009,7 @@ describe(`Operators`, () => {
 
       // Find the group for category A, region East
       const categoryAEastGroup = result.find(
-        ([key]: any) => key[0] === `{"category":"A","region":"East"}`
+        ([key]: any) => key[0] === `{"category":"A","region":"East"}`,
       )
       expect(categoryAEastGroup).toBeDefined()
       expect(categoryAEastGroup[0][1]).toEqual({
@@ -1028,7 +1028,7 @@ describe(`Operators`, () => {
           [{ category: `A`, region: `East`, amount: 10 }, -1],
           [{ category: `A`, region: `East`, amount: 20 }, -1],
           [{ category: `A`, region: `East`, amount: 30 }, -1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -1060,7 +1060,7 @@ describe(`Operators`, () => {
           [{ category: `A`, region: `East`, amount: 15 }, 1],
           [{ category: `A`, region: `East`, amount: 40 }, 1],
           [{ category: `A`, region: `East`, amount: 40 }, 1], // Duplicate to test aggregates properly
-        ])
+        ]),
       )
       graph.run()
 
@@ -1089,7 +1089,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [{ category: `A`, region: `East`, amount: 40 }, -1], // Remove one of the 40s
-        ])
+        ]),
       )
       graph.run()
 
diff --git a/packages/db-ivm/tests/operators/groupedOrderByWithFractionalIndex.test.ts b/packages/db-ivm/tests/operators/groupedOrderByWithFractionalIndex.test.ts
new file mode 100644
index 000000000..d88617b88
--- /dev/null
+++ b/packages/db-ivm/tests/operators/groupedOrderByWithFractionalIndex.test.ts
@@ -0,0 +1,758 @@
+import { describe, expect, it } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { groupedOrderByWithFractionalIndex } from '../../src/operators/groupedOrderBy.js'
+import { output } from '../../src/operators/index.js'
+import { MessageTracker, compareFractionalIndex } from '../test-utils.js'
+import type { KeyValue } from '../../src/types.js'
+
+describe(`Operators`, () => {
+  describe(`GroupedOrderByWithFractionalIndex operator`, () => {
+    it(`should maintain separate ordering per group with array key`, () => {
+      const graph = new D2()
+      const input = graph.newInput<
+        KeyValue<
+          [string, string],
+          {
+            id: string
+            value: number
+          }
+        >
+      >()
+      const tracker = new MessageTracker<
+        [[string, string], [{ id: string; value: number }, string]]
+      >()
+
+      const groupKeyFn = (key: [string, string]) => key[0]
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          groupKeyFn,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      input.sendData(
+        new MultiSet([
+          [[[`group1`, `a`], { id: `g1-a`, value: 5 }], 1],
+          [[[`group1`, `b`], { id: `g1-b`, value: 1 }], 1],
+          [[[`group1`, `c`], { id: `g1-c`, value: 3 }], 1],
+          [[[`group2`, `a`], { id: `g2-a`, value: 4 }], 1],
+          [[[`group2`, `b`], { id: `g2-b`, value: 2 }], 1],
+          [[[`group2`, `c`], { id: `g2-c`, value: 6 }], 1],
+        ]),
+      )
+
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // Each group should have limit 2, so 4 total results
+      expect(result.sortedResults.length).toBe(4)
+
+      // Sort all results by fractional index first, then group by group key
+      const sortedResults = sortByKeyAndIndex(result.sortedResults)
+      const groupedValues = groupResultsByKey(sortedResults, groupKeyFn)
+
+      // group1 should have values 1, 3 (top 2 by ascending value, ordered by fractional index)
+      expect(groupedValues.get(`group1`)).toEqual([1, 3])
+      // group2 should have values 2, 4 (top 2 by ascending value, ordered by fractional index)
+      expect(groupedValues.get(`group2`)).toEqual([2, 4])
+    })
+
+    it(`should group by value property using groupKeyFn`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      const groupKeyFn = (
+        _key: string,
+        value: { id: string; group: string; value: number },
+      ) => value.group
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          groupKeyFn,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - 3 items per group
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g2-a`, { id: `g2-a`, group: `group2`, value: 4 }], 1],
+          [[`g2-b`, { id: `g2-b`, group: `group2`, value: 2 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+          [[`g2-c`, { id: `g2-c`, group: `group2`, value: 6 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // Each group should have limit 2, so 4 total results
+      expect(result.sortedResults.length).toBe(4)
+
+      // Sort all results by fractional index first, then group by group key
+      const sortedResults = sortByKeyAndIndex(result.sortedResults)
+      const groupedValues = groupResultsByKey(sortedResults, groupKeyFn)
+
+      // group1 should have values 1, 3 (top 2 by ascending value, ordered by fractional index)
+      expect(groupedValues.get(`group1`)).toEqual([1, 3])
+      // group2 should have values 2, 4 (top 2 by ascending value, ordered by fractional index)
+      expect(groupedValues.get(`group2`)).toEqual([2, 4])
+    })
+
+    it(`should handle incremental updates within a group`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial should have 2 items (limit 2): values 1 and 3
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(2)
+      const sortedInitialResults = sortByKeyAndIndex(
+        initialResult.sortedResults,
+      )
+      const initialValues = sortedInitialResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialValues).toEqual([1, 3])
+
+      const initialMessageCount = initialResult.messageCount
+
+      // Insert a better value (0) which should evict value 3
+      input.sendData(
+        new MultiSet([
+          [[`g1-d`, { id: `g1-d`, group: `group1`, value: 0 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const updateResult = tracker.getResult(compareFractionalIndex)
+      // Should have 2 new messages: add 0, remove 3
+      expect(updateResult.messageCount - initialMessageCount).toBe(2)
+
+      // Check final state (cumulative)
+      const sortedFinalResults = sortByKeyAndIndex(updateResult.sortedResults)
+      const finalValues = sortedFinalResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(finalValues).toEqual([0, 1])
+    })
+
+    it(`should handle removal of elements from topK`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const initialMessageCount = tracker.getResult().messageCount
+
+      // Remove the element with value 1 (which is in topK)
+      input.sendData(
+        new MultiSet([
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], -1],
+        ]),
+      )
+      graph.run()
+
+      const updateResult = tracker.getResult(compareFractionalIndex)
+      // Should have 2 new messages: remove 1, add 5
+      expect(updateResult.messageCount - initialMessageCount).toBe(2)
+
+      // Final state should have values 3 and 5
+      const sortedFinalResults = sortByKeyAndIndex(updateResult.sortedResults)
+      const finalValues = sortedFinalResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(finalValues).toEqual([3, 5])
+    })
+
+    it(`should handle multiple groups independently`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      const groupKeyFn = (
+        _key: string,
+        value: { id: string; group: string; value: number },
+      ) => value.group
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          groupKeyFn,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data for two groups
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 10 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 20 }], 1],
+          [[`g2-a`, { id: `g2-a`, group: `group2`, value: 5 }], 1],
+          [[`g2-b`, { id: `g2-b`, group: `group2`, value: 15 }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Check initial output: each group should have limit 2
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(4)
+
+      // Sort all results by fractional index first, then group by group key
+      const sortedInitialResults = sortByKeyAndIndex(
+        initialResult.sortedResults,
+      )
+      const initialGroupedValues = groupResultsByKey(
+        sortedInitialResults,
+        groupKeyFn,
+      )
+
+      // group1 should have values 10, 20 (top 2 by ascending value, ordered by fractional index)
+      expect(initialGroupedValues.get(`group1`)).toEqual([10, 20])
+      // group2 should have values 5, 15 (top 2 by ascending value, ordered by fractional index)
+      expect(initialGroupedValues.get(`group2`)).toEqual([5, 15])
+
+      // Capture the fractional index of value 10 before reset
+      const value10Entry = sortedInitialResults.find(
+        ([_key, [value, _index]]) =>
+          value.value === 10 && value.group === `group1`,
+      )
+      expect(value10Entry).toBeDefined()
+      const [_value10Key, [_value10Value, value10Idx]] = value10Entry!
+
+      tracker.reset()
+
+      // Update only group1 - add a better value
+      input.sendData(
+        new MultiSet([
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 5 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const updateResult = tracker.getResult()
+
+      // Should have exactly 2 messages: one removal and one addition
+      expect(updateResult.messages.length).toBe(2)
+
+      // Find the removal message (multiplicity -1) and addition message (multiplicity 1)
+      const removalMessage = updateResult.messages.find(
+        ([_item, mult]) => mult === -1,
+      )
+      const additionMessage = updateResult.messages.find(
+        ([_item, mult]) => mult === 1,
+      )
+
+      expect(removalMessage).toBeDefined()
+      expect(additionMessage).toBeDefined()
+
+      // Check that removal is for value 20 (g1-b)
+      const [_removalKey, [removalValue, _removalIdx]] = removalMessage![0]
+      expect(removalValue.value).toBe(20)
+      expect(removalValue.id).toBe(`g1-b`)
+
+      // Check that addition is for value 5 (g1-c)
+      const [_additionKey, [additionValue, additionIdx]] = additionMessage![0]
+      expect(additionValue.value).toBe(5)
+      expect(additionValue.id).toBe(`g1-c`)
+
+      // Check that the fractional index of the added value (5) is smaller than the index of value 10
+      expect(additionIdx < value10Idx).toBe(true)
+    })
+
+    it(`should support offset within groups`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          offset: 1,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - 4 items per group
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 1 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 2 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+          [[`g1-d`, { id: `g1-d`, group: `group1`, value: 4 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // With offset 1 and limit 2, should get values 2 and 3
+      const sortedResults = sortByKeyAndIndex(result.sortedResults)
+      const values = sortedResults.map(([_key, [value, _index]]) => value.value)
+      expect(values).toEqual([2, 3])
+    })
+
+    it(`should use custom comparator`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+          // Descending order
+          comparator: (a, b) => b - a,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 1 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 2 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // With descending order and limit 2, should get values 3 and 2
+      const sortedResults = sortByKeyAndIndex(result.sortedResults)
+      const values = sortedResults.map(([_key, [value, _index]]) => value.value)
+      expect(values).toEqual([3, 2])
+    })
+
+    it(`should use groupKeyFn to extract group from key with delimiter`, () => {
+      const graph = new D2()
+      // Use keys with format "group:itemId"
+      const input =
+        graph.newInput<KeyValue<string, { id: string; value: number }>>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; value: number }, string]]
+      >()
+
+      const groupKeyFn = (key: string, _value: { id: string; value: number }) =>
+        key.split(`:`)[0]!
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          // Extract group from key "group:itemId"
+          groupKeyFn,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      input.sendData(
+        new MultiSet([
+          [[`group1:a`, { id: `g1-a`, value: 5 }], 1],
+          [[`group1:b`, { id: `g1-b`, value: 1 }], 1],
+          [[`group1:c`, { id: `g1-c`, value: 3 }], 1],
+          [[`group2:a`, { id: `g2-a`, value: 4 }], 1],
+          [[`group2:b`, { id: `g2-b`, value: 2 }], 1],
+          [[`group2:c`, { id: `g2-c`, value: 6 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // Sort all results by fractional index first, then group by group key
+      const sortedResults = sortByKeyAndIndex(result.sortedResults)
+      const groupedValues = groupResultsByKey(sortedResults, groupKeyFn)
+
+      expect(groupedValues.get(`group1`)).toEqual([1, 3])
+      expect(groupedValues.get(`group2`)).toEqual([2, 4])
+    })
+
+    it(`should support infinite limit (no limit)`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          // No limit specified - defaults to Infinity
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // All 3 items should be in the result
+      expect(result.sortedResults.length).toBe(3)
+      const sortedResults = sortByKeyAndIndex(result.sortedResults)
+      const values = sortedResults.map(([_key, [value, _index]]) => value.value)
+      expect(values).toEqual([1, 3, 5])
+    })
+
+    it(`should handle setSizeCallback correctly`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      let getSize: (() => number) | undefined
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+          setSizeCallback: (fn) => {
+            getSize = fn
+          },
+        }),
+        output(() => {}),
+      )
+
+      graph.finalize()
+
+      expect(getSize).toBeDefined()
+      expect(getSize!()).toBe(0) // Initially empty
+
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+          [[`g2-a`, { id: `g2-a`, group: `group2`, value: 4 }], 1],
+          [[`g2-b`, { id: `g2-b`, group: `group2`, value: 2 }], 1],
+        ]),
+      )
+      graph.run()
+
+      // group1 has 2 items in topK, group2 has 2 items
+      expect(getSize!()).toBe(4)
+    })
+
+    it(`should handle moving window with setWindowFn`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | undefined
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          offset: 0,
+          groupKeyFn: (_key, value) => value.group,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 1 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 2 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+          [[`g1-d`, { id: `g1-d`, group: `group1`, value: 4 }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial: values 1, 2
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      const sortedInitialResults = sortByKeyAndIndex(
+        initialResult.sortedResults,
+      )
+      const initialValues = sortedInitialResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialValues).toEqual([1, 2])
+
+      // Move window to offset 1
+      windowFn!({ offset: 1 })
+      graph.run()
+
+      // Now should have values 2, 3
+      const movedResult = tracker.getResult(compareFractionalIndex)
+      const sortedMovedResults = sortByKeyAndIndex(movedResult.sortedResults)
+      const movedValues = sortedMovedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(movedValues).toEqual([2, 3])
+    })
+
+    it(`should cleanup empty groups`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; value: number }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Add items to two groups
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 1 }], 1],
+          [[`g2-a`, { id: `g2-a`, group: `group2`, value: 2 }], 1],
+        ]),
+      )
+      graph.run()
+
+      expect(tracker.getResult().sortedResults.length).toBe(2)
+
+      // Remove all items from group1
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 1 }], -1],
+        ]),
+      )
+      graph.run()
+
+      // Should have only group2 left in materialized results
+      const updateResult = tracker.getResult(compareFractionalIndex)
+      expect(updateResult.sortedResults.length).toBe(1)
+      expect(updateResult.sortedResults[0]![1][0].group).toBe(`group2`)
+    })
+
+    it(`should order by string property`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<
+          KeyValue<string, { id: string; group: string; name: string }>
+        >()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; name: string }, string]]
+      >()
+
+      input.pipe(
+        groupedOrderByWithFractionalIndex((item) => item.name, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, name: `charlie` }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, name: `alice` }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, name: `bob` }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+      const sortedResults = sortByKeyAndIndex(result.sortedResults)
+      const names = sortedResults.map(([_key, [value, _index]]) => value.name)
+      expect(names).toEqual([`alice`, `bob`])
+    })
+  })
+})
+
+/**
+ * Helper function to sort results by key and then index
+ */
+function sortByKeyAndIndex(results: Array<any>) {
+  return [...results]
+    .sort(
+      (
+        [[_aKey, [_aValue, _aIndex]], aMultiplicity],
+        [[_bKey, [_bValue, _bIndex]], bMultiplicity],
+      ) => aMultiplicity - bMultiplicity,
+    )
+    .sort(
+      (
+        [[aKey, [_aValue, _aIndex]], _aMultiplicity],
+        [[bKey, [_bValue, _bIndex]], _bMultiplicity],
+      ) => {
+        // Compare keys - handle string, array, and numeric keys
+        if (typeof aKey === 'number' && typeof bKey === 'number') {
+          return aKey - bKey
+        }
+        // For string or array keys, convert to string for comparison
+        const aKeyStr = Array.isArray(aKey) ? aKey.join(',') : String(aKey)
+        const bKeyStr = Array.isArray(bKey) ? bKey.join(',') : String(bKey)
+        return aKeyStr < bKeyStr ? -1 : aKeyStr > bKeyStr ? 1 : 0
+      },
+    )
+    .sort(
+      (
+        [[_aKey, [_aValue, aIndex]], _aMultiplicity],
+        [[_bKey, [_bValue, bIndex]], _bMultiplicity],
+      ) => {
+        // lexically compare the index
+        return aIndex < bIndex ? -1 : aIndex > bIndex ? 1 : 0
+      },
+    )
+}
+
+/**
+ * Helper function to group sorted results by group key and extract values.
+ * Results should already be sorted by fractional index.
+ * Returns a Map of group key -> array of values (ordered by fractional index).
+ */
+function groupResultsByKey<TGroupKey extends string | number>(
+  sortedResults: Array<any>,
+  groupKeyFn: (key: any, value: any) => TGroupKey,
+): Map<TGroupKey, Array<number>> {
+  const groupedValues = new Map<TGroupKey, Array<number>>()
+  for (const [key, [value, _index]] of sortedResults) {
+    const group = groupKeyFn(key, value)
+    const list = groupedValues.get(group) ?? []
+    // Extract the numeric value from the value object
+    list.push((value as { value: number }).value)
+    groupedValues.set(group, list)
+  }
+  return groupedValues
+}
diff --git a/packages/db-ivm/tests/operators/groupedTopKWithFractionalIndex.test.ts b/packages/db-ivm/tests/operators/groupedTopKWithFractionalIndex.test.ts
new file mode 100644
index 000000000..c5890d22c
--- /dev/null
+++ b/packages/db-ivm/tests/operators/groupedTopKWithFractionalIndex.test.ts
@@ -0,0 +1,518 @@
+import { describe, expect, it } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { groupedTopKWithFractionalIndex } from '../../src/operators/groupedTopKWithFractionalIndex.js'
+import { output } from '../../src/operators/index.js'
+import { MessageTracker, compareFractionalIndex } from '../test-utils.js'
+
+describe(`Operators`, () => {
+  describe(`GroupedTopKWithFractionalIndex operator`, () => {
+    it(`should maintain separate topK per group`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<[string, { id: string; group: string; value: number }]>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - 3 items per group
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+          [[`g2-a`, { id: `g2-a`, group: `group2`, value: 4 }], 1],
+          [[`g2-b`, { id: `g2-b`, group: `group2`, value: 2 }], 1],
+          [[`g2-c`, { id: `g2-c`, group: `group2`, value: 6 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // Each group should have limit 2, so 4 total results
+      expect(result.sortedResults.length).toBe(4)
+
+      // Group by group key and verify each group's results
+      const groupedValues = new Map<string, Array<number>>()
+      for (const [_key, [value, _index]] of result.sortedResults) {
+        const group = value.group
+        const list = groupedValues.get(group) ?? []
+        list.push(value.value)
+        groupedValues.set(group, list)
+      }
+
+      // Sort values within each group for consistent comparison
+      for (const [group, values] of groupedValues) {
+        values.sort((a, b) => a - b)
+        groupedValues.set(group, values)
+      }
+
+      // group1 should have values 1, 3 (top 2 by ascending value)
+      expect(groupedValues.get(`group1`)).toEqual([1, 3])
+      // group2 should have values 2, 4 (top 2 by ascending value)
+      expect(groupedValues.get(`group2`)).toEqual([2, 4])
+    })
+
+    it(`should handle incremental updates within a group`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<[string, { id: string; group: string; value: number }]>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial should have 2 items (limit 2): values 1 and 3
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(2)
+      const initialValues = initialResult.sortedResults
+        .map(([_key, [value, _index]]) => value.value)
+        .sort((a, b) => a - b)
+      expect(initialValues).toEqual([1, 3])
+
+      const initialMessageCount = initialResult.messageCount
+
+      // Insert a better value (0) which should evict value 3
+      input.sendData(
+        new MultiSet([
+          [[`g1-d`, { id: `g1-d`, group: `group1`, value: 0 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const updateResult = tracker.getResult(compareFractionalIndex)
+      // Should have 2 new messages: add 0, remove 3
+      expect(updateResult.messageCount - initialMessageCount).toBe(2)
+
+      // Check final state (cumulative)
+      const finalValues = updateResult.sortedResults
+        .map(([_key, [value, _index]]) => value.value)
+        .sort((a, b) => a - b)
+      expect(finalValues).toEqual([0, 1])
+    })
+
+    it(`should handle removal of elements from topK`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<[string, { id: string; group: string; value: number }]>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const initialMessageCount = tracker.getResult().messageCount
+
+      // Remove the element with value 1 (which is in topK)
+      input.sendData(
+        new MultiSet([
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], -1],
+        ]),
+      )
+      graph.run()
+
+      const updateResult = tracker.getResult(compareFractionalIndex)
+      // Should have 2 new messages: remove 1, add 5
+      expect(updateResult.messageCount - initialMessageCount).toBe(2)
+
+      // Final state should have values 3 and 5
+      const finalValues = updateResult.sortedResults
+        .map(([_key, [value, _index]]) => value.value)
+        .sort((a, b) => a - b)
+      expect(finalValues).toEqual([3, 5])
+    })
+
+    it(`should handle multiple groups independently`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<[string, { id: string; group: string; value: number }]>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data for two groups
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 10 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 20 }], 1],
+          [[`g2-a`, { id: `g2-a`, group: `group2`, value: 5 }], 1],
+          [[`g2-b`, { id: `g2-b`, group: `group2`, value: 15 }], 1],
+        ]),
+      )
+      graph.run()
+
+      tracker.reset()
+
+      // Update only group1 - add a better value
+      input.sendData(
+        new MultiSet([
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 5 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const updateResult = tracker.getResult()
+
+      // Should have exactly 2 messages: one removal and one addition
+      expect(updateResult.messages.length).toBe(2)
+
+      // Find the removal message (multiplicity -1) and addition message (multiplicity 1)
+      const removalMessage = updateResult.messages.find(
+        ([_item, mult]) => mult === -1,
+      )
+      const additionMessage = updateResult.messages.find(
+        ([_item, mult]) => mult === 1,
+      )
+
+      expect(removalMessage).toBeDefined()
+      expect(additionMessage).toBeDefined()
+
+      // Check that removal is for value 20 (g1-b)
+      const [_removalKey, [removalValue, _removalIdx]] = removalMessage![0]
+      expect(removalValue.value).toBe(20)
+      expect(removalValue.id).toBe(`g1-b`)
+
+      // Check that addition is for value 5 (g1-c)
+      const [_additionKey, [additionValue, _additionIdx]] = additionMessage![0]
+      expect(additionValue.value).toBe(5)
+      expect(additionValue.id).toBe(`g1-c`)
+    })
+
+    it(`should support offset within groups`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<[string, { id: string; group: string; value: number }]>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          limit: 2,
+          offset: 1,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - 4 items per group
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 1 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 2 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+          [[`g1-d`, { id: `g1-d`, group: `group1`, value: 4 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // With offset 1 and limit 2, should get values 2 and 3
+      const values = result.sortedResults
+        .map(([_key, [value, _index]]) => value.value)
+        .sort((a, b) => a - b)
+      expect(values).toEqual([2, 3])
+    })
+
+    it(`should use groupKeyFn to extract group from key with delimiter`, () => {
+      const graph = new D2()
+      // Use keys with format "group:itemId"
+      const input = graph.newInput<[string, { id: string; value: number }]>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          limit: 2,
+          // Extract group from key "group:itemId"
+          groupKeyFn: (key, _value) => key.split(`:`)[0],
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      input.sendData(
+        new MultiSet([
+          [[`group1:a`, { id: `g1-a`, value: 5 }], 1],
+          [[`group1:b`, { id: `g1-b`, value: 1 }], 1],
+          [[`group1:c`, { id: `g1-c`, value: 3 }], 1],
+          [[`group2:a`, { id: `g2-a`, value: 4 }], 1],
+          [[`group2:b`, { id: `g2-b`, value: 2 }], 1],
+          [[`group2:c`, { id: `g2-c`, value: 6 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // Group results by group extracted from key
+      const groupedValues = new Map<string, Array<number>>()
+      for (const [key, [value, _index]] of result.sortedResults) {
+        const group = key.split(`:`)[0]!
+        const list = groupedValues.get(group) ?? []
+        list.push(value.value)
+        groupedValues.set(group, list)
+      }
+
+      for (const [group, values] of groupedValues) {
+        values.sort((a, b) => a - b)
+        groupedValues.set(group, values)
+      }
+
+      expect(groupedValues.get(`group1`)).toEqual([1, 3])
+      expect(groupedValues.get(`group2`)).toEqual([2, 4])
+    })
+
+    it(`should support infinite limit (no limit)`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<[string, { id: string; group: string; value: number }]>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          // No limit specified - defaults to Infinity
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+        ]),
+      )
+      graph.run()
+
+      const result = tracker.getResult(compareFractionalIndex)
+
+      // All 3 items should be in the result
+      expect(result.sortedResults.length).toBe(3)
+      const values = result.sortedResults
+        .map(([_key, [value, _index]]) => value.value)
+        .sort((a, b) => a - b)
+      expect(values).toEqual([1, 3, 5])
+    })
+
+    it(`should handle setSizeCallback correctly`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<[string, { id: string; group: string; value: number }]>()
+      let getSize: (() => number) | undefined
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+          setSizeCallback: (fn) => {
+            getSize = fn
+          },
+        }),
+        output(() => {}),
+      )
+
+      graph.finalize()
+
+      expect(getSize).toBeDefined()
+      expect(getSize!()).toBe(0) // Initially empty
+
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 5 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 1 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+          [[`g2-a`, { id: `g2-a`, group: `group2`, value: 4 }], 1],
+          [[`g2-b`, { id: `g2-b`, group: `group2`, value: 2 }], 1],
+        ]),
+      )
+      graph.run()
+
+      // group1 has 2 items in topK, group2 has 2 items
+      expect(getSize!()).toBe(4)
+    })
+
+    it(`should handle moving window with setWindowFn`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<[string, { id: string; group: string; value: number }]>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | undefined
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          limit: 2,
+          offset: 0,
+          groupKeyFn: (_key, value) => value.group,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 1 }], 1],
+          [[`g1-b`, { id: `g1-b`, group: `group1`, value: 2 }], 1],
+          [[`g1-c`, { id: `g1-c`, group: `group1`, value: 3 }], 1],
+          [[`g1-d`, { id: `g1-d`, group: `group1`, value: 4 }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial: values 1, 2
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      const initialValues = initialResult.sortedResults
+        .map(([_key, [value, _index]]) => value.value)
+        .sort((a, b) => a - b)
+      expect(initialValues).toEqual([1, 2])
+
+      // Move window to offset 1
+      windowFn!({ offset: 1 })
+      graph.run()
+
+      // Now should have values 2, 3
+      const movedResult = tracker.getResult(compareFractionalIndex)
+      const movedValues = movedResult.sortedResults
+        .map(([_key, [value, _index]]) => value.value)
+        .sort((a, b) => a - b)
+      expect(movedValues).toEqual([2, 3])
+    })
+
+    it(`should cleanup empty groups`, () => {
+      const graph = new D2()
+      const input =
+        graph.newInput<[string, { id: string; group: string; value: number }]>()
+      const tracker = new MessageTracker<
+        [string, [{ id: string; group: string; value: number }, string]]
+      >()
+
+      input.pipe(
+        groupedTopKWithFractionalIndex((a, b) => a.value - b.value, {
+          limit: 2,
+          groupKeyFn: (_key, value) => value.group,
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Add items to two groups
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 1 }], 1],
+          [[`g2-a`, { id: `g2-a`, group: `group2`, value: 2 }], 1],
+        ]),
+      )
+      graph.run()
+
+      expect(tracker.getResult().sortedResults.length).toBe(2)
+
+      // Remove all items from group1
+      input.sendData(
+        new MultiSet([
+          [[`g1-a`, { id: `g1-a`, group: `group1`, value: 1 }], -1],
+        ]),
+      )
+      graph.run()
+
+      // Should have only group2 left in materialized results
+      const updateResult = tracker.getResult(compareFractionalIndex)
+      expect(updateResult.sortedResults.length).toBe(1)
+      expect(updateResult.sortedResults[0]![1][0].group).toBe(`group2`)
+    })
+  })
+})
diff --git a/packages/db-ivm/tests/operators/join-types.test.ts b/packages/db-ivm/tests/operators/join-types.test.ts
index 9fe8f5387..f0943893e 100644
--- a/packages/db-ivm/tests/operators/join-types.test.ts
+++ b/packages/db-ivm/tests/operators/join-types.test.ts
@@ -1,15 +1,15 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { join } from "../../src/operators/join.js"
-import { output } from "../../src/operators/output.js"
-import { consolidate } from "../../src/operators/consolidate.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { join } from '../../src/operators/join.js'
+import { output } from '../../src/operators/output.js'
+import { consolidate } from '../../src/operators/consolidate.js'
 import {
   KeyedMessageTracker,
   assertKeyedResults,
   assertOnlyKeysAffected,
-} from "../test-utils.js"
-import type { JoinType } from "../../src/operators/join.js"
+} from '../test-utils.js'
+import type { JoinType } from '../../src/operators/join.js'
 
 /**
  * Sort results by multiplicity and then key
@@ -18,11 +18,11 @@ function sortResults(results: Array<any>) {
   return results
     .sort(
       ([[_aKey, _aValue], aMultiplicity], [[_bKey, _bValue], bMultiplicity]) =>
-        aMultiplicity - bMultiplicity
+        aMultiplicity - bMultiplicity,
     )
     .sort(
       ([[aKey, _aValue], _aMultiplicity], [[bKey, _bValue], _bMultiplicity]) =>
-        aKey - bKey
+        aKey - bKey,
     )
 }
 
@@ -52,7 +52,7 @@ describe(`Operators`, () => {
             consolidate(),
             output((message) => {
               tracker.addMessage(message)
-            })
+            }),
           )
 
           graph.finalize()
@@ -62,7 +62,7 @@ describe(`Operators`, () => {
             new MultiSet([
               [[`batch1_item1`, `a1`], 1],
               [[`batch1_item2`, `a2`], 1],
-            ])
+            ]),
           )
 
           inputA.sendData(new MultiSet([[[`batch2_item1`, `a3`], 1]]))
@@ -71,7 +71,7 @@ describe(`Operators`, () => {
             new MultiSet([
               [[`batch3_item1`, `a4`], 1],
               [[`batch3_item2`, `a5`], 1],
-            ])
+            ]),
           )
 
           // Send corresponding data to inputB (some matches, some don't)
@@ -81,7 +81,7 @@ describe(`Operators`, () => {
               [[`batch2_item1`, `x2`], 1], // matches
               [[`batch3_item2`, `x3`], 1], // matches
               [[`non_matching`, `x4`], 1], // doesn't match any inputA
-            ])
+            ]),
           )
 
           // Run the graph - should process all batches
@@ -131,7 +131,7 @@ describe(`Operators`, () => {
           assertOnlyKeysAffected(
             `${joinType} join with multiple batches`,
             result.messages,
-            expectedKeys
+            expectedKeys,
           )
 
           // Verify that we actually got some results
@@ -157,7 +157,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         tracker.addMessage(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -166,13 +166,13 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `A`], 1],
         [[2, `B`], 1],
-      ])
+      ]),
     )
     inputB.sendData(
       new MultiSet([
         [[2, `X`], 1],
         [[3, `Y`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -210,7 +210,7 @@ function testJoin(joinType: JoinType) {
       `${joinType} join - initial join with missing rows`,
       result,
       expectedResults[joinType],
-      6 // Max expected messages (generous upper bound)
+      6, // Max expected messages (generous upper bound)
     )
   })
 
@@ -228,7 +228,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         tracker.addMessage(message)
-      })
+      }),
     )
 
     graph.finalize()
@@ -239,7 +239,7 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `X`], 1],
         [[2, `Y`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -288,7 +288,7 @@ function testJoin(joinType: JoinType) {
       `${joinType} join - insert left (initial)`,
       initialResult,
       initialExpectedResults[joinType],
-      4 // Max expected messages for initial join
+      4, // Max expected messages for initial join
     )
 
     // Clear results after initial join
@@ -341,14 +341,14 @@ function testJoin(joinType: JoinType) {
       `${joinType} join - insert left`,
       result,
       expectedResults[joinType],
-      4 // Max expected messages for incremental update
+      4, // Max expected messages for incremental update
     )
 
     // Verify only affected keys produced messages
     assertOnlyKeysAffected(
       `${joinType} join - insert left`,
       result.messages,
-      [2] // Only key 2 should be affected
+      [2], // Only key 2 should be affected
     )
   })
 
@@ -363,7 +363,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         results.push(...message.getInner())
-      })
+      }),
     )
 
     graph.finalize()
@@ -373,7 +373,7 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `A`], 1],
         [[3, `C`], 1],
-      ])
+      ]),
     )
     inputB.sendData(new MultiSet([[[1, `X`], 1]]))
     graph.run()
@@ -475,7 +475,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         results.push(...message.getInner())
-      })
+      }),
     )
 
     graph.finalize()
@@ -485,13 +485,13 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `A`], 1],
         [[2, `B`], 1],
-      ])
+      ]),
     )
     inputB.sendData(
       new MultiSet([
         [[1, `X`], 1],
         [[2, `Y`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -586,7 +586,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         results.push(...message.getInner())
-      })
+      }),
     )
 
     graph.finalize()
@@ -596,13 +596,13 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `A`], 1],
         [[2, `B`], 1],
-      ])
+      ]),
     )
     inputB.sendData(
       new MultiSet([
         [[1, `X`], 1],
         [[2, `Y`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -698,7 +698,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         results.push(...message.getInner())
-      })
+      }),
     )
 
     graph.finalize()
@@ -738,7 +738,7 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `A`], -1],
         [[1, `A-updated`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -791,7 +791,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         results.push(...message.getInner())
-      })
+      }),
     )
 
     graph.finalize()
@@ -831,7 +831,7 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `X`], -1],
         [[1, `X-updated`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -887,7 +887,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         results.push(...message.getInner())
-      })
+      }),
     )
 
     graph.finalize()
@@ -897,13 +897,13 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `A`], 1],
         [[2, `B`], 1],
-      ])
+      ]),
     )
     inputB.sendData(
       new MultiSet([
         [[1, `X`], 1],
         [[2, `Y`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -988,7 +988,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         results.push(...message.getInner())
-      })
+      }),
     )
 
     graph.finalize()
@@ -998,13 +998,13 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `A`], 1],
         [[2, `B`], 1],
-      ])
+      ]),
     )
     inputB.sendData(
       new MultiSet([
         [[1, `X`], 1],
         [[2, `Y`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -1052,7 +1052,7 @@ function testJoin(joinType: JoinType) {
       new MultiSet([
         [[1, `A`], -1],
         [[1, `A-updated`], 1],
-      ])
+      ]),
     )
     graph.run()
 
@@ -1092,7 +1092,7 @@ function testJoin(joinType: JoinType) {
     }
 
     expect(sortResults(results)).toEqual(
-      sortResults(expectedResults2[joinType])
+      sortResults(expectedResults2[joinType]),
     )
 
     results.length = 0
@@ -1136,7 +1136,7 @@ function testJoin(joinType: JoinType) {
       consolidate(),
       output((message) => {
         results.push(...message.getInner())
-      })
+      }),
     )
 
     graph.finalize()
diff --git a/packages/db-ivm/tests/operators/join.test.ts b/packages/db-ivm/tests/operators/join.test.ts
index 94d7975cf..ed356af4e 100644
--- a/packages/db-ivm/tests/operators/join.test.ts
+++ b/packages/db-ivm/tests/operators/join.test.ts
@@ -1,13 +1,13 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { join } from "../../src/operators/join.js"
-import { output } from "../../src/operators/output.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { join } from '../../src/operators/join.js'
+import { output } from '../../src/operators/output.js'
 import {
   KeyedMessageTracker,
   assertKeyedResults,
   assertOnlyKeysAffected,
-} from "../test-utils.js"
+} from '../test-utils.js'
 
 describe(`Operators`, () => {
   describe(`Join operation`, () => {
@@ -26,7 +26,7 @@ function testJoin() {
       join(inputB),
       output((message) => {
         tracker.addMessage(message as MultiSet<[number, [string, string]]>)
-      })
+      }),
     )
 
     graph.finalize()
@@ -35,7 +35,7 @@ function testJoin() {
       new MultiSet([
         [[1, `a`], 1],
         [[2, `b`], 1],
-      ])
+      ]),
     )
 
     inputB.sendData(
@@ -43,7 +43,7 @@ function testJoin() {
         [[1, `x`], 1],
         [[2, `y`], 1],
         [[3, `z`], 1], // key 3 only exists in B, so no join output expected
-      ])
+      ]),
     )
 
     graph.run()
@@ -61,7 +61,7 @@ function testJoin() {
         [1, [`a`, `x`]],
         [2, [`b`, `y`]],
       ],
-      4 // Expected message count
+      4, // Expected message count
     )
   })
 
@@ -75,7 +75,7 @@ function testJoin() {
       join(inputB),
       output((message) => {
         tracker.addMessage(message as MultiSet<[number, [string, string]]>)
-      })
+      }),
     )
 
     graph.finalize()
@@ -84,7 +84,7 @@ function testJoin() {
       new MultiSet([
         [[1, `a`], 1],
         [[2, `b`], 1],
-      ])
+      ]),
     )
 
     graph.run()
@@ -93,7 +93,7 @@ function testJoin() {
       new MultiSet([
         [[1, `x`], 1],
         [[2, `y`], 1],
-      ])
+      ]),
     )
 
     graph.run()
@@ -104,7 +104,7 @@ function testJoin() {
     assertOnlyKeysAffected(
       `join with late arriving data`,
       result.messages,
-      [1, 2]
+      [1, 2],
     )
 
     // Assert the final materialized results are correct
@@ -115,7 +115,7 @@ function testJoin() {
         [1, [`a`, `x`]],
         [2, [`b`, `y`]],
       ],
-      4 // Expected message count
+      4, // Expected message count
     )
   })
 
@@ -129,7 +129,7 @@ function testJoin() {
       join(inputB),
       output((message) => {
         tracker.addMessage(message as MultiSet<[number, [string, string]]>)
-      })
+      }),
     )
 
     graph.finalize()
@@ -138,13 +138,13 @@ function testJoin() {
       new MultiSet([
         [[1, `a`], 1],
         [[2, `b`], -1], // Negative multiplicity
-      ])
+      ]),
     )
     inputB.sendData(
       new MultiSet([
         [[1, `x`], 1],
         [[2, `y`], 1],
-      ])
+      ]),
     )
 
     graph.run()
@@ -155,12 +155,12 @@ function testJoin() {
     assertOnlyKeysAffected(
       `join with negative multiplicities`,
       result.messages,
-      [1, 2]
+      [1, 2],
     )
 
     // Verify that key 2 produces a message but with negative multiplicity
     const key2Messages = result.messages.filter(
-      ([[key, _value], _mult]) => key === 2
+      ([[key, _value], _mult]) => key === 2,
     )
     expect(key2Messages.length).toBeGreaterThan(0) // Key 2 should produce messages
     expect(key2Messages[0][1]).toBeLessThan(0) // But with negative multiplicity
@@ -172,7 +172,7 @@ function testJoin() {
       [
         [1, [`a`, `x`]], // Only key 1 should remain in final results
       ],
-      4 // Expected message count
+      4, // Expected message count
     )
   })
 
@@ -186,7 +186,7 @@ function testJoin() {
       join(inputB),
       output((message) => {
         tracker.addMessage(message as MultiSet<[string, [string, string]]>)
-      })
+      }),
     )
 
     graph.finalize()
@@ -196,14 +196,14 @@ function testJoin() {
       new MultiSet([
         [[`key1`, `batch1_a`], 1],
         [[`key2`, `batch1_b`], 1],
-      ])
+      ]),
     )
 
     inputA.sendData(
       new MultiSet([
         [[`key3`, `batch2_a`], 1],
         [[`key4`, `batch2_b`], 1],
-      ])
+      ]),
     )
 
     inputA.sendData(new MultiSet([[[`key5`, `batch3_a`], 1]]))
@@ -216,7 +216,7 @@ function testJoin() {
         [[`key3`, `x3`], 1],
         [[`key4`, `x4`], 1],
         [[`key5`, `x5`], 1],
-      ])
+      ]),
     )
 
     // Run the graph - should process all batches
@@ -229,7 +229,7 @@ function testJoin() {
     assertOnlyKeysAffected(
       `join multiple batches`,
       result.messages,
-      expectedKeys
+      expectedKeys,
     )
 
     // Assert the final materialized results are correct
@@ -243,7 +243,7 @@ function testJoin() {
         [`key4`, [`batch2_b`, `x4`]],
         [`key5`, [`batch3_a`, `x5`]],
       ],
-      10 // Expected message count
+      10, // Expected message count
     )
   })
 
@@ -258,7 +258,7 @@ function testJoin() {
       join(inputB1),
       output((message) => {
         stepTracker.addMessage(message as MultiSet<[string, [string, string]]>)
-      })
+      }),
     )
 
     graph1.finalize()
@@ -269,7 +269,7 @@ function testJoin() {
         [[`item1`, `x1`], 1],
         [[`item2`, `x2`], 1],
         [[`item3`, `x3`], 1],
-      ])
+      ]),
     )
 
     // Send and process inputA one batch at a time
@@ -292,7 +292,7 @@ function testJoin() {
       join(inputB2),
       output((message) => {
         batchTracker.addMessage(message as MultiSet<[string, [string, string]]>)
-      })
+      }),
     )
 
     graph2.finalize()
@@ -303,7 +303,7 @@ function testJoin() {
         [[`item1`, `x1`], 1],
         [[`item2`, `x2`], 1],
         [[`item3`, `x3`], 1],
-      ])
+      ]),
     )
 
     // Send all inputA batches then run once
@@ -320,12 +320,12 @@ function testJoin() {
     assertOnlyKeysAffected(
       `join step-by-step`,
       stepResult.messages,
-      expectedKeys
+      expectedKeys,
     )
     assertOnlyKeysAffected(
       `join batch processing`,
       batchResult.messages,
-      expectedKeys
+      expectedKeys,
     )
 
     // Both approaches should produce the same final materialized results
diff --git a/packages/db-ivm/tests/operators/keying-types.test.ts b/packages/db-ivm/tests/operators/keying-types.test.ts
index 3baef7e51..d7c0256c9 100644
--- a/packages/db-ivm/tests/operators/keying-types.test.ts
+++ b/packages/db-ivm/tests/operators/keying-types.test.ts
@@ -1,8 +1,8 @@
-import { describe, expectTypeOf, it } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { keyBy, rekey, unkey } from "../../src/operators/keying.js"
-import type { Keyed } from "../../src/operators/keying.js"
-import type { IStreamBuilder } from "../../src/types.js"
+import { describe, expectTypeOf, it } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { keyBy, rekey, unkey } from '../../src/operators/keying.js'
+import type { Keyed } from '../../src/operators/keying.js'
+import type { IStreamBuilder } from '../../src/types.js'
 
 interface TestItem {
   id: number
diff --git a/packages/db-ivm/tests/operators/keying.test.ts b/packages/db-ivm/tests/operators/keying.test.ts
index ec435af2f..22614e944 100644
--- a/packages/db-ivm/tests/operators/keying.test.ts
+++ b/packages/db-ivm/tests/operators/keying.test.ts
@@ -1,8 +1,8 @@
-import { describe, expect, it } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { keyBy, rekey, unkey } from "../../src/operators/keying.js"
-import { output } from "../../src/operators/index.js"
-import { MultiSet } from "../../src/multiset.js"
+import { describe, expect, it } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { keyBy, rekey, unkey } from '../../src/operators/keying.js'
+import { output } from '../../src/operators/index.js'
+import { MultiSet } from '../../src/multiset.js'
 
 interface TestItem {
   id: number
diff --git a/packages/db-ivm/tests/operators/map.test.ts b/packages/db-ivm/tests/operators/map.test.ts
index f331acfd6..39d1f1675 100644
--- a/packages/db-ivm/tests/operators/map.test.ts
+++ b/packages/db-ivm/tests/operators/map.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { map, output } from "../../src/operators/index.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { map, output } from '../../src/operators/index.js'
 
 describe(`Operators`, () => {
   describe(`Map operation`, () => {
@@ -14,7 +14,7 @@ describe(`Operators`, () => {
         map((x) => x + 5),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -24,7 +24,7 @@ describe(`Operators`, () => {
           [1, 1],
           [2, 1],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -48,7 +48,7 @@ describe(`Operators`, () => {
         map((x) => x + 1),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -58,7 +58,7 @@ describe(`Operators`, () => {
           [1, 1],
           [2, 1],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -81,7 +81,7 @@ describe(`Operators`, () => {
         map((x) => x + 1),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -91,7 +91,7 @@ describe(`Operators`, () => {
           [1, -1],
           [2, -2],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
diff --git a/packages/db-ivm/tests/operators/negate.test.ts b/packages/db-ivm/tests/operators/negate.test.ts
index fa3ef928c..53a793703 100644
--- a/packages/db-ivm/tests/operators/negate.test.ts
+++ b/packages/db-ivm/tests/operators/negate.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { map, negate, output } from "../../src/operators/index.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { map, negate, output } from '../../src/operators/index.js'
 
 describe(`Operators`, () => {
   describe(`Negate operation`, () => {
@@ -14,7 +14,7 @@ describe(`Operators`, () => {
         negate(),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -24,7 +24,7 @@ describe(`Operators`, () => {
           [1, 1],
           [2, 1],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -47,7 +47,7 @@ describe(`Operators`, () => {
         negate(),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -57,7 +57,7 @@ describe(`Operators`, () => {
           [1, -1],
           [2, -2],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -80,7 +80,7 @@ describe(`Operators`, () => {
         negate(),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -90,7 +90,7 @@ describe(`Operators`, () => {
           [1, -2],
           [2, 1],
           [3, -3],
-        ])
+        ]),
       )
 
       graph.run()
@@ -115,7 +115,7 @@ describe(`Operators`, () => {
         map((x) => x + 1),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -124,7 +124,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [1, 1],
           [2, 1],
-        ])
+        ]),
       )
 
       graph.run()
diff --git a/packages/db-ivm/tests/operators/orderBy.test.ts b/packages/db-ivm/tests/operators/orderBy.test.ts
index 53ebcca0c..18ec280fd 100644
--- a/packages/db-ivm/tests/operators/orderBy.test.ts
+++ b/packages/db-ivm/tests/operators/orderBy.test.ts
@@ -1,8 +1,8 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { orderBy, output } from "../../src/operators/index.js"
-import type { KeyValue } from "../../src/types.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { orderBy, output } from '../../src/operators/index.js'
+import type { KeyValue } from '../../src/types.js'
 
 describe(`Operators`, () => {
   describe(`OrderBy operation`, () => {
@@ -23,7 +23,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -35,7 +35,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -72,7 +72,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -84,7 +84,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -119,7 +119,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value, { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -131,7 +131,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -164,7 +164,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value, { limit: 2, offset: 2 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -176,7 +176,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -208,7 +208,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.id),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -220,7 +220,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 1, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 2, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -255,7 +255,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -266,7 +266,7 @@ describe(`Operators`, () => {
           [[`key1`, { id: 1, value: `c` }], 1],
           [[`key2`, { id: 2, value: `d` }], 1],
           [[`key3`, { id: 3, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -283,7 +283,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`key4`, { id: 4, value: `a` }], 1],
           [[`key5`, { id: 5, value: `b` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -312,7 +312,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -324,7 +324,7 @@ describe(`Operators`, () => {
           [[`key2`, { id: 2, value: `b` }], 1],
           [[`key3`, { id: 3, value: `c` }], 1],
           [[`key4`, { id: 4, value: `d` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -365,7 +365,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value, { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -376,7 +376,7 @@ describe(`Operators`, () => {
           [[`key1`, { id: 1, value: `c` }], 1],
           [[`key2`, { id: 2, value: `d` }], 1],
           [[`key3`, { id: 3, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -417,7 +417,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value, { limit: 2, offset: 1 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -429,7 +429,7 @@ describe(`Operators`, () => {
           [[`key2`, { id: 2, value: `b` }], 1],
           [[`key3`, { id: 3, value: `c` }], 1],
           [[`key4`, { id: 4, value: `d` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -469,7 +469,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -480,7 +480,7 @@ describe(`Operators`, () => {
           [[`key1`, { id: 1, value: `a` }], 1],
           [[`key2`, { id: 2, value: `c` }], 1],
           [[`key3`, { id: 3, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -497,7 +497,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`key2`, { id: 2, value: `c` }], -1], // Remove old version
           [[`key2`, { id: 2, value: `z` }], 1], // Add new version with different value
-        ])
+        ]),
       )
       graph.run()
 
@@ -518,10 +518,10 @@ function sortResults(results: Array<any>) {
   return [...results]
     .sort(
       ([[_aKey, _aValue], aMultiplicity], [[_bKey, _bValue], bMultiplicity]) =>
-        aMultiplicity - bMultiplicity
+        aMultiplicity - bMultiplicity,
     )
     .sort(
       ([[aKey, _aValue], _aMultiplicity], [[bKey, _bValue], _bMultiplicity]) =>
-        aKey.localeCompare(bKey)
+        aKey.localeCompare(bKey),
     )
 }
diff --git a/packages/db-ivm/tests/operators/orderByWithFractionalIndex.test.ts b/packages/db-ivm/tests/operators/orderByWithFractionalIndex.test.ts
index 5cf574757..4dc16430f 100644
--- a/packages/db-ivm/tests/operators/orderByWithFractionalIndex.test.ts
+++ b/packages/db-ivm/tests/operators/orderByWithFractionalIndex.test.ts
@@ -1,14 +1,14 @@
-import { beforeAll, describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
+import { beforeAll, describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
 import {
   orderByWithFractionalIndex,
   output,
-} from "../../src/operators/index.js"
-import { orderByWithFractionalIndexBTree } from "../../src/operators/orderByBTree.js"
-import { loadBTree } from "../../src/operators/topKWithFractionalIndexBTree.js"
-import { MessageTracker, compareFractionalIndex } from "../test-utils.js"
-import type { KeyValue } from "../../src/types.js"
+} from '../../src/operators/index.js'
+import { orderByWithFractionalIndexBTree } from '../../src/operators/orderByBTree.js'
+import { loadBTree } from '../../src/operators/topKWithFractionalIndexBTree.js'
+import { MessageTracker, compareFractionalIndex } from '../test-utils.js'
+import type { KeyValue } from '../../src/types.js'
 
 const stripFractionalIndex = ([[key, [value, _index]], multiplicity]: any) => [
   key,
@@ -17,7 +17,7 @@ const stripFractionalIndex = ([[key, [value, _index]], multiplicity]: any) => [
 ]
 
 const stripFractionalIndexWithoutMultiplicity = (
-  r: [string, [{ id: number; value: string }, string]]
+  r: [string, [{ id: number; value: string }, string]],
 ) => [r[0], r[1][0]]
 
 beforeAll(async () => {
@@ -46,7 +46,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -58,7 +58,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -96,7 +96,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -108,7 +108,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -144,7 +144,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value, { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -156,7 +156,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -193,7 +193,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -205,7 +205,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -238,7 +238,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.id),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -250,7 +250,7 @@ describe(`Operators`, () => {
           [[`key1`, { id: 1, value: `a` }], 1],
           [[`key4`, { id: 4, value: `d` }], 1],
           [[`key2`, { id: 2, value: `b` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -286,7 +286,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value, { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -297,7 +297,7 @@ describe(`Operators`, () => {
           [[`key1`, { id: 1, value: `a` }], 1],
           [[`key3`, { id: 3, value: `c` }], 1],
           [[`key2`, { id: 2, value: `b` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -317,7 +317,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [[`key4`, { id: 4, value: `aa` }], 1], // Should be second in order
-        ])
+        ]),
       )
       graph.run()
 
@@ -352,7 +352,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value, { limit: 3 }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -364,7 +364,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `c` }], 1],
           [[`key2`, { id: 2, value: `b` }], 1],
           [[`key4`, { id: 4, value: `d` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -374,7 +374,9 @@ describe(`Operators`, () => {
       expect(initialResult.messageCount).toBeLessThanOrEqual(4) // Should be efficient
 
       expect(
-        initialResult.sortedResults.map(stripFractionalIndexWithoutMultiplicity)
+        initialResult.sortedResults.map(
+          stripFractionalIndexWithoutMultiplicity,
+        ),
       ).toEqual([
         [`key1`, { id: 1, value: `a` }],
         [`key2`, { id: 2, value: `b` }],
@@ -387,7 +389,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [[`key1`, { id: 1, value: `a` }], -1], // Remove the first item
-        ])
+        ]),
       )
       graph.run()
 
@@ -424,7 +426,7 @@ describe(`Operators`, () => {
         orderBy((item) => item.value, { limit: 3 }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -436,14 +438,16 @@ describe(`Operators`, () => {
           [[`key2`, { id: 2, value: `c` }], 1],
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `d` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
       // Should have the top 3 items by value
       const initialResult = tracker.getResult(compareFractionalIndex)
       expect(
-        initialResult.sortedResults.map(stripFractionalIndexWithoutMultiplicity)
+        initialResult.sortedResults.map(
+          stripFractionalIndexWithoutMultiplicity,
+        ),
       ).toEqual([
         [`key1`, { id: 1, value: `a` }],
         [`key3`, { id: 3, value: `b` }],
@@ -458,7 +462,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`key2`, { id: 2, value: `c` }], -1], // Remove old version
           [[`key2`, { id: 2, value: `z` }], 1], // Add new version with different value
-        ])
+        ]),
       )
       graph.run()
 
@@ -510,7 +514,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -524,7 +528,7 @@ describe(`Operators`, () => {
           [[`key4`, { id: 4, value: `d` }], 1],
           [[`key5`, { id: 5, value: `e` }], 1],
           [[`key6`, { id: 6, value: `f` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -535,7 +539,7 @@ describe(`Operators`, () => {
 
       // Verify initial order
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`a`, `b`, `c`])
 
@@ -550,7 +554,7 @@ describe(`Operators`, () => {
 
       // Should now show d, e, f
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`d`, `e`, `f`])
     })
@@ -584,7 +588,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -598,7 +602,7 @@ describe(`Operators`, () => {
           [[`key4`, { id: 4, value: `d` }], 1],
           [[`key5`, { id: 5, value: `e` }], 1],
           [[`key6`, { id: 6, value: `f` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -609,7 +613,7 @@ describe(`Operators`, () => {
 
       // Verify initial order
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`d`, `e`, `f`])
 
@@ -624,7 +628,7 @@ describe(`Operators`, () => {
 
       // Should now show a, b, c
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`a`, `b`, `c`])
     })
@@ -658,7 +662,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -671,7 +675,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `c` }], 1],
           [[`key4`, { id: 4, value: `d` }], 1],
           [[`key5`, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -680,7 +684,7 @@ describe(`Operators`, () => {
       expect(initialResult.sortedResults.length).toBe(2)
 
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`a`, `b`])
 
@@ -691,7 +695,7 @@ describe(`Operators`, () => {
       const moveResult = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`b`, `c`])
 
@@ -702,7 +706,7 @@ describe(`Operators`, () => {
       const moveResult2 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues2 = moveResult2.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues2).toEqual([`c`, `d`])
 
@@ -713,7 +717,7 @@ describe(`Operators`, () => {
       const moveResult3 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues3 = moveResult3.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues3).toEqual([`a`, `b`])
     })
@@ -747,7 +751,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -761,7 +765,7 @@ describe(`Operators`, () => {
           [[`key4`, { id: 4, value: `d` }], 1],
           [[`key5`, { id: 5, value: `e` }], 1],
           [[`key6`, { id: 6, value: `f` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -770,7 +774,7 @@ describe(`Operators`, () => {
       expect(initialResult.sortedResults.length).toBe(2)
 
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`b`, `c`])
 
@@ -781,7 +785,7 @@ describe(`Operators`, () => {
       const moveResult = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`b`, `c`, `d`])
 
@@ -792,7 +796,7 @@ describe(`Operators`, () => {
       const moveResult2 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues2 = moveResult2.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues2).toEqual([`b`])
     })
@@ -826,7 +830,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -837,7 +841,7 @@ describe(`Operators`, () => {
           [[`key1`, { id: 1, value: `a` }], 1],
           [[`key2`, { id: 2, value: `b` }], 1],
           [[`key3`, { id: 3, value: `c` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -846,7 +850,7 @@ describe(`Operators`, () => {
       expect(initialResult.sortedResults.length).toBe(2)
 
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`a`, `b`])
 
@@ -857,7 +861,7 @@ describe(`Operators`, () => {
       const moveResult = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`c`]) // Only 1 element available at offset 2
 
@@ -868,7 +872,7 @@ describe(`Operators`, () => {
       const moveResult2 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues2 = moveResult2.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues2).toEqual([]) // No elements available at offset 5
 
@@ -879,7 +883,7 @@ describe(`Operators`, () => {
       const moveResult3 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues3 = moveResult3.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues3).toEqual([])
 
@@ -890,7 +894,7 @@ describe(`Operators`, () => {
       const moveResult4 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues4 = moveResult4.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues4).toEqual([`a`, `b`])
     })
@@ -905,23 +909,23 @@ function sortByKeyAndIndex(results: Array<any>) {
     .sort(
       (
         [[_aKey, [_aValue, _aIndex]], aMultiplicity],
-        [[_bKey, [_bValue, _bIndex]], bMultiplicity]
-      ) => aMultiplicity - bMultiplicity
+        [[_bKey, [_bValue, _bIndex]], bMultiplicity],
+      ) => aMultiplicity - bMultiplicity,
     )
     .sort(
       (
         [[aKey, [_aValue, _aIndex]], _aMultiplicity],
-        [[bKey, [_bValue, _bIndex]], _bMultiplicity]
-      ) => aKey - bKey
+        [[bKey, [_bValue, _bIndex]], _bMultiplicity],
+      ) => aKey - bKey,
     )
     .sort(
       (
         [[_aKey, [_aValue, aIndex]], _aMultiplicity],
-        [[_bKey, [_bValue, bIndex]], _bMultiplicity]
+        [[_bKey, [_bValue, bIndex]], _bMultiplicity],
       ) => {
         // lexically compare the index
         // return aIndex.localeCompare(bIndex)
         return aIndex < bIndex ? -1 : aIndex > bIndex ? 1 : 0
-      }
+      },
     )
 }
diff --git a/packages/db-ivm/tests/operators/orderByWithIndex.test.ts b/packages/db-ivm/tests/operators/orderByWithIndex.test.ts
index cf7466081..09e40e673 100644
--- a/packages/db-ivm/tests/operators/orderByWithIndex.test.ts
+++ b/packages/db-ivm/tests/operators/orderByWithIndex.test.ts
@@ -1,8 +1,8 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { orderByWithIndex, output } from "../../src/operators/index.js"
-import type { KeyValue } from "../../src/types.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { orderByWithIndex, output } from '../../src/operators/index.js'
+import type { KeyValue } from '../../src/types.js'
 
 describe(`Operators`, () => {
   describe(`OrderByWithIndex operation`, () => {
@@ -23,7 +23,7 @@ describe(`Operators`, () => {
         orderByWithIndex((item) => item.value),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -35,7 +35,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -73,7 +73,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -85,7 +85,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -121,7 +121,7 @@ describe(`Operators`, () => {
         orderByWithIndex((item) => item.value, { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -133,7 +133,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -167,7 +167,7 @@ describe(`Operators`, () => {
         orderByWithIndex((item) => item.value, { limit: 2, offset: 2 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -179,7 +179,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `y` }], 1],
           [[`key5`, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -212,7 +212,7 @@ describe(`Operators`, () => {
         orderByWithIndex((item) => item.id),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -224,7 +224,7 @@ describe(`Operators`, () => {
           [[`key1`, { id: 1, value: `a` }], 1],
           [[`key4`, { id: 4, value: `d` }], 1],
           [[`key2`, { id: 2, value: `b` }], 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -260,7 +260,7 @@ describe(`Operators`, () => {
         orderByWithIndex((item) => item.value, { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -271,7 +271,7 @@ describe(`Operators`, () => {
           [[`key1`, { id: 1, value: `a` }], 1],
           [[`key3`, { id: 3, value: `c` }], 1],
           [[`key2`, { id: 2, value: `b` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -290,7 +290,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [[`key4`, { id: 4, value: `aa` }], 1], // Should be second in order
-        ])
+        ]),
       )
       graph.run()
 
@@ -325,7 +325,7 @@ describe(`Operators`, () => {
         orderByWithIndex((item) => item.value, { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -337,7 +337,7 @@ describe(`Operators`, () => {
           [[`key3`, { id: 3, value: `c` }], 1],
           [[`key2`, { id: 2, value: `b` }], 1],
           [[`key4`, { id: 4, value: `d` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -345,7 +345,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [[`key1`, { id: 1, value: `a` }], -1], // Remove the first item
-        ])
+        ]),
       )
       graph.run()
 
@@ -383,7 +383,7 @@ describe(`Operators`, () => {
         orderByWithIndex((item) => item.value, { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -395,7 +395,7 @@ describe(`Operators`, () => {
           [[`key2`, { id: 2, value: `c` }], 1],
           [[`key3`, { id: 3, value: `b` }], 1],
           [[`key4`, { id: 4, value: `d` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -415,7 +415,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`key2`, { id: 2, value: `c` }], -1], // Remove old version
           [[`key2`, { id: 2, value: `z` }], 1], // Add new version with different value
-        ])
+        ]),
       )
       graph.run()
 
@@ -440,19 +440,19 @@ function sortByKeyAndIndex(results: Array<any>) {
     .sort(
       (
         [[_aKey, [_aValue, _aIndex]], aMultiplicity],
-        [[_bKey, [_bValue, _bIndex]], bMultiplicity]
-      ) => aMultiplicity - bMultiplicity
+        [[_bKey, [_bValue, _bIndex]], bMultiplicity],
+      ) => aMultiplicity - bMultiplicity,
     )
     .sort(
       (
         [[aKey, [_aValue, _aIndex]], _aMultiplicity],
-        [[bKey, [_bValue, _bIndex]], _bMultiplicity]
-      ) => aKey - bKey
+        [[bKey, [_bValue, _bIndex]], _bMultiplicity],
+      ) => aKey - bKey,
     )
     .sort(
       (
         [[_aKey, [_aValue, _aIndex]], _aMultiplicity],
-        [[_bKey, [_bValue, _bIndex]], _bMultiplicity]
-      ) => _aIndex - _bIndex
+        [[_bKey, [_bValue, _bIndex]], _bMultiplicity],
+      ) => _aIndex - _bIndex,
     )
 }
diff --git a/packages/db-ivm/tests/operators/output.test.ts b/packages/db-ivm/tests/operators/output.test.ts
index 14bfd92ab..487e04ce7 100644
--- a/packages/db-ivm/tests/operators/output.test.ts
+++ b/packages/db-ivm/tests/operators/output.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { output } from "../../src/operators/index.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { output } from '../../src/operators/index.js'
 
 describe(`Operators`, () => {
   describe(`Output operation`, () => {
@@ -13,7 +13,7 @@ describe(`Operators`, () => {
       input.pipe(
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -23,7 +23,7 @@ describe(`Operators`, () => {
           [1, 1],
           [2, 1],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
@@ -45,7 +45,7 @@ describe(`Operators`, () => {
       input.pipe(
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -55,7 +55,7 @@ describe(`Operators`, () => {
           [1, -1],
           [2, -2],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
diff --git a/packages/db-ivm/tests/operators/pipe.test.ts b/packages/db-ivm/tests/operators/pipe.test.ts
index 6589780c3..70f42bb47 100644
--- a/packages/db-ivm/tests/operators/pipe.test.ts
+++ b/packages/db-ivm/tests/operators/pipe.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { map, output, pipe } from "../../src/operators/index.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { map, output, pipe } from '../../src/operators/index.js'
 
 describe(`Operators`, () => {
   describe(`Pipe operation`, () => {
@@ -13,11 +13,11 @@ describe(`Operators`, () => {
       input.pipe(
         pipe(
           map((x) => x + 5),
-          map((x) => x * 2)
+          map((x) => x * 2),
         ),
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -27,7 +27,7 @@ describe(`Operators`, () => {
           [1, 1],
           [2, 1],
           [3, 1],
-        ])
+        ]),
       )
 
       graph.run()
diff --git a/packages/db-ivm/tests/operators/reduce.test.ts b/packages/db-ivm/tests/operators/reduce.test.ts
index f1e5de511..31998920e 100644
--- a/packages/db-ivm/tests/operators/reduce.test.ts
+++ b/packages/db-ivm/tests/operators/reduce.test.ts
@@ -1,13 +1,13 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { reduce } from "../../src/operators/reduce.js"
-import { output } from "../../src/operators/output.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { reduce } from '../../src/operators/reduce.js'
+import { output } from '../../src/operators/output.js'
 import {
   KeyedMessageTracker,
   assertKeyedResults,
   assertOnlyKeysAffected,
-} from "../test-utils.js"
+} from '../test-utils.js'
 
 describe(`Operators`, () => {
   describe(`Reduce operation`, () => {
@@ -26,7 +26,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -37,7 +37,7 @@ describe(`Operators`, () => {
           [[`a`, 2], 1],
           [[`a`, 3], 1],
           [[`b`, 4], 1],
-        ])
+        ]),
       )
       input.sendData(new MultiSet([[[`b`, 5], 1]]))
       graph.run()
@@ -58,7 +58,7 @@ describe(`Operators`, () => {
           [`a`, 7], // 1*2 + 2*1 + 3*1 = 7
           [`b`, 9], // 4*1 + 5*1 = 9
         ],
-        4 // Expected message count
+        4, // Expected message count
       )
     })
 
@@ -77,7 +77,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -87,7 +87,7 @@ describe(`Operators`, () => {
           [[`a`, 1], -1],
           [[`a`, 2], 2],
           [[`b`, 3], -2],
-        ])
+        ]),
       )
       graph.run()
 
@@ -97,7 +97,7 @@ describe(`Operators`, () => {
       assertOnlyKeysAffected(
         `reduce with negative multiplicities`,
         result.messages,
-        [`a`, `b`]
+        [`a`, `b`],
       )
 
       // Assert the final materialized results are correct
@@ -108,7 +108,7 @@ describe(`Operators`, () => {
           [`a`, 3], // 1*(-1) + 2*2 = 3
           [`b`, -6], // 3*(-2) = -6
         ],
-        4 // Expected message count
+        4, // Expected message count
       )
     })
 
@@ -127,7 +127,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -137,7 +137,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`a`, 1], 1],
           [[`b`, 2], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -153,7 +153,7 @@ describe(`Operators`, () => {
           [`a`, 1],
           [`b`, 2],
         ],
-        4 // Expected message count
+        4, // Expected message count
       )
 
       tracker.reset()
@@ -163,7 +163,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`a`, 3], 1],
           [[`b`, 4], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -179,7 +179,7 @@ describe(`Operators`, () => {
           [`a`, 4], // 1+3
           [`b`, 6], // 2+4
         ],
-        6 // Expected message count (old removed, new added for both keys)
+        6, // Expected message count (old removed, new added for both keys)
       )
 
       tracker.reset()
@@ -197,7 +197,7 @@ describe(`Operators`, () => {
         [
           [`a`, 3], // 4-1=3
         ],
-        3 // Expected message count (old removed, new added for key a)
+        3, // Expected message count (old removed, new added for key a)
       )
     })
 
@@ -216,7 +216,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -227,7 +227,7 @@ describe(`Operators`, () => {
           [[`a`, 5], 1],
           [[`a`, 3], 1],
           [[`b`, 10], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -236,7 +236,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`a`, 5], -1],
           [[`a`, 3], -1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -246,7 +246,7 @@ describe(`Operators`, () => {
       assertOnlyKeysAffected(
         `updates that cancel out completely`,
         result.messages,
-        [`a`, `b`]
+        [`a`, `b`],
       )
 
       // Assert the final materialized results are correct
@@ -257,7 +257,7 @@ describe(`Operators`, () => {
           [`a`, 0], // 5+3-5-3 = 0
           [`b`, 10], // 10 (unchanged)
         ],
-        6 // Expected message count
+        6, // Expected message count
       )
     })
 
@@ -276,7 +276,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -287,7 +287,7 @@ describe(`Operators`, () => {
           [[`a`, 10], 1],
           [[`a`, 5], 2],
           [[`b`, 20], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -299,7 +299,7 @@ describe(`Operators`, () => {
           [[`b`, 20], -1], // Remove the 20
           [[`b`, 15], 1], // Add a 15
           [[`c`, 100], 1], // Add new key
-        ])
+        ]),
       )
       graph.run()
 
@@ -309,7 +309,7 @@ describe(`Operators`, () => {
       assertOnlyKeysAffected(
         `mixed positive and negative updates`,
         result.messages,
-        [`a`, `b`, `c`]
+        [`a`, `b`, `c`],
       )
 
       // Assert the final materialized results are correct
@@ -321,7 +321,7 @@ describe(`Operators`, () => {
           [`b`, 15], // 20-20+15 = 15
           [`c`, 100], // 100
         ],
-        8 // Expected message count
+        8, // Expected message count
       )
     })
 
@@ -346,7 +346,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -356,7 +356,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`a`, { value: 10, count: 2 }], 1], // 2 values of 10
           [[`a`, { value: 20, count: 1 }], 1], // 1 value of 20
-        ])
+        ]),
       )
       graph.run()
 
@@ -365,7 +365,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`a`, { value: 30, count: 1 }], 1], // 1 value of 30
           [[`b`, { value: 50, count: 3 }], 1], // 3 values of 50
-        ])
+        ]),
       )
       graph.run()
 
@@ -373,7 +373,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [[`a`, { value: 10, count: 2 }], -1], // Remove the 2 values of 10
-        ])
+        ]),
       )
       graph.run()
 
@@ -383,7 +383,7 @@ describe(`Operators`, () => {
       assertOnlyKeysAffected(
         `complex aggregation with multiple updates`,
         result.messages,
-        [`a`, `b`]
+        [`a`, `b`],
       )
 
       // Assert the final materialized results are correct
@@ -394,7 +394,7 @@ describe(`Operators`, () => {
           [`a`, { avg: 25, total: 50 }], // Final: (20*1+30*1)/(1+1) = 50/2 = 25
           [`b`, { avg: 50, total: 150 }], // Final: 50*3 = 150
         ],
-        6 // Expected message count
+        6, // Expected message count
       )
     })
 
@@ -414,7 +414,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -425,7 +425,7 @@ describe(`Operators`, () => {
           [[`a`, 5], 1],
           [[`a`, -3], 1],
           [[`b`, 10], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -443,7 +443,7 @@ describe(`Operators`, () => {
       assertOnlyKeysAffected(
         `updates with zero-multiplicity results`,
         result.messages,
-        [`a`, `b`]
+        [`a`, `b`],
       )
 
       // Assert the final materialized results are correct
@@ -454,7 +454,7 @@ describe(`Operators`, () => {
           [`a`, 7], // Final: 5-3-2+7 = 7
           [`b`, 10], // Final: 10 (unchanged)
         ],
-        5 // Expected message count
+        5, // Expected message count
       )
     })
 
@@ -473,7 +473,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -487,7 +487,7 @@ describe(`Operators`, () => {
           [[`y`, 15], 1],
           [[`y`, 25], 1],
           [[`z`, 100], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -499,7 +499,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`x`, 30], 1], // Add to 'x' (30 -> 60)
           [[`z`, 100], -1], // Remove from 'z' (100 -> 0)
-        ])
+        ]),
       )
       graph.run()
 
@@ -519,7 +519,7 @@ describe(`Operators`, () => {
           [`x`, 60], // Sum increased from 30 to 60
           [`z`, 0], // Sum decreased from 100 to 0
         ],
-        4 // Expected message count: remove old 'x', add new 'x', remove old 'z', add new 'z'
+        4, // Expected message count: remove old 'x', add new 'x', remove old 'z', add new 'z'
       )
     })
 
@@ -539,7 +539,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -552,7 +552,7 @@ describe(`Operators`, () => {
           [[`b`, { id: 3, value: 100 }], 1],
           [[`c`, { id: 4, value: 5 }], 1],
           [[`c`, { id: 5, value: 15 }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -565,7 +565,7 @@ describe(`Operators`, () => {
           [[`a`, { id: 1, value: 10 }], -1], // Remove 10
           [[`a`, { id: 6, value: 10 }], 1], // Add 10 (same value, different object)
           [[`b`, { id: 3, value: 100 }], -1], // Remove from 'b' (100 -> 0)
-        ])
+        ]),
       )
       graph.run()
 
@@ -574,7 +574,7 @@ describe(`Operators`, () => {
       // With object identity: 'a' produces messages even though content is identical
       // This demonstrates the object identity issue, but keysTodo should still limit processing
       const aMessages = result.messages.filter(
-        ([[key, _value], _mult]) => key === `a`
+        ([[key, _value], _mult]) => key === `a`,
       )
       expect(aMessages.length).toBe(2) // Object identity causes 2 messages (remove + add)
 
@@ -585,7 +585,7 @@ describe(`Operators`, () => {
         [
           [`b`, { result: 0 }], // Changed from 100 to 0
         ],
-        4 // With object identity: 4 messages total (2 for 'a', 2 for 'b')
+        4, // With object identity: 4 messages total (2 for 'a', 2 for 'b')
       )
     })
   })
diff --git a/packages/db-ivm/tests/operators/topK.test.ts b/packages/db-ivm/tests/operators/topK.test.ts
index b35adf4b3..486e5469b 100644
--- a/packages/db-ivm/tests/operators/topK.test.ts
+++ b/packages/db-ivm/tests/operators/topK.test.ts
@@ -1,8 +1,8 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { topK } from "../../src/operators/topK.js"
-import { output } from "../../src/operators/output.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { topK } from '../../src/operators/topK.js'
+import { output } from '../../src/operators/output.js'
 
 describe(`Operators`, () => {
   describe(`TopK operation`, () => {
@@ -23,7 +23,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -35,7 +35,7 @@ describe(`Operators`, () => {
           [[null, { id: 3, value: `b` }], 1],
           [[null, { id: 4, value: `y` }], 1],
           [[null, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -69,7 +69,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -81,7 +81,7 @@ describe(`Operators`, () => {
           [[null, { id: 3, value: `b` }], 1],
           [[null, { id: 4, value: `y` }], 1],
           [[null, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -113,7 +113,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -130,7 +130,7 @@ describe(`Operators`, () => {
           [[`two`, { id: 8, value: `2` }], 1],
           [[`two`, { id: 9, value: `1` }], 1],
           [[`two`, { id: 10, value: `0` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -168,7 +168,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -185,7 +185,7 @@ describe(`Operators`, () => {
           [[`two`, { id: 8, value: `2` }], 1],
           [[`two`, { id: 9, value: `1` }], 1],
           [[`two`, { id: 10, value: `0` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -221,7 +221,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -232,7 +232,7 @@ describe(`Operators`, () => {
           [[null, { id: 1, value: `d` }], 1],
           [[null, { id: 2, value: `e` }], 1],
           [[null, { id: 3, value: `f` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -273,7 +273,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -285,7 +285,7 @@ describe(`Operators`, () => {
           [[null, { id: 2, value: `b` }], 1],
           [[null, { id: 3, value: `c` }], 1],
           [[null, { id: 4, value: `d` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -326,7 +326,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -337,7 +337,7 @@ describe(`Operators`, () => {
           [[null, { id: 1, value: `c` }], 1],
           [[null, { id: 2, value: `d` }], 1],
           [[null, { id: 3, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -354,7 +354,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[null, { id: 4, value: `a` }], 1],
           [[null, { id: 5, value: `b` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -388,7 +388,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -400,7 +400,7 @@ describe(`Operators`, () => {
           [[null, { id: 2, value: `b` }], 1],
           [[null, { id: 3, value: `c` }], 1],
           [[null, { id: 4, value: `d` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -415,7 +415,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [[null, { id: 5, value: `0` }], 1], // Should be first alphabetically
-        ])
+        ]),
       )
       graph.run()
 
@@ -444,7 +444,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value), { limit: 2 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -458,7 +458,7 @@ describe(`Operators`, () => {
           [[`group2`, { id: 4, value: `a` }], 1],
           [[`group2`, { id: 5, value: `b` }], 1],
           [[`group2`, { id: 6, value: `f` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -477,7 +477,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[`group1`, { id: 7, value: `a` }], 1], // Should be first in group1
           [[`group2`, { id: 4, value: `a` }], -1], // Remove from group2
-        ])
+        ]),
       )
       graph.run()
 
@@ -511,7 +511,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -524,7 +524,7 @@ describe(`Operators`, () => {
           [[null, { id: 3, value: `c` }], 1],
           [[null, { id: 4, value: `d` }], 1],
           [[null, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -545,7 +545,7 @@ describe(`Operators`, () => {
           [[null, { id: 3, value: `c` }], -1],
           [[null, { id: 6, value: `_` }], 1],
           [[null, { id: 7, value: `aa` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -566,7 +566,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[null, { id: 1, value: `a` }], -1],
           [[null, { id: 8, value: `z` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -590,10 +590,10 @@ function sortResults(results: Array<any>) {
   return [...results]
     .sort(
       ([_a, aMultiplicity], [_b, bMultiplicity]) =>
-        aMultiplicity - bMultiplicity
+        aMultiplicity - bMultiplicity,
     )
     .sort(
       ([[_aKey, aValue], _aMultiplicity], [[_bKey, bValue], _bMultiplicity]) =>
-        aValue.id - bValue.id
+        aValue.id - bValue.id,
     )
 }
diff --git a/packages/db-ivm/tests/operators/topKWithFractionalIndex.test.ts b/packages/db-ivm/tests/operators/topKWithFractionalIndex.test.ts
index 5739cfb36..77afb3ca2 100644
--- a/packages/db-ivm/tests/operators/topKWithFractionalIndex.test.ts
+++ b/packages/db-ivm/tests/operators/topKWithFractionalIndex.test.ts
@@ -1,17 +1,17 @@
-import { beforeAll, describe, expect, it } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { topKWithFractionalIndex } from "../../src/operators/topKWithFractionalIndex.js"
+import { beforeAll, describe, expect, it } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { topKWithFractionalIndex } from '../../src/operators/topKWithFractionalIndex.js'
 import {
   loadBTree,
   topKWithFractionalIndexBTree,
-} from "../../src/operators/topKWithFractionalIndexBTree.js"
-import { output } from "../../src/operators/index.js"
+} from '../../src/operators/topKWithFractionalIndexBTree.js'
+import { output } from '../../src/operators/index.js'
 import {
   MessageTracker,
   assertOnlyKeysAffected,
   compareFractionalIndex,
-} from "../test-utils.js"
+} from '../test-utils.js'
 
 // Helper function to check if indices are in lexicographic order
 function checkLexicographicOrder(results: Array<any>) {
@@ -23,13 +23,13 @@ function checkLexicographicOrder(results: Array<any>) {
 
   // Sort by value using the same comparator as in the test
   const sortedByValue = [...valuesWithIndices].sort((a, b) =>
-    a.value.value < b.value.value ? -1 : 1
+    a.value.value < b.value.value ? -1 : 1,
   )
 
   // Check that indices are in the same order as the sorted values
   for (let i = 0; i < sortedByValue.length - 1; i++) {
-    const currentIndex = sortedByValue[i].index
-    const nextIndex = sortedByValue[i + 1].index
+    const currentIndex = sortedByValue[i]!.index
+    const nextIndex = sortedByValue[i + 1]!.index
 
     // Indices should be in lexicographic order
     if (!(currentIndex < nextIndex)) {
@@ -87,7 +87,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value)),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -100,7 +100,7 @@ describe(`Operators`, () => {
           [[3, { id: 3, value: `c` }], 1],
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -113,8 +113,8 @@ describe(`Operators`, () => {
       const initialMessages = initialResult.messages
       expect(
         checkLexicographicOrder(
-          initialMessages.map(([item, mult]) => [item, mult])
-        )
+          initialMessages.map(([item, mult]) => [item, mult]),
+        ),
       ).toBe(true)
 
       tracker.reset()
@@ -124,7 +124,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[3, { id: 3, value: `c` }], -1], // Remove the old value
           [[3, { id: 3, value: `a-` }], 1], // This should now be first
-        ])
+        ]),
       )
       graph.run()
 
@@ -135,9 +135,11 @@ describe(`Operators`, () => {
       expect(updateResult.messageCount).toBeGreaterThan(0) // Should have some changes
 
       // Check that only the affected key (null) produces messages
-      assertOnlyKeysAffected(`topKFractional update`, updateResult.messages, [
-        3,
-      ])
+      assertOnlyKeysAffected(
+        `topKFractional update`,
+        updateResult.messages,
+        [3],
+      )
 
       // Check that the update messages maintain lexicographic order on their own
       if (updateResult.messages.length > 0) {
@@ -160,7 +162,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value)),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -173,7 +175,7 @@ describe(`Operators`, () => {
           [[3, { id: 3, value: `c` }], 1],
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -182,8 +184,8 @@ describe(`Operators`, () => {
       expect(initialResult.sortedResults.length).toBe(5) // Should have all 5 elements
       expect(
         checkLexicographicOrder(
-          initialResult.messages.map(([item, mult]) => [item, mult])
-        )
+          initialResult.messages.map(([item, mult]) => [item, mult]),
+        ),
       ).toBe(true)
 
       tracker.reset()
@@ -202,7 +204,7 @@ describe(`Operators`, () => {
       assertOnlyKeysAffected(
         `topKFractional duplicate keys`,
         updateResult.messages,
-        [6]
+        [6],
       )
 
       // Check that the update messages maintain lexicographic order on their own
@@ -227,7 +229,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value)),
         output((message) => {
           allMessages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -240,7 +242,7 @@ describe(`Operators`, () => {
           [[3, { id: 3, value: `c` }], 1],
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -271,7 +273,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -284,7 +286,7 @@ describe(`Operators`, () => {
           [[3, { id: 3, value: `c` }], 1],
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -301,7 +303,7 @@ describe(`Operators`, () => {
       })
 
       const sortedValues = sortedByIndex.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(sortedValues).toEqual([`b`, `c`, `d`]) // Should be in correct order with offset 1, limit 3
 
@@ -313,7 +315,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [[6, { id: 6, value: `c+` }], 1], // This should be between c and d
-        ])
+        ]),
       )
       graph.run()
 
@@ -342,7 +344,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value)),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -355,7 +357,7 @@ describe(`Operators`, () => {
           [[3, { id: 3, value: `c` }], 1],
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -371,7 +373,7 @@ describe(`Operators`, () => {
       })
 
       const initialSortedValues = initialSortedByIndex.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`a`, `b`, `c`, `d`, `e`]) // Should be in lexicographic order
 
@@ -384,7 +386,7 @@ describe(`Operators`, () => {
           [[2, { id: 2, value: `d+` }], 1], // 'b' becomes 'd+'
           [[4, { id: 4, value: `d` }], -1], // Remove old 'd'
           [[4, { id: 4, value: `b+` }], 1], // 'd' becomes 'b+'
-        ])
+        ]),
       )
       graph.run()
 
@@ -397,7 +399,7 @@ describe(`Operators`, () => {
       assertOnlyKeysAffected(
         `topK move positions`,
         updateResult.messages,
-        [2, 4]
+        [2, 4],
       )
 
       // For position swaps, we mainly care that the operation is incremental
@@ -416,7 +418,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value)),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -429,7 +431,7 @@ describe(`Operators`, () => {
           [[5, { id: 5, value: `e` }], 1],
           [[7, { id: 7, value: `g` }], 1],
           [[9, { id: 9, value: `i` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -446,7 +448,7 @@ describe(`Operators`, () => {
           [[4, { id: 4, value: `d` }], 1],
           [[6, { id: 6, value: `f` }], 1],
           [[8, { id: 8, value: `h` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -464,7 +466,7 @@ describe(`Operators`, () => {
           [[3, { id: 3, value: `j` }], 1], // Move 'c' to after 'i'
           [[7, { id: 7, value: `g` }], -1], // Remove old 'g'
           [[7, { id: 7, value: `a-` }], 1], // Move 'g' to before 'a'
-        ])
+        ]),
       )
       graph.run()
 
@@ -477,7 +479,7 @@ describe(`Operators`, () => {
       assertOnlyKeysAffected(
         `topK lexicographic update2`,
         update2Result.messages,
-        [3, 7]
+        [3, 7],
       )
     })
 
@@ -492,7 +494,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value)),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -505,7 +507,7 @@ describe(`Operators`, () => {
           [[3, { id: 3, value: `c` }], 1],
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -521,7 +523,7 @@ describe(`Operators`, () => {
       })
 
       const initialSortedValues = initialSortedByIndex.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`a`, `b`, `c`, `d`, `e`]) // Should be in lexicographic order
 
@@ -532,7 +534,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[1, { id: 1, value: `a` }], -1], // Remove old 'a'
           [[1, { id: 1, value: `bb` }], 1], // Move 'a' to after 'b'
-        ])
+        ]),
       )
       graph.run()
 
@@ -548,7 +550,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[1, { id: 1, value: `bb` }], -1], // Remove old 'bb'
           [[1, { id: 1, value: `dd` }], 1], // Move to after 'd'
-        ])
+        ]),
       )
       graph.run()
 
@@ -574,7 +576,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value)),
         output((message) => {
           allMessages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -586,7 +588,7 @@ describe(`Operators`, () => {
           [[3, { id: 3, value: `c` }], 1],
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -607,7 +609,7 @@ describe(`Operators`, () => {
       input.sendData(
         new MultiSet([
           [[1, { id: 1, value: `a` }], 1], // This should be inserted at the start
-        ])
+        ]),
       )
       graph.run()
 
@@ -630,7 +632,7 @@ describe(`Operators`, () => {
 
       // Convert to array for lexicographic order check
       const currentStateArray = Array.from(currentState.values()).map(
-        ([value, index]) => [[null, [value, index]], 1]
+        ([value, index]) => [[null, [value, index]], 1],
       )
 
       expect(checkLexicographicOrder(currentStateArray)).toBe(true)
@@ -658,7 +660,7 @@ describe(`Operators`, () => {
         topK((a, b) => a.value.localeCompare(b.value)),
         output((message) => {
           allMessages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -670,7 +672,7 @@ describe(`Operators`, () => {
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
           [[6, { id: 6, value: `f` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -692,7 +694,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[1, { id: 1, value: `a` }], 1], // This should be inserted at the start
           [[2, { id: 2, value: `b` }], 1], // This should be inserted at the start
-        ])
+        ]),
       )
       graph.run()
 
@@ -715,7 +717,7 @@ describe(`Operators`, () => {
 
       // Convert to array for lexicographic order check
       const currentStateArray = Array.from(currentState.values()).map(
-        ([value, index]) => [[null, [value, index]], 1]
+        ([value, index]) => [[null, [value, index]], 1],
       )
 
       expect(checkLexicographicOrder(currentStateArray)).toBe(true)
@@ -750,7 +752,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -764,7 +766,7 @@ describe(`Operators`, () => {
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
           [[6, { id: 6, value: `f` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -775,7 +777,7 @@ describe(`Operators`, () => {
 
       // Verify initial order
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`a`, `b`, `c`])
 
@@ -792,7 +794,7 @@ describe(`Operators`, () => {
 
       // Should now show d, e, f
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`d`, `e`, `f`])
 
@@ -823,7 +825,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -837,7 +839,7 @@ describe(`Operators`, () => {
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
           [[6, { id: 6, value: `f` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -848,7 +850,7 @@ describe(`Operators`, () => {
 
       // Verify initial order
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`d`, `e`, `f`])
 
@@ -865,7 +867,7 @@ describe(`Operators`, () => {
 
       // Should now show d, e, f
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`a`, `b`, `c`])
 
@@ -896,7 +898,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -909,7 +911,7 @@ describe(`Operators`, () => {
           [[3, { id: 3, value: `c` }], 1],
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -918,7 +920,7 @@ describe(`Operators`, () => {
       expect(initialResult.sortedResults.length).toBe(2)
 
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`a`, `b`])
 
@@ -931,7 +933,7 @@ describe(`Operators`, () => {
       const moveResult = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`b`, `c`])
 
@@ -944,7 +946,7 @@ describe(`Operators`, () => {
       const moveResult2 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues2 = moveResult2.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues2).toEqual([`c`, `d`])
 
@@ -955,7 +957,7 @@ describe(`Operators`, () => {
       const moveResult3 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues3 = moveResult3.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues3).toEqual([`a`, `b`])
     })
@@ -981,7 +983,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -995,7 +997,7 @@ describe(`Operators`, () => {
           [[4, { id: 4, value: `d` }], 1],
           [[5, { id: 5, value: `e` }], 1],
           [[6, { id: 6, value: `f` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -1004,7 +1006,7 @@ describe(`Operators`, () => {
       expect(initialResult.sortedResults.length).toBe(2)
 
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`b`, `c`])
 
@@ -1015,7 +1017,7 @@ describe(`Operators`, () => {
       const moveResult = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`b`, `c`, `d`])
 
@@ -1026,7 +1028,7 @@ describe(`Operators`, () => {
       const moveResult2 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues2 = moveResult2.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues2).toEqual([`b`])
     })
@@ -1052,7 +1054,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -1063,7 +1065,7 @@ describe(`Operators`, () => {
           [[1, { id: 1, value: `a` }], 1],
           [[2, { id: 2, value: `b` }], 1],
           [[3, { id: 3, value: `c` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -1072,7 +1074,7 @@ describe(`Operators`, () => {
       expect(initialResult.sortedResults.length).toBe(2)
 
       const initialSortedValues = initialResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(initialSortedValues).toEqual([`a`, `b`])
 
@@ -1083,7 +1085,7 @@ describe(`Operators`, () => {
       const moveResult = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues = moveResult.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues).toEqual([`c`]) // Only 1 element available at offset 2
 
@@ -1094,7 +1096,7 @@ describe(`Operators`, () => {
       const moveResult2 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues2 = moveResult2.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues2).toEqual([]) // No elements available at offset 5
 
@@ -1105,7 +1107,7 @@ describe(`Operators`, () => {
       const moveResult3 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues3 = moveResult3.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues3).toEqual([])
 
@@ -1116,9 +1118,585 @@ describe(`Operators`, () => {
       const moveResult4 = tracker.getResult(compareFractionalIndex)
 
       const moveSortedValues4 = moveResult4.sortedResults.map(
-        ([_key, [value, _index]]) => value.value
+        ([_key, [value, _index]]) => value.value,
       )
       expect(moveSortedValues4).toEqual([`a`, `b`])
     })
+
+    it(`should handle moving window from infinite limit to finite limit with same offset`, () => {
+      const graph = new D2()
+      const input = graph.newInput<[number, { id: number; value: string }]>()
+      const tracker = new MessageTracker<
+        [number, [{ id: number; value: string }, string]]
+      >()
+
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | null = null
+
+      // Start with no limit (infinite limit)
+      input.pipe(
+        topKWithFractionalIndex((a, b) => a.value.localeCompare(b.value), {
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - a, b, c, d, e, f
+      input.sendData(
+        new MultiSet([
+          [[1, { id: 1, value: `a` }], 1],
+          [[2, { id: 2, value: `b` }], 1],
+          [[3, { id: 3, value: `c` }], 1],
+          [[4, { id: 4, value: `d` }], 1],
+          [[5, { id: 5, value: `e` }], 1],
+          [[6, { id: 6, value: `f` }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial result should have all 6 elements (no limit)
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(6)
+
+      const initialSortedValues = initialResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialSortedValues).toEqual([`a`, `b`, `c`, `d`, `e`, `f`])
+
+      // Verify windowFn was set
+      expect(windowFn).toBeDefined()
+
+      // Move to finite limit of 3 (should show a, b, c)
+      windowFn!({ offset: 0, limit: 3 })
+      graph.run()
+
+      const moveResult = tracker.getResult(compareFractionalIndex)
+
+      // Should now show only first 3 elements
+      const moveSortedValues = moveResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(moveSortedValues).toEqual([`a`, `b`, `c`])
+
+      // Check that we have changes (elements d, e, f should be removed)
+      expect(moveResult.messageCount).toBeGreaterThan(0)
+    })
+
+    it(`should handle moving window from infinite limit to finite limit while moving offset forward`, () => {
+      const graph = new D2()
+      const input = graph.newInput<[number, { id: number; value: string }]>()
+      const tracker = new MessageTracker<
+        [number, [{ id: number; value: string }, string]]
+      >()
+
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | null = null
+
+      // Start with no limit (infinite limit)
+      input.pipe(
+        topKWithFractionalIndex((a, b) => a.value.localeCompare(b.value), {
+          offset: 0,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - a, b, c, d, e, f
+      input.sendData(
+        new MultiSet([
+          [[1, { id: 1, value: `a` }], 1],
+          [[2, { id: 2, value: `b` }], 1],
+          [[3, { id: 3, value: `c` }], 1],
+          [[4, { id: 4, value: `d` }], 1],
+          [[5, { id: 5, value: `e` }], 1],
+          [[6, { id: 6, value: `f` }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial result should have all 6 elements (no limit)
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(6)
+
+      // Move to offset 2, limit 3 (should show c, d, e)
+      windowFn!({ offset: 2, limit: 3 })
+      graph.run()
+
+      const moveResult = tracker.getResult(compareFractionalIndex)
+
+      // Should now show elements c, d, e
+      const moveSortedValues = moveResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(moveSortedValues).toEqual([`c`, `d`, `e`])
+
+      // Check that we have changes
+      expect(moveResult.messageCount).toBeGreaterThan(0)
+    })
+
+    it(`should handle moving window from infinite limit to finite limit while moving offset backward`, () => {
+      const graph = new D2()
+      const input = graph.newInput<[number, { id: number; value: string }]>()
+      const tracker = new MessageTracker<
+        [number, [{ id: number; value: string }, string]]
+      >()
+
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | null = null
+
+      // Start with no limit (infinite limit) and offset 3
+      input.pipe(
+        topKWithFractionalIndex((a, b) => a.value.localeCompare(b.value), {
+          offset: 3,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - a, b, c, d, e, f
+      input.sendData(
+        new MultiSet([
+          [[1, { id: 1, value: `a` }], 1],
+          [[2, { id: 2, value: `b` }], 1],
+          [[3, { id: 3, value: `c` }], 1],
+          [[4, { id: 4, value: `d` }], 1],
+          [[5, { id: 5, value: `e` }], 1],
+          [[6, { id: 6, value: `f` }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial result should have elements d, e, f (no limit, offset 3)
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(3)
+
+      const initialSortedValues = initialResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialSortedValues).toEqual([`d`, `e`, `f`])
+
+      // Move to finite limit of 2, moving offset backward to 1 (should show b, c)
+      windowFn!({ offset: 1, limit: 2 })
+      graph.run()
+
+      const moveResult = tracker.getResult(compareFractionalIndex)
+
+      // Should now show elements b, c (offset 1, limit 2)
+      const moveSortedValues = moveResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(moveSortedValues).toEqual([`b`, `c`])
+
+      // Check that we have changes (elements d, e, f should be removed, b, c should be added)
+      expect(moveResult.messageCount).toBeGreaterThan(0)
+    })
+
+    it(`should handle moving window from infinite limit to infinite limit with same offset (no-op)`, () => {
+      const graph = new D2()
+      const input = graph.newInput<[number, { id: number; value: string }]>()
+      const tracker = new MessageTracker<
+        [number, [{ id: number; value: string }, string]]
+      >()
+
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | null = null
+
+      // Start with no limit (infinite limit) and offset 2
+      input.pipe(
+        topKWithFractionalIndex((a, b) => a.value.localeCompare(b.value), {
+          offset: 2,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - a, b, c, d, e, f
+      input.sendData(
+        new MultiSet([
+          [[1, { id: 1, value: `a` }], 1],
+          [[2, { id: 2, value: `b` }], 1],
+          [[3, { id: 3, value: `c` }], 1],
+          [[4, { id: 4, value: `d` }], 1],
+          [[5, { id: 5, value: `e` }], 1],
+          [[6, { id: 6, value: `f` }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial result should have elements c, d, e, f (no limit, offset 2)
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(4)
+
+      const initialSortedValues = initialResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialSortedValues).toEqual([`c`, `d`, `e`, `f`])
+
+      // Move to same offset, still no limit (should show same elements c, d, e, f)
+      windowFn!({ offset: 2 })
+      graph.run()
+
+      const moveResult = tracker.getResult(compareFractionalIndex)
+
+      // Should show same elements c, d, e, f (offset 2, no limit)
+      const moveSortedValues = moveResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(moveSortedValues).toEqual([`c`, `d`, `e`, `f`])
+
+      // Check that we have no more changes (this should be a no-op)
+      expect(moveResult.messageCount).toBe(initialResult.messageCount)
+    })
+
+    it(`should handle moving window from infinite limit to infinite limit while moving offset forward`, () => {
+      const graph = new D2()
+      const input = graph.newInput<[number, { id: number; value: string }]>()
+      const tracker = new MessageTracker<
+        [number, [{ id: number; value: string }, string]]
+      >()
+
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | null = null
+
+      // Start with no limit (infinite limit) and offset 0
+      input.pipe(
+        topKWithFractionalIndex((a, b) => a.value.localeCompare(b.value), {
+          offset: 0,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - a, b, c, d, e, f
+      input.sendData(
+        new MultiSet([
+          [[1, { id: 1, value: `a` }], 1],
+          [[2, { id: 2, value: `b` }], 1],
+          [[3, { id: 3, value: `c` }], 1],
+          [[4, { id: 4, value: `d` }], 1],
+          [[5, { id: 5, value: `e` }], 1],
+          [[6, { id: 6, value: `f` }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial result should have all 6 elements (no limit, offset 0)
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(6)
+
+      const initialSortedValues = initialResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialSortedValues).toEqual([`a`, `b`, `c`, `d`, `e`, `f`])
+
+      // Move to offset 2, still no limit (should show c, d, e, f)
+      windowFn!({ offset: 2 })
+      graph.run()
+
+      const moveResult = tracker.getResult(compareFractionalIndex)
+
+      // Should now show elements c, d, e, f (offset 2, no limit)
+      const moveSortedValues = moveResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(moveSortedValues).toEqual([`c`, `d`, `e`, `f`])
+
+      // Check that we have changes (elements a, b should be removed)
+      expect(moveResult.messageCount).toBeGreaterThan(0)
+    })
+
+    it(`should handle moving window from infinite limit to infinite limit while moving offset backward`, () => {
+      const graph = new D2()
+      const input = graph.newInput<[number, { id: number; value: string }]>()
+      const tracker = new MessageTracker<
+        [number, [{ id: number; value: string }, string]]
+      >()
+
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | null = null
+
+      // Start with no limit (infinite limit) and offset 3
+      input.pipe(
+        topKWithFractionalIndex((a, b) => a.value.localeCompare(b.value), {
+          offset: 3,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - a, b, c, d, e, f
+      input.sendData(
+        new MultiSet([
+          [[1, { id: 1, value: `a` }], 1],
+          [[2, { id: 2, value: `b` }], 1],
+          [[3, { id: 3, value: `c` }], 1],
+          [[4, { id: 4, value: `d` }], 1],
+          [[5, { id: 5, value: `e` }], 1],
+          [[6, { id: 6, value: `f` }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial result should have elements d, e, f (no limit, offset 3)
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(3)
+
+      const initialSortedValues = initialResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialSortedValues).toEqual([`d`, `e`, `f`])
+
+      // Move to offset 1, still no limit (should show b, c, d, e, f)
+      windowFn!({ offset: 1 })
+      graph.run()
+
+      const moveResult = tracker.getResult(compareFractionalIndex)
+
+      // Should now show elements b, c, d, e, f (offset 1, no limit)
+      const moveSortedValues = moveResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(moveSortedValues).toEqual([`b`, `c`, `d`, `e`, `f`])
+
+      // Check that we have changes (elements b, c should be added)
+      expect(moveResult.messageCount).toBeGreaterThan(0)
+    })
+
+    it(`should handle moving window from finite limit to infinite limit with same offset`, () => {
+      const graph = new D2()
+      const input = graph.newInput<[number, { id: number; value: string }]>()
+      const tracker = new MessageTracker<
+        [number, [{ id: number; value: string }, string]]
+      >()
+
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | null = null
+
+      // Start with finite limit of 2 and offset 2
+      input.pipe(
+        topKWithFractionalIndex((a, b) => a.value.localeCompare(b.value), {
+          limit: 2,
+          offset: 2,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - a, b, c, d, e, f
+      input.sendData(
+        new MultiSet([
+          [[1, { id: 1, value: `a` }], 1],
+          [[2, { id: 2, value: `b` }], 1],
+          [[3, { id: 3, value: `c` }], 1],
+          [[4, { id: 4, value: `d` }], 1],
+          [[5, { id: 5, value: `e` }], 1],
+          [[6, { id: 6, value: `f` }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial result should have 2 elements starting from offset 2 (c, d)
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(2)
+
+      const initialSortedValues = initialResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialSortedValues).toEqual([`c`, `d`])
+
+      // Move to infinite limit, keeping offset 2 (should show c, d, e, f)
+      windowFn!({ offset: 2, limit: Infinity })
+      graph.run()
+
+      const moveResult = tracker.getResult(compareFractionalIndex)
+
+      // Should now show elements c, d, e, f (offset 2, no limit)
+      const moveSortedValues = moveResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(moveSortedValues).toEqual([`c`, `d`, `e`, `f`])
+
+      // Check that we have changes (elements e, f should be added)
+      expect(moveResult.messageCount).toBeGreaterThan(0)
+    })
+
+    it(`should handle moving window from finite limit to infinite limit while moving offset forward`, () => {
+      const graph = new D2()
+      const input = graph.newInput<[number, { id: number; value: string }]>()
+      const tracker = new MessageTracker<
+        [number, [{ id: number; value: string }, string]]
+      >()
+
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | null = null
+
+      // Start with finite limit of 2 and offset 1
+      input.pipe(
+        topKWithFractionalIndex((a, b) => a.value.localeCompare(b.value), {
+          limit: 2,
+          offset: 1,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - a, b, c, d, e, f
+      input.sendData(
+        new MultiSet([
+          [[1, { id: 1, value: `a` }], 1],
+          [[2, { id: 2, value: `b` }], 1],
+          [[3, { id: 3, value: `c` }], 1],
+          [[4, { id: 4, value: `d` }], 1],
+          [[5, { id: 5, value: `e` }], 1],
+          [[6, { id: 6, value: `f` }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial result should have 2 elements starting from offset 1 (b, c)
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(2)
+
+      const initialSortedValues = initialResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialSortedValues).toEqual([`b`, `c`])
+
+      // Move to infinite limit, moving offset forward to 3 (should show d, e, f)
+      windowFn!({ offset: 3, limit: Infinity })
+      graph.run()
+
+      const moveResult = tracker.getResult(compareFractionalIndex)
+
+      // Should now show elements d, e, f (offset 3, no limit)
+      const moveSortedValues = moveResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(moveSortedValues).toEqual([`d`, `e`, `f`])
+
+      // Check that we have changes (elements b, c should be removed, d, e, f should be added)
+      expect(moveResult.messageCount).toBeGreaterThan(0)
+    })
+
+    it(`should handle moving window from finite limit to infinite limit while moving offset backward`, () => {
+      const graph = new D2()
+      const input = graph.newInput<[number, { id: number; value: string }]>()
+      const tracker = new MessageTracker<
+        [number, [{ id: number; value: string }, string]]
+      >()
+
+      let windowFn:
+        | ((options: { offset?: number; limit?: number }) => void)
+        | null = null
+
+      // Start with finite limit of 2 and offset 3
+      input.pipe(
+        topKWithFractionalIndex((a, b) => a.value.localeCompare(b.value), {
+          limit: 2,
+          offset: 3,
+          setWindowFn: (fn) => {
+            windowFn = fn
+          },
+        }),
+        output((message) => {
+          tracker.addMessage(message)
+        }),
+      )
+
+      graph.finalize()
+
+      // Initial data - a, b, c, d, e, f
+      input.sendData(
+        new MultiSet([
+          [[1, { id: 1, value: `a` }], 1],
+          [[2, { id: 2, value: `b` }], 1],
+          [[3, { id: 3, value: `c` }], 1],
+          [[4, { id: 4, value: `d` }], 1],
+          [[5, { id: 5, value: `e` }], 1],
+          [[6, { id: 6, value: `f` }], 1],
+        ]),
+      )
+      graph.run()
+
+      // Initial result should have 2 elements starting from offset 3 (d, e)
+      const initialResult = tracker.getResult(compareFractionalIndex)
+      expect(initialResult.sortedResults.length).toBe(2)
+
+      const initialSortedValues = initialResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(initialSortedValues).toEqual([`d`, `e`])
+
+      // Move to infinite limit, moving offset backward to 1 (should show b, c, d, e, f)
+      windowFn!({ offset: 1, limit: Infinity })
+      graph.run()
+
+      const moveResult = tracker.getResult(compareFractionalIndex)
+
+      // Should now show elements b, c, d, e, f (offset 1, no limit)
+      const moveSortedValues = moveResult.sortedResults.map(
+        ([_key, [value, _index]]) => value.value,
+      )
+      expect(moveSortedValues).toEqual([`b`, `c`, `d`, `e`, `f`])
+
+      // Check that we have changes (elements b, c, f should be added, d, e should remain)
+      expect(moveResult.messageCount).toBeGreaterThan(0)
+    })
   })
 })
diff --git a/packages/db-ivm/tests/operators/topKWithIndex.test.ts b/packages/db-ivm/tests/operators/topKWithIndex.test.ts
index 7b024e550..0a621226b 100644
--- a/packages/db-ivm/tests/operators/topKWithIndex.test.ts
+++ b/packages/db-ivm/tests/operators/topKWithIndex.test.ts
@@ -1,13 +1,13 @@
-import { describe, expect, test } from "vitest"
-import { D2 } from "../../src/d2.js"
-import { MultiSet } from "../../src/multiset.js"
-import { output } from "../../src/operators/index.js"
-import { topKWithIndex } from "../../src/operators/topK.js"
+import { describe, expect, test } from 'vitest'
+import { D2 } from '../../src/d2.js'
+import { MultiSet } from '../../src/multiset.js'
+import { output } from '../../src/operators/index.js'
+import { topKWithIndex } from '../../src/operators/topK.js'
 import {
   MessageTracker,
   assertOnlyKeysAffected,
   assertResults,
-} from "../test-utils.js"
+} from '../test-utils.js'
 
 describe(`Operators`, () => {
   describe(`TopKWithIndex operation`, () => {
@@ -28,7 +28,7 @@ describe(`Operators`, () => {
         topKWithIndex((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -40,7 +40,7 @@ describe(`Operators`, () => {
           [[null, { id: 3, value: `b` }], 1],
           [[null, { id: 4, value: `y` }], 1],
           [[null, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -75,7 +75,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -87,7 +87,7 @@ describe(`Operators`, () => {
           [[null, { id: 3, value: `b` }], 1],
           [[null, { id: 4, value: `y` }], 1],
           [[null, { id: 5, value: `c` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -120,7 +120,7 @@ describe(`Operators`, () => {
         topKWithIndex((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -137,7 +137,7 @@ describe(`Operators`, () => {
           [[`two`, { id: 8, value: `2` }], 1],
           [[`two`, { id: 9, value: `1` }], 1],
           [[`two`, { id: 10, value: `0` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -175,7 +175,7 @@ describe(`Operators`, () => {
         topKWithIndex((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           tracker.addMessage(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -187,7 +187,7 @@ describe(`Operators`, () => {
           [[null, { id: 2, value: `b` }], 1],
           [[null, { id: 3, value: `c` }], 1],
           [[null, { id: 4, value: `d` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -201,7 +201,7 @@ describe(`Operators`, () => {
           [null, [{ id: 2, value: `b` }, 1]],
           [null, [{ id: 3, value: `c` }, 2]],
         ],
-        4 // Max expected messages for initial data
+        4, // Max expected messages for initial data
       )
 
       tracker.reset()
@@ -243,7 +243,7 @@ describe(`Operators`, () => {
         topKWithIndex((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -254,7 +254,7 @@ describe(`Operators`, () => {
           [[null, { id: 1, value: `c` }], 1],
           [[null, { id: 2, value: `d` }], 1],
           [[null, { id: 3, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -272,7 +272,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[null, { id: 4, value: `a` }], 1],
           [[null, { id: 5, value: `b` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -310,7 +310,7 @@ describe(`Operators`, () => {
         topKWithIndex((a, b) => a.value.localeCompare(b.value), { limit: 3 }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -321,7 +321,7 @@ describe(`Operators`, () => {
           [[null, { id: 1, value: `a` }], 1],
           [[null, { id: 2, value: `b` }], 1],
           [[null, { id: 3, value: `c` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -339,7 +339,7 @@ describe(`Operators`, () => {
         new MultiSet([
           [[null, { id: 1, value: `a` }], -1],
           [[null, { id: 1, value: `z` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -381,7 +381,7 @@ describe(`Operators`, () => {
         }),
         output((message) => {
           latestMessage = message
-        })
+        }),
       )
 
       graph.finalize()
@@ -394,7 +394,7 @@ describe(`Operators`, () => {
           [[null, { id: 3, value: `c` }], 1],
           [[null, { id: 4, value: `d` }], 1],
           [[null, { id: 5, value: `e` }], 1],
-        ])
+        ]),
       )
       graph.run()
 
@@ -434,7 +434,7 @@ function sortByIndexAndId(results: Array<any>) {
   return [...results].sort(
     (
       [[_aKey, [aValue, aIndex]], _aMultiplicity],
-      [[_bKey, [bValue, bIndex]], _bMultiplicity]
+      [[_bKey, [bValue, bIndex]], _bMultiplicity],
     ) => {
       // First sort by index
       if (aIndex !== bIndex) {
@@ -442,7 +442,7 @@ function sortByIndexAndId(results: Array<any>) {
       }
       // Then by id if indices are the same
       return aValue.id - bValue.id
-    }
+    },
   )
 }
 
@@ -453,7 +453,7 @@ function sortByKeyIndexAndId(results: Array<any>) {
   return [...results].sort(
     (
       [[aKey, [aValue, aIndex]], _aMultiplicity],
-      [[bKey, [bValue, bIndex]], _bMultiplicity]
+      [[bKey, [bValue, bIndex]], _bMultiplicity],
     ) => {
       // First sort by key
       if (aKey !== bKey) {
@@ -465,7 +465,7 @@ function sortByKeyIndexAndId(results: Array<any>) {
       }
       // Then by id if indices are the same
       return aValue.id - bValue.id
-    }
+    },
   )
 }
 
@@ -476,7 +476,7 @@ function sortByMultiplicityIndexAndId(results: Array<any>) {
   return [...results].sort(
     (
       [[_aKey, [aValue, aIndex]], aMultiplicity],
-      [[_bKey, [bValue, bIndex]], bMultiplicity]
+      [[_bKey, [bValue, bIndex]], bMultiplicity],
     ) => {
       // First sort by multiplicity
       if (aMultiplicity !== bMultiplicity) {
@@ -488,6 +488,6 @@ function sortByMultiplicityIndexAndId(results: Array<any>) {
       }
       // Then by id if indices are the same
       return aValue.id - bValue.id
-    }
+    },
   )
 }
diff --git a/packages/db-ivm/tests/test-utils.ts b/packages/db-ivm/tests/test-utils.ts
index a7ee0f0f5..ca44e88e9 100644
--- a/packages/db-ivm/tests/test-utils.ts
+++ b/packages/db-ivm/tests/test-utils.ts
@@ -1,5 +1,5 @@
-import { expect } from "vitest"
-import { MultiSet } from "../src/multiset.js"
+import { expect } from 'vitest'
+import { MultiSet } from '../src/multiset.js'
 
 // Enable detailed logging of test results when LOG_RESULTS is set
 const LOG_RESULTS =
@@ -10,7 +10,7 @@ const LOG_RESULTS =
  * Takes an array of messages and consolidates them into a final result set
  */
 export function materializeResults<T>(
-  messages: Array<[T, number]>
+  messages: Array<[T, number]>,
 ): Map<string, T> {
   const multiSet = new MultiSet(messages)
   const consolidated = multiSet.consolidate()
@@ -32,7 +32,7 @@ export function materializeResults<T>(
  * Takes an array of keyed messages and consolidates them per key
  */
 export function materializeKeyedResults<K, V>(
-  messages: Array<[[K, V], number]>
+  messages: Array<[[K, V], number]>,
 ): Map<K, V> {
   const result = new Map<K, Map<string, { value: V; multiplicity: number }>>()
 
@@ -59,14 +59,14 @@ export function materializeKeyedResults<K, V>(
   for (const [key, valueMap] of result.entries()) {
     // Filter to only positive multiplicities
     const positiveValues = Array.from(valueMap.values()).filter(
-      (entry) => entry.multiplicity > 0
+      (entry) => entry.multiplicity > 0,
     )
 
     if (positiveValues.length === 1) {
       finalResult.set(key, positiveValues[0].value)
     } else if (positiveValues.length > 1) {
       throw new Error(
-        `Key ${key} has multiple final values: ${positiveValues.map((v) => JSON.stringify(v.value)).join(`, `)}`
+        `Key ${key} has multiple final values: ${positiveValues.map((v) => JSON.stringify(v.value)).join(`, `)}`,
       )
     }
     // If no positive values, key was completely removed
@@ -80,7 +80,7 @@ export function materializeKeyedResults<K, V>(
  */
 export function mapToSortedArray<T>(
   map: Map<string, T>,
-  compare?: (a: T, b: T) => number
+  compare?: (a: T, b: T) => number,
 ): Array<T> {
   const compareFn =
     compare ??
@@ -157,7 +157,7 @@ export class KeyedMessageTracker<K, V> {
       (a, b) => {
         // Sort by key for consistent ordering
         return JSON.stringify(a[0]).localeCompare(JSON.stringify(b[0]))
-      }
+      },
     )
 
     return {
@@ -180,14 +180,14 @@ export function assertResults<T>(
   testName: string,
   actual: TestResult<T>,
   expected: Array<T>,
-  maxExpectedMessages?: number
+  maxExpectedMessages?: number,
 ) {
   const expectedMap = createExpectedResults(expected)
   const expectedSorted = mapToSortedArray(expectedMap)
 
   if (LOG_RESULTS) {
     console.log(
-      `${testName}: ${actual.messageCount} messages, ${actual.sortedResults.length} final results`
+      `${testName}: ${actual.messageCount} messages, ${actual.sortedResults.length} final results`,
     )
     console.log(`  Messages:`, actual.messages)
     console.log(`  Final results:`, actual.sortedResults)
@@ -207,7 +207,7 @@ export function assertResults<T>(
   const reasonableThreshold = expected.length === 0 ? 2 : expected.length * 3
   if (actual.messageCount > reasonableThreshold) {
     console.warn(
-      `⚠️  ${testName}: High message count (${actual.messageCount} messages for ${expected.length} expected results)`
+      `⚠️  ${testName}: High message count (${actual.messageCount} messages for ${expected.length} expected results)`,
     )
   }
 }
@@ -219,7 +219,7 @@ export function assertKeyedResults<K, V>(
   testName: string,
   actual: KeyedTestResult<K, V>,
   expected: Array<[K, V]>,
-  maxExpectedMessages?: number
+  maxExpectedMessages?: number,
 ) {
   const expectedSorted = expected.sort((a, b) => {
     return JSON.stringify(a[0]).localeCompare(JSON.stringify(b[0]))
@@ -227,7 +227,7 @@ export function assertKeyedResults<K, V>(
 
   if (LOG_RESULTS) {
     console.log(
-      `${testName}: ${actual.messageCount} messages, ${actual.sortedResults.length} final results per key`
+      `${testName}: ${actual.messageCount} messages, ${actual.sortedResults.length} final results per key`,
     )
     console.log(`  Messages:`, actual.messages)
     console.log(`  Final results:`, actual.sortedResults)
@@ -247,17 +247,17 @@ export function assertKeyedResults<K, V>(
   const reasonableThreshold = Math.max(expected.length * 4, 2)
   if (actual.messageCount > reasonableThreshold) {
     console.warn(
-      `⚠️  ${testName}: High message count (${actual.messageCount} messages for ${expected.length} expected key-value pairs)`
+      `⚠️  ${testName}: High message count (${actual.messageCount} messages for ${expected.length} expected key-value pairs)`,
     )
   }
 
   // Log key insights
   const affectedKeys = new Set(
-    actual.messages.map(([[key, _value], _mult]) => key)
+    actual.messages.map(([[key, _value], _mult]) => key),
   )
   if (LOG_RESULTS) {
     console.log(
-      `${testName}: ✅ ${affectedKeys.size} keys affected, ${actual.sortedResults.length} final keys`
+      `${testName}: ✅ ${affectedKeys.size} keys affected, ${actual.sortedResults.length} final keys`,
     )
   }
 }
@@ -266,7 +266,7 @@ export function assertKeyedResults<K, V>(
  * Extract unique keys from messages to verify incremental behavior
  */
 export function extractMessageKeys<K, V>(
-  messages: Array<[[K, V], number]>
+  messages: Array<[[K, V], number]>,
 ): Set<K> {
   const keys = new Set<K>()
   for (const [[key, _value], _multiplicity] of messages) {
@@ -281,7 +281,7 @@ export function extractMessageKeys<K, V>(
 export function assertOnlyKeysAffected<K, V>(
   testName: string,
   messages: Array<[[K, V], number]>,
-  expectedKeys: Array<K>
+  expectedKeys: Array<K>,
 ) {
   const actualKeys = extractMessageKeys(messages)
   const expectedKeySet = new Set(expectedKeys)
@@ -295,14 +295,14 @@ export function assertOnlyKeysAffected<K, V>(
 
   if (LOG_RESULTS) {
     console.log(
-      `${testName}: ✅ Only expected keys affected: ${Array.from(actualKeys).join(`, `)}`
+      `${testName}: ✅ Only expected keys affected: ${Array.from(actualKeys).join(`, `)}`,
     )
   }
 }
 
 export const compareFractionalIndex = (
   r1: [unknown, [unknown, string]],
-  r2: [unknown, [unknown, string]]
+  r2: [unknown, [unknown, string]],
 ) => {
   const [_key1, [_value1, index1]] = r1
   const [_key2, [_value2, index2]] = r2
diff --git a/packages/db-ivm/tests/utils.test.ts b/packages/db-ivm/tests/utils.test.ts
index 44e3d4680..9f6986577 100644
--- a/packages/db-ivm/tests/utils.test.ts
+++ b/packages/db-ivm/tests/utils.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest"
-import { DefaultMap } from "../src/utils.js"
-import { hash } from "../src/hashing/index.js"
+import { describe, expect, it } from 'vitest'
+import { DefaultMap } from '../src/utils.js'
+import { hash } from '../src/hashing/index.js'
 
 describe(`DefaultMap`, () => {
   it(`should return default value for missing keys`, () => {
@@ -299,7 +299,8 @@ describe(`hash`, () => {
       expect(hash4).not.toBe(hash6) // Different Symbol content should have different hash
     })
 
-    it(`should hash Buffers, Uint8Arrays and File objects by reference`, () => {
+    it(`should hash small Buffers and Uint8Arrays by content`, () => {
+      // Small buffers (≤128 bytes) are hashed by content for proper equality comparisons
       const buffer1 = Buffer.from([1, 2, 3])
       const buffer2 = Buffer.from([1, 2, 3])
       const buffer3 = Buffer.from([1, 2, 3, 4])
@@ -309,7 +310,7 @@ describe(`hash`, () => {
       const hash3 = hash(buffer3)
 
       expect(typeof hash1).toBe(hashType)
-      expect(hash1).not.toBe(hash2) // Same content but different buffer instances have a different hash because it would be too costly to deeply hash buffers
+      expect(hash1).toBe(hash2) // Same content = same hash for small buffers
       expect(hash1).not.toBe(hash3) // Different Buffer content should have different hash
       expect(hash1).toBe(hash(buffer1)) // Hashing same buffer should return same hash
 
@@ -322,10 +323,46 @@ describe(`hash`, () => {
       const hash6 = hash(uint8Array3)
 
       expect(typeof hash4).toBe(hashType)
-      expect(hash4).not.toBe(hash5) // Same content but different uint8Array instances have a different hash because it would be too costly to deeply hash uint8Arrays
+      expect(hash4).toBe(hash5) // Same content = same hash for small Uint8Arrays
       expect(hash4).not.toBe(hash6) // Different uint8Array content should have different hash
       expect(hash4).toBe(hash(uint8Array1)) // Hashing same uint8Array should return same hash
+    })
+
+    it(`should hash large Buffers, Uint8Arrays and File objects by reference`, () => {
+      // Large buffers (>128 bytes) are hashed by reference to avoid performance costs
+      const largeBuffer1 = Buffer.alloc(300)
+      const largeBuffer2 = Buffer.alloc(300)
+
+      // Fill with same content
+      for (let i = 0; i < 300; i++) {
+        largeBuffer1[i] = i % 256
+        largeBuffer2[i] = i % 256
+      }
+
+      const hash1 = hash(largeBuffer1)
+      const hash2 = hash(largeBuffer2)
+
+      expect(typeof hash1).toBe(hashType)
+      expect(hash1).not.toBe(hash2) // Same content but different instances = different hash for large buffers
+      expect(hash1).toBe(hash(largeBuffer1)) // Hashing same buffer should return same hash
+
+      const largeUint8Array1 = new Uint8Array(300)
+      const largeUint8Array2 = new Uint8Array(300)
+
+      // Fill with same content
+      for (let i = 0; i < 300; i++) {
+        largeUint8Array1[i] = i % 256
+        largeUint8Array2[i] = i % 256
+      }
+
+      const hash3 = hash(largeUint8Array1)
+      const hash4 = hash(largeUint8Array2)
+
+      expect(typeof hash3).toBe(hashType)
+      expect(hash3).not.toBe(hash4) // Same content but different instances = different hash for large Uint8Arrays
+      expect(hash3).toBe(hash(largeUint8Array1)) // Hashing same uint8Array should return same hash
 
+      // Files are always hashed by reference regardless of size
       const file1 = new File([`Hello, world!`], `test.txt`)
       const file2 = new File([`Hello, world!`], `test.txt`)
       const file3 = new File([`Hello, world!`], `test.txt`)
diff --git a/packages/db-ivm/vite.config.ts b/packages/db-ivm/vite.config.ts
index c7968f28a..aa589f666 100644
--- a/packages/db-ivm/vite.config.ts
+++ b/packages/db-ivm/vite.config.ts
@@ -1,6 +1,6 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import packageJson from './package.json'
 
 const config = defineConfig({
   test: {
@@ -17,5 +17,5 @@ export default mergeConfig(
   tanstackViteConfig({
     entry: `./src/index.ts`,
     srcDir: `./src`,
-  })
+  }),
 )
diff --git a/packages/db/CHANGELOG.md b/packages/db/CHANGELOG.md
index 0103ace18..66a590b02 100644
--- a/packages/db/CHANGELOG.md
+++ b/packages/db/CHANGELOG.md
@@ -1,5 +1,897 @@
 # @tanstack/db
 
+## 0.5.24
+
+### Patch Changes
+
+- Fix `$selected` namespace availability in `orderBy`, `having`, and `fn.having` when using `fn.select`. Previously, the `$selected` namespace was only available when using regular `.select()`, not functional `fn.select()`. ([#1183](https://github.com/TanStack/db/pull/1183))
+
+## 0.5.23
+
+### Patch Changes
+
+- Fix bug that caused the WHERE clause of a subquery not to be passed to the `loadSubset` function ([#1097](https://github.com/TanStack/db/pull/1097))
+
+## 0.5.22
+
+### Patch Changes
+
+- Fix `gcTime: Infinity` causing immediate garbage collection instead of disabling GC. JavaScript's `setTimeout` coerces `Infinity` to `0` via ToInt32, so we now explicitly check for non-finite values. ([#1135](https://github.com/TanStack/db/pull/1135))
+
+## 0.5.21
+
+### Patch Changes
+
+- Clarify queueStrategy error handling behavior in documentation. Changed "guaranteed to persist" to "guaranteed to be attempted" and added explicit documentation about how failed mutations are handled (not retried, queue continues). Added new Retry Behavior section with example code for implementing custom retry logic. ([#1107](https://github.com/TanStack/db/pull/1107))
+
+- Improve DuplicateKeySyncError message when using `.distinct()` with custom `getKey`. The error now explains that `.distinct()` deduplicates by the entire selected object, and provides actionable guidance to fix the issue. ([#1119](https://github.com/TanStack/db/pull/1119))
+
+- Fix syncedData not updating when manual write operations (writeUpsert, writeInsert, etc.) are called after async operations in mutation handlers. Previously, the sync transaction would be blocked by the persisting user transaction, leaving syncedData stale until the next sync cycle. ([#1130](https://github.com/TanStack/db/pull/1130))
+
+- Add string support to `min()` and `max()` aggregate functions. These functions now work with strings using lexicographic comparison, matching standard SQL behavior. ([#1120](https://github.com/TanStack/db/pull/1120))
+
+- Updated dependencies [[`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db-ivm@0.1.17
+
+## 0.5.20
+
+### Patch Changes
+
+- Updated dependencies [[`f5b504e`](https://github.com/TanStack/db/commit/f5b504e6d105034d23cb2ae27782e8cba0094cbe)]:
+  - @tanstack/db-ivm@0.1.16
+
+## 0.5.19
+
+### Patch Changes
+
+- Fix `isReady()` returning `true` while `toArray()` returns empty results. The status now correctly waits until data has been processed through the graph before marking ready. ([#1114](https://github.com/TanStack/db/pull/1114))
+
+  Also fix duplicate key errors when live queries use joins with custom `getKey` functions. D2's incremental join can produce multiple outputs for the same key during a single graph run; this change batches all outputs into a single transaction to prevent conflicts.
+
+- Introduce $selected namespace for accessing fields from SELECT clause inside ORDER BY and HAVING clauses. ([#1094](https://github.com/TanStack/db/pull/1094))
+
+- Updated dependencies [[`2456adb`](https://github.com/TanStack/db/commit/2456adbdb78b01d3f7323b3a0405b25f578df956)]:
+  - @tanstack/db-ivm@0.1.15
+
+## 0.5.18
+
+### Patch Changes
+
+- fix(db): prevent live query from being marked ready before subset data is loaded ([#1081](https://github.com/TanStack/db/pull/1081))
+
+  In on-demand sync mode, the live query collection was being marked as `ready` before
+  the subset data finished loading. This caused `useLiveQuery` to return `isReady=true`
+  with empty data, and `useLiveSuspenseQuery` to release suspense prematurely.
+
+  The root cause was a race condition: the `status:change` listener in `CollectionSubscriber`
+  was registered _after_ the snapshot was triggered. If `loadSubset` resolved quickly
+  (or synchronously), the `loadingSubset` status transition would be missed entirely,
+  so `trackLoadPromise` was never called on the live query collection.
+
+  Changes:
+  1. **Core fix - `onStatusChange` option**: Added `onStatusChange` callback option to
+     `subscribeChanges()`. The listener is registered BEFORE any snapshot is requested,
+     guaranteeing no status transitions are missed. This replaces the error-prone pattern
+     of manually deferring snapshots and registering listeners in the correct order.
+  2. **Ready state gating**: `updateLiveQueryStatus()` now checks `isLoadingSubset` on the
+     live query collection before marking it ready, and listens for `loadingSubset:change`
+     to trigger the ready check when subset loading completes.
+
+## 0.5.17
+
+### Patch Changes
+
+- Export `QueryResult` helper type for easily extracting query result types (similar to Zod's `z.infer`). ([#1096](https://github.com/TanStack/db/pull/1096))
+
+  ```typescript
+  import { Query, QueryResult } from '@tanstack/db'
+
+  const myQuery = new Query()
+    .from({ users })
+    .select(({ users }) => ({ name: users.name }))
+
+  // Extract the result type - clean and simple!
+  type MyQueryResult = QueryResult<typeof myQuery>
+  ```
+
+  Also exports `ExtractContext` for advanced use cases where you need the full context type.
+
+- Add validation for where() and having() expressions to catch JavaScript operator usage ([#1082](https://github.com/TanStack/db/pull/1082))
+
+  When users accidentally use JavaScript's comparison operators (`===`, `!==`, `<`, `>`, etc.) in `where()` or `having()` callbacks instead of query builder functions (`eq`, `gt`, etc.), the query builder now throws a helpful `InvalidWhereExpressionError` with clear guidance.
+
+  Previously, this mistake would result in a confusing "Unknown expression type: undefined" error at query compilation time. Now users get immediate feedback with an example of the correct syntax:
+
+  ```
+  ❌ .where(({ user }) => user.id === 'abc')
+  ✅ .where(({ user }) => eq(user.id, 'abc'))
+  ```
+
+- Fix asymmetric behavior in `deepEquals` when comparing different special types (Date, RegExp, Map, Set, TypedArray, Temporal, Array). Previously, comparing values like `deepEquals(Date, Temporal.Duration)` could return a different result than `deepEquals(Temporal.Duration, Date)`. Now both directions correctly return `false` for mismatched types, ensuring `deepEquals` is a proper equivalence relation. ([#1018](https://github.com/TanStack/db/pull/1018))
+
+- Add `where` callback option to `subscribeChanges` for ergonomic filtering ([#943](https://github.com/TanStack/db/pull/943))
+
+  Instead of manually constructing IR with `PropRef`:
+
+  ```ts
+  import { eq, PropRef } from '@tanstack/db'
+  collection.subscribeChanges(callback, {
+    whereExpression: eq(new PropRef(['status']), 'active'),
+  })
+  ```
+
+  You can now use a callback with query builder functions:
+
+  ```ts
+  import { eq } from '@tanstack/db'
+  collection.subscribeChanges(callback, {
+    where: (row) => eq(row.status, 'active'),
+  })
+  ```
+
+## 0.5.16
+
+### Patch Changes
+
+- Fix useLiveInfiniteQuery not updating when deleting an item from a partial page with DESC order. ([#970](https://github.com/TanStack/db/pull/970))
+
+  The bug occurred when using `useLiveInfiniteQuery` with `orderBy(..., 'desc')` and having fewer items than the `pageSize`. Deleting an item would not update the live result - the deleted item would remain visible until another change occurred.
+
+  The root cause was in `requestLimitedSnapshot` where `biggestObservedValue` was incorrectly set to the full row object instead of the indexed value (e.g., the salary field used for ordering). This caused the BTree comparison to fail, resulting in the same data being loaded multiple times with each item having a multiplicity > 1. When an item was deleted, its multiplicity would decrement but not reach 0, so it remained visible.
+
+## 0.5.15
+
+### Patch Changes
+
+- fix: prevent duplicate inserts from reaching D2 pipeline in live queries ([#1054](https://github.com/TanStack/db/pull/1054))
+
+  Added defensive measures to prevent duplicate INSERT events from reaching the D2 (differential dataflow) pipeline, which could cause items to not disappear when deleted (due to multiplicity going from 2 to 1 instead of 1 to 0).
+
+  Changes:
+  - Added `sentToD2Keys` tracking in `CollectionSubscriber` to filter duplicate inserts at the D2 pipeline entry point
+  - Fixed `includeInitialState` handling to only pass when `true`, preventing internal lazy-loading subscriptions from incorrectly disabling filtering
+  - Clear `sentToD2Keys` on truncate to allow re-inserts after collection reset
+
+## 0.5.14
+
+### Patch Changes
+
+- Fix subscriptions not re-requesting data after truncate in on-demand sync mode. When a must-refetch occurs, subscriptions now buffer changes and re-request their previously loaded subsets, preventing a flash of missing content. ([#1043](https://github.com/TanStack/db/pull/1043))
+
+  Key improvements:
+  - Buffer changes atomically: deletes and inserts are emitted together in a single callback
+  - Correct event ordering: defers loadSubset calls to a microtask so truncate deletes are buffered before refetch inserts
+  - Gated on on-demand mode: only buffers when there's an actual loadSubset handler
+  - Fixes delete filter edge case: skips delete filter during truncate buffering when `sentKeys` is empty
+
+## 0.5.13
+
+### Patch Changes
+
+- Allow rows to be deleted by key by using the write function passed to a collection's sync function. ([#1003](https://github.com/TanStack/db/pull/1003))
+
+- fix: deleted items not disappearing from live queries with `.limit()` ([#1044](https://github.com/TanStack/db/pull/1044))
+
+  Fixed a bug where deleting an item from a live query with `.orderBy()` and `.limit()` would not remove it from the query results. The `subscribeChanges` callback would never fire with a delete event.
+
+  The issue was caused by duplicate inserts reaching the D2 pipeline, which corrupted the multiplicity tracking used by `TopKWithFractionalIndexOperator`. A delete would decrement multiplicity from 2 to 1 instead of 1 to 0, so the item remained visible.
+
+  Fixed by ensuring `sentKeys` is updated before callbacks execute (preventing race conditions) and filtering duplicate inserts in `filterAndFlipChanges`.
+
+## 0.5.12
+
+### Patch Changes
+
+- Enhanced LoadSubsetOptions with separate cursor expressions and offset for flexible pagination. ([#960](https://github.com/TanStack/db/pull/960))
+
+  **⚠️ Breaking Change for Custom Sync Layers / Query Collections:**
+
+  `LoadSubsetOptions.where` no longer includes cursor expressions for pagination. If you have a custom sync layer or query collection that implements `loadSubset`, you must now handle pagination separately:
+  - **Cursor-based pagination:** Use the new `cursor` property (`cursor.whereFrom` and `cursor.whereCurrent`) and combine them with `where` yourself
+  - **Offset-based pagination:** Use the new `offset` property
+
+  Previously, cursor expressions were baked into the `where` clause. Now they are passed separately so sync layers can choose their preferred pagination strategy.
+
+  **Changes:**
+  - Added `CursorExpressions` type with `whereFrom`, `whereCurrent`, and optional `lastKey` properties
+  - Added `cursor` to `LoadSubsetOptions` for cursor-based pagination (separate from `where`)
+  - Added `offset` to `LoadSubsetOptions` for offset-based pagination support
+  - Electric sync layer now makes two parallel `requestSnapshot` calls when cursor is present:
+    - One for `whereCurrent` (all ties at boundary, no limit)
+    - One for `whereFrom` (rows after cursor, with limit)
+  - Query collection serialization now includes `offset` for query key generation
+  - Added `truncate` event to collections, emitted when synced data is truncated (e.g., after `must-refetch`)
+  - Fixed `setWindow` pagination: cursor expressions are now correctly built when paging through results
+  - Fixed offset tracking: `loadNextItems` now passes the correct window offset to prevent incorrect deduplication
+  - `CollectionSubscriber` now listens for `truncate` events to reset cursor tracking state
+
+  **Benefits:**
+  - Sync layers can choose between cursor-based or offset-based pagination strategies
+  - Electric can efficiently handle tie-breaking with two targeted requests
+  - Better separation of concerns between filtering (`where`) and pagination (`cursor`/`offset`)
+  - `setWindow` correctly triggers backend loading for subsequent pages in multi-column orderBy queries
+  - Cursor state is properly reset after truncation, preventing stale cursor data from being used
+
+- Ensure deterministic iteration order for collections and indexes. ([#958](https://github.com/TanStack/db/pull/958))
+
+  **SortedMap improvements:**
+  - Added key-based tie-breaking when values compare as equal, ensuring deterministic ordering
+  - Optimized to skip value comparison entirely when no comparator is provided (key-only sorting)
+  - Extracted `compareKeys` utility to `utils/comparison.ts` for reuse
+
+  **BTreeIndex improvements:**
+  - Keys within the same indexed value are now returned in deterministic sorted order
+  - Optimized with fast paths for empty sets and single-key sets to avoid unnecessary allocations
+
+  **CollectionStateManager changes:**
+  - Collections now always use `SortedMap` for `syncedData`, ensuring deterministic iteration order
+  - When no `compare` function is provided, entries are sorted by key only
+
+  This ensures that live queries with `orderBy` and `limit` produce stable, deterministic results even when multiple rows have equal sort values.
+
+- Enhanced multi-column orderBy support with lazy loading and composite cursor optimization. ([#926](https://github.com/TanStack/db/pull/926))
+
+  **Changes:**
+  - Create index on first orderBy column even for multi-column orderBy queries, enabling lazy loading with first-column ordering
+  - Pass multi-column orderBy to loadSubset with precise composite cursors (e.g., `or(gt(col1, v1), and(eq(col1, v1), gt(col2, v2)))`) for backend optimization
+  - Use wide bounds (first column only) for local index operations to ensure no rows are missed
+  - Use precise composite cursor for sync layer loadSubset to minimize data transfer
+
+  **Benefits:**
+  - Multi-column orderBy queries with limit now support lazy loading (previously disabled)
+  - Sync implementations (like Electric) can optimize queries using composite indexes on the backend
+  - Local collection uses first-column index efficiently while backend gets precise cursor
+
+- Updated dependencies [[`52c29fa`](https://github.com/TanStack/db/commit/52c29fa83b390ac26341dbf93e79ce0d59543686)]:
+  - @tanstack/db-ivm@0.1.14
+
+## 0.5.11
+
+### Patch Changes
+
+- fix(db): compile filter expression once in createFilterFunctionFromExpression ([#954](https://github.com/TanStack/db/pull/954))
+
+  Fixed a performance issue in `createFilterFunctionFromExpression` where the expression was being recompiled on every filter call. This only affected realtime change event filtering for pushed-down predicates at the collection level when using orderBy + limit. The core query engine was not affected as it already compiled predicates once.
+
+- fix(query-db-collection): use deep equality for object field comparison in query observer ([#967](https://github.com/TanStack/db/pull/967))
+
+  Fixed an issue where updating object fields (non-primitives) with `refetch: false` in `onUpdate` handlers would cause the value to rollback to the previous state every other update. The query observer was using shallow equality (`===`) to compare items, which compares object properties by reference rather than by value. This caused the observer to incorrectly detect differences and write stale data back to syncedData. Now uses `deepEquals` for proper value comparison.
+
+## 0.5.10
+
+### Patch Changes
+
+- Type utils in collection options as specific type (e.g. ElectricCollectionUtils) instead of generic UtilsRecord. ([#940](https://github.com/TanStack/db/pull/940))
+
+- Fix proxy to handle frozen objects correctly. Previously, creating a proxy for a frozen object (such as data from state management libraries that freeze their state) would throw a TypeError when attempting to modify properties via the proxy. The proxy now uses an unfrozen internal copy as the Proxy target, allowing modifications to be tracked correctly while preserving the immutability of the original object. ([#933](https://github.com/TanStack/db/pull/933))
+
+  Also adds support for `Object.seal()` and `Object.preventExtensions()` on proxies, allowing these operations to work correctly on change-tracking proxies.
+
+## 0.5.9
+
+### Patch Changes
+
+- Fix bulk insert not detecting duplicate keys within the same batch. Previously, when inserting multiple items with the same key in a single bulk insert operation, later items would silently overwrite earlier ones. Now, a `DuplicateKeyError` is thrown when duplicate keys are detected within the same batch. ([#929](https://github.com/TanStack/db/pull/929))
+
+## 0.5.8
+
+### Patch Changes
+
+- Fix pagination with Date orderBy values when backend has higher precision than JavaScript's millisecond precision. When loading duplicate values during cursor-based pagination, Date values now use a 1ms range query (`gte`/`lt`) instead of exact equality (`eq`) to correctly match all rows that fall within the same millisecond, even if the backend (e.g., PostgreSQL) stores them with microsecond precision. ([#913](https://github.com/TanStack/db/pull/913))
+
+- Fixed incorrect deduplication of limited queries with different where clauses. Previously, a query like `{where: searchFilter, limit: 10}` could be incorrectly deduplicated against a prior query `{where: undefined, limit: 10}`, causing search/filter results to only show cached data. Now, limited queries are only deduplicated when their where clauses are structurally equal. ([#914](https://github.com/TanStack/db/pull/914))
+
+## 0.5.7
+
+### Patch Changes
+
+- Fix change tracking for array items accessed via iteration methods (find, forEach, for...of, etc.) ([#910](https://github.com/TanStack/db/pull/910))
+
+  Previously, modifications to array items retrieved via iteration methods were not tracked by the change proxy because these methods returned raw array elements instead of proxied versions. This caused `getChanges()` to return an empty object, which in turn caused `createOptimisticAction`'s `mutationFn` to never be called when using patterns like:
+
+  ```ts
+  collection.update(id, (draft) => {
+    const item = draft.items.find((x) => x.id === targetId)
+    if (item) {
+      item.value = newValue // This change was not tracked!
+    }
+  })
+  ```
+
+  The fix adds proxy handling for array iteration methods similar to how Map/Set iteration is already handled, ensuring that callbacks receive proxied elements and returned elements are properly proxied.
+
+  Also refactors proxy.ts for improved readability by extracting helper functions and hoisting constants to module scope.
+
+## 0.5.6
+
+### Patch Changes
+
+- Fix scheduler handling of lazy left-join/live-query dependencies: treat non-enqueued lazy deps as satisfied to avoid unresolved-dependency deadlocks, and block only when a dep actually has pending work. ([#898](https://github.com/TanStack/db/pull/898))
+
+## 0.5.5
+
+### Patch Changes
+
+- Fix data loss on component remount by implementing reference counting for QueryObserver lifecycle ([#870](https://github.com/TanStack/db/pull/870))
+
+  **What changed vs main:**
+
+  Previously, when live query subscriptions unsubscribed, there was no tracking of which rows were still needed by other active queries. This caused data loss during remounts.
+
+  This PR adds reference counting infrastructure to properly manage QueryObserver lifecycle:
+  1. Pass same predicates to `unloadSubset` that were passed to `loadSubset`
+  2. Use them to compute the queryKey (via `generateQueryKeyFromOptions`)
+  3. Use existing machinery (`queryToRows` map) to find rows that query loaded
+  4. Decrement the ref count
+  5. GC rows where count reaches 0 (no longer referenced by any active query)
+
+  **Impact:**
+  - Navigation back to previously loaded pages shows cached data immediately
+  - No unnecessary refetches during quick remounts (< gcTime)
+  - Multiple live queries with identical predicates correctly share QueryObservers
+  - Proper row-level cleanup when last subscriber leaves
+  - TanStack Query's cache lifecycle (gcTime) is fully respected
+  - No data leakage from in-flight requests when unsubscribing
+
+## 0.5.4
+
+### Patch Changes
+
+- Fix progressive mode to use fetchSnapshot and atomic swap ([#852](https://github.com/TanStack/db/pull/852))
+
+  Progressive mode was broken because `requestSnapshot()` injected snapshots into the stream in causally correct position, which didn't work properly with the `full` mode stream. This release fixes progressive mode by:
+
+  **Core Changes:**
+  - Use `fetchSnapshot()` during initial sync to fetch and apply snapshots immediately in sync transactions
+  - Buffer all stream messages during initial sync (renamed flag to `isBufferingInitialSync`)
+  - Perform atomic swap on first `up-to-date`: truncate snapshot data → apply buffered messages → mark ready
+  - Track txids/snapshots only after atomic swap (enables correct optimistic transaction confirmation)
+
+  **Test Infrastructure:**
+  - Added `ELECTRIC_TEST_HOOKS` symbol for test control (hidden from public API)
+  - Added `progressiveTestControl.releaseInitialSync()` to E2E test config for explicit transition control
+  - Created comprehensive progressive mode E2E test suite (8 tests):
+    - Explicit snapshot phase and atomic swap validation
+    - Txid tracking behavior (Electric-only)
+    - Multiple concurrent snapshots with deduplication
+    - Incremental updates after swap
+    - Predicate handling and resilience tests
+
+  **Bug Fixes:**
+  - Fixed type errors in test files
+  - All 166 unit tests + 95 E2E tests passing
+
+- Improved error messages when invalid source types are passed to `.from()` or `.join()` methods. When users mistakenly pass a string, null, array, or other invalid type instead of an object with a collection, they now receive a clear, actionable error message with an example of the correct usage (e.g., `.from({ todos: todosCollection })`). ([#875](https://github.com/TanStack/db/pull/875))
+
+- Migrated paced mutations implementation from `@tanstack/pacer` to `@tanstack/pacer-lite`. The lite version provides the same core functionality with minimal overhead and no external dependencies, making it more suitable for library use. This is an internal implementation change with no impact on the public API - all paced mutation strategies (debounce, throttle, queue) continue to work exactly as before. ([#880](https://github.com/TanStack/db/pull/880))
+
+- Add warning when calling `.preload()` on collections with `on-demand` syncMode. In on-demand mode, data is only loaded when queries request it, so calling `.preload()` on the collection itself is a no-op. Users should create a live query and call `.preload()` on that instead. ([#871](https://github.com/TanStack/db/pull/871))
+
+## 0.5.3
+
+### Patch Changes
+
+- Pass all operators in where clauses to the collection's loadSubset function ([#851](https://github.com/TanStack/db/pull/851))
+
+- Improve type of mutations in transactions ([#854](https://github.com/TanStack/db/pull/854))
+
+## 0.5.2
+
+### Patch Changes
+
+- Fix localStorage collections to properly handle numeric and string IDs without collisions. Previously, operations could target the wrong item when using numeric IDs (e.g., `id: 1`, `id: 2`) after the page reloaded, due to a type mismatch between numeric keys in memory and stringified keys from localStorage. Keys are now encoded with type prefixes (`n:` for numbers, `s:` for strings) to prevent all possible collisions between different key types. ([#845](https://github.com/TanStack/db/pull/845))
+
+## 0.5.1
+
+### Patch Changes
+
+- Upgrade @tanstack/pacer to v0.16.2 and fix AsyncQueuer API usage. The pacer package API changed significantly, requiring updates to how AsyncQueuer is constructed and items are queued in the queueStrategy implementation. ([#840](https://github.com/TanStack/db/pull/840))
+
+## 0.5.0
+
+### Minor Changes
+
+- Implement 3-valued logic (true/false/unknown) for all comparison and logical operators. ([#765](https://github.com/TanStack/db/pull/765))
+  Queries with null/undefined values now behave consistently with SQL databases, where UNKNOWN results exclude rows from WHERE clauses.
+
+  **Breaking Change**: This changes the behavior of `WHERE` and `HAVING` clauses when dealing with `null` and `undefined` values.
+
+  **Example 1: Equality checks with null**
+
+  Previously, this query would return all persons with `age = null`:
+
+  ```ts
+  q.from(...).where(({ person }) => eq(person.age, null))
+  ```
+
+  With 3-valued logic, `eq(anything, null)` evaluates to `null` (UNKNOWN) and is filtered out. Use `isNull()` instead:
+
+  ```ts
+  q.from(...).where(({ person }) => isNull(person.age))
+  ```
+
+  **Example 2: Comparisons with null values**
+
+  Previously, this query would return persons with `age < 18` OR `age = null`:
+
+  ```ts
+  q.from(...).where(({ person }) => lt(person.age, 18))
+  ```
+
+  With 3-valued logic, `lt(null, 18)` evaluates to `null` (UNKNOWN) and is filtered out. The same applies to `undefined` values. To include null values, combine with `isNull()`:
+
+  ```ts
+  q.from(...).where(({ person }) =>
+    or(lt(person.age, 18), isNull(person.age))
+  )
+  ```
+
+### Patch Changes
+
+- Add optional compareOptions to collection configuration. ([#763](https://github.com/TanStack/db/pull/763))
+
+- Add expression helper utilities for parsing LoadSubsetOptions in queryFn. ([#763](https://github.com/TanStack/db/pull/763))
+
+  When using `syncMode: 'on-demand'`, TanStack DB now provides helper functions to easily parse where clauses, orderBy, and limit predicates into your API's format:
+  - `parseWhereExpression`: Parse where clauses with custom handlers for each operator
+  - `parseOrderByExpression`: Parse order by into simple array format
+  - `extractSimpleComparisons`: Extract simple AND-ed filters
+  - `parseLoadSubsetOptions`: Convenience function to parse all options at once
+  - `walkExpression`, `extractFieldPath`, `extractValue`: Lower-level helpers
+
+  **Example:**
+
+  ```typescript
+  import { parseLoadSubsetOptions } from '@tanstack/db'
+  // or from "@tanstack/query-db-collection" (re-exported for convenience)
+
+  queryFn: async (ctx) => {
+    const { where, orderBy, limit } = ctx.meta.loadSubsetOptions
+
+    const parsed = parseLoadSubsetOptions({ where, orderBy, limit })
+
+    // Build API request from parsed filters
+    const params = new URLSearchParams()
+    parsed.filters.forEach(({ field, operator, value }) => {
+      if (operator === 'eq') {
+        params.set(field.join('.'), String(value))
+      }
+    })
+
+    return fetch(`/api/products?${params}`).then((r) => r.json())
+  }
+  ```
+
+  This eliminates the need to manually traverse expression AST trees when implementing predicate push-down.
+
+- Fix Uint8Array/Buffer comparison to work by content instead of reference. This enables proper equality checks for binary IDs like ULIDs in WHERE clauses using the `eq` function. ([#779](https://github.com/TanStack/db/pull/779))
+
+- Add predicate comparison and merging utilities (isWhereSubset, intersectWherePredicates, unionWherePredicates, and related functions) to support predicate push-down in collection sync operations, enabling efficient tracking of loaded data ranges and preventing redundant server requests. Includes performance optimizations for large primitive IN predicates and full support for Date objects in equality, range, and IN clause comparisons. ([#763](https://github.com/TanStack/db/pull/763))
+
+- Add support for orderBy and limit in currentStateAsChanges function ([#763](https://github.com/TanStack/db/pull/763))
+
+- Adds an onDeduplicate callback on the DeduplicatedLoadSubset class which is called when a loadSubset call is deduplicated ([#763](https://github.com/TanStack/db/pull/763))
+
+- Updated dependencies [[`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb)]:
+  - @tanstack/db-ivm@0.1.13
+
+## 0.4.20
+
+### Patch Changes
+
+- Fix type inference for findOne() when used with join operations ([#749](https://github.com/TanStack/db/pull/749))
+
+  Previously, using `findOne()` with join operations (leftJoin, innerJoin, etc.) resulted in the query type being inferred as `never`, breaking TypeScript type checking:
+
+  ```typescript
+  const query = useLiveQuery(
+    (q) =>
+      q
+        .from({ todo: todoCollection })
+        .leftJoin({ todoOptions: todoOptionsCollection }, ...)
+        .findOne() // Type became 'never'
+  )
+  ```
+
+  **The Fix:**
+
+  Fixed the `MergeContextWithJoinType` type definition to conditionally include the `singleResult` property only when it's explicitly `true`, avoiding type conflicts when `findOne()` is called after joins:
+
+  ```typescript
+  // Before (buggy):
+  singleResult: TContext['singleResult'] extends true ? true : false
+
+  // After (fixed):
+  type PreserveSingleResultFlag<TFlag> = [TFlag] extends [true]
+    ? { singleResult: true }
+    : {}
+
+  // Used as:
+  } & PreserveSingleResultFlag<TContext['singleResult']>
+  ```
+
+  **Why This Works:**
+
+  By using a conditional intersection that omits the property entirely when not needed, we avoid type conflicts. Intersecting `{} & { singleResult: true }` cleanly results in `{ singleResult: true }`, whereas the previous approach created conflicting property types resulting in `never`. The tuple wrapper (`[TFlag]`) ensures robust behavior even if the flag type becomes a union in the future.
+
+  **Impact:**
+  - ✅ `findOne()` now works correctly with all join types
+  - ✅ Type inference works properly in `useLiveQuery` and other contexts
+  - ✅ Both `findOne()` before and after joins work correctly
+  - ✅ All tests pass with no breaking changes (8 new type tests added)
+
+- Improve error messages for custom getKey with joined queries ([#717](https://github.com/TanStack/db/pull/717))
+
+  Enhanced `DuplicateKeySyncError` to provide context-aware guidance when duplicate keys occur with custom `getKey` and joined queries.
+
+  **The Issue:**
+
+  When using custom `getKey` with joins, duplicate keys can occur if the join produces multiple rows with the same key value. This is valid for 1:1 relationships but problematic for 1:many relationships, and the previous error message didn't explain what went wrong or how to fix it.
+
+  **What's New:**
+
+  When a duplicate key error occurs in a live query collection that uses both custom `getKey` and joins, the error message now:
+  - Explains that joined queries can produce multiple rows with the same key
+  - Suggests using a composite key in your `getKey` function
+  - Provides concrete examples of solutions
+  - Helps distinguish between correctly structured 1:1 joins vs problematic 1:many joins
+
+  **Example:**
+
+  ```typescript
+  // ✅ Valid - 1:1 relationship with unique keys
+  const userProfiles = createLiveQueryCollection({
+    query: (q) =>
+      q
+        .from({ profile: profiles })
+        .join({ user: users }, ({ profile, user }) =>
+          eq(profile.userId, user.id),
+        ),
+    getKey: (profile) => profile.id, // Each profile has unique ID
+  })
+  ```
+
+  ```typescript
+  // ⚠️ Problematic - 1:many relationship with duplicate keys
+  const userComments = createLiveQueryCollection({
+    query: (q) =>
+      q
+        .from({ user: users })
+        .join({ comment: comments }, ({ user, comment }) =>
+          eq(user.id, comment.userId),
+        ),
+    getKey: (item) => item.userId, // Multiple comments share same userId!
+  })
+
+  // Enhanced error message:
+  // "Cannot insert document with key "user1" from sync because it already exists.
+  // This collection uses a custom getKey with joined queries. Joined queries can
+  // produce multiple rows with the same key when relationships are not 1:1.
+  // Consider: (1) using a composite key in your getKey function (e.g., `${item.key1}-${item.key2}`),
+  // (2) ensuring your join produces unique rows per key, or (3) removing the
+  // custom getKey to use the default composite key behavior."
+  ```
+
+- Add QueryObserver state utilities and convert error utils to getters ([#742](https://github.com/TanStack/db/pull/742))
+
+  Exposes TanStack Query's QueryObserver state through QueryCollectionUtils, providing visibility into sync status beyond just error states. Also converts existing error state utilities from methods to getters for consistency with TanStack DB/Query patterns.
+
+  **Breaking Changes:**
+  - `lastError()`, `isError()`, and `errorCount()` are now getters instead of methods
+    - Before: `collection.utils.lastError()`
+    - After: `collection.utils.lastError`
+
+  **New Utilities:**
+  - `isFetching` - Check if query is currently fetching (initial or background)
+  - `isRefetching` - Check if query is refetching in background
+  - `isLoading` - Check if query is loading for first time
+  - `dataUpdatedAt` - Get timestamp of last successful data update
+  - `fetchStatus` - Get current fetch status ('fetching' | 'paused' | 'idle')
+
+  **Use Cases:**
+  - Show loading indicators during background refetches
+  - Implement "Last updated X minutes ago" UI patterns
+  - Better understanding of query sync behavior
+
+  **Example Usage:**
+
+  ```ts
+  const collection = queryCollectionOptions({
+    // ... config
+  })
+
+  // Check sync status
+  if (collection.utils.isFetching) {
+    console.log('Syncing with server...')
+  }
+
+  if (collection.utils.isRefetching) {
+    console.log('Background refresh in progress')
+  }
+
+  // Show last update time
+  const lastUpdate = new Date(collection.utils.dataUpdatedAt)
+  console.log(`Last synced: ${lastUpdate.toLocaleTimeString()}`)
+
+  // Check error state (now using getters)
+  if (collection.utils.isError) {
+    console.error('Sync failed:', collection.utils.lastError)
+    console.log(`Failed ${collection.utils.errorCount} times`)
+  }
+  ```
+
+## 0.4.19
+
+### Patch Changes
+
+- Significantly improve localStorage collection performance during rapid mutations ([#760](https://github.com/TanStack/db/pull/760))
+
+  Optimizes localStorage collections to eliminate redundant storage reads, providing dramatic performance improvements for use cases with rapid mutations (e.g., text input with live query rendering).
+
+  **Performance Improvements:**
+  - **67% reduction in localStorage I/O operations** - from 3 reads + 1 write per mutation down to just 1 write
+  - Eliminated 2 JSON parse operations per mutation
+  - Eliminated 1 full collection diff operation per mutation
+  - Leverages in-memory cache (`lastKnownData`) instead of reading from storage on every mutation
+
+  **What Changed:**
+  1. **Mutation handlers** now use in-memory cache instead of loading from storage before mutations
+  2. **Post-mutation sync** eliminated - no longer triggers redundant storage reads after local mutations
+  3. **Manual transactions** (`acceptMutations`) optimized to use in-memory cache
+
+  **Before:** Each mutation performed 3 I/O operations:
+  - `loadFromStorage()` - read + JSON parse
+  - Modify data
+  - `saveToStorage()` - JSON stringify + write
+  - `processStorageChanges()` - another read + parse + diff
+
+  **After:** Each mutation performs 1 I/O operation:
+  - Modify in-memory data ✨ No I/O!
+  - `saveToStorage()` - JSON stringify + write
+
+  **Safety:**
+  - Cross-tab synchronization still works correctly via storage event listeners
+  - All 50 tests pass including 8 new tests specifically for rapid mutations and edge cases
+  - 92.3% code coverage on local-storage.ts
+  - `lastKnownData` cache kept in sync with storage through initial load, mutations, and cross-tab events
+
+  This optimization is particularly impactful for applications with:
+  - Real-time text input with live query rendering
+  - Frequent mutations to localStorage-backed collections
+  - Multiple rapid sequential mutations
+
+## 0.4.18
+
+### Patch Changes
+
+- Fix bug with orderBy that caused queries to skip duplicate values and/or stall on duplicate values. ([#713](https://github.com/TanStack/db/pull/713))
+
+- Validate against duplicate collection aliases in subqueries. Prevents a bug where using the same alias for a collection in both parent and subquery causes empty results or incorrect aggregation values. Now throws a clear `DuplicateAliasInSubqueryError` when this pattern is detected, guiding users to rename the conflicting alias. ([#719](https://github.com/TanStack/db/pull/719))
+
+## 0.4.17
+
+### Patch Changes
+
+- Add offline-transactions package with robust offline-first capabilities ([#559](https://github.com/TanStack/db/pull/559))
+
+  New package `@tanstack/offline-transactions` provides a comprehensive offline-first transaction system with:
+
+  **Core Features:**
+  - Persistent outbox pattern for reliable transaction processing
+  - Leader election for multi-tab coordination (Web Locks API with BroadcastChannel fallback)
+  - Automatic storage capability detection with graceful degradation
+  - Retry logic with exponential backoff and jitter
+  - Sequential transaction processing (FIFO ordering)
+
+  **Storage:**
+  - Automatic fallback chain: IndexedDB → localStorage → online-only
+  - Detects and handles private mode, SecurityError, QuotaExceededError
+  - Custom storage adapter support
+  - Diagnostic callbacks for storage failures
+
+  **Developer Experience:**
+  - TypeScript-first with full type safety
+  - Comprehensive test suite (25 tests covering leader failover, storage failures, e2e scenarios)
+  - Works in all modern browsers and server-side rendering environments
+
+  **@tanstack/db improvements:**
+  - Enhanced duplicate instance detection (dev-only, iframe-aware, with escape hatch)
+  - Better environment detection for SSR and worker contexts
+
+  Example usage:
+
+  ```typescript
+  import {
+    startOfflineExecutor,
+    IndexedDBAdapter,
+  } from '@tanstack/offline-transactions'
+
+  const executor = startOfflineExecutor({
+    collections: { todos: todoCollection },
+    storage: new IndexedDBAdapter(),
+    mutationFns: {
+      syncTodos: async ({ transaction, idempotencyKey }) => {
+        // Sync mutations to backend
+        await api.sync(transaction.mutations, idempotencyKey)
+      },
+    },
+    onStorageFailure: (diagnostic) => {
+      console.warn('Running in online-only mode:', diagnostic.message)
+    },
+  })
+
+  // Create offline transaction
+  const tx = executor.createOfflineTransaction({
+    mutationFnName: 'syncTodos',
+    autoCommit: false,
+  })
+
+  tx.mutate(() => {
+    todoCollection.insert({ id: '1', text: 'Buy milk', completed: false })
+  })
+
+  await tx.commit() // Persists to outbox and syncs when online
+  ```
+
+## 0.4.16
+
+### Patch Changes
+
+- Enable auto-indexing for nested field paths ([#728](https://github.com/TanStack/db/pull/728))
+
+  Previously, auto-indexes were only created for top-level fields. Queries filtering on nested fields like `vehicleDispatch.date` or `profile.score` were forced to perform full table scans, causing significant performance issues.
+
+  Now, auto-indexes are automatically created for nested field paths of any depth when using `eq()`, `gt()`, `gte()`, `lt()`, `lte()`, or `in()` operations.
+
+  **Performance Impact:**
+
+  Before this fix, filtering on nested fields resulted in expensive full scans:
+  - Query time: ~353ms for 39 executions (from issue #727)
+  - "graph run" and "d2ts join" operations dominated execution time
+
+  After this fix, nested field queries use indexes:
+  - Query time: Sub-millisecond (typical indexed lookup)
+  - Proper index utilization verified through query optimizer
+
+  **Example:**
+
+  ```typescript
+  const collection = createCollection({
+    getKey: (item) => item.id,
+    autoIndex: 'eager', // default
+    // ... sync config
+  })
+
+  // These now automatically create and use indexes:
+  collection.subscribeChanges((items) => console.log(items), {
+    whereExpression: eq(row.vehicleDispatch?.date, '2024-01-01'),
+  })
+
+  collection.subscribeChanges((items) => console.log(items), {
+    whereExpression: gt(row.profile?.stats.rating, 4.5),
+  })
+  ```
+
+  **Index Naming:**
+
+  Auto-indexes for nested paths use the format `auto:field.path` to avoid naming conflicts:
+  - `auto:status` for top-level field `status`
+  - `auto:profile.score` for nested field `profile.score`
+  - `auto:metadata.stats.views` for deeply nested field `metadata.stats.views`
+
+  Fixes #727
+
+- Fixed performance issue where using multiple `.where()` calls created multiple filter operators in the query pipeline. The optimizer now implements the missing final step (step 3) of combining remaining WHERE clauses into a single AND expression. This applies to both queries with and without joins: ([#732](https://github.com/TanStack/db/pull/732))
+  - Queries without joins: Multiple WHERE clauses are now combined before compilation
+  - Queries with joins: Remaining WHERE clauses after predicate pushdown are combined
+
+  This reduces filter operators from N to 1, making chained `.where()` calls perform identically to using a single `.where()` with `and()`.
+
+- Add paced mutations with pluggable timing strategies ([#704](https://github.com/TanStack/db/pull/704))
+
+  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
+  ```
+
+## 0.4.15
+
+### Patch Changes
+
+- Added support for custom parsers/serializers like superjson in LocalStorage collections ([#730](https://github.com/TanStack/db/pull/730))
+
+## 0.4.14
+
+### Patch Changes
+
+- Fix collection cleanup to fire status:change event with 'cleaned-up' status ([#714](https://github.com/TanStack/db/pull/714))
+
+  Previously, when a collection was garbage collected, event handlers were removed before the status was changed to 'cleaned-up'. This prevented listeners from receiving the status:change event, breaking the collection factory pattern where collections listen for cleanup to remove themselves from a cache.
+
+  Now, the cleanup process:
+  1. Cleans up sync, state, changes, and indexes
+  2. Sets status to 'cleaned-up' (fires the event)
+  3. Finally cleans up event handlers
+
+  This enables the collection factory pattern:
+
+  ```typescript
+  const cache = new Map<string, ReturnType<typeof createCollection>>()
+
+  const getTodoCollection = (id: string) => {
+    if (!cache.has(id)) {
+      const collection = createCollection(/* ... */)
+
+      collection.on('status:change', ({ status }) => {
+        if (status === 'cleaned-up') {
+          cache.delete(id) // This now works!
+        }
+      })
+
+      cache.set(id, collection)
+    }
+    return cache.get(id)!
+  }
+  ```
+
+## 0.4.13
+
+### Patch Changes
+
+- Fix synced propagation when preceding mutation was non-optimistic ([#715](https://github.com/TanStack/db/pull/715))
+
+## 0.4.12
+
+### Patch Changes
+
+- Add in-memory fallback for localStorage collections in SSR environments ([#696](https://github.com/TanStack/db/pull/696))
+
+  Prevents errors when localStorage collections are imported on the server by automatically falling back to an in-memory store. This allows isomorphic JavaScript applications to safely import localStorage collection modules without errors during module initialization.
+
+  When localStorage is not available (e.g., in server-side rendering environments), the collection automatically uses an in-memory storage implementation. Data will not persist across page reloads or be shared across tabs when using the in-memory fallback, but the collection will function normally otherwise.
+
+  Fixes #691
+
+- Add support for orderBy and limit in currentStateAsChanges function ([#701](https://github.com/TanStack/db/pull/701))
+
+- Updated dependencies [[`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db-ivm@0.1.12
+
 ## 0.4.11
 
 ### Patch Changes
@@ -18,9 +910,9 @@
   const users = createLiveQueryCollection((q) =>
     q
       .from({ user: usersCollection })
-      .orderBy(({ user }) => user.name, "asc")
+      .orderBy(({ user }) => user.name, 'asc')
       .limit(10)
-      .offset(0)
+      .offset(0),
   )
 
   users.utils.setWindow({ offset: 10, limit: 10 })
@@ -181,15 +1073,15 @@
   ```js
   // Before - commit() didn't throw
   await tx.commit()
-  if (tx.state === "failed") {
-    console.error("Failed:", tx.error)
+  if (tx.state === 'failed') {
+    console.error('Failed:', tx.error)
   }
 
   // After - commit() now throws
   try {
     await tx.commit()
   } catch (error) {
-    console.error("Failed:", error)
+    console.error('Failed:', error)
   }
   ```
 
@@ -529,7 +1421,7 @@
   try {
     collection.insert(data)
   } catch (error) {
-    if (error.message.includes("already exists")) {
+    if (error.message.includes('already exists')) {
       // Handle duplicate key error
     }
   }
@@ -538,7 +1430,7 @@
   **After:**
 
   ```ts
-  import { DuplicateKeyError } from "@tanstack/db"
+  import { DuplicateKeyError } from '@tanstack/db'
 
   try {
     collection.insert(data)
@@ -555,14 +1447,14 @@
 
   ```ts
   // Electric collection errors were imported from @tanstack/db
-  import { ElectricInsertHandlerMustReturnTxIdError } from "@tanstack/db"
+  import { ElectricInsertHandlerMustReturnTxIdError } from '@tanstack/db'
   ```
 
   **After:**
 
   ```ts
   // Now import from the specific adapter package
-  import { ElectricInsertHandlerMustReturnTxIdError } from "@tanstack/electric-db-collection"
+  import { ElectricInsertHandlerMustReturnTxIdError } from '@tanstack/electric-db-collection'
   ```
 
   ### Unified Error Handling
@@ -570,14 +1462,14 @@
   **New:**
 
   ```ts
-  import { TanStackDBError } from "@tanstack/db"
+  import { TanStackDBError } from '@tanstack/db'
 
   try {
     // Any TanStack DB operation
   } catch (error) {
     if (error instanceof TanStackDBError) {
       // Handle all TanStack DB errors uniformly
-      console.log("TanStack DB error:", error.message)
+      console.log('TanStack DB error:', error.message)
     }
   }
   ```
diff --git a/packages/db/README.md b/packages/db/README.md
index 0a18beb57..b0ba1746d 100644
--- a/packages/db/README.md
+++ b/packages/db/README.md
@@ -1,8 +1,8 @@
 # @tanstack/db
 
-**A reactive client store for building super fast apps on sync**
+**The reactive client store for your API**
 
-TanStack DB extends TanStack Query with collections, live queries and optimistic mutations that keep your UI reactive, consistent and blazing fast 🔥
+TanStack DB solves the problems of building fast, modern apps. It extends TanStack Query with collections, live queries and optimistic mutations that keep your UI reactive, consistent and blazing fast 🔥
 
 <p>
   <a href="https://x.com/intent/post?text=TanStack%20DB&url=https://tanstack.com/db">
@@ -21,14 +21,14 @@ TanStack DB extends TanStack Query with collections, live queries and optimistic
 
 ## 💥 Visit the [TanStack/db](https://github.com/TanStack/db) repo for docs and details!
 
-- 🔥 **blazing fast query engine**<br />
-  for sub-millisecond live queries &mdash; even for complex queries with joins and aggregates
-- 🎯 **fine-grained reactivity**<br />
-  to minimize component re-rendering
-- 💪 **robust transaction primitives**<br />
-  for easy optimistic mutations with sync and lifecycle support
-- 🌟 **normalized data**<br />
-  to keep your backend simple
+- 🚀 **Avoid endpoint sprawl**<br />
+  Load data into normalized collections instead of building custom endpoints for every view
+- 🔥 **Blazing fast queries**<br />
+  Sub-millisecond live queries with joins & aggregates—your app stays fast no matter how much data you load
+- ⚡ **Instant interactions**<br />
+  Take the network off the interaction path with optimistic writes that feel instantaneous
+- 🎯 **Fine-grained reactivity**<br />
+  Minimize component re-rendering with precise updates
 
 ---
 
diff --git a/packages/db/package.json b/packages/db/package.json
index 932d17e67..fb777bb48 100644
--- a/packages/db/package.json
+++ b/packages/db/package.json
@@ -1,16 +1,30 @@
 {
   "name": "@tanstack/db",
+  "version": "0.5.24",
   "description": "A reactive client store for building super fast apps on sync",
-  "version": "0.4.11",
-  "dependencies": {
-    "@standard-schema/spec": "^1.0.0",
-    "@tanstack/db-ivm": "workspace:*"
+  "author": "Kyle Mathews",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/db.git",
+    "directory": "packages/db"
   },
-  "devDependencies": {
-    "@vitest/coverage-istanbul": "^3.2.4",
-    "arktype": "^2.1.23",
-    "temporal-polyfill": "^0.3.0"
+  "homepage": "https://tanstack.com/db",
+  "keywords": [
+    "optimistic",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "build:minified": "vite build --minify",
+    "dev": "vite build --watch",
+    "lint": "eslint . --fix",
+    "test": "vitest --run"
   },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -24,35 +38,25 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
-  "packageManager": "pnpm@10.18.3",
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "@tanstack/db-ivm": "workspace:*",
+    "@tanstack/pacer-lite": "^0.2.0"
+  },
   "peerDependencies": {
     "typescript": ">=4.7"
   },
-  "author": "Kyle Mathews",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/TanStack/db.git",
-    "directory": "packages/db"
-  },
-  "homepage": "https://tanstack.com/db",
-  "keywords": [
-    "optimistic",
-    "typescript"
-  ],
-  "scripts": {
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "lint": "eslint . --fix",
-    "test": "npx vitest --run"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "devDependencies": {
+    "@tanstack/config": "^0.22.2",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "arktype": "^2.1.29",
+    "mitt": "^3.0.1",
+    "superjson": "^2.2.6",
+    "temporal-polyfill": "^0.3.0"
+  }
 }
diff --git a/packages/db/src/SortedMap.ts b/packages/db/src/SortedMap.ts
index 268b614f0..3d59ad687 100644
--- a/packages/db/src/SortedMap.ts
+++ b/packages/db/src/SortedMap.ts
@@ -1,62 +1,81 @@
+import { compareKeys } from '@tanstack/db-ivm'
+
 /**
  * A Map implementation that keeps its entries sorted based on a comparator function
- * @template TKey - The type of keys in the map
+ * @template TKey - The type of keys in the map (must be string | number)
  * @template TValue - The type of values in the map
  */
-export class SortedMap<TKey, TValue> {
+export class SortedMap<TKey extends string | number, TValue> {
   private map: Map<TKey, TValue>
   private sortedKeys: Array<TKey>
-  private comparator: (a: TValue, b: TValue) => number
+  private comparator: ((a: TValue, b: TValue) => number) | undefined
 
   /**
    * Creates a new SortedMap instance
    *
-   * @param comparator - Optional function to compare values for sorting
+   * @param comparator - Optional function to compare values for sorting.
+   *                     If not provided, entries are sorted by key only.
    */
   constructor(comparator?: (a: TValue, b: TValue) => number) {
     this.map = new Map<TKey, TValue>()
     this.sortedKeys = []
-    this.comparator = comparator || this.defaultComparator
-  }
-
-  /**
-   * Default comparator function used when none is provided
-   *
-   * @param a - First value to compare
-   * @param b - Second value to compare
-   * @returns -1 if a < b, 1 if a > b, 0 if equal
-   */
-  private defaultComparator(a: TValue, b: TValue): number {
-    if (a < b) return -1
-    if (a > b) return 1
-    return 0
+    this.comparator = comparator
   }
 
   /**
    * Finds the index where a key-value pair should be inserted to maintain sort order.
-   * Uses binary search to find the correct position based on the value.
-   * Hence, it is in O(log n) time.
+   * Uses binary search to find the correct position based on the value (if comparator provided),
+   * with key-based tie-breaking for deterministic ordering when values compare as equal.
+   * If no comparator is provided, sorts by key only.
+   * Runs in O(log n) time.
    *
-   * @param key - The key to find position for
-   * @param value - The value to compare against
+   * @param key - The key to find position for (used as tie-breaker or primary sort when no comparator)
+   * @param value - The value to compare against (only used if comparator is provided)
    * @returns The index where the key should be inserted
    */
-  private indexOf(value: TValue): number {
+  private indexOf(key: TKey, value: TValue): number {
     let left = 0
     let right = this.sortedKeys.length
 
+    // Fast path: no comparator means sort by key only
+    if (!this.comparator) {
+      while (left < right) {
+        const mid = Math.floor((left + right) / 2)
+        const midKey = this.sortedKeys[mid]!
+        const keyComparison = compareKeys(key, midKey)
+        if (keyComparison < 0) {
+          right = mid
+        } else if (keyComparison > 0) {
+          left = mid + 1
+        } else {
+          return mid
+        }
+      }
+      return left
+    }
+
+    // With comparator: sort by value first, then key as tie-breaker
     while (left < right) {
       const mid = Math.floor((left + right) / 2)
       const midKey = this.sortedKeys[mid]!
       const midValue = this.map.get(midKey)!
-      const comparison = this.comparator(value, midValue)
+      const valueComparison = this.comparator(value, midValue)
 
-      if (comparison < 0) {
+      if (valueComparison < 0) {
         right = mid
-      } else if (comparison > 0) {
+      } else if (valueComparison > 0) {
         left = mid + 1
       } else {
-        return mid
+        // Values are equal, use key as tie-breaker for deterministic ordering
+        const keyComparison = compareKeys(key, midKey)
+        if (keyComparison < 0) {
+          right = mid
+        } else if (keyComparison > 0) {
+          left = mid + 1
+        } else {
+          // Same key (shouldn't happen during insert, but handle for lookups)
+          return mid
+        }
       }
     }
 
@@ -74,12 +93,12 @@ export class SortedMap<TKey, TValue> {
     if (this.map.has(key)) {
       // Need to remove the old key from the sorted keys array
       const oldValue = this.map.get(key)!
-      const oldIndex = this.indexOf(oldValue)
+      const oldIndex = this.indexOf(key, oldValue)
       this.sortedKeys.splice(oldIndex, 1)
     }
 
     // Insert the new key at the correct position
-    const index = this.indexOf(value)
+    const index = this.indexOf(key, value)
     this.sortedKeys.splice(index, 0, key)
 
     this.map.set(key, value)
@@ -106,7 +125,7 @@ export class SortedMap<TKey, TValue> {
   delete(key: TKey): boolean {
     if (this.map.has(key)) {
       const oldValue = this.map.get(key)
-      const index = this.indexOf(oldValue!)
+      const index = this.indexOf(key, oldValue!)
       this.sortedKeys.splice(index, 1)
       return this.map.delete(key)
     }
@@ -187,7 +206,7 @@ export class SortedMap<TKey, TValue> {
    * @param callbackfn - Function to execute for each entry
    */
   forEach(
-    callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void
+    callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void,
   ): void {
     for (const key of this.sortedKeys) {
       callbackfn(this.map.get(key)!, key, this.map)
diff --git a/packages/db/src/collection/change-events.ts b/packages/db/src/collection/change-events.ts
index 7a0e41acf..8a422a407 100644
--- a/packages/db/src/collection/change-events.ts
+++ b/packages/db/src/collection/change-events.ts
@@ -1,34 +1,32 @@
 import {
   createSingleRowRefProxy,
   toExpression,
-} from "../query/builder/ref-proxy"
-import { compileSingleRowExpression } from "../query/compiler/evaluators.js"
-import { optimizeExpressionWithIndexes } from "../utils/index-optimization.js"
+} from '../query/builder/ref-proxy'
+import {
+  compileSingleRowExpression,
+  toBooleanPredicate,
+} from '../query/compiler/evaluators.js'
+import {
+  findIndexForField,
+  optimizeExpressionWithIndexes,
+} from '../utils/index-optimization.js'
+import { ensureIndexForField } from '../indexes/auto-index.js'
+import { makeComparator } from '../utils/comparison.js'
+import { buildCompareOptions } from '../query/compiler/order-by'
 import type {
   ChangeMessage,
+  CollectionLike,
   CurrentStateAsChangesOptions,
   SubscribeChangesOptions,
-} from "../types"
-import type { Collection } from "./index.js"
-import type { SingleRowRefProxy } from "../query/builder/ref-proxy"
-import type { BasicExpression } from "../query/ir.js"
-
-/**
- * Interface for a collection-like object that provides the necessary methods
- * for the change events system to work
- */
-export interface CollectionLike<
-  T extends object = Record<string, unknown>,
-  TKey extends string | number = string | number,
-> extends Pick<
-    Collection<T, TKey>,
-    `get` | `has` | `entries` | `indexes` | `id`
-  > {}
+} from '../types'
+import type { CollectionImpl } from './index.js'
+import type { SingleRowRefProxy } from '../query/builder/ref-proxy'
+import type { BasicExpression, OrderBy } from '../query/ir.js'
 
 /**
  * Returns the current state of the collection as an array of changes
  * @param collection - The collection to get changes from
- * @param options - Options including optional where filter
+ * @param options - Options including optional where filter, orderBy, and limit
  * @returns An array of changes
  * @example
  * // Get all items as changes
@@ -41,7 +39,19 @@ export interface CollectionLike<
  *
  * // Get only items using a pre-compiled expression
  * const activeChanges = currentStateAsChanges(collection, {
- *   whereExpression: eq(row.status, 'active')
+ *   where: eq(row.status, 'active')
+ * })
+ *
+ * // Get items ordered by name with limit
+ * const topUsers = currentStateAsChanges(collection, {
+ *   orderBy: [{ expression: row.name, compareOptions: { direction: 'asc' } }],
+ *   limit: 10
+ * })
+ *
+ * // Get active users ordered by score (highest score first)
+ * const topActiveUsers = currentStateAsChanges(collection, {
+ *   where: eq(row.status, 'active'),
+ *   orderBy: [{ expression: row.score, compareOptions: { direction: 'desc' } }],
  * })
  */
 export function currentStateAsChanges<
@@ -49,11 +59,11 @@ export function currentStateAsChanges<
   TKey extends string | number,
 >(
   collection: CollectionLike<T, TKey>,
-  options: CurrentStateAsChangesOptions = {}
+  options: CurrentStateAsChangesOptions = {},
 ): Array<ChangeMessage<T>> | void {
   // Helper function to collect filtered results
   const collectFilteredResults = (
-    filterFn?: (value: T) => boolean
+    filterFn?: (value: T) => boolean,
   ): Array<ChangeMessage<T>> => {
     const result: Array<ChangeMessage<T>> = []
     for (const [key, value] of collection.entries()) {
@@ -69,9 +79,48 @@ export function currentStateAsChanges<
     return result
   }
 
-  // TODO: handle orderBy and limit options
-  //       by calling optimizeOrderedLimit
+  // Validate that limit without orderBy doesn't happen
+  if (options.limit !== undefined && !options.orderBy) {
+    throw new Error(`limit cannot be used without orderBy`)
+  }
+
+  // First check if orderBy is present (optionally with limit)
+  if (options.orderBy) {
+    // Create where filter function if present
+    const whereFilter = options.where
+      ? createFilterFunctionFromExpression(options.where)
+      : undefined
+
+    // Get ordered keys using index optimization when possible
+    const orderedKeys = getOrderedKeys(
+      collection,
+      options.orderBy,
+      options.limit,
+      whereFilter,
+      options.optimizedOnly,
+    )
+
+    if (orderedKeys === undefined) {
+      // `getOrderedKeys` returned undefined because we asked for `optimizedOnly` and there was no index to use
+      return
+    }
+
+    // Convert keys to change messages
+    const result: Array<ChangeMessage<T>> = []
+    for (const key of orderedKeys) {
+      const value = collection.get(key)
+      if (value !== undefined) {
+        result.push({
+          type: `insert`,
+          key,
+          value,
+        })
+      }
+    }
+    return result
+  }
 
+  // If no orderBy OR orderBy optimization failed, use where clause optimization
   if (!options.where) {
     // No filtering, return all items
     return collectFilteredResults()
@@ -84,7 +133,7 @@ export function currentStateAsChanges<
     // Try to optimize the query using indexes
     const optimizationResult = optimizeExpressionWithIndexes(
       expression,
-      collection.indexes
+      collection,
     )
 
     if (optimizationResult.canOptimize) {
@@ -113,7 +162,7 @@ export function currentStateAsChanges<
     // If anything goes wrong with the where clause, fall back to full scan
     console.warn(
       `${collection.id ? `[${collection.id}] ` : ``}Error processing where clause, falling back to full scan:`,
-      error
+      error,
     )
 
     const filterFn = createFilterFunctionFromExpression(options.where)
@@ -132,7 +181,7 @@ export function currentStateAsChanges<
  * @returns A function that takes an item and returns true if it matches the filter
  */
 export function createFilterFunction<T extends object>(
-  whereCallback: (row: SingleRowRefProxy<T>) => any
+  whereCallback: (row: SingleRowRefProxy<T>) => any,
 ): (item: T) => boolean {
   return (item: T): boolean => {
     try {
@@ -143,7 +192,7 @@ export function createFilterFunction<T extends object>(
       const evaluator = compileSingleRowExpression(expression)
       const result = evaluator(item as Record<string, unknown>)
       // WHERE clauses should always evaluate to boolean predicates (Kevin's feedback)
-      return result
+      return toBooleanPredicate(result)
     } catch {
       // If RefProxy approach fails (e.g., arithmetic operations), fall back to direct evaluation
       try {
@@ -155,7 +204,7 @@ export function createFilterFunction<T extends object>(
         }) as SingleRowRefProxy<T>
 
         const result = whereCallback(simpleProxy)
-        return result
+        return toBooleanPredicate(result)
       } catch {
         // If both approaches fail, exclude the item
         return false
@@ -170,13 +219,15 @@ export function createFilterFunction<T extends object>(
  * @returns A function that takes an item and returns true if it matches the filter
  */
 export function createFilterFunctionFromExpression<T extends object>(
-  expression: BasicExpression<boolean>
+  expression: BasicExpression<boolean>,
 ): (item: T) => boolean {
+  // Compile expression once when filter function is created, not on every invocation
+  const evaluator = compileSingleRowExpression(expression)
+
   return (item: T): boolean => {
     try {
-      const evaluator = compileSingleRowExpression(expression)
       const result = evaluator(item as Record<string, unknown>)
-      return Boolean(result)
+      return toBooleanPredicate(result)
     } catch {
       // If evaluation fails, exclude the item
       return false
@@ -192,7 +243,7 @@ export function createFilterFunctionFromExpression<T extends object>(
  */
 export function createFilteredCallback<T extends object>(
   originalCallback: (changes: Array<ChangeMessage<T>>) => void,
-  options: SubscribeChangesOptions
+  options: SubscribeChangesOptions,
 ): (changes: Array<ChangeMessage<T>>) => void {
   const filterFn = createFilterFunctionFromExpression(options.whereExpression!)
 
@@ -246,3 +297,118 @@ export function createFilteredCallback<T extends object>(
     }
   }
 }
+
+/**
+ * Gets ordered keys from a collection using index optimization when possible
+ * @param collection - The collection to get keys from
+ * @param orderBy - The order by clause
+ * @param limit - Optional limit on number of keys to return
+ * @param whereFilter - Optional filter function to apply while traversing
+ * @returns Array of keys in sorted order
+ */
+function getOrderedKeys<T extends object, TKey extends string | number>(
+  collection: CollectionLike<T, TKey>,
+  orderBy: OrderBy,
+  limit?: number,
+  whereFilter?: (item: T) => boolean,
+  optimizedOnly?: boolean,
+): Array<TKey> | undefined {
+  // For single-column orderBy on a ref expression, try index optimization
+  if (orderBy.length === 1) {
+    const clause = orderBy[0]!
+    const orderByExpression = clause.expression
+
+    if (orderByExpression.type === `ref`) {
+      const propRef = orderByExpression
+      const fieldPath = propRef.path
+      const compareOpts = buildCompareOptions(clause, collection)
+
+      // Ensure index exists for this field
+      ensureIndexForField(
+        fieldPath[0]!,
+        fieldPath,
+        collection as CollectionImpl<T, TKey>,
+        compareOpts,
+      )
+
+      // Find the index
+      const index = findIndexForField(collection, fieldPath, compareOpts)
+
+      if (index && index.supports(`gt`)) {
+        // Use index optimization
+        const filterFn = (key: TKey): boolean => {
+          const value = collection.get(key)
+          if (value === undefined) {
+            return false
+          }
+          return whereFilter?.(value) ?? true
+        }
+
+        // Take the keys that match the filter and limit
+        // if no limit is provided `index.keyCount` is used,
+        // i.e. we will take all keys that match the filter
+        return index.take(limit ?? index.keyCount, undefined, filterFn)
+      }
+    }
+  }
+
+  if (optimizedOnly) {
+    return
+  }
+
+  // Fallback: collect all items and sort in memory
+  const allItems: Array<{ key: TKey; value: T }> = []
+  for (const [key, value] of collection.entries()) {
+    if (whereFilter?.(value) ?? true) {
+      allItems.push({ key, value })
+    }
+  }
+
+  // Sort using makeComparator
+  const compare = (a: { key: TKey; value: T }, b: { key: TKey; value: T }) => {
+    for (const clause of orderBy) {
+      const compareFn = makeComparator(clause.compareOptions)
+
+      // Extract values for comparison
+      const aValue = extractValueFromItem(a.value, clause.expression)
+      const bValue = extractValueFromItem(b.value, clause.expression)
+
+      const result = compareFn(aValue, bValue)
+      if (result !== 0) {
+        return result
+      }
+    }
+    return 0
+  }
+
+  allItems.sort(compare)
+  const sortedKeys = allItems.map((item) => item.key)
+
+  // Apply limit if provided
+  if (limit !== undefined) {
+    return sortedKeys.slice(0, limit)
+  }
+
+  // if no limit is provided, we will return all keys
+  return sortedKeys
+}
+
+/**
+ * Helper function to extract a value from an item based on an expression
+ */
+function extractValueFromItem(item: any, expression: BasicExpression): any {
+  if (expression.type === `ref`) {
+    const propRef = expression
+    let value = item
+    for (const pathPart of propRef.path) {
+      value = value?.[pathPart]
+    }
+    return value
+  } else if (expression.type === `val`) {
+    return expression.value
+  } else {
+    // It must be a function
+    const evaluator = compileSingleRowExpression(expression)
+    return evaluator(item as Record<string, unknown>)
+  }
+}
diff --git a/packages/db/src/collection/changes.ts b/packages/db/src/collection/changes.ts
index 97e42c53b..03ed04a07 100644
--- a/packages/db/src/collection/changes.ts
+++ b/packages/db/src/collection/changes.ts
@@ -1,11 +1,15 @@
-import { NegativeActiveSubscribersError } from "../errors"
-import { CollectionSubscription } from "./subscription.js"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import type { ChangeMessage, SubscribeChangesOptions } from "../types"
-import type { CollectionLifecycleManager } from "./lifecycle.js"
-import type { CollectionSyncManager } from "./sync.js"
-import type { CollectionEventsManager } from "./events.js"
-import type { CollectionImpl } from "./index.js"
+import { NegativeActiveSubscribersError } from '../errors'
+import {
+  createSingleRowRefProxy,
+  toExpression,
+} from '../query/builder/ref-proxy.js'
+import { CollectionSubscription } from './subscription.js'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { ChangeMessage, SubscribeChangesOptions } from '../types'
+import type { CollectionLifecycleManager } from './lifecycle.js'
+import type { CollectionSyncManager } from './sync.js'
+import type { CollectionEventsManager } from './events.js'
+import type { CollectionImpl } from './index.js'
 
 export class CollectionChangesManager<
   TOutput extends object = Record<string, unknown>,
@@ -56,7 +60,7 @@ export class CollectionChangesManager<
    */
   public emitEvents(
     changes: Array<ChangeMessage<TOutput, TKey>>,
-    forceEmit = false
+    forceEmit = false,
   ): void {
     // Skip batching for user actions (forceEmit=true) to keep UI responsive
     if (this.shouldBatchEvents && !forceEmit) {
@@ -94,21 +98,48 @@ export class CollectionChangesManager<
    */
   public subscribeChanges(
     callback: (changes: Array<ChangeMessage<TOutput>>) => void,
-    options: SubscribeChangesOptions = {}
+    options: SubscribeChangesOptions<TOutput> = {},
   ): CollectionSubscription {
     // Start sync and track subscriber
     this.addSubscriber()
 
+    // Compile where callback to whereExpression if provided
+    if (options.where && options.whereExpression) {
+      throw new Error(
+        `Cannot specify both 'where' and 'whereExpression' options. Use one or the other.`,
+      )
+    }
+
+    const { where, ...opts } = options
+    let whereExpression = opts.whereExpression
+    if (where) {
+      const proxy = createSingleRowRefProxy<TOutput>()
+      const result = where(proxy)
+      whereExpression = toExpression(result)
+    }
+
     const subscription = new CollectionSubscription(this.collection, callback, {
-      ...options,
+      ...opts,
+      whereExpression,
       onUnsubscribe: () => {
         this.removeSubscriber()
         this.changeSubscriptions.delete(subscription)
       },
     })
 
+    // Register status listener BEFORE requesting snapshot to avoid race condition.
+    // This ensures the listener catches all status transitions, even if the
+    // loadSubset promise resolves synchronously or very quickly.
+    if (options.onStatusChange) {
+      subscription.on(`status:change`, options.onStatusChange)
+    }
+
     if (options.includeInitialState) {
-      subscription.requestSnapshot()
+      subscription.requestSnapshot({ trackLoadSubsetPromise: false })
+    } else if (options.includeInitialState === false) {
+      // When explicitly set to false (not just undefined), mark all state as "seen"
+      // so that all future changes (including deletes) pass through unfiltered.
+      subscription.markAllStateAsSeen()
     }
 
     // Add to batched listeners
@@ -135,7 +166,7 @@ export class CollectionChangesManager<
 
     this.events.emitSubscribersChange(
       this.activeSubscribersCount,
-      previousSubscriberCount
+      previousSubscriberCount,
     )
   }
 
@@ -154,7 +185,7 @@ export class CollectionChangesManager<
 
     this.events.emitSubscribersChange(
       this.activeSubscribersCount,
-      previousSubscriberCount
+      previousSubscriberCount,
     )
   }
 
diff --git a/packages/db/src/collection/events.ts b/packages/db/src/collection/events.ts
index 0f6d8cec1..f82a42f2c 100644
--- a/packages/db/src/collection/events.ts
+++ b/packages/db/src/collection/events.ts
@@ -1,6 +1,6 @@
-import { EventEmitter } from "../event-emitter.js"
-import type { Collection } from "./index.js"
-import type { CollectionStatus } from "../types.js"
+import { EventEmitter } from '../event-emitter.js'
+import type { Collection } from './index.js'
+import type { CollectionStatus } from '../types.js'
 
 /**
  * Event emitted when the collection status changes
@@ -43,10 +43,19 @@ export interface CollectionLoadingSubsetChangeEvent {
   loadingSubsetTransition: `start` | `end`
 }
 
+/**
+ * Event emitted when the collection is truncated (all data cleared)
+ */
+export interface CollectionTruncateEvent {
+  type: `truncate`
+  collection: Collection<any, any, any, any, any>
+}
+
 export type AllCollectionEvents = {
-  "status:change": CollectionStatusChangeEvent
-  "subscribers:change": CollectionSubscribersChangeEvent
-  "loadingSubset:change": CollectionLoadingSubsetChangeEvent
+  'status:change': CollectionStatusChangeEvent
+  'subscribers:change': CollectionSubscribersChangeEvent
+  'loadingSubset:change': CollectionLoadingSubsetChangeEvent
+  truncate: CollectionTruncateEvent
 } & {
   [K in CollectionStatus as `status:${K}`]: CollectionStatusEvent<K>
 }
@@ -56,9 +65,10 @@ export type CollectionEvent =
   | CollectionStatusChangeEvent
   | CollectionSubscribersChangeEvent
   | CollectionLoadingSubsetChangeEvent
+  | CollectionTruncateEvent
 
 export type CollectionEventHandler<T extends keyof AllCollectionEvents> = (
-  event: AllCollectionEvents[T]
+  event: AllCollectionEvents[T],
 ) => void
 
 export class CollectionEventsManager extends EventEmitter<AllCollectionEvents> {
@@ -78,14 +88,14 @@ export class CollectionEventsManager extends EventEmitter<AllCollectionEvents> {
    */
   emit<T extends keyof AllCollectionEvents>(
     event: T,
-    eventPayload: AllCollectionEvents[T]
+    eventPayload: AllCollectionEvents[T],
   ): void {
     this.emitInner(event, eventPayload)
   }
 
   emitStatusChange<T extends CollectionStatus>(
     status: T,
-    previousStatus: CollectionStatus
+    previousStatus: CollectionStatus,
   ) {
     this.emit(`status:change`, {
       type: `status:change`,
@@ -106,7 +116,7 @@ export class CollectionEventsManager extends EventEmitter<AllCollectionEvents> {
 
   emitSubscribersChange(
     subscriberCount: number,
-    previousSubscriberCount: number
+    previousSubscriberCount: number,
   ) {
     this.emit(`subscribers:change`, {
       type: `subscribers:change`,
diff --git a/packages/db/src/collection/index.ts b/packages/db/src/collection/index.ts
index 5a4ab3c07..39f59ed73 100644
--- a/packages/db/src/collection/index.ts
+++ b/packages/db/src/collection/index.ts
@@ -1,20 +1,20 @@
 import {
   CollectionRequiresConfigError,
   CollectionRequiresSyncConfigError,
-} from "../errors"
-import { currentStateAsChanges } from "./change-events"
-
-import { CollectionStateManager } from "./state"
-import { CollectionChangesManager } from "./changes"
-import { CollectionLifecycleManager } from "./lifecycle.js"
-import { CollectionSyncManager } from "./sync"
-import { CollectionIndexesManager } from "./indexes"
-import { CollectionMutationsManager } from "./mutations"
-import { CollectionEventsManager } from "./events.js"
-import type { CollectionSubscription } from "./subscription"
-import type { AllCollectionEvents, CollectionEventHandler } from "./events.js"
-import type { BaseIndex, IndexResolver } from "../indexes/base-index.js"
-import type { IndexOptions } from "../indexes/index-options.js"
+} from '../errors'
+import { currentStateAsChanges } from './change-events'
+
+import { CollectionStateManager } from './state'
+import { CollectionChangesManager } from './changes'
+import { CollectionLifecycleManager } from './lifecycle.js'
+import { CollectionSyncManager } from './sync'
+import { CollectionIndexesManager } from './indexes'
+import { CollectionMutationsManager } from './mutations'
+import { CollectionEventsManager } from './events.js'
+import type { CollectionSubscription } from './subscription'
+import type { AllCollectionEvents, CollectionEventHandler } from './events.js'
+import type { BaseIndex, IndexResolver } from '../indexes/base-index.js'
+import type { IndexOptions } from '../indexes/index-options.js'
 import type {
   ChangeMessage,
   CollectionConfig,
@@ -27,15 +27,16 @@ import type {
   NonSingleResult,
   OperationConfig,
   SingleResult,
+  StringCollationConfig,
   SubscribeChangesOptions,
   Transaction as TransactionType,
   UtilsRecord,
   WritableDeep,
-} from "../types"
-import type { SingleRowRefProxy } from "../query/builder/ref-proxy"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import type { BTreeIndex } from "../indexes/btree-index.js"
-import type { IndexProxy } from "../indexes/lazy-index.js"
+} from '../types'
+import type { SingleRowRefProxy } from '../query/builder/ref-proxy'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { BTreeIndex } from '../indexes/btree-index.js'
+import type { IndexProxy } from '../indexes/lazy-index.js'
 
 /**
  * Enhanced Collection interface that includes both data type T and utilities TUtils
@@ -126,32 +127,85 @@ export interface Collection<
  *
  */
 
-// Overload for when schema is provided
+// Overload for when schema is provided and utils is required (not optional)
+// We can't infer the Utils type from the CollectionConfig because it will always be optional
+// So we omit it from that type and instead infer it from the extension `& { utils: TUtils }`
+// such that we have the real, non-optional Utils type
 export function createCollection<
   T extends StandardSchemaV1,
-  TKey extends string | number = string | number,
-  TUtils extends UtilsRecord = UtilsRecord,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
 >(
-  options: CollectionConfig<InferSchemaOutput<T>, TKey, T> & {
+  options: Omit<
+    CollectionConfig<InferSchemaOutput<T>, TKey, T, TUtils>,
+    `utils`
+  > & {
     schema: T
-    utils?: TUtils
-  } & NonSingleResult
+    utils: TUtils // Required utils
+  } & NonSingleResult,
 ): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>> &
   NonSingleResult
 
+// Overload for when schema is provided and utils is optional
+// In this case we can simply infer the Utils type from the CollectionConfig type
+export function createCollection<
+  T extends StandardSchemaV1,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
+>(
+  options: CollectionConfig<InferSchemaOutput<T>, TKey, T, TUtils> & {
+    schema: T
+  } & NonSingleResult,
+): Collection<
+  InferSchemaOutput<T>,
+  TKey,
+  Exclude<TUtils, undefined>,
+  T,
+  InferSchemaInput<T>
+> &
+  NonSingleResult
+
+// Overload for when schema is provided, singleResult is true, and utils is required
+export function createCollection<
+  T extends StandardSchemaV1,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
+>(
+  options: Omit<
+    CollectionConfig<InferSchemaOutput<T>, TKey, T, TUtils>,
+    `utils`
+  > & {
+    schema: T
+    utils: TUtils // Required utils
+  } & SingleResult,
+): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>> &
+  SingleResult
+
 // Overload for when schema is provided and singleResult is true
 export function createCollection<
   T extends StandardSchemaV1,
-  TKey extends string | number = string | number,
-  TUtils extends UtilsRecord = UtilsRecord,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
 >(
-  options: CollectionConfig<InferSchemaOutput<T>, TKey, T> & {
+  options: CollectionConfig<InferSchemaOutput<T>, TKey, T, TUtils> & {
     schema: T
-    utils?: TUtils
-  } & SingleResult
+  } & SingleResult,
 ): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>> &
   SingleResult
 
+// Overload for when no schema is provided and utils is required
+// the type T needs to be passed explicitly unless it can be inferred from the getKey function in the config
+export function createCollection<
+  T extends object,
+  TKey extends string | number,
+  TUtils extends UtilsRecord,
+>(
+  options: Omit<CollectionConfig<T, TKey, never, TUtils>, `utils`> & {
+    schema?: never // prohibit schema if an explicit type is provided
+    utils: TUtils // Required utils
+  } & NonSingleResult,
+): Collection<T, TKey, TUtils, never, T> & NonSingleResult
+
 // Overload for when no schema is provided
 // the type T needs to be passed explicitly unless it can be inferred from the getKey function in the config
 export function createCollection<
@@ -159,12 +213,24 @@ export function createCollection<
   TKey extends string | number = string | number,
   TUtils extends UtilsRecord = UtilsRecord,
 >(
-  options: CollectionConfig<T, TKey, never> & {
+  options: CollectionConfig<T, TKey, never, TUtils> & {
     schema?: never // prohibit schema if an explicit type is provided
-    utils?: TUtils
-  } & NonSingleResult
+  } & NonSingleResult,
 ): Collection<T, TKey, TUtils, never, T> & NonSingleResult
 
+// Overload for when no schema is provided, singleResult is true, and utils is required
+// the type T needs to be passed explicitly unless it can be inferred from the getKey function in the config
+export function createCollection<
+  T extends object,
+  TKey extends string | number = string | number,
+  TUtils extends UtilsRecord = UtilsRecord,
+>(
+  options: Omit<CollectionConfig<T, TKey, never, TUtils>, `utils`> & {
+    schema?: never // prohibit schema if an explicit type is provided
+    utils: TUtils // Required utils
+  } & SingleResult,
+): Collection<T, TKey, TUtils, never, T> & SingleResult
+
 // Overload for when no schema is provided and singleResult is true
 // the type T needs to be passed explicitly unless it can be inferred from the getKey function in the config
 export function createCollection<
@@ -172,26 +238,24 @@ export function createCollection<
   TKey extends string | number = string | number,
   TUtils extends UtilsRecord = UtilsRecord,
 >(
-  options: CollectionConfig<T, TKey, never> & {
+  options: CollectionConfig<T, TKey, never, TUtils> & {
     schema?: never // prohibit schema if an explicit type is provided
-    utils?: TUtils
-  } & SingleResult
+  } & SingleResult,
 ): Collection<T, TKey, TUtils, never, T> & SingleResult
 
 // Implementation
 export function createCollection(
-  options: CollectionConfig<any, string | number, any> & {
+  options: CollectionConfig<any, string | number, any, UtilsRecord> & {
     schema?: StandardSchemaV1
-    utils?: UtilsRecord
-  }
+  },
 ): Collection<any, string | number, UtilsRecord, any, any> {
   const collection = new CollectionImpl<any, string | number, any, any, any>(
-    options
+    options,
   )
 
-  // Copy utils to both top level and .utils namespace
+  // Attach utils to collection
   if (options.utils) {
-    collection.utils = { ...options.utils }
+    collection.utils = options.utils
   } else {
     collection.utils = {}
   }
@@ -230,6 +294,8 @@ export class CollectionImpl<
   // and for debugging
   public _state: CollectionStateManager<TOutput, TKey, TSchema, TInput>
 
+  private comparisonOpts: StringCollationConfig
+
   /**
    * Creates a new Collection instance
    *
@@ -267,6 +333,8 @@ export class CollectionImpl<
     this._state = new CollectionStateManager(config)
     this._sync = new CollectionSyncManager(config, this.id)
 
+    this.comparisonOpts = buildCompareOptionsFromConfig(config)
+
     this._changes.setDeps({
       collection: this, // Required for passing to CollectionSubscription
       lifecycle: this._lifecycle,
@@ -297,6 +365,7 @@ export class CollectionImpl<
       lifecycle: this._lifecycle,
       changes: this._changes,
       indexes: this._indexes,
+      events: this._events,
     })
     this._sync.setDeps({
       collection: this, // Required for passing to config.sync callback
@@ -432,7 +501,7 @@ export class CollectionImpl<
    * Execute a callback for each entry in the collection
    */
   public forEach(
-    callbackfn: (value: TOutput, key: TKey, index: number) => void
+    callbackfn: (value: TOutput, key: TKey, index: number) => void,
   ): void {
     return this._state.forEach(callbackfn)
   }
@@ -441,7 +510,7 @@ export class CollectionImpl<
    * Create a new array with the results of calling a function for each entry in the collection
    */
   public map<U>(
-    callbackfn: (value: TOutput, key: TKey, index: number) => U
+    callbackfn: (value: TOutput, key: TKey, index: number) => U,
   ): Array<U> {
     return this._state.map(callbackfn)
   }
@@ -485,7 +554,7 @@ export class CollectionImpl<
    */
   public createIndex<TResolver extends IndexResolver<TKey> = typeof BTreeIndex>(
     indexCallback: (row: SingleRowRefProxy<TOutput>) => any,
-    config: IndexOptions<TResolver> = {}
+    config: IndexOptions<TResolver> = {},
   ): IndexProxy<TKey> {
     return this._indexes.createIndex(indexCallback, config)
   }
@@ -503,11 +572,16 @@ export class CollectionImpl<
   public validateData(
     data: unknown,
     type: `insert` | `update`,
-    key?: TKey
+    key?: TKey,
   ): TOutput | never {
     return this._mutations.validateData(data, type, key)
   }
 
+  get compareOptions(): StringCollationConfig {
+    // return a copy such that no one can mutate the internal comparison object
+    return { ...this.comparisonOpts }
+  }
+
   /**
    * Inserts one or more items into the collection
    * @param items - Single item or array of items to insert
@@ -591,27 +665,27 @@ export class CollectionImpl<
   // Overload 1: Update multiple items with a callback
   update(
     key: Array<TKey | unknown>,
-    callback: (drafts: Array<WritableDeep<TInput>>) => void
+    callback: (drafts: Array<WritableDeep<TInput>>) => void,
   ): TransactionType
 
   // Overload 2: Update multiple items with config and a callback
   update(
     keys: Array<TKey | unknown>,
     config: OperationConfig,
-    callback: (drafts: Array<WritableDeep<TInput>>) => void
+    callback: (drafts: Array<WritableDeep<TInput>>) => void,
   ): TransactionType
 
   // Overload 3: Update a single item with a callback
   update(
     id: TKey | unknown,
-    callback: (draft: WritableDeep<TInput>) => void
+    callback: (draft: WritableDeep<TInput>) => void,
   ): TransactionType
 
   // Overload 4: Update a single item with config and a callback
   update(
     id: TKey | unknown,
     config: OperationConfig,
-    callback: (draft: WritableDeep<TInput>) => void
+    callback: (draft: WritableDeep<TInput>) => void,
   ): TransactionType
 
   update(
@@ -622,7 +696,7 @@ export class CollectionImpl<
       | OperationConfig,
     maybeCallback?:
       | ((draft: WritableDeep<TInput>) => void)
-      | ((drafts: Array<WritableDeep<TInput>>) => void)
+      | ((drafts: Array<WritableDeep<TInput>>) => void),
   ) {
     return this._mutations.update(keys, configOrCallback, maybeCallback)
   }
@@ -659,7 +733,7 @@ export class CollectionImpl<
    */
   delete = (
     keys: Array<TKey> | TKey,
-    config?: OperationConfig
+    config?: OperationConfig,
   ): TransactionType<any> => {
     return this._mutations.delete(keys, config)
   }
@@ -748,7 +822,7 @@ export class CollectionImpl<
    * })
    */
   public currentStateAsChanges(
-    options: CurrentStateAsChangesOptions = {}
+    options: CurrentStateAsChangesOptions = {},
   ): Array<ChangeMessage<TOutput>> | void {
     return currentStateAsChanges(this, options)
   }
@@ -775,26 +849,29 @@ export class CollectionImpl<
    * }, { includeInitialState: true })
    *
    * @example
-   * // Subscribe only to changes matching a condition
+   * // Subscribe only to changes matching a condition using where callback
+   * import { eq } from "@tanstack/db"
+   *
    * const subscription = collection.subscribeChanges((changes) => {
    *   updateUI(changes)
    * }, {
    *   includeInitialState: true,
-   *   where: (row) => row.status === 'active'
+   *   where: (row) => eq(row.status, "active")
    * })
    *
    * @example
-   * // Subscribe using a pre-compiled expression
+   * // Using multiple conditions with and()
+   * import { and, eq, gt } from "@tanstack/db"
+   *
    * const subscription = collection.subscribeChanges((changes) => {
    *   updateUI(changes)
    * }, {
-   *   includeInitialState: true,
-   *   whereExpression: eq(row.status, 'active')
+   *   where: (row) => and(eq(row.status, "active"), gt(row.priority, 5))
    * })
    */
   public subscribeChanges(
     callback: (changes: Array<ChangeMessage<TOutput>>) => void,
-    options: SubscribeChangesOptions = {}
+    options: SubscribeChangesOptions<TOutput> = {},
   ): CollectionSubscription {
     return this._changes.subscribeChanges(callback, options)
   }
@@ -804,7 +881,7 @@ export class CollectionImpl<
    */
   public on<T extends keyof AllCollectionEvents>(
     event: T,
-    callback: CollectionEventHandler<T>
+    callback: CollectionEventHandler<T>,
   ) {
     return this._events.on(event, callback)
   }
@@ -814,7 +891,7 @@ export class CollectionImpl<
    */
   public once<T extends keyof AllCollectionEvents>(
     event: T,
-    callback: CollectionEventHandler<T>
+    callback: CollectionEventHandler<T>,
   ) {
     return this._events.once(event, callback)
   }
@@ -824,7 +901,7 @@ export class CollectionImpl<
    */
   public off<T extends keyof AllCollectionEvents>(
     event: T,
-    callback: CollectionEventHandler<T>
+    callback: CollectionEventHandler<T>,
   ) {
     this._events.off(event, callback)
   }
@@ -834,7 +911,7 @@ export class CollectionImpl<
    */
   public waitFor<T extends keyof AllCollectionEvents>(
     event: T,
-    timeout?: number
+    timeout?: number,
   ) {
     return this._events.waitFor(event, timeout)
   }
@@ -848,3 +925,21 @@ export class CollectionImpl<
     return Promise.resolve()
   }
 }
+
+function buildCompareOptionsFromConfig(
+  config: CollectionConfig<any, any, any>,
+): StringCollationConfig {
+  if (config.defaultStringCollation) {
+    const options = config.defaultStringCollation
+    return {
+      stringSort: options.stringSort ?? `locale`,
+      locale: options.stringSort === `locale` ? options.locale : undefined,
+      localeOptions:
+        options.stringSort === `locale` ? options.localeOptions : undefined,
+    }
+  } else {
+    return {
+      stringSort: `locale`,
+    }
+  }
+}
diff --git a/packages/db/src/collection/indexes.ts b/packages/db/src/collection/indexes.ts
index 96eba97ce..037bd126c 100644
--- a/packages/db/src/collection/indexes.ts
+++ b/packages/db/src/collection/indexes.ts
@@ -1,16 +1,16 @@
-import { IndexProxy, LazyIndexWrapper } from "../indexes/lazy-index"
+import { IndexProxy, LazyIndexWrapper } from '../indexes/lazy-index'
 import {
   createSingleRowRefProxy,
   toExpression,
-} from "../query/builder/ref-proxy"
-import { BTreeIndex } from "../indexes/btree-index"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import type { BaseIndex, IndexResolver } from "../indexes/base-index"
-import type { ChangeMessage } from "../types"
-import type { IndexOptions } from "../indexes/index-options"
-import type { SingleRowRefProxy } from "../query/builder/ref-proxy"
-import type { CollectionLifecycleManager } from "./lifecycle"
-import type { CollectionStateManager } from "./state"
+} from '../query/builder/ref-proxy'
+import { BTreeIndex } from '../indexes/btree-index'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { BaseIndex, IndexResolver } from '../indexes/base-index'
+import type { ChangeMessage } from '../types'
+import type { IndexOptions } from '../indexes/index-options'
+import type { SingleRowRefProxy } from '../query/builder/ref-proxy'
+import type { CollectionLifecycleManager } from './lifecycle'
+import type { CollectionStateManager } from './state'
 
 export class CollectionIndexesManager<
   TOutput extends object = Record<string, unknown>,
@@ -41,7 +41,7 @@ export class CollectionIndexesManager<
    */
   public createIndex<TResolver extends IndexResolver<TKey> = typeof BTreeIndex>(
     indexCallback: (row: SingleRowRefProxy<TOutput>) => any,
-    config: IndexOptions<TResolver> = {}
+    config: IndexOptions<TResolver> = {},
   ): IndexProxy<TKey> {
     this.lifecycle.validateCollectionUsable(`createIndex`)
 
@@ -60,7 +60,7 @@ export class CollectionIndexesManager<
       config.name,
       resolver,
       config.options,
-      this.state.entries()
+      this.state.entries(),
     )
 
     this.lazyIndexes.set(indexId, lazyIndex)
@@ -109,7 +109,7 @@ export class CollectionIndexesManager<
 
         this.resolvedIndexes.set(indexId, resolvedIndex)
         return { indexId, resolvedIndex }
-      }
+      },
     )
 
     await Promise.all(resolutionPromises)
@@ -121,7 +121,7 @@ export class CollectionIndexesManager<
    */
   private async resolveSingleIndex(
     indexId: number,
-    lazyIndex: LazyIndexWrapper<TKey>
+    lazyIndex: LazyIndexWrapper<TKey>,
   ): Promise<BaseIndex<TKey>> {
     const resolvedIndex = await lazyIndex.resolve()
     resolvedIndex.build(this.state.entries())
diff --git a/packages/db/src/collection/lifecycle.ts b/packages/db/src/collection/lifecycle.ts
index be607a3c9..097d138c1 100644
--- a/packages/db/src/collection/lifecycle.ts
+++ b/packages/db/src/collection/lifecycle.ts
@@ -2,19 +2,19 @@ import {
   CollectionInErrorStateError,
   CollectionStateError,
   InvalidCollectionStatusTransitionError,
-} from "../errors"
+} from '../errors'
 import {
   safeCancelIdleCallback,
   safeRequestIdleCallback,
-} from "../utils/browser-polyfills"
-import type { IdleCallbackDeadline } from "../utils/browser-polyfills"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import type { CollectionConfig, CollectionStatus } from "../types"
-import type { CollectionEventsManager } from "./events"
-import type { CollectionIndexesManager } from "./indexes"
-import type { CollectionChangesManager } from "./changes"
-import type { CollectionSyncManager } from "./sync"
-import type { CollectionStateManager } from "./state"
+} from '../utils/browser-polyfills'
+import type { IdleCallbackDeadline } from '../utils/browser-polyfills'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { CollectionConfig, CollectionStatus } from '../types'
+import type { CollectionEventsManager } from './events'
+import type { CollectionIndexesManager } from './indexes'
+import type { CollectionChangesManager } from './changes'
+import type { CollectionSyncManager } from './sync'
+import type { CollectionStateManager } from './state'
 
 export class CollectionLifecycleManager<
   TOutput extends object = Record<string, unknown>,
@@ -64,7 +64,7 @@ export class CollectionLifecycleManager<
    */
   public validateStatusTransition(
     from: CollectionStatus,
-    to: CollectionStatus
+    to: CollectionStatus,
   ): void {
     if (from === to) {
       // Allow same state transitions
@@ -78,7 +78,7 @@ export class CollectionLifecycleManager<
       loading: [`ready`, `error`, `cleaned-up`],
       ready: [`cleaned-up`, `error`],
       error: [`cleaned-up`, `idle`],
-      "cleaned-up": [`loading`, `error`],
+      'cleaned-up': [`loading`, `error`],
     }
 
     if (!validTransitions[from].includes(to)) {
@@ -92,14 +92,14 @@ export class CollectionLifecycleManager<
    */
   public setStatus(
     newStatus: CollectionStatus,
-    allowReady: boolean = false
+    allowReady: boolean = false,
   ): void {
     if (newStatus === `ready` && !allowReady) {
       // setStatus('ready') is an internal method that should not be called directly
       // Instead, use markReady to transition to ready triggering the necessary events
       // and side effects.
       throw new CollectionStateError(
-        `You can't directly call "setStatus('ready'). You must use markReady instead.`
+        `You can't directly call "setStatus('ready'). You must use markReady instead.`,
       )
     }
     this.validateStatusTransition(this.status, newStatus)
@@ -112,7 +112,7 @@ export class CollectionLifecycleManager<
       this.indexes.resolveAllIndexes().catch((error) => {
         console.warn(
           `${this.config.id ? `[${this.config.id}] ` : ``}Failed to resolve indexes:`,
-          error
+          error,
         )
       })
     }
@@ -180,8 +180,10 @@ export class CollectionLifecycleManager<
 
     const gcTime = this.config.gcTime ?? 300000 // 5 minutes default
 
-    // If gcTime is 0, GC is disabled
-    if (gcTime === 0) {
+    // If gcTime is 0, negative, or non-finite (Infinity, -Infinity, NaN), GC is disabled.
+    // Note: setTimeout with Infinity coerces to 0 via ToInt32, causing immediate GC,
+    // so we must explicitly check for non-finite values here.
+    if (gcTime <= 0 || !Number.isFinite(gcTime)) {
       return
     }
 
@@ -235,7 +237,7 @@ export class CollectionLifecycleManager<
           this.idleCallbackId = null
         }
       },
-      { timeout: 1000 }
+      { timeout: 1000 },
     )
   }
 
@@ -250,8 +252,7 @@ export class CollectionLifecycleManager<
       !deadline || deadline.timeRemaining() > 0 || deadline.didTimeout
 
     if (hasTime) {
-      // Perform all cleanup operations
-      this.events.cleanup()
+      // Perform all cleanup operations except events
       this.sync.cleanup()
       this.state.cleanup()
       this.changes.cleanup()
@@ -265,8 +266,13 @@ export class CollectionLifecycleManager<
       this.hasBeenReady = false
       this.onFirstReadyCallbacks = []
 
-      // Set status to cleaned-up
+      // Set status to cleaned-up after everything is cleaned up
+      // This fires the status:change event to notify listeners
       this.setStatus(`cleaned-up`)
+
+      // Finally, cleanup event handlers after the event has been fired
+      this.events.cleanup()
+
       return true
     } else {
       // If we don't have time, reschedule for the next idle period
diff --git a/packages/db/src/collection/mutations.ts b/packages/db/src/collection/mutations.ts
index 278234f47..48e8b7b20 100644
--- a/packages/db/src/collection/mutations.ts
+++ b/packages/db/src/collection/mutations.ts
@@ -1,8 +1,9 @@
-import { withArrayChangeTracking, withChangeTracking } from "../proxy"
-import { createTransaction, getActiveTransaction } from "../transactions"
+import { withArrayChangeTracking, withChangeTracking } from '../proxy'
+import { createTransaction, getActiveTransaction } from '../transactions'
 import {
   DeleteKeyNotFoundError,
   DuplicateKeyError,
+  InvalidKeyError,
   InvalidSchemaError,
   KeyUpdateNotAllowedError,
   MissingDeleteHandlerError,
@@ -15,9 +16,9 @@ import {
   SchemaValidationError,
   UndefinedKeyError,
   UpdateKeyNotFoundError,
-} from "../errors"
-import type { Collection, CollectionImpl } from "./index.js"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+} from '../errors'
+import type { Collection, CollectionImpl } from './index.js'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type {
   CollectionConfig,
   InsertConfig,
@@ -28,9 +29,9 @@ import type {
   TransactionWithMutations,
   UtilsRecord,
   WritableDeep,
-} from "../types"
-import type { CollectionLifecycleManager } from "./lifecycle"
-import type { CollectionStateManager } from "./state"
+} from '../types'
+import type { CollectionLifecycleManager } from './lifecycle'
+import type { CollectionStateManager } from './state'
 
 export class CollectionMutationsManager<
   TOutput extends object = Record<string, unknown>,
@@ -72,7 +73,7 @@ export class CollectionMutationsManager<
   public validateData(
     data: unknown,
     type: `insert` | `update`,
-    key?: TKey
+    key?: TKey,
   ): TOutput | never {
     if (!this.config.schema) return data as TOutput
 
@@ -113,7 +114,7 @@ export class CollectionMutationsManager<
         const validatedMergedData = result.value as TOutput
         const modifiedKeys = Object.keys(data)
         const extractedChanges = Object.fromEntries(
-          modifiedKeys.map((k) => [k, validatedMergedData[k as keyof TOutput]])
+          modifiedKeys.map((k) => [k, validatedMergedData[k as keyof TOutput]]),
         ) as TOutput
 
         return extractedChanges
@@ -141,8 +142,12 @@ export class CollectionMutationsManager<
   }
 
   public generateGlobalKey(key: any, item: any): string {
-    if (typeof key === `undefined`) {
-      throw new UndefinedKeyError(item)
+    if (typeof key !== `string` && typeof key !== `number`) {
+      // Preserve specific error for undefined keys
+      if (typeof key === `undefined`) {
+        throw new UndefinedKeyError(item)
+      }
+      throw new InvalidKeyError(key, item)
     }
 
     return `KEY::${this.id}/${key}`
@@ -163,17 +168,19 @@ export class CollectionMutationsManager<
 
     const items = Array.isArray(data) ? data : [data]
     const mutations: Array<PendingMutation<TOutput>> = []
+    const keysInCurrentBatch = new Set<TKey>()
 
     // Create mutations for each item
     items.forEach((item) => {
       // Validate the data against the schema if one exists
       const validatedData = this.validateData(item, `insert`)
 
-      // Check if an item with this ID already exists in the collection
+      // Check if an item with this ID already exists in the collection or in the current batch
       const key = this.config.getKey(validatedData)
-      if (this.state.has(key)) {
+      if (this.state.has(key) || keysInCurrentBatch.has(key)) {
         throw new DuplicateKeyError(key)
       }
+      keysInCurrentBatch.add(key)
       const globalKey = this.generateGlobalKey(key, item)
 
       const mutation: PendingMutation<TOutput, `insert`> = {
@@ -187,7 +194,7 @@ export class CollectionMutationsManager<
           Object.keys(item).map((k) => [
             k,
             validatedData[k as keyof typeof validatedData],
-          ])
+          ]),
         ) as TInput,
         globalKey,
         key,
@@ -253,7 +260,7 @@ export class CollectionMutationsManager<
       | OperationConfig,
     maybeCallback?:
       | ((draft: WritableDeep<TInput>) => void)
-      | ((drafts: Array<WritableDeep<TInput>>) => void)
+      | ((drafts: Array<WritableDeep<TInput>>) => void),
   ) {
     if (typeof keys === `undefined`) {
       throw new MissingUpdateArgumentError()
@@ -296,12 +303,12 @@ export class CollectionMutationsManager<
       // Use the proxy to track changes for all objects
       changesArray = withArrayChangeTracking(
         currentObjects,
-        callback as (draft: Array<TInput>) => void
+        callback as (draft: Array<TInput>) => void,
       )
     } else {
       const result = withChangeTracking(
         currentObjects[0]!,
-        callback as (draft: TInput) => void
+        callback as (draft: TInput) => void,
       )
       changesArray = [result]
     }
@@ -327,14 +334,14 @@ export class CollectionMutationsManager<
         const validatedUpdatePayload = this.validateData(
           itemChanges,
           `update`,
-          key
+          key,
         )
 
         // Construct the full modified item by applying the validated update payload to the original item
         const modifiedItem = Object.assign(
           {},
           originalItem,
-          validatedUpdatePayload
+          validatedUpdatePayload,
         )
 
         // Check if the ID of the item is being changed
@@ -359,7 +366,7 @@ export class CollectionMutationsManager<
             Object.keys(itemChanges).map((k) => [
               k,
               modifiedItem[k as keyof typeof modifiedItem],
-            ])
+            ]),
           ) as TInput,
           globalKey,
           key,
@@ -442,7 +449,7 @@ export class CollectionMutationsManager<
    */
   delete = (
     keys: Array<TKey> | TKey,
-    config?: OperationConfig
+    config?: OperationConfig,
   ): TransactionType<any> => {
     const state = this.state
     this.lifecycle.validateCollectionUsable(`delete`)
diff --git a/packages/db/src/collection/state.ts b/packages/db/src/collection/state.ts
index 02dd1708e..b873610f6 100644
--- a/packages/db/src/collection/state.ts
+++ b/packages/db/src/collection/state.ts
@@ -1,16 +1,17 @@
-import { deepEquals } from "../utils"
-import { SortedMap } from "../SortedMap"
-import type { Transaction } from "../transactions"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+import { deepEquals } from '../utils'
+import { SortedMap } from '../SortedMap'
+import type { Transaction } from '../transactions'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type {
   ChangeMessage,
   CollectionConfig,
   OptimisticChangeMessage,
-} from "../types"
-import type { CollectionImpl } from "./index.js"
-import type { CollectionLifecycleManager } from "./lifecycle"
-import type { CollectionChangesManager } from "./changes"
-import type { CollectionIndexesManager } from "./indexes"
+} from '../types'
+import type { CollectionImpl } from './index.js'
+import type { CollectionLifecycleManager } from './lifecycle'
+import type { CollectionChangesManager } from './changes'
+import type { CollectionIndexesManager } from './indexes'
+import type { CollectionEventsManager } from './events'
 
 interface PendingSyncedTransaction<
   T extends object = Record<string, unknown>,
@@ -24,6 +25,12 @@ interface PendingSyncedTransaction<
     upserts: Map<TKey, T>
     deletes: Set<TKey>
   }
+  /**
+   * When true, this transaction should be processed immediately even if there
+   * are persisting user transactions. Used by manual write operations (writeInsert,
+   * writeUpdate, writeDelete, writeUpsert) which need synchronous updates to syncedData.
+   */
+  immediate?: boolean
 }
 
 export class CollectionStateManager<
@@ -37,13 +44,14 @@ export class CollectionStateManager<
   public lifecycle!: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>
   public changes!: CollectionChangesManager<TOutput, TKey, TSchema, TInput>
   public indexes!: CollectionIndexesManager<TOutput, TKey, TSchema, TInput>
+  private _events!: CollectionEventsManager
 
   // Core state - make public for testing
   public transactions: SortedMap<string, Transaction<any>>
   public pendingSyncedTransactions: Array<
     PendingSyncedTransaction<TOutput, TKey>
   > = []
-  public syncedData: Map<TKey, TOutput> | SortedMap<TKey, TOutput>
+  public syncedData: SortedMap<TKey, TOutput>
   public syncedMetadata = new Map<TKey, unknown>()
 
   // Optimistic state tracking - make public for testing
@@ -66,15 +74,12 @@ export class CollectionStateManager<
   constructor(config: CollectionConfig<TOutput, TKey, TSchema>) {
     this.config = config
     this.transactions = new SortedMap<string, Transaction<any>>((a, b) =>
-      a.compareCreatedAt(b)
+      a.compareCreatedAt(b),
     )
 
-    // Set up data storage with optional comparison function
-    if (config.compare) {
-      this.syncedData = new SortedMap<TKey, TOutput>(config.compare)
-    } else {
-      this.syncedData = new Map<TKey, TOutput>()
-    }
+    // Set up data storage - always use SortedMap for deterministic iteration.
+    // If a custom compare function is provided, use it; otherwise entries are sorted by key only.
+    this.syncedData = new SortedMap<TKey, TOutput>(config.compare)
   }
 
   setDeps(deps: {
@@ -82,11 +87,13 @@ export class CollectionStateManager<
     lifecycle: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>
     changes: CollectionChangesManager<TOutput, TKey, TSchema, TInput>
     indexes: CollectionIndexesManager<TOutput, TKey, TSchema, TInput>
+    events: CollectionEventsManager
   }) {
     this.collection = deps.collection
     this.lifecycle = deps.lifecycle
     this.changes = deps.changes
     this.indexes = deps.indexes
+    this._events = deps.events
   }
 
   /**
@@ -185,7 +192,7 @@ export class CollectionStateManager<
    * Execute a callback for each entry in the collection
    */
   public forEach(
-    callbackfn: (value: TOutput, key: TKey, index: number) => void
+    callbackfn: (value: TOutput, key: TKey, index: number) => void,
   ): void {
     let index = 0
     for (const [key, value] of this.entries()) {
@@ -197,7 +204,7 @@ export class CollectionStateManager<
    * Create a new array with the results of calling a function for each entry in the collection
    */
   public map<U>(
-    callbackfn: (value: TOutput, key: TKey, index: number) => U
+    callbackfn: (value: TOutput, key: TKey, index: number) => U,
   ): Array<U> {
     const result: Array<U> = []
     let index = 0
@@ -213,7 +220,7 @@ export class CollectionStateManager<
    * @returns True if the given collection is this collection, false otherwise
    */
   private isThisCollection(
-    collection: CollectionImpl<any, any, any, any, any>
+    collection: CollectionImpl<any, any, any, any, any>,
   ): boolean {
     return collection === this.collection
   }
@@ -222,7 +229,7 @@ export class CollectionStateManager<
    * Recompute optimistic state from active transactions
    */
   public recomputeOptimisticState(
-    triggeredByUserAction: boolean = false
+    triggeredByUserAction: boolean = false,
   ): void {
     // Skip redundant recalculations when we're in the middle of committing sync transactions
     // While the sync pipeline is replaying a large batch we still want to honour
@@ -257,7 +264,7 @@ export class CollectionStateManager<
             case `update`:
               this.optimisticUpserts.set(
                 mutation.key,
-                mutation.modified as TOutput
+                mutation.modified as TOutput,
               )
               this.optimisticDeletes.delete(mutation.key)
               break
@@ -316,8 +323,8 @@ export class CollectionStateManager<
           // We can infer this by checking if we have no remaining optimistic mutations for this key
           const hasActiveOptimisticMutation = activeTransactions.some((tx) =>
             tx.mutations.some(
-              (m) => this.isThisCollection(m.collection) && m.key === event.key
-            )
+              (m) => this.isThisCollection(m.collection) && m.key === event.key,
+            ),
           )
 
           if (!hasActiveOptimisticMutation) {
@@ -348,10 +355,10 @@ export class CollectionStateManager<
   private calculateSize(): number {
     const syncedSize = this.syncedData.size
     const deletesFromSynced = Array.from(this.optimisticDeletes).filter(
-      (key) => this.syncedData.has(key) && !this.optimisticUpserts.has(key)
+      (key) => this.syncedData.has(key) && !this.optimisticUpserts.has(key),
     ).length
     const upsertsNotInSynced = Array.from(this.optimisticUpserts.keys()).filter(
-      (key) => !this.syncedData.has(key)
+      (key) => !this.syncedData.has(key),
     ).length
 
     return syncedSize - deletesFromSynced + upsertsNotInSynced
@@ -363,7 +370,7 @@ export class CollectionStateManager<
   private collectOptimisticChanges(
     previousUpserts: Map<TKey, TOutput>,
     previousDeletes: Set<TKey>,
-    events: Array<ChangeMessage<TOutput, TKey>>
+    events: Array<ChangeMessage<TOutput, TKey>>,
   ): void {
     const allKeys = new Set([
       ...previousUpserts.keys(),
@@ -377,7 +384,7 @@ export class CollectionStateManager<
       const previousValue = this.getPreviousValue(
         key,
         previousUpserts,
-        previousDeletes
+        previousDeletes,
       )
 
       if (previousValue !== undefined && currentValue === undefined) {
@@ -405,7 +412,7 @@ export class CollectionStateManager<
   private getPreviousValue(
     key: TKey,
     previousUpserts: Map<TKey, TOutput>,
-    previousDeletes: Set<TKey>
+    previousDeletes: Set<TKey>,
   ): TOutput | undefined {
     if (previousDeletes.has(key)) {
       return undefined
@@ -436,13 +443,17 @@ export class CollectionStateManager<
       committedSyncedTransactions,
       uncommittedSyncedTransactions,
       hasTruncateSync,
+      hasImmediateSync,
     } = this.pendingSyncedTransactions.reduce(
       (acc, t) => {
         if (t.committed) {
           acc.committedSyncedTransactions.push(t)
-          if (t.truncate === true) {
+          if (t.truncate) {
             acc.hasTruncateSync = true
           }
+          if (t.immediate) {
+            acc.hasImmediateSync = true
+          }
         } else {
           acc.uncommittedSyncedTransactions.push(t)
         }
@@ -456,10 +467,21 @@ export class CollectionStateManager<
           PendingSyncedTransaction<TOutput, TKey>
         >,
         hasTruncateSync: false,
-      }
+        hasImmediateSync: false,
+      },
     )
 
-    if (!hasPersistingTransaction || hasTruncateSync) {
+    // Process committed transactions if:
+    // 1. No persisting user transaction (normal sync flow), OR
+    // 2. There's a truncate operation (must be processed immediately), OR
+    // 3. There's an immediate transaction (manual writes must be processed synchronously)
+    //
+    // Note: When hasImmediateSync or hasTruncateSync is true, we process ALL committed
+    // sync transactions (not just the immediate/truncate ones). This is intentional for
+    // ordering correctness: if we only processed the immediate transaction, earlier
+    // non-immediate transactions would be applied later and could overwrite newer state.
+    // Processing all committed transactions together preserves causal ordering.
+    if (!hasPersistingTransaction || hasTruncateSync || hasImmediateSync) {
       // Set flag to prevent redundant optimistic state recalculations
       this.isCommittingSyncTransactions = true
 
@@ -528,6 +550,12 @@ export class CollectionStateManager<
           for (const key of changedKeys) {
             currentVisibleState.delete(key)
           }
+
+          // 4) Emit truncate event so subscriptions can reset their cursor tracking state
+          this._events.emit(`truncate`, {
+            type: `truncate`,
+            collection: this.collection,
+          })
         }
 
         for (const operation of transaction.operations) {
@@ -545,8 +573,8 @@ export class CollectionStateManager<
                 Object.assign(
                   {},
                   this.syncedMetadata.get(key),
-                  operation.metadata
-                )
+                  operation.metadata,
+                ),
               )
               break
             case `delete`:
@@ -564,7 +592,7 @@ export class CollectionStateManager<
                 const updatedValue = Object.assign(
                   {},
                   this.syncedData.get(key),
-                  operation.value
+                  operation.value,
                 )
                 this.syncedData.set(key, updatedValue)
               } else {
@@ -597,10 +625,10 @@ export class CollectionStateManager<
         // Build re-apply sets from the snapshot taken at the start of this function.
         // This prevents losing optimistic state if transactions complete during truncate processing.
         const reapplyUpserts = new Map<TKey, TOutput>(
-          truncateOptimisticSnapshot!.upserts
+          truncateOptimisticSnapshot!.upserts,
         )
         const reapplyDeletes = new Set<TKey>(
-          truncateOptimisticSnapshot!.deletes
+          truncateOptimisticSnapshot!.deletes,
         )
 
         // Emit inserts for re-applied upserts, skipping any keys that have an optimistic delete.
@@ -679,7 +707,7 @@ export class CollectionStateManager<
                 case `update`:
                   this.optimisticUpserts.set(
                     mutation.key,
-                    mutation.modified as TOutput
+                    mutation.modified as TOutput,
                   )
                   this.optimisticDeletes.delete(mutation.key)
                   break
@@ -700,6 +728,7 @@ export class CollectionStateManager<
         if (transaction.state === `completed`) {
           for (const mutation of transaction.mutations) {
             if (
+              mutation.optimistic &&
               this.isThisCollection(mutation.collection) &&
               changedKeys.has(mutation.key)
             ) {
diff --git a/packages/db/src/collection/subscription.ts b/packages/db/src/collection/subscription.ts
index d6a43a256..44c9af49f 100644
--- a/packages/db/src/collection/subscription.ts
+++ b/packages/db/src/collection/subscription.ts
@@ -1,31 +1,42 @@
-import { ensureIndexForExpression } from "../indexes/auto-index.js"
-import { and, gt, lt } from "../query/builder/functions.js"
-import { Value } from "../query/ir.js"
-import { EventEmitter } from "../event-emitter.js"
+import { ensureIndexForExpression } from '../indexes/auto-index.js'
+import { and, eq, gte, lt } from '../query/builder/functions.js'
+import { PropRef, Value } from '../query/ir.js'
+import { EventEmitter } from '../event-emitter.js'
+import { compileExpression } from '../query/compiler/evaluators.js'
+import { buildCursor } from '../utils/cursor.js'
 import {
   createFilterFunctionFromExpression,
   createFilteredCallback,
-} from "./change-events.js"
-import type { BasicExpression, OrderBy } from "../query/ir.js"
-import type { IndexInterface } from "../indexes/base-index.js"
+} from './change-events.js'
+import type { BasicExpression, OrderBy } from '../query/ir.js'
+import type { IndexInterface } from '../indexes/base-index.js'
 import type {
   ChangeMessage,
+  LoadSubsetOptions,
   Subscription,
   SubscriptionEvents,
   SubscriptionStatus,
   SubscriptionUnsubscribedEvent,
-} from "../types.js"
-import type { CollectionImpl } from "./index.js"
+} from '../types.js'
+import type { CollectionImpl } from './index.js'
 
 type RequestSnapshotOptions = {
   where?: BasicExpression<boolean>
   optimizedOnly?: boolean
+  trackLoadSubsetPromise?: boolean
+  /** Optional orderBy to pass to loadSubset for backend optimization */
+  orderBy?: OrderBy
+  /** Optional limit to pass to loadSubset for backend optimization */
+  limit?: number
 }
 
 type RequestLimitedSnapshotOptions = {
   orderBy: OrderBy
   limit: number
-  minValue?: any
+  /** All column values for cursor (first value used for local index, all values for sync layer) */
+  minValues?: Array<unknown>
+  /** Row offset for offset-based pagination (passed to sync layer) */
+  offset?: number
 }
 
 type CollectionSubscriptionOptions = {
@@ -42,13 +53,30 @@ export class CollectionSubscription
 {
   private loadedInitialState = false
 
+  // Flag to skip filtering in filterAndFlipChanges.
+  // This is separate from loadedInitialState because we want to allow
+  // requestSnapshot to still work even when filtering is skipped.
+  private skipFiltering = false
+
   // Flag to indicate that we have sent at least 1 snapshot.
   // While `snapshotSent` is false we filter out all changes from subscription to the collection.
   private snapshotSent = false
 
+  /**
+   * Track all loadSubset calls made by this subscription so we can unload them on cleanup.
+   * We store the exact LoadSubsetOptions we passed to loadSubset to ensure symmetric unload.
+   */
+  private loadedSubsets: Array<LoadSubsetOptions> = []
+
   // Keep track of the keys we've sent (needed for join and orderBy optimizations)
   private sentKeys = new Set<string | number>()
 
+  // Track the count of rows sent via requestLimitedSnapshot for offset-based pagination
+  private limitedSnapshotRowCount = 0
+
+  // Track the last key sent via requestLimitedSnapshot for cursor-based pagination
+  private lastSentKey: string | number | undefined
+
   private filteredCallback: (changes: Array<ChangeMessage<any, any>>) => void
 
   private orderByIndex: IndexInterface<string | number> | undefined
@@ -57,6 +85,16 @@ export class CollectionSubscription
   private _status: SubscriptionStatus = `ready`
   private pendingLoadSubsetPromises: Set<Promise<void>> = new Set()
 
+  // Cleanup function for truncate event listener
+  private truncateCleanup: (() => void) | undefined
+
+  // Truncate buffering state
+  // When a truncate occurs, we buffer changes until all loadSubset refetches complete
+  // This prevents a flash of missing content between deletes and new inserts
+  private isBufferingForTruncate = false
+  private truncateBuffer: Array<Array<ChangeMessage<any, any>>> = []
+  private pendingTruncateRefetches: Set<Promise<void>> = new Set()
+
   public get status(): SubscriptionStatus {
     return this._status
   }
@@ -64,7 +102,7 @@ export class CollectionSubscription
   constructor(
     private collection: CollectionImpl<any, any, any, any, any>,
     private callback: (changes: Array<ChangeMessage<any, any>>) => void,
-    private options: CollectionSubscriptionOptions
+    private options: CollectionSubscriptionOptions,
   ) {
     super()
     if (options.onUnsubscribe) {
@@ -77,7 +115,7 @@ export class CollectionSubscription
     }
 
     const callbackWithSentKeysTracking = (
-      changes: Array<ChangeMessage<any, any>>
+      changes: Array<ChangeMessage<any, any>>,
     ) => {
       callback(changes)
       this.trackSentKeys(changes)
@@ -89,6 +127,123 @@ export class CollectionSubscription
     this.filteredCallback = options.whereExpression
       ? createFilteredCallback(this.callback, options)
       : this.callback
+
+    // Listen for truncate events to re-request data after must-refetch
+    // When a truncate happens (e.g., from a 409 must-refetch), all collection data is cleared.
+    // We need to re-request all previously loaded subsets to repopulate the data.
+    this.truncateCleanup = this.collection.on(`truncate`, () => {
+      this.handleTruncate()
+    })
+  }
+
+  /**
+   * Handle collection truncate event by resetting state and re-requesting subsets.
+   * This is called when the sync layer receives a must-refetch and clears all data.
+   *
+   * To prevent a flash of missing content, we buffer all changes (deletes from truncate
+   * and inserts from refetch) until all loadSubset promises resolve, then emit them together.
+   */
+  private handleTruncate() {
+    // Copy the loaded subsets before clearing (we'll re-request them)
+    const subsetsToReload = [...this.loadedSubsets]
+
+    // Only buffer if there's an actual loadSubset handler that can do async work.
+    // Without a loadSubset handler, there's nothing to re-request and no reason to buffer.
+    // This prevents unnecessary buffering in eager sync mode or when loadSubset isn't implemented.
+    const hasLoadSubsetHandler = this.collection._sync.syncLoadSubsetFn !== null
+
+    // If there are no subsets to reload OR no loadSubset handler, just reset state
+    if (subsetsToReload.length === 0 || !hasLoadSubsetHandler) {
+      this.snapshotSent = false
+      this.loadedInitialState = false
+      this.limitedSnapshotRowCount = 0
+      this.lastSentKey = undefined
+      this.loadedSubsets = []
+      return
+    }
+
+    // Start buffering BEFORE we receive the delete events from the truncate commit
+    // This ensures we capture both the deletes and subsequent inserts
+    this.isBufferingForTruncate = true
+    this.truncateBuffer = []
+    this.pendingTruncateRefetches.clear()
+
+    // Reset snapshot/pagination tracking state
+    // Note: We don't need to populate sentKeys here because filterAndFlipChanges
+    // will skip the delete filter when isBufferingForTruncate is true
+    this.snapshotSent = false
+    this.loadedInitialState = false
+    this.limitedSnapshotRowCount = 0
+    this.lastSentKey = undefined
+
+    // Clear the loadedSubsets array since we're re-requesting fresh
+    this.loadedSubsets = []
+
+    // Defer the loadSubset calls to a microtask so the truncate commit's delete events
+    // are buffered BEFORE the loadSubset calls potentially trigger nested commits.
+    // This ensures correct event ordering: deletes first, then inserts.
+    queueMicrotask(() => {
+      // Check if we were unsubscribed while waiting
+      if (!this.isBufferingForTruncate) {
+        return
+      }
+
+      // Re-request all previously loaded subsets and track their promises
+      for (const options of subsetsToReload) {
+        const syncResult = this.collection._sync.loadSubset(options)
+
+        // Track this loadSubset call so we can unload it later
+        this.loadedSubsets.push(options)
+        this.trackLoadSubsetPromise(syncResult)
+
+        // Track the promise for buffer flushing
+        if (syncResult instanceof Promise) {
+          this.pendingTruncateRefetches.add(syncResult)
+          syncResult
+            .catch(() => {
+              // Ignore errors - we still want to flush the buffer even if some requests fail
+            })
+            .finally(() => {
+              this.pendingTruncateRefetches.delete(syncResult)
+              this.checkTruncateRefetchComplete()
+            })
+        }
+      }
+
+      // If all loadSubset calls were synchronous (returned true), flush now
+      // At this point, delete events have already been buffered from the truncate commit
+      if (this.pendingTruncateRefetches.size === 0) {
+        this.flushTruncateBuffer()
+      }
+    })
+  }
+
+  /**
+   * Check if all truncate refetch promises have completed and flush buffer if so
+   */
+  private checkTruncateRefetchComplete() {
+    if (
+      this.pendingTruncateRefetches.size === 0 &&
+      this.isBufferingForTruncate
+    ) {
+      this.flushTruncateBuffer()
+    }
+  }
+
+  /**
+   * Flush the truncate buffer, emitting all buffered changes to the callback
+   */
+  private flushTruncateBuffer() {
+    this.isBufferingForTruncate = false
+
+    // Flatten all buffered changes into a single array for atomic emission
+    // This ensures consumers see all truncate changes (deletes + inserts) in one callback
+    const merged = this.truncateBuffer.flat()
+    if (merged.length > 0) {
+      this.filteredCallback(merged)
+    }
+
+    this.truncateBuffer = []
   }
 
   setOrderByIndex(index: IndexInterface<any>) {
@@ -152,7 +307,16 @@ export class CollectionSubscription
 
   emitEvents(changes: Array<ChangeMessage<any, any>>) {
     const newChanges = this.filterAndFlipChanges(changes)
-    this.filteredCallback(newChanges)
+
+    if (this.isBufferingForTruncate) {
+      // Buffer the changes instead of emitting immediately
+      // This prevents a flash of missing content during truncate/refetch
+      if (newChanges.length > 0) {
+        this.truncateBuffer.push(newChanges)
+      }
+    } else {
+      this.filteredCallback(newChanges)
+    }
   }
 
   /**
@@ -192,12 +356,22 @@ export class CollectionSubscription
 
     // Request the sync layer to load more data
     // don't await it, we will load the data into the collection when it comes in
-    const syncResult = this.collection._sync.loadSubset({
+    const loadOptions: LoadSubsetOptions = {
       where: stateOpts.where,
       subscription: this,
-    })
+      // Include orderBy and limit if provided so sync layer can optimize the query
+      orderBy: opts?.orderBy,
+      limit: opts?.limit,
+    }
+    const syncResult = this.collection._sync.loadSubset(loadOptions)
 
-    this.trackLoadSubsetPromise(syncResult)
+    // Track this loadSubset call so we can unload it later
+    this.loadedSubsets.push(loadOptions)
+
+    const trackLoadSubsetPromise = opts?.trackLoadSubsetPromise ?? true
+    if (trackLoadSubsetPromise) {
+      this.trackLoadSubsetPromise(syncResult)
+    }
 
     // Also load data immediately from the collection
     const snapshot = this.collection.currentStateAsChanges(stateOpts)
@@ -209,33 +383,53 @@ export class CollectionSubscription
 
     // Only send changes that have not been sent yet
     const filteredSnapshot = snapshot.filter(
-      (change) => !this.sentKeys.has(change.key)
+      (change) => !this.sentKeys.has(change.key),
     )
 
+    // Add keys to sentKeys BEFORE calling callback to prevent race condition.
+    // If a change event arrives while the callback is executing, it will see
+    // the keys already in sentKeys and filter out duplicates correctly.
+    for (const change of filteredSnapshot) {
+      this.sentKeys.add(change.key)
+    }
+
     this.snapshotSent = true
     this.callback(filteredSnapshot)
     return true
   }
 
   /**
-   * Sends a snapshot that is limited to the first `limit` rows that fulfill the `where` clause and are bigger than `minValue`.
+   * Sends a snapshot that fulfills the `where` clause and all rows are bigger or equal to the cursor.
    * Requires a range index to be set with `setOrderByIndex` prior to calling this method.
    * It uses that range index to load the items in the order of the index.
-   * Note: it does not send keys that have already been sent before.
+   *
+   * For multi-column orderBy:
+   * - Uses first value from `minValues` for LOCAL index operations (wide bounds, ensures no missed rows)
+   * - Uses all `minValues` to build a precise composite cursor for SYNC layer loadSubset
+   *
+   * Note 1: it may load more rows than the provided LIMIT because it loads all values equal to the first cursor value + limit values greater.
+   *         This is needed to ensure that it does not accidentally skip duplicate values when the limit falls in the middle of some duplicated values.
+   * Note 2: it does not send keys that have already been sent before.
    */
   requestLimitedSnapshot({
     orderBy,
     limit,
-    minValue,
+    minValues,
+    offset,
   }: RequestLimitedSnapshotOptions) {
     if (!limit) throw new Error(`limit is required`)
 
     if (!this.orderByIndex) {
       throw new Error(
-        `Ordered snapshot was requested but no index was found. You have to call setOrderByIndex before requesting an ordered snapshot.`
+        `Ordered snapshot was requested but no index was found. You have to call setOrderByIndex before requesting an ordered snapshot.`,
       )
     }
 
+    // Derive first column value from minValues (used for local index operations)
+    const minValue = minValues?.[0]
+    // Cast for index operations (index expects string | number)
+    const minValueForIndex = minValue as string | number | undefined
+
     const index = this.orderByIndex
     const where = this.options.whereExpression
     const whereFilterFn = where
@@ -255,14 +449,62 @@ export class CollectionSubscription
       return whereFilterFn?.(value) ?? true
     }
 
-    let biggestObservedValue = minValue
+    let biggestObservedValue = minValueForIndex
     const changes: Array<ChangeMessage<any, string | number>> = []
-    let keys: Array<string | number> = index.take(limit, minValue, filterFn)
+
+    // If we have a minValue we need to handle the case
+    // where there might be duplicate values equal to minValue that we need to include
+    // because we can have data like this: [1, 2, 3, 3, 3, 4, 5]
+    // so if minValue is 3 then the previous snapshot may not have included all 3s
+    // e.g. if it was offset 0 and limit 3 it would only have loaded the first 3
+    //      so we load all rows equal to minValue first, to be sure we don't skip any duplicate values
+    //
+    // For multi-column orderBy, we use the first column value for index operations (wide bounds)
+    // This may load some duplicates but ensures we never miss any rows.
+    let keys: Array<string | number> = []
+    if (minValueForIndex !== undefined) {
+      // First, get all items with the same FIRST COLUMN value as minValue
+      // This provides wide bounds for the local index
+      const { expression } = orderBy[0]!
+      const allRowsWithMinValue = this.collection.currentStateAsChanges({
+        where: eq(expression, new Value(minValueForIndex)),
+      })
+
+      if (allRowsWithMinValue) {
+        const keysWithMinValue = allRowsWithMinValue
+          .map((change) => change.key)
+          .filter((key) => !this.sentKeys.has(key) && filterFn(key))
+
+        // Add items with the minValue first
+        keys.push(...keysWithMinValue)
+
+        // Then get items greater than minValue
+        const keysGreaterThanMin = index.take(
+          limit - keys.length,
+          minValueForIndex,
+          filterFn,
+        )
+        keys.push(...keysGreaterThanMin)
+      } else {
+        keys = index.take(limit, minValueForIndex, filterFn)
+      }
+    } else {
+      keys = index.take(limit, minValueForIndex, filterFn)
+    }
 
     const valuesNeeded = () => Math.max(limit - changes.length, 0)
     const collectionExhausted = () => keys.length === 0
 
+    // Create a value extractor for the orderBy field to properly track the biggest indexed value
+    const orderByExpression = orderBy[0]!.expression
+    const valueExtractor =
+      orderByExpression.type === `ref`
+        ? compileExpression(new PropRef(orderByExpression.path), true)
+        : null
+
     while (valuesNeeded() > 0 && !collectionExhausted()) {
+      const insertedKeys = new Set<string | number>() // Track keys we add to `changes` in this iteration
+
       for (const key of keys) {
         const value = this.collection.get(key)!
         changes.push({
@@ -270,58 +512,146 @@ export class CollectionSubscription
           key,
           value,
         })
-        biggestObservedValue = value
+        // Extract the indexed value (e.g., salary) from the row, not the full row
+        // This is needed for index.take() to work correctly with the BTree comparator
+        biggestObservedValue = valueExtractor ? valueExtractor(value) : value
+        insertedKeys.add(key) // Track this key
       }
 
       keys = index.take(valuesNeeded(), biggestObservedValue, filterFn)
     }
 
+    // Track row count for offset-based pagination (before sending to callback)
+    // Use the current count as the offset for this load
+    const currentOffset = this.limitedSnapshotRowCount
+
+    // Add keys to sentKeys BEFORE calling callback to prevent race condition.
+    // If a change event arrives while the callback is executing, it will see
+    // the keys already in sentKeys and filter out duplicates correctly.
+    for (const change of changes) {
+      this.sentKeys.add(change.key)
+    }
+
     this.callback(changes)
 
-    let whereWithValueFilter = where
-    if (typeof minValue !== `undefined`) {
-      // Only request data that we haven't seen yet (i.e. is bigger than the minValue)
-      const { expression, compareOptions } = orderBy[0]!
-      const operator = compareOptions.direction === `asc` ? gt : lt
-      const valueFilter = operator(expression, new Value(minValue))
-      whereWithValueFilter = where ? and(where, valueFilter) : valueFilter
+    // Update the row count and last key after sending (for next call's offset/cursor)
+    this.limitedSnapshotRowCount += changes.length
+    if (changes.length > 0) {
+      this.lastSentKey = changes[changes.length - 1]!.key
+    }
+
+    // Build cursor expressions for sync layer loadSubset
+    // The cursor expressions are separate from the main where clause
+    // so the sync layer can choose cursor-based or offset-based pagination
+    let cursorExpressions:
+      | {
+          whereFrom: BasicExpression<boolean>
+          whereCurrent: BasicExpression<boolean>
+          lastKey?: string | number
+        }
+      | undefined
+
+    if (minValues !== undefined && minValues.length > 0) {
+      const whereFromCursor = buildCursor(orderBy, minValues)
+
+      if (whereFromCursor) {
+        const { expression } = orderBy[0]!
+        const minValue = minValues[0]
+
+        // Build the whereCurrent expression for the first orderBy column
+        // For Date values, we need to handle precision differences between JS (ms) and backends (μs)
+        // A JS Date represents a 1ms range, so we query for all values within that range
+        let whereCurrentCursor: BasicExpression<boolean>
+        if (minValue instanceof Date) {
+          const minValuePlus1ms = new Date(minValue.getTime() + 1)
+          whereCurrentCursor = and(
+            gte(expression, new Value(minValue)),
+            lt(expression, new Value(minValuePlus1ms)),
+          )
+        } else {
+          whereCurrentCursor = eq(expression, new Value(minValue))
+        }
+
+        cursorExpressions = {
+          whereFrom: whereFromCursor,
+          whereCurrent: whereCurrentCursor,
+          lastKey: this.lastSentKey,
+        }
+      }
     }
 
     // Request the sync layer to load more data
     // don't await it, we will load the data into the collection when it comes in
-    const syncResult = this.collection._sync.loadSubset({
-      where: whereWithValueFilter,
+    // Note: `where` does NOT include cursor expressions - they are passed separately
+    // The sync layer can choose to use cursor-based or offset-based pagination
+    const loadOptions: LoadSubsetOptions = {
+      where, // Main filter only, no cursor
       limit,
       orderBy,
+      cursor: cursorExpressions, // Cursor expressions passed separately
+      offset: offset ?? currentOffset, // Use provided offset, or auto-tracked offset
       subscription: this,
-    })
+    }
+    const syncResult = this.collection._sync.loadSubset(loadOptions)
 
+    // Track this loadSubset call
+    this.loadedSubsets.push(loadOptions)
     this.trackLoadSubsetPromise(syncResult)
   }
 
+  // TODO: also add similar test but that checks that it can also load it from the collection's loadSubset function
+  //       and that that also works properly (i.e. does not skip duplicate values)
+
   /**
    * Filters and flips changes for keys that have not been sent yet.
    * Deletes are filtered out for keys that have not been sent yet.
    * Updates are flipped into inserts for keys that have not been sent yet.
+   * Duplicate inserts are filtered out to prevent D2 multiplicity > 1.
    */
   private filterAndFlipChanges(changes: Array<ChangeMessage<any, any>>) {
-    if (this.loadedInitialState) {
-      // We loaded the entire initial state
+    if (this.loadedInitialState || this.skipFiltering) {
+      // We loaded the entire initial state or filtering is explicitly skipped
       // so no need to filter or flip changes
       return changes
     }
 
+    // When buffering for truncate, we need all changes (including deletes) to pass through.
+    // This is important because:
+    // 1. If loadedInitialState was previously true, sentKeys will be empty
+    //    (trackSentKeys early-returns when loadedInitialState is true)
+    // 2. The truncate deletes are for keys that WERE sent to the subscriber
+    // 3. We're collecting all changes atomically, so filtering doesn't make sense
+    const skipDeleteFilter = this.isBufferingForTruncate
+
     const newChanges = []
     for (const change of changes) {
       let newChange = change
-      if (!this.sentKeys.has(change.key)) {
+      const keyInSentKeys = this.sentKeys.has(change.key)
+
+      if (!keyInSentKeys) {
         if (change.type === `update`) {
           newChange = { ...change, type: `insert`, previousValue: undefined }
         } else if (change.type === `delete`) {
-          // filter out deletes for keys that have not been sent
-          continue
+          // Filter out deletes for keys that have not been sent,
+          // UNLESS we're buffering for truncate (where all deletes should pass through)
+          if (!skipDeleteFilter) {
+            continue
+          }
         }
         this.sentKeys.add(change.key)
+      } else {
+        // Key was already sent - handle based on change type
+        if (change.type === `insert`) {
+          // Filter out duplicate inserts - the key was already inserted.
+          // This prevents D2 multiplicity from going above 1, which would
+          // cause deletes to not properly remove items (multiplicity would
+          // go from 2 to 1 instead of 1 to 0).
+          continue
+        } else if (change.type === `delete`) {
+          // Remove from sentKeys so future inserts for this key are allowed
+          // (e.g., after truncate + reinsert)
+          this.sentKeys.delete(change.key)
+        }
       }
       newChanges.push(newChange)
     }
@@ -329,18 +659,49 @@ export class CollectionSubscription
   }
 
   private trackSentKeys(changes: Array<ChangeMessage<any, string | number>>) {
-    if (this.loadedInitialState) {
-      // No need to track sent keys if we loaded the entire state.
-      // Since we sent everything, all keys must have been observed.
+    if (this.loadedInitialState || this.skipFiltering) {
+      // No need to track sent keys if we loaded the entire state or filtering is skipped.
+      // Since filtering won't be applied, all keys are effectively "observed".
       return
     }
 
     for (const change of changes) {
-      this.sentKeys.add(change.key)
+      if (change.type === `delete`) {
+        // Remove deleted keys from sentKeys so future re-inserts are allowed
+        this.sentKeys.delete(change.key)
+      } else {
+        // For inserts and updates, track the key as sent
+        this.sentKeys.add(change.key)
+      }
     }
   }
 
+  /**
+   * Mark that the subscription should not filter any changes.
+   * This is used when includeInitialState is explicitly set to false,
+   * meaning the caller doesn't want initial state but does want ALL future changes.
+   */
+  markAllStateAsSeen() {
+    this.skipFiltering = true
+  }
+
   unsubscribe() {
+    // Clean up truncate event listener
+    this.truncateCleanup?.()
+    this.truncateCleanup = undefined
+
+    // Clean up truncate buffer state
+    this.isBufferingForTruncate = false
+    this.truncateBuffer = []
+    this.pendingTruncateRefetches.clear()
+
+    // Unload all subsets that this subscription loaded
+    // We pass the exact same LoadSubsetOptions we used for loadSubset
+    for (const options of this.loadedSubsets) {
+      this.collection._sync.unloadSubset(options)
+    }
+    this.loadedSubsets = []
+
     this.emitInner(`unsubscribed`, {
       type: `unsubscribed`,
       subscription: this,
diff --git a/packages/db/src/collection/sync.ts b/packages/db/src/collection/sync.ts
index 251fba608..4b71e4afd 100644
--- a/packages/db/src/collection/sync.ts
+++ b/packages/db/src/collection/sync.ts
@@ -7,20 +7,23 @@ import {
   SyncCleanupError,
   SyncTransactionAlreadyCommittedError,
   SyncTransactionAlreadyCommittedWriteError,
-} from "../errors"
-import { deepEquals } from "../utils"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+} from '../errors'
+import { deepEquals } from '../utils'
+import { LIVE_QUERY_INTERNAL } from '../query/live/internal.js'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type {
-  ChangeMessage,
+  ChangeMessageOrDeleteKeyMessage,
   CleanupFn,
   CollectionConfig,
   LoadSubsetOptions,
+  OptimisticChangeMessage,
   SyncConfigRes,
-} from "../types"
-import type { CollectionImpl } from "./index.js"
-import type { CollectionStateManager } from "./state"
-import type { CollectionLifecycleManager } from "./lifecycle"
-import type { CollectionEventsManager } from "./events.js"
+} from '../types'
+import type { CollectionImpl } from './index.js'
+import type { CollectionStateManager } from './state'
+import type { CollectionLifecycleManager } from './lifecycle'
+import type { CollectionEventsManager } from './events.js'
+import type { LiveQueryCollectionUtils } from '../query/live/collection-config-builder.js'
 
 export class CollectionSyncManager<
   TOutput extends object = Record<string, unknown>,
@@ -41,6 +44,8 @@ export class CollectionSyncManager<
   public syncLoadSubsetFn:
     | ((options: LoadSubsetOptions) => true | Promise<void>)
     | null = null
+  public syncUnloadSubsetFn: ((options: LoadSubsetOptions) => void) | null =
+    null
 
   private pendingLoadSubsetPromises: Set<Promise<void>> = new Set()
 
@@ -83,14 +88,20 @@ export class CollectionSyncManager<
       const syncRes = normalizeSyncFnResult(
         this.config.sync.sync({
           collection: this.collection,
-          begin: () => {
+          begin: (options?: { immediate?: boolean }) => {
             this.state.pendingSyncedTransactions.push({
               committed: false,
               operations: [],
               deletedKeys: new Set(),
+              immediate: options?.immediate,
             })
           },
-          write: (messageWithoutKey: Omit<ChangeMessage<TOutput>, `key`>) => {
+          write: (
+            messageWithOptionalKey: ChangeMessageOrDeleteKeyMessage<
+              TOutput,
+              TKey
+            >,
+          ) => {
             const pendingTransaction =
               this.state.pendingSyncedTransactions[
                 this.state.pendingSyncedTransactions.length - 1
@@ -101,12 +112,18 @@ export class CollectionSyncManager<
             if (pendingTransaction.committed) {
               throw new SyncTransactionAlreadyCommittedWriteError()
             }
-            const key = this.config.getKey(messageWithoutKey.value)
 
-            let messageType = messageWithoutKey.type
+            let key: TKey | undefined = undefined
+            if (`key` in messageWithOptionalKey) {
+              key = messageWithOptionalKey.key
+            } else {
+              key = this.config.getKey(messageWithOptionalKey.value)
+            }
+
+            let messageType = messageWithOptionalKey.type
 
             // Check if an item with this key already exists when inserting
-            if (messageWithoutKey.type === `insert`) {
+            if (messageWithOptionalKey.type === `insert`) {
               const insertingIntoExistingSynced = this.state.syncedData.has(key)
               const hasPendingDeleteForKey =
                 pendingTransaction.deletedKeys.has(key)
@@ -118,25 +135,32 @@ export class CollectionSyncManager<
                 !isTruncateTransaction
               ) {
                 const existingValue = this.state.syncedData.get(key)
-                if (
+                const valuesEqual =
                   existingValue !== undefined &&
-                  deepEquals(existingValue, messageWithoutKey.value)
-                ) {
+                  deepEquals(existingValue, messageWithOptionalKey.value)
+                if (valuesEqual) {
                   // The "insert" is an echo of a value we already have locally.
                   // Treat it as an update so we preserve optimistic intent without
                   // throwing a duplicate-key error during reconciliation.
                   messageType = `update`
                 } else {
-                  throw new DuplicateKeySyncError(key, this.id)
+                  const utils = this.config
+                    .utils as Partial<LiveQueryCollectionUtils>
+                  const internal = utils[LIVE_QUERY_INTERNAL]
+                  throw new DuplicateKeySyncError(key, this.id, {
+                    hasCustomGetKey: internal?.hasCustomGetKey ?? false,
+                    hasJoins: internal?.hasJoins ?? false,
+                    hasDistinct: internal?.hasDistinct ?? false,
+                  })
                 }
               }
             }
 
-            const message: ChangeMessage<TOutput> = {
-              ...messageWithoutKey,
+            const message = {
+              ...messageWithOptionalKey,
               type: messageType,
               key,
-            }
+            } as OptimisticChangeMessage<TOutput, TKey>
             pendingTransaction.operations.push(message)
 
             if (messageType === `delete`) {
@@ -192,7 +216,7 @@ export class CollectionSyncManager<
               deletes: new Set(this.state.optimisticDeletes),
             }
           },
-        })
+        }),
       )
 
       // Store cleanup function if provided
@@ -201,11 +225,14 @@ export class CollectionSyncManager<
       // Store loadSubset function if provided
       this.syncLoadSubsetFn = syncRes?.loadSubset ?? null
 
+      // Store unloadSubset function if provided
+      this.syncUnloadSubsetFn = syncRes?.unloadSubset ?? null
+
       // Validate: on-demand mode requires a loadSubset function
       if (this.syncMode === `on-demand` && !this.syncLoadSubsetFn) {
         throw new CollectionConfigurationError(
           `Collection "${this.id}" is configured with syncMode "on-demand" but the sync function did not return a loadSubset handler. ` +
-            `Either provide a loadSubset handler or use syncMode "eager".`
+            `Either provide a loadSubset handler or use syncMode "eager".`,
         )
       }
     } catch (error) {
@@ -223,6 +250,16 @@ export class CollectionSyncManager<
       return this.preloadPromise
     }
 
+    // Warn when calling preload on an on-demand collection
+    if (this.syncMode === `on-demand`) {
+      console.warn(
+        `${this.id ? `[${this.id}] ` : ``}Calling .preload() on a collection with syncMode "on-demand" is a no-op. ` +
+          `In on-demand mode, data is only loaded when queries request it. ` +
+          `Instead, create a live query and call .preload() on that to load the specific data you need. ` +
+          `See https://tanstack.com/blog/tanstack-db-0.5-query-driven-sync for more details.`,
+      )
+    }
+
     this.preloadPromise = new Promise<void>((resolve, reject) => {
       if (this.lifecycle.status === `ready`) {
         resolve()
@@ -323,6 +360,16 @@ export class CollectionSyncManager<
     return true
   }
 
+  /**
+   * Notifies the sync layer that a subset is no longer needed.
+   * @param options Options that identify what data is being unloaded
+   */
+  public unloadSubset(options: LoadSubsetOptions): void {
+    if (this.syncUnloadSubsetFn) {
+      this.syncUnloadSubsetFn(options)
+    }
+  }
+
   public cleanup(): void {
     try {
       if (this.syncCleanupFn) {
diff --git a/packages/db/src/duplicate-instance-check.ts b/packages/db/src/duplicate-instance-check.ts
new file mode 100644
index 000000000..2f38a562f
--- /dev/null
+++ b/packages/db/src/duplicate-instance-check.ts
@@ -0,0 +1,32 @@
+import { DuplicateDbInstanceError } from './errors'
+
+/**
+ * Check if we're in a browser top-level window (not a worker, SSR, or iframe).
+ * This helps avoid false positives in environments where multiple instances are legitimate.
+ */
+function isBrowserTopWindow(): boolean {
+  const w = (globalThis as any).window
+  // Exclude workers and SSR-ish shims
+  if (!w || !(`document` in w)) return false
+  // Avoid triggering inside iframes (cross-origin iframes can throw)
+  try {
+    return w === w.top
+  } catch {
+    return true // If we can't access w.top due to cross-origin, assume we should check
+  }
+}
+
+// Detect duplicate @tanstack/db instances (dev-only, browser top-window only)
+const DB_INSTANCE_MARKER = Symbol.for(`@tanstack/db/instance-marker`)
+const DEV =
+  typeof process !== `undefined` && process.env.NODE_ENV !== `production`
+const DISABLED =
+  typeof process !== `undefined` &&
+  process.env.TANSTACK_DB_DISABLE_DUP_CHECK === `1`
+
+if (DEV && !DISABLED && isBrowserTopWindow()) {
+  if ((globalThis as any)[DB_INSTANCE_MARKER]) {
+    throw new DuplicateDbInstanceError()
+  }
+  ;(globalThis as any)[DB_INSTANCE_MARKER] = true
+}
diff --git a/packages/db/src/errors.ts b/packages/db/src/errors.ts
index 7ec6dd478..dc1c7b900 100644
--- a/packages/db/src/errors.ts
+++ b/packages/db/src/errors.ts
@@ -28,7 +28,7 @@ export class SchemaValidationError extends TanStackDBError {
       message: string
       path?: ReadonlyArray<string | number | symbol>
     }>,
-    message?: string
+    message?: string,
   ) {
     const defaultMessage = `${type === `insert` ? `Insert` : `Update`} validation failed: ${issues
       .map((issue) => `\n- ${issue.message} - path: ${issue.path}`)
@@ -41,6 +41,32 @@ export class SchemaValidationError extends TanStackDBError {
   }
 }
 
+// Module Instance Errors
+export class DuplicateDbInstanceError extends TanStackDBError {
+  constructor() {
+    super(
+      `Multiple instances of @tanstack/db detected!\n\n` +
+        `This causes transaction context to be lost because each instance maintains ` +
+        `its own transaction stack.\n\n` +
+        `Common causes:\n` +
+        `1. Different versions of @tanstack/db installed\n` +
+        `2. Incompatible peer dependency versions in packages\n` +
+        `3. Module resolution issues in bundler configuration\n\n` +
+        `To fix:\n` +
+        `1. Check installed versions: npm list @tanstack/db (or pnpm/yarn list)\n` +
+        `2. Force a single version using package manager overrides:\n` +
+        `   - npm: "overrides" in package.json\n` +
+        `   - pnpm: "pnpm.overrides" in package.json\n` +
+        `   - yarn: "resolutions" in package.json\n` +
+        `3. Clear node_modules and lockfile, then reinstall\n\n` +
+        `To temporarily disable this check (not recommended):\n` +
+        `Set environment variable: TANSTACK_DB_DISABLE_DUP_CHECK=1\n\n` +
+        `See: https://tanstack.com/db/latest/docs/troubleshooting#duplicate-instances`,
+    )
+    this.name = `DuplicateDbInstanceError`
+  }
+}
+
 // Collection Configuration Errors
 export class CollectionConfigurationError extends TanStackDBError {
   constructor(message: string) {
@@ -84,7 +110,7 @@ export class CollectionStateError extends TanStackDBError {
 export class CollectionInErrorStateError extends CollectionStateError {
   constructor(operation: string, collectionId: string) {
     super(
-      `Cannot perform ${operation} on collection "${collectionId}" - collection is in error state. Try calling cleanup() and restarting the collection.`
+      `Cannot perform ${operation} on collection "${collectionId}" - collection is in error state. Try calling cleanup() and restarting the collection.`,
     )
   }
 }
@@ -92,7 +118,7 @@ export class CollectionInErrorStateError extends CollectionStateError {
 export class InvalidCollectionStatusTransitionError extends CollectionStateError {
   constructor(from: string, to: string, collectionId: string) {
     super(
-      `Invalid collection status transition from "${from}" to "${to}" for collection "${collectionId}"`
+      `Invalid collection status transition from "${from}" to "${to}" for collection "${collectionId}"`,
     )
   }
 }
@@ -120,7 +146,16 @@ export class CollectionOperationError extends TanStackDBError {
 export class UndefinedKeyError extends CollectionOperationError {
   constructor(item: any) {
     super(
-      `An object was created without a defined key: ${JSON.stringify(item)}`
+      `An object was created without a defined key: ${JSON.stringify(item)}`,
+    )
+  }
+}
+
+export class InvalidKeyError extends CollectionOperationError {
+  constructor(key: unknown, item: unknown) {
+    const keyType = key === null ? `null` : typeof key
+    super(
+      `getKey returned an invalid key type. Expected string or number, but got ${keyType}: ${JSON.stringify(key)}. Item: ${JSON.stringify(item)}`,
     )
   }
 }
@@ -128,16 +163,48 @@ export class UndefinedKeyError extends CollectionOperationError {
 export class DuplicateKeyError extends CollectionOperationError {
   constructor(key: string | number) {
     super(
-      `Cannot insert document with ID "${key}" because it already exists in the collection`
+      `Cannot insert document with ID "${key}" because it already exists in the collection`,
     )
   }
 }
 
 export class DuplicateKeySyncError extends CollectionOperationError {
-  constructor(key: string | number, collectionId: string) {
-    super(
-      `Cannot insert document with key "${key}" from sync because it already exists in the collection "${collectionId}"`
-    )
+  constructor(
+    key: string | number,
+    collectionId: string,
+    options?: {
+      hasCustomGetKey?: boolean
+      hasJoins?: boolean
+      hasDistinct?: boolean
+    },
+  ) {
+    const baseMessage = `Cannot insert document with key "${key}" from sync because it already exists in the collection "${collectionId}"`
+
+    // Provide enhanced guidance when custom getKey is used with distinct
+    if (options?.hasCustomGetKey && options.hasDistinct) {
+      super(
+        `${baseMessage}. ` +
+          `This collection uses a custom getKey with .distinct(). ` +
+          `The .distinct() operator deduplicates by the ENTIRE selected object (standard SQL behavior), ` +
+          `but your custom getKey extracts only a subset of fields. This causes multiple distinct rows ` +
+          `(with different values in non-key fields) to receive the same key. ` +
+          `To fix this, either: (1) ensure your SELECT only includes fields that uniquely identify each row, ` +
+          `(2) use .groupBy() with min()/max() aggregates to select one value per group, or ` +
+          `(3) remove the custom getKey to use the default key behavior.`,
+      )
+    } else if (options?.hasCustomGetKey && options.hasJoins) {
+      // Provide enhanced guidance when custom getKey is used with joins
+      super(
+        `${baseMessage}. ` +
+          `This collection uses a custom getKey with joined queries. ` +
+          `Joined queries can produce multiple rows with the same key when relationships are not 1:1. ` +
+          `Consider: (1) using a composite key in your getKey function (e.g., \`\${item.key1}-\${item.key2}\`), ` +
+          `(2) ensuring your join produces unique rows per key, or (3) removing the custom getKey ` +
+          `to use the default composite key behavior.`,
+      )
+    } else {
+      super(baseMessage)
+    }
   }
 }
 
@@ -156,7 +223,7 @@ export class NoKeysPassedToUpdateError extends CollectionOperationError {
 export class UpdateKeyNotFoundError extends CollectionOperationError {
   constructor(key: string | number) {
     super(
-      `The key "${key}" was passed to update but an object for this key was not found in the collection`
+      `The key "${key}" was passed to update but an object for this key was not found in the collection`,
     )
   }
 }
@@ -164,7 +231,7 @@ export class UpdateKeyNotFoundError extends CollectionOperationError {
 export class KeyUpdateNotAllowedError extends CollectionOperationError {
   constructor(originalKey: string | number, newKey: string | number) {
     super(
-      `Updating the key of an item is not allowed. Original key: "${originalKey}", Attempted new key: "${newKey}". Please delete the old item and create a new one if a key change is necessary.`
+      `Updating the key of an item is not allowed. Original key: "${originalKey}", Attempted new key: "${newKey}". Please delete the old item and create a new one if a key change is necessary.`,
     )
   }
 }
@@ -178,7 +245,7 @@ export class NoKeysPassedToDeleteError extends CollectionOperationError {
 export class DeleteKeyNotFoundError extends CollectionOperationError {
   constructor(key: string | number) {
     super(
-      `Collection.delete was called with key '${key}' but there is no item in the collection with this key`
+      `Collection.delete was called with key '${key}' but there is no item in the collection with this key`,
     )
   }
 }
@@ -194,7 +261,7 @@ export class MissingHandlerError extends TanStackDBError {
 export class MissingInsertHandlerError extends MissingHandlerError {
   constructor() {
     super(
-      `Collection.insert called directly (not within an explicit transaction) but no 'onInsert' handler is configured.`
+      `Collection.insert called directly (not within an explicit transaction) but no 'onInsert' handler is configured.`,
     )
   }
 }
@@ -202,7 +269,7 @@ export class MissingInsertHandlerError extends MissingHandlerError {
 export class MissingUpdateHandlerError extends MissingHandlerError {
   constructor() {
     super(
-      `Collection.update called directly (not within an explicit transaction) but no 'onUpdate' handler is configured.`
+      `Collection.update called directly (not within an explicit transaction) but no 'onUpdate' handler is configured.`,
     )
   }
 }
@@ -210,7 +277,7 @@ export class MissingUpdateHandlerError extends MissingHandlerError {
 export class MissingDeleteHandlerError extends MissingHandlerError {
   constructor() {
     super(
-      `Collection.delete called directly (not within an explicit transaction) but no 'onDelete' handler is configured.`
+      `Collection.delete called directly (not within an explicit transaction) but no 'onDelete' handler is configured.`,
     )
   }
 }
@@ -229,10 +296,19 @@ export class MissingMutationFunctionError extends TransactionError {
   }
 }
 
+export class OnMutateMustBeSynchronousError extends TransactionError {
+  constructor() {
+    super(
+      `onMutate must be synchronous and cannot return a promise. Remove async/await or returned promises from onMutate.`,
+    )
+    this.name = `OnMutateMustBeSynchronousError`
+  }
+}
+
 export class TransactionNotPendingMutateError extends TransactionError {
   constructor() {
     super(
-      `You can no longer call .mutate() as the transaction is no longer pending`
+      `You can no longer call .mutate() as the transaction is no longer pending`,
     )
   }
 }
@@ -240,7 +316,7 @@ export class TransactionNotPendingMutateError extends TransactionError {
 export class TransactionAlreadyCompletedRollbackError extends TransactionError {
   constructor() {
     super(
-      `You can no longer call .rollback() as the transaction is already completed`
+      `You can no longer call .rollback() as the transaction is already completed`,
     )
   }
 }
@@ -248,7 +324,7 @@ export class TransactionAlreadyCompletedRollbackError extends TransactionError {
 export class TransactionNotPendingCommitError extends TransactionError {
   constructor() {
     super(
-      `You can no longer call .commit() as the transaction is no longer pending`
+      `You can no longer call .commit() as the transaction is no longer pending`,
     )
   }
 }
@@ -262,7 +338,7 @@ export class NoPendingSyncTransactionWriteError extends TransactionError {
 export class SyncTransactionAlreadyCommittedWriteError extends TransactionError {
   constructor() {
     super(
-      `The pending sync transaction is already committed, you can't still write to it.`
+      `The pending sync transaction is already committed, you can't still write to it.`,
     )
   }
 }
@@ -276,7 +352,7 @@ export class NoPendingSyncTransactionCommitError extends TransactionError {
 export class SyncTransactionAlreadyCommittedError extends TransactionError {
   constructor() {
     super(
-      `The pending sync transaction is already committed, you can't commit it again.`
+      `The pending sync transaction is already committed, you can't commit it again.`,
     )
   }
 }
@@ -304,7 +380,16 @@ export class SubQueryMustHaveFromClauseError extends QueryBuilderError {
 export class InvalidSourceError extends QueryBuilderError {
   constructor(alias: string) {
     super(
-      `Invalid source for live query: The value provided for alias "${alias}" is not a Collection or subquery. Live queries only accept Collection instances or subqueries. Please ensure you're passing a valid Collection or QueryBuilder, not a plain array or other data type.`
+      `Invalid source for live query: The value provided for alias "${alias}" is not a Collection or subquery. Live queries only accept Collection instances or subqueries. Please ensure you're passing a valid Collection or QueryBuilder, not a plain array or other data type.`,
+    )
+  }
+}
+
+export class InvalidSourceTypeError extends QueryBuilderError {
+  constructor(context: string, type: string) {
+    super(
+      `Invalid source for ${context}: Expected an object with a single key-value pair like { alias: collection }. ` +
+        `For example: .from({ todos: todosCollection }). Got: ${type}`,
     )
   }
 }
@@ -321,6 +406,19 @@ export class QueryMustHaveFromClauseError extends QueryBuilderError {
   }
 }
 
+export class InvalidWhereExpressionError extends QueryBuilderError {
+  constructor(valueType: string) {
+    super(
+      `Invalid where() expression: Expected a query expression, but received a ${valueType}. ` +
+        `This usually happens when using JavaScript's comparison operators (===, !==, <, >, etc.) directly. ` +
+        `Instead, use the query builder functions:\n\n` +
+        `  ❌ .where(({ user }) => user.id === 'abc')\n` +
+        `  ✅ .where(({ user }) => eq(user.id, 'abc'))\n\n` +
+        `Available comparison functions: eq, gt, gte, lt, lte, and, or, not, like, ilike, isNull, isUndefined`,
+    )
+  }
+}
+
 // Query Compilation Errors
 export class QueryCompilationError extends TanStackDBError {
   constructor(message: string) {
@@ -344,7 +442,7 @@ export class HavingRequiresGroupByError extends QueryCompilationError {
 export class LimitOffsetRequireOrderByError extends QueryCompilationError {
   constructor() {
     super(
-      `LIMIT and OFFSET require an ORDER BY clause to ensure deterministic results`
+      `LIMIT and OFFSET require an ORDER BY clause to ensure deterministic results`,
     )
   }
 }
@@ -357,7 +455,7 @@ export class CollectionInputNotFoundError extends QueryCompilationError {
   constructor(
     alias: string,
     collectionId?: string,
-    availableKeys?: Array<string>
+    availableKeys?: Array<string>,
   ) {
     const details = collectionId
       ? `alias "${alias}" (collection "${collectionId}")`
@@ -369,6 +467,22 @@ export class CollectionInputNotFoundError extends QueryCompilationError {
   }
 }
 
+/**
+ * Error thrown when a subquery uses the same alias as its parent query.
+ * This causes issues because parent and subquery would share the same input streams,
+ * leading to empty results or incorrect data (aggregation cross-leaking).
+ */
+export class DuplicateAliasInSubqueryError extends QueryCompilationError {
+  constructor(alias: string, parentAliases: Array<string>) {
+    super(
+      `Subquery uses alias "${alias}" which is already used in the parent query. ` +
+        `Each alias must be unique across parent and subquery contexts. ` +
+        `Parent query aliases: ${parentAliases.join(`, `)}. ` +
+        `Please rename "${alias}" in either the parent query or subquery to avoid conflicts.`,
+    )
+  }
+}
+
 export class UnsupportedFromTypeError extends QueryCompilationError {
   constructor(type: string) {
     super(`Unsupported FROM type: ${type}`)
@@ -416,7 +530,7 @@ export class UnsupportedJoinTypeError extends JoinError {
 export class InvalidJoinConditionSameSourceError extends JoinError {
   constructor(sourceAlias: string) {
     super(
-      `Invalid join condition: both expressions refer to the same source "${sourceAlias}"`
+      `Invalid join condition: both expressions refer to the same source "${sourceAlias}"`,
     )
   }
 }
@@ -430,7 +544,7 @@ export class InvalidJoinConditionSourceMismatchError extends JoinError {
 export class InvalidJoinConditionLeftSourceError extends JoinError {
   constructor(sourceAlias: string) {
     super(
-      `Invalid join condition: left expression refers to an unavailable source "${sourceAlias}"`
+      `Invalid join condition: left expression refers to an unavailable source "${sourceAlias}"`,
     )
   }
 }
@@ -438,7 +552,7 @@ export class InvalidJoinConditionLeftSourceError extends JoinError {
 export class InvalidJoinConditionRightSourceError extends JoinError {
   constructor(sourceAlias: string) {
     super(
-      `Invalid join condition: right expression does not refer to the joined source "${sourceAlias}"`
+      `Invalid join condition: right expression does not refer to the joined source "${sourceAlias}"`,
     )
   }
 }
@@ -466,7 +580,7 @@ export class GroupByError extends TanStackDBError {
 export class NonAggregateExpressionNotInGroupByError extends GroupByError {
   constructor(alias: string) {
     super(
-      `Non-aggregate expression '${alias}' in SELECT must also appear in GROUP BY clause`
+      `Non-aggregate expression '${alias}' in SELECT must also appear in GROUP BY clause`,
     )
   }
 }
@@ -480,7 +594,7 @@ export class UnsupportedAggregateFunctionError extends GroupByError {
 export class AggregateFunctionNotInSelectError extends GroupByError {
   constructor(functionName: string) {
     super(
-      `Aggregate function in HAVING clause must also be in SELECT clause: ${functionName}`
+      `Aggregate function in HAVING clause must also be in SELECT clause: ${functionName}`,
     )
   }
 }
@@ -502,7 +616,7 @@ export class StorageError extends TanStackDBError {
 export class SerializationError extends StorageError {
   constructor(operation: string, originalError: string) {
     super(
-      `Cannot ${operation} item because it cannot be JSON serialized: ${originalError}`
+      `Cannot ${operation} item because it cannot be JSON serialized: ${originalError}`,
     )
   }
 }
@@ -524,7 +638,7 @@ export class StorageKeyRequiredError extends LocalStorageCollectionError {
 export class InvalidStorageDataFormatError extends LocalStorageCollectionError {
   constructor(storageKey: string, key: string) {
     super(
-      `[LocalStorageCollection] Invalid data format in storage key "${storageKey}" for key "${key}".`
+      `[LocalStorageCollection] Invalid data format in storage key "${storageKey}" for key "${key}".`,
     )
   }
 }
@@ -532,7 +646,7 @@ export class InvalidStorageDataFormatError extends LocalStorageCollectionError {
 export class InvalidStorageObjectFormatError extends LocalStorageCollectionError {
   constructor(storageKey: string) {
     super(
-      `[LocalStorageCollection] Invalid data format in storage key "${storageKey}". Expected object format.`
+      `[LocalStorageCollection] Invalid data format in storage key "${storageKey}". Expected object format.`,
     )
   }
 }
@@ -542,7 +656,7 @@ export class SyncCleanupError extends TanStackDBError {
   constructor(collectionId: string, error: Error | string) {
     const message = error instanceof Error ? error.message : String(error)
     super(
-      `Collection "${collectionId}" sync cleanup function threw an error: ${message}`
+      `Collection "${collectionId}" sync cleanup function threw an error: ${message}`,
     )
     this.name = `SyncCleanupError`
   }
@@ -568,7 +682,7 @@ export class CannotCombineEmptyExpressionListError extends QueryOptimizerError {
 export class WhereClauseConversionError extends QueryOptimizerError {
   constructor(collectionId: string, alias: string) {
     super(
-      `Failed to convert WHERE clause to collection filter for collection '${collectionId}' alias '${alias}'. This indicates a bug in the query optimization logic.`
+      `Failed to convert WHERE clause to collection filter for collection '${collectionId}' alias '${alias}'. This indicates a bug in the query optimization logic.`,
     )
   }
 }
@@ -582,10 +696,10 @@ export class SubscriptionNotFoundError extends QueryCompilationError {
     resolvedAlias: string,
     originalAlias: string,
     collectionId: string,
-    availableAliases: Array<string>
+    availableAliases: Array<string>,
   ) {
     super(
-      `Internal error: subscription for alias '${resolvedAlias}' (remapped from '${originalAlias}', collection '${collectionId}') is missing in join pipeline. Available aliases: ${availableAliases.join(`, `)}. This indicates a bug in alias tracking.`
+      `Internal error: subscription for alias '${resolvedAlias}' (remapped from '${originalAlias}', collection '${collectionId}') is missing in join pipeline. Available aliases: ${availableAliases.join(`, `)}. This indicates a bug in alias tracking.`,
     )
   }
 }
@@ -596,7 +710,7 @@ export class SubscriptionNotFoundError extends QueryCompilationError {
 export class AggregateNotSupportedError extends QueryCompilationError {
   constructor() {
     super(
-      `Aggregate expressions are not supported in this context. Use GROUP BY clause for aggregates.`
+      `Aggregate expressions are not supported in this context. Use GROUP BY clause for aggregates.`,
     )
   }
 }
@@ -609,7 +723,7 @@ export class MissingAliasInputsError extends QueryCompilationError {
   constructor(missingAliases: Array<string>) {
     super(
       `Internal error: compiler returned aliases without inputs: ${missingAliases.join(`, `)}. ` +
-        `This indicates a bug in query compilation. Please report this issue.`
+        `This indicates a bug in query compilation. Please report this issue.`,
     )
   }
 }
@@ -621,7 +735,7 @@ export class SetWindowRequiresOrderByError extends QueryCompilationError {
   constructor() {
     super(
       `setWindow() can only be called on collections with an ORDER BY clause. ` +
-        `Add .orderBy() to your query to enable window movement.`
+        `Add .orderBy() to your query to enable window movement.`,
     )
   }
 }
diff --git a/packages/db/src/event-emitter.ts b/packages/db/src/event-emitter.ts
index 19656e573..6d7ad90aa 100644
--- a/packages/db/src/event-emitter.ts
+++ b/packages/db/src/event-emitter.ts
@@ -16,7 +16,7 @@ export class EventEmitter<TEvents extends Record<string, any>> {
    */
   on<T extends keyof TEvents>(
     event: T,
-    callback: (event: TEvents[T]) => void
+    callback: (event: TEvents[T]) => void,
   ): () => void {
     if (!this.listeners.has(event)) {
       this.listeners.set(event, new Set())
@@ -36,7 +36,7 @@ export class EventEmitter<TEvents extends Record<string, any>> {
    */
   once<T extends keyof TEvents>(
     event: T,
-    callback: (event: TEvents[T]) => void
+    callback: (event: TEvents[T]) => void,
   ): () => void {
     const unsubscribe = this.on(event, (eventPayload) => {
       callback(eventPayload)
@@ -52,7 +52,7 @@ export class EventEmitter<TEvents extends Record<string, any>> {
    */
   off<T extends keyof TEvents>(
     event: T,
-    callback: (event: TEvents[T]) => void
+    callback: (event: TEvents[T]) => void,
   ): void {
     this.listeners.get(event)?.delete(callback as (event: any) => void)
   }
@@ -65,7 +65,7 @@ export class EventEmitter<TEvents extends Record<string, any>> {
    */
   waitFor<T extends keyof TEvents>(
     event: T,
-    timeout?: number
+    timeout?: number,
   ): Promise<TEvents[T]> {
     return new Promise((resolve, reject) => {
       let timeoutId: NodeJS.Timeout | undefined
@@ -95,7 +95,7 @@ export class EventEmitter<TEvents extends Record<string, any>> {
    */
   protected emitInner<T extends keyof TEvents>(
     event: T,
-    eventPayload: TEvents[T]
+    eventPayload: TEvents[T],
   ): void {
     this.listeners.get(event)?.forEach((listener) => {
       try {
diff --git a/packages/db/src/index.ts b/packages/db/src/index.ts
index a41cf51aa..ccf7cbb6e 100644
--- a/packages/db/src/index.ts
+++ b/packages/db/src/index.ts
@@ -1,25 +1,32 @@
 // Re-export all public APIs
 // Re-export IR types under their own namespace
 // because custom collections need access to the IR types
-import * as IR from "./query/ir.js"
+import * as IR from './query/ir.js'
 
-export * from "./collection/index.js"
-export * from "./SortedMap"
-export * from "./transactions"
-export * from "./types"
-export * from "./proxy"
-export * from "./query/index.js"
-export * from "./optimistic-action"
-export * from "./local-only"
-export * from "./local-storage"
-export * from "./errors"
+export * from './collection/index.js'
+export * from './SortedMap'
+export * from './transactions'
+export * from './types'
+export * from './proxy'
+export * from './query/index.js'
+export * from './optimistic-action'
+export * from './local-only'
+export * from './local-storage'
+export * from './errors'
+export { deepEquals } from './utils'
+export * from './paced-mutations'
+export * from './strategies/index.js'
 
 // Index system exports
-export * from "./indexes/base-index.js"
-export * from "./indexes/btree-index.js"
-export * from "./indexes/lazy-index.js"
-export { type IndexOptions } from "./indexes/index-options.js"
+export * from './indexes/base-index.js'
+export * from './indexes/btree-index.js'
+export * from './indexes/lazy-index.js'
+export { type IndexOptions } from './indexes/index-options.js'
+
+// Expression helpers
+export * from './query/expression-helpers.js'
 
 // Re-export some stuff explicitly to ensure the type & value is exported
-export type { Collection } from "./collection/index.js"
+export type { Collection } from './collection/index.js'
 export { IR }
+export { operators, type OperatorName } from './query/builder/functions.js'
diff --git a/packages/db/src/indexes/auto-index.ts b/packages/db/src/indexes/auto-index.ts
index f9387c968..098c92b50 100644
--- a/packages/db/src/indexes/auto-index.ts
+++ b/packages/db/src/indexes/auto-index.ts
@@ -1,8 +1,8 @@
-import { DEFAULT_COMPARE_OPTIONS } from "../utils"
-import { BTreeIndex } from "./btree-index"
-import type { CompareOptions } from "../query/builder/types"
-import type { BasicExpression } from "../query/ir"
-import type { CollectionImpl } from "../collection/index.js"
+import { DEFAULT_COMPARE_OPTIONS } from '../utils'
+import { BTreeIndex } from './btree-index'
+import type { CompareOptions } from '../query/builder/types'
+import type { BasicExpression } from '../query/ir'
+import type { CollectionImpl } from '../collection/index.js'
 
 export interface AutoIndexConfig {
   autoIndex?: `off` | `eager`
@@ -24,18 +24,22 @@ export function ensureIndexForField<
   fieldName: string,
   fieldPath: Array<string>,
   collection: CollectionImpl<T, TKey, any, any, any>,
-  compareOptions: CompareOptions = DEFAULT_COMPARE_OPTIONS,
-  compareFn?: (a: any, b: any) => number
+  compareOptions?: CompareOptions,
+  compareFn?: (a: any, b: any) => number,
 ) {
   if (!shouldAutoIndex(collection)) {
     return
   }
 
+  const compareOpts = compareOptions ?? {
+    ...DEFAULT_COMPARE_OPTIONS,
+    ...collection.compareOptions,
+  }
+
   // Check if we already have an index for this field
   const existingIndex = Array.from(collection.indexes.values()).find(
     (index) =>
-      index.matchesField(fieldPath) &&
-      index.matchesCompareOptions(compareOptions)
+      index.matchesField(fieldPath) && index.matchesCompareOptions(compareOpts),
   )
 
   if (existingIndex) {
@@ -44,15 +48,26 @@ export function ensureIndexForField<
 
   // Create a new index for this field using the collection's createIndex method
   try {
-    collection.createIndex((row) => (row as any)[fieldName], {
-      name: `auto_${fieldName}`,
-      indexType: BTreeIndex,
-      options: compareFn ? { compareFn, compareOptions } : {},
-    })
+    // Use the proxy-based approach to create the proper accessor for nested paths
+    collection.createIndex(
+      (row) => {
+        // Navigate through the field path
+        let current: any = row
+        for (const part of fieldPath) {
+          current = current[part]
+        }
+        return current
+      },
+      {
+        name: `auto:${fieldPath.join(`.`)}`,
+        indexType: BTreeIndex,
+        options: compareFn ? { compareFn, compareOptions: compareOpts } : {},
+      },
+    )
   } catch (error) {
     console.warn(
-      `${collection.id ? `[${collection.id}] ` : ``}Failed to create auto-index for field "${fieldName}":`,
-      error
+      `${collection.id ? `[${collection.id}] ` : ``}Failed to create auto-index for field path "${fieldPath.join(`.`)}":`,
+      error,
     )
   }
 }
@@ -65,7 +80,7 @@ export function ensureIndexForExpression<
   TKey extends string | number,
 >(
   expression: BasicExpression,
-  collection: CollectionImpl<T, TKey, any, any, any>
+  collection: CollectionImpl<T, TKey, any, any, any>,
 ): void {
   if (!shouldAutoIndex(collection)) {
     return
@@ -83,7 +98,7 @@ export function ensureIndexForExpression<
  * Extracts all indexable expressions from a where expression
  */
 function extractIndexableExpressions(
-  expression: BasicExpression
+  expression: BasicExpression,
 ): Array<{ fieldName: string; fieldPath: Array<string> }> {
   const results: Array<{ fieldName: string; fieldPath: Array<string> }> = []
 
@@ -108,7 +123,7 @@ function extractIndexableExpressions(
       return
     }
 
-    // Check if the first argument is a property reference (single field)
+    // Check if the first argument is a property reference
     if (func.args.length < 1 || func.args[0].type !== `ref`) {
       return
     }
@@ -116,12 +131,14 @@ function extractIndexableExpressions(
     const fieldRef = func.args[0]
     const fieldPath = fieldRef.path
 
-    // Skip if it's not a simple field (e.g., nested properties or array access)
-    if (fieldPath.length !== 1) {
+    // Skip if the path is empty
+    if (fieldPath.length === 0) {
       return
     }
 
-    const fieldName = fieldPath[0]
+    // For nested paths, use the full path joined with underscores as the field name
+    // For simple paths, use the first (and only) element
+    const fieldName = fieldPath.join(`_`)
     results.push({ fieldName, fieldPath })
   }
 
diff --git a/packages/db/src/indexes/base-index.ts b/packages/db/src/indexes/base-index.ts
index 3f611147f..18e58b7eb 100644
--- a/packages/db/src/indexes/base-index.ts
+++ b/packages/db/src/indexes/base-index.ts
@@ -1,9 +1,9 @@
-import { compileSingleRowExpression } from "../query/compiler/evaluators.js"
-import { comparisonFunctions } from "../query/builder/functions.js"
-import { DEFAULT_COMPARE_OPTIONS, deepEquals } from "../utils.js"
-import type { RangeQueryOptions } from "./btree-index.js"
-import type { CompareOptions } from "../query/builder/types.js"
-import type { BasicExpression, OrderByDirection } from "../query/ir.js"
+import { compileSingleRowExpression } from '../query/compiler/evaluators.js'
+import { comparisonFunctions } from '../query/builder/functions.js'
+import { DEFAULT_COMPARE_OPTIONS, deepEquals } from '../utils.js'
+import type { RangeQueryOptions } from './btree-index.js'
+import type { CompareOptions } from '../query/builder/types.js'
+import type { BasicExpression, OrderByDirection } from '../query/ir.js'
 
 /**
  * Operations that indexes can support, imported from available comparison functions
@@ -46,12 +46,12 @@ export interface IndexInterface<
   take: (
     n: number,
     from?: TKey,
-    filterFn?: (key: TKey) => boolean
+    filterFn?: (key: TKey) => boolean,
   ) => Array<TKey>
   takeReversed: (
     n: number,
     from?: TKey,
-    filterFn?: (key: TKey) => boolean
+    filterFn?: (key: TKey) => boolean,
   ) => Array<TKey>
 
   get keyCount(): number
@@ -73,9 +73,9 @@ export interface IndexInterface<
 /**
  * Base abstract class that all index types extend
  */
-export abstract class BaseIndex<TKey extends string | number = string | number>
-  implements IndexInterface<TKey>
-{
+export abstract class BaseIndex<
+  TKey extends string | number = string | number,
+> implements IndexInterface<TKey> {
   public readonly id: number
   public readonly name?: string
   public readonly expression: BasicExpression
@@ -90,7 +90,7 @@ export abstract class BaseIndex<TKey extends string | number = string | number>
     id: number,
     expression: BasicExpression,
     name?: string,
-    options?: any
+    options?: any,
   ) {
     this.id = id
     this.expression = expression
@@ -109,12 +109,12 @@ export abstract class BaseIndex<TKey extends string | number = string | number>
   abstract take(
     n: number,
     from?: TKey,
-    filterFn?: (key: TKey) => boolean
+    filterFn?: (key: TKey) => boolean,
   ): Array<TKey>
   abstract takeReversed(
     n: number,
     from?: TKey,
-    filterFn?: (key: TKey) => boolean
+    filterFn?: (key: TKey) => boolean,
   ): Array<TKey>
   abstract get keyCount(): number
   abstract equalityLookup(value: any): Set<TKey>
@@ -155,7 +155,7 @@ export abstract class BaseIndex<TKey extends string | number = string | number>
 
     return deepEquals(
       thisCompareOptionsWithoutDirection,
-      compareOptionsWithoutDirection
+      compareOptionsWithoutDirection,
     )
   }
 
@@ -203,7 +203,7 @@ export type IndexConstructor<TKey extends string | number = string | number> =
     id: number,
     expression: BasicExpression,
     name?: string,
-    options?: any
+    options?: any,
   ) => BaseIndex<TKey>
 
 /**
diff --git a/packages/db/src/indexes/btree-index.ts b/packages/db/src/indexes/btree-index.ts
index 467d5e1cc..2392fbcad 100644
--- a/packages/db/src/indexes/btree-index.ts
+++ b/packages/db/src/indexes/btree-index.ts
@@ -1,9 +1,10 @@
-import { BTree } from "../utils/btree.js"
-import { defaultComparator, normalizeValue } from "../utils/comparison.js"
-import { BaseIndex } from "./base-index.js"
-import type { CompareOptions } from "../query/builder/types.js"
-import type { BasicExpression } from "../query/ir.js"
-import type { IndexOperation } from "./base-index.js"
+import { compareKeys } from '@tanstack/db-ivm'
+import { BTree } from '../utils/btree.js'
+import { defaultComparator, normalizeValue } from '../utils/comparison.js'
+import { BaseIndex } from './base-index.js'
+import type { CompareOptions } from '../query/builder/types.js'
+import type { BasicExpression } from '../query/ir.js'
+import type { IndexOperation } from './base-index.js'
 
 /**
  * Options for Ordered index
@@ -51,7 +52,7 @@ export class BTreeIndex<
     id: number,
     expression: BasicExpression,
     name?: string,
-    options?: any
+    options?: any,
   ) {
     super(id, expression, name, options)
     this.compareFn = options?.compareFn ?? defaultComparator
@@ -72,7 +73,7 @@ export class BTreeIndex<
       indexedValue = this.evaluateIndexExpression(item)
     } catch (error) {
       throw new Error(
-        `Failed to evaluate index expression for key ${key}: ${error}`
+        `Failed to evaluate index expression for key ${key}: ${error}`,
       )
     }
 
@@ -104,7 +105,7 @@ export class BTreeIndex<
     } catch (error) {
       console.warn(
         `Failed to evaluate index expression for key ${key} during removal:`,
-        error
+        error,
       )
       return
     }
@@ -238,7 +239,7 @@ export class BTreeIndex<
         if (keys) {
           keys.forEach((key) => result.add(key))
         }
-      }
+      },
     )
 
     return result
@@ -261,7 +262,8 @@ export class BTreeIndex<
     n: number,
     nextPair: (k?: any) => [any, any] | undefined,
     from?: any,
-    filterFn?: (key: TKey) => boolean
+    filterFn?: (key: TKey) => boolean,
+    reversed: boolean = false,
   ): Array<TKey> {
     const keysInResult: Set<TKey> = new Set()
     const result: Array<TKey> = []
@@ -271,10 +273,12 @@ export class BTreeIndex<
     while ((pair = nextPair(key)) !== undefined && result.length < n) {
       key = pair[0]
       const keys = this.valueMap.get(key)
-      if (keys) {
-        const it = keys.values()
-        let ks: TKey | undefined
-        while (result.length < n && (ks = it.next().value)) {
+      if (keys && keys.size > 0) {
+        // Sort keys for deterministic order, reverse if needed
+        const sorted = Array.from(keys).sort(compareKeys)
+        if (reversed) sorted.reverse()
+        for (const ks of sorted) {
+          if (result.length >= n) break
           if (!keysInResult.has(ks) && (filterFn?.(ks) ?? true)) {
             result.push(ks)
             keysInResult.add(ks)
@@ -306,10 +310,10 @@ export class BTreeIndex<
   takeReversed(
     n: number,
     from?: any,
-    filterFn?: (key: TKey) => boolean
+    filterFn?: (key: TKey) => boolean,
   ): Array<TKey> {
     const nextPair = (k?: any) => this.orderedEntries.nextLowerPair(k)
-    return this.takeInternal(n, nextPair, from, filterFn)
+    return this.takeInternal(n, nextPair, from, filterFn, true)
   }
 
   /**
diff --git a/packages/db/src/indexes/index-options.ts b/packages/db/src/indexes/index-options.ts
index aaf1fcd6e..6dfbc137b 100644
--- a/packages/db/src/indexes/index-options.ts
+++ b/packages/db/src/indexes/index-options.ts
@@ -1,4 +1,4 @@
-import type { IndexConstructor, IndexResolver } from "./base-index.js"
+import type { IndexConstructor, IndexResolver } from './base-index.js'
 
 /**
  * Enhanced index options that support both sync and async resolvers
@@ -11,7 +11,7 @@ export interface IndexOptions<TResolver extends IndexResolver = IndexResolver> {
         id: number,
         expr: any,
         name?: string,
-        options?: infer O
+        options?: infer O,
       ) => any
       ? O
       : never
@@ -20,7 +20,7 @@ export interface IndexOptions<TResolver extends IndexResolver = IndexResolver> {
           id: number,
           expr: any,
           name?: string,
-          options?: infer O
+          options?: infer O,
         ) => any
         ? O
         : never
diff --git a/packages/db/src/indexes/lazy-index.ts b/packages/db/src/indexes/lazy-index.ts
index bcf28f45b..ca1dc6b02 100644
--- a/packages/db/src/indexes/lazy-index.ts
+++ b/packages/db/src/indexes/lazy-index.ts
@@ -2,14 +2,14 @@ import type {
   BaseIndex,
   IndexConstructor,
   IndexResolver,
-} from "./base-index.js"
-import type { BasicExpression } from "../query/ir.js"
+} from './base-index.js'
+import type { BasicExpression } from '../query/ir.js'
 
 /**
  * Utility to determine if a resolver is a constructor or async loader
  */
 function isConstructor<TKey extends string | number>(
-  resolver: IndexResolver<TKey>
+  resolver: IndexResolver<TKey>,
 ): resolver is IndexConstructor<TKey> {
   // Check if it's a function with a prototype (constructor)
   return (
@@ -23,7 +23,7 @@ function isConstructor<TKey extends string | number>(
  * Resolve index constructor from resolver
  */
 async function resolveIndexConstructor<TKey extends string | number>(
-  resolver: IndexResolver<TKey>
+  resolver: IndexResolver<TKey>,
 ): Promise<IndexConstructor<TKey>> {
   if (isConstructor(resolver)) {
     return resolver
@@ -46,7 +46,7 @@ export class LazyIndexWrapper<TKey extends string | number = string | number> {
     private name: string | undefined,
     private resolver: IndexResolver<TKey>,
     private options: any,
-    private collectionEntries?: Iterable<[TKey, any]>
+    private collectionEntries?: Iterable<[TKey, any]>,
   ) {
     // For synchronous constructors, resolve immediately
     if (isConstructor(this.resolver)) {
@@ -54,7 +54,7 @@ export class LazyIndexWrapper<TKey extends string | number = string | number> {
         this.id,
         this.expression,
         this.name,
-        this.options
+        this.options,
       )
       // Build with initial data if provided
       if (this.collectionEntries) {
@@ -92,7 +92,7 @@ export class LazyIndexWrapper<TKey extends string | number = string | number> {
   getResolved(): BaseIndex<TKey> {
     if (!this.resolvedIndex) {
       throw new Error(
-        `Index ${this.id} has not been resolved yet. Ensure collection is synced.`
+        `Index ${this.id} has not been resolved yet. Ensure collection is synced.`,
       )
     }
     return this.resolvedIndex
@@ -131,7 +131,7 @@ export class LazyIndexWrapper<TKey extends string | number = string | number> {
 export class IndexProxy<TKey extends string | number = string | number> {
   constructor(
     private indexId: number,
-    private lazyIndex: LazyIndexWrapper<TKey>
+    private lazyIndex: LazyIndexWrapper<TKey>,
   ) {}
 
   /**
diff --git a/packages/db/src/indexes/reverse-index.ts b/packages/db/src/indexes/reverse-index.ts
index 96a92b729..6bd9de0a3 100644
--- a/packages/db/src/indexes/reverse-index.ts
+++ b/packages/db/src/indexes/reverse-index.ts
@@ -1,11 +1,11 @@
-import type { CompareOptions } from "../query/builder/types"
-import type { OrderByDirection } from "../query/ir"
-import type { IndexInterface, IndexOperation, IndexStats } from "./base-index"
-import type { RangeQueryOptions } from "./btree-index"
-
-export class ReverseIndex<TKey extends string | number>
-  implements IndexInterface<TKey>
-{
+import type { CompareOptions } from '../query/builder/types'
+import type { OrderByDirection } from '../query/ir'
+import type { IndexInterface, IndexOperation, IndexStats } from './base-index'
+import type { RangeQueryOptions } from './btree-index'
+
+export class ReverseIndex<
+  TKey extends string | number,
+> implements IndexInterface<TKey> {
   private originalIndex: IndexInterface<TKey>
 
   constructor(index: IndexInterface<TKey>) {
@@ -43,7 +43,7 @@ export class ReverseIndex<TKey extends string | number>
   takeReversed(
     n: number,
     from?: any,
-    filterFn?: (key: TKey) => boolean
+    filterFn?: (key: TKey) => boolean,
   ): Array<TKey> {
     return this.originalIndex.take(n, from, filterFn)
   }
diff --git a/packages/db/src/local-only.ts b/packages/db/src/local-only.ts
index 11f19a43c..68168ae02 100644
--- a/packages/db/src/local-only.ts
+++ b/packages/db/src/local-only.ts
@@ -9,9 +9,9 @@ import type {
   SyncConfig,
   UpdateMutationFnParams,
   UtilsRecord,
-} from "./types"
-import type { Collection } from "./collection/index"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+} from './types'
+import type { Collection } from './collection/index'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 /**
  * Configuration interface for Local-only collection options
@@ -24,9 +24,9 @@ export interface LocalOnlyCollectionConfig<
   TSchema extends StandardSchemaV1 = never,
   TKey extends string | number = string | number,
 > extends Omit<
-    BaseCollectionConfig<T, TKey, TSchema, LocalOnlyCollectionUtils>,
-    `gcTime` | `startSync`
-  > {
+  BaseCollectionConfig<T, TKey, TSchema, LocalOnlyCollectionUtils>,
+  `gcTime` | `startSync`
+> {
   /**
    * Optional initial data to populate the collection with on creation
    * This data will be applied during the initial sync process
@@ -152,7 +152,7 @@ export function localOnlyCollectionOptions<
 >(
   config: LocalOnlyCollectionConfig<InferSchemaOutput<T>, T, TKey> & {
     schema: T
-  }
+  },
 ): LocalOnlyCollectionOptionsResult<InferSchemaOutput<T>, TKey, T> & {
   schema: T
 }
@@ -165,7 +165,7 @@ export function localOnlyCollectionOptions<
 >(
   config: LocalOnlyCollectionConfig<T, never, TKey> & {
     schema?: never // prohibit schema
-  }
+  },
 ): LocalOnlyCollectionOptionsResult<T, TKey> & {
   schema?: never // no schema in the result
 }
@@ -175,7 +175,7 @@ export function localOnlyCollectionOptions<
   TSchema extends StandardSchemaV1 = never,
   TKey extends string | number = string | number,
 >(
-  config: LocalOnlyCollectionConfig<T, TSchema, TKey>
+  config: LocalOnlyCollectionConfig<T, TSchema, TKey>,
 ): LocalOnlyCollectionOptionsResult<T, TKey, TSchema> & {
   schema?: StandardSchemaV1
 } {
@@ -189,7 +189,7 @@ export function localOnlyCollectionOptions<
    * Wraps the user's onInsert handler to also confirm the transaction immediately
    */
   const wrappedOnInsert = async (
-    params: InsertMutationFnParams<T, TKey, LocalOnlyCollectionUtils>
+    params: InsertMutationFnParams<T, TKey, LocalOnlyCollectionUtils>,
   ) => {
     // Call user handler first if provided
     let handlerResult
@@ -207,7 +207,7 @@ export function localOnlyCollectionOptions<
    * Wrapper for onUpdate handler that also confirms the transaction immediately
    */
   const wrappedOnUpdate = async (
-    params: UpdateMutationFnParams<T, TKey, LocalOnlyCollectionUtils>
+    params: UpdateMutationFnParams<T, TKey, LocalOnlyCollectionUtils>,
   ) => {
     // Call user handler first if provided
     let handlerResult
@@ -225,7 +225,7 @@ export function localOnlyCollectionOptions<
    * Wrapper for onDelete handler that also confirms the transaction immediately
    */
   const wrappedOnDelete = async (
-    params: DeleteMutationFnParams<T, TKey, LocalOnlyCollectionUtils>
+    params: DeleteMutationFnParams<T, TKey, LocalOnlyCollectionUtils>,
   ) => {
     // Call user handler first if provided
     let handlerResult
@@ -249,7 +249,7 @@ export function localOnlyCollectionOptions<
     const collectionMutations = transaction.mutations.filter(
       (m) =>
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        m.collection === syncResult.collection
+        m.collection === syncResult.collection,
     )
 
     if (collectionMutations.length === 0) {
@@ -258,7 +258,7 @@ export function localOnlyCollectionOptions<
 
     // Persist the mutations through sync
     syncResult.confirmOperationsSync(
-      collectionMutations as Array<PendingMutation<T>>
+      collectionMutations as Array<PendingMutation<T>>,
     )
   }
 
@@ -289,7 +289,7 @@ export function localOnlyCollectionOptions<
  * @returns Object with sync configuration and confirmOperationsSync function
  */
 function createLocalOnlySync<T extends object, TKey extends string | number>(
-  initialData?: Array<T>
+  initialData?: Array<T>,
 ) {
   // Capture sync functions and collection for transaction confirmation
   let syncBegin: (() => void) | null = null
diff --git a/packages/db/src/local-storage.ts b/packages/db/src/local-storage.ts
index df3b1b2e5..3060b7ec6 100644
--- a/packages/db/src/local-storage.ts
+++ b/packages/db/src/local-storage.ts
@@ -3,7 +3,7 @@ import {
   InvalidStorageObjectFormatError,
   SerializationError,
   StorageKeyRequiredError,
-} from "./errors"
+} from './errors'
 import type {
   BaseCollectionConfig,
   CollectionConfig,
@@ -14,8 +14,8 @@ import type {
   SyncConfig,
   UpdateMutationFnParams,
   UtilsRecord,
-} from "./types"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+} from './types'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 /**
  * Storage API interface - subset of DOM Storage that we need
@@ -28,11 +28,11 @@ export type StorageApi = Pick<Storage, `getItem` | `setItem` | `removeItem`>
 export type StorageEventApi = {
   addEventListener: (
     type: `storage`,
-    listener: (event: StorageEvent) => void
+    listener: (event: StorageEvent) => void,
   ) => void
   removeEventListener: (
     type: `storage`,
-    listener: (event: StorageEvent) => void
+    listener: (event: StorageEvent) => void,
   ) => void
 }
 
@@ -44,6 +44,11 @@ interface StoredItem<T> {
   data: T
 }
 
+export interface Parser {
+  parse: (data: string) => unknown
+  stringify: (data: unknown) => string
+}
+
 /**
  * Configuration interface for localStorage collection options
  * @template T - The type of items in the collection
@@ -71,6 +76,12 @@ export interface LocalStorageCollectionConfig<
    * Can be any object that implements addEventListener/removeEventListener for storage events
    */
   storageEventApi?: StorageEventApi
+
+  /**
+   * Parser to use for serializing and deserializing data to and from storage
+   * Defaults to JSON
+   */
+  parser?: Parser
 }
 
 /**
@@ -113,17 +124,22 @@ export interface LocalStorageCollectionUtils extends UtilsRecord {
 
 /**
  * Validates that a value can be JSON serialized
+ * @param parser - The parser to use for serialization
  * @param value - The value to validate for JSON serialization
  * @param operation - The operation type being performed (for error messages)
  * @throws Error if the value cannot be JSON serialized
  */
-function validateJsonSerializable(value: any, operation: string): void {
+function validateJsonSerializable(
+  parser: Parser,
+  value: any,
+  operation: string,
+): void {
   try {
-    JSON.stringify(value)
+    parser.stringify(value)
   } catch (error) {
     throw new SerializationError(
       operation,
-      error instanceof Error ? error.message : String(error)
+      error instanceof Error ? error.message : String(error),
     )
   }
 }
@@ -136,6 +152,43 @@ function generateUuid(): string {
   return crypto.randomUUID()
 }
 
+/**
+ * Encodes a key (string or number) into a storage-safe string format.
+ * This prevents collisions between numeric and string keys by prefixing with type information.
+ *
+ * Examples:
+ *   - number 1 → "n:1"
+ *   - string "1" → "s:1"
+ *   - string "n:1" → "s:n:1"
+ *
+ * @param key - The key to encode (string or number)
+ * @returns Type-prefixed string that is safe for storage
+ */
+function encodeStorageKey(key: string | number): string {
+  if (typeof key === `number`) {
+    return `n:${key}`
+  }
+  return `s:${key}`
+}
+
+/**
+ * Decodes a storage key back to its original form.
+ * This is the inverse of encodeStorageKey.
+ *
+ * @param encodedKey - The encoded key from storage
+ * @returns The original key (string or number)
+ */
+function decodeStorageKey(encodedKey: string): string | number {
+  if (encodedKey.startsWith(`n:`)) {
+    return Number(encodedKey.slice(2))
+  }
+  if (encodedKey.startsWith(`s:`)) {
+    return encodedKey.slice(2)
+  }
+  // Fallback for legacy data without encoding
+  return encodedKey
+}
+
 /**
  * Creates an in-memory storage implementation that mimics the StorageApi interface
  * Used as a fallback when localStorage is not available (e.g., server-side rendering)
@@ -266,8 +319,13 @@ export function localStorageCollectionOptions<
 >(
   config: LocalStorageCollectionConfig<InferSchemaOutput<T>, T, TKey> & {
     schema: T
-  }
-): CollectionConfig<InferSchemaOutput<T>, TKey, T> & {
+  },
+): CollectionConfig<
+  InferSchemaOutput<T>,
+  TKey,
+  T,
+  LocalStorageCollectionUtils
+> & {
   id: string
   utils: LocalStorageCollectionUtils
   schema: T
@@ -281,16 +339,19 @@ export function localStorageCollectionOptions<
 >(
   config: LocalStorageCollectionConfig<T, never, TKey> & {
     schema?: never // prohibit schema
-  }
-): CollectionConfig<T, TKey> & {
+  },
+): CollectionConfig<T, TKey, never, LocalStorageCollectionUtils> & {
   id: string
   utils: LocalStorageCollectionUtils
   schema?: never // no schema in the result
 }
 
 export function localStorageCollectionOptions(
-  config: LocalStorageCollectionConfig<any, any, string | number>
-): Omit<CollectionConfig<any, string | number, any>, `id`> & {
+  config: LocalStorageCollectionConfig<any, any, string | number>,
+): Omit<
+  CollectionConfig<any, string | number, any, LocalStorageCollectionUtils>,
+  `id`
+> & {
   id: string
   utils: LocalStorageCollectionUtils
   schema?: StandardSchemaV1
@@ -314,6 +375,9 @@ export function localStorageCollectionOptions(
     (typeof window !== `undefined` ? window : null) ||
     createNoOpStorageEventApi()
 
+  // Default to JSON parser if no parser is provided
+  const parser = config.parser || JSON
+
   // Track the last known state to detect changes
   const lastKnownData = new Map<string | number, StoredItem<any>>()
 
@@ -322,39 +386,30 @@ export function localStorageCollectionOptions(
     config.storageKey,
     storage,
     storageEventApi,
+    parser,
     config.getKey,
-    lastKnownData
+    lastKnownData,
   )
 
-  /**
-   * Manual trigger function for local sync updates
-   * Forces a check for storage changes and updates the collection if needed
-   */
-  const triggerLocalSync = () => {
-    if (sync.manualTrigger) {
-      sync.manualTrigger()
-    }
-  }
-
   /**
    * Save data to storage
    * @param dataMap - Map of items with version tracking to save to storage
    */
   const saveToStorage = (
-    dataMap: Map<string | number, StoredItem<any>>
+    dataMap: Map<string | number, StoredItem<any>>,
   ): void => {
     try {
       // Convert Map to object format for storage
       const objectData: Record<string, StoredItem<any>> = {}
       dataMap.forEach((storedItem, key) => {
-        objectData[String(key)] = storedItem
+        objectData[encodeStorageKey(key)] = storedItem
       })
-      const serialized = JSON.stringify(objectData)
+      const serialized = parser.stringify(objectData)
       storage.setItem(config.storageKey, serialized)
     } catch (error) {
       console.error(
         `[LocalStorageCollection] Error saving data to storage key "${config.storageKey}":`,
-        error
+        error,
       )
       throw error
     }
@@ -383,7 +438,7 @@ export function localStorageCollectionOptions(
   const wrappedOnInsert = async (params: InsertMutationFnParams<any>) => {
     // Validate that all values in the transaction can be JSON serialized
     params.transaction.mutations.forEach((mutation) => {
-      validateJsonSerializable(mutation.modified, `insert`)
+      validateJsonSerializable(parser, mutation.modified, `insert`)
     })
 
     // Call the user handler BEFORE persisting changes (if provided)
@@ -393,24 +448,23 @@ export function localStorageCollectionOptions(
     }
 
     // Always persist to storage
-    // Load current data from storage
-    const currentData = loadFromStorage<any>(config.storageKey, storage)
-
+    // Use lastKnownData (in-memory cache) instead of reading from storage
     // Add new items with version keys
     params.transaction.mutations.forEach((mutation) => {
-      const key = config.getKey(mutation.modified)
+      // Use the engine's pre-computed key for consistency
       const storedItem: StoredItem<any> = {
         versionKey: generateUuid(),
         data: mutation.modified,
       }
-      currentData.set(key, storedItem)
+      lastKnownData.set(mutation.key, storedItem)
     })
 
     // Save to storage
-    saveToStorage(currentData)
+    saveToStorage(lastKnownData)
 
-    // Manually trigger local sync since storage events don't fire for current tab
-    triggerLocalSync()
+    // Confirm mutations through sync interface (moves from optimistic to synced state)
+    // without reloading from storage
+    sync.confirmOperationsSync(params.transaction.mutations)
 
     return handlerResult
   }
@@ -418,7 +472,7 @@ export function localStorageCollectionOptions(
   const wrappedOnUpdate = async (params: UpdateMutationFnParams<any>) => {
     // Validate that all values in the transaction can be JSON serialized
     params.transaction.mutations.forEach((mutation) => {
-      validateJsonSerializable(mutation.modified, `update`)
+      validateJsonSerializable(parser, mutation.modified, `update`)
     })
 
     // Call the user handler BEFORE persisting changes (if provided)
@@ -428,24 +482,23 @@ export function localStorageCollectionOptions(
     }
 
     // Always persist to storage
-    // Load current data from storage
-    const currentData = loadFromStorage<any>(config.storageKey, storage)
-
+    // Use lastKnownData (in-memory cache) instead of reading from storage
     // Update items with new version keys
     params.transaction.mutations.forEach((mutation) => {
-      const key = config.getKey(mutation.modified)
+      // Use the engine's pre-computed key for consistency
       const storedItem: StoredItem<any> = {
         versionKey: generateUuid(),
         data: mutation.modified,
       }
-      currentData.set(key, storedItem)
+      lastKnownData.set(mutation.key, storedItem)
     })
 
     // Save to storage
-    saveToStorage(currentData)
+    saveToStorage(lastKnownData)
 
-    // Manually trigger local sync since storage events don't fire for current tab
-    triggerLocalSync()
+    // Confirm mutations through sync interface (moves from optimistic to synced state)
+    // without reloading from storage
+    sync.confirmOperationsSync(params.transaction.mutations)
 
     return handlerResult
   }
@@ -458,21 +511,19 @@ export function localStorageCollectionOptions(
     }
 
     // Always persist to storage
-    // Load current data from storage
-    const currentData = loadFromStorage<any>(config.storageKey, storage)
-
+    // Use lastKnownData (in-memory cache) instead of reading from storage
     // Remove items
     params.transaction.mutations.forEach((mutation) => {
-      // For delete operations, mutation.original contains the full object
-      const key = config.getKey(mutation.original)
-      currentData.delete(key)
+      // Use the engine's pre-computed key for consistency
+      lastKnownData.delete(mutation.key)
     })
 
     // Save to storage
-    saveToStorage(currentData)
+    saveToStorage(lastKnownData)
 
-    // Manually trigger local sync since storage events don't fire for current tab
-    triggerLocalSync()
+    // Confirm mutations through sync interface (moves from optimistic to synced state)
+    // without reloading from storage
+    sync.confirmOperationsSync(params.transaction.mutations)
 
     return handlerResult
   }
@@ -518,25 +569,18 @@ export function localStorageCollectionOptions(
       switch (mutation.type) {
         case `insert`:
         case `update`:
-          validateJsonSerializable(mutation.modified, mutation.type)
+          validateJsonSerializable(parser, mutation.modified, mutation.type)
           break
         case `delete`:
-          validateJsonSerializable(mutation.original, mutation.type)
+          validateJsonSerializable(parser, mutation.original, mutation.type)
           break
       }
     }
 
-    // Load current data from storage
-    const currentData = loadFromStorage<Record<string, unknown>>(
-      config.storageKey,
-      storage
-    )
-
+    // Use lastKnownData (in-memory cache) instead of reading from storage
     // Apply each mutation
     for (const mutation of collectionMutations) {
       // Use the engine's pre-computed key to avoid key derivation issues
-      const key = mutation.key
-
       switch (mutation.type) {
         case `insert`:
         case `update`: {
@@ -544,18 +588,18 @@ export function localStorageCollectionOptions(
             versionKey: generateUuid(),
             data: mutation.modified,
           }
-          currentData.set(key, storedItem)
+          lastKnownData.set(mutation.key, storedItem)
           break
         }
         case `delete`: {
-          currentData.delete(key)
+          lastKnownData.delete(mutation.key)
           break
         }
       }
     }
 
     // Save to storage
-    saveToStorage(currentData)
+    saveToStorage(lastKnownData)
 
     // Confirm the mutations in the collection to move them from optimistic to synced state
     // This writes them through the sync interface to make them "synced" instead of "optimistic"
@@ -579,13 +623,15 @@ export function localStorageCollectionOptions(
 
 /**
  * Load data from storage and return as a Map
+ * @param parser - The parser to use for deserializing the data
  * @param storageKey - The key used to store data in the storage API
  * @param storage - The storage API to load from (localStorage, sessionStorage, etc.)
  * @returns Map of stored items with version tracking, or empty Map if loading fails
  */
 function loadFromStorage<T extends object>(
   storageKey: string,
-  storage: StorageApi
+  storage: StorageApi,
+  parser: Parser,
 ): Map<string | number, StoredItem<T>> {
   try {
     const rawData = storage.getItem(storageKey)
@@ -593,7 +639,7 @@ function loadFromStorage<T extends object>(
       return new Map()
     }
 
-    const parsed = JSON.parse(rawData)
+    const parsed = parser.parse(rawData)
     const dataMap = new Map<string | number, StoredItem<T>>()
 
     // Handle object format where keys map to StoredItem values
@@ -602,7 +648,7 @@ function loadFromStorage<T extends object>(
       parsed !== null &&
       !Array.isArray(parsed)
     ) {
-      Object.entries(parsed).forEach(([key, value]) => {
+      Object.entries(parsed).forEach(([encodedKey, value]) => {
         // Runtime check to ensure the value has the expected StoredItem structure
         if (
           value &&
@@ -611,9 +657,10 @@ function loadFromStorage<T extends object>(
           `data` in value
         ) {
           const storedItem = value as StoredItem<T>
-          dataMap.set(key, storedItem)
+          const decodedKey = decodeStorageKey(encodedKey)
+          dataMap.set(decodedKey, storedItem)
         } else {
-          throw new InvalidStorageDataFormatError(storageKey, key)
+          throw new InvalidStorageDataFormatError(storageKey, encodedKey)
         }
       })
     } else {
@@ -624,7 +671,7 @@ function loadFromStorage<T extends object>(
   } catch (error) {
     console.warn(
       `[LocalStorageCollection] Error loading data from storage key "${storageKey}":`,
-      error
+      error,
     )
     return new Map()
   }
@@ -644,8 +691,9 @@ function createLocalStorageSync<T extends object>(
   storageKey: string,
   storage: StorageApi,
   storageEventApi: StorageEventApi,
+  parser: Parser,
   _getKey: (item: T) => string | number,
-  lastKnownData: Map<string | number, StoredItem<T>>
+  lastKnownData: Map<string | number, StoredItem<T>>,
 ): SyncConfig<T> & {
   manualTrigger?: () => void
   collection: any
@@ -662,7 +710,7 @@ function createLocalStorageSync<T extends object>(
    */
   const findChanges = (
     oldData: Map<string | number, StoredItem<T>>,
-    newData: Map<string | number, StoredItem<T>>
+    newData: Map<string | number, StoredItem<T>>,
   ): Array<{
     type: `insert` | `update` | `delete`
     key: string | number
@@ -704,7 +752,7 @@ function createLocalStorageSync<T extends object>(
     const { begin, write, commit } = syncParams
 
     // Load the new data
-    const newData = loadFromStorage<T>(storageKey, storage)
+    const newData = loadFromStorage<T>(storageKey, storage, parser)
 
     // Find the specific changes
     const changes = findChanges(lastKnownData, newData)
@@ -713,7 +761,7 @@ function createLocalStorageSync<T extends object>(
       begin()
       changes.forEach(({ type, value }) => {
         if (value) {
-          validateJsonSerializable(value, type)
+          validateJsonSerializable(parser, value, type)
           write({ type, value })
         }
       })
@@ -739,11 +787,11 @@ function createLocalStorageSync<T extends object>(
       collection = params.collection
 
       // Initial load
-      const initialData = loadFromStorage<T>(storageKey, storage)
+      const initialData = loadFromStorage<T>(storageKey, storage, parser)
       if (initialData.size > 0) {
         begin()
         initialData.forEach((storedItem) => {
-          validateJsonSerializable(storedItem.data, `load`)
+          validateJsonSerializable(parser, storedItem.data, `load`)
           write({ type: `insert`, value: storedItem.data })
         })
         commit()
diff --git a/packages/db/src/optimistic-action.ts b/packages/db/src/optimistic-action.ts
index 09ad02a15..ff5326326 100644
--- a/packages/db/src/optimistic-action.ts
+++ b/packages/db/src/optimistic-action.ts
@@ -1,5 +1,7 @@
-import { createTransaction } from "./transactions"
-import type { CreateOptimisticActionsOptions, Transaction } from "./types"
+import { createTransaction } from './transactions'
+import { OnMutateMustBeSynchronousError } from './errors'
+import { isPromiseLike } from './utils/type-guards'
+import type { CreateOptimisticActionsOptions, Transaction } from './types'
 
 /**
  * Creates an optimistic action function that applies local optimistic updates immediately
@@ -50,7 +52,7 @@ import type { CreateOptimisticActionsOptions, Transaction } from "./types"
  * @returns A function that accepts variables of type TVariables and returns a Transaction
  */
 export function createOptimisticAction<TVariables = unknown>(
-  options: CreateOptimisticActionsOptions<TVariables>
+  options: CreateOptimisticActionsOptions<TVariables>,
 ) {
   const { mutationFn, onMutate, ...config } = options
 
@@ -67,8 +69,11 @@ export function createOptimisticAction<TVariables = unknown>(
     // Execute the transaction. The mutationFn is called once mutate()
     // is finished.
     transaction.mutate(() => {
-      // Call onMutate with variables to apply optimistic updates
-      onMutate(variables)
+      const maybePromise = onMutate(variables) as unknown
+
+      if (isPromiseLike(maybePromise)) {
+        throw new OnMutateMustBeSynchronousError()
+      }
     })
 
     return transaction
diff --git a/packages/db/src/paced-mutations.ts b/packages/db/src/paced-mutations.ts
new file mode 100644
index 000000000..d1d6d9a3e
--- /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 ({ 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 ({ 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/proxy.ts b/packages/db/src/proxy.ts
index baffc1743..57723e3cc 100644
--- a/packages/db/src/proxy.ts
+++ b/packages/db/src/proxy.ts
@@ -3,7 +3,454 @@
  * and provides a way to retrieve those changes.
  */
 
-import { deepEquals, isTemporal } from "./utils"
+import { deepEquals, isTemporal } from './utils'
+
+/**
+ * Set of array methods that iterate with callbacks and may return elements.
+ * Hoisted to module scope to avoid creating a new Set on every property access.
+ */
+const CALLBACK_ITERATION_METHODS = new Set([
+  `find`,
+  `findLast`,
+  `findIndex`,
+  `findLastIndex`,
+  `filter`,
+  `map`,
+  `flatMap`,
+  `forEach`,
+  `some`,
+  `every`,
+  `reduce`,
+  `reduceRight`,
+])
+
+/**
+ * Set of array methods that modify the array in place.
+ */
+const ARRAY_MODIFYING_METHODS = new Set([
+  `pop`,
+  `push`,
+  `shift`,
+  `unshift`,
+  `splice`,
+  `sort`,
+  `reverse`,
+  `fill`,
+  `copyWithin`,
+])
+
+/**
+ * Set of Map/Set methods that modify the collection in place.
+ */
+const MAP_SET_MODIFYING_METHODS = new Set([`set`, `delete`, `clear`, `add`])
+
+/**
+ * Set of Map/Set iterator methods.
+ */
+const MAP_SET_ITERATOR_METHODS = new Set([
+  `entries`,
+  `keys`,
+  `values`,
+  `forEach`,
+])
+
+/**
+ * Check if a value is a proxiable object (not Date, RegExp, or Temporal)
+ */
+function isProxiableObject(
+  value: unknown,
+): value is Record<string | symbol, unknown> {
+  return (
+    value !== null &&
+    typeof value === `object` &&
+    !((value as any) instanceof Date) &&
+    !((value as any) instanceof RegExp) &&
+    !isTemporal(value)
+  )
+}
+
+/**
+ * Creates a handler for array iteration methods that ensures proxied elements
+ * are passed to callbacks and returned from methods like find/filter.
+ */
+function createArrayIterationHandler<T extends object>(
+  methodName: string,
+  methodFn: (...args: Array<unknown>) => unknown,
+  changeTracker: ChangeTracker<T>,
+  memoizedCreateChangeProxy: (
+    obj: Record<string | symbol, unknown>,
+    parent?: {
+      tracker: ChangeTracker<Record<string | symbol, unknown>>
+      prop: string | symbol
+    },
+  ) => { proxy: Record<string | symbol, unknown> },
+): ((...args: Array<unknown>) => unknown) | undefined {
+  if (!CALLBACK_ITERATION_METHODS.has(methodName)) {
+    return undefined
+  }
+
+  return function (...args: Array<unknown>) {
+    const callback = args[0]
+    if (typeof callback !== `function`) {
+      return methodFn.apply(changeTracker.copy_, args)
+    }
+
+    // Create a helper to get proxied version of an array element
+    const getProxiedElement = (element: unknown, index: number): unknown => {
+      if (isProxiableObject(element)) {
+        const nestedParent = {
+          tracker: changeTracker as unknown as ChangeTracker<
+            Record<string | symbol, unknown>
+          >,
+          prop: String(index),
+        }
+        const { proxy: elementProxy } = memoizedCreateChangeProxy(
+          element,
+          nestedParent,
+        )
+        return elementProxy
+      }
+      return element
+    }
+
+    // Wrap the callback to pass proxied elements
+    const wrappedCallback = function (
+      this: unknown,
+      element: unknown,
+      index: number,
+      array: unknown,
+    ) {
+      const proxiedElement = getProxiedElement(element, index)
+      return callback.call(this, proxiedElement, index, array)
+    }
+
+    // For reduce/reduceRight, the callback signature is different
+    if (methodName === `reduce` || methodName === `reduceRight`) {
+      const reduceCallback = function (
+        this: unknown,
+        accumulator: unknown,
+        element: unknown,
+        index: number,
+        array: unknown,
+      ) {
+        const proxiedElement = getProxiedElement(element, index)
+        return callback.call(this, accumulator, proxiedElement, index, array)
+      }
+      return methodFn.apply(changeTracker.copy_, [
+        reduceCallback,
+        ...args.slice(1),
+      ])
+    }
+
+    const result = methodFn.apply(changeTracker.copy_, [
+      wrappedCallback,
+      ...args.slice(1),
+    ])
+
+    // For find/findLast, proxy the returned element if it's an object
+    if (
+      (methodName === `find` || methodName === `findLast`) &&
+      result &&
+      typeof result === `object`
+    ) {
+      const foundIndex = (
+        changeTracker.copy_ as unknown as Array<unknown>
+      ).indexOf(result)
+      if (foundIndex !== -1) {
+        return getProxiedElement(result, foundIndex)
+      }
+    }
+
+    // For filter, proxy each element in the result array
+    if (methodName === `filter` && Array.isArray(result)) {
+      return result.map((element) => {
+        const originalIndex = (
+          changeTracker.copy_ as unknown as Array<unknown>
+        ).indexOf(element)
+        if (originalIndex !== -1) {
+          return getProxiedElement(element, originalIndex)
+        }
+        return element
+      })
+    }
+
+    return result
+  }
+}
+
+/**
+ * Creates a Symbol.iterator handler for arrays that yields proxied elements.
+ */
+function createArrayIteratorHandler<T extends object>(
+  changeTracker: ChangeTracker<T>,
+  memoizedCreateChangeProxy: (
+    obj: Record<string | symbol, unknown>,
+    parent?: {
+      tracker: ChangeTracker<Record<string | symbol, unknown>>
+      prop: string | symbol
+    },
+  ) => { proxy: Record<string | symbol, unknown> },
+): () => Iterator<unknown> {
+  return function () {
+    const array = changeTracker.copy_ as unknown as Array<unknown>
+    let index = 0
+
+    return {
+      next() {
+        if (index >= array.length) {
+          return { done: true, value: undefined }
+        }
+
+        const element = array[index]
+        let proxiedElement = element
+
+        if (isProxiableObject(element)) {
+          const nestedParent = {
+            tracker: changeTracker as unknown as ChangeTracker<
+              Record<string | symbol, unknown>
+            >,
+            prop: String(index),
+          }
+          const { proxy: elementProxy } = memoizedCreateChangeProxy(
+            element,
+            nestedParent,
+          )
+          proxiedElement = elementProxy
+        }
+
+        index++
+        return { done: false, value: proxiedElement }
+      },
+      [Symbol.iterator]() {
+        return this
+      },
+    }
+  }
+}
+
+/**
+ * Creates a wrapper for methods that modify a collection (array, Map, Set).
+ * The wrapper calls the method and marks the change tracker as modified.
+ */
+function createModifyingMethodHandler<T extends object>(
+  methodFn: (...args: Array<unknown>) => unknown,
+  changeTracker: ChangeTracker<T>,
+  markChanged: (tracker: ChangeTracker<T>) => void,
+): (...args: Array<unknown>) => unknown {
+  return function (...args: Array<unknown>) {
+    const result = methodFn.apply(changeTracker.copy_, args)
+    markChanged(changeTracker)
+    return result
+  }
+}
+
+/**
+ * Creates handlers for Map/Set iterator methods (entries, keys, values, forEach).
+ * Returns proxied values for iteration to enable change tracking.
+ */
+function createMapSetIteratorHandler<T extends object>(
+  methodName: string,
+  prop: string | symbol,
+  methodFn: (...args: Array<unknown>) => unknown,
+  target: Map<unknown, unknown> | Set<unknown>,
+  changeTracker: ChangeTracker<T>,
+  memoizedCreateChangeProxy: (
+    obj: Record<string | symbol, unknown>,
+    parent?: {
+      tracker: ChangeTracker<Record<string | symbol, unknown>>
+      prop: string | symbol
+    },
+  ) => { proxy: Record<string | symbol, unknown> },
+  markChanged: (tracker: ChangeTracker<T>) => void,
+): ((...args: Array<unknown>) => unknown) | undefined {
+  const isIteratorMethod =
+    MAP_SET_ITERATOR_METHODS.has(methodName) || prop === Symbol.iterator
+
+  if (!isIteratorMethod) {
+    return undefined
+  }
+
+  return function (this: unknown, ...args: Array<unknown>) {
+    const result = methodFn.apply(changeTracker.copy_, args)
+
+    // For forEach, wrap the callback to track changes
+    if (methodName === `forEach`) {
+      const callback = args[0]
+      if (typeof callback === `function`) {
+        const wrappedCallback = function (
+          this: unknown,
+          value: unknown,
+          key: unknown,
+          collection: unknown,
+        ) {
+          const cbresult = callback.call(this, value, key, collection)
+          markChanged(changeTracker)
+          return cbresult
+        }
+        return methodFn.apply(target, [wrappedCallback, ...args.slice(1)])
+      }
+    }
+
+    // For iterators (entries, keys, values, Symbol.iterator)
+    const isValueIterator =
+      methodName === `entries` ||
+      methodName === `values` ||
+      methodName === Symbol.iterator.toString() ||
+      prop === Symbol.iterator
+
+    if (isValueIterator) {
+      const originalIterator = result as Iterator<unknown>
+
+      // For values() iterator on Maps, create a value-to-key mapping
+      const valueToKeyMap = new Map()
+      if (methodName === `values` && target instanceof Map) {
+        for (const [key, mapValue] of (
+          changeTracker.copy_ as unknown as Map<unknown, unknown>
+        ).entries()) {
+          valueToKeyMap.set(mapValue, key)
+        }
+      }
+
+      // For Set iterators, create an original-to-modified mapping
+      const originalToModifiedMap = new Map()
+      if (target instanceof Set) {
+        for (const setValue of (
+          changeTracker.copy_ as unknown as Set<unknown>
+        ).values()) {
+          originalToModifiedMap.set(setValue, setValue)
+        }
+      }
+
+      // Return a wrapped iterator that proxies values
+      return {
+        next() {
+          const nextResult = originalIterator.next()
+
+          if (
+            !nextResult.done &&
+            nextResult.value &&
+            typeof nextResult.value === `object`
+          ) {
+            // For entries, the value is a [key, value] pair
+            if (
+              methodName === `entries` &&
+              Array.isArray(nextResult.value) &&
+              nextResult.value.length === 2
+            ) {
+              if (
+                nextResult.value[1] &&
+                typeof nextResult.value[1] === `object`
+              ) {
+                const mapKey = nextResult.value[0]
+                const mapParent = {
+                  tracker: changeTracker as unknown as ChangeTracker<
+                    Record<string | symbol, unknown>
+                  >,
+                  prop: mapKey as string | symbol,
+                  updateMap: (newValue: unknown) => {
+                    if (changeTracker.copy_ instanceof Map) {
+                      ;(changeTracker.copy_ as Map<unknown, unknown>).set(
+                        mapKey,
+                        newValue,
+                      )
+                    }
+                  },
+                }
+                const { proxy: valueProxy } = memoizedCreateChangeProxy(
+                  nextResult.value[1] as Record<string | symbol, unknown>,
+                  mapParent as unknown as {
+                    tracker: ChangeTracker<Record<string | symbol, unknown>>
+                    prop: string | symbol
+                  },
+                )
+                nextResult.value[1] = valueProxy
+              }
+            } else if (
+              methodName === `values` ||
+              methodName === Symbol.iterator.toString() ||
+              prop === Symbol.iterator
+            ) {
+              // For Map values(), use the key mapping
+              if (methodName === `values` && target instanceof Map) {
+                const mapKey = valueToKeyMap.get(nextResult.value)
+                if (mapKey !== undefined) {
+                  const mapParent = {
+                    tracker: changeTracker as unknown as ChangeTracker<
+                      Record<string | symbol, unknown>
+                    >,
+                    prop: mapKey as string | symbol,
+                    updateMap: (newValue: unknown) => {
+                      if (changeTracker.copy_ instanceof Map) {
+                        ;(changeTracker.copy_ as Map<unknown, unknown>).set(
+                          mapKey,
+                          newValue,
+                        )
+                      }
+                    },
+                  }
+                  const { proxy: valueProxy } = memoizedCreateChangeProxy(
+                    nextResult.value as Record<string | symbol, unknown>,
+                    mapParent as unknown as {
+                      tracker: ChangeTracker<Record<string | symbol, unknown>>
+                      prop: string | symbol
+                    },
+                  )
+                  nextResult.value = valueProxy
+                }
+              } else if (target instanceof Set) {
+                // For Set, track modifications
+                const setOriginalValue = nextResult.value
+                const setParent = {
+                  tracker: changeTracker as unknown as ChangeTracker<
+                    Record<string | symbol, unknown>
+                  >,
+                  prop: setOriginalValue as unknown as string | symbol,
+                  updateSet: (newValue: unknown) => {
+                    if (changeTracker.copy_ instanceof Set) {
+                      ;(changeTracker.copy_ as Set<unknown>).delete(
+                        setOriginalValue,
+                      )
+                      ;(changeTracker.copy_ as Set<unknown>).add(newValue)
+                      originalToModifiedMap.set(setOriginalValue, newValue)
+                    }
+                  },
+                }
+                const { proxy: valueProxy } = memoizedCreateChangeProxy(
+                  nextResult.value as Record<string | symbol, unknown>,
+                  setParent as unknown as {
+                    tracker: ChangeTracker<Record<string | symbol, unknown>>
+                    prop: string | symbol
+                  },
+                )
+                nextResult.value = valueProxy
+              } else {
+                // For other cases, use a symbol placeholder
+                const tempKey = Symbol(`iterator-value`)
+                const { proxy: valueProxy } = memoizedCreateChangeProxy(
+                  nextResult.value as Record<string | symbol, unknown>,
+                  {
+                    tracker: changeTracker as unknown as ChangeTracker<
+                      Record<string | symbol, unknown>
+                    >,
+                    prop: tempKey,
+                  },
+                )
+                nextResult.value = valueProxy
+              }
+            }
+          }
+
+          return nextResult
+        },
+        [Symbol.iterator]() {
+          return this
+        },
+      }
+    }
+
+    return result
+  }
+}
 
 /**
  * Simple debug utility that only logs when debug mode is enabled
@@ -66,7 +513,7 @@ interface ChangeTracker<T extends object> {
 
 function deepClone<T extends unknown>(
   obj: T,
-  visited = new WeakMap<object, unknown>()
+  visited = new WeakMap<object, unknown>(),
 ): T {
   // Handle null and undefined
   if (obj === null || obj === undefined) {
@@ -105,7 +552,7 @@ function deepClone<T extends unknown>(
     // Get the constructor to create a new instance of the same type
     const TypedArrayConstructor = Object.getPrototypeOf(obj).constructor
     const clone = new TypedArrayConstructor(
-      (obj as unknown as TypedArray).length
+      (obj as unknown as TypedArray).length,
     ) as unknown as TypedArray
     visited.set(obj as object, clone)
 
@@ -149,7 +596,7 @@ function deepClone<T extends unknown>(
     if (Object.prototype.hasOwnProperty.call(obj, key)) {
       clone[key] = deepClone(
         (obj as Record<string | symbol, unknown>)[key],
-        visited
+        visited,
       )
     }
   }
@@ -158,7 +605,7 @@ function deepClone<T extends unknown>(
   for (const sym of symbolProps) {
     clone[sym] = deepClone(
       (obj as Record<string | symbol, unknown>)[sym],
-      visited
+      visited,
     )
   }
 
@@ -185,7 +632,7 @@ export function createChangeProxy<
   parent?: {
     tracker: ChangeTracker<Record<string | symbol, unknown>>
     prop: string | symbol
-  }
+  },
 ): {
   proxy: T
 
@@ -200,7 +647,7 @@ export function createChangeProxy<
     innerParent?: {
       tracker: ChangeTracker<Record<string | symbol, unknown>>
       prop: string | symbol
-    }
+    },
   ): {
     proxy: TInner
     getChanges: () => Record<string | symbol, any>
@@ -236,7 +683,7 @@ export function createChangeProxy<
   debugLog(
     `createChangeProxy called for target`,
     target,
-    changeTracker.proxyCount
+    changeTracker.proxyCount,
   )
   // Mark this object and all its ancestors as modified
   // Also propagate the actual changes up the chain
@@ -269,11 +716,11 @@ export function createChangeProxy<
 
   // Check if all properties in the current state have reverted to original values
   function checkIfReverted(
-    state: ChangeTracker<Record<string | symbol, unknown>>
+    state: ChangeTracker<Record<string | symbol, unknown>>,
   ): boolean {
     debugLog(
       `checkIfReverted called with assigned keys:`,
-      Object.keys(state.assigned_)
+      Object.keys(state.assigned_),
     )
 
     // If there are no assigned properties, object is unchanged
@@ -296,7 +743,7 @@ export function createChangeProxy<
           `Checking property ${String(prop)}, current:`,
           currentValue,
           `original:`,
-          originalValue
+          originalValue,
         )
 
         // If the value is not equal to original, something is still changed
@@ -338,7 +785,7 @@ export function createChangeProxy<
   // Update parent status based on child changes
   function checkParentStatus(
     parentState: ChangeTracker<Record<string | symbol, unknown>>,
-    childProp: string | symbol | unknown
+    childProp: string | symbol | unknown,
   ) {
     debugLog(`checkParentStatus called for child prop:`, childProp)
 
@@ -392,271 +839,66 @@ export function createChangeProxy<
           // For Array methods that modify the array
           if (Array.isArray(ptarget)) {
             const methodName = prop.toString()
-            const modifyingMethods = new Set([
-              `pop`,
-              `push`,
-              `shift`,
-              `unshift`,
-              `splice`,
-              `sort`,
-              `reverse`,
-              `fill`,
-              `copyWithin`,
-            ])
-
-            if (modifyingMethods.has(methodName)) {
-              return function (...args: Array<unknown>) {
-                const result = value.apply(changeTracker.copy_, args)
-                markChanged(changeTracker)
-                return result
-              }
+
+            if (ARRAY_MODIFYING_METHODS.has(methodName)) {
+              return createModifyingMethodHandler(
+                value,
+                changeTracker,
+                markChanged,
+              )
+            }
+
+            // Handle array iteration methods (find, filter, forEach, etc.)
+            const iterationHandler = createArrayIterationHandler(
+              methodName,
+              value,
+              changeTracker,
+              memoizedCreateChangeProxy,
+            )
+            if (iterationHandler) {
+              return iterationHandler
+            }
+
+            // Handle array Symbol.iterator for for...of loops
+            if (prop === Symbol.iterator) {
+              return createArrayIteratorHandler(
+                changeTracker,
+                memoizedCreateChangeProxy,
+              )
             }
           }
 
           // For Map and Set methods that modify the collection
           if (ptarget instanceof Map || ptarget instanceof Set) {
             const methodName = prop.toString()
-            const modifyingMethods = new Set([
-              `set`,
-              `delete`,
-              `clear`,
-              `add`,
-              `pop`,
-              `push`,
-              `shift`,
-              `unshift`,
-              `splice`,
-              `sort`,
-              `reverse`,
-            ])
-
-            if (modifyingMethods.has(methodName)) {
-              return function (...args: Array<unknown>) {
-                const result = value.apply(changeTracker.copy_, args)
-                markChanged(changeTracker)
-                return result
-              }
+
+            if (MAP_SET_MODIFYING_METHODS.has(methodName)) {
+              return createModifyingMethodHandler(
+                value,
+                changeTracker,
+                markChanged,
+              )
             }
 
             // Handle iterator methods for Map and Set
-            const iteratorMethods = new Set([
-              `entries`,
-              `keys`,
-              `values`,
-              `forEach`,
-              Symbol.iterator,
-            ])
-
-            if (iteratorMethods.has(methodName) || prop === Symbol.iterator) {
-              return function (this: unknown, ...args: Array<unknown>) {
-                const result = value.apply(changeTracker.copy_, args)
-
-                // For forEach, we need to wrap the callback to track changes
-                if (methodName === `forEach`) {
-                  const callback = args[0]
-                  if (typeof callback === `function`) {
-                    // Replace the original callback with our wrapped version
-                    const wrappedCallback = function (
-                      this: unknown,
-                      // eslint-disable-next-line
-                      value: unknown,
-                      key: unknown,
-                      collection: unknown
-                    ) {
-                      // Call the original callback
-                      const cbresult = callback.call(
-                        this,
-                        value,
-                        key,
-                        collection
-                      )
-                      // Mark as changed since the callback might have modified the value
-                      markChanged(changeTracker)
-                      return cbresult
-                    }
-                    // Call forEach with our wrapped callback
-                    return value.apply(ptarget, [
-                      wrappedCallback,
-                      ...args.slice(1),
-                    ])
-                  }
-                }
-
-                // For iterators (entries, keys, values, Symbol.iterator)
-                if (
-                  methodName === `entries` ||
-                  methodName === `values` ||
-                  methodName === Symbol.iterator.toString() ||
-                  prop === Symbol.iterator
-                ) {
-                  // If it's an iterator, we need to wrap the returned iterator
-                  // to track changes when the values are accessed and potentially modified
-                  const originalIterator = result
-
-                  // For values() iterator on Maps, we need to create a value-to-key mapping
-                  const valueToKeyMap = new Map()
-                  if (methodName === `values` && ptarget instanceof Map) {
-                    // Build a mapping from value to key for reverse lookup
-                    // Use the copy_ (which is the current state) to build the mapping
-                    for (const [
-                      key,
-                      mapValue,
-                    ] of changeTracker.copy_.entries()) {
-                      valueToKeyMap.set(mapValue, key)
-                    }
-                  }
-
-                  // For Set iterators, we need to create an original-to-modified mapping
-                  const originalToModifiedMap = new Map()
-                  if (ptarget instanceof Set) {
-                    // Initialize with original values
-                    for (const setValue of changeTracker.copy_.values()) {
-                      originalToModifiedMap.set(setValue, setValue)
-                    }
-                  }
-
-                  // Create a proxy for the iterator that will mark changes when next() is called
-                  return {
-                    next() {
-                      const nextResult = originalIterator.next()
-
-                      // If we have a value and it's an object, we need to track it
-                      if (
-                        !nextResult.done &&
-                        nextResult.value &&
-                        typeof nextResult.value === `object`
-                      ) {
-                        // For entries, the value is a [key, value] pair
-                        if (
-                          methodName === `entries` &&
-                          Array.isArray(nextResult.value) &&
-                          nextResult.value.length === 2
-                        ) {
-                          // The value is at index 1 in the [key, value] pair
-                          if (
-                            nextResult.value[1] &&
-                            typeof nextResult.value[1] === `object`
-                          ) {
-                            const mapKey = nextResult.value[0]
-                            // Create a special parent tracker that knows how to update the Map
-                            const mapParent = {
-                              tracker: changeTracker,
-                              prop: mapKey,
-                              updateMap: (newValue: unknown) => {
-                                // Update the Map in the copy
-                                if (changeTracker.copy_ instanceof Map) {
-                                  changeTracker.copy_.set(mapKey, newValue)
-                                }
-                              },
-                            }
-
-                            // Create a proxy for the value and replace it in the result
-                            const { proxy: valueProxy } =
-                              memoizedCreateChangeProxy(
-                                nextResult.value[1],
-                                mapParent
-                              )
-                            nextResult.value[1] = valueProxy
-                          }
-                        } else if (
-                          methodName === `values` ||
-                          methodName === Symbol.iterator.toString() ||
-                          prop === Symbol.iterator
-                        ) {
-                          // If the value is an object, create a proxy for it
-                          if (
-                            typeof nextResult.value === `object` &&
-                            nextResult.value !== null
-                          ) {
-                            // For Map values(), try to find the key using our mapping
-                            if (
-                              methodName === `values` &&
-                              ptarget instanceof Map
-                            ) {
-                              const mapKey = valueToKeyMap.get(nextResult.value)
-                              if (mapKey !== undefined) {
-                                // Create a special parent tracker for this Map value
-                                const mapParent = {
-                                  tracker: changeTracker,
-                                  prop: mapKey,
-                                  updateMap: (newValue: unknown) => {
-                                    // Update the Map in the copy
-                                    if (changeTracker.copy_ instanceof Map) {
-                                      changeTracker.copy_.set(mapKey, newValue)
-                                    }
-                                  },
-                                }
-
-                                const { proxy: valueProxy } =
-                                  memoizedCreateChangeProxy(
-                                    nextResult.value,
-                                    mapParent
-                                  )
-                                nextResult.value = valueProxy
-                              }
-                            } else if (ptarget instanceof Set) {
-                              // For Set, we need to track modifications and update the Set accordingly
-                              const setOriginalValue = nextResult.value
-                              const setParent = {
-                                tracker: changeTracker,
-                                prop: setOriginalValue, // Use the original value as the prop
-                                updateSet: (newValue: unknown) => {
-                                  // Update the Set in the copy by removing old value and adding new one
-                                  if (changeTracker.copy_ instanceof Set) {
-                                    changeTracker.copy_.delete(setOriginalValue)
-                                    changeTracker.copy_.add(newValue)
-                                    // Update our mapping for future iterations
-                                    originalToModifiedMap.set(
-                                      setOriginalValue,
-                                      newValue
-                                    )
-                                  }
-                                },
-                              }
-
-                              const { proxy: valueProxy } =
-                                memoizedCreateChangeProxy(
-                                  nextResult.value,
-                                  setParent
-                                )
-                              nextResult.value = valueProxy
-                            } else {
-                              // For other cases, use a symbol as a placeholder
-                              const tempKey = Symbol(`iterator-value`)
-                              const { proxy: valueProxy } =
-                                memoizedCreateChangeProxy(nextResult.value, {
-                                  tracker: changeTracker,
-                                  prop: tempKey,
-                                })
-                              nextResult.value = valueProxy
-                            }
-                          }
-                        }
-                      }
-
-                      return nextResult
-                    },
-                    [Symbol.iterator]() {
-                      return this
-                    },
-                  }
-                }
-
-                return result
-              }
+            const iteratorHandler = createMapSetIteratorHandler(
+              methodName,
+              prop,
+              value,
+              ptarget,
+              changeTracker,
+              memoizedCreateChangeProxy,
+              markChanged,
+            )
+            if (iteratorHandler) {
+              return iteratorHandler
             }
           }
           return value.bind(ptarget)
         }
 
         // If the value is an object (but not Date, RegExp, or Temporal), create a proxy for it
-        if (
-          value &&
-          typeof value === `object` &&
-          !((value as any) instanceof Date) &&
-          !((value as any) instanceof RegExp) &&
-          !isTemporal(value)
-        ) {
+        if (isProxiableObject(value)) {
           // Create a parent reference for the nested object
           const nestedParent = {
             tracker: changeTracker,
@@ -666,7 +908,7 @@ export function createChangeProxy<
           // Create a proxy for the nested object
           const { proxy: nestedProxy } = memoizedCreateChangeProxy(
             originalValue,
-            nestedParent
+            nestedParent,
           )
 
           // Cache the proxy
@@ -684,7 +926,7 @@ export function createChangeProxy<
           `set called for property ${String(prop)}, current:`,
           currentValue,
           `new:`,
-          value
+          value,
         )
 
         // Only track the change if the value is actually different
@@ -699,7 +941,7 @@ export function createChangeProxy<
             `original:`,
             originalValue,
             `isRevertToOriginal:`,
-            isRevertToOriginal
+            isRevertToOriginal,
           )
 
           if (isRevertToOriginal) {
@@ -752,21 +994,31 @@ export function createChangeProxy<
         return true
       },
 
-      defineProperty(_ptarget, prop, descriptor) {
-        // const result = Reflect.defineProperty(
-        //   changeTracker.copy_,
-        //   prop,
-        //   descriptor
-        // )
-        // if (result) {
-        if (`value` in descriptor) {
+      defineProperty(ptarget, prop, descriptor) {
+        // Forward the defineProperty to the target to maintain Proxy invariants
+        // This allows Object.seal() and Object.freeze() to work on the proxy
+        const result = Reflect.defineProperty(ptarget, prop, descriptor)
+        if (result && `value` in descriptor) {
           changeTracker.copy_[prop as keyof T] = deepClone(descriptor.value)
           changeTracker.assigned_[prop.toString()] = true
           markChanged(changeTracker)
         }
-        // }
-        // return result
-        return true
+        return result
+      },
+
+      getOwnPropertyDescriptor(ptarget, prop) {
+        // Forward to target to maintain Proxy invariants for seal/freeze
+        return Reflect.getOwnPropertyDescriptor(ptarget, prop)
+      },
+
+      preventExtensions(ptarget) {
+        // Forward to target to allow Object.seal() and Object.preventExtensions()
+        return Reflect.preventExtensions(ptarget)
+      },
+
+      isExtensible(ptarget) {
+        // Forward to target to maintain consistency
+        return Reflect.isExtensible(ptarget)
       },
 
       deleteProperty(dobj, prop) {
@@ -778,33 +1030,36 @@ export function createChangeProxy<
           const hadPropertyInOriginal =
             stringProp in changeTracker.originalObject
 
-          // Delete the property from the copy
-          // Use type assertion to tell TypeScript this is allowed
-          delete (changeTracker.copy_ as Record<string | symbol, unknown>)[prop]
-
-          // If the property didn't exist in the original object, removing it
-          // should revert to the original state
-          if (!hadPropertyInOriginal) {
-            delete changeTracker.copy_[stringProp]
-            delete changeTracker.assigned_[stringProp]
-
-            // If this is the last change and we're not a nested object,
-            // mark the object as unmodified
-            if (
-              Object.keys(changeTracker.assigned_).length === 0 &&
-              Object.getOwnPropertySymbols(changeTracker.assigned_).length === 0
-            ) {
-              changeTracker.modified = false
+          // Forward the delete to the target using Reflect
+          // This respects Object.seal/preventExtensions constraints
+          const result = Reflect.deleteProperty(dobj, prop)
+
+          if (result) {
+            // If the property didn't exist in the original object, removing it
+            // should revert to the original state
+            if (!hadPropertyInOriginal) {
+              delete changeTracker.assigned_[stringProp]
+
+              // If this is the last change and we're not a nested object,
+              // mark the object as unmodified
+              if (
+                Object.keys(changeTracker.assigned_).length === 0 &&
+                Object.getOwnPropertySymbols(changeTracker.assigned_).length ===
+                  0
+              ) {
+                changeTracker.modified = false
+              } else {
+                // We still have changes, keep as modified
+                changeTracker.modified = true
+              }
             } else {
-              // We still have changes, keep as modified
-              changeTracker.modified = true
+              // Mark this property as deleted
+              changeTracker.assigned_[stringProp] = false
+              markChanged(changeTracker)
             }
-          } else {
-            // Mark this property as deleted
-            changeTracker.assigned_[stringProp] = false
-            changeTracker.copy_[stringProp as keyof T] = undefined as T[keyof T]
-            markChanged(changeTracker)
           }
+
+          return result
         }
 
         return true
@@ -818,7 +1073,9 @@ export function createChangeProxy<
   }
 
   // Create a proxy for the target object
-  const proxy = createObjectProxy(target)
+  // Use the unfrozen copy_ as the proxy target to avoid Proxy invariant violations
+  // when the original target is frozen (e.g., from Immer)
+  const proxy = createObjectProxy(changeTracker.copy_ as unknown as T)
 
   // Return the proxy and a function to get the changes
   return {
@@ -871,7 +1128,7 @@ export function createChangeProxy<
  * @returns An object containing the array of proxies and a function to get all changes
  */
 export function createArrayChangeProxy<T extends object>(
-  targets: Array<T>
+  targets: Array<T>,
 ): {
   proxies: Array<T>
   getChanges: () => Array<Record<string | symbol, unknown>>
@@ -894,7 +1151,7 @@ export function createArrayChangeProxy<T extends object>(
  */
 export function withChangeTracking<T extends object>(
   target: T,
-  callback: (proxy: T) => void
+  callback: (proxy: T) => void,
 ): Record<string | symbol, unknown> {
   const { proxy, getChanges } = createChangeProxy(target)
 
@@ -913,7 +1170,7 @@ export function withChangeTracking<T extends object>(
  */
 export function withArrayChangeTracking<T extends object>(
   targets: Array<T>,
-  callback: (proxies: Array<T>) => void
+  callback: (proxies: Array<T>) => void,
 ): Array<Record<string | symbol, unknown>> {
   const { proxies, getChanges } = createArrayChangeProxy(targets)
 
diff --git a/packages/db/src/query/builder/functions.ts b/packages/db/src/query/builder/functions.ts
index 402c6de97..887c1468d 100644
--- a/packages/db/src/query/builder/functions.ts
+++ b/packages/db/src/query/builder/functions.ts
@@ -1,8 +1,8 @@
-import { Aggregate, Func } from "../ir"
-import { toExpression } from "./ref-proxy.js"
-import type { BasicExpression } from "../ir"
-import type { RefProxy } from "./ref-proxy.js"
-import type { RefLeaf } from "./types.js"
+import { Aggregate, Func } from '../ir'
+import { toExpression } from './ref-proxy.js'
+import type { BasicExpression } from '../ir'
+import type { RefProxy } from './ref-proxy.js'
+import type { RefLeaf } from './types.js'
 
 type StringRef =
   | RefLeaf<string>
@@ -53,10 +53,10 @@ type ExtractType<T> =
 // Helper type to determine aggregate return type based on input nullability
 type AggregateReturnType<T> =
   ExtractType<T> extends infer U
-    ? U extends number | undefined | null | Date | bigint
+    ? U extends number | undefined | null | Date | bigint | string
       ? Aggregate<U>
-      : Aggregate<number | undefined | null | Date | bigint>
-    : Aggregate<number | undefined | null | Date | bigint>
+      : Aggregate<number | undefined | null | Date | bigint | string>
+    : Aggregate<number | undefined | null | Date | bigint | string>
 
 // Helper type to determine string function return type based on input nullability
 type StringFunctionReturnType<T> =
@@ -114,11 +114,11 @@ type BinaryNumericReturnType<T1, T2> =
 
 export function eq<T>(
   left: ComparisonOperand<T>,
-  right: ComparisonOperand<T>
+  right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
 export function eq<T extends string | number | boolean>(
   left: ComparisonOperandPrimitive<T>,
-  right: ComparisonOperandPrimitive<T>
+  right: ComparisonOperandPrimitive<T>,
 ): BasicExpression<boolean>
 export function eq<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>
 export function eq(left: any, right: any): BasicExpression<boolean> {
@@ -127,11 +127,11 @@ export function eq(left: any, right: any): BasicExpression<boolean> {
 
 export function gt<T>(
   left: ComparisonOperand<T>,
-  right: ComparisonOperand<T>
+  right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
 export function gt<T extends string | number>(
   left: ComparisonOperandPrimitive<T>,
-  right: ComparisonOperandPrimitive<T>
+  right: ComparisonOperandPrimitive<T>,
 ): BasicExpression<boolean>
 export function gt<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>
 export function gt(left: any, right: any): BasicExpression<boolean> {
@@ -140,11 +140,11 @@ export function gt(left: any, right: any): BasicExpression<boolean> {
 
 export function gte<T>(
   left: ComparisonOperand<T>,
-  right: ComparisonOperand<T>
+  right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
 export function gte<T extends string | number>(
   left: ComparisonOperandPrimitive<T>,
-  right: ComparisonOperandPrimitive<T>
+  right: ComparisonOperandPrimitive<T>,
 ): BasicExpression<boolean>
 export function gte<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>
 export function gte(left: any, right: any): BasicExpression<boolean> {
@@ -153,11 +153,11 @@ export function gte(left: any, right: any): BasicExpression<boolean> {
 
 export function lt<T>(
   left: ComparisonOperand<T>,
-  right: ComparisonOperand<T>
+  right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
 export function lt<T extends string | number>(
   left: ComparisonOperandPrimitive<T>,
-  right: ComparisonOperandPrimitive<T>
+  right: ComparisonOperandPrimitive<T>,
 ): BasicExpression<boolean>
 export function lt<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>
 export function lt(left: any, right: any): BasicExpression<boolean> {
@@ -166,11 +166,11 @@ export function lt(left: any, right: any): BasicExpression<boolean> {
 
 export function lte<T>(
   left: ComparisonOperand<T>,
-  right: ComparisonOperand<T>
+  right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
 export function lte<T extends string | number>(
   left: ComparisonOperandPrimitive<T>,
-  right: ComparisonOperandPrimitive<T>
+  right: ComparisonOperandPrimitive<T>,
 ): BasicExpression<boolean>
 export function lte<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>
 export function lte(left: any, right: any): BasicExpression<boolean> {
@@ -180,7 +180,7 @@ export function lte(left: any, right: any): BasicExpression<boolean> {
 // Overloads for and() - support 2 or more arguments
 export function and(
   left: ExpressionLike,
-  right: ExpressionLike
+  right: ExpressionLike,
 ): BasicExpression<boolean>
 export function and(
   left: ExpressionLike,
@@ -195,14 +195,14 @@ export function and(
   const allArgs = [left, right, ...rest]
   return new Func(
     `and`,
-    allArgs.map((arg) => toExpression(arg))
+    allArgs.map((arg) => toExpression(arg)),
   )
 }
 
 // Overloads for or() - support 2 or more arguments
 export function or(
   left: ExpressionLike,
-  right: ExpressionLike
+  right: ExpressionLike,
 ): BasicExpression<boolean>
 export function or(
   left: ExpressionLike,
@@ -217,7 +217,7 @@ export function or(
   const allArgs = [left, right, ...rest]
   return new Func(
     `or`,
-    allArgs.map((arg) => toExpression(arg))
+    allArgs.map((arg) => toExpression(arg)),
   )
 }
 
@@ -236,14 +236,14 @@ export function isNull(value: ExpressionLike): BasicExpression<boolean> {
 
 export function inArray(
   value: ExpressionLike,
-  array: ExpressionLike
+  array: ExpressionLike,
 ): BasicExpression<boolean> {
   return new Func(`in`, [toExpression(value), toExpression(array)])
 }
 
 export function like(
   left: StringLike,
-  right: StringLike
+  right: StringLike,
 ): BasicExpression<boolean>
 export function like(left: any, right: any): BasicExpression<boolean> {
   return new Func(`like`, [toExpression(left), toExpression(right)])
@@ -251,7 +251,7 @@ export function like(left: any, right: any): BasicExpression<boolean> {
 
 export function ilike(
   left: StringLike,
-  right: StringLike
+  right: StringLike,
 ): BasicExpression<boolean> {
   return new Func(`ilike`, [toExpression(left), toExpression(right)])
 }
@@ -259,19 +259,19 @@ export function ilike(
 // Functions
 
 export function upper<T extends ExpressionLike>(
-  arg: T
+  arg: T,
 ): StringFunctionReturnType<T> {
   return new Func(`upper`, [toExpression(arg)]) as StringFunctionReturnType<T>
 }
 
 export function lower<T extends ExpressionLike>(
-  arg: T
+  arg: T,
 ): StringFunctionReturnType<T> {
   return new Func(`lower`, [toExpression(arg)]) as StringFunctionReturnType<T>
 }
 
 export function length<T extends ExpressionLike>(
-  arg: T
+  arg: T,
 ): NumericFunctionReturnType<T> {
   return new Func(`length`, [toExpression(arg)]) as NumericFunctionReturnType<T>
 }
@@ -281,20 +281,20 @@ export function concat(
 ): BasicExpression<string> {
   return new Func(
     `concat`,
-    args.map((arg) => toExpression(arg))
+    args.map((arg) => toExpression(arg)),
   )
 }
 
 export function coalesce(...args: Array<ExpressionLike>): BasicExpression<any> {
   return new Func(
     `coalesce`,
-    args.map((arg) => toExpression(arg))
+    args.map((arg) => toExpression(arg)),
   )
 }
 
 export function add<T1 extends ExpressionLike, T2 extends ExpressionLike>(
   left: T1,
-  right: T2
+  right: T2,
 ): BinaryNumericReturnType<T1, T2> {
   return new Func(`add`, [
     toExpression(left),
@@ -337,3 +337,42 @@ export const comparisonFunctions = [
   `like`,
   `ilike`,
 ] as const
+
+/**
+ * All supported operator names in TanStack DB expressions
+ */
+export const operators = [
+  // Comparison operators
+  `eq`,
+  `gt`,
+  `gte`,
+  `lt`,
+  `lte`,
+  `in`,
+  `like`,
+  `ilike`,
+  // Logical operators
+  `and`,
+  `or`,
+  `not`,
+  // Null checking
+  `isNull`,
+  `isUndefined`,
+  // String functions
+  `upper`,
+  `lower`,
+  `length`,
+  `concat`,
+  // Numeric functions
+  `add`,
+  // Utility functions
+  `coalesce`,
+  // Aggregate functions
+  `count`,
+  `avg`,
+  `sum`,
+  `min`,
+  `max`,
+] as const
+
+export type OperatorName = (typeof operators)[number]
diff --git a/packages/db/src/query/builder/index.ts b/packages/db/src/query/builder/index.ts
index f6b52e5ed..dcdfe6c0e 100644
--- a/packages/db/src/query/builder/index.ts
+++ b/packages/db/src/query/builder/index.ts
@@ -1,4 +1,4 @@
-import { CollectionImpl } from "../../collection/index.js"
+import { CollectionImpl } from '../../collection/index.js'
 import {
   Aggregate as AggregateExpr,
   CollectionRef,
@@ -7,16 +7,22 @@ import {
   QueryRef,
   Value as ValueExpr,
   isExpressionLike,
-} from "../ir.js"
+} from '../ir.js'
 import {
   InvalidSourceError,
+  InvalidSourceTypeError,
+  InvalidWhereExpressionError,
   JoinConditionMustBeEqualityError,
   OnlyOneSourceAllowedError,
   QueryMustHaveFromClauseError,
   SubQueryMustHaveFromClauseError,
-} from "../../errors.js"
-import { createRefProxy, toExpression } from "./ref-proxy.js"
-import type { NamespacedRow, SingleResult } from "../../types.js"
+} from '../../errors.js'
+import {
+  createRefProxy,
+  createRefProxyWithSelected,
+  toExpression,
+} from './ref-proxy.js'
+import type { NamespacedRow, SingleResult } from '../../types.js'
 import type {
   Aggregate,
   BasicExpression,
@@ -24,10 +30,12 @@ import type {
   OrderBy,
   OrderByDirection,
   QueryIR,
-} from "../ir.js"
+} from '../ir.js'
 import type {
   CompareOptions,
   Context,
+  FunctionalHavingRow,
+  GetResult,
   GroupByCallback,
   JoinOnCallback,
   MergeContextForJoinCallback,
@@ -41,7 +49,7 @@ import type {
   Source,
   WhereCallback,
   WithResult,
-} from "./types.js"
+} from './types.js'
 
 export class BaseQueryBuilder<TContext extends Context = Context> {
   private readonly query: Partial<QueryIR> = {}
@@ -58,15 +66,40 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    */
   private _createRefForSource<TSource extends Source>(
     source: TSource,
-    context: string
+    context: string,
   ): [string, CollectionRef | QueryRef] {
-    if (Object.keys(source).length !== 1) {
+    // Validate source is a plain object (not null, array, string, etc.)
+    // We use try-catch to handle null/undefined gracefully
+    let keys: Array<string>
+    try {
+      keys = Object.keys(source)
+    } catch {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      const type = source === null ? `null` : `undefined`
+      throw new InvalidSourceTypeError(context, type)
+    }
+
+    // Check if it's an array (arrays pass Object.keys but aren't valid sources)
+    if (Array.isArray(source)) {
+      throw new InvalidSourceTypeError(context, `array`)
+    }
+
+    // Validate exactly one key
+    if (keys.length !== 1) {
+      if (keys.length === 0) {
+        throw new InvalidSourceTypeError(context, `empty object`)
+      }
+      // Check if it looks like a string was passed (has numeric keys)
+      if (keys.every((k) => !isNaN(Number(k)))) {
+        throw new InvalidSourceTypeError(context, `string`)
+      }
       throw new OnlyOneSourceAllowedError(context)
     }
 
-    const alias = Object.keys(source)[0]!
+    const alias = keys[0]!
     const sourceValue = source[alias]
 
+    // Validate the value is a Collection or QueryBuilder
     let ref: CollectionRef | QueryRef
 
     if (sourceValue instanceof CollectionImpl) {
@@ -101,7 +134,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    * ```
    */
   from<TSource extends Source>(
-    source: TSource
+    source: TSource,
   ): QueryBuilder<{
     baseSchema: SchemaFromSource<TSource>
     schema: SchemaFromSource<TSource>
@@ -151,7 +184,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
     >,
-    type: TJoinType = `left` as TJoinType
+    type: TJoinType = `left` as TJoinType,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, TJoinType>
   > {
@@ -217,7 +250,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     source: TSource,
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
-    >
+    >,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `left`>
   > {
@@ -243,7 +276,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     source: TSource,
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
-    >
+    >,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `right`>
   > {
@@ -269,7 +302,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     source: TSource,
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
-    >
+    >,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `inner`>
   > {
@@ -295,7 +328,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     source: TSource,
     onCallback: JoinOnCallback<
       MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
-    >
+    >,
   ): QueryBuilder<
     MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `full`>
   > {
@@ -335,6 +368,13 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
     const expression = callback(refProxy)
 
+    // Validate that the callback returned a valid expression
+    // This catches common mistakes like using JavaScript comparison operators (===, !==, etc.)
+    // which return boolean primitives instead of expression objects
+    if (!isExpressionLike(expression)) {
+      throw new InvalidWhereExpressionError(getValueTypeName(expression))
+    }
+
     const existingWhere = this.query.where || []
 
     return new BaseQueryBuilder({
@@ -373,9 +413,21 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    */
   having(callback: WhereCallback<TContext>): QueryBuilder<TContext> {
     const aliases = this._getCurrentAliases()
-    const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
+    // Add $selected namespace if SELECT clause exists (either regular or functional)
+    const refProxy = (
+      this.query.select || this.query.fnSelect
+        ? createRefProxyWithSelected(aliases)
+        : createRefProxy(aliases)
+    ) as RefsForContext<TContext>
     const expression = callback(refProxy)
 
+    // Validate that the callback returned a valid expression
+    // This catches common mistakes like using JavaScript comparison operators (===, !==, etc.)
+    // which return boolean primitives instead of expression objects
+    if (!isExpressionLike(expression)) {
+      throw new InvalidWhereExpressionError(getValueTypeName(expression))
+    }
+
     const existingHaving = this.query.having || []
 
     return new BaseQueryBuilder({
@@ -419,7 +471,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    * ```
    */
   select<TSelectObject extends SelectObject>(
-    callback: (refs: RefsForContext<TContext>) => TSelectObject
+    callback: (refs: RefsForContext<TContext>) => TSelectObject,
   ): QueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelectObject>>> {
     const aliases = this._getCurrentAliases()
     const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
@@ -461,19 +513,24 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    */
   orderBy(
     callback: OrderByCallback<TContext>,
-    options: OrderByDirection | OrderByOptions = `asc`
+    options: OrderByDirection | OrderByOptions = `asc`,
   ): QueryBuilder<TContext> {
     const aliases = this._getCurrentAliases()
-    const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
+    // Add $selected namespace if SELECT clause exists (either regular or functional)
+    const refProxy = (
+      this.query.select || this.query.fnSelect
+        ? createRefProxyWithSelected(aliases)
+        : createRefProxy(aliases)
+    ) as RefsForContext<TContext>
     const result = callback(refProxy)
 
     const opts: CompareOptions =
       typeof options === `string`
-        ? { direction: options, nulls: `first`, stringSort: `locale` }
+        ? { direction: options, nulls: `first` }
         : {
             direction: options.direction ?? `asc`,
             nulls: options.nulls ?? `first`,
-            stringSort: options.stringSort ?? `locale`,
+            stringSort: options.stringSort,
             locale:
               options.stringSort === `locale` ? options.locale : undefined,
             localeOptions:
@@ -691,7 +748,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
        * ```
        */
       select<TFuncSelectResult>(
-        callback: (row: TContext[`schema`]) => TFuncSelectResult
+        callback: (row: TContext[`schema`]) => TFuncSelectResult,
       ): QueryBuilder<WithResult<TContext, TFuncSelectResult>> {
         return new BaseQueryBuilder({
           ...builder.query,
@@ -715,7 +772,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
        * ```
        */
       where(
-        callback: (row: TContext[`schema`]) => any
+        callback: (row: TContext[`schema`]) => any,
       ): QueryBuilder<TContext> {
         return new BaseQueryBuilder({
           ...builder.query,
@@ -729,7 +786,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
        * Filter grouped rows using a function that operates on each aggregated row
        * Warning: This cannot be optimized by the query compiler
        *
-       * @param callback - A function that receives an aggregated row and returns a boolean
+       * @param callback - A function that receives an aggregated row (with $selected when select() was called) and returns a boolean
        * @returns A QueryBuilder with functional having filter applied
        *
        * @example
@@ -738,11 +795,12 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
        * query
        *   .from({ posts: postsCollection })
        *   .groupBy(({posts}) => posts.userId)
-       *   .fn.having(row => row.count > 5)
+       *   .select(({posts}) => ({ userId: posts.userId, count: count(posts.id) }))
+       *   .fn.having(({ $selected }) => $selected.count > 5)
        * ```
        */
       having(
-        callback: (row: TContext[`schema`]) => any
+        callback: (row: FunctionalHavingRow<TContext>) => any,
       ): QueryBuilder<TContext> {
         return new BaseQueryBuilder({
           ...builder.query,
@@ -763,6 +821,14 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   }
 }
 
+// Helper to get a descriptive type name for error messages
+function getValueTypeName(value: unknown): string {
+  if (value === null) return `null`
+  if (value === undefined) return `undefined`
+  if (typeof value === `object`) return `object`
+  return typeof value
+}
+
 // Helper to ensure we have a BasicExpression/Aggregate for a value
 function toExpr(value: any): BasicExpression | Aggregate {
   if (value === undefined) return toExpression(null)
@@ -803,7 +869,7 @@ function buildNestedSelect(obj: any): any {
 // Internal function to build a query from a callback
 // used by liveQueryCollectionOptions.query
 export function buildQuery<TContext extends Context>(
-  fn: (builder: InitialQueryBuilder) => QueryBuilder<TContext>
+  fn: (builder: InitialQueryBuilder) => QueryBuilder<TContext>,
 ): QueryIR {
   const result = fn(new BaseQueryBuilder())
   return getQueryIR(result)
@@ -811,7 +877,7 @@ export function buildQuery<TContext extends Context>(
 
 // Internal function to get the QueryIR from a builder
 export function getQueryIR(
-  builder: BaseQueryBuilder | QueryBuilder<any> | InitialQueryBuilder
+  builder: BaseQueryBuilder | QueryBuilder<any> | InitialQueryBuilder,
 ): QueryIR {
   return (builder as unknown as BaseQueryBuilder)._getQuery()
 }
@@ -838,6 +904,9 @@ export type ExtractContext<T> =
       ? TContext
       : never
 
+// Helper type to extract the result type from a QueryBuilder (similar to Zod's z.infer)
+export type QueryResult<T> = GetResult<ExtractContext<T>>
+
 // Export the types from types.ts for convenience
 export type {
   Context,
@@ -845,4 +914,4 @@ export type {
   GetResult,
   RefLeaf as Ref,
   InferResultType,
-} from "./types.js"
+} from './types.js'
diff --git a/packages/db/src/query/builder/ref-proxy.ts b/packages/db/src/query/builder/ref-proxy.ts
index 0b2296146..b3f79ef51 100644
--- a/packages/db/src/query/builder/ref-proxy.ts
+++ b/packages/db/src/query/builder/ref-proxy.ts
@@ -1,6 +1,6 @@
-import { PropRef, Value } from "../ir.js"
-import type { BasicExpression } from "../ir.js"
-import type { RefLeaf } from "./types.js"
+import { PropRef, Value } from '../ir.js'
+import type { BasicExpression } from '../ir.js'
+import type { RefLeaf } from './types.js'
 
 export interface RefProxy<T = any> {
   /** @internal */
@@ -81,7 +81,7 @@ export function createSingleRowRefProxy<
  * Used in callbacks like where, select, etc. to create type-safe references
  */
 export function createRefProxy<T extends Record<string, any>>(
-  aliases: Array<string>
+  aliases: Array<string>,
 ): RefProxy<T> & T {
   const cache = new Map<string, any>()
   let accessId = 0 // Monotonic counter to record evaluation order
@@ -175,6 +175,96 @@ export function createRefProxy<T extends Record<string, any>>(
   return rootProxy
 }
 
+/**
+ * Creates a ref proxy with $selected namespace for SELECT fields
+ *
+ * Adds a $selected property that allows accessing SELECT fields via $selected.fieldName syntax.
+ * The $selected proxy creates paths like ['$selected', 'fieldName'] which directly reference
+ * the $selected property on the namespaced row.
+ *
+ * @param aliases - Array of table aliases to create proxies for
+ * @returns A ref proxy with table aliases and $selected namespace
+ */
+export function createRefProxyWithSelected<T extends Record<string, any>>(
+  aliases: Array<string>,
+): RefProxy<T> & T & { $selected: SingleRowRefProxy<any> } {
+  const baseProxy = createRefProxy(aliases)
+
+  // Create a proxy for $selected that prefixes all paths with '$selected'
+  const cache = new Map<string, any>()
+
+  function createSelectedProxy(path: Array<string>): any {
+    const pathKey = path.join(`.`)
+    if (cache.has(pathKey)) {
+      return cache.get(pathKey)
+    }
+
+    const proxy = new Proxy({} as any, {
+      get(target, prop, receiver) {
+        if (prop === `__refProxy`) return true
+        if (prop === `__path`) return [`$selected`, ...path]
+        if (prop === `__type`) return undefined
+        if (typeof prop === `symbol`) return Reflect.get(target, prop, receiver)
+
+        const newPath = [...path, String(prop)]
+        return createSelectedProxy(newPath)
+      },
+
+      has(target, prop) {
+        if (prop === `__refProxy` || prop === `__path` || prop === `__type`)
+          return true
+        return Reflect.has(target, prop)
+      },
+
+      ownKeys(target) {
+        return Reflect.ownKeys(target)
+      },
+
+      getOwnPropertyDescriptor(target, prop) {
+        if (prop === `__refProxy` || prop === `__path` || prop === `__type`) {
+          return { enumerable: false, configurable: true }
+        }
+        return Reflect.getOwnPropertyDescriptor(target, prop)
+      },
+    })
+
+    cache.set(pathKey, proxy)
+    return proxy
+  }
+
+  const wrappedSelectedProxy = createSelectedProxy([])
+
+  // Wrap the base proxy to also handle $selected access
+  return new Proxy(baseProxy, {
+    get(target, prop, receiver) {
+      if (prop === `$selected`) {
+        return wrappedSelectedProxy
+      }
+      return Reflect.get(target, prop, receiver)
+    },
+
+    has(target, prop) {
+      if (prop === `$selected`) return true
+      return Reflect.has(target, prop)
+    },
+
+    ownKeys(target) {
+      return [...Reflect.ownKeys(target), `$selected`]
+    },
+
+    getOwnPropertyDescriptor(target, prop) {
+      if (prop === `$selected`) {
+        return {
+          enumerable: true,
+          configurable: true,
+          value: wrappedSelectedProxy,
+        }
+      }
+      return Reflect.getOwnPropertyDescriptor(target, prop)
+    },
+  }) as RefProxy<T> & T & { $selected: SingleRowRefProxy<any> }
+}
+
 /**
  * Converts a value to an Expression
  * If it's a RefProxy, creates a Ref, otherwise creates a Value
diff --git a/packages/db/src/query/builder/types.ts b/packages/db/src/query/builder/types.ts
index de01f4be5..11360dd82 100644
--- a/packages/db/src/query/builder/types.ts
+++ b/packages/db/src/query/builder/types.ts
@@ -1,5 +1,5 @@
-import type { CollectionImpl } from "../../collection/index.js"
-import type { SingleResult } from "../../types.js"
+import type { CollectionImpl } from '../../collection/index.js'
+import type { SingleResult, StringCollationConfig } from '../../types.js'
 import type {
   Aggregate,
   BasicExpression,
@@ -7,8 +7,8 @@ import type {
   OrderByDirection,
   PropRef,
   Value,
-} from "../ir.js"
-import type { QueryBuilder } from "./index.js"
+} from '../ir.js'
+import type { QueryBuilder } from './index.js'
 
 /**
  * Context - The central state container for query builder operations
@@ -121,7 +121,7 @@ export type GetAliases<TContext extends Context> = keyof TContext[`schema`]
  * Example: `(refs) => eq(refs.users.age, 25)`
  */
 export type WhereCallback<TContext extends Context> = (
-  refs: RefsForContext<TContext>
+  refs: RefsForContext<TContext>,
 ) => any
 
 /**
@@ -290,7 +290,7 @@ type NeedsExtraction<T> = T extends
  * Example: `(refs) => refs.users.createdAt`
  */
 export type OrderByCallback<TContext extends Context> = (
-  refs: RefsForContext<TContext>
+  refs: RefsForContext<TContext>,
 ) => any
 
 /**
@@ -303,26 +303,7 @@ export type OrderByCallback<TContext extends Context> = (
 export type OrderByOptions = {
   direction?: OrderByDirection
   nulls?: `first` | `last`
-} & StringSortOpts
-
-/**
- * StringSortOpts - Options for string sorting behavior
- *
- * This discriminated union allows for two types of string sorting:
- * - **Lexical**: Simple character-by-character comparison (default)
- * - **Locale**: Locale-aware sorting with optional customization
- *
- * The union ensures that locale options are only available when locale sorting is selected.
- */
-export type StringSortOpts =
-  | {
-      stringSort?: `lexical`
-    }
-  | {
-      stringSort?: `locale`
-      locale?: string
-      localeOptions?: object
-    }
+} & StringCollationConfig
 
 /**
  * CompareOptions - Final resolved options for comparison operations
@@ -331,12 +312,9 @@ export type StringSortOpts =
  * to their concrete values. Unlike OrderByOptions, all fields are required
  * since defaults have been applied.
  */
-export type CompareOptions = {
+export type CompareOptions = StringCollationConfig & {
   direction: OrderByDirection
   nulls: `first` | `last`
-  stringSort: `lexical` | `locale`
-  locale?: string
-  localeOptions?: object
 }
 
 /**
@@ -348,7 +326,7 @@ export type CompareOptions = {
  * Example: `(refs) => refs.orders.status`
  */
 export type GroupByCallback<TContext extends Context> = (
-  refs: RefsForContext<TContext>
+  refs: RefsForContext<TContext>,
 ) => any
 
 /**
@@ -364,9 +342,29 @@ export type GroupByCallback<TContext extends Context> = (
  * Example: `(refs) => eq(refs.users.id, refs.orders.userId)`
  */
 export type JoinOnCallback<TContext extends Context> = (
-  refs: RefsForContext<TContext>
+  refs: RefsForContext<TContext>,
 ) => any
 
+/**
+ * FunctionalHavingRow - Type for the row parameter in functional having callbacks
+ *
+ * Functional having callbacks receive a namespaced row that includes:
+ * - Table data from the schema (when available)
+ * - $selected: The SELECT result fields (when select() has been called)
+ *
+ * After `select()` is called, this type includes `$selected` which provides access
+ * to the SELECT result fields via `$selected.fieldName` syntax.
+ *
+ * Note: When used with GROUP BY, functional having receives `{ $selected: ... }` with the
+ * aggregated SELECT results. When used without GROUP BY, it receives the full namespaced row
+ * which includes both table data and `$selected`.
+ *
+ * Example: `({ $selected }) => $selected.sessionCount > 2`
+ * Example (no GROUP BY): `(row) => row.user.salary > 70000 && row.$selected.user_count > 2`
+ */
+export type FunctionalHavingRow<TContext extends Context> = TContext[`schema`] &
+  (TContext[`result`] extends object ? { $selected: TContext[`result`] } : {})
+
 /**
  * RefProxyForContext - Creates ref proxies for all tables/collections in a query context
  *
@@ -386,6 +384,9 @@ export type JoinOnCallback<TContext extends Context> = (
  *
  * The logic prioritizes optional chaining by always placing `undefined` outside when
  * a type is both optional and nullable (e.g., `string | null | undefined`).
+ *
+ * After `select()` is called, this type also includes `$selected` which provides access
+ * to the SELECT result fields via `$selected.fieldName` syntax.
  */
 export type RefsForContext<TContext extends Context> = {
   [K in keyof TContext[`schema`]]: IsNonExactOptional<
@@ -393,11 +394,11 @@ export type RefsForContext<TContext extends Context> = {
   > extends true
     ? IsNonExactNullable<TContext[`schema`][K]> extends true
       ? // T is both non-exact optional and non-exact nullable (e.g., string | null | undefined)
-        // Extract the non-undefined and non-null part and place undefined outside
-        Ref<NonNullable<TContext[`schema`][K]>> | undefined
+          // Extract the non-undefined and non-null part and place undefined outside
+          Ref<NonNullable<TContext[`schema`][K]>> | undefined
       : // T is optional (T | undefined) but not exactly undefined, and not nullable
-        // Extract the non-undefined part and place undefined outside
-        Ref<NonUndefined<TContext[`schema`][K]>> | undefined
+          // Extract the non-undefined part and place undefined outside
+          Ref<NonUndefined<TContext[`schema`][K]>> | undefined
     : IsNonExactNullable<TContext[`schema`][K]> extends true
       ? // T is nullable (T | null) but not exactly null, and not optional
         // Extract the non-null part and place null outside
@@ -405,7 +406,9 @@ export type RefsForContext<TContext extends Context> = {
       : // T is exactly undefined, exactly null, or neither optional nor nullable
         // Wrap in RefProxy as-is (includes exact undefined, exact null, and normal types)
         Ref<TContext[`schema`][K]>
-}
+} & (TContext[`result`] extends object
+  ? { $selected: Ref<TContext[`result`]> }
+  : {})
 
 /**
  * Type Detection Helpers
@@ -530,6 +533,20 @@ export type RefLeaf<T = any> = { readonly [RefBrand]?: T }
 type WithoutRefBrand<T> =
   T extends Record<string, any> ? Omit<T, typeof RefBrand> : T
 
+/**
+ * PreserveSingleResultFlag - Conditionally includes the singleResult flag
+ *
+ * This helper type ensures the singleResult flag is only added to the context when it's
+ * explicitly true. It uses a non-distributive conditional (tuple wrapper) to prevent
+ * unexpected behavior when TFlag is a union type.
+ *
+ * @template TFlag - The singleResult flag value to check
+ * @returns { singleResult: true } if TFlag is true, otherwise {}
+ */
+type PreserveSingleResultFlag<TFlag> = [TFlag] extends [true]
+  ? { singleResult: true }
+  : {}
+
 /**
  * MergeContextWithJoinType - Creates a new context after a join operation
  *
@@ -551,6 +568,7 @@ type WithoutRefBrand<T> =
  * - `hasJoins`: Set to true
  * - `joinTypes`: Updated to track this join type
  * - `result`: Preserved from previous operations
+ * - `singleResult`: Preserved only if already true (via PreserveSingleResultFlag)
  */
 export type MergeContextWithJoinType<
   TContext extends Context,
@@ -574,8 +592,7 @@ export type MergeContextWithJoinType<
     [K in keyof TNewSchema & string]: TJoinType
   }
   result: TContext[`result`]
-  singleResult: TContext[`singleResult`] extends true ? true : false
-}
+} & PreserveSingleResultFlag<TContext[`singleResult`]>
 
 /**
  * ApplyJoinOptionalityToMergedSchema - Applies optionality rules when merging schemas
@@ -620,7 +637,7 @@ export type ApplyJoinOptionalityToMergedSchema<
   // Apply optionality to new schema based on join type
   [K in keyof TNewSchema]: TJoinType extends `left` | `full`
     ? // New table becomes optional for left and full joins
-      TNewSchema[K] | undefined
+        TNewSchema[K] | undefined
     : // New table is required for inner and right joins
       TNewSchema[K]
 }
diff --git a/packages/db/src/query/compiler/evaluators.ts b/packages/db/src/query/compiler/evaluators.ts
index 9304dfe2a..5e44e5bcd 100644
--- a/packages/db/src/query/compiler/evaluators.ts
+++ b/packages/db/src/query/compiler/evaluators.ts
@@ -2,10 +2,33 @@ import {
   EmptyReferencePathError,
   UnknownExpressionTypeError,
   UnknownFunctionError,
-} from "../../errors.js"
-import { normalizeValue } from "../../utils/comparison.js"
-import type { BasicExpression, Func, PropRef } from "../ir.js"
-import type { NamespacedRow } from "../../types.js"
+} from '../../errors.js'
+import { areValuesEqual, normalizeValue } from '../../utils/comparison.js'
+import type { BasicExpression, Func, PropRef } from '../ir.js'
+import type { NamespacedRow } from '../../types.js'
+
+/**
+ * Helper function to check if a value is null or undefined (represents UNKNOWN in 3-valued logic)
+ */
+function isUnknown(value: any): boolean {
+  return value === null || value === undefined
+}
+
+/**
+ * Converts a 3-valued logic result to a boolean for use in WHERE/HAVING filters.
+ * In SQL, UNKNOWN (null) values in WHERE clauses exclude rows, matching false behavior.
+ *
+ * @param result - The 3-valued logic result: true, false, or null (UNKNOWN)
+ * @returns true only if result is explicitly true, false otherwise
+ *
+ * Truth table:
+ * - true → true (include row)
+ * - false → false (exclude row)
+ * - null (UNKNOWN) → false (exclude row, matching SQL behavior)
+ */
+export function toBooleanPredicate(result: boolean | null): boolean {
+  return result === true
+}
 
 /**
  * Compiled expression evaluator function type
@@ -23,7 +46,7 @@ export type CompiledSingleRowExpression = (item: Record<string, unknown>) => any
  */
 export function compileExpression(
   expr: BasicExpression,
-  isSingleRow: boolean = false
+  isSingleRow: boolean = false,
 ): CompiledExpression | CompiledSingleRowExpression {
   const compiledFn = compileExpressionInternal(expr, isSingleRow)
   return compiledFn
@@ -33,7 +56,7 @@ export function compileExpression(
  * Compiles a single-row expression into an optimized evaluator function.
  */
 export function compileSingleRowExpression(
-  expr: BasicExpression
+  expr: BasicExpression,
 ): CompiledSingleRowExpression {
   const compiledFn = compileExpressionInternal(expr, true)
   return compiledFn as CompiledSingleRowExpression
@@ -44,7 +67,7 @@ export function compileSingleRowExpression(
  */
 function compileExpressionInternal(
   expr: BasicExpression,
-  isSingleRow: boolean
+  isSingleRow: boolean,
 ): (data: any) => any {
   switch (expr.type) {
     case `val`: {
@@ -72,12 +95,48 @@ function compileExpressionInternal(
  * Compiles a reference expression into an optimized evaluator
  */
 function compileRef(ref: PropRef): CompiledExpression {
-  const [tableAlias, ...propertyPath] = ref.path
+  const [namespace, ...propertyPath] = ref.path
 
-  if (!tableAlias) {
+  if (!namespace) {
     throw new EmptyReferencePathError()
   }
 
+  // Handle $selected namespace - references SELECT result fields
+  if (namespace === `$selected`) {
+    // Access $selected directly
+    if (propertyPath.length === 0) {
+      // Just $selected - return entire $selected object
+      return (namespacedRow) => (namespacedRow as any).$selected
+    } else if (propertyPath.length === 1) {
+      // Single property access - most common case
+      const prop = propertyPath[0]!
+      return (namespacedRow) => {
+        const selectResults = (namespacedRow as any).$selected
+        return selectResults?.[prop]
+      }
+    } else {
+      // Multiple property navigation (nested SELECT fields)
+      return (namespacedRow) => {
+        const selectResults = (namespacedRow as any).$selected
+        if (selectResults === undefined) {
+          return undefined
+        }
+
+        let value: any = selectResults
+        for (const prop of propertyPath) {
+          if (value == null) {
+            return value
+          }
+          value = value[prop]
+        }
+        return value
+      }
+    }
+  }
+
+  // Handle table alias namespace (existing logic)
+  const tableAlias = namespace
+
   // Pre-compile the property path navigation
   if (propertyPath.length === 0) {
     // Simple table reference
@@ -134,7 +193,7 @@ function compileSingleRowRef(ref: PropRef): CompiledSingleRowExpression {
 function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
   // Pre-compile all arguments using the appropriate compiler
   const compiledArgs = func.args.map((arg) =>
-    compileExpressionInternal(arg, isSingleRow)
+    compileExpressionInternal(arg, isSingleRow),
   )
 
   switch (func.name) {
@@ -145,7 +204,12 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
       return (data) => {
         const a = normalizeValue(argA(data))
         const b = normalizeValue(argB(data))
-        return a === b
+        // In 3-valued logic, any comparison with null/undefined returns UNKNOWN
+        if (isUnknown(a) || isUnknown(b)) {
+          return null
+        }
+        // Use areValuesEqual for proper Uint8Array/Buffer comparison
+        return areValuesEqual(a, b)
       }
     }
     case `gt`: {
@@ -154,6 +218,10 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
       return (data) => {
         const a = argA(data)
         const b = argB(data)
+        // In 3-valued logic, any comparison with null/undefined returns UNKNOWN
+        if (isUnknown(a) || isUnknown(b)) {
+          return null
+        }
         return a > b
       }
     }
@@ -163,6 +231,10 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
       return (data) => {
         const a = argA(data)
         const b = argB(data)
+        // In 3-valued logic, any comparison with null/undefined returns UNKNOWN
+        if (isUnknown(a) || isUnknown(b)) {
+          return null
+        }
         return a >= b
       }
     }
@@ -172,6 +244,10 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
       return (data) => {
         const a = argA(data)
         const b = argB(data)
+        // In 3-valued logic, any comparison with null/undefined returns UNKNOWN
+        if (isUnknown(a) || isUnknown(b)) {
+          return null
+        }
         return a < b
       }
     }
@@ -181,6 +257,10 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
       return (data) => {
         const a = argA(data)
         const b = argB(data)
+        // In 3-valued logic, any comparison with null/undefined returns UNKNOWN
+        if (isUnknown(a) || isUnknown(b)) {
+          return null
+        }
         return a <= b
       }
     }
@@ -188,25 +268,67 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
     // Boolean operators
     case `and`:
       return (data) => {
+        // 3-valued logic for AND:
+        // - false AND anything = false (short-circuit)
+        // - null AND false = false
+        // - null AND anything (except false) = null
+        // - anything (except false) AND null = null
+        // - true AND true = true
+        let hasUnknown = false
         for (const compiledArg of compiledArgs) {
-          if (!compiledArg(data)) {
+          const result = compiledArg(data)
+          if (result === false) {
             return false
           }
+          if (isUnknown(result)) {
+            hasUnknown = true
+          }
         }
+        // If we got here, no operand was false
+        // If any operand was null, return null (UNKNOWN)
+        if (hasUnknown) {
+          return null
+        }
+
         return true
       }
     case `or`:
       return (data) => {
+        // 3-valued logic for OR:
+        // - true OR anything = true (short-circuit)
+        // - null OR anything (except true) = null
+        // - false OR false = false
+        let hasUnknown = false
         for (const compiledArg of compiledArgs) {
-          if (compiledArg(data)) {
+          const result = compiledArg(data)
+          if (result === true) {
             return true
           }
+          if (isUnknown(result)) {
+            hasUnknown = true
+          }
+        }
+        // If we got here, no operand was true
+        // If any operand was null, return null (UNKNOWN)
+        if (hasUnknown) {
+          return null
         }
+
         return false
       }
     case `not`: {
       const arg = compiledArgs[0]!
-      return (data) => !arg(data)
+      return (data) => {
+        // 3-valued logic for NOT:
+        // - NOT null = null
+        // - NOT true = false
+        // - NOT false = true
+        const result = arg(data)
+        if (isUnknown(result)) {
+          return null
+        }
+        return !result
+      }
     }
 
     // Array operators
@@ -216,6 +338,10 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
       return (data) => {
         const value = valueEvaluator(data)
         const array = arrayEvaluator(data)
+        // In 3-valued logic, if the value is null/undefined, return UNKNOWN
+        if (isUnknown(value)) {
+          return null
+        }
         if (!Array.isArray(array)) {
           return false
         }
@@ -230,6 +356,10 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
       return (data) => {
         const value = valueEvaluator(data)
         const pattern = patternEvaluator(data)
+        // In 3-valued logic, if value or pattern is null/undefined, return UNKNOWN
+        if (isUnknown(value) || isUnknown(pattern)) {
+          return null
+        }
         return evaluateLike(value, pattern, false)
       }
     }
@@ -239,6 +369,10 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
       return (data) => {
         const value = valueEvaluator(data)
         const pattern = patternEvaluator(data)
+        // In 3-valued logic, if value or pattern is null/undefined, return UNKNOWN
+        if (isUnknown(value) || isUnknown(pattern)) {
+          return null
+        }
         return evaluateLike(value, pattern, true)
       }
     }
@@ -365,7 +499,7 @@ function compileFunction(func: Func, isSingleRow: boolean): (data: any) => any {
 function evaluateLike(
   value: any,
   pattern: any,
-  caseInsensitive: boolean
+  caseInsensitive: boolean,
 ): boolean {
   if (typeof value !== `string` || typeof pattern !== `string`) {
     return false
diff --git a/packages/db/src/query/compiler/expressions.ts b/packages/db/src/query/compiler/expressions.ts
index 821d9b708..f2856ed7e 100644
--- a/packages/db/src/query/compiler/expressions.ts
+++ b/packages/db/src/query/compiler/expressions.ts
@@ -1,59 +1,27 @@
-import { Func, PropRef, Value } from "../ir.js"
-import type { BasicExpression, OrderBy } from "../ir.js"
+import { Func, PropRef, Value } from '../ir.js'
+import type { BasicExpression, OrderBy } from '../ir.js'
 
 /**
- * Functions supported by the collection index system.
- * These are the only functions that can be used in WHERE clauses
- * that are pushed down to collection subscriptions for index optimization.
- */
-export const SUPPORTED_COLLECTION_FUNCS = new Set([
-  `eq`,
-  `gt`,
-  `lt`,
-  `gte`,
-  `lte`,
-  `and`,
-  `or`,
-  `in`,
-])
-
-/**
- * Determines if a WHERE clause can be converted to collection-compatible BasicExpression format.
- * This checks if the expression only uses functions supported by the collection index system.
+ * Normalizes a WHERE clause expression by removing table aliases from property references.
  *
- * @param whereClause - The WHERE clause to check
- * @returns True if the clause can be converted for collection index optimization
- */
-export function isConvertibleToCollectionFilter(
-  whereClause: BasicExpression<boolean>
-): boolean {
-  const tpe = whereClause.type
-  if (tpe === `func`) {
-    // Check if this function is supported
-    if (!SUPPORTED_COLLECTION_FUNCS.has(whereClause.name)) {
-      return false
-    }
-    // Recursively check all arguments
-    return whereClause.args.every((arg) =>
-      isConvertibleToCollectionFilter(arg as BasicExpression<boolean>)
-    )
-  }
-  return [`val`, `ref`].includes(tpe)
-}
-
-/**
- * Converts a WHERE clause to BasicExpression format compatible with collection indexes.
- * This function creates proper BasicExpression class instances that the collection
- * index system can understand.
+ * This function recursively traverses an expression tree and creates new BasicExpression
+ * instances with normalized paths. The main transformation is removing the collection alias
+ * from property reference paths (e.g., `['user', 'id']` becomes `['id']` when `collectionAlias`
+ * is `'user'`), which is needed when converting query-level expressions to collection-level
+ * expressions for subscriptions.
  *
- * @param whereClause - The WHERE clause to convert
- * @param collectionAlias - The alias of the collection being filtered
- * @returns The converted BasicExpression or null if conversion fails
+ * @param whereClause - The WHERE clause expression to normalize
+ * @param collectionAlias - The alias of the collection being filtered (to strip from paths)
+ * @returns A new BasicExpression with normalized paths
+ *
+ * @example
+ * // Input: ref with path ['user', 'id'] where collectionAlias is 'user'
+ * // Output: ref with path ['id']
  */
-export function convertToBasicExpression(
+export function normalizeExpressionPaths(
   whereClause: BasicExpression<boolean>,
-  collectionAlias: string
-): BasicExpression<boolean> | null {
+  collectionAlias: string,
+): BasicExpression<boolean> {
   const tpe = whereClause.type
   if (tpe === `val`) {
     return new Value(whereClause.value)
@@ -71,42 +39,29 @@ export function convertToBasicExpression(
     // Fallback for non-array paths
     return new PropRef(Array.isArray(path) ? path : [String(path)])
   } else {
-    // Check if this function is supported
-    if (!SUPPORTED_COLLECTION_FUNCS.has(whereClause.name)) {
-      return null
-    }
     // Recursively convert all arguments
     const args: Array<BasicExpression> = []
     for (const arg of whereClause.args) {
-      const convertedArg = convertToBasicExpression(
+      const convertedArg = normalizeExpressionPaths(
         arg as BasicExpression<boolean>,
-        collectionAlias
+        collectionAlias,
       )
-      if (convertedArg == null) {
-        return null
-      }
       args.push(convertedArg)
     }
     return new Func(whereClause.name, args)
   }
 }
 
-export function convertOrderByToBasicExpression(
+export function normalizeOrderByPaths(
   orderBy: OrderBy,
-  collectionAlias: string
+  collectionAlias: string,
 ): OrderBy {
   const normalizedOrderBy = orderBy.map((clause) => {
-    const basicExp = convertToBasicExpression(
+    const basicExp = normalizeExpressionPaths(
       clause.expression,
-      collectionAlias
+      collectionAlias,
     )
 
-    if (!basicExp) {
-      throw new Error(
-        `Failed to convert orderBy expression to a basic expression: ${clause.expression}`
-      )
-    }
-
     return {
       ...clause,
       expression: basicExp,
diff --git a/packages/db/src/query/compiler/group-by.ts b/packages/db/src/query/compiler/group-by.ts
index c37520b76..a20780696 100644
--- a/packages/db/src/query/compiler/group-by.ts
+++ b/packages/db/src/query/compiler/group-by.ts
@@ -1,20 +1,26 @@
-import { filter, groupBy, groupByOperators, map } from "@tanstack/db-ivm"
-import { Func, PropRef, getHavingExpression } from "../ir.js"
+import {
+  filter,
+  groupBy,
+  groupByOperators,
+  map,
+  serializeValue,
+} from '@tanstack/db-ivm'
+import { Func, PropRef, getHavingExpression } from '../ir.js'
 import {
   AggregateFunctionNotInSelectError,
   NonAggregateExpressionNotInGroupByError,
   UnknownHavingExpressionTypeError,
   UnsupportedAggregateFunctionError,
-} from "../../errors.js"
-import { compileExpression } from "./evaluators.js"
+} from '../../errors.js'
+import { compileExpression, toBooleanPredicate } from './evaluators.js'
 import type {
   Aggregate,
   BasicExpression,
   GroupBy,
   Having,
   Select,
-} from "../ir.js"
-import type { NamespacedAndKeyedStream, NamespacedRow } from "../../types.js"
+} from '../ir.js'
+import type { NamespacedAndKeyedStream, NamespacedRow } from '../../types.js'
 
 const { sum, count, avg, min, max } = groupByOperators
 
@@ -32,7 +38,7 @@ interface GroupBySelectMapping {
  */
 function validateAndCreateMapping(
   groupByClause: GroupBy,
-  selectClause?: Select
+  selectClause?: Select,
 ): GroupBySelectMapping {
   const selectToGroupByIndex = new Map<string, number>()
   const groupByExpressions = [...groupByClause]
@@ -50,7 +56,7 @@ function validateAndCreateMapping(
 
     // Non-aggregate expression must be in GROUP BY
     const groupIndex = groupByExpressions.findIndex((groupExpr) =>
-      expressionsEqual(expr, groupExpr)
+      expressionsEqual(expr, groupExpr),
     )
 
     if (groupIndex === -1) {
@@ -66,14 +72,14 @@ function validateAndCreateMapping(
 
 /**
  * Processes the GROUP BY clause with optional HAVING and SELECT
- * Works with the new __select_results structure from early SELECT processing
+ * Works with the new $selected structure from early SELECT processing
  */
 export function processGroupBy(
   pipeline: NamespacedAndKeyedStream,
   groupByClause: GroupBy,
   havingClauses?: Array<Having>,
   selectClause?: Select,
-  fnHavingClauses?: Array<(row: any) => any>
+  fnHavingClauses?: Array<(row: any) => any>,
 ): NamespacedAndKeyedStream {
   // Handle empty GROUP BY (single-group aggregation)
   if (groupByClause.length === 0) {
@@ -95,14 +101,14 @@ export function processGroupBy(
 
     // Apply the groupBy operator with single group
     pipeline = pipeline.pipe(
-      groupBy(keyExtractor, aggregates)
+      groupBy(keyExtractor, aggregates),
     ) as NamespacedAndKeyedStream
 
-    // Update __select_results to include aggregate values
+    // Update $selected to include aggregate values
     pipeline = pipeline.pipe(
       map(([, aggregatedRow]) => {
-        // Start with the existing __select_results from early SELECT processing
-        const selectResults = (aggregatedRow as any).__select_results || {}
+        // Start with the existing $selected from early SELECT processing
+        const selectResults = (aggregatedRow as any).$selected || {}
         const finalResults: Record<string, any> = { ...selectResults }
 
         if (selectClause) {
@@ -115,15 +121,15 @@ export function processGroupBy(
           }
         }
 
-        // Use a single key for the result and update __select_results
+        // Use a single key for the result and update $selected
         return [
           `single_group`,
           {
             ...aggregatedRow,
-            __select_results: finalResults,
+            $selected: finalResults,
           },
         ] as [unknown, Record<string, any>]
-      })
+      }),
     )
 
     // Apply HAVING clauses if present
@@ -132,16 +138,17 @@ export function processGroupBy(
         const havingExpression = getHavingExpression(havingClause)
         const transformedHavingClause = replaceAggregatesByRefs(
           havingExpression,
-          selectClause || {}
+          selectClause || {},
+          `$selected`,
         )
         const compiledHaving = compileExpression(transformedHavingClause)
 
         pipeline = pipeline.pipe(
           filter(([, row]) => {
             // Create a namespaced row structure for HAVING evaluation
-            const namespacedRow = { result: (row as any).__select_results }
-            return compiledHaving(namespacedRow)
-          })
+            const namespacedRow = { $selected: (row as any).$selected }
+            return toBooleanPredicate(compiledHaving(namespacedRow))
+          }),
         )
       }
     }
@@ -152,9 +159,9 @@ export function processGroupBy(
         pipeline = pipeline.pipe(
           filter(([, row]) => {
             // Create a namespaced row structure for functional HAVING evaluation
-            const namespacedRow = { result: (row as any).__select_results }
-            return fnHaving(namespacedRow)
-          })
+            const namespacedRow = { $selected: (row as any).$selected }
+            return toBooleanPredicate(fnHaving(namespacedRow))
+          }),
         )
       }
     }
@@ -168,17 +175,17 @@ export function processGroupBy(
 
   // Pre-compile groupBy expressions
   const compiledGroupByExpressions = groupByClause.map((e) =>
-    compileExpression(e)
+    compileExpression(e),
   )
 
   // Create a key extractor function using simple __key_X format
   const keyExtractor = ([, row]: [
     string,
-    NamespacedRow & { __select_results?: any },
+    NamespacedRow & { $selected?: any },
   ]) => {
-    // Use the original namespaced row for GROUP BY expressions, not __select_results
+    // Use the original namespaced row for GROUP BY expressions, not $selected
     const namespacedRow = { ...row }
-    delete (namespacedRow as any).__select_results
+    delete (namespacedRow as any).$selected
 
     const key: Record<string, unknown> = {}
 
@@ -208,11 +215,11 @@ export function processGroupBy(
   // Apply the groupBy operator
   pipeline = pipeline.pipe(groupBy(keyExtractor, aggregates))
 
-  // Update __select_results to handle GROUP BY results
+  // Update $selected to handle GROUP BY results
   pipeline = pipeline.pipe(
     map(([, aggregatedRow]) => {
-      // Start with the existing __select_results from early SELECT processing
-      const selectResults = (aggregatedRow as any).__select_results || {}
+      // Start with the existing $selected from early SELECT processing
+      const selectResults = (aggregatedRow as any).$selected || {}
       const finalResults: Record<string, any> = {}
 
       if (selectClause) {
@@ -248,17 +255,17 @@ export function processGroupBy(
         for (let i = 0; i < groupByClause.length; i++) {
           keyParts.push(aggregatedRow[`__key_${i}`])
         }
-        finalKey = JSON.stringify(keyParts)
+        finalKey = serializeValue(keyParts)
       }
 
       return [
         finalKey,
         {
           ...aggregatedRow,
-          __select_results: finalResults,
+          $selected: finalResults,
         },
       ] as [unknown, Record<string, any>]
-    })
+    }),
   )
 
   // Apply HAVING clauses if present
@@ -267,16 +274,16 @@ export function processGroupBy(
       const havingExpression = getHavingExpression(havingClause)
       const transformedHavingClause = replaceAggregatesByRefs(
         havingExpression,
-        selectClause || {}
+        selectClause || {},
       )
       const compiledHaving = compileExpression(transformedHavingClause)
 
       pipeline = pipeline.pipe(
         filter(([, row]) => {
           // Create a namespaced row structure for HAVING evaluation
-          const namespacedRow = { result: (row as any).__select_results }
+          const namespacedRow = { $selected: (row as any).$selected }
           return compiledHaving(namespacedRow)
-        })
+        }),
       )
     }
   }
@@ -287,9 +294,9 @@ export function processGroupBy(
       pipeline = pipeline.pipe(
         filter(([, row]) => {
           // Create a namespaced row structure for functional HAVING evaluation
-          const namespacedRow = { result: (row as any).__select_results }
-          return fnHaving(namespacedRow)
-        })
+          const namespacedRow = { $selected: (row as any).$selected }
+          return toBooleanPredicate(fnHaving(namespacedRow))
+        }),
       )
     }
   }
@@ -310,7 +317,7 @@ function expressionsEqual(expr1: any, expr2: any): boolean {
       if (!expr1.path || !expr2.path) return false
       if (expr1.path.length !== expr2.path.length) return false
       return expr1.path.every(
-        (segment: string, i: number) => segment === expr2.path[i]
+        (segment: string, i: number) => segment === expr2.path[i],
       )
     case `val`:
       return expr1.value === expr2.value
@@ -319,7 +326,7 @@ function expressionsEqual(expr1: any, expr2: any): boolean {
         expr1.name === expr2.name &&
         expr1.args?.length === expr2.args?.length &&
         (expr1.args || []).every((arg: any, i: number) =>
-          expressionsEqual(arg, expr2.args[i])
+          expressionsEqual(arg, expr2.args[i]),
         )
       )
     case `agg`:
@@ -327,7 +334,7 @@ function expressionsEqual(expr1: any, expr2: any): boolean {
         expr1.name === expr2.name &&
         expr1.args?.length === expr2.args?.length &&
         (expr1.args || []).every((arg: any, i: number) =>
-          expressionsEqual(arg, expr2.args[i])
+          expressionsEqual(arg, expr2.args[i]),
         )
       )
     default:
@@ -346,20 +353,28 @@ function getAggregateFunction(aggExpr: Aggregate) {
   const valueExtractor = ([, namespacedRow]: [string, NamespacedRow]) => {
     const value = compiledExpr(namespacedRow)
     // Ensure we return a number for numeric aggregate functions
-    return typeof value === `number` ? value : value != null ? Number(value) : 0
+    if (typeof value === `number`) {
+      return value
+    }
+    return value != null ? Number(value) : 0
   }
 
-  // Create a value extractor function for the expression to aggregate
-  const valueExtractorWithDate = ([, namespacedRow]: [
+  // Create a value extractor function for min/max that preserves comparable types
+  const valueExtractorForMinMax = ([, namespacedRow]: [
     string,
     NamespacedRow,
   ]) => {
     const value = compiledExpr(namespacedRow)
-    return typeof value === `number` || value instanceof Date
-      ? value
-      : value != null
-        ? Number(value)
-        : 0
+    // Preserve strings, numbers, Dates, and bigints for comparison
+    if (
+      typeof value === `number` ||
+      typeof value === `string` ||
+      typeof value === `bigint` ||
+      value instanceof Date
+    ) {
+      return value
+    }
+    return value != null ? Number(value) : 0
   }
 
   // Create a raw value extractor function for the expression to aggregate
@@ -376,21 +391,32 @@ function getAggregateFunction(aggExpr: Aggregate) {
     case `avg`:
       return avg(valueExtractor)
     case `min`:
-      return min(valueExtractorWithDate)
+      return min(valueExtractorForMinMax)
     case `max`:
-      return max(valueExtractorWithDate)
+      return max(valueExtractorForMinMax)
     default:
       throw new UnsupportedAggregateFunctionError(aggExpr.name)
   }
 }
 
 /**
- * Transforms basic expressions and aggregates to replace Agg expressions with references to computed values
+ * Transforms expressions to replace aggregate functions with references to computed values.
+ *
+ * For aggregate expressions, finds matching aggregates in the SELECT clause and replaces them
+ * with PropRef([resultAlias, alias]) to reference the computed aggregate value.
+ *
+ * Ref expressions (table columns and $selected fields) and value expressions are passed through unchanged.
+ * Function expressions are recursively transformed.
+ *
+ * @param havingExpr - The expression to transform (can be aggregate, ref, func, or val)
+ * @param selectClause - The SELECT clause containing aliases and aggregate definitions
+ * @param resultAlias - The namespace alias for SELECT results (default: '$selected')
+ * @returns A transformed BasicExpression that references computed values instead of raw expressions
  */
 export function replaceAggregatesByRefs(
   havingExpr: BasicExpression | Aggregate,
   selectClause: Select,
-  resultAlias: string = `result`
+  resultAlias: string = `$selected`,
 ): BasicExpression {
   switch (havingExpr.type) {
     case `agg`: {
@@ -411,15 +437,16 @@ export function replaceAggregatesByRefs(
       // Transform function arguments recursively
       const transformedArgs = funcExpr.args.map(
         (arg: BasicExpression | Aggregate) =>
-          replaceAggregatesByRefs(arg, selectClause)
+          replaceAggregatesByRefs(arg, selectClause),
       )
       return new Func(funcExpr.name, transformedArgs)
     }
 
-    case `ref`: {
-      // Non-aggregate refs are passed through unchanged (they reference table columns)
+    case `ref`:
+      // Ref expressions are passed through unchanged - they reference either:
+      // - $selected fields (which are already in the correct namespace)
+      // - Table column references (which remain valid)
       return havingExpr as BasicExpression
-    }
 
     case `val`:
       // Return as-is
diff --git a/packages/db/src/query/compiler/index.ts b/packages/db/src/query/compiler/index.ts
index 1cd033453..b1d306607 100644
--- a/packages/db/src/query/compiler/index.ts
+++ b/packages/db/src/query/compiler/index.ts
@@ -1,36 +1,37 @@
-import { distinct, filter, map } from "@tanstack/db-ivm"
-import { optimizeQuery } from "../optimizer.js"
+import { distinct, filter, map } from '@tanstack/db-ivm'
+import { optimizeQuery } from '../optimizer.js'
 import {
   CollectionInputNotFoundError,
   DistinctRequiresSelectError,
+  DuplicateAliasInSubqueryError,
   HavingRequiresGroupByError,
   LimitOffsetRequireOrderByError,
   UnsupportedFromTypeError,
-} from "../../errors.js"
-import { PropRef, Value as ValClass, getWhereExpression } from "../ir.js"
-import { compileExpression } from "./evaluators.js"
-import { processJoins } from "./joins.js"
-import { processGroupBy } from "./group-by.js"
-import { processOrderBy } from "./order-by.js"
-import { processSelect } from "./select.js"
-import type { CollectionSubscription } from "../../collection/subscription.js"
-import type { OrderByOptimizationInfo } from "./order-by.js"
+} from '../../errors.js'
+import { PropRef, Value as ValClass, getWhereExpression } from '../ir.js'
+import { compileExpression, toBooleanPredicate } from './evaluators.js'
+import { processJoins } from './joins.js'
+import { processGroupBy } from './group-by.js'
+import { processOrderBy } from './order-by.js'
+import { processSelect } from './select.js'
+import type { CollectionSubscription } from '../../collection/subscription.js'
+import type { OrderByOptimizationInfo } from './order-by.js'
 import type {
   BasicExpression,
   CollectionRef,
   QueryIR,
   QueryRef,
-} from "../ir.js"
-import type { LazyCollectionCallbacks } from "./joins.js"
-import type { Collection } from "../../collection/index.js"
+} from '../ir.js'
+import type { LazyCollectionCallbacks } from './joins.js'
+import type { Collection } from '../../collection/index.js'
 import type {
   KeyedStream,
   NamespacedAndKeyedStream,
   ResultStream,
-} from "../../types.js"
-import type { QueryCache, QueryMapping, WindowOptions } from "./types.js"
+} from '../../types.js'
+import type { QueryCache, QueryMapping, WindowOptions } from './types.js'
 
-export type { WindowOptions } from "./types.js"
+export type { WindowOptions } from './types.js'
 
 /**
  * Result of query compilation including both the pipeline and source-specific WHERE clauses
@@ -91,7 +92,7 @@ export function compileQuery(
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo>,
   setWindowFn: (windowFn: (options: WindowOptions) => void) => void,
   cache: QueryCache = new WeakMap(),
-  queryMapping: QueryMapping = new WeakMap()
+  queryMapping: QueryMapping = new WeakMap(),
 ): CompilationResult {
   // Check if the original raw query has already been compiled
   const cachedResult = cache.get(rawQuery)
@@ -99,6 +100,11 @@ export function compileQuery(
     return cachedResult
   }
 
+  // Validate the raw query BEFORE optimization to check user's original structure.
+  // This must happen before optimization because the optimizer may create internal
+  // subqueries (e.g., for predicate pushdown) that reuse aliases, which is fine.
+  validateQueryStructure(rawQuery)
+
   // Optimize the query before compilation
   const { optimizedQuery: query, sourceWhereClauses } = optimizeQuery(rawQuery)
 
@@ -141,7 +147,8 @@ export function compileQuery(
     cache,
     queryMapping,
     aliasToCollectionId,
-    aliasRemapping
+    aliasRemapping,
+    sourceWhereClauses,
   )
   sources[mainSource] = mainInput
 
@@ -154,7 +161,7 @@ export function compileQuery(
         Record<string, typeof row>,
       ]
       return ret
-    })
+    }),
   )
 
   // Process JOIN clauses if they exist
@@ -177,7 +184,8 @@ export function compileQuery(
       rawQuery,
       compileQuery,
       aliasToCollectionId,
-      aliasRemapping
+      aliasRemapping,
+      sourceWhereClauses,
     )
   }
 
@@ -189,8 +197,8 @@ export function compileQuery(
       const compiledWhere = compileExpression(whereExpression)
       pipeline = pipeline.pipe(
         filter(([_key, namespacedRow]) => {
-          return compiledWhere(namespacedRow)
-        })
+          return toBooleanPredicate(compiledWhere(namespacedRow))
+        }),
       )
     }
   }
@@ -200,8 +208,8 @@ export function compileQuery(
     for (const fnWhere of query.fnWhere) {
       pipeline = pipeline.pipe(
         filter(([_key, namespacedRow]) => {
-          return fnWhere(namespacedRow)
-        })
+          return toBooleanPredicate(fnWhere(namespacedRow))
+        }),
       )
     }
   }
@@ -210,7 +218,7 @@ export function compileQuery(
     throw new DistinctRequiresSelectError()
   }
 
-  // Process the SELECT clause early - always create __select_results
+  // Process the SELECT clause early - always create $selected
   // This eliminates duplication and allows for DISTINCT implementation
   if (query.fnSelect) {
     // Handle functional select - apply the function to transform the row
@@ -221,15 +229,15 @@ export function compileQuery(
           key,
           {
             ...namespacedRow,
-            __select_results: selectResults,
+            $selected: selectResults,
           },
-        ] as [string, typeof namespacedRow & { __select_results: any }]
-      })
+        ] as [string, typeof namespacedRow & { $selected: any }]
+      }),
     )
   } else if (query.select) {
     pipeline = processSelect(pipeline, query.select, allInputs)
   } else {
-    // If no SELECT clause, create __select_results with the main table data
+    // If no SELECT clause, create $selected with the main table data
     pipeline = pipeline.pipe(
       map(([key, namespacedRow]) => {
         const selectResults =
@@ -241,10 +249,10 @@ export function compileQuery(
           key,
           {
             ...namespacedRow,
-            __select_results: selectResults,
+            $selected: selectResults,
           },
-        ] as [string, typeof namespacedRow & { __select_results: any }]
-      })
+        ] as [string, typeof namespacedRow & { $selected: any }]
+      }),
     )
   }
 
@@ -255,12 +263,12 @@ export function compileQuery(
       query.groupBy,
       query.having,
       query.select,
-      query.fnHaving
+      query.fnHaving,
     )
   } else if (query.select) {
     // Check if SELECT contains aggregates but no GROUP BY (implicit single-group aggregation)
     const hasAggregates = Object.values(query.select).some(
-      (expr) => expr.type === `agg`
+      (expr) => expr.type === `agg`,
     )
     if (hasAggregates) {
       // Handle implicit single-group aggregation
@@ -269,7 +277,7 @@ export function compileQuery(
         [], // Empty group by means single group
         query.having,
         query.select,
-        query.fnHaving
+        query.fnHaving,
       )
     }
   }
@@ -297,14 +305,14 @@ export function compileQuery(
       pipeline = pipeline.pipe(
         filter(([_key, namespacedRow]) => {
           return fnHaving(namespacedRow)
-        })
+        }),
       )
     }
   }
 
   // Process the DISTINCT clause if it exists
   if (query.distinct) {
-    pipeline = pipeline.pipe(distinct(([_key, row]) => row.__select_results))
+    pipeline = pipeline.pipe(distinct(([_key, row]) => row.$selected))
   }
 
   // Process orderBy parameter if it exists
@@ -318,17 +326,17 @@ export function compileQuery(
       optimizableOrderByCollections,
       setWindowFn,
       query.limit,
-      query.offset
+      query.offset,
     )
 
-    // Final step: extract the __select_results and include orderBy index
+    // Final step: extract the $selected and include orderBy index
     const resultPipeline = orderedPipeline.pipe(
       map(([key, [row, orderByIndex]]) => {
-        // Extract the final results from __select_results and include orderBy index
-        const raw = (row as any).__select_results
+        // Extract the final results from $selected and include orderBy index
+        const raw = (row as any).$selected
         const finalResults = unwrapValue(raw)
         return [key, [finalResults, orderByIndex]] as [unknown, [any, string]]
-      })
+      }),
     )
 
     const result = resultPipeline
@@ -348,17 +356,17 @@ export function compileQuery(
     throw new LimitOffsetRequireOrderByError()
   }
 
-  // Final step: extract the __select_results and return tuple format (no orderBy)
+  // Final step: extract the $selected and return tuple format (no orderBy)
   const resultPipeline: ResultStream = pipeline.pipe(
     map(([key, row]) => {
-      // Extract the final results from __select_results and return [key, [results, undefined]]
-      const raw = (row as any).__select_results
+      // Extract the final results from $selected and return [key, [results, undefined]]
+      const raw = (row as any).$selected
       const finalResults = unwrapValue(raw)
       return [key, [finalResults, undefined]] as [
         unknown,
         [any, string | undefined],
       ]
-    })
+    }),
   )
 
   const result = resultPipeline
@@ -375,6 +383,74 @@ export function compileQuery(
   return compilationResult
 }
 
+/**
+ * Collects aliases used for DIRECT collection references (not subqueries).
+ * Used to validate that subqueries don't reuse parent query collection aliases.
+ * Only direct CollectionRef aliases matter - QueryRef aliases don't cause conflicts.
+ */
+function collectDirectCollectionAliases(query: QueryIR): Set<string> {
+  const aliases = new Set<string>()
+
+  // Collect FROM alias only if it's a direct collection reference
+  if (query.from.type === `collectionRef`) {
+    aliases.add(query.from.alias)
+  }
+
+  // Collect JOIN aliases only for direct collection references
+  if (query.join) {
+    for (const joinClause of query.join) {
+      if (joinClause.from.type === `collectionRef`) {
+        aliases.add(joinClause.from.alias)
+      }
+    }
+  }
+
+  return aliases
+}
+
+/**
+ * Validates the structure of a query and its subqueries.
+ * Checks that subqueries don't reuse collection aliases from parent queries.
+ * This must be called on the RAW query before optimization.
+ */
+function validateQueryStructure(
+  query: QueryIR,
+  parentCollectionAliases: Set<string> = new Set(),
+): void {
+  // Collect direct collection aliases from this query level
+  const currentLevelAliases = collectDirectCollectionAliases(query)
+
+  // Check if any current alias conflicts with parent aliases
+  for (const alias of currentLevelAliases) {
+    if (parentCollectionAliases.has(alias)) {
+      throw new DuplicateAliasInSubqueryError(
+        alias,
+        Array.from(parentCollectionAliases),
+      )
+    }
+  }
+
+  // Combine parent and current aliases for checking nested subqueries
+  const combinedAliases = new Set([
+    ...parentCollectionAliases,
+    ...currentLevelAliases,
+  ])
+
+  // Recursively validate FROM subquery
+  if (query.from.type === `queryRef`) {
+    validateQueryStructure(query.from.query, combinedAliases)
+  }
+
+  // Recursively validate JOIN subqueries
+  if (query.join) {
+    for (const joinClause of query.join) {
+      if (joinClause.from.type === `queryRef`) {
+        validateQueryStructure(joinClause.from.query, combinedAliases)
+      }
+    }
+  }
+}
+
 /**
  * Processes the FROM clause, handling direct collection references and subqueries.
  * Populates `aliasToCollectionId` and `aliasRemapping` for per-alias subscription tracking.
@@ -391,7 +467,8 @@ function processFrom(
   cache: QueryCache,
   queryMapping: QueryMapping,
   aliasToCollectionId: Record<string, string>,
-  aliasRemapping: Record<string, string>
+  aliasRemapping: Record<string, string>,
+  sourceWhereClauses: Map<string, BasicExpression<boolean>>,
 ): { alias: string; input: KeyedStream; collectionId: string } {
   switch (from.type) {
     case `collectionRef`: {
@@ -400,7 +477,7 @@ function processFrom(
         throw new CollectionInputNotFoundError(
           from.alias,
           from.collection.id,
-          Object.keys(allInputs)
+          Object.keys(allInputs),
         )
       }
       aliasToCollectionId[from.alias] = from.collection.id
@@ -421,7 +498,7 @@ function processFrom(
         optimizableOrderByCollections,
         setWindowFn,
         cache,
-        queryMapping
+        queryMapping,
       )
 
       // Pull up alias mappings from subquery to parent scope.
@@ -430,6 +507,28 @@ function processFrom(
       Object.assign(aliasToCollectionId, subQueryResult.aliasToCollectionId)
       Object.assign(aliasRemapping, subQueryResult.aliasRemapping)
 
+      // Pull up source WHERE clauses from subquery to parent scope.
+      // This enables loadSubset to receive the correct where clauses for subquery collections.
+      //
+      // IMPORTANT: Skip pull-up for optimizer-created subqueries. These are detected when:
+      // 1. The outer alias (from.alias) matches the inner alias (from.query.from.alias)
+      // 2. The subquery was found in queryMapping (it's a user-defined subquery, not optimizer-created)
+      //
+      // For optimizer-created subqueries, the parent already has the sourceWhereClauses
+      // extracted from the original raw query, so pulling up would be redundant.
+      // More importantly, pulling up for optimizer-created subqueries can cause issues
+      // when the optimizer has restructured the query.
+      const isUserDefinedSubquery = queryMapping.has(from.query)
+      const subqueryFromAlias = from.query.from.alias
+      const isOptimizerCreated =
+        !isUserDefinedSubquery && from.alias === subqueryFromAlias
+
+      if (!isOptimizerCreated) {
+        for (const [alias, whereClause] of subQueryResult.sourceWhereClauses) {
+          sourceWhereClauses.set(alias, whereClause)
+        }
+      }
+
       // Create a FLATTENED remapping from outer alias to innermost alias.
       // For nested subqueries, this ensures one-hop lookups (not recursive chains).
       //
@@ -445,7 +544,7 @@ function processFrom(
       const innerAlias = Object.keys(subQueryResult.aliasToCollectionId).find(
         (alias) =>
           subQueryResult.aliasToCollectionId[alias] ===
-          subQueryResult.collectionId
+          subQueryResult.collectionId,
       )
       if (innerAlias && innerAlias !== from.alias) {
         aliasRemapping[from.alias] = innerAlias
@@ -462,7 +561,7 @@ function processFrom(
           // Unwrap Value expressions that might have leaked through as the entire row
           const unwrapped = unwrapValue(value)
           return [key, unwrapped] as [unknown, any]
-        })
+        }),
       )
 
       return {
@@ -497,7 +596,7 @@ function unwrapValue(value: any): any {
 function mapNestedQueries(
   optimizedQuery: QueryIR,
   originalQuery: QueryIR,
-  queryMapping: QueryMapping
+  queryMapping: QueryMapping,
 ): void {
   // Map the FROM clause if it's a QueryRef
   if (
@@ -509,7 +608,7 @@ function mapNestedQueries(
     mapNestedQueries(
       optimizedQuery.from.query,
       originalQuery.from.query,
-      queryMapping
+      queryMapping,
     )
   }
 
@@ -532,7 +631,7 @@ function mapNestedQueries(
         mapNestedQueries(
           optimizedJoin.from.query,
           originalJoin.from.query,
-          queryMapping
+          queryMapping,
         )
       }
     }
@@ -541,7 +640,7 @@ function mapNestedQueries(
 
 function getRefFromAlias(
   query: QueryIR,
-  alias: string
+  alias: string,
 ): CollectionRef | QueryRef | void {
   if (query.from.alias === alias) {
     return query.from
@@ -562,7 +661,7 @@ function getRefFromAlias(
 export function followRef(
   query: QueryIR,
   ref: PropRef<any>,
-  collection: Collection
+  collection: Collection,
 ): { collection: Collection; path: Array<string> } | void {
   if (ref.path.length === 0) {
     return
diff --git a/packages/db/src/query/compiler/joins.ts b/packages/db/src/query/compiler/joins.ts
index 505f90bf3..5dcb7ed39 100644
--- a/packages/db/src/query/compiler/joins.ts
+++ b/packages/db/src/query/compiler/joins.ts
@@ -1,4 +1,4 @@
-import { filter, join as joinOperator, map, tap } from "@tanstack/db-ivm"
+import { filter, join as joinOperator, map, tap } from '@tanstack/db-ivm'
 import {
   CollectionInputNotFoundError,
   InvalidJoinCondition,
@@ -10,29 +10,29 @@ import {
   SubscriptionNotFoundError,
   UnsupportedJoinSourceTypeError,
   UnsupportedJoinTypeError,
-} from "../../errors.js"
-import { ensureIndexForField } from "../../indexes/auto-index.js"
-import { PropRef, followRef } from "../ir.js"
-import { inArray } from "../builder/functions.js"
-import { compileExpression } from "./evaluators.js"
-import type { CompileQueryFn } from "./index.js"
-import type { OrderByOptimizationInfo } from "./order-by.js"
+} from '../../errors.js'
+import { ensureIndexForField } from '../../indexes/auto-index.js'
+import { PropRef, followRef } from '../ir.js'
+import { inArray } from '../builder/functions.js'
+import { compileExpression } from './evaluators.js'
+import type { CompileQueryFn } from './index.js'
+import type { OrderByOptimizationInfo } from './order-by.js'
 import type {
   BasicExpression,
   CollectionRef,
   JoinClause,
   QueryIR,
   QueryRef,
-} from "../ir.js"
-import type { IStreamBuilder, JoinType } from "@tanstack/db-ivm"
-import type { Collection } from "../../collection/index.js"
+} from '../ir.js'
+import type { IStreamBuilder, JoinType } from '@tanstack/db-ivm'
+import type { Collection } from '../../collection/index.js'
 import type {
   KeyedStream,
   NamespacedAndKeyedStream,
   NamespacedRow,
-} from "../../types.js"
-import type { QueryCache, QueryMapping, WindowOptions } from "./types.js"
-import type { CollectionSubscription } from "../../collection/subscription.js"
+} from '../../types.js'
+import type { QueryCache, QueryMapping, WindowOptions } from './types.js'
+import type { CollectionSubscription } from '../../collection/subscription.js'
 
 /** Function type for loading specific keys into a lazy collection */
 export type LoadKeysFn = (key: Set<string | number>) => void
@@ -65,7 +65,8 @@ export function processJoins(
   rawQuery: QueryIR,
   onCompileSubquery: CompileQueryFn,
   aliasToCollectionId: Record<string, string>,
-  aliasRemapping: Record<string, string>
+  aliasRemapping: Record<string, string>,
+  sourceWhereClauses: Map<string, BasicExpression<boolean>>,
 ): NamespacedAndKeyedStream {
   let resultPipeline = pipeline
 
@@ -88,7 +89,8 @@ export function processJoins(
       rawQuery,
       onCompileSubquery,
       aliasToCollectionId,
-      aliasRemapping
+      aliasRemapping,
+      sourceWhereClauses,
     )
   }
 
@@ -117,7 +119,8 @@ function processJoin(
   rawQuery: QueryIR,
   onCompileSubquery: CompileQueryFn,
   aliasToCollectionId: Record<string, string>,
-  aliasRemapping: Record<string, string>
+  aliasRemapping: Record<string, string>,
+  sourceWhereClauses: Map<string, BasicExpression<boolean>>,
 ): NamespacedAndKeyedStream {
   const isCollectionRef = joinClause.from.type === `collectionRef`
 
@@ -139,7 +142,8 @@ function processJoin(
     queryMapping,
     onCompileSubquery,
     aliasToCollectionId,
-    aliasRemapping
+    aliasRemapping,
+    sourceWhereClauses,
   )
 
   // Add the joined source to the sources map
@@ -164,7 +168,7 @@ function processJoin(
   const { activeSource, lazySource } = getActiveAndLazySources(
     joinClause.type,
     mainCollection,
-    joinedCollection
+    joinedCollection,
   )
 
   // Analyze which source each expression refers to and swap if necessary
@@ -173,7 +177,7 @@ function processJoin(
     joinClause.left,
     joinClause.right,
     availableSources,
-    joinedSource
+    joinedSource,
   )
 
   // Pre-compile the join expressions
@@ -191,7 +195,7 @@ function processJoin(
         unknown,
         [string, typeof namespacedRow],
       ]
-    })
+    }),
   )
 
   // Prepare the joined pipeline
@@ -208,7 +212,7 @@ function processJoin(
         unknown,
         [string, typeof namespacedRow],
       ]
-    })
+    }),
   )
 
   // Apply the join operation
@@ -255,7 +259,7 @@ function processJoin(
       const followRefResult = followRef(
         rawQuery,
         lazySourceJoinExpr,
-        lazySource
+        lazySource,
       )!
       const followRefCollection = followRefResult.collection
 
@@ -264,7 +268,7 @@ function processJoin(
         ensureIndexForField(
           fieldName,
           followRefResult.path,
-          followRefCollection
+          followRefCollection,
         )
       }
 
@@ -288,7 +292,7 @@ function processJoin(
               resolvedAlias,
               lazyAlias,
               lazySource.id,
-              Object.keys(subscriptions)
+              Object.keys(subscriptions),
             )
           }
 
@@ -309,7 +313,7 @@ function processJoin(
             // Snapshot wasn't sent because it could not be loaded from the indexes
             lazySourceSubscription.requestSnapshot()
           }
-        })
+        }),
       )
 
       if (activeSource === `main`) {
@@ -322,7 +326,7 @@ function processJoin(
 
   return mainPipeline.pipe(
     joinOperator(joinedPipeline, joinClause.type as JoinType),
-    processJoinResults(joinClause.type)
+    processJoinResults(joinClause.type),
   )
 }
 
@@ -334,11 +338,11 @@ function analyzeJoinExpressions(
   left: BasicExpression,
   right: BasicExpression,
   allAvailableSourceAliases: Array<string>,
-  joinedSource: string
+  joinedSource: string,
 ): { mainExpr: BasicExpression; joinedExpr: BasicExpression } {
   // Filter out the joined source alias from the available source aliases
   const availableSources = allAvailableSourceAliases.filter(
-    (alias) => alias !== joinedSource
+    (alias) => alias !== joinedSource,
   )
 
   const leftSourceAlias = getSourceAliasFromExpression(left)
@@ -430,7 +434,8 @@ function processJoinSource(
   queryMapping: QueryMapping,
   onCompileSubquery: CompileQueryFn,
   aliasToCollectionId: Record<string, string>,
-  aliasRemapping: Record<string, string>
+  aliasRemapping: Record<string, string>,
+  sourceWhereClauses: Map<string, BasicExpression<boolean>>,
 ): { alias: string; input: KeyedStream; collectionId: string } {
   switch (from.type) {
     case `collectionRef`: {
@@ -439,7 +444,7 @@ function processJoinSource(
         throw new CollectionInputNotFoundError(
           from.alias,
           from.collection.id,
-          Object.keys(allInputs)
+          Object.keys(allInputs),
         )
       }
       aliasToCollectionId[from.alias] = from.collection.id
@@ -460,7 +465,7 @@ function processJoinSource(
         optimizableOrderByCollections,
         setWindowFn,
         cache,
-        queryMapping
+        queryMapping,
       )
 
       // Pull up alias mappings from subquery to parent scope.
@@ -469,6 +474,26 @@ function processJoinSource(
       Object.assign(aliasToCollectionId, subQueryResult.aliasToCollectionId)
       Object.assign(aliasRemapping, subQueryResult.aliasRemapping)
 
+      // Pull up source WHERE clauses from subquery to parent scope.
+      // This enables loadSubset to receive the correct where clauses for subquery collections.
+      //
+      // IMPORTANT: Skip pull-up for optimizer-created subqueries. These are detected when:
+      // 1. The outer alias (from.alias) matches the inner alias (from.query.from.alias)
+      // 2. The subquery was found in queryMapping (it's a user-defined subquery, not optimizer-created)
+      //
+      // For optimizer-created subqueries, the parent already has the sourceWhereClauses
+      // extracted from the original raw query, so pulling up would be redundant.
+      const isUserDefinedSubquery = queryMapping.has(from.query)
+      const fromInnerAlias = from.query.from.alias
+      const isOptimizerCreated =
+        !isUserDefinedSubquery && from.alias === fromInnerAlias
+
+      if (!isOptimizerCreated) {
+        for (const [alias, whereClause] of subQueryResult.sourceWhereClauses) {
+          sourceWhereClauses.set(alias, whereClause)
+        }
+      }
+
       // Create a flattened remapping from outer alias to innermost alias.
       // For nested subqueries, this ensures one-hop lookups (not recursive chains).
       //
@@ -483,7 +508,7 @@ function processJoinSource(
       const innerAlias = Object.keys(subQueryResult.aliasToCollectionId).find(
         (alias) =>
           subQueryResult.aliasToCollectionId[alias] ===
-          subQueryResult.collectionId
+          subQueryResult.collectionId,
       )
       if (innerAlias && innerAlias !== from.alias) {
         aliasRemapping[from.alias] = innerAlias
@@ -498,7 +523,7 @@ function processJoinSource(
         map((data: any) => {
           const [key, [value, _orderByIndex]] = data
           return [key, value] as [unknown, any]
-        })
+        }),
       )
 
       return {
@@ -525,7 +550,7 @@ function processJoinResults(joinType: string) {
           [string, NamespacedRow] | undefined,
         ],
       ]
-    >
+    >,
   ): NamespacedAndKeyedStream {
     return pipeline.pipe(
       // Process the join result and handle nulls
@@ -574,7 +599,7 @@ function processJoinResults(joinType: string) {
         const resultKey = `[${mainKey},${joinedKey}]`
 
         return [resultKey, mergedNamespacedRow] as [string, NamespacedRow]
-      })
+      }),
     )
   }
 }
@@ -592,7 +617,7 @@ function processJoinResults(joinType: string) {
 function getActiveAndLazySources(
   joinType: JoinClause[`type`],
   leftCollection: Collection,
-  rightCollection: Collection
+  rightCollection: Collection,
 ):
   | { activeSource: `main` | `joined`; lazySource: Collection }
   | { activeSource: undefined; lazySource: undefined } {
diff --git a/packages/db/src/query/compiler/order-by.ts b/packages/db/src/query/compiler/order-by.ts
index 679dceeda..0ced0081c 100644
--- a/packages/db/src/query/compiler/order-by.ts
+++ b/packages/db/src/query/compiler/order-by.ts
@@ -1,17 +1,22 @@
-import { orderByWithFractionalIndex } from "@tanstack/db-ivm"
-import { defaultComparator, makeComparator } from "../../utils/comparison.js"
-import { PropRef, followRef } from "../ir.js"
-import { ensureIndexForField } from "../../indexes/auto-index.js"
-import { findIndexForField } from "../../utils/index-optimization.js"
-import { compileExpression } from "./evaluators.js"
-import { replaceAggregatesByRefs } from "./group-by.js"
-import type { WindowOptions } from "./types.js"
-import type { CompiledSingleRowExpression } from "./evaluators.js"
-import type { OrderBy, OrderByClause, QueryIR, Select } from "../ir.js"
-import type { NamespacedAndKeyedStream, NamespacedRow } from "../../types.js"
-import type { IStreamBuilder, KeyValue } from "@tanstack/db-ivm"
-import type { IndexInterface } from "../../indexes/base-index.js"
-import type { Collection } from "../../collection/index.js"
+import { orderByWithFractionalIndex } from '@tanstack/db-ivm'
+import { defaultComparator, makeComparator } from '../../utils/comparison.js'
+import { PropRef, followRef } from '../ir.js'
+import { ensureIndexForField } from '../../indexes/auto-index.js'
+import { findIndexForField } from '../../utils/index-optimization.js'
+import { compileExpression } from './evaluators.js'
+import { replaceAggregatesByRefs } from './group-by.js'
+import type { CompareOptions } from '../builder/types.js'
+import type { WindowOptions } from './types.js'
+import type { CompiledSingleRowExpression } from './evaluators.js'
+import type { OrderBy, OrderByClause, QueryIR, Select } from '../ir.js'
+import type {
+  CollectionLike,
+  NamespacedAndKeyedStream,
+  NamespacedRow,
+} from '../../types.js'
+import type { IStreamBuilder, KeyValue } from '@tanstack/db-ivm'
+import type { IndexInterface } from '../../indexes/base-index.js'
+import type { Collection } from '../../collection/index.js'
 
 export type OrderByOptimizationInfo = {
   alias: string
@@ -20,16 +25,20 @@ export type OrderByOptimizationInfo = {
   limit: number
   comparator: (
     a: Record<string, unknown> | null | undefined,
-    b: Record<string, unknown> | null | undefined
+    b: Record<string, unknown> | null | undefined,
   ) => number
-  valueExtractorForRawRow: (row: Record<string, unknown>) => any
-  index: IndexInterface<string | number>
+  /** Extracts all orderBy column values from a raw row (array for multi-column) */
+  valueExtractorForRawRow: (row: Record<string, unknown>) => unknown
+  /** Extracts only the first column value - used for index-based cursor */
+  firstColumnValueExtractor: (row: Record<string, unknown>) => unknown
+  /** Index on the first orderBy column - used for lazy loading */
+  index?: IndexInterface<string | number>
   dataNeeded?: () => number
 }
 
 /**
  * Processes the ORDER BY clause
- * Works with the new structure that has both namespaced row data and __select_results
+ * Works with the new structure that has both namespaced row data and $selected
  * Always uses fractional indexing and adds the index as __ordering_index to the result
  */
 export function processOrderBy(
@@ -41,34 +50,36 @@ export function processOrderBy(
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo>,
   setWindowFn: (windowFn: (options: WindowOptions) => void) => void,
   limit?: number,
-  offset?: number
+  offset?: number,
 ): IStreamBuilder<KeyValue<unknown, [NamespacedRow, string]>> {
   // Pre-compile all order by expressions
   const compiledOrderBy = orderByClause.map((clause) => {
     const clauseWithoutAggregates = replaceAggregatesByRefs(
       clause.expression,
       selectClause,
-      `__select_results`
+      `$selected`,
     )
+
     return {
       compiledExpression: compileExpression(clauseWithoutAggregates),
-      compareOptions: clause.compareOptions,
+      compareOptions: buildCompareOptions(clause, collection),
     }
   })
 
   // Create a value extractor function for the orderBy operator
-  const valueExtractor = (row: NamespacedRow & { __select_results?: any }) => {
+  const valueExtractor = (row: NamespacedRow & { $selected?: any }) => {
     // The namespaced row contains:
     // 1. Table aliases as top-level properties (e.g., row["tableName"])
-    // 2. SELECT results in __select_results (e.g., row.__select_results["aggregateAlias"])
-    // The replaceAggregatesByRefs function has already transformed any aggregate expressions
-    // that match SELECT aggregates to use the __select_results namespace.
+    // 2. SELECT results in $selected (e.g., row.$selected["aggregateAlias"])
+    // The replaceAggregatesByRefs function has already transformed:
+    // - Aggregate expressions that match SELECT aggregates to use the $selected namespace
+    // - $selected ref expressions are passed through unchanged (already using the correct namespace)
     const orderByContext = row
 
     if (orderByClause.length > 1) {
       // For multiple orderBy columns, create a composite key
       return compiledOrderBy.map((compiled) =>
-        compiled.compiledExpression(orderByContext)
+        compiled.compiledExpression(orderByContext),
       )
     } else if (orderByClause.length === 1) {
       // For a single orderBy column, use the value directly
@@ -87,7 +98,7 @@ export function processOrderBy(
       const arrayA = a as Array<unknown>
       const arrayB = b as Array<unknown>
       for (let i = 0; i < orderByClause.length; i++) {
-        const clause = orderByClause[i]!
+        const clause = compiledOrderBy[i]!
         const compareFn = makeComparator(clause.compareOptions)
         const result = compareFn(arrayA[i], arrayB[i])
         if (result !== 0) {
@@ -99,7 +110,7 @@ export function processOrderBy(
 
     // Single property comparison
     if (orderByClause.length === 1) {
-      const clause = orderByClause[0]!
+      const clause = compiledOrderBy[0]!
       const compareFn = makeComparator(clause.compareOptions)
       return compareFn(a, b)
     }
@@ -111,81 +122,169 @@ export function processOrderBy(
 
   let orderByOptimizationInfo: OrderByOptimizationInfo | undefined
 
-  // Optimize the orderBy operator to lazily load elements
-  // by using the range index of the collection.
-  // Only for orderBy clause on a single column for now (no composite ordering)
-  if (limit && orderByClause.length === 1) {
-    const clause = orderByClause[0]!
-    const orderByExpression = clause.expression
+  // When there's a limit, we create orderByOptimizationInfo to pass orderBy/limit
+  // to loadSubset so the sync layer can optimize the query.
+  // We try to use an index on the FIRST orderBy column for lazy loading,
+  // even for multi-column orderBy (using wider bounds on first column).
+  if (limit) {
+    let index: IndexInterface<string | number> | undefined
+    let followRefCollection: Collection | undefined
+    let firstColumnValueExtractor: CompiledSingleRowExpression | undefined
+    let orderByAlias: string = rawQuery.from.alias
+
+    // Try to create/find an index on the FIRST orderBy column for lazy loading
+    const firstClause = orderByClause[0]!
+    const firstOrderByExpression = firstClause.expression
 
-    if (orderByExpression.type === `ref`) {
+    if (firstOrderByExpression.type === `ref`) {
       const followRefResult = followRef(
         rawQuery,
-        orderByExpression,
-        collection
-      )!
-
-      const followRefCollection = followRefResult.collection
-      const fieldName = followRefResult.path[0]
-      if (fieldName) {
-        ensureIndexForField(
-          fieldName,
-          followRefResult.path,
+        firstOrderByExpression,
+        collection,
+      )
+
+      if (followRefResult) {
+        followRefCollection = followRefResult.collection
+        const fieldName = followRefResult.path[0]
+        const compareOpts = buildCompareOptions(
+          firstClause,
           followRefCollection,
-          clause.compareOptions,
-          compare
         )
-      }
 
-      const valueExtractorForRawRow = compileExpression(
-        new PropRef(followRefResult.path),
-        true
-      ) as CompiledSingleRowExpression
+        if (fieldName) {
+          ensureIndexForField(
+            fieldName,
+            followRefResult.path,
+            followRefCollection,
+            compareOpts,
+            compare,
+          )
+        }
 
-      const comparator = (
-        a: Record<string, unknown> | null | undefined,
-        b: Record<string, unknown> | null | undefined
-      ) => {
-        const extractedA = a ? valueExtractorForRawRow(a) : a
-        const extractedB = b ? valueExtractorForRawRow(b) : b
-        return compare(extractedA, extractedB)
-      }
+        // First column value extractor - used for index cursor
+        firstColumnValueExtractor = compileExpression(
+          new PropRef(followRefResult.path),
+          true,
+        ) as CompiledSingleRowExpression
 
-      const index: IndexInterface<string | number> | undefined =
-        findIndexForField(
-          followRefCollection.indexes,
+        index = findIndexForField(
+          followRefCollection,
           followRefResult.path,
-          clause.compareOptions
+          compareOpts,
         )
 
-      if (index && index.supports(`gt`)) {
-        // We found an index that we can use to lazily load ordered data
-        const orderByAlias =
-          orderByExpression.path.length > 1
-            ? String(orderByExpression.path[0])
+        // Only use the index if it supports range queries
+        if (!index?.supports(`gt`)) {
+          index = undefined
+        }
+
+        orderByAlias =
+          firstOrderByExpression.path.length > 1
+            ? String(firstOrderByExpression.path[0])
             : rawQuery.from.alias
+      }
+    }
+
+    // Only create comparator and value extractors if the first column is a ref expression
+    // For aggregate or computed expressions, we can't extract values from raw collection rows
+    if (!firstColumnValueExtractor) {
+      // Skip optimization for non-ref expressions (aggregates, computed values, etc.)
+      // The query will still work, but without lazy loading optimization
+    } else {
+      // Build value extractors for all columns (must all be ref expressions for multi-column)
+      // Check if all orderBy expressions are ref types (required for multi-column extraction)
+      const allColumnsAreRefs = orderByClause.every(
+        (clause) => clause.expression.type === `ref`,
+      )
+
+      // Create extractors for all columns if they're all refs
+      const allColumnExtractors:
+        | Array<CompiledSingleRowExpression>
+        | undefined = allColumnsAreRefs
+        ? orderByClause.map((clause) => {
+            // We know it's a ref since we checked allColumnsAreRefs
+            const refExpr = clause.expression as PropRef
+            const followResult = followRef(rawQuery, refExpr, collection)
+            if (followResult) {
+              return compileExpression(
+                new PropRef(followResult.path),
+                true,
+              ) as CompiledSingleRowExpression
+            }
+            // Fallback for refs that don't follow
+            return compileExpression(
+              clause.expression,
+              true,
+            ) as CompiledSingleRowExpression
+          })
+        : undefined
+
+      // Create a comparator for raw rows (used for tracking sent values)
+      // This compares ALL orderBy columns for proper ordering
+      const comparator = (
+        a: Record<string, unknown> | null | undefined,
+        b: Record<string, unknown> | null | undefined,
+      ) => {
+        if (orderByClause.length === 1) {
+          // Single column: extract and compare
+          const extractedA = a ? firstColumnValueExtractor(a) : a
+          const extractedB = b ? firstColumnValueExtractor(b) : b
+          return compare(extractedA, extractedB)
+        }
+        if (allColumnExtractors) {
+          // Multi-column with all refs: extract all values and compare
+          const extractAll = (
+            row: Record<string, unknown> | null | undefined,
+          ) => {
+            if (!row) return row
+            return allColumnExtractors.map((extractor) => extractor(row))
+          }
+          return compare(extractAll(a), extractAll(b))
+        }
+        // Fallback: can't compare (shouldn't happen since we skip non-ref cases)
+        return 0
+      }
 
-        orderByOptimizationInfo = {
-          alias: orderByAlias,
-          offset: offset ?? 0,
-          limit,
-          comparator,
-          valueExtractorForRawRow,
-          index,
-          orderBy: orderByClause,
+      // Create a value extractor for raw rows that extracts ALL orderBy column values
+      // This is used for tracking sent values and building composite cursors
+      const rawRowValueExtractor = (row: Record<string, unknown>): unknown => {
+        if (orderByClause.length === 1) {
+          // Single column: return single value
+          return firstColumnValueExtractor(row)
+        }
+        if (allColumnExtractors) {
+          // Multi-column: return array of all values
+          return allColumnExtractors.map((extractor) => extractor(row))
         }
+        // Fallback (shouldn't happen)
+        return undefined
+      }
+
+      orderByOptimizationInfo = {
+        alias: orderByAlias,
+        offset: offset ?? 0,
+        limit,
+        comparator,
+        valueExtractorForRawRow: rawRowValueExtractor,
+        firstColumnValueExtractor: firstColumnValueExtractor,
+        index,
+        orderBy: orderByClause,
+      }
 
-        optimizableOrderByCollections[followRefCollection.id] =
-          orderByOptimizationInfo
+      // Store the optimization info keyed by collection ID
+      // Use the followed collection if available, otherwise use the main collection
+      const targetCollectionId = followRefCollection?.id ?? collection.id
+      optimizableOrderByCollections[targetCollectionId] =
+        orderByOptimizationInfo
 
+      // Set up lazy loading callback if we have an index
+      if (index) {
         setSizeCallback = (getSize: () => number) => {
-          optimizableOrderByCollections[followRefCollection.id] = {
-            ...optimizableOrderByCollections[followRefCollection.id]!,
-            dataNeeded: () => {
+          optimizableOrderByCollections[targetCollectionId]![`dataNeeded`] =
+            () => {
               const size = getSize()
               return Math.max(0, orderByOptimizationInfo!.limit - size)
-            },
-          }
+            }
         }
       }
     }
@@ -199,7 +298,7 @@ export function processOrderBy(
       comparator: compare,
       setSizeCallback,
       setWindowFn: (
-        windowFn: (options: { offset?: number; limit?: number }) => void
+        windowFn: (options: { offset?: number; limit?: number }) => void,
       ) => {
         setWindowFn(
           // We wrap the move function such that we update the orderByOptimizationInfo
@@ -212,10 +311,29 @@ export function processOrderBy(
               orderByOptimizationInfo.limit =
                 options.limit ?? orderByOptimizationInfo.limit
             }
-          }
+          },
         )
       },
-    })
+    }),
     // orderByWithFractionalIndex returns [key, [value, index]] - we keep this format
   )
 }
+
+/**
+ * Builds a comparison configuration object that uses the values provided in the orderBy clause.
+ * If no string sort configuration is provided it defaults to the collection's string sort configuration.
+ */
+export function buildCompareOptions(
+  clause: OrderByClause,
+  collection: CollectionLike<any, any>,
+): CompareOptions {
+  if (clause.compareOptions.stringSort !== undefined) {
+    return clause.compareOptions
+  }
+
+  return {
+    ...collection.compareOptions,
+    direction: clause.compareOptions.direction,
+    nulls: clause.compareOptions.nulls,
+  }
+}
diff --git a/packages/db/src/query/compiler/select.ts b/packages/db/src/query/compiler/select.ts
index f036fb29c..94c8ac8f2 100644
--- a/packages/db/src/query/compiler/select.ts
+++ b/packages/db/src/query/compiler/select.ts
@@ -1,13 +1,13 @@
-import { map } from "@tanstack/db-ivm"
-import { PropRef, Value as ValClass, isExpressionLike } from "../ir.js"
-import { AggregateNotSupportedError } from "../../errors.js"
-import { compileExpression } from "./evaluators.js"
-import type { Aggregate, BasicExpression, Select } from "../ir.js"
+import { map } from '@tanstack/db-ivm'
+import { PropRef, Value as ValClass, isExpressionLike } from '../ir.js'
+import { AggregateNotSupportedError } from '../../errors.js'
+import { compileExpression } from './evaluators.js'
+import type { Aggregate, BasicExpression, Select } from '../ir.js'
 import type {
   KeyedStream,
   NamespacedAndKeyedStream,
   NamespacedRow,
-} from "../../types.js"
+} from '../../types.js'
 
 /**
  * Type for operations array used in select processing
@@ -34,7 +34,7 @@ function unwrapVal(input: any): any {
 function processMerge(
   op: Extract<SelectOp, { kind: `merge` }>,
   namespacedRow: NamespacedRow,
-  selectResults: Record<string, any>
+  selectResults: Record<string, any>,
 ): void {
   const value = op.source(namespacedRow)
   if (value && typeof value === `object`) {
@@ -74,7 +74,7 @@ function processMerge(
 function processNonMergeOp(
   op: Extract<SelectOp, { kind: `field` }>,
   namespacedRow: NamespacedRow,
-  selectResults: Record<string, any>
+  selectResults: Record<string, any>,
 ): void {
   // Support nested alias paths like "meta.author.name"
   const path = op.alias.split(`.`)
@@ -99,8 +99,8 @@ function processNonMergeOp(
  */
 function processRow(
   [key, namespacedRow]: [unknown, NamespacedRow],
-  ops: Array<SelectOp>
-): [unknown, typeof namespacedRow & { __select_results: any }] {
+  ops: Array<SelectOp>,
+): [unknown, typeof namespacedRow & { $selected: any }] {
   const selectResults: Record<string, any> = {}
 
   for (const op of ops) {
@@ -111,27 +111,24 @@ function processRow(
     }
   }
 
-  // Return the namespaced row with __select_results added
+  // Return the namespaced row with $selected added
   return [
     key,
     {
       ...namespacedRow,
-      __select_results: selectResults,
+      $selected: selectResults,
     },
-  ] as [
-    unknown,
-    typeof namespacedRow & { __select_results: typeof selectResults },
-  ]
+  ] as [unknown, typeof namespacedRow & { $selected: typeof selectResults }]
 }
 
 /**
- * Processes the SELECT clause and places results in __select_results
+ * Processes the SELECT clause and places results in $selected
  * while preserving the original namespaced row for ORDER BY access
  */
 export function processSelect(
   pipeline: NamespacedAndKeyedStream,
   select: Select,
-  _allInputs: Record<string, KeyedStream>
+  _allInputs: Record<string, KeyedStream>,
 ): NamespacedAndKeyedStream {
   // Build ordered operations to preserve authoring order (spreads and fields)
   const ops: Array<SelectOp> = []
@@ -145,7 +142,7 @@ export function processSelect(
  * Helper function to check if an expression is an aggregate
  */
 function isAggregateExpression(
-  expr: BasicExpression | Aggregate
+  expr: BasicExpression | Aggregate,
 ): expr is Aggregate {
   return expr.type === `agg`
 }
@@ -155,7 +152,7 @@ function isAggregateExpression(
  */
 export function processArgument(
   arg: BasicExpression | Aggregate,
-  namespacedRow: NamespacedRow
+  namespacedRow: NamespacedRow,
 ): any {
   if (isAggregateExpression(arg)) {
     throw new AggregateNotSupportedError()
@@ -189,7 +186,7 @@ function isNestedSelectObject(obj: any): boolean {
 function addFromObject(
   prefixPath: Array<string>,
   obj: any,
-  ops: Array<SelectOp>
+  ops: Array<SelectOp>,
 ) {
   for (const [key, value] of Object.entries(obj)) {
     if (key.startsWith(`__SPREAD_SENTINEL__`)) {
diff --git a/packages/db/src/query/compiler/types.ts b/packages/db/src/query/compiler/types.ts
index f10f953c9..bbce9eaaf 100644
--- a/packages/db/src/query/compiler/types.ts
+++ b/packages/db/src/query/compiler/types.ts
@@ -1,5 +1,5 @@
-import type { QueryIR } from "../ir.js"
-import type { CompilationResult } from "./index.js"
+import type { QueryIR } from '../ir.js'
+import type { CompilationResult } from './index.js'
 
 /**
  * Cache for compiled subqueries to avoid duplicate compilation
diff --git a/packages/db/src/query/expression-helpers.ts b/packages/db/src/query/expression-helpers.ts
new file mode 100644
index 000000000..9b79159e0
--- /dev/null
+++ b/packages/db/src/query/expression-helpers.ts
@@ -0,0 +1,522 @@
+/**
+ * Expression Helpers for TanStack DB
+ *
+ * These utilities help parse LoadSubsetOptions (where, orderBy, limit) from TanStack DB
+ * into formats suitable for your API backend. They provide a generic way to traverse
+ * expression trees without having to implement your own parser.
+ *
+ * @example
+ * ```typescript
+ * import { parseWhereExpression, parseOrderByExpression } from '@tanstack/db'
+ *
+ * queryFn: async (ctx) => {
+ *   const { limit, where, orderBy } = ctx.meta?.loadSubsetOptions ?? {}
+ *
+ *   // Convert expression tree to filters
+ *   const filters = parseWhereExpression(where, {
+ *     eq: (field, value) => ({ [field]: value }),
+ *     lt: (field, value) => ({ [`${field}_lt`]: value }),
+ *     and: (filters) => Object.assign({}, ...filters)
+ *   })
+ *
+ *   // Extract sort information
+ *   const sort = parseOrderByExpression(orderBy)
+ *
+ *   return api.getProducts({ ...filters, sort, limit })
+ * }
+ * ```
+ */
+
+import type { IR, OperatorName } from '../index.js'
+
+type BasicExpression<T = any> = IR.BasicExpression<T>
+type OrderBy = IR.OrderBy
+
+/**
+ * Represents a simple field path extracted from an expression.
+ * Can include string keys for object properties and numbers for array indices.
+ */
+export type FieldPath = Array<string | number>
+
+/**
+ * Represents a simple comparison operation
+ */
+export interface SimpleComparison {
+  field: FieldPath
+  operator: string
+  value?: any // Optional for operators like isNull and isUndefined that don't have a value
+}
+
+/**
+ * Options for customizing how WHERE expressions are parsed
+ */
+export interface ParseWhereOptions<T = any> {
+  /**
+   * Handler functions for different operators.
+   * Each handler receives the parsed field path(s) and value(s) and returns your custom format.
+   *
+   * Supported operators from TanStack DB:
+   * - Comparison: eq, gt, gte, lt, lte, in, like, ilike
+   * - Logical: and, or, not
+   * - Null checking: isNull, isUndefined
+   * - String functions: upper, lower, length, concat
+   * - Numeric: add
+   * - Utility: coalesce
+   * - Aggregates: count, avg, sum, min, max
+   */
+  handlers: {
+    [K in OperatorName]?: (...args: Array<any>) => T
+  } & {
+    [key: string]: (...args: Array<any>) => T
+  }
+  /**
+   * Optional handler for when an unknown operator is encountered.
+   * If not provided, unknown operators throw an error.
+   */
+  onUnknownOperator?: (operator: string, args: Array<any>) => T
+}
+
+/**
+ * Result of parsing an ORDER BY expression
+ */
+export interface ParsedOrderBy {
+  field: FieldPath
+  direction: `asc` | `desc`
+  nulls: `first` | `last`
+  /** String sorting method: 'lexical' (default) or 'locale' (locale-aware) */
+  stringSort?: `lexical` | `locale`
+  /** Locale for locale-aware string sorting (e.g., 'en-US') */
+  locale?: string
+  /** Additional options for locale-aware sorting */
+  localeOptions?: object
+}
+
+/**
+ * Extracts the field path from a PropRef expression.
+ * Returns null for non-ref expressions.
+ *
+ * @param expr - The expression to extract from
+ * @returns The field path array, or null
+ *
+ * @example
+ * ```typescript
+ * const field = extractFieldPath(someExpression)
+ * // Returns: ['product', 'category']
+ * ```
+ */
+export function extractFieldPath(expr: BasicExpression): FieldPath | null {
+  if (expr.type === `ref`) {
+    return expr.path
+  }
+  return null
+}
+
+/**
+ * Extracts the value from a Value expression.
+ * Returns undefined for non-value expressions.
+ *
+ * @param expr - The expression to extract from
+ * @returns The extracted value
+ *
+ * @example
+ * ```typescript
+ * const val = extractValue(someExpression)
+ * // Returns: 'electronics'
+ * ```
+ */
+export function extractValue(expr: BasicExpression): any {
+  if (expr.type === `val`) {
+    return expr.value
+  }
+  return undefined
+}
+
+/**
+ * Generic expression tree walker that visits each node in the expression.
+ * Useful for implementing custom parsing logic.
+ *
+ * @param expr - The expression to walk
+ * @param visitor - Visitor function called for each node
+ *
+ * @example
+ * ```typescript
+ * walkExpression(whereExpr, (node) => {
+ *   if (node.type === 'func' && node.name === 'eq') {
+ *     console.log('Found equality comparison')
+ *   }
+ * })
+ * ```
+ */
+export function walkExpression(
+  expr: BasicExpression | undefined | null,
+  visitor: (node: BasicExpression) => void,
+): void {
+  if (!expr) return
+
+  visitor(expr)
+
+  if (expr.type === `func`) {
+    expr.args.forEach((arg: BasicExpression) => walkExpression(arg, visitor))
+  }
+}
+
+/**
+ * Parses a WHERE expression into a custom format using provided handlers.
+ *
+ * This is the main helper for converting TanStack DB where clauses into your API's filter format.
+ * You provide handlers for each operator, and this function traverses the expression tree
+ * and calls the appropriate handlers.
+ *
+ * @param expr - The WHERE expression to parse
+ * @param options - Configuration with handler functions for each operator
+ * @returns The parsed result in your custom format
+ *
+ * @example
+ * ```typescript
+ * // REST API with query parameters
+ * const filters = parseWhereExpression(where, {
+ *   handlers: {
+ *     eq: (field, value) => ({ [field.join('.')]: value }),
+ *     lt: (field, value) => ({ [`${field.join('.')}_lt`]: value }),
+ *     gt: (field, value) => ({ [`${field.join('.')}_gt`]: value }),
+ *     and: (...filters) => Object.assign({}, ...filters),
+ *     or: (...filters) => ({ $or: filters })
+ *   }
+ * })
+ * // Returns: { category: 'electronics', price_lt: 100 }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // GraphQL where clause
+ * const where = parseWhereExpression(whereExpr, {
+ *   handlers: {
+ *     eq: (field, value) => ({ [field.join('_')]: { _eq: value } }),
+ *     lt: (field, value) => ({ [field.join('_')]: { _lt: value } }),
+ *     and: (...filters) => ({ _and: filters })
+ *   }
+ * })
+ * ```
+ */
+export function parseWhereExpression<T = any>(
+  expr: BasicExpression<boolean> | undefined | null,
+  options: ParseWhereOptions<T>,
+): T | null {
+  if (!expr) return null
+
+  const { handlers, onUnknownOperator } = options
+
+  // Handle value expressions
+  if (expr.type === `val`) {
+    return expr.value as unknown as T
+  }
+
+  // Handle property references
+  if (expr.type === `ref`) {
+    return expr.path as unknown as T
+  }
+
+  // Handle function expressions
+  // After checking val and ref, expr must be func
+  const { name, args } = expr
+  const handler = handlers[name]
+
+  if (!handler) {
+    if (onUnknownOperator) {
+      return onUnknownOperator(name, args)
+    }
+    throw new Error(
+      `No handler provided for operator: ${name}. Available handlers: ${Object.keys(handlers).join(`, `)}`,
+    )
+  }
+
+  // Parse arguments recursively
+  const parsedArgs = args.map((arg: BasicExpression) => {
+    // For refs, extract the field path
+    if (arg.type === `ref`) {
+      return arg.path
+    }
+    // For values, extract the value
+    if (arg.type === `val`) {
+      return arg.value
+    }
+    // For nested functions, recurse (after checking ref and val, must be func)
+    return parseWhereExpression(arg, options)
+  })
+
+  return handler(...parsedArgs)
+}
+
+/**
+ * Parses an ORDER BY expression into a simple array of sort specifications.
+ *
+ * @param orderBy - The ORDER BY expression array
+ * @returns Array of parsed order by specifications
+ *
+ * @example
+ * ```typescript
+ * const sorts = parseOrderByExpression(orderBy)
+ * // Returns: [
+ * //   { field: ['category'], direction: 'asc', nulls: 'last' },
+ * //   { field: ['price'], direction: 'desc', nulls: 'last' }
+ * // ]
+ * ```
+ */
+export function parseOrderByExpression(
+  orderBy: OrderBy | undefined | null,
+): Array<ParsedOrderBy> {
+  if (!orderBy || orderBy.length === 0) {
+    return []
+  }
+
+  return orderBy.map((clause: IR.OrderByClause) => {
+    const field = extractFieldPath(clause.expression)
+
+    if (!field) {
+      throw new Error(
+        `ORDER BY expression must be a field reference, got: ${clause.expression.type}`,
+      )
+    }
+
+    const { direction, nulls } = clause.compareOptions
+    const result: ParsedOrderBy = {
+      field,
+      direction,
+      nulls,
+    }
+
+    // Add string collation options if present (discriminated union)
+    if (`stringSort` in clause.compareOptions) {
+      result.stringSort = clause.compareOptions.stringSort
+    }
+    if (`locale` in clause.compareOptions) {
+      result.locale = clause.compareOptions.locale
+    }
+    if (`localeOptions` in clause.compareOptions) {
+      result.localeOptions = clause.compareOptions.localeOptions
+    }
+
+    return result
+  })
+}
+
+/**
+ * Extracts all simple comparisons from a WHERE expression.
+ * This is useful for simple APIs that only support basic filters.
+ *
+ * Note: This only works for simple AND-ed conditions and NOT-wrapped comparisons.
+ * Throws an error if it encounters unsupported operations like OR or complex nested expressions.
+ *
+ * NOT operators are flattened by prefixing the operator name (e.g., `not(eq(...))` becomes `not_eq`).
+ *
+ * @param expr - The WHERE expression to parse
+ * @returns Array of simple comparisons
+ * @throws Error if expression contains OR or other unsupported operations
+ *
+ * @example
+ * ```typescript
+ * const comparisons = extractSimpleComparisons(where)
+ * // Returns: [
+ * //   { field: ['category'], operator: 'eq', value: 'electronics' },
+ * //   { field: ['price'], operator: 'lt', value: 100 },
+ * //   { field: ['email'], operator: 'isNull' }, // No value for null checks
+ * //   { field: ['status'], operator: 'not_eq', value: 'archived' }
+ * // ]
+ * ```
+ */
+export function extractSimpleComparisons(
+  expr: BasicExpression<boolean> | undefined | null,
+): Array<SimpleComparison> {
+  if (!expr) return []
+
+  const comparisons: Array<SimpleComparison> = []
+
+  function extract(e: BasicExpression): void {
+    if (e.type === `func`) {
+      // Handle AND - recurse into both sides
+      if (e.name === `and`) {
+        e.args.forEach((arg: BasicExpression) => extract(arg))
+        return
+      }
+
+      // Handle NOT - recurse into argument and prefix operator with 'not_'
+      if (e.name === `not`) {
+        const [arg] = e.args
+        if (!arg || arg.type !== `func`) {
+          throw new Error(
+            `extractSimpleComparisons requires a comparison or null check inside 'not' operator.`,
+          )
+        }
+
+        // Handle NOT with null/undefined checks
+        const nullCheckOps = [`isNull`, `isUndefined`]
+        if (nullCheckOps.includes(arg.name)) {
+          const [fieldArg] = arg.args
+          const field = fieldArg?.type === `ref` ? fieldArg.path : null
+
+          if (field) {
+            comparisons.push({
+              field,
+              operator: `not_${arg.name}`,
+              // No value for null/undefined checks
+            })
+          } else {
+            throw new Error(
+              `extractSimpleComparisons requires a field reference for '${arg.name}' operator.`,
+            )
+          }
+          return
+        }
+
+        // Handle NOT with comparison operators
+        const comparisonOps = [`eq`, `gt`, `gte`, `lt`, `lte`, `in`]
+        if (comparisonOps.includes(arg.name)) {
+          const [leftArg, rightArg] = arg.args
+          const field = leftArg?.type === `ref` ? leftArg.path : null
+          const value = rightArg?.type === `val` ? rightArg.value : null
+
+          if (field && value !== undefined) {
+            comparisons.push({
+              field,
+              operator: `not_${arg.name}`,
+              value,
+            })
+          } else {
+            throw new Error(
+              `extractSimpleComparisons requires simple field-value comparisons. Found complex expression for 'not(${arg.name})' operator.`,
+            )
+          }
+          return
+        }
+
+        // NOT can only wrap simple comparisons or null checks
+        throw new Error(
+          `extractSimpleComparisons does not support 'not(${arg.name})'. NOT can only wrap comparison operators (eq, gt, gte, lt, lte, in) or null checks (isNull, isUndefined).`,
+        )
+      }
+
+      // Throw on unsupported operations
+      const unsupportedOps = [
+        `or`,
+        `like`,
+        `ilike`,
+        `upper`,
+        `lower`,
+        `length`,
+        `concat`,
+        `add`,
+        `coalesce`,
+        `count`,
+        `avg`,
+        `sum`,
+        `min`,
+        `max`,
+      ]
+      if (unsupportedOps.includes(e.name)) {
+        throw new Error(
+          `extractSimpleComparisons does not support '${e.name}' operator. Use parseWhereExpression with custom handlers for complex expressions.`,
+        )
+      }
+
+      // Handle null/undefined check operators (single argument, no value)
+      const nullCheckOps = [`isNull`, `isUndefined`]
+      if (nullCheckOps.includes(e.name)) {
+        const [fieldArg] = e.args
+
+        // Extract field (must be a ref)
+        const field = fieldArg?.type === `ref` ? fieldArg.path : null
+
+        if (field) {
+          comparisons.push({
+            field,
+            operator: e.name,
+            // No value for null/undefined checks
+          })
+        } else {
+          throw new Error(
+            `extractSimpleComparisons requires a field reference for '${e.name}' operator.`,
+          )
+        }
+        return
+      }
+
+      // Handle comparison operators
+      const comparisonOps = [`eq`, `gt`, `gte`, `lt`, `lte`, `in`]
+      if (comparisonOps.includes(e.name)) {
+        const [leftArg, rightArg] = e.args
+
+        // Extract field and value
+        const field = leftArg?.type === `ref` ? leftArg.path : null
+        const value = rightArg?.type === `val` ? rightArg.value : null
+
+        if (field && value !== undefined) {
+          comparisons.push({
+            field,
+            operator: e.name,
+            value,
+          })
+        } else {
+          throw new Error(
+            `extractSimpleComparisons requires simple field-value comparisons. Found complex expression for '${e.name}' operator.`,
+          )
+        }
+      } else {
+        // Unknown operator
+        throw new Error(
+          `extractSimpleComparisons encountered unknown operator: '${e.name}'`,
+        )
+      }
+    }
+  }
+
+  extract(expr)
+  return comparisons
+}
+
+/**
+ * Convenience function to get all LoadSubsetOptions in a pre-parsed format.
+ * Good starting point for simple use cases.
+ *
+ * @param options - The LoadSubsetOptions from ctx.meta
+ * @returns Pre-parsed filters, sorts, and limit
+ *
+ * @example
+ * ```typescript
+ * queryFn: async (ctx) => {
+ *   const parsed = parseLoadSubsetOptions(ctx.meta?.loadSubsetOptions)
+ *
+ *   // Convert to your API format
+ *   return api.getProducts({
+ *     ...Object.fromEntries(
+ *       parsed.filters.map(f => [`${f.field.join('.')}_${f.operator}`, f.value])
+ *     ),
+ *     sort: parsed.sorts.map(s => `${s.field.join('.')}:${s.direction}`).join(','),
+ *     limit: parsed.limit
+ *   })
+ * }
+ * ```
+ */
+export function parseLoadSubsetOptions(
+  options:
+    | {
+        where?: BasicExpression<boolean>
+        orderBy?: OrderBy
+        limit?: number
+      }
+    | undefined
+    | null,
+): {
+  filters: Array<SimpleComparison>
+  sorts: Array<ParsedOrderBy>
+  limit?: number
+} {
+  if (!options) {
+    return { filters: [], sorts: [] }
+  }
+
+  return {
+    filters: extractSimpleComparisons(options.where),
+    sorts: parseOrderByExpression(options.orderBy),
+    limit: options.limit,
+  }
+}
diff --git a/packages/db/src/query/index.ts b/packages/db/src/query/index.ts
index 17f4dd8e7..524b4dcf1 100644
--- a/packages/db/src/query/index.ts
+++ b/packages/db/src/query/index.ts
@@ -10,7 +10,9 @@ export {
   type Source,
   type GetResult,
   type InferResultType,
-} from "./builder/index.js"
+  type ExtractContext,
+  type QueryResult,
+} from './builder/index.js'
 
 // Expression functions exports
 export {
@@ -41,19 +43,32 @@ export {
   sum,
   min,
   max,
-} from "./builder/functions.js"
+} from './builder/functions.js'
 
 // Ref proxy utilities
-export type { Ref } from "./builder/types.js"
+export type { Ref } from './builder/types.js'
 
 // Compiler
-export { compileQuery } from "./compiler/index.js"
+export { compileQuery } from './compiler/index.js'
 
 // Live query collection utilities
 export {
   createLiveQueryCollection,
   liveQueryCollectionOptions,
-} from "./live-query-collection.js"
+} from './live-query-collection.js'
 
-export { type LiveQueryCollectionConfig } from "./live/types.js"
-export { type LiveQueryCollectionUtils } from "./live/collection-config-builder.js"
+export { type LiveQueryCollectionConfig } from './live/types.js'
+export { type LiveQueryCollectionUtils } from './live/collection-config-builder.js'
+
+// Predicate utilities for predicate push-down
+export {
+  isWhereSubset,
+  unionWherePredicates,
+  minusWherePredicates,
+  isOrderBySubset,
+  isLimitSubset,
+  isOffsetLimitSubset,
+  isPredicateSubset,
+} from './predicate-utils.js'
+
+export { DeduplicatedLoadSubset } from './subset-dedupe.js'
diff --git a/packages/db/src/query/ir.ts b/packages/db/src/query/ir.ts
index d493aaa64..b1e3d1e07 100644
--- a/packages/db/src/query/ir.ts
+++ b/packages/db/src/query/ir.ts
@@ -2,9 +2,9 @@
 This is the intermediate representation of the query.
 */
 
-import type { CompareOptions } from "./builder/types"
-import type { Collection, CollectionImpl } from "../collection/index.js"
-import type { NamespacedRow } from "../types"
+import type { CompareOptions } from './builder/types'
+import type { Collection, CollectionImpl } from '../collection/index.js'
+import type { NamespacedRow } from '../types'
 
 export interface QueryIR {
   from: From
@@ -73,7 +73,7 @@ export class CollectionRef extends BaseExpression {
   public type = `collectionRef` as const
   constructor(
     public collection: CollectionImpl,
-    public alias: string
+    public alias: string,
   ) {
     super()
   }
@@ -83,7 +83,7 @@ export class QueryRef extends BaseExpression {
   public type = `queryRef` as const
   constructor(
     public query: QueryIR,
-    public alias: string
+    public alias: string,
   ) {
     super()
   }
@@ -92,7 +92,7 @@ export class QueryRef extends BaseExpression {
 export class PropRef<T = any> extends BaseExpression<T> {
   public type = `ref` as const
   constructor(
-    public path: Array<string> // path to the property in the collection, with the alias as the first element
+    public path: Array<string>, // path to the property in the collection, with the alias as the first element
   ) {
     super()
   }
@@ -101,7 +101,7 @@ export class PropRef<T = any> extends BaseExpression<T> {
 export class Value<T = any> extends BaseExpression<T> {
   public type = `val` as const
   constructor(
-    public value: T // any js value
+    public value: T, // any js value
   ) {
     super()
   }
@@ -111,7 +111,7 @@ export class Func<T = any> extends BaseExpression<T> {
   public type = `func` as const
   constructor(
     public name: string, // such as eq, gt, lt, upper, lower, etc.
-    public args: Array<BasicExpression>
+    public args: Array<BasicExpression>,
   ) {
     super()
   }
@@ -126,7 +126,7 @@ export class Aggregate<T = any> extends BaseExpression<T> {
   public type = `agg` as const
   constructor(
     public name: string, // such as count, avg, sum, min, max, etc.
-    public args: Array<BasicExpression>
+    public args: Array<BasicExpression>,
   ) {
     super()
   }
@@ -163,7 +163,7 @@ export function getWhereExpression(where: Where): BasicExpression<boolean> {
  * HAVING clauses can contain aggregates, unlike regular WHERE clauses
  */
 export function getHavingExpression(
-  having: Having
+  having: Having,
 ): BasicExpression | Aggregate {
   return typeof having === `object` && `expression` in having
     ? having.expression
@@ -185,14 +185,14 @@ export function isResidualWhere(where: Where): boolean {
  * Create a residual Where clause from an expression
  */
 export function createResidualWhere(
-  expression: BasicExpression<boolean>
+  expression: BasicExpression<boolean>,
 ): Where {
   return { expression, residual: true }
 }
 
 function getRefFromAlias(
   query: QueryIR,
-  alias: string
+  alias: string,
 ): CollectionRef | QueryRef | void {
   if (query.from.alias === alias) {
     return query.from
@@ -213,7 +213,7 @@ function getRefFromAlias(
 export function followRef(
   query: QueryIR,
   ref: PropRef<any>,
-  collection: Collection
+  collection: Collection,
 ): { collection: Collection; path: Array<string> } | void {
   if (ref.path.length === 0) {
     return
diff --git a/packages/db/src/query/live-query-collection.ts b/packages/db/src/query/live-query-collection.ts
index 5e4355a48..47eceac15 100644
--- a/packages/db/src/query/live-query-collection.ts
+++ b/packages/db/src/query/live-query-collection.ts
@@ -1,21 +1,21 @@
-import { createCollection } from "../collection/index.js"
-import { CollectionConfigBuilder } from "./live/collection-config-builder.js"
+import { createCollection } from '../collection/index.js'
+import { CollectionConfigBuilder } from './live/collection-config-builder.js'
 import {
   getBuilderFromConfig,
   registerCollectionBuilder,
-} from "./live/collection-registry.js"
-import type { LiveQueryCollectionUtils } from "./live/collection-config-builder.js"
-import type { LiveQueryCollectionConfig } from "./live/types.js"
-import type { InitialQueryBuilder, QueryBuilder } from "./builder/index.js"
-import type { Collection } from "../collection/index.js"
+} from './live/collection-registry.js'
+import type { LiveQueryCollectionUtils } from './live/collection-config-builder.js'
+import type { LiveQueryCollectionConfig } from './live/types.js'
+import type { InitialQueryBuilder, QueryBuilder } from './builder/index.js'
+import type { Collection } from '../collection/index.js'
 import type {
   CollectionConfig,
   CollectionConfigSingleRowOption,
   NonSingleResult,
   SingleResult,
   UtilsRecord,
-} from "../types.js"
-import type { Context, GetResult } from "./builder/types.js"
+} from '../types.js'
+import type { Context, GetResult } from './builder/types.js'
 
 type CollectionConfigForContext<
   TContext extends Context,
@@ -63,7 +63,7 @@ export function liveQueryCollectionOptions<
   TContext extends Context,
   TResult extends object = GetResult<TContext>,
 >(
-  config: LiveQueryCollectionConfig<TContext, TResult>
+  config: LiveQueryCollectionConfig<TContext, TResult>,
 ): CollectionConfigForContext<TContext, TResult> & {
   utils: LiveQueryCollectionUtils
 } {
@@ -116,7 +116,7 @@ export function createLiveQueryCollection<
   TContext extends Context,
   TResult extends object = GetResult<TContext>,
 >(
-  query: (q: InitialQueryBuilder) => QueryBuilder<TContext>
+  query: (q: InitialQueryBuilder) => QueryBuilder<TContext>,
 ): CollectionForContext<TContext, TResult> & {
   utils: LiveQueryCollectionUtils
 }
@@ -127,7 +127,7 @@ export function createLiveQueryCollection<
   TResult extends object = GetResult<TContext>,
   TUtils extends UtilsRecord = {},
 >(
-  config: LiveQueryCollectionConfig<TContext, TResult> & { utils?: TUtils }
+  config: LiveQueryCollectionConfig<TContext, TResult> & { utils?: TUtils },
 ): CollectionForContext<TContext, TResult> & {
   utils: LiveQueryCollectionUtils & TUtils
 }
@@ -140,7 +140,7 @@ export function createLiveQueryCollection<
 >(
   configOrQuery:
     | (LiveQueryCollectionConfig<TContext, TResult> & { utils?: TUtils })
-    | ((q: InitialQueryBuilder) => QueryBuilder<TContext>)
+    | ((q: InitialQueryBuilder) => QueryBuilder<TContext>),
 ): CollectionForContext<TContext, TResult> & {
   utils: LiveQueryCollectionUtils & TUtils
 } {
@@ -149,7 +149,7 @@ export function createLiveQueryCollection<
     // Simple query function case
     const config: LiveQueryCollectionConfig<TContext, TResult> = {
       query: configOrQuery as (
-        q: InitialQueryBuilder
+        q: InitialQueryBuilder,
       ) => QueryBuilder<TContext>,
     }
     const options = liveQueryCollectionOptions<TContext, TResult>(config)
@@ -185,7 +185,7 @@ function bridgeToCreateCollection<
   TResult extends object,
   TUtils extends UtilsRecord = {},
 >(
-  options: CollectionConfig<TResult> & { utils: TUtils }
+  options: CollectionConfig<TResult> & { utils: TUtils },
 ): Collection<TResult, string | number, TUtils> {
   const collection = createCollection(options as any) as unknown as Collection<
     TResult,
diff --git a/packages/db/src/query/live/collection-config-builder.ts b/packages/db/src/query/live/collection-config-builder.ts
index eef3241dc..21cd04d1d 100644
--- a/packages/db/src/query/live/collection-config-builder.ts
+++ b/packages/db/src/query/live/collection-config-builder.ts
@@ -1,41 +1,43 @@
-import { D2, output } from "@tanstack/db-ivm"
-import { compileQuery } from "../compiler/index.js"
-import { buildQuery, getQueryIR } from "../builder/index.js"
+import { D2, output } from '@tanstack/db-ivm'
+import { compileQuery } from '../compiler/index.js'
+import { buildQuery, getQueryIR } from '../builder/index.js'
 import {
   MissingAliasInputsError,
   SetWindowRequiresOrderByError,
-} from "../../errors.js"
-import { transactionScopedScheduler } from "../../scheduler.js"
-import { getActiveTransaction } from "../../transactions.js"
-import { CollectionSubscriber } from "./collection-subscriber.js"
-import { getCollectionBuilder } from "./collection-registry.js"
-import type { WindowOptions } from "../compiler/index.js"
-import type { SchedulerContextId } from "../../scheduler.js"
-import type { CollectionSubscription } from "../../collection/subscription.js"
-import type { RootStreamBuilder } from "@tanstack/db-ivm"
-import type { OrderByOptimizationInfo } from "../compiler/order-by.js"
-import type { Collection } from "../../collection/index.js"
+} from '../../errors.js'
+import { transactionScopedScheduler } from '../../scheduler.js'
+import { getActiveTransaction } from '../../transactions.js'
+import { CollectionSubscriber } from './collection-subscriber.js'
+import { getCollectionBuilder } from './collection-registry.js'
+import { LIVE_QUERY_INTERNAL } from './internal.js'
+import type { LiveQueryInternalUtils } from './internal.js'
+import type { WindowOptions } from '../compiler/index.js'
+import type { SchedulerContextId } from '../../scheduler.js'
+import type { CollectionSubscription } from '../../collection/subscription.js'
+import type { RootStreamBuilder } from '@tanstack/db-ivm'
+import type { OrderByOptimizationInfo } from '../compiler/order-by.js'
+import type { Collection } from '../../collection/index.js'
 import type {
   CollectionConfigSingleRowOption,
   KeyedStream,
   ResultStream,
+  StringCollationConfig,
   SyncConfig,
   UtilsRecord,
-} from "../../types.js"
-import type { Context, GetResult } from "../builder/types.js"
-import type { BasicExpression, QueryIR } from "../ir.js"
-import type { LazyCollectionCallbacks } from "../compiler/joins.js"
+} from '../../types.js'
+import type { Context, GetResult } from '../builder/types.js'
+import type { BasicExpression, QueryIR } from '../ir.js'
+import type { LazyCollectionCallbacks } from '../compiler/joins.js'
 import type {
   Changes,
   FullSyncState,
   LiveQueryCollectionConfig,
   SyncState,
-} from "./types.js"
-import type { AllCollectionEvents } from "../../collection/events.js"
+} from './types.js'
+import type { AllCollectionEvents } from '../../collection/events.js'
 
 export type LiveQueryCollectionUtils = UtilsRecord & {
   getRunCount: () => number
-  getBuilder: () => CollectionConfigBuilder<any, any>
   /**
    * Sets the offset and limit of an ordered query.
    * Is a no-op if the query is not ordered.
@@ -49,6 +51,7 @@ export type LiveQueryCollectionUtils = UtilsRecord & {
    * @returns The current window settings, or `undefined` if the query is not windowed
    */
   getWindow: () => { offset: number; limit: number } | undefined
+  [LIVE_QUERY_INTERNAL]: LiveQueryInternalUtils
 }
 
 type PendingGraphRun = {
@@ -81,6 +84,7 @@ export class CollectionConfigBuilder<
   private readonly orderByIndices = new WeakMap<object, string>()
 
   private readonly compare?: (val1: TResult, val2: TResult) => number
+  private readonly compareOptions?: StringCollationConfig
 
   private isGraphRunning = false
   private runCount = 0
@@ -142,7 +146,7 @@ export class CollectionConfigBuilder<
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo> = {}
 
   constructor(
-    private readonly config: LiveQueryCollectionConfig<TContext, TResult>
+    private readonly config: LiveQueryCollectionConfig<TContext, TResult>,
   ) {
     // Generate a unique ID if not provided
     this.id = config.id || `live-query-${++liveQueryCollectionCounter}`
@@ -168,11 +172,35 @@ export class CollectionConfigBuilder<
       this.compare = createOrderByComparator<TResult>(this.orderByIndices)
     }
 
+    // Use explicitly provided compareOptions if available, otherwise inherit from FROM collection
+    this.compareOptions =
+      this.config.defaultStringCollation ??
+      extractCollectionFromSource(this.query).compareOptions
+
     // Compile the base pipeline once initially
     // This is done to ensure that any errors are thrown immediately and synchronously
     this.compileBasePipeline()
   }
 
+  /**
+   * Recursively checks if a query or any of its subqueries contains joins
+   */
+  private hasJoins(query: QueryIR): boolean {
+    // Check if this query has joins
+    if (query.join && query.join.length > 0) {
+      return true
+    }
+
+    // Recursively check subqueries in the from clause
+    if (query.from.type === `queryRef`) {
+      if (this.hasJoins(query.from.query)) {
+        return true
+      }
+    }
+
+    return false
+  }
+
   getConfig(): CollectionConfigSingleRowOption<TResult> & {
     utils: LiveQueryCollectionUtils
   } {
@@ -183,6 +211,7 @@ export class CollectionConfigBuilder<
         ((item) => this.resultKeys.get(item) as string | number),
       sync: this.getSyncConfig(),
       compare: this.compare,
+      defaultStringCollation: this.compareOptions,
       gcTime: this.config.gcTime || 5000, // 5 seconds by default for live queries
       schema: this.config.schema,
       onInsert: this.config.onInsert,
@@ -192,9 +221,14 @@ export class CollectionConfigBuilder<
       singleResult: this.query.singleResult,
       utils: {
         getRunCount: this.getRunCount.bind(this),
-        getBuilder: () => this,
         setWindow: this.setWindow.bind(this),
         getWindow: this.getWindow.bind(this),
+        [LIVE_QUERY_INTERNAL]: {
+          getBuilder: () => this,
+          hasCustomGetKey: !!this.config.getKey,
+          hasJoins: this.hasJoins(this.query),
+          hasDistinct: !!this.query.distinct,
+        },
       },
     }
   }
@@ -219,7 +253,7 @@ export class CollectionConfigBuilder<
               unsubscribe()
               resolve()
             }
-          }
+          },
         )
       })
     }
@@ -285,7 +319,7 @@ export class CollectionConfigBuilder<
     // Should only be called when sync is active
     if (!this.currentSyncConfig || !this.currentSyncState) {
       throw new Error(
-        `maybeRunGraph called without active sync session. This should not happen.`
+        `maybeRunGraph called without active sync session. This should not happen.`,
       )
     }
 
@@ -304,6 +338,10 @@ export class CollectionConfigBuilder<
       if (syncState.subscribedToAllCollections) {
         while (syncState.graph.pendingWork()) {
           syncState.graph.run()
+          // Flush accumulated changes after each graph step to commit them as one transaction.
+          // This ensures intermediate join states (like null on one side) don't cause
+          // duplicate key errors when the full join result arrives in the same step.
+          syncState.flushPendingChanges?.()
           callback?.()
         }
 
@@ -312,10 +350,14 @@ export class CollectionConfigBuilder<
         if (syncState.messagesCount === 0) {
           begin()
           commit()
-          // After initial commit, check if we should mark ready
-          // (in case all sources were already ready before we subscribed)
-          this.updateLiveQueryStatus(this.currentSyncConfig)
         }
+
+        // After graph processing completes, check if we should mark ready.
+        // This is the canonical place to transition to ready state because:
+        // 1. All data has been processed through the graph
+        // 2. All source collections have had a chance to send their initial data
+        // This prevents marking ready before data is processed (fixes isReady=true with empty data)
+        this.updateLiveQueryStatus(this.currentSyncConfig)
       }
     } finally {
       this.isGraphRunning = false
@@ -347,7 +389,7 @@ export class CollectionConfigBuilder<
       jobId?: unknown
       alias?: string
       dependencies?: Array<CollectionConfigBuilder<any, any>>
-    }
+    },
   ) {
     const contextId = options?.contextId ?? getActiveTransaction()?.id
     // Use the builder instance as the job ID for deduplication. This is memory-safe
@@ -373,13 +415,23 @@ export class CollectionConfigBuilder<
       return Array.from(deps)
     })()
 
+    // Ensure dependent builders are actually scheduled in this context so that
+    // dependency edges always point to a real job (or a deduped no-op if already scheduled).
+    if (contextId) {
+      for (const dep of dependentBuilders) {
+        if (typeof dep.scheduleGraphRun === `function`) {
+          dep.scheduleGraphRun(undefined, { contextId })
+        }
+      }
+    }
+
     // We intentionally scope deduplication to the builder instance. Each instance
     // owns caches and compiled pipelines, so sharing work across instances that
     // merely reuse the same string id would execute the wrong builder's graph.
 
     if (!this.currentSyncConfig || !this.currentSyncState) {
       throw new Error(
-        `scheduleGraphRun called without active sync session. This should not happen.`
+        `scheduleGraphRun called without active sync session. This should not happen.`,
       )
     }
 
@@ -418,6 +470,13 @@ export class CollectionConfigBuilder<
     this.pendingGraphRuns.delete(contextId)
   }
 
+  /**
+   * Returns true if this builder has a pending graph run for the given context.
+   */
+  hasPendingGraphRun(contextId: SchedulerContextId): boolean {
+    return this.pendingGraphRuns.has(contextId)
+  }
+
   /**
    * Executes a pending graph run. Called by the scheduler when dependencies are satisfied.
    * Clears the pending state BEFORE execution so that any re-schedules during the run
@@ -429,7 +488,7 @@ export class CollectionConfigBuilder<
    */
   private executeGraphRun(
     contextId?: SchedulerContextId,
-    pendingParam?: PendingGraphRun
+    pendingParam?: PendingGraphRun,
   ): void {
     // Get pending state: either from parameter (no context) or from map (with context)
     // Remove from map BEFORE checking sync state to prevent leaking entries when sync ends
@@ -504,7 +563,7 @@ export class CollectionConfigBuilder<
     // Extend the pipeline such that it applies the incoming changes to the collection
     const fullSyncState = this.extendPipelineWithChangeProcessing(
       config,
-      syncState
+      syncState,
     )
     this.currentSyncState = fullSyncState
 
@@ -513,12 +572,27 @@ export class CollectionConfigBuilder<
     this.unsubscribeFromSchedulerClears = transactionScopedScheduler.onClear(
       (contextId) => {
         this.clearPendingGraphRun(contextId)
-      }
+      },
+    )
+
+    // Listen for loadingSubset changes on the live query collection BEFORE subscribing.
+    // This ensures we don't miss the event if subset loading completes synchronously.
+    // When isLoadingSubset becomes false, we may need to mark the collection as ready
+    // (if all source collections are already ready but we were waiting for subset load to complete)
+    const loadingSubsetUnsubscribe = config.collection.on(
+      `loadingSubset:change`,
+      (event) => {
+        if (!event.isLoadingSubset) {
+          // Subset loading finished, check if we can now mark ready
+          this.updateLiveQueryStatus(config)
+        }
+      },
     )
+    syncState.unsubscribeCallbacks.add(loadingSubsetUnsubscribe)
 
     const loadSubsetDataCallbacks = this.subscribeToAllCollections(
       config,
-      fullSyncState
+      fullSyncState,
     )
 
     this.maybeRunGraphFn = () => this.scheduleGraphRun(loadSubsetDataCallbacks)
@@ -553,7 +627,7 @@ export class CollectionConfigBuilder<
       // Clear subscription references to prevent memory leaks
       // Note: Individual subscriptions are already unsubscribed via unsubscribeCallbacks
       Object.keys(this.subscriptions).forEach(
-        (key) => delete this.subscriptions[key]
+        (key) => delete this.subscriptions[key],
       )
       this.compiledAliasToCollectionId = {}
 
@@ -573,7 +647,7 @@ export class CollectionConfigBuilder<
       Object.keys(this.collectionByAlias).map((alias) => [
         alias,
         this.graphCache!.newInput<any>(),
-      ])
+      ]),
     )
 
     const compilation = compileQuery(
@@ -586,7 +660,7 @@ export class CollectionConfigBuilder<
       this.optimizableOrderByCollections,
       (windowFn: (options: WindowOptions) => void) => {
         this.windowFn = windowFn
-      }
+      },
     )
 
     this.pipelineCache = compilation.pipeline
@@ -597,7 +671,7 @@ export class CollectionConfigBuilder<
     // This should never happen since all aliases come from user declarations,
     // but catch it early if the assumption is violated in the future.
     const missingAliases = Object.keys(this.compiledAliasToCollectionId).filter(
-      (alias) => !Object.hasOwn(this.inputsCache!, alias)
+      (alias) => !Object.hasOwn(this.inputsCache!, alias),
     )
     if (missingAliases.length > 0) {
       throw new MissingAliasInputsError(missingAliases)
@@ -617,27 +691,40 @@ export class CollectionConfigBuilder<
 
   private extendPipelineWithChangeProcessing(
     config: SyncMethods<TResult>,
-    syncState: SyncState
+    syncState: SyncState,
   ): FullSyncState {
     const { begin, commit } = config
     const { graph, inputs, pipeline } = this.maybeCompileBasePipeline()
 
+    // Accumulator for changes across all output callbacks within a single graph run.
+    // This allows us to batch all changes from intermediate join states into a single
+    // transaction, avoiding duplicate key errors when joins produce multiple outputs
+    // for the same key (e.g., first output with null, then output with joined data).
+    let pendingChanges: Map<unknown, Changes<TResult>> = new Map()
+
     pipeline.pipe(
       output((data) => {
         const messages = data.getInner()
         syncState.messagesCount += messages.length
 
-        begin()
-        messages
-          .reduce(
-            accumulateChanges<TResult>,
-            new Map<unknown, Changes<TResult>>()
-          )
-          .forEach(this.applyChanges.bind(this, config))
-        commit()
-      })
+        // Accumulate changes from this output callback into the pending changes map.
+        // Changes for the same key are merged (inserts/deletes are added together).
+        messages.reduce(accumulateChanges<TResult>, pendingChanges)
+      }),
     )
 
+    // Flush pending changes and reset the accumulator.
+    // Called at the end of each graph run to commit all accumulated changes.
+    syncState.flushPendingChanges = () => {
+      if (pendingChanges.size === 0) {
+        return
+      }
+      begin()
+      pendingChanges.forEach(this.applyChanges.bind(this, config))
+      commit()
+      pendingChanges = new Map()
+    }
+
     graph.finalize()
 
     // Extend the sync state with the graph, inputs, and pipeline
@@ -656,7 +743,7 @@ export class CollectionConfigBuilder<
       value: TResult
       orderByIndex: string | undefined
     },
-    key: unknown
+    key: unknown,
   ) {
     const { write, collection } = config
     const { deletes, inserts, value, orderByIndex } = changes
@@ -695,7 +782,7 @@ export class CollectionConfigBuilder<
       })
     } else {
       throw new Error(
-        `Could not apply changes: ${JSON.stringify(changes)}. This should never happen.`
+        `Could not apply changes: ${JSON.stringify(changes)}. This should never happen.`,
       )
     }
   }
@@ -706,14 +793,14 @@ export class CollectionConfigBuilder<
   private handleSourceStatusChange(
     config: SyncMethods<TResult>,
     collectionId: string,
-    event: AllCollectionEvents[`status:change`]
+    event: AllCollectionEvents[`status:change`],
   ) {
     const { status } = event
 
     // Handle error state - any source collection in error puts live query in error
     if (status === `error`) {
       this.transitionToError(
-        `Source collection '${collectionId}' entered error state`
+        `Source collection '${collectionId}' entered error state`,
       )
       return
     }
@@ -723,7 +810,7 @@ export class CollectionConfigBuilder<
     if (status === `cleaned-up`) {
       this.transitionToError(
         `Source collection '${collectionId}' was manually cleaned up while live query '${this.id}' depends on it. ` +
-          `Live queries prevent automatic GC, so this was likely a manual cleanup() call.`
+          `Live queries prevent automatic GC, so this was likely a manual cleanup() call.`,
       )
       return
     }
@@ -743,8 +830,17 @@ export class CollectionConfigBuilder<
       return
     }
 
-    // Mark ready when all source collections are ready
-    if (this.allCollectionsReady()) {
+    // Mark ready when:
+    // 1. All subscriptions are set up (subscribedToAllCollections)
+    // 2. All source collections are ready
+    // 3. The live query collection is not loading subset data
+    // This prevents marking the live query ready before its data is processed
+    // (fixes issue where useLiveQuery returns isReady=true with empty data)
+    if (
+      this.currentSyncState?.subscribedToAllCollections &&
+      this.allCollectionsReady() &&
+      !this.liveQueryCollection?.isLoadingSubset
+    ) {
       markReady()
     }
   }
@@ -764,7 +860,7 @@ export class CollectionConfigBuilder<
 
   private allCollectionsReady() {
     return Object.values(this.collections).every((collection) =>
-      collection.isReady()
+      collection.isReady(),
     )
   }
 
@@ -775,14 +871,14 @@ export class CollectionConfigBuilder<
    */
   private subscribeToAllCollections(
     config: SyncMethods<TResult>,
-    syncState: FullSyncState
+    syncState: FullSyncState,
   ) {
     // Use compiled aliases as the source of truth - these include all aliases from the query
     // including those from subqueries, which may not be in collectionByAlias
     const compiledAliases = Object.entries(this.compiledAliasToCollectionId)
     if (compiledAliases.length === 0) {
       throw new Error(
-        `Compiler returned no alias metadata for query '${this.id}'. This should not happen; please report.`
+        `Compiler returned no alias metadata for query '${this.id}'. This should not happen; please report.`,
       )
     }
 
@@ -807,7 +903,7 @@ export class CollectionConfigBuilder<
         alias,
         collectionId,
         collection,
-        this
+        this,
       )
 
       // Subscribe to status changes for status flow
@@ -824,7 +920,7 @@ export class CollectionConfigBuilder<
       // Create a callback for loading more data if needed (used by OrderBy optimization)
       const loadMore = collectionSubscriber.loadMoreIfNeeded.bind(
         collectionSubscriber,
-        subscription
+        subscription,
       )
 
       return loadMore
@@ -842,15 +938,17 @@ export class CollectionConfigBuilder<
     // (graph only runs when all collections are subscribed)
     syncState.subscribedToAllCollections = true
 
-    // Initial status check after all subscriptions are set up
-    this.updateLiveQueryStatus(config)
+    // Note: We intentionally don't call updateLiveQueryStatus() here.
+    // The graph hasn't run yet, so marking ready would be premature.
+    // The canonical place to mark ready is after the graph processes data
+    // in maybeRunGraph(), which ensures data has been processed first.
 
     return loadSubsetDataCallbacks
   }
 }
 
 function buildQueryFromConfig<TContext extends Context>(
-  config: LiveQueryCollectionConfig<any, any>
+  config: LiveQueryCollectionConfig<any, any>,
 ) {
   // Build the query using the provided query builder function or instance
   if (typeof config.query === `function`) {
@@ -860,7 +958,7 @@ function buildQueryFromConfig<TContext extends Context>(
 }
 
 function createOrderByComparator<T extends object>(
-  orderByIndices: WeakMap<object, string>
+  orderByIndices: WeakMap<object, string>,
 ) {
   return (val1: T, val2: T): number => {
     // Use the orderBy index stored in the WeakMap
@@ -889,7 +987,7 @@ function createOrderByComparator<T extends object>(
  * Maps collections by their ID (not alias) as expected by the compiler
  */
 function extractCollectionsFromQuery(
-  query: any
+  query: any,
 ): Record<string, Collection<any, any, any>> {
   const collections: Record<string, any> = {}
 
@@ -926,6 +1024,25 @@ function extractCollectionsFromQuery(
   return collections
 }
 
+/**
+ * Helper function to extract the collection that is referenced in the query's FROM clause.
+ * The FROM clause may refer directly to a collection or indirectly to a subquery.
+ */
+function extractCollectionFromSource(query: any): Collection<any, any, any> {
+  const from = query.from
+
+  if (from.type === `collectionRef`) {
+    return from.collection
+  } else if (from.type === `queryRef`) {
+    // Recursively extract from subquery
+    return extractCollectionFromSource(from.query)
+  }
+
+  throw new Error(
+    `Failed to extract collection. Invalid FROM clause: ${JSON.stringify(query)}`,
+  )
+}
+
 /**
  * Extracts all aliases used for each collection across the entire query tree.
  *
@@ -990,7 +1107,7 @@ function accumulateChanges<T>(
   [[key, tupleData], multiplicity]: [
     [unknown, [any, string | undefined]],
     number,
-  ]
+  ],
 ) {
   // All queries now consistently return [value, orderByIndex] format
   // where orderByIndex is undefined for queries without ORDER BY
@@ -1006,8 +1123,11 @@ function accumulateChanges<T>(
     changes.deletes += Math.abs(multiplicity)
   } else if (multiplicity > 0) {
     changes.inserts += multiplicity
+    // Update value to the latest version for this key
     changes.value = value
-    changes.orderByIndex = orderByIndex
+    if (orderByIndex !== undefined) {
+      changes.orderByIndex = orderByIndex
+    }
   }
   acc.set(key, changes)
   return acc
diff --git a/packages/db/src/query/live/collection-registry.ts b/packages/db/src/query/live/collection-registry.ts
index 72921604b..d17b182f9 100644
--- a/packages/db/src/query/live/collection-registry.ts
+++ b/packages/db/src/query/live/collection-registry.ts
@@ -1,5 +1,6 @@
-import type { Collection } from "../../collection/index.js"
-import type { CollectionConfigBuilder } from "./collection-config-builder.js"
+import { LIVE_QUERY_INTERNAL } from './internal.js'
+import type { Collection } from '../../collection/index.js'
+import type { CollectionConfigBuilder } from './collection-config-builder.js'
 
 const collectionBuilderRegistry = new WeakMap<
   Collection<any, any, any>,
@@ -7,15 +8,15 @@ const collectionBuilderRegistry = new WeakMap<
 >()
 
 /**
- * Retrieves the builder attached to a config object via its utils.getBuilder() method.
+ * Retrieves the builder attached to a config object via its internal utils.
  *
  * @param config - The collection config object
  * @returns The attached builder, or `undefined` if none exists
  */
 export function getBuilderFromConfig(
-  config: object
+  config: object,
 ): CollectionConfigBuilder<any, any> | undefined {
-  return (config as any).utils?.getBuilder?.()
+  return (config as any).utils?.[LIVE_QUERY_INTERNAL]?.getBuilder?.()
 }
 
 /**
@@ -28,7 +29,7 @@ export function getBuilderFromConfig(
  */
 export function registerCollectionBuilder(
   collection: Collection<any, any, any>,
-  builder: CollectionConfigBuilder<any, any>
+  builder: CollectionConfigBuilder<any, any>,
 ): void {
   collectionBuilderRegistry.set(collection, builder)
 }
@@ -41,7 +42,7 @@ export function registerCollectionBuilder(
  * @returns The registered builder, or `undefined` if none exists
  */
 export function getCollectionBuilder(
-  collection: Collection<any, any, any>
+  collection: Collection<any, any, any>,
 ): CollectionConfigBuilder<any, any> | undefined {
   return collectionBuilderRegistry.get(collection)
 }
diff --git a/packages/db/src/query/live/collection-subscriber.ts b/packages/db/src/query/live/collection-subscriber.ts
index 5835a2f0e..ec4876b74 100644
--- a/packages/db/src/query/live/collection-subscriber.ts
+++ b/packages/db/src/query/live/collection-subscriber.ts
@@ -1,20 +1,22 @@
-import { MultiSet } from "@tanstack/db-ivm"
+import { MultiSet } from '@tanstack/db-ivm'
 import {
-  convertOrderByToBasicExpression,
-  convertToBasicExpression,
-} from "../compiler/expressions.js"
-import { WhereClauseConversionError } from "../../errors.js"
-import type { MultiSetArray, RootStreamBuilder } from "@tanstack/db-ivm"
-import type { Collection } from "../../collection/index.js"
-import type { ChangeMessage } from "../../types.js"
-import type { Context, GetResult } from "../builder/types.js"
-import type { BasicExpression } from "../ir.js"
-import type { OrderByOptimizationInfo } from "../compiler/order-by.js"
-import type { CollectionConfigBuilder } from "./collection-config-builder.js"
-import type { CollectionSubscription } from "../../collection/subscription.js"
+  normalizeExpressionPaths,
+  normalizeOrderByPaths,
+} from '../compiler/expressions.js'
+import type { MultiSetArray, RootStreamBuilder } from '@tanstack/db-ivm'
+import type { Collection } from '../../collection/index.js'
+import type {
+  ChangeMessage,
+  SubscriptionStatusChangeEvent,
+} from '../../types.js'
+import type { Context, GetResult } from '../builder/types.js'
+import type { BasicExpression } from '../ir.js'
+import type { OrderByOptimizationInfo } from '../compiler/order-by.js'
+import type { CollectionConfigBuilder } from './collection-config-builder.js'
+import type { CollectionSubscription } from '../../collection/subscription.js'
 
 const loadMoreCallbackSymbol = Symbol.for(
-  `@tanstack/db.collection-config-builder`
+  `@tanstack/db.collection-config-builder`,
 )
 
 export class CollectionSubscriber<
@@ -30,82 +32,93 @@ export class CollectionSubscriber<
     { resolve: () => void }
   >()
 
+  // Track keys that have been sent to the D2 pipeline to prevent duplicate inserts
+  // This is necessary because different code paths (initial load, change events)
+  // can potentially send the same item to D2 multiple times.
+  private sentToD2Keys = new Set<string | number>()
+
   constructor(
     private alias: string,
     private collectionId: string,
     private collection: Collection,
-    private collectionConfigBuilder: CollectionConfigBuilder<TContext, TResult>
+    private collectionConfigBuilder: CollectionConfigBuilder<TContext, TResult>,
   ) {}
 
   subscribe(): CollectionSubscription {
     const whereClause = this.getWhereClauseForAlias()
 
     if (whereClause) {
-      const whereExpression = convertToBasicExpression(whereClause, this.alias)
-
-      if (whereExpression) {
-        return this.subscribeToChanges(whereExpression)
-      }
-
-      throw new WhereClauseConversionError(this.collectionId, this.alias)
+      const whereExpression = normalizeExpressionPaths(whereClause, this.alias)
+      return this.subscribeToChanges(whereExpression)
     }
 
     return this.subscribeToChanges()
   }
 
   private subscribeToChanges(whereExpression?: BasicExpression<boolean>) {
-    let subscription: CollectionSubscription
     const orderByInfo = this.getOrderByInfo()
+
+    // Track load promises using subscription from the event (avoids circular dependency)
+    const trackLoadPromise = (subscription: CollectionSubscription) => {
+      // Guard against duplicate transitions
+      if (!this.subscriptionLoadingPromises.has(subscription)) {
+        let resolve: () => void
+        const promise = new Promise<void>((res) => {
+          resolve = res
+        })
+
+        this.subscriptionLoadingPromises.set(subscription, {
+          resolve: resolve!,
+        })
+        this.collectionConfigBuilder.liveQueryCollection!._sync.trackLoadPromise(
+          promise,
+        )
+      }
+    }
+
+    // Status change handler - passed to subscribeChanges so it's registered
+    // BEFORE any snapshot is requested, preventing race conditions
+    const onStatusChange = (event: SubscriptionStatusChangeEvent) => {
+      const subscription = event.subscription as CollectionSubscription
+      if (event.status === `loadingSubset`) {
+        trackLoadPromise(subscription)
+      } else {
+        // status is 'ready'
+        const deferred = this.subscriptionLoadingPromises.get(subscription)
+        if (deferred) {
+          // Clear the map entry FIRST (before resolving)
+          this.subscriptionLoadingPromises.delete(subscription)
+          deferred.resolve()
+        }
+      }
+    }
+
+    // Create subscription with onStatusChange - listener is registered before any async work
+    let subscription: CollectionSubscription
     if (orderByInfo) {
       subscription = this.subscribeToOrderedChanges(
         whereExpression,
-        orderByInfo
+        orderByInfo,
+        onStatusChange,
       )
     } else {
       // If the source alias is lazy then we should not include the initial state
       const includeInitialState = !this.collectionConfigBuilder.isLazyAlias(
-        this.alias
+        this.alias,
       )
 
       subscription = this.subscribeToMatchingChanges(
         whereExpression,
-        includeInitialState
+        includeInitialState,
+        onStatusChange,
       )
     }
 
-    // Subscribe to subscription status changes to propagate loading state
-    const statusUnsubscribe = subscription.on(`status:change`, (event) => {
-      // TODO: For now we are setting this loading state whenever the subscription
-      // status changes to 'loadingSubset'. But we have discussed it only happening
-      // when the the live query has it's offset/limit changed, and that triggers the
-      // subscription to request a snapshot. This will require more work to implement,
-      // and builds on https://github.com/TanStack/db/pull/663 which this PR
-      // does not yet depend on.
-      if (event.status === `loadingSubset`) {
-        // Guard against duplicate transitions
-        if (!this.subscriptionLoadingPromises.has(subscription)) {
-          let resolve: () => void
-          const promise = new Promise<void>((res) => {
-            resolve = res
-          })
-
-          this.subscriptionLoadingPromises.set(subscription, {
-            resolve: resolve!,
-          })
-          this.collectionConfigBuilder.liveQueryCollection!._sync.trackLoadPromise(
-            promise
-          )
-        }
-      } else {
-        // status is 'ready'
-        const deferred = this.subscriptionLoadingPromises.get(subscription)
-        if (deferred) {
-          // Clear the map entry FIRST (before resolving)
-          this.subscriptionLoadingPromises.delete(subscription)
-          deferred.resolve()
-        }
-      }
-    })
+    // Check current status after subscribing - if status is 'loadingSubset', track it.
+    // The onStatusChange listener will catch the transition to 'ready'.
+    if (subscription.status === `loadingSubset`) {
+      trackLoadPromise(subscription)
+    }
 
     const unsubscribe = () => {
       // If subscription has a pending promise, resolve it before unsubscribing
@@ -116,29 +129,48 @@ export class CollectionSubscriber<
         deferred.resolve()
       }
 
-      statusUnsubscribe()
       subscription.unsubscribe()
     }
     // currentSyncState is always defined when subscribe() is called
     // (called during sync session setup)
     this.collectionConfigBuilder.currentSyncState!.unsubscribeCallbacks.add(
-      unsubscribe
+      unsubscribe,
     )
     return subscription
   }
 
   private sendChangesToPipeline(
     changes: Iterable<ChangeMessage<any, string | number>>,
-    callback?: () => boolean
+    callback?: () => boolean,
   ) {
+    // Filter changes to prevent duplicate inserts to D2 pipeline.
+    // This ensures D2 multiplicity stays at 1 for visible items, so deletes
+    // properly reduce multiplicity to 0 (triggering DELETE output).
+    const changesArray = Array.isArray(changes) ? changes : [...changes]
+    const filteredChanges: Array<ChangeMessage<any, string | number>> = []
+    for (const change of changesArray) {
+      if (change.type === `insert`) {
+        if (this.sentToD2Keys.has(change.key)) {
+          // Skip duplicate insert - already sent to D2
+          continue
+        }
+        this.sentToD2Keys.add(change.key)
+      } else if (change.type === `delete`) {
+        // Remove from tracking so future re-inserts are allowed
+        this.sentToD2Keys.delete(change.key)
+      }
+      // Updates are handled as delete+insert by splitUpdates, so no special handling needed
+      filteredChanges.push(change)
+    }
+
     // currentSyncState and input are always defined when this method is called
     // (only called from active subscriptions during a sync session)
     const input =
       this.collectionConfigBuilder.currentSyncState!.inputs[this.alias]!
     const sentChanges = sendChangesToInput(
       input,
-      changes,
-      this.collection.config.getKey
+      filteredChanges,
+      this.collection.config.getKey,
     )
 
     // Do not provide the callback that loads more data
@@ -156,17 +188,22 @@ export class CollectionSubscriber<
 
   private subscribeToMatchingChanges(
     whereExpression: BasicExpression<boolean> | undefined,
-    includeInitialState: boolean = false
-  ) {
+    includeInitialState: boolean,
+    onStatusChange: (event: SubscriptionStatusChangeEvent) => void,
+  ): CollectionSubscription {
     const sendChanges = (
-      changes: Array<ChangeMessage<any, string | number>>
+      changes: Array<ChangeMessage<any, string | number>>,
     ) => {
       this.sendChangesToPipeline(changes)
     }
 
+    // Create subscription with onStatusChange - listener is registered before snapshot
+    // Note: For non-ordered queries (no limit/offset), we use trackLoadSubsetPromise: false
+    // which is the default behavior in subscribeChanges
     const subscription = this.collection.subscribeChanges(sendChanges, {
-      includeInitialState,
+      ...(includeInitialState && { includeInitialState }),
       whereExpression,
+      onStatusChange,
     })
 
     return subscription
@@ -174,54 +211,71 @@ export class CollectionSubscriber<
 
   private subscribeToOrderedChanges(
     whereExpression: BasicExpression<boolean> | undefined,
-    orderByInfo: OrderByOptimizationInfo
-  ) {
-    const { orderBy, offset, limit, comparator, dataNeeded, index } =
-      orderByInfo
+    orderByInfo: OrderByOptimizationInfo,
+    onStatusChange: (event: SubscriptionStatusChangeEvent) => void,
+  ): CollectionSubscription {
+    const { orderBy, offset, limit, index } = orderByInfo
+
+    // Use a holder to forward-reference subscription in the callback
+    const subscriptionHolder: { current?: CollectionSubscription } = {}
 
     const sendChangesInRange = (
-      changes: Iterable<ChangeMessage<any, string | number>>
+      changes: Iterable<ChangeMessage<any, string | number>>,
     ) => {
       // Split live updates into a delete of the old value and an insert of the new value
-      // and filter out changes that are bigger than the biggest value we've sent so far
-      // because they can't affect the topK (and if later we need more data, we will dynamically load more data)
       const splittedChanges = splitUpdates(changes)
-      let filteredChanges = splittedChanges
-      if (dataNeeded && dataNeeded() === 0) {
-        // If the topK is full [..., maxSentValue] then we do not need to send changes > maxSentValue
-        // because they can never make it into the topK.
-        // However, if the topK isn't full yet, we need to also send changes > maxSentValue
-        // because they will make it into the topK
-        filteredChanges = filterChangesSmallerOrEqualToMax(
-          splittedChanges,
-          comparator,
-          this.biggest
-        )
-      }
-
-      this.sendChangesToPipelineWithTracking(filteredChanges, subscription)
+      this.sendChangesToPipelineWithTracking(
+        splittedChanges,
+        subscriptionHolder.current!,
+      )
     }
 
-    // Subscribe to changes and only send changes that are smaller than the biggest value we've sent so far
-    // values that are bigger don't need to be sent because they can't affect the topK
+    // Subscribe to changes with onStatusChange - listener is registered before any snapshot
+    // values bigger than what we've sent don't need to be sent because they can't affect the topK
     const subscription = this.collection.subscribeChanges(sendChangesInRange, {
       whereExpression,
+      onStatusChange,
+    })
+    subscriptionHolder.current = subscription
+
+    // Listen for truncate events to reset cursor tracking state and sentToD2Keys
+    // This ensures that after a must-refetch/truncate, we don't use stale cursor data
+    // and allow re-inserts of previously sent keys
+    const truncateUnsubscribe = this.collection.on(`truncate`, () => {
+      this.biggest = undefined
+      this.sentToD2Keys.clear()
     })
 
-    subscription.setOrderByIndex(index)
+    // Clean up truncate listener when subscription is unsubscribed
+    subscription.on(`unsubscribed`, () => {
+      truncateUnsubscribe()
+    })
 
     // Normalize the orderBy clauses such that the references are relative to the collection
-    const normalizedOrderBy = convertOrderByToBasicExpression(
-      orderBy,
-      this.alias
-    )
-
-    // Load the first `offset + limit` values from the index
-    // i.e. the K items from the collection that fall into the requested range: [offset, offset + limit[
-    subscription.requestLimitedSnapshot({
-      limit: offset + limit,
-      orderBy: normalizedOrderBy,
-    })
+    const normalizedOrderBy = normalizeOrderByPaths(orderBy, this.alias)
+
+    // Trigger the snapshot request - onStatusChange listener is already registered
+    if (index) {
+      // We have an index on the first orderBy column - use lazy loading optimization
+      // This works for both single-column and multi-column orderBy:
+      // - Single-column: index provides exact ordering
+      // - Multi-column: index provides ordering on first column, secondary sort in memory
+      subscription.setOrderByIndex(index)
+
+      // Load the first `offset + limit` values from the index
+      // i.e. the K items from the collection that fall into the requested range: [offset, offset + limit[
+      subscription.requestLimitedSnapshot({
+        limit: offset + limit,
+        orderBy: normalizedOrderBy,
+      })
+    } else {
+      // No index available (e.g., non-ref expression): pass orderBy/limit to loadSubset
+      // so the sync layer can optimize if the backend supports it
+      subscription.requestSnapshot({
+        orderBy: normalizedOrderBy,
+        limit: offset + limit,
+      })
+    }
 
     return subscription
   }
@@ -241,11 +295,10 @@ export class CollectionSubscriber<
     const { dataNeeded } = orderByInfo
 
     if (!dataNeeded) {
-      // This should never happen because the topK operator should always set the size callback
-      // which in turn should lead to the orderBy operator setting the dataNeeded callback
-      throw new Error(
-        `Missing dataNeeded callback for collection ${this.collectionId}`
-      )
+      // dataNeeded is not set when there's no index (e.g., non-ref expression).
+      // In this case, we've already loaded all data via requestSnapshot
+      // and don't need to lazily load more.
+      return true
     }
 
     // `dataNeeded` probes the orderBy operator to see if it needs more data
@@ -259,7 +312,7 @@ export class CollectionSubscriber<
 
   private sendChangesToPipelineWithTracking(
     changes: Iterable<ChangeMessage<any, string | number>>,
-    subscription: CollectionSubscription
+    subscription: CollectionSubscription,
   ) {
     const orderByInfo = this.getOrderByInfo()
     if (!orderByInfo) {
@@ -283,7 +336,7 @@ export class CollectionSubscriber<
 
     this.sendChangesToPipeline(
       trackedChanges,
-      subscriptionWithLoader[loadMoreCallbackSymbol]
+      subscriptionWithLoader[loadMoreCallbackSymbol],
     )
   }
 
@@ -294,23 +347,33 @@ export class CollectionSubscriber<
     if (!orderByInfo) {
       return
     }
-    const { orderBy, valueExtractorForRawRow } = orderByInfo
+    const { orderBy, valueExtractorForRawRow, offset } = orderByInfo
     const biggestSentRow = this.biggest
-    const biggestSentValue = biggestSentRow
+
+    // Extract all orderBy column values from the biggest sent row
+    // For single-column: returns single value, for multi-column: returns array
+    const extractedValues = biggestSentRow
       ? valueExtractorForRawRow(biggestSentRow)
-      : biggestSentRow
+      : undefined
+
+    // Normalize to array format for minValues
+    const minValues =
+      extractedValues !== undefined
+        ? Array.isArray(extractedValues)
+          ? extractedValues
+          : [extractedValues]
+        : undefined
 
     // Normalize the orderBy clauses such that the references are relative to the collection
-    const normalizedOrderBy = convertOrderByToBasicExpression(
-      orderBy,
-      this.alias
-    )
+    const normalizedOrderBy = normalizeOrderByPaths(orderBy, this.alias)
 
     // Take the `n` items after the biggest sent value
+    // Pass the current window offset to ensure proper deduplication
     subscription.requestLimitedSnapshot({
       orderBy: normalizedOrderBy,
       limit: n,
-      minValue: biggestSentValue,
+      minValues,
+      offset,
     })
   }
 
@@ -336,13 +399,16 @@ export class CollectionSubscriber<
 
   private *trackSentValues(
     changes: Iterable<ChangeMessage<any, string | number>>,
-    comparator: (a: any, b: any) => number
+    comparator: (a: any, b: any) => number,
   ) {
     for (const change of changes) {
-      if (!this.biggest) {
-        this.biggest = change.value
-      } else if (comparator(this.biggest, change.value) < 0) {
-        this.biggest = change.value
+      // Only track inserts/updates for cursor positioning, not deletes
+      if (change.type !== `delete`) {
+        if (!this.biggest) {
+          this.biggest = change.value
+        } else if (comparator(this.biggest, change.value) < 0) {
+          this.biggest = change.value
+        }
       }
 
       yield change
@@ -356,7 +422,7 @@ export class CollectionSubscriber<
 function sendChangesToInput(
   input: RootStreamBuilder<unknown>,
   changes: Iterable<ChangeMessage>,
-  getKey: (item: ChangeMessage[`value`]) => any
+  getKey: (item: ChangeMessage[`value`]) => any,
 ): number {
   const multiSetArray: MultiSetArray<unknown> = []
   for (const change of changes) {
@@ -384,7 +450,7 @@ function* splitUpdates<
   T extends object = Record<string, unknown>,
   TKey extends string | number = string | number,
 >(
-  changes: Iterable<ChangeMessage<T, TKey>>
+  changes: Iterable<ChangeMessage<T, TKey>>,
 ): Generator<ChangeMessage<T, TKey>> {
   for (const change of changes) {
     if (change.type === `update`) {
@@ -395,37 +461,3 @@ function* splitUpdates<
     }
   }
 }
-
-function* filterChanges<
-  T extends object = Record<string, unknown>,
-  TKey extends string | number = string | number,
->(
-  changes: Iterable<ChangeMessage<T, TKey>>,
-  f: (change: ChangeMessage<T, TKey>) => boolean
-): Generator<ChangeMessage<T, TKey>> {
-  for (const change of changes) {
-    if (f(change)) {
-      yield change
-    }
-  }
-}
-
-/**
- * Filters changes to only include those that are smaller or equal to the provided max value
- * @param changes - Iterable of changes to filter
- * @param comparator - Comparator function to use for filtering
- * @param maxValue - Range to filter changes within (range boundaries are exclusive)
- * @returns Iterable of changes that fall within the range
- */
-function* filterChangesSmallerOrEqualToMax<
-  T extends object = Record<string, unknown>,
-  TKey extends string | number = string | number,
->(
-  changes: Iterable<ChangeMessage<T, TKey>>,
-  comparator: (a: any, b: any) => number,
-  maxValue: any
-): Generator<ChangeMessage<T, TKey>> {
-  yield* filterChanges(changes, (change) => {
-    return !maxValue || comparator(change.value, maxValue) <= 0
-  })
-}
diff --git a/packages/db/src/query/live/internal.ts b/packages/db/src/query/live/internal.ts
new file mode 100644
index 000000000..3c6a706f4
--- /dev/null
+++ b/packages/db/src/query/live/internal.ts
@@ -0,0 +1,16 @@
+import type { CollectionConfigBuilder } from './collection-config-builder.js'
+
+/**
+ * Symbol for accessing internal utilities that should not be part of the public API
+ */
+export const LIVE_QUERY_INTERNAL = Symbol(`liveQueryInternal`)
+
+/**
+ * Internal utilities for live queries, accessible via Symbol
+ */
+export type LiveQueryInternalUtils = {
+  getBuilder: () => CollectionConfigBuilder<any, any>
+  hasCustomGetKey: boolean
+  hasJoins: boolean
+  hasDistinct: boolean
+}
diff --git a/packages/db/src/query/live/types.ts b/packages/db/src/query/live/types.ts
index 3149b3a66..04d0b389f 100644
--- a/packages/db/src/query/live/types.ts
+++ b/packages/db/src/query/live/types.ts
@@ -1,7 +1,11 @@
-import type { D2, RootStreamBuilder } from "@tanstack/db-ivm"
-import type { CollectionConfig, ResultStream } from "../../types.js"
-import type { InitialQueryBuilder, QueryBuilder } from "../builder/index.js"
-import type { Context, GetResult } from "../builder/types.js"
+import type { D2, RootStreamBuilder } from '@tanstack/db-ivm'
+import type {
+  CollectionConfig,
+  ResultStream,
+  StringCollationConfig,
+} from '../../types.js'
+import type { InitialQueryBuilder, QueryBuilder } from '../builder/index.js'
+import type { Context, GetResult } from '../builder/types.js'
 
 export type Changes<T> = {
   deletes: number
@@ -18,9 +22,11 @@ export type SyncState = {
   graph?: D2
   inputs?: Record<string, RootStreamBuilder<unknown>>
   pipeline?: ResultStream
+  flushPendingChanges?: () => void
 }
 
-export type FullSyncState = Required<SyncState>
+export type FullSyncState = Required<Omit<SyncState, `flushPendingChanges`>> &
+  Pick<SyncState, `flushPendingChanges`>
 
 /**
  * Configuration interface for live query collection options
@@ -95,4 +101,10 @@ export interface LiveQueryCollectionConfig<
    * If enabled the collection will return a single object instead of an array
    */
   singleResult?: true
+
+  /**
+   * Optional compare options for string sorting.
+   * If provided, these will be used instead of inheriting from the FROM collection.
+   */
+  defaultStringCollation?: StringCollationConfig
 }
diff --git a/packages/db/src/query/optimizer.ts b/packages/db/src/query/optimizer.ts
index 738eec95a..e1020c284 100644
--- a/packages/db/src/query/optimizer.ts
+++ b/packages/db/src/query/optimizer.ts
@@ -120,8 +120,8 @@
  * transformed into a D2Mini pipeline.
  */
 
-import { deepEquals } from "../utils.js"
-import { CannotCombineEmptyExpressionListError } from "../errors.js"
+import { deepEquals } from '../utils.js'
+import { CannotCombineEmptyExpressionListError } from '../errors.js'
 import {
   CollectionRef as CollectionRefClass,
   Func,
@@ -130,9 +130,8 @@ import {
   createResidualWhere,
   getWhereExpression,
   isResidualWhere,
-} from "./ir.js"
-import { isConvertibleToCollectionFilter } from "./compiler/expressions.js"
-import type { BasicExpression, From, QueryIR, Select, Where } from "./ir.js"
+} from './ir.js'
+import type { BasicExpression, From, QueryIR, Select, Where } from './ir.js'
 
 /**
  * Represents a WHERE clause after source analysis
@@ -227,7 +226,7 @@ export function optimizeQuery(query: QueryIR): OptimizationResult {
  * @returns Map of source aliases to their WHERE clauses
  */
 function extractSourceWhereClauses(
-  query: QueryIR
+  query: QueryIR,
 ): Map<string, BasicExpression<boolean>> {
   const sourceWhereClauses = new Map<string, BasicExpression<boolean>>()
 
@@ -241,21 +240,17 @@ function extractSourceWhereClauses(
 
   // Analyze each WHERE clause to determine which sources it touches
   const analyzedClauses = splitWhereClauses.map((clause) =>
-    analyzeWhereClause(clause)
+    analyzeWhereClause(clause),
   )
 
   // Group clauses by single-source vs multi-source
   const groupedClauses = groupWhereClauses(analyzedClauses)
 
   // Only include single-source clauses that reference collections directly
-  // and can be converted to BasicExpression format for collection indexes
   for (const [sourceAlias, whereClause] of groupedClauses.singleSource) {
     // Check if this source alias corresponds to a collection reference
     if (isCollectionReference(query, sourceAlias)) {
-      // Check if the WHERE clause can be converted to collection-compatible format
-      if (isConvertibleToCollectionFilter(whereClause)) {
-        sourceWhereClauses.set(sourceAlias, whereClause)
-      }
+      sourceWhereClauses.set(sourceAlias, whereClause)
     }
   }
 
@@ -302,7 +297,7 @@ function applyRecursiveOptimization(query: QueryIR): QueryIR {
       query.from.type === `queryRef`
         ? new QueryRefClass(
             applyRecursiveOptimization(query.from.query),
-            query.from.alias
+            query.from.alias,
           )
         : query.from,
     join: query.join?.map((joinClause) => ({
@@ -311,7 +306,7 @@ function applyRecursiveOptimization(query: QueryIR): QueryIR {
         joinClause.from.type === `queryRef`
           ? new QueryRefClass(
               applyRecursiveOptimization(joinClause.from.query),
-              joinClause.from.alias
+              joinClause.from.alias,
             )
           : joinClause.from,
     })),
@@ -330,15 +325,28 @@ function applySingleLevelOptimization(query: QueryIR): QueryIR {
     return query
   }
 
-  // Skip optimization if there are no joins - predicate pushdown only benefits joins
-  // Single-table queries don't benefit from this optimization
+  // For queries without joins, combine multiple WHERE clauses into a single clause
+  // to avoid creating multiple filter operators in the pipeline
   if (!query.join || query.join.length === 0) {
+    // Only optimize if there are multiple WHERE clauses to combine
+    if (query.where.length > 1) {
+      // Combine multiple WHERE clauses into a single AND expression
+      const splitWhereClauses = splitAndClauses(query.where)
+      const combinedWhere = combineWithAnd(splitWhereClauses)
+
+      return {
+        ...query,
+        where: [combinedWhere],
+      }
+    }
+
+    // For single WHERE clauses, no optimization needed
     return query
   }
 
   // Filter out residual WHERE clauses to prevent them from being optimized again
   const nonResidualWhereClauses = query.where.filter(
-    (where) => !isResidualWhere(where)
+    (where) => !isResidualWhere(where),
   )
 
   // Step 1: Split all AND clauses at the root level for granular optimization
@@ -346,7 +354,7 @@ function applySingleLevelOptimization(query: QueryIR): QueryIR {
 
   // Step 2: Analyze each WHERE clause to determine which sources it touches
   const analyzedClauses = splitWhereClauses.map((clause) =>
-    analyzeWhereClause(clause)
+    analyzeWhereClause(clause),
   )
 
   // Step 3: Group clauses by single-source vs multi-source
@@ -357,7 +365,7 @@ function applySingleLevelOptimization(query: QueryIR): QueryIR {
 
   // Add back any residual WHERE clauses that were filtered out
   const residualWhereClauses = query.where.filter((where) =>
-    isResidualWhere(where)
+    isResidualWhere(where),
   )
   if (residualWhereClauses.length > 0) {
     optimizedQuery.where = [
@@ -453,7 +461,7 @@ function isRedundantSubquery(query: QueryIR): boolean {
  * ```
  */
 function splitAndClauses(
-  whereClauses: Array<Where>
+  whereClauses: Array<Where>,
 ): Array<BasicExpression<boolean>> {
   const result: Array<BasicExpression<boolean>> = []
 
@@ -467,7 +475,7 @@ function splitAndClauses(
 
 // Helper function for recursive splitting of BasicExpression arrays
 function splitAndClausesRecursive(
-  clause: BasicExpression<boolean>
+  clause: BasicExpression<boolean>,
 ): Array<BasicExpression<boolean>> {
   if (clause.type === `func` && clause.name === `and`) {
     // Recursively split nested AND clauses to handle complex expressions
@@ -507,7 +515,7 @@ function splitAndClausesRecursive(
  * ```
  */
 function analyzeWhereClause(
-  clause: BasicExpression<boolean>
+  clause: BasicExpression<boolean>,
 ): AnalyzedWhereClause {
   // Track which table aliases this WHERE clause touches
   const touchedSources = new Set<string>()
@@ -572,7 +580,7 @@ function analyzeWhereClause(
  * @returns Grouped clauses ready for optimization
  */
 function groupWhereClauses(
-  analyzedClauses: Array<AnalyzedWhereClause>
+  analyzedClauses: Array<AnalyzedWhereClause>,
 ): GroupedWhereClauses {
   const singleSource = new Map<string, Array<BasicExpression<boolean>>>()
   const multiSource: Array<BasicExpression<boolean>> = []
@@ -622,7 +630,7 @@ function groupWhereClauses(
  */
 function applyOptimizations(
   query: QueryIR,
-  groupedClauses: GroupedWhereClauses
+  groupedClauses: GroupedWhereClauses,
 ): QueryIR {
   // Track which single-source clauses were actually optimized
   const actuallyOptimized = new Set<string>()
@@ -631,7 +639,7 @@ function applyOptimizations(
   const optimizedFrom = optimizeFromWithTracking(
     query.from,
     groupedClauses.singleSource,
-    actuallyOptimized
+    actuallyOptimized,
   )
 
   // Optimize JOIN clauses and track what was optimized
@@ -641,7 +649,7 @@ function applyOptimizations(
         from: optimizeFromWithTracking(
           joinClause.from,
           groupedClauses.singleSource,
-          actuallyOptimized
+          actuallyOptimized,
         ),
       }))
     : undefined
@@ -659,7 +667,7 @@ function applyOptimizations(
     query.join &&
     query.join.some(
       (join) =>
-        join.type === `left` || join.type === `right` || join.type === `full`
+        join.type === `left` || join.type === `right` || join.type === `full`,
     )
 
   // Add single-source clauses
@@ -674,6 +682,20 @@ function applyOptimizations(
     // If optimized and no outer JOINs - don't keep (original behavior)
   }
 
+  // Combine multiple remaining WHERE clauses into a single clause to avoid
+  // multiple filter operations in the pipeline (performance optimization)
+  // First flatten any nested AND expressions to avoid and(and(...), ...)
+  const finalWhere: Array<Where> =
+    remainingWhereClauses.length > 1
+      ? [
+          combineWithAnd(
+            remainingWhereClauses.flatMap((clause) =>
+              splitAndClausesRecursive(getWhereExpression(clause)),
+            ),
+          ),
+        ]
+      : remainingWhereClauses
+
   // Create a completely new query object to ensure immutability
   const optimizedQuery: QueryIR = {
     // Copy all non-optimized fields as-is
@@ -692,8 +714,8 @@ function applyOptimizations(
     from: optimizedFrom,
     join: optimizedJoins,
 
-    // Only include WHERE clauses that weren't successfully optimized
-    where: remainingWhereClauses.length > 0 ? remainingWhereClauses : [],
+    // Include combined WHERE clauses
+    where: finalWhere.length > 0 ? finalWhere : [],
   }
 
   return optimizedQuery
@@ -727,11 +749,11 @@ function deepCopyQuery(query: QueryIR): QueryIR {
             joinClause.from.type === `collectionRef`
               ? new CollectionRefClass(
                   joinClause.from.collection,
-                  joinClause.from.alias
+                  joinClause.from.alias,
                 )
               : new QueryRefClass(
                   deepCopyQuery(joinClause.from.query),
-                  joinClause.from.alias
+                  joinClause.from.alias,
                 ),
         }))
       : undefined,
@@ -758,7 +780,7 @@ function deepCopyQuery(query: QueryIR): QueryIR {
 function optimizeFromWithTracking(
   from: From,
   singleSourceClauses: Map<string, BasicExpression<boolean>>,
-  actuallyOptimized: Set<string>
+  actuallyOptimized: Set<string>,
 ): From {
   const whereClause = singleSourceClauses.get(from.alias)
 
@@ -811,7 +833,7 @@ function optimizeFromWithTracking(
 function unsafeSelect(
   query: QueryIR,
   whereClause: BasicExpression<boolean>,
-  outerAlias: string
+  outerAlias: string,
 ): boolean {
   if (!query.select) return false
 
@@ -848,7 +870,7 @@ function unsafeFnSelect(query: QueryIR) {
 function isSafeToPushIntoExistingSubquery(
   query: QueryIR,
   whereClause: BasicExpression<boolean>,
-  outerAlias: string
+  outerAlias: string,
 ): boolean {
   return !(
     unsafeSelect(query, whereClause, outerAlias) ||
@@ -923,7 +945,7 @@ function collectRefs(expr: any): Array<PropRef> {
 function whereReferencesComputedSelectFields(
   select: Select,
   whereClause: BasicExpression<boolean>,
-  outerAlias: string
+  outerAlias: string,
 ): boolean {
   // Build a set of computed field names at the top-level of the subquery output
   const computed = new Set<string>()
@@ -957,7 +979,7 @@ function whereReferencesComputedSelectFields(
 function referencesAliasWithRemappedSelect(
   subquery: QueryIR,
   whereClause: BasicExpression<boolean>,
-  outerAlias: string
+  outerAlias: string,
 ): boolean {
   const refs = collectRefs(whereClause)
   // Only care about clauses that actually reference the outer alias.
@@ -1024,7 +1046,7 @@ function referencesAliasWithRemappedSelect(
  * @throws Error if the expressions array is empty
  */
 function combineWithAnd(
-  expressions: Array<BasicExpression<boolean>>
+  expressions: Array<BasicExpression<boolean>>,
 ): BasicExpression<boolean> {
   if (expressions.length === 0) {
     throw new CannotCombineEmptyExpressionListError()
diff --git a/packages/db/src/query/predicate-utils.ts b/packages/db/src/query/predicate-utils.ts
new file mode 100644
index 000000000..96162e868
--- /dev/null
+++ b/packages/db/src/query/predicate-utils.ts
@@ -0,0 +1,1514 @@
+import { Func, Value } from './ir.js'
+import type { BasicExpression, OrderBy, PropRef } from './ir.js'
+import type { LoadSubsetOptions } from '../types.js'
+
+/**
+ * Check if one where clause is a logical subset of another.
+ * Returns true if the subset predicate is more restrictive than (or equal to) the superset predicate.
+ *
+ * @example
+ * // age > 20 is subset of age > 10 (more restrictive)
+ * isWhereSubset(gt(ref('age'), val(20)), gt(ref('age'), val(10))) // true
+ *
+ * @example
+ * // age > 10 AND name = 'X' is subset of age > 10 (more conditions)
+ * isWhereSubset(and(gt(ref('age'), val(10)), eq(ref('name'), val('X'))), gt(ref('age'), val(10))) // true
+ *
+ * @param subset - The potentially more restrictive predicate
+ * @param superset - The potentially less restrictive predicate
+ * @returns true if subset logically implies superset
+ */
+export function isWhereSubset(
+  subset: BasicExpression<boolean> | undefined,
+  superset: BasicExpression<boolean> | undefined,
+): boolean {
+  // undefined/missing where clause means "no filter" (all data)
+  // Both undefined means subset relationship holds (all data ⊆ all data)
+  if (subset === undefined && superset === undefined) {
+    return true
+  }
+
+  // If subset is undefined but superset is not, we're requesting ALL data
+  // but have only loaded SOME data - subset relationship does NOT hold
+  if (subset === undefined && superset !== undefined) {
+    return false
+  }
+
+  // If superset is undefined (no filter = all data loaded),
+  // then any constrained subset is contained
+  if (superset === undefined && subset !== undefined) {
+    return true
+  }
+
+  return isWhereSubsetInternal(subset!, superset!)
+}
+
+function makeDisjunction(
+  preds: Array<BasicExpression<boolean>>,
+): BasicExpression<boolean> {
+  if (preds.length === 0) {
+    return new Value(false)
+  }
+  if (preds.length === 1) {
+    return preds[0]!
+  }
+  return new Func(`or`, preds)
+}
+
+function convertInToOr(inField: InField) {
+  const equalities = inField.values.map(
+    (value) => new Func(`eq`, [inField.ref, new Value(value)]),
+  )
+  return makeDisjunction(equalities)
+}
+
+function isWhereSubsetInternal(
+  subset: BasicExpression<boolean>,
+  superset: BasicExpression<boolean>,
+): boolean {
+  // If subset is false it is requesting no data,
+  // thus the result set is empty
+  // and the empty set is a subset of any set
+  if (subset.type === `val` && subset.value === false) {
+    return true
+  }
+
+  // If expressions are structurally equal, subset relationship holds
+  if (areExpressionsEqual(subset, superset)) {
+    return true
+  }
+
+  // Handle superset being an AND: subset must imply ALL conjuncts
+  // If superset is (A AND B), then subset ⊆ (A AND B) only if subset ⊆ A AND subset ⊆ B
+  // Example: (age > 20) ⊆ (age > 10 AND status = 'active') is false (doesn't imply status condition)
+  if (superset.type === `func` && superset.name === `and`) {
+    return superset.args.every((arg) =>
+      isWhereSubsetInternal(subset, arg as BasicExpression<boolean>),
+    )
+  }
+
+  // Handle subset being an AND: (A AND B) implies both A and B
+  if (subset.type === `func` && subset.name === `and`) {
+    // For (A AND B) ⊆ C, since (A AND B) implies A, we check if any conjunct implies C
+    return subset.args.some((arg) =>
+      isWhereSubsetInternal(arg as BasicExpression<boolean>, superset),
+    )
+  }
+
+  // Turn x IN [A, B, C] into x = A OR x = B OR x = C
+  // for unified handling of IN and OR
+  if (subset.type === `func` && subset.name === `in`) {
+    const inField = extractInField(subset)
+    if (inField) {
+      return isWhereSubsetInternal(convertInToOr(inField), superset)
+    }
+  }
+
+  if (superset.type === `func` && superset.name === `in`) {
+    const inField = extractInField(superset)
+    if (inField) {
+      return isWhereSubsetInternal(subset, convertInToOr(inField))
+    }
+  }
+
+  // Handle OR in subset: (A OR B) is subset of C only if both A and B are subsets of C
+  if (subset.type === `func` && subset.name === `or`) {
+    return subset.args.every((arg) =>
+      isWhereSubsetInternal(arg as BasicExpression<boolean>, superset),
+    )
+  }
+
+  // Handle OR in superset: subset ⊆ (A OR B) if subset ⊆ A or subset ⊆ B
+  // (A OR B) as superset means data can satisfy A or B
+  // If subset is contained in any disjunct, it's contained in the union
+  if (superset.type === `func` && superset.name === `or`) {
+    return superset.args.some((arg) =>
+      isWhereSubsetInternal(subset, arg as BasicExpression<boolean>),
+    )
+  }
+
+  // Handle comparison operators on the same field
+  if (subset.type === `func` && superset.type === `func`) {
+    const subsetFunc = subset as Func
+    const supersetFunc = superset as Func
+
+    // Check if both are comparisons on the same field
+    const subsetField = extractComparisonField(subsetFunc)
+    const supersetField = extractComparisonField(supersetFunc)
+
+    if (
+      subsetField &&
+      supersetField &&
+      areRefsEqual(subsetField.ref, supersetField.ref)
+    ) {
+      return isComparisonSubset(
+        subsetFunc,
+        subsetField.value,
+        supersetFunc,
+        supersetField.value,
+      )
+    }
+
+    /*
+    // Handle eq vs in
+    if (subsetFunc.name === `eq` && supersetFunc.name === `in`) {
+      const subsetFieldEq = extractEqualityField(subsetFunc)
+      const supersetFieldIn = extractInField(supersetFunc)
+      if (
+        subsetFieldEq &&
+        supersetFieldIn &&
+        areRefsEqual(subsetFieldEq.ref, supersetFieldIn.ref)
+      ) {
+        // field = X is subset of field IN [X, Y, Z] if X is in the array
+        // Use cached primitive set and metadata from extraction
+        return arrayIncludesWithSet(
+          supersetFieldIn.values,
+          subsetFieldEq.value,
+          supersetFieldIn.primitiveSet ?? null,
+          supersetFieldIn.areAllPrimitives
+        )
+      }
+    }
+
+    // Handle in vs in
+    if (subsetFunc.name === `in` && supersetFunc.name === `in`) {
+      const subsetFieldIn = extractInField(subsetFunc)
+      const supersetFieldIn = extractInField(supersetFunc)
+      if (
+        subsetFieldIn &&
+        supersetFieldIn &&
+        areRefsEqual(subsetFieldIn.ref, supersetFieldIn.ref)
+      ) {
+        // field IN [A, B] is subset of field IN [A, B, C] if all values in subset are in superset
+        // Use cached primitive set and metadata from extraction
+        return subsetFieldIn.values.every((subVal) =>
+          arrayIncludesWithSet(
+            supersetFieldIn.values,
+            subVal,
+            supersetFieldIn.primitiveSet ?? null,
+            supersetFieldIn.areAllPrimitives
+          )
+        )
+      }
+    }
+    */
+  }
+
+  // Conservative: if we can't determine, return false
+  return false
+}
+
+/**
+ * Helper to combine where predicates with common logic for AND/OR operations
+ */
+function combineWherePredicates(
+  predicates: Array<BasicExpression<boolean>>,
+  operation: `and` | `or`,
+  simplifyFn: (
+    preds: Array<BasicExpression<boolean>>,
+  ) => BasicExpression<boolean> | null,
+): BasicExpression<boolean> {
+  const emptyValue = operation === `and` ? true : false
+  const identityValue = operation === `and` ? true : false
+
+  if (predicates.length === 0) {
+    return { type: `val`, value: emptyValue } as BasicExpression<boolean>
+  }
+
+  if (predicates.length === 1) {
+    return predicates[0]!
+  }
+
+  // Flatten nested expressions of the same operation
+  const flatPredicates: Array<BasicExpression<boolean>> = []
+  for (const pred of predicates) {
+    if (pred.type === `func` && pred.name === operation) {
+      flatPredicates.push(...pred.args)
+    } else {
+      flatPredicates.push(pred)
+    }
+  }
+
+  // Group predicates by field for simplification
+  const grouped = groupPredicatesByField(flatPredicates)
+
+  // Simplify each group
+  const simplified: Array<BasicExpression<boolean>> = []
+  for (const [field, preds] of grouped.entries()) {
+    if (field === null) {
+      // Complex predicates that we can't group by field
+      simplified.push(...preds)
+    } else {
+      // Try to simplify same-field predicates
+      const result = simplifyFn(preds)
+
+      // For intersection: check for empty set (contradiction)
+      if (
+        operation === `and` &&
+        result &&
+        result.type === `val` &&
+        result.value === false
+      ) {
+        // Intersection is empty (conflicting constraints) - entire AND is false
+        return { type: `val`, value: false } as BasicExpression<boolean>
+      }
+
+      // For union: result may be null if simplification failed
+      if (result) {
+        simplified.push(result)
+      }
+    }
+  }
+
+  if (simplified.length === 0) {
+    return { type: `val`, value: identityValue } as BasicExpression<boolean>
+  }
+
+  if (simplified.length === 1) {
+    return simplified[0]!
+  }
+
+  // Return combined predicate
+  return {
+    type: `func`,
+    name: operation,
+    args: simplified,
+  } as BasicExpression<boolean>
+}
+
+/**
+ * Combine multiple where predicates with OR logic (union).
+ * Returns a predicate that is satisfied when any input predicate is satisfied.
+ * Simplifies when possible (e.g., age > 10 OR age > 20 → age > 10).
+ *
+ * @example
+ * // Take least restrictive
+ * unionWherePredicates([gt(ref('age'), val(10)), gt(ref('age'), val(20))]) // age > 10
+ *
+ * @example
+ * // Combine equals into IN
+ * unionWherePredicates([eq(ref('age'), val(5)), eq(ref('age'), val(10))]) // age IN [5, 10]
+ *
+ * @param predicates - Array of where predicates to union
+ * @returns Combined predicate representing the union
+ */
+export function unionWherePredicates(
+  predicates: Array<BasicExpression<boolean>>,
+): BasicExpression<boolean> {
+  return combineWherePredicates(predicates, `or`, unionSameFieldPredicates)
+}
+
+/**
+ * Compute the difference between two where predicates: `fromPredicate AND NOT(subtractPredicate)`.
+ * Returns the simplified predicate, or null if the difference cannot be simplified
+ * (in which case the caller should fetch the full fromPredicate).
+ *
+ * @example
+ * // Range difference
+ * minusWherePredicates(
+ *   gt(ref('age'), val(10)),      // age > 10
+ *   gt(ref('age'), val(20))       // age > 20
+ * ) // → age > 10 AND age <= 20
+ *
+ * @example
+ * // Set difference
+ * minusWherePredicates(
+ *   inOp(ref('status'), ['A', 'B', 'C', 'D']),  // status IN ['A','B','C','D']
+ *   inOp(ref('status'), ['B', 'C'])             // status IN ['B','C']
+ * ) // → status IN ['A', 'D']
+ *
+ * @example
+ * // Common conditions
+ * minusWherePredicates(
+ *   and(gt(ref('age'), val(10)), eq(ref('status'), val('active'))),  // age > 10 AND status = 'active'
+ *   and(gt(ref('age'), val(20)), eq(ref('status'), val('active')))   // age > 20 AND status = 'active'
+ * ) // → age > 10 AND age <= 20 AND status = 'active'
+ *
+ * @example
+ * // Complete overlap - empty result
+ * minusWherePredicates(
+ *   gt(ref('age'), val(20)),     // age > 20
+ *   gt(ref('age'), val(10))      // age > 10
+ * ) // → {type: 'val', value: false} (empty set)
+ *
+ * @param fromPredicate - The predicate to subtract from
+ * @param subtractPredicate - The predicate to subtract
+ * @returns The simplified difference, or null if cannot be simplified
+ */
+export function minusWherePredicates(
+  fromPredicate: BasicExpression<boolean> | undefined,
+  subtractPredicate: BasicExpression<boolean> | undefined,
+): BasicExpression<boolean> | null {
+  // If nothing to subtract, return the original
+  if (subtractPredicate === undefined) {
+    return (
+      fromPredicate ??
+      ({ type: `val`, value: true } as BasicExpression<boolean>)
+    )
+  }
+
+  // If from is undefined then we are asking for all data
+  // so we need to load all data minus what we already loaded
+  // i.e. we need to load NOT(subtractPredicate)
+  if (fromPredicate === undefined) {
+    return {
+      type: `func`,
+      name: `not`,
+      args: [subtractPredicate],
+    } as BasicExpression<boolean>
+  }
+
+  // Check if fromPredicate is entirely contained in subtractPredicate
+  // In that case, fromPredicate AND NOT(subtractPredicate) = empty set
+  if (isWhereSubset(fromPredicate, subtractPredicate)) {
+    return { type: `val`, value: false } as BasicExpression<boolean>
+  }
+
+  // Try to detect and handle common conditions
+  const commonConditions = findCommonConditions(
+    fromPredicate,
+    subtractPredicate,
+  )
+  if (commonConditions.length > 0) {
+    // Extract predicates without common conditions
+    const fromWithoutCommon = removeConditions(fromPredicate, commonConditions)
+    const subtractWithoutCommon = removeConditions(
+      subtractPredicate,
+      commonConditions,
+    )
+
+    // Recursively compute difference on simplified predicates
+    const simplifiedDifference = minusWherePredicates(
+      fromWithoutCommon,
+      subtractWithoutCommon,
+    )
+
+    if (simplifiedDifference !== null) {
+      // Combine the simplified difference with common conditions
+      return combineConditions([...commonConditions, simplifiedDifference])
+    }
+  }
+
+  // Check if they are on the same field - if so, we can try to simplify
+  if (fromPredicate.type === `func` && subtractPredicate.type === `func`) {
+    const result = minusSameFieldPredicates(fromPredicate, subtractPredicate)
+    if (result !== null) {
+      return result
+    }
+  }
+
+  // Can't simplify - return null to indicate caller should fetch full fromPredicate
+  return null
+}
+
+/**
+ * Helper function to compute difference for same-field predicates
+ */
+function minusSameFieldPredicates(
+  fromPred: Func,
+  subtractPred: Func,
+): BasicExpression<boolean> | null {
+  // Extract field information
+  const fromField =
+    extractComparisonField(fromPred) ||
+    extractEqualityField(fromPred) ||
+    extractInField(fromPred)
+  const subtractField =
+    extractComparisonField(subtractPred) ||
+    extractEqualityField(subtractPred) ||
+    extractInField(subtractPred)
+
+  // Must be on the same field
+  if (
+    !fromField ||
+    !subtractField ||
+    !areRefsEqual(fromField.ref, subtractField.ref)
+  ) {
+    return null
+  }
+
+  // Handle IN minus IN: status IN [A,B,C,D] - status IN [B,C] = status IN [A,D]
+  if (fromPred.name === `in` && subtractPred.name === `in`) {
+    const fromInField = fromField as InField
+    const subtractInField = subtractField as InField
+
+    // Filter out values that are in the subtract set
+    const remainingValues = fromInField.values.filter(
+      (v) =>
+        !arrayIncludesWithSet(
+          subtractInField.values,
+          v,
+          subtractInField.primitiveSet ?? null,
+          subtractInField.areAllPrimitives,
+        ),
+    )
+
+    if (remainingValues.length === 0) {
+      return { type: `val`, value: false } as BasicExpression<boolean>
+    }
+
+    if (remainingValues.length === 1) {
+      return {
+        type: `func`,
+        name: `eq`,
+        args: [fromField.ref, { type: `val`, value: remainingValues[0] }],
+      } as BasicExpression<boolean>
+    }
+
+    return {
+      type: `func`,
+      name: `in`,
+      args: [fromField.ref, { type: `val`, value: remainingValues }],
+    } as BasicExpression<boolean>
+  }
+
+  // Handle IN minus equality: status IN [A,B,C] - status = B = status IN [A,C]
+  if (fromPred.name === `in` && subtractPred.name === `eq`) {
+    const fromInField = fromField as InField
+    const subtractValue = (subtractField as { ref: PropRef; value: any }).value
+
+    const remainingValues = fromInField.values.filter(
+      (v) => !areValuesEqual(v, subtractValue),
+    )
+
+    if (remainingValues.length === 0) {
+      return { type: `val`, value: false } as BasicExpression<boolean>
+    }
+
+    if (remainingValues.length === 1) {
+      return {
+        type: `func`,
+        name: `eq`,
+        args: [fromField.ref, { type: `val`, value: remainingValues[0] }],
+      } as BasicExpression<boolean>
+    }
+
+    return {
+      type: `func`,
+      name: `in`,
+      args: [fromField.ref, { type: `val`, value: remainingValues }],
+    } as BasicExpression<boolean>
+  }
+
+  // Handle equality minus equality: age = 15 - age = 15 = empty, age = 15 - age = 20 = age = 15
+  if (fromPred.name === `eq` && subtractPred.name === `eq`) {
+    const fromValue = (fromField as { ref: PropRef; value: any }).value
+    const subtractValue = (subtractField as { ref: PropRef; value: any }).value
+
+    if (areValuesEqual(fromValue, subtractValue)) {
+      return { type: `val`, value: false } as BasicExpression<boolean>
+    }
+
+    // No overlap - return original
+    return fromPred as BasicExpression<boolean>
+  }
+
+  // Handle range minus range: age > 10 - age > 20 = age > 10 AND age <= 20
+  const fromComp = extractComparisonField(fromPred)
+  const subtractComp = extractComparisonField(subtractPred)
+
+  if (
+    fromComp &&
+    subtractComp &&
+    areRefsEqual(fromComp.ref, subtractComp.ref)
+  ) {
+    // Try to compute the difference using range logic
+    const result = minusRangePredicates(
+      fromPred,
+      fromComp.value,
+      subtractPred,
+      subtractComp.value,
+    )
+    return result
+  }
+
+  // Can't simplify
+  return null
+}
+
+/**
+ * Helper to compute difference between range predicates
+ */
+function minusRangePredicates(
+  fromFunc: Func,
+  fromValue: any,
+  subtractFunc: Func,
+  subtractValue: any,
+): BasicExpression<boolean> | null {
+  const fromOp = fromFunc.name as `gt` | `gte` | `lt` | `lte` | `eq`
+  const subtractOp = subtractFunc.name as `gt` | `gte` | `lt` | `lte` | `eq`
+  const ref = (extractComparisonField(fromFunc) ||
+    extractEqualityField(fromFunc))!.ref
+
+  // age > 10 - age > 20 = (age > 10 AND age <= 20)
+  if (fromOp === `gt` && subtractOp === `gt`) {
+    if (fromValue < subtractValue) {
+      // Result is: fromValue < field <= subtractValue
+      return {
+        type: `func`,
+        name: `and`,
+        args: [
+          fromFunc as BasicExpression<boolean>,
+          {
+            type: `func`,
+            name: `lte`,
+            args: [ref, { type: `val`, value: subtractValue }],
+          } as BasicExpression<boolean>,
+        ],
+      } as BasicExpression<boolean>
+    }
+    // fromValue >= subtractValue means no overlap
+    return fromFunc as BasicExpression<boolean>
+  }
+
+  // age >= 10 - age >= 20 = (age >= 10 AND age < 20)
+  if (fromOp === `gte` && subtractOp === `gte`) {
+    if (fromValue < subtractValue) {
+      return {
+        type: `func`,
+        name: `and`,
+        args: [
+          fromFunc as BasicExpression<boolean>,
+          {
+            type: `func`,
+            name: `lt`,
+            args: [ref, { type: `val`, value: subtractValue }],
+          } as BasicExpression<boolean>,
+        ],
+      } as BasicExpression<boolean>
+    }
+    return fromFunc as BasicExpression<boolean>
+  }
+
+  // age > 10 - age >= 20 = (age > 10 AND age < 20)
+  if (fromOp === `gt` && subtractOp === `gte`) {
+    if (fromValue < subtractValue) {
+      return {
+        type: `func`,
+        name: `and`,
+        args: [
+          fromFunc as BasicExpression<boolean>,
+          {
+            type: `func`,
+            name: `lt`,
+            args: [ref, { type: `val`, value: subtractValue }],
+          } as BasicExpression<boolean>,
+        ],
+      } as BasicExpression<boolean>
+    }
+    return fromFunc as BasicExpression<boolean>
+  }
+
+  // age >= 10 - age > 20 = (age >= 10 AND age <= 20)
+  if (fromOp === `gte` && subtractOp === `gt`) {
+    if (fromValue <= subtractValue) {
+      return {
+        type: `func`,
+        name: `and`,
+        args: [
+          fromFunc as BasicExpression<boolean>,
+          {
+            type: `func`,
+            name: `lte`,
+            args: [ref, { type: `val`, value: subtractValue }],
+          } as BasicExpression<boolean>,
+        ],
+      } as BasicExpression<boolean>
+    }
+    return fromFunc as BasicExpression<boolean>
+  }
+
+  // age < 30 - age < 20 = (age >= 20 AND age < 30)
+  if (fromOp === `lt` && subtractOp === `lt`) {
+    if (fromValue > subtractValue) {
+      return {
+        type: `func`,
+        name: `and`,
+        args: [
+          {
+            type: `func`,
+            name: `gte`,
+            args: [ref, { type: `val`, value: subtractValue }],
+          } as BasicExpression<boolean>,
+          fromFunc as BasicExpression<boolean>,
+        ],
+      } as BasicExpression<boolean>
+    }
+    return fromFunc as BasicExpression<boolean>
+  }
+
+  // age <= 30 - age <= 20 = (age > 20 AND age <= 30)
+  if (fromOp === `lte` && subtractOp === `lte`) {
+    if (fromValue > subtractValue) {
+      return {
+        type: `func`,
+        name: `and`,
+        args: [
+          {
+            type: `func`,
+            name: `gt`,
+            args: [ref, { type: `val`, value: subtractValue }],
+          } as BasicExpression<boolean>,
+          fromFunc as BasicExpression<boolean>,
+        ],
+      } as BasicExpression<boolean>
+    }
+    return fromFunc as BasicExpression<boolean>
+  }
+
+  // age < 30 - age <= 20 = (age > 20 AND age < 30)
+  if (fromOp === `lt` && subtractOp === `lte`) {
+    if (fromValue > subtractValue) {
+      return {
+        type: `func`,
+        name: `and`,
+        args: [
+          {
+            type: `func`,
+            name: `gt`,
+            args: [ref, { type: `val`, value: subtractValue }],
+          } as BasicExpression<boolean>,
+          fromFunc as BasicExpression<boolean>,
+        ],
+      } as BasicExpression<boolean>
+    }
+    return fromFunc as BasicExpression<boolean>
+  }
+
+  // age <= 30 - age < 20 = (age >= 20 AND age <= 30)
+  if (fromOp === `lte` && subtractOp === `lt`) {
+    if (fromValue >= subtractValue) {
+      return {
+        type: `func`,
+        name: `and`,
+        args: [
+          {
+            type: `func`,
+            name: `gte`,
+            args: [ref, { type: `val`, value: subtractValue }],
+          } as BasicExpression<boolean>,
+          fromFunc as BasicExpression<boolean>,
+        ],
+      } as BasicExpression<boolean>
+    }
+    return fromFunc as BasicExpression<boolean>
+  }
+
+  // Can't simplify other combinations
+  return null
+}
+
+/**
+ * Check if one orderBy clause is a subset of another.
+ * Returns true if the subset ordering requirements are satisfied by the superset ordering.
+ *
+ * @example
+ * // Subset is prefix of superset
+ * isOrderBySubset([{expr: age, asc}], [{expr: age, asc}, {expr: name, desc}]) // true
+ *
+ * @param subset - The ordering requirements to check
+ * @param superset - The ordering that might satisfy the requirements
+ * @returns true if subset is satisfied by superset
+ */
+export function isOrderBySubset(
+  subset: OrderBy | undefined,
+  superset: OrderBy | undefined,
+): boolean {
+  // No ordering requirement is always satisfied
+  if (!subset || subset.length === 0) {
+    return true
+  }
+
+  // If there's no superset ordering but subset requires ordering, not satisfied
+  if (!superset || superset.length === 0) {
+    return false
+  }
+
+  // Check if subset is a prefix of superset with matching expressions and compare options
+  if (subset.length > superset.length) {
+    return false
+  }
+
+  for (let i = 0; i < subset.length; i++) {
+    const subClause = subset[i]!
+    const superClause = superset[i]!
+
+    // Check if expressions match
+    if (!areExpressionsEqual(subClause.expression, superClause.expression)) {
+      return false
+    }
+
+    // Check if compare options match
+    if (
+      !areCompareOptionsEqual(
+        subClause.compareOptions,
+        superClause.compareOptions,
+      )
+    ) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * Check if one limit is a subset of another.
+ * Returns true if the subset limit requirements are satisfied by the superset limit.
+ *
+ * Note: This function does NOT consider offset. For offset-aware subset checking,
+ * use `isOffsetLimitSubset` instead.
+ *
+ * @example
+ * isLimitSubset(10, 20) // true (requesting 10 items when 20 are available)
+ * isLimitSubset(20, 10) // false (requesting 20 items when only 10 are available)
+ * isLimitSubset(10, undefined) // true (requesting 10 items when unlimited are available)
+ *
+ * @param subset - The limit requirement to check
+ * @param superset - The limit that might satisfy the requirement
+ * @returns true if subset is satisfied by superset
+ */
+export function isLimitSubset(
+  subset: number | undefined,
+  superset: number | undefined,
+): boolean {
+  // Unlimited superset satisfies any limit requirement
+  if (superset === undefined) {
+    return true
+  }
+
+  // If requesting all data (no limit), we need unlimited data to satisfy it
+  // But we know superset is not unlimited so we return false
+  if (subset === undefined) {
+    return false
+  }
+
+  // Otherwise, subset must be less than or equal to superset
+  return subset <= superset
+}
+
+/**
+ * Check if one offset+limit range is a subset of another.
+ * Returns true if the subset range is fully contained within the superset range.
+ *
+ * A query with `{limit: 10, offset: 0}` loads rows [0, 10).
+ * A query with `{limit: 10, offset: 20}` loads rows [20, 30).
+ *
+ * For subset to be satisfied by superset:
+ * - Superset must start at or before subset (superset.offset <= subset.offset)
+ * - Superset must end at or after subset (superset.offset + superset.limit >= subset.offset + subset.limit)
+ *
+ * @example
+ * isOffsetLimitSubset({ offset: 0, limit: 5 }, { offset: 0, limit: 10 }) // true
+ * isOffsetLimitSubset({ offset: 5, limit: 5 }, { offset: 0, limit: 10 }) // true (rows 5-9 within 0-9)
+ * isOffsetLimitSubset({ offset: 5, limit: 10 }, { offset: 0, limit: 10 }) // false (rows 5-14 exceed 0-9)
+ * isOffsetLimitSubset({ offset: 20, limit: 10 }, { offset: 0, limit: 10 }) // false (rows 20-29 outside 0-9)
+ *
+ * @param subset - The offset+limit requirements to check
+ * @param superset - The offset+limit that might satisfy the requirements
+ * @returns true if subset range is fully contained within superset range
+ */
+export function isOffsetLimitSubset(
+  subset: { offset?: number; limit?: number },
+  superset: { offset?: number; limit?: number },
+): boolean {
+  const subsetOffset = subset.offset ?? 0
+  const supersetOffset = superset.offset ?? 0
+
+  // Superset must start at or before subset
+  if (supersetOffset > subsetOffset) {
+    return false
+  }
+
+  // If superset is unlimited, it covers everything from its offset onwards
+  if (superset.limit === undefined) {
+    return true
+  }
+
+  // If subset is unlimited but superset has a limit, subset can't be satisfied
+  if (subset.limit === undefined) {
+    return false
+  }
+
+  // Both have limits - check if subset range is within superset range
+  const subsetEnd = subsetOffset + subset.limit
+  const supersetEnd = supersetOffset + superset.limit
+
+  return subsetEnd <= supersetEnd
+}
+
+/**
+ * Check if one predicate (where + orderBy + limit + offset) is a subset of another.
+ * Returns true if all aspects of the subset predicate are satisfied by the superset.
+ *
+ * @example
+ * isPredicateSubset(
+ *   { where: gt(ref('age'), val(20)), limit: 10 },
+ *   { where: gt(ref('age'), val(10)), limit: 20 }
+ * ) // true
+ *
+ * @param subset - The predicate requirements to check
+ * @param superset - The predicate that might satisfy the requirements
+ * @returns true if subset is satisfied by superset
+ */
+export function isPredicateSubset(
+  subset: LoadSubsetOptions,
+  superset: LoadSubsetOptions,
+): boolean {
+  // When the superset has a limit, we can only determine subset relationship
+  // if the where clauses are equal (not just subset relationship).
+  //
+  // This is because a limited query only loads a portion of the matching rows.
+  // A more restrictive where clause might require rows outside that portion.
+  //
+  // Example: superset = {where: undefined, limit: 10, orderBy: desc}
+  //          subset = {where: LIKE 'search%', limit: 10, orderBy: desc}
+  // The top 10 items matching 'search%' might include items outside the overall top 10.
+  //
+  // However, if the where clauses are equal, then the subset relationship can
+  // be determined by orderBy, limit, and offset:
+  // Example: superset = {where: status='active', limit: 10, offset: 0, orderBy: desc}
+  //          subset = {where: status='active', limit: 5, offset: 0, orderBy: desc}
+  // The top 5 active items ARE contained in the top 10 active items.
+  if (superset.limit !== undefined) {
+    // For limited supersets, where clauses must be equal
+    if (!areWhereClausesEqual(subset.where, superset.where)) {
+      return false
+    }
+    return (
+      isOrderBySubset(subset.orderBy, superset.orderBy) &&
+      isOffsetLimitSubset(subset, superset)
+    )
+  }
+
+  // For unlimited supersets, use the normal subset logic
+  // Still need to consider offset - an unlimited query with offset only covers
+  // rows from that offset onwards
+  return (
+    isWhereSubset(subset.where, superset.where) &&
+    isOrderBySubset(subset.orderBy, superset.orderBy) &&
+    isOffsetLimitSubset(subset, superset)
+  )
+}
+
+/**
+ * Check if two where clauses are structurally equal.
+ * Used for limited query subset checks where subset relationship isn't sufficient.
+ */
+function areWhereClausesEqual(
+  a: BasicExpression<boolean> | undefined,
+  b: BasicExpression<boolean> | undefined,
+): boolean {
+  if (a === undefined && b === undefined) {
+    return true
+  }
+  if (a === undefined || b === undefined) {
+    return false
+  }
+  return areExpressionsEqual(a, b)
+}
+
+// ============================================================================
+// Helper functions
+// ============================================================================
+
+/**
+ * Find common conditions between two predicates.
+ * Returns an array of conditions that appear in both predicates.
+ */
+function findCommonConditions(
+  predicate1: BasicExpression<boolean>,
+  predicate2: BasicExpression<boolean>,
+): Array<BasicExpression<boolean>> {
+  const conditions1 = extractAllConditions(predicate1)
+  const conditions2 = extractAllConditions(predicate2)
+
+  const common: Array<BasicExpression<boolean>> = []
+
+  for (const cond1 of conditions1) {
+    for (const cond2 of conditions2) {
+      if (areExpressionsEqual(cond1, cond2)) {
+        // Avoid duplicates
+        if (!common.some((c) => areExpressionsEqual(c, cond1))) {
+          common.push(cond1)
+        }
+        break
+      }
+    }
+  }
+
+  return common
+}
+
+/**
+ * Extract all individual conditions from a predicate, flattening AND operations.
+ */
+function extractAllConditions(
+  predicate: BasicExpression<boolean>,
+): Array<BasicExpression<boolean>> {
+  if (predicate.type === `func` && predicate.name === `and`) {
+    const conditions: Array<BasicExpression<boolean>> = []
+    for (const arg of predicate.args) {
+      conditions.push(...extractAllConditions(arg as BasicExpression<boolean>))
+    }
+    return conditions
+  }
+
+  return [predicate]
+}
+
+/**
+ * Remove specified conditions from a predicate.
+ * Returns the predicate with the specified conditions removed, or undefined if all conditions are removed.
+ */
+function removeConditions(
+  predicate: BasicExpression<boolean>,
+  conditionsToRemove: Array<BasicExpression<boolean>>,
+): BasicExpression<boolean> | undefined {
+  if (predicate.type === `func` && predicate.name === `and`) {
+    const remainingArgs = predicate.args.filter(
+      (arg) =>
+        !conditionsToRemove.some((cond) =>
+          areExpressionsEqual(arg as BasicExpression<boolean>, cond),
+        ),
+    )
+
+    if (remainingArgs.length === 0) {
+      return undefined
+    } else if (remainingArgs.length === 1) {
+      return remainingArgs[0]!
+    } else {
+      return {
+        type: `func`,
+        name: `and`,
+        args: remainingArgs,
+      } as BasicExpression<boolean>
+    }
+  }
+
+  // For non-AND predicates, don't remove anything
+  return predicate
+}
+
+/**
+ * Combine multiple conditions into a single predicate using AND logic.
+ * Flattens nested AND operations to avoid unnecessary nesting.
+ */
+function combineConditions(
+  conditions: Array<BasicExpression<boolean>>,
+): BasicExpression<boolean> {
+  if (conditions.length === 0) {
+    return { type: `val`, value: true } as BasicExpression<boolean>
+  } else if (conditions.length === 1) {
+    return conditions[0]!
+  } else {
+    // Flatten all conditions, including those that are already AND operations
+    const flattenedConditions: Array<BasicExpression<boolean>> = []
+
+    for (const condition of conditions) {
+      if (condition.type === `func` && condition.name === `and`) {
+        // Flatten nested AND operations
+        flattenedConditions.push(...condition.args)
+      } else {
+        flattenedConditions.push(condition)
+      }
+    }
+
+    if (flattenedConditions.length === 1) {
+      return flattenedConditions[0]!
+    } else {
+      return {
+        type: `func`,
+        name: `and`,
+        args: flattenedConditions,
+      } as BasicExpression<boolean>
+    }
+  }
+}
+
+/**
+ * Find a predicate with a specific operator and value
+ */
+function findPredicateWithOperator(
+  predicates: Array<BasicExpression<boolean>>,
+  operator: string,
+  value: any,
+): BasicExpression<boolean> | undefined {
+  return predicates.find((p) => {
+    if (p.type === `func`) {
+      const f = p as Func
+      const field = extractComparisonField(f)
+      return f.name === operator && field && areValuesEqual(field.value, value)
+    }
+    return false
+  })
+}
+
+function areExpressionsEqual(a: BasicExpression, b: BasicExpression): boolean {
+  if (a.type !== b.type) {
+    return false
+  }
+
+  if (a.type === `val` && b.type === `val`) {
+    return areValuesEqual(a.value, b.value)
+  }
+
+  if (a.type === `ref` && b.type === `ref`) {
+    return areRefsEqual(a, b)
+  }
+
+  if (a.type === `func` && b.type === `func`) {
+    const aFunc = a
+    const bFunc = b
+    if (aFunc.name !== bFunc.name) {
+      return false
+    }
+    if (aFunc.args.length !== bFunc.args.length) {
+      return false
+    }
+    return aFunc.args.every((arg, i) =>
+      areExpressionsEqual(arg, bFunc.args[i]!),
+    )
+  }
+
+  return false
+}
+
+function areValuesEqual(a: any, b: any): boolean {
+  // Simple equality check - could be enhanced for deep object comparison
+  if (a === b) {
+    return true
+  }
+
+  // Handle NaN
+  if (typeof a === `number` && typeof b === `number` && isNaN(a) && isNaN(b)) {
+    return true
+  }
+
+  // Handle Date objects
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime()
+  }
+
+  // For arrays and objects, use reference equality
+  // (In practice, we don't need deep equality for these cases -
+  // same object reference means same value for our use case)
+  if (
+    typeof a === `object` &&
+    typeof b === `object` &&
+    a !== null &&
+    b !== null
+  ) {
+    return a === b
+  }
+
+  return false
+}
+
+function areRefsEqual(a: PropRef, b: PropRef): boolean {
+  if (a.path.length !== b.path.length) {
+    return false
+  }
+  return a.path.every((segment, i) => segment === b.path[i])
+}
+
+/**
+ * Check if a value is a primitive (string, number, boolean, null, undefined)
+ * Primitives can use Set for fast lookups
+ */
+function isPrimitive(value: any): boolean {
+  return (
+    value === null ||
+    value === undefined ||
+    typeof value === `string` ||
+    typeof value === `number` ||
+    typeof value === `boolean`
+  )
+}
+
+/**
+ * Check if all values in an array are primitives
+ */
+function areAllPrimitives(values: Array<any>): boolean {
+  return values.every(isPrimitive)
+}
+
+/**
+ * Check if a value is in an array, with optional pre-built Set for optimization.
+ * The primitiveSet is cached in InField during extraction and reused for all lookups.
+ */
+function arrayIncludesWithSet(
+  array: Array<any>,
+  value: any,
+  primitiveSet: Set<any> | null,
+  arrayIsAllPrimitives?: boolean,
+): boolean {
+  // Fast path: use pre-built Set for O(1) lookup
+  if (primitiveSet) {
+    // Skip isPrimitive check if we know the value must be primitive for a match
+    // (if array is all primitives, only primitives can match)
+    if (arrayIsAllPrimitives || isPrimitive(value)) {
+      return primitiveSet.has(value)
+    }
+    return false // Non-primitive can't be in primitive-only set
+  }
+
+  // Fallback: use areValuesEqual for Dates and objects
+  return array.some((v) => areValuesEqual(v, value))
+}
+
+/**
+ * Get the maximum of two values, handling both numbers and Dates
+ */
+function maxValue(a: any, b: any): any {
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() > b.getTime() ? a : b
+  }
+  return Math.max(a, b)
+}
+
+/**
+ * Get the minimum of two values, handling both numbers and Dates
+ */
+function minValue(a: any, b: any): any {
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() < b.getTime() ? a : b
+  }
+  return Math.min(a, b)
+}
+
+function areCompareOptionsEqual(
+  a: { direction?: `asc` | `desc`; [key: string]: any },
+  b: { direction?: `asc` | `desc`; [key: string]: any },
+): boolean {
+  // For now, just compare direction - could be enhanced for other options
+  return a.direction === b.direction
+}
+
+interface ComparisonField {
+  ref: PropRef
+  value: any
+}
+
+function extractComparisonField(func: Func): ComparisonField | null {
+  // Handle comparison operators: eq, gt, gte, lt, lte
+  if ([`eq`, `gt`, `gte`, `lt`, `lte`].includes(func.name)) {
+    // Assume first arg is ref, second is value
+    const firstArg = func.args[0]
+    const secondArg = func.args[1]
+
+    if (firstArg?.type === `ref` && secondArg?.type === `val`) {
+      return {
+        ref: firstArg,
+        value: secondArg.value,
+      }
+    }
+  }
+
+  return null
+}
+
+function extractEqualityField(func: Func): ComparisonField | null {
+  if (func.name === `eq`) {
+    const firstArg = func.args[0]
+    const secondArg = func.args[1]
+
+    if (firstArg?.type === `ref` && secondArg?.type === `val`) {
+      return {
+        ref: firstArg,
+        value: secondArg.value,
+      }
+    }
+  }
+  return null
+}
+
+interface InField {
+  ref: PropRef
+  values: Array<any>
+  // Cached optimization data (computed once, reused many times)
+  areAllPrimitives?: boolean
+  primitiveSet?: Set<any> | null
+}
+
+function extractInField(func: Func): InField | null {
+  if (func.name === `in`) {
+    const firstArg = func.args[0]
+    const secondArg = func.args[1]
+
+    if (
+      firstArg?.type === `ref` &&
+      secondArg?.type === `val` &&
+      Array.isArray(secondArg.value)
+    ) {
+      let values = secondArg.value
+      // Precompute optimization metadata once
+      const allPrimitives = areAllPrimitives(values)
+      let primitiveSet: Set<any> | null = null
+
+      if (allPrimitives && values.length > 10) {
+        // Build Set and dedupe values at the same time
+        primitiveSet = new Set(values)
+        // If we found duplicates, use the deduped array going forward
+        if (primitiveSet.size < values.length) {
+          values = Array.from(primitiveSet)
+        }
+      }
+
+      return {
+        ref: firstArg,
+        values,
+        areAllPrimitives: allPrimitives,
+        primitiveSet,
+      }
+    }
+  }
+  return null
+}
+
+function isComparisonSubset(
+  subsetFunc: Func,
+  subsetValue: any,
+  supersetFunc: Func,
+  supersetValue: any,
+): boolean {
+  const subOp = subsetFunc.name
+  const superOp = supersetFunc.name
+
+  // Handle same operator
+  if (subOp === superOp) {
+    if (subOp === `eq`) {
+      // field = X is subset of field = X only
+      // Fast path: primitives can use strict equality
+      if (isPrimitive(subsetValue) && isPrimitive(supersetValue)) {
+        return subsetValue === supersetValue
+      }
+      return areValuesEqual(subsetValue, supersetValue)
+    } else if (subOp === `gt`) {
+      // field > 20 is subset of field > 10 if 20 > 10
+      return subsetValue >= supersetValue
+    } else if (subOp === `gte`) {
+      // field >= 20 is subset of field >= 10 if 20 >= 10
+      return subsetValue >= supersetValue
+    } else if (subOp === `lt`) {
+      // field < 10 is subset of field < 20 if 10 <= 20
+      return subsetValue <= supersetValue
+    } else if (subOp === `lte`) {
+      // field <= 10 is subset of field <= 20 if 10 <= 20
+      return subsetValue <= supersetValue
+    }
+  }
+
+  // Handle different operators on same field
+  // eq vs gt/gte: field = 15 is subset of field > 10 if 15 > 10
+  if (subOp === `eq` && superOp === `gt`) {
+    return subsetValue > supersetValue
+  }
+  if (subOp === `eq` && superOp === `gte`) {
+    return subsetValue >= supersetValue
+  }
+  if (subOp === `eq` && superOp === `lt`) {
+    return subsetValue < supersetValue
+  }
+  if (subOp === `eq` && superOp === `lte`) {
+    return subsetValue <= supersetValue
+  }
+
+  // gt/gte vs gte/gt
+  if (subOp === `gt` && superOp === `gte`) {
+    // field > 10 is subset of field >= 10 if 10 >= 10 (always true for same value)
+    return subsetValue >= supersetValue
+  }
+  if (subOp === `gte` && superOp === `gt`) {
+    // field >= 11 is subset of field > 10 if 11 > 10
+    return subsetValue > supersetValue
+  }
+
+  // lt/lte vs lte/lt
+  if (subOp === `lt` && superOp === `lte`) {
+    // field < 10 is subset of field <= 10 if 10 <= 10
+    return subsetValue <= supersetValue
+  }
+  if (subOp === `lte` && superOp === `lt`) {
+    // field <= 9 is subset of field < 10 if 9 < 10
+    return subsetValue < supersetValue
+  }
+
+  return false
+}
+
+function groupPredicatesByField(
+  predicates: Array<BasicExpression<boolean>>,
+): Map<string | null, Array<BasicExpression<boolean>>> {
+  const groups = new Map<string | null, Array<BasicExpression<boolean>>>()
+
+  for (const pred of predicates) {
+    let fieldKey: string | null = null
+
+    if (pred.type === `func`) {
+      const func = pred as Func
+      const field =
+        extractComparisonField(func) ||
+        extractEqualityField(func) ||
+        extractInField(func)
+      if (field) {
+        fieldKey = field.ref.path.join(`.`)
+      }
+    }
+
+    const group = groups.get(fieldKey) || []
+    group.push(pred)
+    groups.set(fieldKey, group)
+  }
+
+  return groups
+}
+
+function unionSameFieldPredicates(
+  predicates: Array<BasicExpression<boolean>>,
+): BasicExpression<boolean> | null {
+  if (predicates.length === 1) {
+    return predicates[0]!
+  }
+
+  // Try to extract range constraints
+  let maxGt: number | null = null
+  let maxGte: number | null = null
+  let minLt: number | null = null
+  let minLte: number | null = null
+  const eqValues: Set<any> = new Set()
+  const inValues: Set<any> = new Set()
+  const otherPredicates: Array<BasicExpression<boolean>> = []
+
+  for (const pred of predicates) {
+    if (pred.type === `func`) {
+      const func = pred as Func
+      const field = extractComparisonField(func)
+
+      if (field) {
+        const value = field.value
+        if (func.name === `gt`) {
+          maxGt = maxGt === null ? value : minValue(maxGt, value)
+        } else if (func.name === `gte`) {
+          maxGte = maxGte === null ? value : minValue(maxGte, value)
+        } else if (func.name === `lt`) {
+          minLt = minLt === null ? value : maxValue(minLt, value)
+        } else if (func.name === `lte`) {
+          minLte = minLte === null ? value : maxValue(minLte, value)
+        } else if (func.name === `eq`) {
+          eqValues.add(value)
+        } else {
+          otherPredicates.push(pred)
+        }
+      } else {
+        const inField = extractInField(func)
+        if (inField) {
+          for (const val of inField.values) {
+            inValues.add(val)
+          }
+        } else {
+          otherPredicates.push(pred)
+        }
+      }
+    } else {
+      otherPredicates.push(pred)
+    }
+  }
+
+  // If we have multiple equality values, combine into IN
+  if (eqValues.size > 1 || (eqValues.size > 0 && inValues.size > 0)) {
+    const allValues = [...eqValues, ...inValues]
+    const ref = predicates.find((p) => {
+      if (p.type === `func`) {
+        const field =
+          extractComparisonField(p as Func) || extractInField(p as Func)
+        return field !== null
+      }
+      return false
+    })
+
+    if (ref && ref.type === `func`) {
+      const field =
+        extractComparisonField(ref as Func) || extractInField(ref as Func)
+      if (field) {
+        return {
+          type: `func`,
+          name: `in`,
+          args: [
+            field.ref,
+            { type: `val`, value: allValues } as BasicExpression,
+          ],
+        } as BasicExpression<boolean>
+      }
+    }
+  }
+
+  // Build the least restrictive range
+  const result: Array<BasicExpression<boolean>> = []
+
+  // Choose the least restrictive lower bound
+  if (maxGt !== null && maxGte !== null) {
+    // Take the smaller one (less restrictive)
+    const pred =
+      maxGte <= maxGt
+        ? findPredicateWithOperator(predicates, `gte`, maxGte)
+        : findPredicateWithOperator(predicates, `gt`, maxGt)
+    if (pred) result.push(pred)
+  } else if (maxGt !== null) {
+    const pred = findPredicateWithOperator(predicates, `gt`, maxGt)
+    if (pred) result.push(pred)
+  } else if (maxGte !== null) {
+    const pred = findPredicateWithOperator(predicates, `gte`, maxGte)
+    if (pred) result.push(pred)
+  }
+
+  // Choose the least restrictive upper bound
+  if (minLt !== null && minLte !== null) {
+    const pred =
+      minLte >= minLt
+        ? findPredicateWithOperator(predicates, `lte`, minLte)
+        : findPredicateWithOperator(predicates, `lt`, minLt)
+    if (pred) result.push(pred)
+  } else if (minLt !== null) {
+    const pred = findPredicateWithOperator(predicates, `lt`, minLt)
+    if (pred) result.push(pred)
+  } else if (minLte !== null) {
+    const pred = findPredicateWithOperator(predicates, `lte`, minLte)
+    if (pred) result.push(pred)
+  }
+
+  // Add single eq value
+  if (eqValues.size === 1 && inValues.size === 0) {
+    const pred = findPredicateWithOperator(predicates, `eq`, [...eqValues][0])
+    if (pred) result.push(pred)
+  }
+
+  // Add IN if only IN values
+  if (eqValues.size === 0 && inValues.size > 0) {
+    result.push(
+      predicates.find((p) => {
+        if (p.type === `func`) {
+          return (p as Func).name === `in`
+        }
+        return false
+      })!,
+    )
+  }
+
+  // Add other predicates
+  result.push(...otherPredicates)
+
+  if (result.length === 0) {
+    return { type: `val`, value: true } as BasicExpression<boolean>
+  }
+
+  if (result.length === 1) {
+    return result[0]!
+  }
+
+  return {
+    type: `func`,
+    name: `or`,
+    args: result,
+  } as BasicExpression<boolean>
+}
diff --git a/packages/db/src/query/subset-dedupe.ts b/packages/db/src/query/subset-dedupe.ts
new file mode 100644
index 000000000..4959d3cbb
--- /dev/null
+++ b/packages/db/src/query/subset-dedupe.ts
@@ -0,0 +1,243 @@
+import {
+  isPredicateSubset,
+  isWhereSubset,
+  minusWherePredicates,
+  unionWherePredicates,
+} from './predicate-utils.js'
+import type { BasicExpression } from './ir.js'
+import type { LoadSubsetOptions } from '../types.js'
+
+/**
+ * Deduplicated wrapper for a loadSubset function.
+ * Tracks what data has been loaded and avoids redundant calls by applying
+ * subset logic to predicates.
+ *
+ * @param opts - The options for the DeduplicatedLoadSubset
+ * @param opts.loadSubset - The underlying loadSubset function to wrap
+ * @param opts.onDeduplicate - An optional callback function that is invoked when a loadSubset call is deduplicated.
+ *                              If the call is deduplicated because the requested data is being loaded by an inflight request,
+ *                              then this callback is invoked when the inflight request completes successfully and the data is fully loaded.
+ *                              This callback is useful if you need to track rows per query, in which case you can't ignore deduplicated calls
+ *                              because you need to know which rows were loaded for each query.
+ * @example
+ * const dedupe = new DeduplicatedLoadSubset({ loadSubset: myLoadSubset, onDeduplicate: (opts) => console.log(`Call was deduplicated:`, opts) })
+ *
+ * // First call - fetches data
+ * await dedupe.loadSubset({ where: gt(ref('age'), val(10)) })
+ *
+ * // Second call - subset of first, returns true immediately
+ * await dedupe.loadSubset({ where: gt(ref('age'), val(20)) })
+ *
+ * // Clear state to start fresh
+ * dedupe.reset()
+ */
+export class DeduplicatedLoadSubset {
+  // The underlying loadSubset function to wrap
+  private readonly _loadSubset: (
+    options: LoadSubsetOptions,
+  ) => true | Promise<void>
+
+  // An optional callback function that is invoked when a loadSubset call is deduplicated.
+  private readonly onDeduplicate:
+    | ((options: LoadSubsetOptions) => void)
+    | undefined
+
+  // Combined where predicate for all unlimited calls (no limit)
+  private unlimitedWhere: BasicExpression<boolean> | undefined = undefined
+
+  // Flag to track if we've loaded all data (unlimited call with no where clause)
+  private hasLoadedAllData = false
+
+  // List of all limited calls (with limit, possibly with orderBy)
+  // We clone options before storing to prevent mutation of stored predicates
+  private limitedCalls: Array<LoadSubsetOptions> = []
+
+  // Track in-flight calls to prevent concurrent duplicate requests
+  // We store both the options and the promise so we can apply subset logic
+  private inflightCalls: Array<{
+    options: LoadSubsetOptions
+    promise: Promise<void>
+  }> = []
+
+  // Generation counter to invalidate in-flight requests after reset()
+  // When reset() is called, this increments, and any in-flight completion handlers
+  // check if their captured generation matches before updating tracking state
+  private generation = 0
+
+  constructor(opts: {
+    loadSubset: (options: LoadSubsetOptions) => true | Promise<void>
+    onDeduplicate?: (options: LoadSubsetOptions) => void
+  }) {
+    this._loadSubset = opts.loadSubset
+    this.onDeduplicate = opts.onDeduplicate
+  }
+
+  /**
+   * Load a subset of data, with automatic deduplication based on previously
+   * loaded predicates and in-flight requests.
+   *
+   * This method is auto-bound, so it can be safely passed as a callback without
+   * losing its `this` context (e.g., `loadSubset: dedupe.loadSubset` in a sync config).
+   *
+   * @param options - The predicate options (where, orderBy, limit)
+   * @returns true if data is already loaded, or a Promise that resolves when data is loaded
+   */
+  loadSubset = (options: LoadSubsetOptions): true | Promise<void> => {
+    // If we've loaded all data, everything is covered
+    if (this.hasLoadedAllData) {
+      this.onDeduplicate?.(options)
+      return true
+    }
+
+    // Check against unlimited combined predicate
+    // If we've loaded all data matching a where clause, we don't need to refetch subsets
+    if (this.unlimitedWhere !== undefined && options.where !== undefined) {
+      if (isWhereSubset(options.where, this.unlimitedWhere)) {
+        this.onDeduplicate?.(options)
+        return true // Data already loaded via unlimited call
+      }
+    }
+
+    // Check against limited calls
+    if (options.limit !== undefined) {
+      const alreadyLoaded = this.limitedCalls.some((loaded) =>
+        isPredicateSubset(options, loaded),
+      )
+
+      if (alreadyLoaded) {
+        this.onDeduplicate?.(options)
+        return true // Already loaded
+      }
+    }
+
+    // Check against in-flight calls using the same subset logic as resolved calls
+    // This prevents duplicate requests when concurrent calls have subset relationships
+    const matchingInflight = this.inflightCalls.find((inflight) =>
+      isPredicateSubset(options, inflight.options),
+    )
+
+    if (matchingInflight !== undefined) {
+      // An in-flight call will load data that covers this request
+      // Return the same promise so this caller waits for the data to load
+      // The in-flight promise already handles tracking updates when it completes
+      const prom = matchingInflight.promise
+      // Call `onDeduplicate` when the inflight request has loaded the data
+      prom.then(() => this.onDeduplicate?.(options)).catch() // ignore errors
+      return prom
+    }
+
+    // Not fully covered by existing data
+    // Compute the subset of data that is not covered by the existing data
+    // such that we only have to load that subset of missing data
+    const clonedOptions = cloneOptions(options)
+    if (this.unlimitedWhere !== undefined && options.limit === undefined) {
+      // Compute difference to get only the missing data
+      // We can only do this for unlimited queries
+      // and we can only remove data that was loaded from unlimited queries
+      // because with limited queries we have no way to express that we already loaded part of the matching data
+      clonedOptions.where =
+        minusWherePredicates(clonedOptions.where, this.unlimitedWhere) ??
+        clonedOptions.where
+    }
+
+    // Call underlying loadSubset to load the missing data
+    const resultPromise = this._loadSubset(clonedOptions)
+
+    // Handle both sync (true) and async (Promise<void>) return values
+    if (resultPromise === true) {
+      // Sync return - update tracking synchronously
+      // Clone options before storing to protect against caller mutation
+      this.updateTracking(clonedOptions)
+      return true
+    } else {
+      // Async return - track the promise and update tracking after it resolves
+
+      // Capture the current generation - this lets us detect if reset() was called
+      // while this request was in-flight, so we can skip updating tracking state
+      const capturedGeneration = this.generation
+
+      // We need to create a reference to the in-flight entry so we can remove it later
+      const inflightEntry = {
+        options: clonedOptions, // Store cloned options for subset matching
+        promise: resultPromise
+          .then((result) => {
+            // Only update tracking if this request is still from the current generation
+            // If reset() was called, the generation will have incremented and we should
+            // not repopulate the state that was just cleared
+            if (capturedGeneration === this.generation) {
+              // Use the cloned options that we captured before any caller mutations
+              // This ensures we track exactly what was loaded, not what the caller changed
+              this.updateTracking(clonedOptions)
+            }
+            return result
+          })
+          .finally(() => {
+            // Always remove from in-flight array on completion OR rejection
+            // This ensures failed requests can be retried instead of being cached forever
+            const index = this.inflightCalls.indexOf(inflightEntry)
+            if (index !== -1) {
+              this.inflightCalls.splice(index, 1)
+            }
+          }),
+      }
+
+      // Store the in-flight entry so concurrent subset calls can wait for it
+      this.inflightCalls.push(inflightEntry)
+      return inflightEntry.promise
+    }
+  }
+
+  /**
+   * Reset all tracking state.
+   * Clears the history of loaded predicates and in-flight calls.
+   * Use this when you want to start fresh, for example after clearing the underlying data store.
+   *
+   * Note: Any in-flight requests will still complete, but they will not update the tracking
+   * state after the reset. This prevents old requests from repopulating cleared state.
+   */
+  reset(): void {
+    this.unlimitedWhere = undefined
+    this.hasLoadedAllData = false
+    this.limitedCalls = []
+    this.inflightCalls = []
+    // Increment generation to invalidate any in-flight completion handlers
+    // This ensures requests that were started before reset() don't repopulate the state
+    this.generation++
+  }
+
+  private updateTracking(options: LoadSubsetOptions): void {
+    // Update tracking based on whether this was a limited or unlimited call
+    if (options.limit === undefined) {
+      // Unlimited call - update combined where predicate
+      // We ignore orderBy for unlimited calls as mentioned in requirements
+      if (options.where === undefined) {
+        // No where clause = all data loaded
+        this.hasLoadedAllData = true
+        this.unlimitedWhere = undefined
+        this.limitedCalls = []
+        this.inflightCalls = []
+      } else if (this.unlimitedWhere === undefined) {
+        this.unlimitedWhere = options.where
+      } else {
+        this.unlimitedWhere = unionWherePredicates([
+          this.unlimitedWhere,
+          options.where,
+        ])
+      }
+    } else {
+      // Limited call - add to list for future subset checks
+      // Options are already cloned by caller to prevent mutation issues
+      this.limitedCalls.push(options)
+    }
+  }
+}
+
+/**
+ * Clones a LoadSubsetOptions object to prevent mutation of stored predicates.
+ * This is crucial because callers often reuse the same options object and mutate
+ * properties like limit or where between calls. Without cloning, our stored history
+ * would reflect the mutated values rather than what was actually loaded.
+ */
+export function cloneOptions(options: LoadSubsetOptions): LoadSubsetOptions {
+  return { ...options }
+}
diff --git a/packages/db/src/scheduler.ts b/packages/db/src/scheduler.ts
index de67593ed..8ffe8b768 100644
--- a/packages/db/src/scheduler.ts
+++ b/packages/db/src/scheduler.ts
@@ -25,6 +25,18 @@ interface SchedulerContextState {
   completed: Set<unknown>
 }
 
+interface PendingAwareJob {
+  hasPendingGraphRun: (contextId: SchedulerContextId) => boolean
+}
+
+function isPendingAwareJob(dep: any): dep is PendingAwareJob {
+  return (
+    typeof dep === `object` &&
+    dep !== null &&
+    typeof dep.hasPendingGraphRun === `function`
+  )
+}
+
 /**
  * Scoped scheduler that coalesces work by context and job.
  *
@@ -42,7 +54,7 @@ export class Scheduler {
    * Get or create the state bucket for a context.
    */
   private getOrCreateContext(
-    contextId: SchedulerContextId
+    contextId: SchedulerContextId,
   ): SchedulerContextState {
     let context = this.contexts.get(contextId)
     if (!context) {
@@ -119,7 +131,19 @@ export class Scheduler {
         if (deps) {
           ready = true
           for (const dep of deps) {
-            if (dep !== jobId && !completed.has(dep)) {
+            if (dep === jobId) continue
+
+            const depHasPending =
+              isPendingAwareJob(dep) && dep.hasPendingGraphRun(contextId)
+
+            // Treat dependencies as blocking if the dep has a pending run in this
+            // context or if it's enqueued and not yet complete. If the dep is
+            // neither pending nor enqueued, consider it satisfied to avoid deadlocks
+            // on lazy sources that never schedule work.
+            if (
+              (jobs.has(dep) && !completed.has(dep)) ||
+              (!jobs.has(dep) && depHasPending)
+            ) {
               ready = false
               break
             }
@@ -142,8 +166,8 @@ export class Scheduler {
       if (!ranThisPass) {
         throw new Error(
           `Scheduler detected unresolved dependencies for context ${String(
-            contextId
-          )}.`
+            contextId,
+          )}.`,
         )
       }
     }
diff --git a/packages/db/src/strategies/debounceStrategy.ts b/packages/db/src/strategies/debounceStrategy.ts
new file mode 100644
index 000000000..355b435c5
--- /dev/null
+++ b/packages/db/src/strategies/debounceStrategy.ts
@@ -0,0 +1,48 @@
+import { LiteDebouncer } from '@tanstack/pacer-lite/lite-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 = usePacedMutations({
+ *   onMutate: (value) => {
+ *     collection.update(id, draft => { draft.value = value })
+ *   },
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.save(transaction.mutations)
+ *   },
+ *   strategy: debounceStrategy({ wait: 500 })
+ * })
+ * ```
+ */
+export function debounceStrategy(
+  options: DebounceStrategyOptions,
+): DebounceStrategy {
+  const debouncer = new LiteDebouncer(
+    (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..64d41acea
--- /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..2a374d8ee
--- /dev/null
+++ b/packages/db/src/strategies/queueStrategy.ts
@@ -0,0 +1,97 @@
+import { LiteQueuer } from '@tanstack/pacer-lite/lite-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 attempted sequentially. Each transaction commit completes before
+ * the next one starts. Useful when data consistency is critical and
+ * every operation must be attempted in order.
+ *
+ * **Error handling behavior:**
+ * - If a mutation fails, it is NOT automatically retried - the transaction transitions to "failed" state
+ * - Failed mutations surface their error via `transaction.isPersisted.promise` (which will reject)
+ * - Subsequent mutations continue processing - a single failure does not block the queue
+ * - Each mutation is independent; there is no all-or-nothing transaction semantics
+ *
+ * @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 {
+  // Manual promise chaining to ensure async serialization
+  // LiteQueuer (unlike AsyncQueuer from @tanstack/pacer) lacks built-in async queue
+  // primitives and concurrency control. We compensate by manually chaining promises
+  // to ensure each transaction completes before the next one starts.
+  let processingChain = Promise.resolve()
+
+  const queuer = new LiteQueuer<() => Transaction>(
+    (fn) => {
+      // Chain each transaction to the previous one's completion
+      processingChain = processingChain
+        .then(async () => {
+          const transaction = fn()
+          // Wait for the transaction to be persisted before processing next item
+          await transaction.isPersisted.promise
+        })
+        .catch(() => {
+          // Errors are handled via transaction.isPersisted.promise and surfaced there.
+          // This catch prevents unhandled promise rejections from breaking the chain,
+          // ensuring subsequent transactions can still execute even if one fails.
+        })
+    },
+    {
+      wait: options?.wait ?? 0,
+      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>,
+    ) => {
+      // Add the transaction-creating function to the queue
+      queuer.addItem(fn as () => Transaction)
+    },
+    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..95ad510a8
--- /dev/null
+++ b/packages/db/src/strategies/throttleStrategy.ts
@@ -0,0 +1,68 @@
+import { LiteThrottler } from '@tanstack/pacer-lite/lite-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 = usePacedMutations({
+ *   onMutate: (volume) => {
+ *     settingsCollection.update('volume', draft => { draft.value = volume })
+ *   },
+ *   mutationFn: async ({ transaction }) => {
+ *     await api.updateVolume(transaction.mutations)
+ *   },
+ *   strategy: throttleStrategy({ wait: 200 })
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Throttle with leading and trailing execution
+ * const mutate = usePacedMutations({
+ *   onMutate: (data) => {
+ *     collection.update(id, draft => { Object.assign(draft, data) })
+ *   },
+ *   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 LiteThrottler(
+    (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..70102c87a
--- /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/db/src/transactions.ts b/packages/db/src/transactions.ts
index 9fc79238b..858772be2 100644
--- a/packages/db/src/transactions.ts
+++ b/packages/db/src/transactions.ts
@@ -1,19 +1,20 @@
-import { createDeferred } from "./deferred"
+import { createDeferred } from './deferred'
+import './duplicate-instance-check'
 import {
   MissingMutationFunctionError,
   TransactionAlreadyCompletedRollbackError,
   TransactionNotPendingCommitError,
   TransactionNotPendingMutateError,
-} from "./errors"
-import { transactionScopedScheduler } from "./scheduler.js"
-import type { Deferred } from "./deferred"
+} from './errors'
+import { transactionScopedScheduler } from './scheduler.js'
+import type { Deferred } from './deferred'
 import type {
   MutationFn,
   PendingMutation,
   TransactionConfig,
   TransactionState,
   TransactionWithMutations,
-} from "./types"
+} from './types'
 
 const transactions: Array<Transaction<any>> = []
 let transactionStack: Array<Transaction<any>> = []
@@ -40,7 +41,7 @@ let sequenceNumber = 0
  */
 function mergePendingMutations<T extends object>(
   existing: PendingMutation<T>,
-  incoming: PendingMutation<T>
+  incoming: PendingMutation<T>,
 ): PendingMutation<T> | null {
   // Truth table implementation
   switch (`${existing.type}-${incoming.type}` as const) {
@@ -153,7 +154,7 @@ function mergePendingMutations<T extends object>(
  * await tx.commit()
  */
 export function createTransaction<T extends object = Record<string, unknown>>(
-  config: TransactionConfig<T>
+  config: TransactionConfig<T>,
 ): Transaction<T> {
   const newTransaction = new Transaction<T>(config)
   transactions.push(newTransaction)
@@ -244,7 +245,9 @@ class Transaction<T extends object = Record<string, unknown>> {
 
   /**
    * Execute collection operations within this transaction
-   * @param callback - Function containing collection operations to group together
+   * @param callback - Function containing collection operations to group together. If the
+   * callback returns a Promise, the transaction context will remain active until the promise
+   * settles, allowing optimistic writes after `await` boundaries.
    * @returns This transaction for chaining
    * @example
    * // Group multiple operations
@@ -287,6 +290,7 @@ class Transaction<T extends object = Record<string, unknown>> {
     }
 
     registerTransaction(this)
+
     try {
       callback()
     } finally {
@@ -323,7 +327,7 @@ class Transaction<T extends object = Record<string, unknown>> {
   applyMutations(mutations: Array<PendingMutation<any>>): void {
     for (const newMutation of mutations) {
       const existingIndex = this.mutations.findIndex(
-        (m) => m.globalKey === newMutation.globalKey
+        (m) => m.globalKey === newMutation.globalKey,
       )
 
       if (existingIndex >= 0) {
diff --git a/packages/db/src/types.ts b/packages/db/src/types.ts
index 73c1fc4fe..51dbe2ddd 100644
--- a/packages/db/src/types.ts
+++ b/packages/db/src/types.ts
@@ -1,9 +1,41 @@
-import type { IStreamBuilder } from "@tanstack/db-ivm"
-import type { Collection } from "./collection/index.js"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import type { Transaction } from "./transactions"
-import type { BasicExpression, OrderBy } from "./query/ir.js"
-import type { EventEmitter } from "./event-emitter.js"
+import type { IStreamBuilder } from '@tanstack/db-ivm'
+import type { Collection } from './collection/index.js'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { Transaction } from './transactions'
+import type { BasicExpression, OrderBy } from './query/ir.js'
+import type { EventEmitter } from './event-emitter.js'
+import type { SingleRowRefProxy } from './query/builder/ref-proxy.js'
+
+/**
+ * Interface for a collection-like object that provides the necessary methods
+ * for the change events system to work
+ */
+export interface CollectionLike<
+  T extends object = Record<string, unknown>,
+  TKey extends string | number = string | number,
+> extends Pick<
+  Collection<T, TKey>,
+  `get` | `has` | `entries` | `indexes` | `id` | `compareOptions`
+> {}
+
+/**
+ * StringSortOpts - Options for string sorting behavior
+ *
+ * This discriminated union allows for two types of string sorting:
+ * - **Lexical**: Simple character-by-character comparison (default)
+ * - **Locale**: Locale-aware sorting with optional customization
+ *
+ * The union ensures that locale options are only available when locale sorting is selected.
+ */
+export type StringCollationConfig =
+  | {
+      stringSort?: `lexical`
+    }
+  | {
+      stringSort?: `locale`
+      locale?: string
+      localeOptions?: object
+    }
 
 /**
  * Helper type to extract the output type from a standard schema
@@ -35,9 +67,9 @@ export type TransactionState = `pending` | `persisting` | `completed` | `failed`
 export type Fn = (...args: Array<any>) => any
 
 /**
- * A record of utility functions that can be attached to a collection
+ * A record of utilities (functions or getters) that can be attached to a collection
  */
-export type UtilsRecord = Record<string, Fn>
+export type UtilsRecord = Record<string, any>
 
 /**
  *
@@ -93,7 +125,7 @@ export type MutationFnParams<T extends object = Record<string, unknown>> = {
 }
 
 export type MutationFn<T extends object = Record<string, unknown>> = (
-  params: MutationFnParams<T>
+  params: MutationFnParams<T>,
 ) => Promise<any>
 
 /**
@@ -108,7 +140,26 @@ export type NonEmptyArray<T> = [T, ...Array<T>]
 export type TransactionWithMutations<
   T extends object = Record<string, unknown>,
   TOperation extends OperationType = OperationType,
-> = Transaction<T> & {
+> = Omit<Transaction<T>, `mutations`> & {
+  /**
+   * We must omit the `mutations` property from `Transaction<T>` before intersecting
+   * because TypeScript intersects property types when the same property appears on
+   * both sides of an intersection.
+   *
+   * Without `Omit`:
+   * - `Transaction<T>` has `mutations: Array<PendingMutation<T>>`
+   * - The intersection would create: `Array<PendingMutation<T>> & NonEmptyArray<PendingMutation<T, TOperation>>`
+   * - When mapping over this array, TypeScript widens `TOperation` from the specific literal
+   *   (e.g., `"delete"`) to the union `OperationType` (`"insert" | "update" | "delete"`)
+   * - This causes `PendingMutation<T, OperationType>` to evaluate the conditional type
+   *   `original: TOperation extends 'insert' ? {} : T` as `{} | T` instead of just `T`
+   *
+   * With `Omit`:
+   * - We remove `mutations` from `Transaction<T>` first
+   * - Then add back `mutations: NonEmptyArray<PendingMutation<T, TOperation>>`
+   * - TypeScript can properly narrow `TOperation` to the specific literal type
+   * - This ensures `mutation.original` is correctly typed as `T` (not `{} | T`) when mapping
+   */
   mutations: NonEmptyArray<PendingMutation<T, TOperation>>
 }
 
@@ -188,9 +239,9 @@ export interface SubscriptionUnsubscribedEvent {
  * All subscription events
  */
 export type SubscriptionEvents = {
-  "status:change": SubscriptionStatusChangeEvent
-  "status:ready": SubscriptionStatusEvent<`ready`>
-  "status:loadingSubset": SubscriptionStatusEvent<`loadingSubset`>
+  'status:change': SubscriptionStatusChangeEvent
+  'status:ready': SubscriptionStatusEvent<`ready`>
+  'status:loadingSubset': SubscriptionStatusEvent<`loadingSubset`>
   unsubscribed: SubscriptionUnsubscribedEvent
 }
 
@@ -203,13 +254,52 @@ export interface Subscription extends EventEmitter<SubscriptionEvents> {
   readonly status: SubscriptionStatus
 }
 
+/**
+ * Cursor expressions for pagination, passed separately from the main `where` clause.
+ * The sync layer can choose to use cursor-based pagination (combining these with the where)
+ * or offset-based pagination (ignoring these and using the `offset` parameter).
+ *
+ * Neither expression includes the main `where` clause - they are cursor-specific only.
+ */
+export type CursorExpressions = {
+  /**
+   * Expression for rows greater than (after) the cursor value.
+   * For multi-column orderBy, this is a composite cursor using OR of conditions.
+   * Example for [col1 ASC, col2 DESC] with values [v1, v2]:
+   *   or(gt(col1, v1), and(eq(col1, v1), lt(col2, v2)))
+   */
+  whereFrom: BasicExpression<boolean>
+  /**
+   * Expression for rows equal to the current cursor value (first orderBy column only).
+   * Used to handle tie-breaking/duplicates at the boundary.
+   * Example: eq(col1, v1) or for Dates: and(gte(col1, v1), lt(col1, v1+1ms))
+   */
+  whereCurrent: BasicExpression<boolean>
+  /**
+   * The key of the last item that was loaded.
+   * Can be used by sync layers for tracking or deduplication.
+   */
+  lastKey?: string | number
+}
+
 export type LoadSubsetOptions = {
-  /** The where expression to filter the data */
+  /** The where expression to filter the data (does NOT include cursor expressions) */
   where?: BasicExpression<boolean>
   /** The order by clause to sort the data */
   orderBy?: OrderBy
   /** The limit of the data to load */
   limit?: number
+  /**
+   * Cursor expressions for cursor-based pagination.
+   * These are separate from `where` - the sync layer should combine them if using cursor-based pagination.
+   * Neither expression includes the main `where` clause.
+   */
+  cursor?: CursorExpressions
+  /**
+   * Row offset for offset-based pagination.
+   * The sync layer can use this instead of `cursor` if it prefers offset-based pagination.
+   */
+  offset?: number
   /**
    * The subscription that triggered the load.
    * Advanced sync implementations can use this for:
@@ -223,11 +313,14 @@ export type LoadSubsetOptions = {
 
 export type LoadSubsetFn = (options: LoadSubsetOptions) => true | Promise<void>
 
+export type UnloadSubsetFn = (options: LoadSubsetOptions) => void
+
 export type CleanupFn = () => void
 
 export type SyncConfigRes = {
   cleanup?: CleanupFn
   loadSubset?: LoadSubsetFn
+  unloadSubset?: UnloadSubsetFn
 }
 export interface SyncConfig<
   T extends object = Record<string, unknown>,
@@ -235,8 +328,13 @@ export interface SyncConfig<
 > {
   sync: (params: {
     collection: Collection<T, TKey, any, any, any>
-    begin: () => void
-    write: (message: Omit<ChangeMessage<T>, `key`>) => void
+    /**
+     * Begin a new sync transaction.
+     * @param options.immediate - When true, the transaction will be processed immediately
+     *   even if there are persisting user transactions. Used by manual write operations.
+     */
+    begin: (options?: { immediate?: boolean }) => void
+    write: (message: ChangeMessageOrDeleteKeyMessage<T, TKey>) => void
     commit: () => void
     markReady: () => void
     truncate: () => void
@@ -269,19 +367,35 @@ export interface ChangeMessage<
   metadata?: Record<string, unknown>
 }
 
-export interface OptimisticChangeMessage<
+export type DeleteKeyMessage<TKey extends string | number = string | number> =
+  Omit<ChangeMessage<any, TKey>, `value` | `previousValue` | `type`> & {
+    type: `delete`
+  }
+
+export type ChangeMessageOrDeleteKeyMessage<
   T extends object = Record<string, unknown>,
-> extends ChangeMessage<T> {
-  // Is this change message part of an active transaction. Only applies to optimistic changes.
-  isActive?: boolean
-}
+  TKey extends string | number = string | number,
+> = Omit<ChangeMessage<T>, `key`> | DeleteKeyMessage<TKey>
+
+export type OptimisticChangeMessage<
+  T extends object = Record<string, unknown>,
+  TKey extends string | number = string | number,
+> =
+  | (ChangeMessage<T> & {
+      // Is this change message part of an active transaction. Only applies to optimistic changes.
+      isActive?: boolean
+    })
+  | (DeleteKeyMessage<TKey> & {
+      // Is this change message part of an active transaction. Only applies to optimistic changes.
+      isActive?: boolean
+    })
 
 /**
  * The Standard Schema interface.
  * This follows the standard-schema specification: https://github.com/standard-schema/standard-schema
  */
 export type StandardSchema<T> = StandardSchemaV1 & {
-  "~standard": {
+  '~standard': {
     types?: {
       input: T
       output: T
@@ -582,6 +696,14 @@ export interface BaseCollectionConfig<
    */
   onDelete?: DeleteMutationFn<T, TKey, TUtils, TReturn>
 
+  /**
+   * Specifies how to compare data in the collection.
+   * This should be configured to match data ordering on the backend.
+   * E.g., when using the Electric DB collection these options
+   *       should match the database's collation settings.
+   */
+  defaultStringCollation?: StringCollationConfig
+
   utils?: TUtils
 }
 
@@ -659,15 +781,39 @@ export type NamespacedAndKeyedStream = IStreamBuilder<KeyedNamespacedRow>
 /**
  * Options for subscribing to collection changes
  */
-export interface SubscribeChangesOptions {
+export interface SubscribeChangesOptions<
+  T extends object = Record<string, unknown>,
+> {
   /** Whether to include the current state as initial changes */
   includeInitialState?: boolean
+  /**
+   * Callback function for filtering changes using a row proxy.
+   * The callback receives a proxy object that records property access,
+   * allowing you to use query builder functions like `eq`, `gt`, etc.
+   *
+   * @example
+   * ```ts
+   * import { eq } from "@tanstack/db"
+   *
+   * collection.subscribeChanges(callback, {
+   *   where: (row) => eq(row.status, "active")
+   * })
+   * ```
+   */
+  where?: (row: SingleRowRefProxy<T>) => any
   /** Pre-compiled expression for filtering changes */
   whereExpression?: BasicExpression<boolean>
+  /**
+   * Listener for subscription status changes.
+   * Registered BEFORE any snapshot is requested, ensuring no status transitions are missed.
+   * @internal
+   */
+  onStatusChange?: (event: SubscriptionStatusChangeEvent) => void
 }
 
-export interface SubscribeChangesSnapshotOptions
-  extends Omit<SubscribeChangesOptions, `includeInitialState`> {
+export interface SubscribeChangesSnapshotOptions<
+  T extends object = Record<string, unknown>,
+> extends Omit<SubscribeChangesOptions<T>, `includeInitialState`> {
   orderBy?: OrderBy
   limit?: number
 }
@@ -792,3 +938,6 @@ export type WritableDeep<T> = T extends BuiltIns
           : T extends object
             ? WritableObjectDeep<T>
             : unknown
+
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> &
+  Partial<Pick<T, K>>
diff --git a/packages/db/src/utils.ts b/packages/db/src/utils.ts
index 5f40934e1..00292e37a 100644
--- a/packages/db/src/utils.ts
+++ b/packages/db/src/utils.ts
@@ -2,7 +2,7 @@
  * Generic utility functions
  */
 
-import type { CompareOptions } from "./query/builder/types"
+import type { CompareOptions } from './query/builder/types'
 
 interface TypedArray {
   length: number
@@ -36,7 +36,7 @@ export function deepEquals(a: any, b: any): boolean {
 function deepEqualsInternal(
   a: any,
   b: any,
-  visited: Map<object, object>
+  visited: Map<object, object>,
 ): boolean {
   // Handle strict equality (primitives, same reference)
   if (a === b) return true
@@ -52,12 +52,16 @@ function deepEqualsInternal(
     if (!(b instanceof Date)) return false
     return a.getTime() === b.getTime()
   }
+  // Symmetric check: if b is Date but a is not, they're not equal
+  if (b instanceof Date) return false
 
   // Handle RegExp objects
   if (a instanceof RegExp) {
     if (!(b instanceof RegExp)) return false
     return a.source === b.source && a.flags === b.flags
   }
+  // Symmetric check: if b is RegExp but a is not, they're not equal
+  if (b instanceof RegExp) return false
 
   // Handle Map objects - only if both are Maps
   if (a instanceof Map) {
@@ -78,6 +82,8 @@ function deepEqualsInternal(
     visited.delete(a)
     return result
   }
+  // Symmetric check: if b is Map but a is not, they're not equal
+  if (b instanceof Map) return false
 
   // Handle Set objects - only if both are Sets
   if (a instanceof Set) {
@@ -106,6 +112,8 @@ function deepEqualsInternal(
     visited.delete(a)
     return result
   }
+  // Symmetric check: if b is Set but a is not, they're not equal
+  if (b instanceof Set) return false
 
   // Handle TypedArrays
   if (
@@ -124,6 +132,14 @@ function deepEqualsInternal(
 
     return true
   }
+  // Symmetric check: if b is TypedArray but a is not, they're not equal
+  if (
+    ArrayBuffer.isView(b) &&
+    !(b instanceof DataView) &&
+    !ArrayBuffer.isView(a)
+  ) {
+    return false
+  }
 
   // Handle Temporal objects
   // Check if both are Temporal objects of the same type
@@ -142,6 +158,8 @@ function deepEqualsInternal(
     // Fallback to toString comparison for other types
     return a.toString() === b.toString()
   }
+  // Symmetric check: if b is Temporal but a is not, they're not equal
+  if (isTemporal(b)) return false
 
   // Handle arrays
   if (Array.isArray(a)) {
@@ -154,11 +172,13 @@ function deepEqualsInternal(
     visited.set(a, b)
 
     const result = a.every((item, index) =>
-      deepEqualsInternal(item, b[index], visited)
+      deepEqualsInternal(item, b[index], visited),
     )
     visited.delete(a)
     return result
   }
+  // Symmetric check: if b is array but a is not, they're not equal
+  if (Array.isArray(b)) return false
 
   // Handle objects
   if (typeof a === `object`) {
@@ -180,7 +200,7 @@ function deepEqualsInternal(
 
     // Check if all keys exist in both objects and their values are equal
     const result = keysA.every(
-      (key) => key in b && deepEqualsInternal(a[key], b[key], visited)
+      (key) => key in b && deepEqualsInternal(a[key], b[key], visited),
     )
 
     visited.delete(a)
diff --git a/packages/db/src/utils/array-utils.ts b/packages/db/src/utils/array-utils.ts
index 55847d91f..8b2cdbefd 100644
--- a/packages/db/src/utils/array-utils.ts
+++ b/packages/db/src/utils/array-utils.ts
@@ -8,7 +8,7 @@
 export function findInsertPosition<T>(
   sortedArray: Array<[T, any]>,
   value: T,
-  compareFn: (a: T, b: T) => number
+  compareFn: (a: T, b: T) => number,
 ): number {
   let left = 0
   let right = sortedArray.length
diff --git a/packages/db/src/utils/browser-polyfills.ts b/packages/db/src/utils/browser-polyfills.ts
index f370024a6..16a021785 100644
--- a/packages/db/src/utils/browser-polyfills.ts
+++ b/packages/db/src/utils/browser-polyfills.ts
@@ -7,7 +7,7 @@ export type IdleCallbackDeadline = {
 export type IdleCallbackFunction = (deadline: IdleCallbackDeadline) => void
 
 const requestIdleCallbackPolyfill = (
-  callback: IdleCallbackFunction
+  callback: IdleCallbackFunction,
 ): number => {
   // Use a very small timeout for the polyfill to simulate idle time
   const timeout = 0
@@ -26,7 +26,7 @@ const cancelIdleCallbackPolyfill = (id: number): void => {
 
 export const safeRequestIdleCallback: (
   callback: IdleCallbackFunction,
-  options?: { timeout?: number }
+  options?: { timeout?: number },
 ) => number =
   typeof window !== `undefined` && `requestIdleCallback` in window
     ? (callback, options) =>
diff --git a/packages/db/src/utils/btree.ts b/packages/db/src/utils/btree.ts
index 30f39c42d..0d35cf7a5 100644
--- a/packages/db/src/utils/btree.ts
+++ b/packages/db/src/utils/btree.ts
@@ -117,7 +117,7 @@ export class BTree<K = any, V = any> {
   public constructor(
     compare: (a: K, b: K) => number,
     entries?: Array<[K, V]>,
-    maxNodeSize?: number
+    maxNodeSize?: number,
   ) {
     this._maxNodeSize = maxNodeSize! >= 4 ? Math.min(maxNodeSize!, 256) : 32
     this._compare = compare
@@ -230,7 +230,7 @@ export class BTree<K = any, V = any> {
       0,
       (k, _v) => {
         results.push(k)
-      }
+      },
     )
     return results
   }
@@ -250,7 +250,7 @@ export class BTree<K = any, V = any> {
       key,
       this._compare,
       false,
-      reusedArray
+      reusedArray,
     )
   }
 
@@ -306,7 +306,7 @@ export class BTree<K = any, V = any> {
     high: K,
     includeHigh: boolean,
     onFound?: (k: K, v: V, counter: number) => void,
-    initialCounter?: number
+    initialCounter?: number,
   ): number
 
   /**
@@ -331,7 +331,7 @@ export class BTree<K = any, V = any> {
     high: K,
     includeHigh: boolean,
     onFound?: (k: K, v: V, counter: number) => { break?: R } | void,
-    initialCounter?: number
+    initialCounter?: number,
   ): R | number {
     const r = this._root.forRange(
       low,
@@ -340,7 +340,7 @@ export class BTree<K = any, V = any> {
       false,
       this,
       initialCounter || 0,
-      onFound
+      onFound,
     )
     return typeof r === `number` ? r : r.break!
   }
@@ -379,7 +379,7 @@ export class BTree<K = any, V = any> {
     high: K,
     includeHigh: boolean,
     onFound: (k: K, v: V, counter: number) => EditRangeResult<V, R> | void,
-    initialCounter?: number
+    initialCounter?: number,
   ): R | number {
     let root = this._root
     if (root.isShared) this._root = root = root.clone()
@@ -391,7 +391,7 @@ export class BTree<K = any, V = any> {
         true,
         this,
         initialCounter || 0,
-        onFound
+        onFound,
       )
       return typeof r === `number` ? r : r.break!
     } finally {
@@ -500,7 +500,7 @@ class BNode<K, V> {
     key: K,
     compare: (a: K, b: K) => number,
     inclusive: boolean,
-    reusedArray: [K, V]
+    reusedArray: [K, V],
   ): [K, V] | undefined {
     const i = this.indexOf(key, -1, compare)
     const indexOrLower = i < 0 ? ~i - 1 : inclusive ? i : i - 1
@@ -516,7 +516,7 @@ class BNode<K, V> {
     key: K,
     compare: (a: K, b: K) => number,
     inclusive: boolean,
-    reusedArray: [K, V]
+    reusedArray: [K, V],
   ): [K, V] | undefined {
     const i = this.indexOf(key, -1, compare)
     const indexOrLower = i < 0 ? ~i : inclusive ? i : i + 1
@@ -536,7 +536,7 @@ class BNode<K, V> {
     key: K,
     value: V,
     overwrite: boolean | undefined,
-    tree: BTree<K, V>
+    tree: BTree<K, V>,
   ): boolean | BNode<K, V> {
     let i = this.indexOf(key, -1, tree._compare)
     if (i < 0) {
@@ -636,7 +636,7 @@ class BNode<K, V> {
     editMode: boolean,
     tree: BTree<K, V>,
     count: number,
-    onFound?: (k: K, v: V, counter: number) => EditRangeResult<V, R> | void
+    onFound?: (k: K, v: V, counter: number) => EditRangeResult<V, R> | void,
   ): EditRangeResult<V, R> | number {
     const cmp = tree._compare
     let iLow, iHigh
@@ -732,7 +732,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
     key: K,
     compare: (a: K, b: K) => number,
     inclusive: boolean,
-    reusedArray: [K, V]
+    reusedArray: [K, V],
   ): [K, V] | undefined {
     const i = this.indexOf(key, 0, compare),
       children = this.children
@@ -741,7 +741,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
       key,
       compare,
       inclusive,
-      reusedArray
+      reusedArray,
     )
     if (result === undefined && i > 0) {
       return children[i - 1]!.maxPair(reusedArray)
@@ -753,7 +753,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
     key: K,
     compare: (a: K, b: K) => number,
     inclusive: boolean,
-    reusedArray: [K, V]
+    reusedArray: [K, V],
   ): [K, V] | undefined {
     const i = this.indexOf(key, 0, compare),
       children = this.children,
@@ -763,7 +763,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
       key,
       compare,
       inclusive,
-      reusedArray
+      reusedArray,
     )
     if (result === undefined && i < length - 1) {
       return children[i + 1]!.minPair(reusedArray)
@@ -778,7 +778,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
     key: K,
     value: V,
     overwrite: boolean | undefined,
-    tree: BTree<K, V>
+    tree: BTree<K, V>,
   ): boolean | BNodeInternal<K, V> {
     const c = this.children,
       max = tree._maxNodeSize,
@@ -854,7 +854,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
     const half = this.children.length >> 1
     return new BNodeInternal<K, V>(
       this.children.splice(half),
-      this.keys.splice(half)
+      this.keys.splice(half),
     )
   }
 
@@ -887,7 +887,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
     editMode: boolean,
     tree: BTree<K, V>,
     count: number,
-    onFound?: (k: K, v: V, counter: number) => EditRangeResult<V, R> | void
+    onFound?: (k: K, v: V, counter: number) => EditRangeResult<V, R> | void,
   ): EditRangeResult<V, R> | number {
     const cmp = tree._compare
     const keys = this.keys,
@@ -896,7 +896,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
       i = iLow
     const iHigh = Math.min(
       high === low ? iLow : this.indexOf(high, 0, cmp),
-      keys.length - 1
+      keys.length - 1,
     )
     if (!editMode) {
       // Simple case
@@ -908,7 +908,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
           editMode,
           tree,
           count,
-          onFound
+          onFound,
         )
         if (typeof result !== `number`) return result
         count = result
@@ -924,7 +924,7 @@ class BNodeInternal<K, V> extends BNode<K, V> {
             editMode,
             tree,
             count,
-            onFound
+            onFound,
           )
           // Note: if children[i] is empty then keys[i]=undefined.
           //       This is an invalid state, but it is fixed below.
diff --git a/packages/db/src/utils/comparison.ts b/packages/db/src/utils/comparison.ts
index 787ba13a3..3cf14a210 100644
--- a/packages/db/src/utils/comparison.ts
+++ b/packages/db/src/utils/comparison.ts
@@ -1,4 +1,4 @@
-import type { CompareOptions } from "../query/builder/types"
+import type { CompareOptions } from '../query/builder/types'
 
 // WeakMap to store stable IDs for objects
 const objectIds = new WeakMap<object, number>()
@@ -84,7 +84,7 @@ export const ascComparator = (a: any, b: any, opts: CompareOptions): number => {
 export const descComparator = (
   a: unknown,
   b: unknown,
-  opts: CompareOptions
+  opts: CompareOptions,
 ): number => {
   return ascComparator(b, a, {
     ...opts,
@@ -93,7 +93,7 @@ export const descComparator = (
 }
 
 export function makeComparator(
-  opts: CompareOptions
+  opts: CompareOptions,
 ): (a: any, b: any) => number {
   return (a, b) => {
     if (opts.direction === `asc`) {
@@ -112,11 +112,80 @@ export const defaultComparator = makeComparator({
 })
 
 /**
- * Normalize a value for comparison
+ * Compare two Uint8Arrays for content equality
+ */
+function areUint8ArraysEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.byteLength !== b.byteLength) {
+    return false
+  }
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * Threshold for normalizing Uint8Arrays to string representations.
+ * Arrays larger than this will use reference equality to avoid memory overhead.
+ * 128 bytes is enough for common ID formats (ULIDs are 16 bytes, UUIDs are 16 bytes)
+ * while avoiding excessive string allocation for large binary data.
+ */
+const UINT8ARRAY_NORMALIZE_THRESHOLD = 128
+
+/**
+ * Normalize a value for comparison and Map key usage
+ * Converts values that can't be directly compared or used as Map keys
+ * into comparable primitive representations
  */
 export function normalizeValue(value: any): any {
   if (value instanceof Date) {
     return value.getTime()
   }
+
+  // Normalize Uint8Arrays/Buffers to a string representation for Map key usage
+  // This enables content-based equality for binary data like ULIDs
+  const isUint8Array =
+    (typeof Buffer !== `undefined` && value instanceof Buffer) ||
+    value instanceof Uint8Array
+
+  if (isUint8Array) {
+    // Only normalize small arrays to avoid memory overhead for large binary data
+    if (value.byteLength <= UINT8ARRAY_NORMALIZE_THRESHOLD) {
+      // Convert to a string representation that can be used as a Map key
+      // Use a special prefix to avoid collisions with user strings
+      return `__u8__${Array.from(value).join(`,`)}`
+    }
+    // For large arrays, fall back to reference equality
+    // Users working with large binary data should use a derived key if needed
+  }
+
   return value
 }
+
+/**
+ * Compare two values for equality, with special handling for Uint8Arrays and Buffers
+ */
+export function areValuesEqual(a: any, b: any): boolean {
+  // Fast path for reference equality
+  if (a === b) {
+    return true
+  }
+
+  // Check for Uint8Array/Buffer comparison
+  const aIsUint8Array =
+    (typeof Buffer !== `undefined` && a instanceof Buffer) ||
+    a instanceof Uint8Array
+  const bIsUint8Array =
+    (typeof Buffer !== `undefined` && b instanceof Buffer) ||
+    b instanceof Uint8Array
+
+  // If both are Uint8Arrays, compare by content
+  if (aIsUint8Array && bIsUint8Array) {
+    return areUint8ArraysEqual(a, b)
+  }
+
+  // Different types or not Uint8Arrays
+  return false
+}
diff --git a/packages/db/src/utils/cursor.ts b/packages/db/src/utils/cursor.ts
new file mode 100644
index 000000000..322a37470
--- /dev/null
+++ b/packages/db/src/utils/cursor.ts
@@ -0,0 +1,78 @@
+import { and, eq, gt, lt, or } from '../query/builder/functions.js'
+import { Value } from '../query/ir.js'
+import type { BasicExpression, OrderBy } from '../query/ir.js'
+
+/**
+ * Builds a cursor expression for paginating through ordered results.
+ * For multi-column orderBy, creates a composite cursor that respects all columns.
+ *
+ * For [col1 ASC, col2 DESC] with values [v1, v2], produces:
+ *   or(
+ *     gt(col1, v1),                         // col1 > v1
+ *     and(eq(col1, v1), lt(col2, v2))       // col1 = v1 AND col2 < v2 (DESC)
+ *   )
+ *
+ * This creates a precise cursor that works with composite indexes on the backend.
+ *
+ * @param orderBy - The order-by clauses defining sort columns and directions
+ * @param values - The cursor values corresponding to each order-by column
+ * @returns A filter expression for rows after the cursor position, or undefined if empty
+ */
+export function buildCursor(
+  orderBy: OrderBy,
+  values: Array<unknown>,
+): BasicExpression<boolean> | undefined {
+  if (values.length === 0 || orderBy.length === 0) {
+    return undefined
+  }
+
+  // For single column, just use simple gt/lt
+  if (orderBy.length === 1) {
+    const { expression, compareOptions } = orderBy[0]!
+    const operator = compareOptions.direction === `asc` ? gt : lt
+    return operator(expression, new Value(values[0]))
+  }
+
+  // For multi-column, build the composite cursor:
+  // or(
+  //   gt(col1, v1),
+  //   and(eq(col1, v1), gt(col2, v2)),
+  //   and(eq(col1, v1), eq(col2, v2), gt(col3, v3)),
+  //   ...
+  // )
+  const clauses: Array<BasicExpression<boolean>> = []
+
+  for (let i = 0; i < orderBy.length && i < values.length; i++) {
+    const clause = orderBy[i]!
+    const value = values[i]
+
+    // Build equality conditions for all previous columns
+    const eqConditions: Array<BasicExpression<boolean>> = []
+    for (let j = 0; j < i; j++) {
+      const prevClause = orderBy[j]!
+      const prevValue = values[j]
+      eqConditions.push(eq(prevClause.expression, new Value(prevValue)))
+    }
+
+    // Add the comparison for the current column (respecting direction)
+    const operator = clause.compareOptions.direction === `asc` ? gt : lt
+    const comparison = operator(clause.expression, new Value(value))
+
+    if (eqConditions.length === 0) {
+      // First column: just the comparison
+      clauses.push(comparison)
+    } else {
+      // Subsequent columns: and(eq(prev...), comparison)
+      // We need to spread into and() which expects at least 2 args
+      const allConditions = [...eqConditions, comparison]
+      clauses.push(allConditions.reduce((acc, cond) => and(acc, cond)))
+    }
+  }
+
+  // Combine all clauses with OR
+  if (clauses.length === 1) {
+    return clauses[0]!
+  }
+  // Use reduce to combine with or() which expects exactly 2 args
+  return clauses.reduce((acc, clause) => or(acc, clause))
+}
diff --git a/packages/db/src/utils/index-optimization.ts b/packages/db/src/utils/index-optimization.ts
index 77c8861ed..f6c26ff91 100644
--- a/packages/db/src/utils/index-optimization.ts
+++ b/packages/db/src/utils/index-optimization.ts
@@ -15,15 +15,12 @@
  * - Optimizes IN array expressions
  */
 
-import { DEFAULT_COMPARE_OPTIONS } from "../utils.js"
-import { ReverseIndex } from "../indexes/reverse-index.js"
-import type { CompareOptions } from "../query/builder/types.js"
-import type {
-  BaseIndex,
-  IndexInterface,
-  IndexOperation,
-} from "../indexes/base-index.js"
-import type { BasicExpression } from "../query/ir.js"
+import { DEFAULT_COMPARE_OPTIONS } from '../utils.js'
+import { ReverseIndex } from '../indexes/reverse-index.js'
+import type { CompareOptions } from '../query/builder/types.js'
+import type { IndexInterface, IndexOperation } from '../indexes/base-index.js'
+import type { BasicExpression } from '../query/ir.js'
+import type { CollectionLike } from '../types.js'
 
 /**
  * Result of index-based query optimization
@@ -37,16 +34,21 @@ export interface OptimizationResult<TKey> {
  * Finds an index that matches a given field path
  */
 export function findIndexForField<TKey extends string | number>(
-  indexes: Map<number, IndexInterface<TKey>>,
+  collection: CollectionLike<any, TKey>,
   fieldPath: Array<string>,
-  compareOptions: CompareOptions = DEFAULT_COMPARE_OPTIONS
+  compareOptions?: CompareOptions,
 ): IndexInterface<TKey> | undefined {
-  for (const index of indexes.values()) {
+  const compareOpts = compareOptions ?? {
+    ...DEFAULT_COMPARE_OPTIONS,
+    ...collection.compareOptions,
+  }
+
+  for (const index of collection.indexes.values()) {
     if (
       index.matchesField(fieldPath) &&
-      index.matchesCompareOptions(compareOptions)
+      index.matchesCompareOptions(compareOpts)
     ) {
-      if (!index.matchesDirection(compareOptions.direction)) {
+      if (!index.matchesDirection(compareOpts.direction)) {
         return new ReverseIndex(index)
       }
       return index
@@ -91,19 +93,22 @@ export function unionSets<T>(sets: Array<Set<T>>): Set<T> {
 /**
  * Optimizes a query expression using available indexes to find matching keys
  */
-export function optimizeExpressionWithIndexes<TKey extends string | number>(
+export function optimizeExpressionWithIndexes<
+  T extends object,
+  TKey extends string | number,
+>(
   expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
+  collection: CollectionLike<T, TKey>,
 ): OptimizationResult<TKey> {
-  return optimizeQueryRecursive(expression, indexes)
+  return optimizeQueryRecursive(expression, collection)
 }
 
 /**
  * Recursively optimizes query expressions
  */
-function optimizeQueryRecursive<TKey extends string | number>(
+function optimizeQueryRecursive<T extends object, TKey extends string | number>(
   expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
+  collection: CollectionLike<T, TKey>,
 ): OptimizationResult<TKey> {
   if (expression.type === `func`) {
     switch (expression.name) {
@@ -112,16 +117,16 @@ function optimizeQueryRecursive<TKey extends string | number>(
       case `gte`:
       case `lt`:
       case `lte`:
-        return optimizeSimpleComparison(expression, indexes)
+        return optimizeSimpleComparison(expression, collection)
 
       case `and`:
-        return optimizeAndExpression(expression, indexes)
+        return optimizeAndExpression(expression, collection)
 
       case `or`:
-        return optimizeOrExpression(expression, indexes)
+        return optimizeOrExpression(expression, collection)
 
       case `in`:
-        return optimizeInArrayExpression(expression, indexes)
+        return optimizeInArrayExpression(expression, collection)
     }
   }
 
@@ -131,10 +136,10 @@ function optimizeQueryRecursive<TKey extends string | number>(
 /**
  * Checks if an expression can be optimized
  */
-export function canOptimizeExpression<TKey extends string | number>(
-  expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
-): boolean {
+export function canOptimizeExpression<
+  T extends object,
+  TKey extends string | number,
+>(expression: BasicExpression, collection: CollectionLike<T, TKey>): boolean {
   if (expression.type === `func`) {
     switch (expression.name) {
       case `eq`:
@@ -142,16 +147,16 @@ export function canOptimizeExpression<TKey extends string | number>(
       case `gte`:
       case `lt`:
       case `lte`:
-        return canOptimizeSimpleComparison(expression, indexes)
+        return canOptimizeSimpleComparison(expression, collection)
 
       case `and`:
-        return canOptimizeAndExpression(expression, indexes)
+        return canOptimizeAndExpression(expression, collection)
 
       case `or`:
-        return canOptimizeOrExpression(expression, indexes)
+        return canOptimizeOrExpression(expression, collection)
 
       case `in`:
-        return canOptimizeInArrayExpression(expression, indexes)
+        return canOptimizeInArrayExpression(expression, collection)
     }
   }
 
@@ -162,9 +167,12 @@ export function canOptimizeExpression<TKey extends string | number>(
  * Optimizes compound range queries on the same field
  * Example: WHERE age > 5 AND age < 10
  */
-function optimizeCompoundRangeQuery<TKey extends string | number>(
+function optimizeCompoundRangeQuery<
+  T extends object,
+  TKey extends string | number,
+>(
   expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
+  collection: CollectionLike<T, TKey>,
 ): OptimizationResult<TKey> {
   if (expression.type !== `func` || expression.args.length < 2) {
     return { canOptimize: false, matchingKeys: new Set() }
@@ -236,7 +244,7 @@ function optimizeCompoundRangeQuery<TKey extends string | number>(
   for (const [fieldKey, operations] of fieldOperations) {
     if (operations.length >= 2) {
       const fieldPath = fieldKey.split(`.`)
-      const index = findIndexForField(indexes, fieldPath)
+      const index = findIndexForField(collection, fieldPath)
 
       if (index && index.supports(`gt`) && index.supports(`lt`)) {
         // Build range query options
@@ -292,9 +300,12 @@ function optimizeCompoundRangeQuery<TKey extends string | number>(
 /**
  * Optimizes simple comparison expressions (eq, gt, gte, lt, lte)
  */
-function optimizeSimpleComparison<TKey extends string | number>(
+function optimizeSimpleComparison<
+  T extends object,
+  TKey extends string | number,
+>(
   expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
+  collection: CollectionLike<T, TKey>,
 ): OptimizationResult<TKey> {
   if (expression.type !== `func` || expression.args.length !== 2) {
     return { canOptimize: false, matchingKeys: new Set() }
@@ -337,7 +348,7 @@ function optimizeSimpleComparison<TKey extends string | number>(
 
   if (fieldArg && valueArg) {
     const fieldPath = (fieldArg as any).path
-    const index = findIndexForField(indexes, fieldPath)
+    const index = findIndexForField(collection, fieldPath)
 
     if (index) {
       const queryValue = (valueArg as any).value
@@ -361,10 +372,10 @@ function optimizeSimpleComparison<TKey extends string | number>(
 /**
  * Checks if a simple comparison can be optimized
  */
-function canOptimizeSimpleComparison<TKey extends string | number>(
-  expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
-): boolean {
+function canOptimizeSimpleComparison<
+  T extends object,
+  TKey extends string | number,
+>(expression: BasicExpression, collection: CollectionLike<T, TKey>): boolean {
   if (expression.type !== `func` || expression.args.length !== 2) {
     return false
   }
@@ -382,7 +393,7 @@ function canOptimizeSimpleComparison<TKey extends string | number>(
   }
 
   if (fieldPath) {
-    const index = findIndexForField(indexes, fieldPath)
+    const index = findIndexForField(collection, fieldPath)
     return index !== undefined
   }
 
@@ -392,16 +403,16 @@ function canOptimizeSimpleComparison<TKey extends string | number>(
 /**
  * Optimizes AND expressions
  */
-function optimizeAndExpression<TKey extends string | number>(
+function optimizeAndExpression<T extends object, TKey extends string | number>(
   expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
+  collection: CollectionLike<T, TKey>,
 ): OptimizationResult<TKey> {
   if (expression.type !== `func` || expression.args.length < 2) {
     return { canOptimize: false, matchingKeys: new Set() }
   }
 
   // First, try to optimize compound range queries on the same field
-  const compoundRangeResult = optimizeCompoundRangeQuery(expression, indexes)
+  const compoundRangeResult = optimizeCompoundRangeQuery(expression, collection)
   if (compoundRangeResult.canOptimize) {
     return compoundRangeResult
   }
@@ -410,7 +421,7 @@ function optimizeAndExpression<TKey extends string | number>(
 
   // Try to optimize each part, keep the optimizable ones
   for (const arg of expression.args) {
-    const result = optimizeQueryRecursive(arg, indexes)
+    const result = optimizeQueryRecursive(arg, collection)
     if (result.canOptimize) {
       results.push(result)
     }
@@ -429,24 +440,24 @@ function optimizeAndExpression<TKey extends string | number>(
 /**
  * Checks if an AND expression can be optimized
  */
-function canOptimizeAndExpression<TKey extends string | number>(
-  expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
-): boolean {
+function canOptimizeAndExpression<
+  T extends object,
+  TKey extends string | number,
+>(expression: BasicExpression, collection: CollectionLike<T, TKey>): boolean {
   if (expression.type !== `func` || expression.args.length < 2) {
     return false
   }
 
   // If any argument can be optimized, we can gain some speedup
-  return expression.args.some((arg) => canOptimizeExpression(arg, indexes))
+  return expression.args.some((arg) => canOptimizeExpression(arg, collection))
 }
 
 /**
  * Optimizes OR expressions
  */
-function optimizeOrExpression<TKey extends string | number>(
+function optimizeOrExpression<T extends object, TKey extends string | number>(
   expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
+  collection: CollectionLike<T, TKey>,
 ): OptimizationResult<TKey> {
   if (expression.type !== `func` || expression.args.length < 2) {
     return { canOptimize: false, matchingKeys: new Set() }
@@ -456,7 +467,7 @@ function optimizeOrExpression<TKey extends string | number>(
 
   // Try to optimize each part, keep the optimizable ones
   for (const arg of expression.args) {
-    const result = optimizeQueryRecursive(arg, indexes)
+    const result = optimizeQueryRecursive(arg, collection)
     if (result.canOptimize) {
       results.push(result)
     }
@@ -475,24 +486,27 @@ function optimizeOrExpression<TKey extends string | number>(
 /**
  * Checks if an OR expression can be optimized
  */
-function canOptimizeOrExpression<TKey extends string | number>(
-  expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
-): boolean {
+function canOptimizeOrExpression<
+  T extends object,
+  TKey extends string | number,
+>(expression: BasicExpression, collection: CollectionLike<T, TKey>): boolean {
   if (expression.type !== `func` || expression.args.length < 2) {
     return false
   }
 
   // If any argument can be optimized, we can gain some speedup
-  return expression.args.some((arg) => canOptimizeExpression(arg, indexes))
+  return expression.args.some((arg) => canOptimizeExpression(arg, collection))
 }
 
 /**
  * Optimizes IN array expressions
  */
-function optimizeInArrayExpression<TKey extends string | number>(
+function optimizeInArrayExpression<
+  T extends object,
+  TKey extends string | number,
+>(
   expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
+  collection: CollectionLike<T, TKey>,
 ): OptimizationResult<TKey> {
   if (expression.type !== `func` || expression.args.length !== 2) {
     return { canOptimize: false, matchingKeys: new Set() }
@@ -508,7 +522,7 @@ function optimizeInArrayExpression<TKey extends string | number>(
   ) {
     const fieldPath = (fieldArg as any).path
     const values = (arrayArg as any).value
-    const index = findIndexForField(indexes, fieldPath)
+    const index = findIndexForField(collection, fieldPath)
 
     if (index) {
       // Check if the index supports IN operation
@@ -535,10 +549,10 @@ function optimizeInArrayExpression<TKey extends string | number>(
 /**
  * Checks if an IN array expression can be optimized
  */
-function canOptimizeInArrayExpression<TKey extends string | number>(
-  expression: BasicExpression,
-  indexes: Map<number, BaseIndex<TKey>>
-): boolean {
+function canOptimizeInArrayExpression<
+  T extends object,
+  TKey extends string | number,
+>(expression: BasicExpression, collection: CollectionLike<T, TKey>): boolean {
   if (expression.type !== `func` || expression.args.length !== 2) {
     return false
   }
@@ -552,7 +566,7 @@ function canOptimizeInArrayExpression<TKey extends string | number>(
     Array.isArray((arrayArg as any).value)
   ) {
     const fieldPath = (fieldArg as any).path
-    const index = findIndexForField(indexes, fieldPath)
+    const index = findIndexForField(collection, fieldPath)
     return index !== undefined
   }
 
diff --git a/packages/db/src/utils/type-guards.ts b/packages/db/src/utils/type-guards.ts
new file mode 100644
index 000000000..4c54d8077
--- /dev/null
+++ b/packages/db/src/utils/type-guards.ts
@@ -0,0 +1,12 @@
+/**
+ * Type guard to check if a value is promise-like (has a `.then` method)
+ * @param value - The value to check
+ * @returns True if the value is promise-like, false otherwise
+ */
+export function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+  return (
+    !!value &&
+    (typeof value === `object` || typeof value === `function`) &&
+    typeof (value as { then?: unknown }).then === `function`
+  )
+}
diff --git a/packages/db/tests/SortedMap.test.ts b/packages/db/tests/SortedMap.test.ts
index 27ce7be13..e2a46da61 100644
--- a/packages/db/tests/SortedMap.test.ts
+++ b/packages/db/tests/SortedMap.test.ts
@@ -1,5 +1,5 @@
-import { describe, expect, it } from "vitest"
-import { SortedMap } from "../src/SortedMap"
+import { describe, expect, it } from 'vitest'
+import { SortedMap } from '../src/SortedMap'
 
 describe(`SortedMap`, () => {
   it(`maintains sorted order by values`, () => {
diff --git a/packages/db/tests/apply-mutations.test.ts b/packages/db/tests/apply-mutations.test.ts
index 325abfbf8..3e4931d5f 100644
--- a/packages/db/tests/apply-mutations.test.ts
+++ b/packages/db/tests/apply-mutations.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest"
-import { createTransaction } from "../src/transactions"
-import { createCollection } from "../src/collection"
+import { describe, expect, it } from 'vitest'
+import { createTransaction } from '../src/transactions'
+import { createCollection } from '../src/collection'
 
 describe(`applyMutations merge logic`, () => {
   // Create a shared collection for all tests
diff --git a/packages/db/tests/collection-auto-index.test.ts b/packages/db/tests/collection-auto-index.test.ts
index f3821f7cb..f40db1e61 100644
--- a/packages/db/tests/collection-auto-index.test.ts
+++ b/packages/db/tests/collection-auto-index.test.ts
@@ -1,5 +1,5 @@
-import { describe, expect, it } from "vitest"
-import { createCollection } from "../src/collection/index.js"
+import { describe, expect, it } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
 import {
   and,
   eq,
@@ -8,15 +8,15 @@ import {
   lte,
   not,
   or,
-} from "../src/query/builder/functions"
-import { createSingleRowRefProxy } from "../src/query/builder/ref-proxy"
-import { createLiveQueryCollection } from "../src"
-import { PropRef } from "../src/query/ir"
+} from '../src/query/builder/functions'
+import { createSingleRowRefProxy } from '../src/query/builder/ref-proxy'
+import { createLiveQueryCollection } from '../src'
+import { PropRef } from '../src/query/ir'
 import {
   createIndexUsageTracker,
   expectIndexUsage,
   withIndexTracking,
-} from "./utils"
+} from './utils'
 
 // Global row proxy for expressions
 const row = createSingleRowRefProxy<TestItem>()
@@ -112,7 +112,7 @@ describe(`Collection Auto-Indexing`, () => {
       {
         includeInitialState: true,
         whereExpression: eq(row.status, `active`),
-      }
+      },
     )
 
     // Should still have no indexes after subscription
@@ -154,7 +154,7 @@ describe(`Collection Auto-Indexing`, () => {
       {
         includeInitialState: true,
         whereExpression: eq(row.status, `active`),
-      }
+      },
     )
 
     // Should have created an auto-index for the status field (default is eager)
@@ -201,7 +201,7 @@ describe(`Collection Auto-Indexing`, () => {
       {
         includeInitialState: true,
         whereExpression: eq(row.status, `active`),
-      }
+      },
     )
 
     // Should have created an auto-index for the status field
@@ -302,7 +302,7 @@ describe(`Collection Auto-Indexing`, () => {
     expect(autoIndexCollection.indexes.size).toBe(3)
 
     const indexPaths = Array.from(autoIndexCollection.indexes.values()).map(
-      (index) => (index.expression as any).path
+      (index) => (index.expression as any).path,
     )
 
     expect(indexPaths).toContainEqual([`status`])
@@ -345,7 +345,7 @@ describe(`Collection Auto-Indexing`, () => {
     expect(autoIndexCollection.indexes.size).toBe(2)
 
     const indexPaths = Array.from(autoIndexCollection.indexes.values()).map(
-      (index) => (index.expression as any).path
+      (index) => (index.expression as any).path,
     )
 
     expect(indexPaths).toContainEqual([`status`])
@@ -414,7 +414,7 @@ describe(`Collection Auto-Indexing`, () => {
       whereExpression: and(
         eq(row.status, `active`),
         gt(row.age, 25),
-        lte(row.score, 90)
+        lte(row.score, 90),
       ),
     })
 
@@ -422,7 +422,7 @@ describe(`Collection Auto-Indexing`, () => {
     expect(autoIndexCollection.indexes.size).toBe(3)
 
     const indexPaths = Array.from(autoIndexCollection.indexes.values()).map(
-      (index) => (index.expression as any).path
+      (index) => (index.expression as any).path,
     )
 
     expect(indexPaths).toContainEqual([`status`])
@@ -495,7 +495,7 @@ describe(`Collection Auto-Indexing`, () => {
           .join(
             { other: rightCollection },
             ({ item, other }: any) => eq(item.id, other.id2),
-            `left`
+            `left`,
           )
           .select(({ item, other }: any) => ({
             id: item.id,
@@ -614,7 +614,7 @@ describe(`Collection Auto-Indexing`, () => {
                 })),
             },
             ({ item, other }: any) => eq(item.id, other.id2),
-            `left`
+            `left`,
           )
           .select(({ item, other }: any) => ({
             id: item.id,
@@ -750,4 +750,148 @@ describe(`Collection Auto-Indexing`, () => {
 
     subscription.unsubscribe()
   })
+
+  it(`should create auto-indexes for nested field paths`, async () => {
+    interface NestedTestItem {
+      id: string
+      name: string
+      profile?: {
+        score: number
+        bio: string
+      }
+      metadata?: {
+        tags: Array<string>
+        stats: {
+          views: number
+          likes: number
+        }
+      }
+    }
+
+    const nestedTestData: Array<NestedTestItem> = [
+      {
+        id: `1`,
+        name: `Alice`,
+        profile: { score: 85, bio: `Developer` },
+        metadata: {
+          tags: [`tech`, `coding`],
+          stats: { views: 100, likes: 50 },
+        },
+      },
+      {
+        id: `2`,
+        name: `Bob`,
+        profile: { score: 92, bio: `Designer` },
+        metadata: {
+          tags: [`design`, `ui`],
+          stats: { views: 200, likes: 75 },
+        },
+      },
+      {
+        id: `3`,
+        name: `Charlie`,
+        profile: { score: 78, bio: `Manager` },
+        metadata: {
+          tags: [`management`, `leadership`],
+          stats: { views: 150, likes: 60 },
+        },
+      },
+    ]
+
+    const collection = createCollection<NestedTestItem, string>({
+      getKey: (item) => item.id,
+      autoIndex: `eager`,
+      startSync: true,
+      sync: {
+        sync: ({ begin, write, commit, markReady }) => {
+          begin()
+          for (const item of nestedTestData) {
+            write({
+              type: `insert`,
+              value: item,
+            })
+          }
+          commit()
+          markReady()
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    // Should have no indexes initially
+    expect(collection.indexes.size).toBe(0)
+
+    // Test 1: Nested field one level deep (profile.score)
+    const changes1: Array<any> = []
+    const subscription1 = collection.subscribeChanges(
+      (items) => {
+        changes1.push(...items)
+      },
+      {
+        includeInitialState: true,
+        whereExpression: gt(new PropRef([`profile`, `score`]), 80),
+      },
+    )
+
+    // Should have created an auto-index for profile.score
+    const profileScoreIndex = Array.from(collection.indexes.values()).find(
+      (index) =>
+        index.expression.type === `ref` &&
+        (index.expression as any).path.length === 2 &&
+        (index.expression as any).path[0] === `profile` &&
+        (index.expression as any).path[1] === `score`,
+    )
+    expect(profileScoreIndex).toBeDefined()
+
+    // Verify the filtered results are correct
+    expect(changes1.filter((c) => c.type === `insert`).length).toBe(2) // Alice (85) and Bob (92)
+
+    subscription1.unsubscribe()
+
+    // Test 2: Deeply nested field (metadata.stats.views)
+    const changes2: Array<any> = []
+    const subscription2 = collection.subscribeChanges(
+      (items) => {
+        changes2.push(...items)
+      },
+      {
+        includeInitialState: true,
+        whereExpression: eq(new PropRef([`metadata`, `stats`, `views`]), 200),
+      },
+    )
+
+    // Should have created an auto-index for metadata.stats.views
+    const viewsIndex = Array.from(collection.indexes.values()).find(
+      (index) =>
+        index.expression.type === `ref` &&
+        (index.expression as any).path.length === 3 &&
+        (index.expression as any).path[0] === `metadata` &&
+        (index.expression as any).path[1] === `stats` &&
+        (index.expression as any).path[2] === `views`,
+    )
+    expect(viewsIndex).toBeDefined()
+
+    // Verify the filtered results are correct
+    expect(changes2.filter((c) => c.type === `insert`).length).toBe(1) // Only Bob has 200 views
+
+    subscription2.unsubscribe()
+
+    // Test 3: Index usage verification with tracker
+    withIndexTracking(collection, (tracker) => {
+      const result = collection.currentStateAsChanges({
+        where: gt(new PropRef([`profile`, `score`]), 80),
+      })!
+
+      expect(result.length).toBe(2) // Alice and Bob
+
+      // Verify it used the auto-created index
+      expectIndexUsage(tracker.stats, {
+        shouldUseIndex: true,
+        shouldUseFullScan: false,
+        indexCallCount: 1,
+        fullScanCallCount: 0,
+      })
+    })
+  })
 })
diff --git a/packages/db/tests/collection-change-events.test.ts b/packages/db/tests/collection-change-events.test.ts
new file mode 100644
index 000000000..be59dde14
--- /dev/null
+++ b/packages/db/tests/collection-change-events.test.ts
@@ -0,0 +1,439 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
+import { currentStateAsChanges } from '../src/collection/change-events.js'
+import { Func, PropRef, Value } from '../src/query/ir.js'
+import { DEFAULT_COMPARE_OPTIONS } from '../src/utils.js'
+
+interface TestUser {
+  id: string
+  name: string
+  age: number
+  score: number
+  status: `active` | `inactive`
+}
+
+describe(`currentStateAsChanges`, () => {
+  let mockSync: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    mockSync = vi.fn()
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  const users: Array<TestUser> = [
+    { id: `1`, name: `Alice`, age: 25, score: 100, status: `active` },
+    { id: `2`, name: `Bob`, age: 30, score: 80, status: `inactive` },
+    { id: `3`, name: `Charlie`, age: 35, score: 90, status: `active` },
+    { id: `4`, name: `David`, age: 20, score: 70, status: `active` },
+    { id: `5`, name: `Eve`, age: 28, score: 95, status: `inactive` },
+  ]
+
+  // Helper function to create and populate collection with test data
+  async function createAndPopulateCollection(
+    autoIndex: `eager` | `off` = `eager`,
+  ) {
+    const collection = createCollection<TestUser>({
+      id: `test-collection-${autoIndex}`,
+      getKey: (user) => user.id,
+      autoIndex,
+      sync: {
+        sync: mockSync,
+      },
+    })
+
+    // Insert users via sync
+    mockSync.mockImplementation(({ begin, write, commit }) => {
+      begin()
+      users.forEach((user) => {
+        write({
+          type: `insert`,
+          value: user,
+        })
+      })
+      commit()
+    })
+
+    collection.startSyncImmediate()
+    await collection.stateWhenReady()
+
+    return collection
+  }
+
+  describe.each([
+    [`with auto-indexing`, `eager`],
+    [`without auto-indexing`, `off`],
+  ])(`%s`, (testName, autoIndex) => {
+    describe(`where clause without orderBy or limit`, () => {
+      it(`should return all items when no where clause is provided`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection)
+
+        expect(result).toHaveLength(5)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Alice`,
+          `Bob`,
+          `Charlie`,
+          `David`,
+          `Eve`,
+        ])
+      })
+
+      it(`should filter items based on where clause`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          where: new Func(`eq`, [new PropRef([`status`]), new Value(`active`)]),
+        })
+
+        expect(result).toHaveLength(3)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Alice`,
+          `Charlie`,
+          `David`,
+        ])
+      })
+
+      it(`should filter items based on numeric where clause`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          where: new Func(`gt`, [new PropRef([`age`]), new Value(25)]),
+        })
+
+        expect(result).toHaveLength(3)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Bob`,
+          `Charlie`,
+          `Eve`,
+        ])
+      })
+    })
+
+    describe(`orderBy without limit and no where clause`, () => {
+      it(`should return all items ordered by name ascending`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          orderBy: [
+            {
+              expression: new PropRef([`name`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `asc` },
+            },
+          ],
+        })
+
+        expect(result).toHaveLength(5)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Alice`,
+          `Bob`,
+          `Charlie`,
+          `David`,
+          `Eve`,
+        ])
+      })
+
+      it(`should return all items ordered by score descending`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          orderBy: [
+            {
+              expression: new PropRef([`score`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `desc` },
+            },
+          ],
+        })
+
+        expect(result).toHaveLength(5)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Alice`, // score: 100
+          `Eve`, // score: 95
+          `Charlie`, // score: 90
+          `Bob`, // score: 80
+          `David`, // score: 70
+        ])
+      })
+
+      it(`should return all items ordered by age ascending`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          orderBy: [
+            {
+              expression: new PropRef([`age`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `asc` },
+            },
+          ],
+        })
+
+        expect(result).toHaveLength(5)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `David`, // age: 20
+          `Alice`, // age: 25
+          `Eve`, // age: 28
+          `Bob`, // age: 30
+          `Charlie`, // age: 35
+        ])
+      })
+    })
+
+    describe(`orderBy with limit and no where clause`, () => {
+      it(`should return top 3 items ordered by score descending`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          orderBy: [
+            {
+              expression: new PropRef([`score`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `desc` },
+            },
+          ],
+          limit: 3,
+        })
+
+        expect(result).toHaveLength(3)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Alice`, // score: 100
+          `Eve`, // score: 95
+          `Charlie`, // score: 90
+        ])
+      })
+    })
+
+    describe(`orderBy with limit and where clause`, () => {
+      it(`should return top active users ordered by score descending`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          where: new Func(`eq`, [new PropRef([`status`]), new Value(`active`)]),
+          orderBy: [
+            {
+              expression: new PropRef([`score`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `desc` },
+            },
+          ],
+          limit: 2,
+        })
+
+        expect(result).toHaveLength(2)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Alice`, // score: 100, status: active
+          `Charlie`, // score: 90, status: active
+        ])
+      })
+
+      it(`should return top users over 25 ordered by age ascending`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          where: new Func(`gt`, [new PropRef([`age`]), new Value(25)]),
+          orderBy: [
+            {
+              expression: new PropRef([`age`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `asc` },
+            },
+          ],
+          limit: 2,
+        })
+
+        expect(result).toHaveLength(2)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Eve`, // age: 28
+          `Bob`, // age: 30
+        ])
+      })
+
+      it(`should handle multi-column orderBy with where clause`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          where: new Func(`eq`, [new PropRef([`status`]), new Value(`active`)]),
+          orderBy: [
+            {
+              expression: new PropRef([`score`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `desc` },
+            },
+            {
+              expression: new PropRef([`age`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `asc` },
+            },
+          ],
+          limit: 2,
+        })
+
+        expect(result).toHaveLength(2)
+        // Should be ordered by score desc, then age asc for ties
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Alice`, // score: 100, age: 25
+          `Charlie`, // score: 90, age: 35
+        ])
+      })
+    })
+
+    describe(`error cases`, () => {
+      it(`should throw error when limit is provided without orderBy`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        expect(() => {
+          currentStateAsChanges(collection, {
+            limit: 5,
+          })
+        }).toThrow(`limit cannot be used without orderBy`)
+      })
+
+      it(`should throw error when limit is provided without orderBy even with where clause`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        expect(() => {
+          currentStateAsChanges(collection, {
+            where: new Func(`eq`, [
+              new PropRef([`status`]),
+              new Value(`active`),
+            ]),
+            limit: 3,
+          })
+        }).toThrow(`limit cannot be used without orderBy`)
+      })
+    })
+
+    describe(`optimizedOnly option`, () => {
+      it(`should return undefined when optimizedOnly is true and no index is available`, async () => {
+        // Only test this with auto-indexing disabled
+        if (autoIndex === `off`) {
+          const collection = await createAndPopulateCollection(`off`)
+
+          const result = currentStateAsChanges(collection, {
+            orderBy: [
+              {
+                expression: new PropRef([`score`]),
+                compareOptions: {
+                  ...DEFAULT_COMPARE_OPTIONS,
+                  direction: `desc`,
+                },
+              },
+            ],
+            limit: 1,
+            optimizedOnly: true,
+          })
+
+          expect(result).toBeUndefined()
+        }
+      })
+
+      it(`should return results when optimizedOnly is true and index is available`, async () => {
+        // Only test this with auto-indexing enabled
+        if (autoIndex === `eager`) {
+          const collection = await createAndPopulateCollection(`eager`)
+
+          const result = currentStateAsChanges(collection, {
+            orderBy: [
+              {
+                expression: new PropRef([`score`]),
+                compareOptions: {
+                  ...DEFAULT_COMPARE_OPTIONS,
+                  direction: `desc`,
+                },
+              },
+            ],
+            limit: 1,
+            optimizedOnly: true,
+          })
+
+          expect(result).toHaveLength(1)
+          expect(result?.[0]?.value.name).toBe(`Alice`)
+        }
+      })
+    })
+
+    describe(`edge cases`, () => {
+      it(`should handle empty collection`, () => {
+        const collection = createCollection<TestUser>({
+          id: `test-collection-empty-${autoIndex}`,
+          getKey: (user) => user.id,
+          autoIndex: autoIndex as `eager` | `off`,
+          sync: {
+            sync: mockSync,
+          },
+        })
+
+        // Don't populate the collection
+        collection.startSyncImmediate()
+
+        const result = currentStateAsChanges(collection)
+
+        expect(result).toHaveLength(0)
+      })
+
+      it(`should handle limit larger than collection size`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          orderBy: [
+            {
+              expression: new PropRef([`name`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `asc` },
+            },
+          ],
+          limit: 10, // More than the 5 items in collection
+        })
+
+        expect(result).toHaveLength(5)
+        expect(result?.map((change) => change.value.name)).toEqual([
+          `Alice`,
+          `Bob`,
+          `Charlie`,
+          `David`,
+          `Eve`,
+        ])
+      })
+
+      it(`should handle limit of 0`, async () => {
+        const collection = await createAndPopulateCollection(
+          autoIndex as `eager` | `off`,
+        )
+
+        const result = currentStateAsChanges(collection, {
+          orderBy: [
+            {
+              expression: new PropRef([`name`]),
+              compareOptions: { ...DEFAULT_COMPARE_OPTIONS, direction: `asc` },
+            },
+          ],
+          limit: 0,
+        })
+
+        expect(result).toHaveLength(0)
+      })
+    })
+  })
+})
diff --git a/packages/db/tests/collection-errors.test.ts b/packages/db/tests/collection-errors.test.ts
index 53ede7f0d..f4bdae52d 100644
--- a/packages/db/tests/collection-errors.test.ts
+++ b/packages/db/tests/collection-errors.test.ts
@@ -1,10 +1,10 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { createCollection } from "../src/collection/index.js"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
 import {
   CollectionInErrorStateError,
   InvalidCollectionStatusTransitionError,
   SyncCleanupError,
-} from "../src/errors"
+} from '../src/errors'
 
 describe(`Collection Error Handling`, () => {
   let originalQueueMicrotask: typeof queueMicrotask
@@ -69,7 +69,7 @@ describe(`Collection Error Handling`, () => {
 
       expect(caughtError).toBeInstanceOf(SyncCleanupError)
       expect(caughtError?.message).toBe(
-        `Collection "error-test-collection" sync cleanup function threw an error: Sync cleanup failed`
+        `Collection "error-test-collection" sync cleanup function threw an error: Sync cleanup failed`,
       )
     })
 
@@ -114,7 +114,7 @@ describe(`Collection Error Handling`, () => {
       // Verify the re-thrown error has proper context and preserved stack
       expect(caughtError).toBeDefined()
       expect(caughtError!.message).toBe(
-        `Collection "stack-trace-test" sync cleanup function threw an error: Original sync error`
+        `Collection "stack-trace-test" sync cleanup function threw an error: Original sync error`,
       )
       expect(caughtError!.stack).toBe(originalStack) // Original stack preserved
       expect(caughtError!.cause).toBe(originalError) // Original error chained
@@ -159,7 +159,7 @@ describe(`Collection Error Handling`, () => {
       // Verify non-Error values are handled properly
       expect(caughtError).toBeDefined()
       expect(caughtError!.message).toBe(
-        `Collection "non-error-test" sync cleanup function threw an error: String error message`
+        `Collection "non-error-test" sync cleanup function threw an error: String error message`,
       )
 
       // No cause or stack preservation for non-Error values
@@ -240,7 +240,7 @@ describe(`Collection Error Handling`, () => {
 
         expect(caughtError).toBeInstanceOf(SyncCleanupError)
         expect(caughtError?.message).toBe(
-          `Collection "multiple-cleanup-test" sync cleanup function threw an error: Cleanup error`
+          `Collection "multiple-cleanup-test" sync cleanup function threw an error: Cleanup error`,
         )
       }
     })
@@ -325,7 +325,7 @@ describe(`Collection Error Handling`, () => {
               markReady()
             },
           },
-        }
+        },
       )
 
       // Wait for initial sync and then cleanup
@@ -399,77 +399,80 @@ describe(`Collection Error Handling`, () => {
 
       // Valid transitions from idle
       expect(() =>
-        collectionImpl._lifecycle.validateStatusTransition(`idle`, `loading`)
+        collectionImpl._lifecycle.validateStatusTransition(`idle`, `loading`),
       ).not.toThrow()
       expect(() =>
-        collectionImpl._lifecycle.validateStatusTransition(`idle`, `error`)
+        collectionImpl._lifecycle.validateStatusTransition(`idle`, `error`),
       ).not.toThrow()
       expect(() =>
-        collectionImpl._lifecycle.validateStatusTransition(`idle`, `cleaned-up`)
+        collectionImpl._lifecycle.validateStatusTransition(
+          `idle`,
+          `cleaned-up`,
+        ),
       ).not.toThrow()
 
       // Valid transitions from loading
       expect(() =>
-        collectionImpl._lifecycle.validateStatusTransition(`loading`, `ready`)
+        collectionImpl._lifecycle.validateStatusTransition(`loading`, `ready`),
       ).not.toThrow()
       expect(() =>
-        collectionImpl._lifecycle.validateStatusTransition(`loading`, `error`)
+        collectionImpl._lifecycle.validateStatusTransition(`loading`, `error`),
       ).not.toThrow()
       expect(() =>
         collectionImpl._lifecycle.validateStatusTransition(
           `loading`,
-          `cleaned-up`
-        )
+          `cleaned-up`,
+        ),
       ).not.toThrow()
 
       // Valid transitions from ready
       expect(() =>
         collectionImpl._lifecycle.validateStatusTransition(
           `ready`,
-          `cleaned-up`
-        )
+          `cleaned-up`,
+        ),
       ).not.toThrow()
       expect(() =>
-        collectionImpl._lifecycle.validateStatusTransition(`ready`, `error`)
+        collectionImpl._lifecycle.validateStatusTransition(`ready`, `error`),
       ).not.toThrow()
 
       // Valid transitions from error (allow recovery)
       expect(() =>
         collectionImpl._lifecycle.validateStatusTransition(
           `error`,
-          `cleaned-up`
-        )
+          `cleaned-up`,
+        ),
       ).not.toThrow()
       expect(() =>
-        collectionImpl._lifecycle.validateStatusTransition(`error`, `idle`)
+        collectionImpl._lifecycle.validateStatusTransition(`error`, `idle`),
       ).not.toThrow()
 
       // Valid transitions from cleaned-up (allow restart)
       expect(() =>
         collectionImpl._lifecycle.validateStatusTransition(
           `cleaned-up`,
-          `loading`
-        )
+          `loading`,
+        ),
       ).not.toThrow()
       expect(() =>
         collectionImpl._lifecycle.validateStatusTransition(
           `cleaned-up`,
-          `error`
-        )
+          `error`,
+        ),
       ).not.toThrow()
 
       // Allow same-state transitions (idempotent operations)
       expect(() =>
-        collectionImpl._lifecycle.validateStatusTransition(`idle`, `idle`)
+        collectionImpl._lifecycle.validateStatusTransition(`idle`, `idle`),
       ).not.toThrow()
       expect(() =>
-        collectionImpl._lifecycle.validateStatusTransition(`ready`, `ready`)
+        collectionImpl._lifecycle.validateStatusTransition(`ready`, `ready`),
       ).not.toThrow()
       expect(() =>
         collectionImpl._lifecycle.validateStatusTransition(
           `cleaned-up`,
-          `cleaned-up`
-        )
+          `cleaned-up`,
+        ),
       ).not.toThrow()
     })
   })
diff --git a/packages/db/tests/collection-events.test.ts b/packages/db/tests/collection-events.test.ts
index 494d5a3e8..e9f988548 100644
--- a/packages/db/tests/collection-events.test.ts
+++ b/packages/db/tests/collection-events.test.ts
@@ -1,6 +1,6 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { createCollection } from "../src/collection/index.js"
-import type { Collection } from "../src/collection/index.js"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
+import type { Collection } from '../src/collection/index.js'
 
 describe(`Collection Events System`, () => {
   let collection: Collection
@@ -149,7 +149,7 @@ describe(`Collection Events System`, () => {
       vi.advanceTimersByTime(1001)
 
       await expect(waitPromise).rejects.toThrow(
-        `Timeout waiting for event status:change`
+        `Timeout waiting for event status:change`,
       )
 
       vi.useRealTimers()
diff --git a/packages/db/tests/collection-getters.test.ts b/packages/db/tests/collection-getters.test.ts
index da9f73004..f5f8dda41 100644
--- a/packages/db/tests/collection-getters.test.ts
+++ b/packages/db/tests/collection-getters.test.ts
@@ -1,8 +1,8 @@
-import { beforeEach, describe, expect, it, vi } from "vitest"
-import { createTransaction } from "../src/transactions"
-import { createCollection } from "../src/collection/index.js"
-import type { CollectionImpl } from "../src/collection/index.js"
-import type { SyncConfig } from "../src/types"
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createTransaction } from '../src/transactions'
+import { createCollection } from '../src/collection/index.js'
+import type { CollectionImpl } from '../src/collection/index.js'
+import type { SyncConfig } from '../src/types'
 
 type Item = { id: string; name: string }
 
@@ -141,7 +141,7 @@ describe(`Collection getters`, () => {
       tx.mutate(() =>
         collection.update(`item1`, (draft) => {
           draft.name = `Updated Item 1`
-        })
+        }),
       )
 
       expect(collection.size).toBe(2) // Size should remain the same for updates
@@ -212,7 +212,7 @@ describe(`Collection getters`, () => {
       tx.mutate(() =>
         collection.update(`item1`, (draft) => {
           draft.name = `Updated Item 1`
-        })
+        }),
       )
 
       const key = `item1`
@@ -294,7 +294,7 @@ describe(`Collection getters`, () => {
       tx.mutate(() =>
         collection.update(`item1`, (draft) => {
           draft.name = `Updated Item 1`
-        })
+        }),
       )
 
       const values = Array.from(collection.values())
@@ -343,7 +343,7 @@ describe(`Collection getters`, () => {
       tx.mutate(() =>
         collection.update(`item1`, (draft) => {
           draft.name = `Updated Item 1`
-        })
+        }),
       )
 
       const entries = Array.from(collection.entries())
@@ -398,7 +398,7 @@ describe(`Collection getters`, () => {
       tx.mutate(() =>
         collection.update(`item1`, (draft) => {
           draft.name = `Updated Item 1`
-        })
+        }),
       )
 
       const key = `item1`
diff --git a/packages/db/tests/collection-indexes.test.ts b/packages/db/tests/collection-indexes.test.ts
index 533ecfce5..a8e3896fd 100644
--- a/packages/db/tests/collection-indexes.test.ts
+++ b/packages/db/tests/collection-indexes.test.ts
@@ -1,7 +1,7 @@
-import { beforeEach, describe, expect, it } from "vitest"
-import mitt from "mitt"
-import { createCollection } from "../src/collection/index.js"
-import { createTransaction } from "../src/transactions"
+import { beforeEach, describe, expect, it } from 'vitest'
+import mitt from 'mitt'
+import { createCollection } from '../src/collection/index.js'
+import { createTransaction } from '../src/transactions'
 import {
   and,
   eq,
@@ -12,11 +12,11 @@ import {
   lt,
   lte,
   or,
-} from "../src/query/builder/functions"
-import { PropRef } from "../src/query/ir"
-import { expectIndexUsage, withIndexTracking } from "./utils"
-import type { Collection } from "../src/collection/index.js"
-import type { MutationFn, PendingMutation } from "../src/types"
+} from '../src/query/builder/functions'
+import { PropRef } from '../src/query/ir'
+import { expectIndexUsage, withIndexTracking } from './utils'
+import type { Collection } from '../src/collection/index.js'
+import type { MutationFn, PendingMutation } from '../src/types'
 
 interface TestItem {
   id: string
@@ -231,7 +231,7 @@ describe(`Collection Indexes`, () => {
         },
         {
           includeInitialState: true,
-        }
+        },
       )
 
       // Clear the changes array
@@ -242,7 +242,7 @@ describe(`Collection Indexes`, () => {
         collection.update(`1`, (draft) => {
           draft.status = `inactive`
           draft.age = 26
-        })
+        }),
       )
       await tx.isPersisted.promise
 
@@ -271,7 +271,7 @@ describe(`Collection Indexes`, () => {
         collection.update(`1`, (draft) => {
           draft.status = `inactive`
           draft.age = 26
-        })
+        }),
       )
       await tx.isPersisted.promise
 
@@ -297,7 +297,7 @@ describe(`Collection Indexes`, () => {
         },
         {
           includeInitialState: true,
-        }
+        },
       )
 
       // Clear the changes
@@ -318,7 +318,7 @@ describe(`Collection Indexes`, () => {
 
       // Ensure all events are the same delete event
       const deleteEvents = changes.filter(
-        (c) => c.type === `delete` && c.key === `1`
+        (c) => c.type === `delete` && c.key === `1`,
       )
       expect(deleteEvents.length).toBe(changes.length) // All events should be the same delete
 
@@ -356,7 +356,7 @@ describe(`Collection Indexes`, () => {
         {
           whereExpression: eq(new PropRef([`status`]), `active`),
           includeInitialState: true,
-        }
+        },
       )
 
       // Clear the changes
@@ -367,7 +367,7 @@ describe(`Collection Indexes`, () => {
       tx1.mutate(() =>
         collection.update(`2`, (draft) => {
           draft.status = `active`
-        })
+        }),
       )
       await tx1.isPersisted.promise
 
@@ -380,7 +380,7 @@ describe(`Collection Indexes`, () => {
       tx2.mutate(() =>
         collection.update(`1`, (draft) => {
           draft.status = `inactive`
-        })
+        }),
       )
       await tx2.isPersisted.promise
 
@@ -402,7 +402,7 @@ describe(`Collection Indexes`, () => {
         },
         {
           whereExpression: eq(new PropRef([`status`]), `active`),
-        }
+        },
       )
 
       // Change inactive item to active (should trigger)
@@ -410,7 +410,7 @@ describe(`Collection Indexes`, () => {
       tx1.mutate(() =>
         collection.update(`2`, (draft) => {
           draft.status = `active`
-        })
+        }),
       )
       await tx1.isPersisted.promise
 
@@ -423,7 +423,7 @@ describe(`Collection Indexes`, () => {
       tx2.mutate(() =>
         collection.update(`1`, (draft) => {
           draft.status = `inactive`
-        })
+        }),
       )
       await tx2.isPersisted.promise
 
@@ -688,7 +688,7 @@ describe(`Collection Indexes`, () => {
         const result = collection.currentStateAsChanges({
           where: and(
             gt(new PropRef([`age`]), 25),
-            lt(new PropRef([`age`]), 35)
+            lt(new PropRef([`age`]), 35),
           ),
         })!
 
@@ -720,7 +720,7 @@ describe(`Collection Indexes`, () => {
         const result = collection.currentStateAsChanges({
           where: and(
             eq(new PropRef([`status`]), `active`),
-            gte(new PropRef([`age`]), 25)
+            gte(new PropRef([`age`]), 25),
           ),
         })!
 
@@ -823,7 +823,7 @@ describe(`Collection Indexes`, () => {
         const result = collection.currentStateAsChanges({
           where: or(
             and(gte(new PropRef([`age`]), 25), lte(new PropRef([`age`]), 30)),
-            eq(new PropRef([`status`]), `pending`)
+            eq(new PropRef([`status`]), `pending`),
           ),
         })!
 
@@ -862,7 +862,7 @@ describe(`Collection Indexes`, () => {
         const result = collection.currentStateAsChanges({
           where: and(
             eq(new PropRef([`status`]), `active`), // Can optimize with index
-            gt(new PropRef([`age`]), 24) // Can also optimize - will be AND combined
+            gt(new PropRef([`age`]), 24), // Can also optimize - will be AND combined
           ),
         })!
 
@@ -886,7 +886,7 @@ describe(`Collection Indexes`, () => {
         const result = collection.currentStateAsChanges({
           where: and(
             eq(new PropRef([`age`]), 25), // Has index
-            eq(new PropRef([`name`]), `Alice`) // No index on name
+            eq(new PropRef([`name`]), `Alice`), // No index on name
           ),
         })!
 
@@ -930,7 +930,7 @@ describe(`Collection Indexes`, () => {
         const result = collection.currentStateAsChanges({
           where: and(
             gt(length(new PropRef([`name`])), 4), // Complex - can't optimize (Alice=5, Charlie=7, Diana=5)
-            gt(length(new PropRef([`status`])), 6) // Complex - can't optimize (only "inactive" = 8 > 6)
+            gt(length(new PropRef([`status`])), 6), // Complex - can't optimize (only "inactive" = 8 > 6)
           ),
         })!
 
@@ -954,7 +954,7 @@ describe(`Collection Indexes`, () => {
         const result = collection.currentStateAsChanges({
           where: or(
             gt(length(new PropRef([`name`])), 6), // Complex - can't optimize (only Charlie has name length 7 > 6)
-            gt(length(new PropRef([`status`])), 7) // Complex - can't optimize (only Bob has status "inactive" = 8 > 7)
+            gt(length(new PropRef([`status`])), 7), // Complex - can't optimize (only Bob has status "inactive" = 8 > 7)
           ),
         })!
 
@@ -978,7 +978,7 @@ describe(`Collection Indexes`, () => {
         const result = collection.currentStateAsChanges({
           where: and(
             eq(new PropRef([`name`]), `Alice`),
-            eq(new PropRef([`score`]), 95)
+            eq(new PropRef([`score`]), 95),
           ),
         })!
 
@@ -1003,7 +1003,7 @@ describe(`Collection Indexes`, () => {
         const result1 = collection.currentStateAsChanges({
           where: and(
             eq(new PropRef([`age`]), 25), // Can optimize - has index
-            eq(new PropRef([`name`]), `Alice`) // Can't optimize - no index
+            eq(new PropRef([`name`]), `Alice`), // Can't optimize - no index
           ),
         })
 
@@ -1021,7 +1021,7 @@ describe(`Collection Indexes`, () => {
         const result2 = collection.currentStateAsChanges({
           where: and(
             eq(new PropRef([`name`]), `Alice`), // Can't optimize - no index
-            gt(length(new PropRef([`name`])), 3) // Can't optimize - complex expression
+            gt(length(new PropRef([`name`])), 3), // Can't optimize - complex expression
           ),
         })
 
@@ -1108,7 +1108,7 @@ describe(`Collection Indexes`, () => {
           {
             includeInitialState: true,
             whereExpression: eq(new PropRef([`status`]), `active`),
-          }
+          },
         )
 
         expect(changes).toHaveLength(3) // Initial active items
@@ -1143,7 +1143,7 @@ describe(`Collection Indexes`, () => {
           {
             includeInitialState: true,
             whereExpression: eq(new PropRef([`status`]), `active`),
-          }
+          },
         )
 
         expect(changes).toHaveLength(3) // Initial active items
@@ -1171,7 +1171,7 @@ describe(`Collection Indexes`, () => {
             age: 40,
             status: `active`,
             createdAt: new Date(),
-          })
+          }),
         )
         await tx1.isPersisted.promise
 
@@ -1188,7 +1188,7 @@ describe(`Collection Indexes`, () => {
             age: 35,
             status: `inactive`,
             createdAt: new Date(),
-          })
+          }),
         )
         await tx2.isPersisted.promise
 
@@ -1200,7 +1200,7 @@ describe(`Collection Indexes`, () => {
         tx3.mutate(() =>
           collection.update(`1`, (draft) => {
             draft.status = `inactive`
-          })
+          }),
         )
         await tx3.isPersisted.promise
 
@@ -1224,7 +1224,7 @@ describe(`Collection Indexes`, () => {
           {
             includeInitialState: true,
             whereExpression: gte(new PropRef([`age`]), 30),
-          }
+          },
         )
 
         expect(changes).toHaveLength(2) // Bob (30) and Charlie (35)
@@ -1247,7 +1247,7 @@ describe(`Collection Indexes`, () => {
         tx.mutate(() =>
           collection.update(`4`, (draft) => {
             draft.age = 32
-          })
+          }),
         )
         await tx.isPersisted.promise
 
@@ -1271,7 +1271,7 @@ describe(`Collection Indexes`, () => {
           {
             includeInitialState: true,
             whereExpression: eq(new PropRef([`status`]), `active`),
-          }
+          },
         )
 
         expect(changes).toHaveLength(3) // Initial active items
@@ -1407,14 +1407,14 @@ describe(`Collection Indexes`, () => {
           age: 50,
           status: `active`,
           createdAt: new Date(),
-        })
+        }),
       )
 
       const tx2 = createTransaction({ mutationFn })
       tx2.mutate(() =>
         collection.update(`1`, (draft) => {
           draft.age = 99
-        })
+        }),
       )
 
       const tx3 = createTransaction({ mutationFn })
diff --git a/packages/db/tests/collection-lifecycle.test.ts b/packages/db/tests/collection-lifecycle.test.ts
index 5af642c08..8b70b3ddc 100644
--- a/packages/db/tests/collection-lifecycle.test.ts
+++ b/packages/db/tests/collection-lifecycle.test.ts
@@ -1,5 +1,5 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { createCollection } from "../src/collection/index.js"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
 
 // Mock setTimeout and clearTimeout for testing GC behavior
 const originalSetTimeout = global.setTimeout
@@ -360,6 +360,26 @@ describe(`Collection Lifecycle Management`, () => {
       expect(mockSetTimeout).not.toHaveBeenCalled()
       expect(collection.status).not.toBe(`cleaned-up`)
     })
+
+    it(`should disable GC when gcTime is Infinity`, () => {
+      const collection = createCollection<{ id: string; name: string }>({
+        id: `infinity-gc-test`,
+        getKey: (item) => item.id,
+        gcTime: Infinity, // Disabled GC via Infinity
+        sync: {
+          sync: () => {},
+        },
+      })
+
+      const subscription = collection.subscribeChanges(() => {})
+      subscription.unsubscribe()
+
+      // Should not start any timer when gcTime is Infinity
+      // Note: Without this fix, setTimeout(fn, Infinity) would coerce to 0,
+      // causing immediate GC instead of never collecting
+      expect(mockSetTimeout).not.toHaveBeenCalled()
+      expect(collection.status).not.toBe(`cleaned-up`)
+    })
   })
 
   describe(`Manual Preload and Cleanup`, () => {
@@ -474,5 +494,52 @@ describe(`Collection Lifecycle Management`, () => {
 
       subscription.unsubscribe()
     })
+
+    it(`should fire status:change event with 'cleaned-up' status before clearing event handlers`, () => {
+      const collection = createCollection<{ id: string; name: string }>({
+        id: `cleanup-event-test`,
+        getKey: (item) => item.id,
+        gcTime: 1000,
+        sync: {
+          sync: () => {},
+        },
+      })
+
+      // Track status changes
+      const statusChanges: Array<{ status: string; previousStatus: string }> =
+        []
+
+      // Add event listener for status changes
+      collection.on(`status:change`, ({ status, previousStatus }) => {
+        statusChanges.push({ status, previousStatus })
+      })
+
+      // Subscribe and unsubscribe to trigger GC
+      const subscription = collection.subscribeChanges(() => {})
+      subscription.unsubscribe()
+
+      expect(statusChanges).toHaveLength(1)
+      expect(statusChanges[0]).toEqual({
+        status: `loading`,
+        previousStatus: `idle`,
+      })
+
+      // Trigger GC timeout to schedule cleanup
+      const gcTimerId = mockSetTimeout.mock.results[0]?.value
+      if (gcTimerId) {
+        triggerTimeout(gcTimerId)
+      }
+
+      // Trigger all remaining timeouts to handle the idle callback
+      triggerAllTimeouts()
+
+      // Verify that the listener received the 'cleaned-up' status change event
+      expect(statusChanges).toHaveLength(2)
+      expect(statusChanges[1]).toEqual({
+        status: `cleaned-up`,
+        previousStatus: `loading`,
+      })
+      expect(collection.status).toBe(`cleaned-up`)
+    })
   })
 })
diff --git a/packages/db/tests/collection-schema.test.ts b/packages/db/tests/collection-schema.test.ts
index 0db0bddfc..70030beb3 100644
--- a/packages/db/tests/collection-schema.test.ts
+++ b/packages/db/tests/collection-schema.test.ts
@@ -1,14 +1,14 @@
-import { type } from "arktype"
-import { describe, expect, expectTypeOf, it } from "vitest"
-import { z } from "zod"
-import { createCollection } from "../src/collection/index.js"
-import { SchemaValidationError } from "../src/errors"
-import { createTransaction } from "../src/transactions"
+import { type } from 'arktype'
+import { describe, expect, expectTypeOf, it } from 'vitest'
+import { z } from 'zod'
+import { createCollection } from '../src/collection/index.js'
+import { SchemaValidationError } from '../src/errors'
+import { createTransaction } from '../src/transactions'
 import type {
   OperationType,
   PendingMutation,
   ResolveTransactionChanges,
-} from "../src/types"
+} from '../src/types'
 
 describe(`Collection Schema Validation`, () => {
   it(`should apply transformations for both insert and update operations`, () => {
@@ -75,7 +75,7 @@ describe(`Collection Schema Validation`, () => {
     const validatedUpdate = updateCollection.validateData(
       updateData,
       `update`,
-      `1`
+      `1`,
     )
 
     // Verify that the updated data has been transformed
@@ -199,7 +199,7 @@ describe(`Collection Schema Validation`, () => {
     const validatedUpdateWithTimestamp = collection.validateData(
       updateDataWithTimestamp,
       `update`,
-      `1`
+      `1`,
     )
 
     // Verify that both modified fields are returned with transformations applied
@@ -276,7 +276,7 @@ describe(`Collection with schema validation`, () => {
     const userSchema = type({
       name: `string > 0`,
       age: `number.integer > 0`,
-      "email?": `string.email`,
+      'email?': `string.email`,
     })
 
     // Create a collection with the schema
@@ -323,13 +323,13 @@ describe(`Collection with schema validation`, () => {
         expect(error.issues.length).toBeGreaterThan(0)
         // Check that we have validation errors for each invalid field
         expect(error.issues.some((issue) => issue.path?.includes(`name`))).toBe(
-          true
+          true,
         )
         expect(error.issues.some((issue) => issue.path?.includes(`age`))).toBe(
-          true
+          true,
         )
         expect(
-          error.issues.some((issue) => issue.path?.includes(`email`))
+          error.issues.some((issue) => issue.path?.includes(`email`)),
         ).toBe(true)
       }
     }
@@ -339,7 +339,7 @@ describe(`Collection with schema validation`, () => {
     tx3.mutate(() =>
       collection.update(`Alice`, (draft) => {
         draft.age = 31
-      })
+      }),
     )
 
     // Partial updates should fail with invalid data
@@ -348,7 +348,7 @@ describe(`Collection with schema validation`, () => {
       tx4.mutate(() =>
         collection.update(`Alice`, (draft) => {
           draft.age = -1
-        })
+        }),
       )
       // Should not reach here
       expect(true).toBe(false)
@@ -358,7 +358,7 @@ describe(`Collection with schema validation`, () => {
         expect(error.type).toBe(`update`)
         expect(error.issues.length).toBeGreaterThan(0)
         expect(error.issues.some((issue) => issue.path?.includes(`age`))).toBe(
-          true
+          true,
         )
       }
     }
@@ -416,13 +416,13 @@ describe(`Collection with schema validation`, () => {
         expect(error.issues.length).toBeGreaterThan(0)
         // Check that we have validation errors for each invalid field
         expect(error.issues.some((issue) => issue.path?.includes(`name`))).toBe(
-          true
+          true,
         )
         expect(error.issues.some((issue) => issue.path?.includes(`age`))).toBe(
-          true
+          true,
         )
         expect(
-          error.issues.some((issue) => issue.path?.includes(`email`))
+          error.issues.some((issue) => issue.path?.includes(`email`)),
         ).toBe(true)
       }
     }
@@ -432,7 +432,7 @@ describe(`Collection with schema validation`, () => {
     tx3.mutate(() =>
       collection.update(`Alice`, (draft) => {
         draft.age = 31
-      })
+      }),
     )
 
     // Partial updates should fail with invalid data
@@ -441,7 +441,7 @@ describe(`Collection with schema validation`, () => {
       tx4.mutate(() =>
         collection.update(`Alice`, (draft) => {
           draft.age = -1
-        })
+        }),
       )
       // Should not reach here
       expect(true).toBe(false)
@@ -451,7 +451,7 @@ describe(`Collection with schema validation`, () => {
         expect(error.type).toBe(`update`)
         expect(error.issues.length).toBeGreaterThan(0)
         expect(error.issues.some((issue) => issue.path?.includes(`age`))).toBe(
-          true
+          true,
         )
       }
     }
@@ -555,7 +555,7 @@ describe(`Collection with schema validation`, () => {
         completed: true,
         createdAt: new Date(`2023-01-01T00:00:00Z`),
         updatedAt: new Date(`2023-01-01T00:00:00Z`),
-      })
+      }),
     )
     insertedItems = Array.from(collection.state.values())
     expect(insertedItems).toHaveLength(3)
@@ -702,7 +702,7 @@ describe(`Collection with schema validation`, () => {
         draft.updated_at = `2023-01-02T00:00:00.000Z`
         draft.tags = [`IMPORTANT`, `ADMIN`]
         draft.metadata = { role: `admin` } as Record<string, string>
-      })
+      }),
     )
 
     // Verify that transformations were applied and only modified fields are returned
@@ -798,7 +798,7 @@ describe(`Collection with schema validation`, () => {
     expect((insertMutation.modified as any).preferences.theme).toBe(`dark`)
     expect((insertMutation.modified as any).preferences.version).toBe(`1.0`)
     expect((insertMutation.modified as any).preferences.notifications).toBe(
-      true
+      true,
     )
 
     // Now test update with the same schema that can handle existing transformed data
@@ -813,7 +813,7 @@ describe(`Collection with schema validation`, () => {
             city: z.string(),
             country: z.string().transform((val) => val.toUpperCase()),
             normalized: z.boolean().optional(),
-          })
+          }),
         )
         .transform((val) => val.map((addr) => ({ ...addr, normalized: true }))),
       preferences: z
@@ -859,7 +859,7 @@ describe(`Collection with schema validation`, () => {
           theme: `LIGHT`,
           notifications: false,
         }
-      })
+      }),
     )
 
     // Verify update transformations
@@ -878,7 +878,7 @@ describe(`Collection with schema validation`, () => {
     expect((updateMutation.changes as any).preferences.theme).toBe(`light`)
     expect((updateMutation.changes as any).preferences.version).toBe(`1.0`)
     expect((updateMutation.changes as any).preferences.notifications).toBe(
-      false
+      false,
     )
   })
 })
diff --git a/packages/db/tests/collection-subscribe-changes.test.ts b/packages/db/tests/collection-subscribe-changes.test.ts
index 710f2122a..02e987e1e 100644
--- a/packages/db/tests/collection-subscribe-changes.test.ts
+++ b/packages/db/tests/collection-subscribe-changes.test.ts
@@ -1,16 +1,16 @@
-import { describe, expect, it, vi } from "vitest"
-import mitt from "mitt"
-import { createCollection } from "../src/collection/index.js"
-import { createTransaction } from "../src/transactions"
-import { eq } from "../src/query/builder/functions"
-import { PropRef } from "../src/query/ir"
+import { describe, expect, it, vi } from 'vitest'
+import mitt from 'mitt'
+import { createCollection } from '../src/collection/index.js'
+import { createTransaction } from '../src/transactions'
+import { and, eq, gt } from '../src/query/builder/functions'
+import { PropRef } from '../src/query/ir'
 import type {
   ChangeMessage,
   ChangesPayload,
   MutationFn,
   PendingMutation,
   SyncConfig,
-} from "../src/types"
+} from '../src/types'
 
 // Helper function to wait for changes to be processed
 const waitForChanges = () => new Promise((resolve) => setTimeout(resolve, 10))
@@ -294,7 +294,7 @@ describe(`Collection.subscribeChanges`, () => {
       collection.update(item.id, (draft) => {
         draft.value = `updated optimistic value`
         draft.updated = true
-      })
+      }),
     )
 
     // Verify that update was emitted
@@ -437,7 +437,7 @@ describe(`Collection.subscribeChanges`, () => {
     updateTx.mutate(() =>
       collection.update(optItem.id, (draft) => {
         draft.value = `updated optimistic value`
-      })
+      }),
     )
 
     // Verify the optimistic update was emitted
@@ -557,7 +557,7 @@ describe(`Collection.subscribeChanges`, () => {
         { id: 3, value: `batch1` },
         { id: 4, value: `batch2` },
         { id: 5, value: `batch3` },
-      ])
+      ]),
     )
 
     // Verify only the 3 new items were emitted, not the existing ones
@@ -587,7 +587,7 @@ describe(`Collection.subscribeChanges`, () => {
     tx2.mutate(() =>
       collection.update(itemToUpdate.id, (draft) => {
         draft.value = `updated value`
-      })
+      }),
     )
 
     // Verify only the updated item was emitted
@@ -734,7 +734,7 @@ describe(`Collection.subscribeChanges`, () => {
     tx1.mutate(() =>
       collection.update(1, (draft) => {
         draft.status = `active`
-      })
+      }),
     )
 
     // Should emit an insert event for the newly active item
@@ -757,7 +757,7 @@ describe(`Collection.subscribeChanges`, () => {
     tx2.mutate(() =>
       collection.update(2, (draft) => {
         draft.status = `inactive`
-      })
+      }),
     )
 
     // Should emit a delete event for the newly inactive item
@@ -780,7 +780,7 @@ describe(`Collection.subscribeChanges`, () => {
     tx3.mutate(() =>
       collection.update(1, (draft) => {
         draft.value = `updated item1`
-      })
+      }),
     )
 
     // Should emit an update event for the active item
@@ -803,7 +803,7 @@ describe(`Collection.subscribeChanges`, () => {
     tx4.mutate(() =>
       collection.update(2, (draft) => {
         draft.value = `updated inactive item`
-      })
+      }),
     )
 
     // Should not emit any events for inactive items
@@ -849,7 +849,7 @@ describe(`Collection.subscribeChanges`, () => {
       },
       {
         includeInitialState: true,
-      }
+      },
     )
 
     await collection.stateWhenReady()
@@ -926,7 +926,7 @@ describe(`Collection.subscribeChanges`, () => {
       },
       {
         includeInitialState: true,
-      }
+      },
     )
 
     await collection.stateWhenReady()
@@ -1042,7 +1042,7 @@ describe(`Collection.subscribeChanges`, () => {
       },
       {
         includeInitialState: true,
-      }
+      },
     )
 
     await collection.stateWhenReady()
@@ -1182,7 +1182,7 @@ describe(`Collection.subscribeChanges`, () => {
     tx.mutate(() =>
       collection.update(1, (draft) => {
         draft.value = `client-update`
-      })
+      }),
     )
 
     changeEvents.length = 0
@@ -1193,8 +1193,10 @@ describe(`Collection.subscribeChanges`, () => {
     f.write({ type: `insert`, value: { id: 1, value: `server-after` } })
     f.commit()
 
-    // Expect delete, insert with optimistic value, and an empty event from markReady
-    expect(changeEvents.length).toBe(3)
+    // Expect delete and insert with optimistic value
+    // Note: Previously there was a duplicate insert event that was incorrectly
+    // being sent, causing 3 events. Now duplicates are filtered correctly.
+    expect(changeEvents.length).toBe(2)
     expect(changeEvents[0]).toEqual({
       type: `delete`,
       key: 1,
@@ -1250,6 +1252,70 @@ describe(`Collection.subscribeChanges`, () => {
     expect(collection.state.has(1)).toBe(false)
   })
 
+  it(`should emit synced delete after a non-optimistic delete`, async () => {
+    const emitter = mitt()
+    const callback = vi.fn()
+
+    const collection = createCollection<{ id: number; value: string }>({
+      id: `non-optimistic-delete-sync`,
+      getKey: (item) => item.id,
+      sync: {
+        sync: ({ begin, write, commit }) => {
+          // replay any pending mutations emitted via mitt
+          // @ts-expect-error Mitt typings are loose for our test helpers
+          emitter.on(`*`, (_, changes: Array<PendingMutation>) => {
+            begin()
+            changes.forEach((change) => {
+              write({
+                type: change.type,
+                // @ts-expect-error test helper
+                value: change.modified,
+              })
+            })
+            commit()
+          })
+
+          // seed initial row
+          begin()
+          write({
+            type: `insert`,
+            value: { id: 1, value: `initial` },
+          })
+          commit()
+        },
+      },
+      onDelete: async ({ transaction }) => {
+        emitter.emit(`sync`, transaction.mutations)
+      },
+    })
+
+    const subscription = collection.subscribeChanges(callback, {
+      includeInitialState: true,
+    })
+
+    // initial insert emitted
+    expect(callback).toHaveBeenCalledTimes(1)
+    callback.mockClear()
+
+    const tx = collection.delete(1, { optimistic: false })
+    await tx.isPersisted.promise
+
+    expect(callback).toHaveBeenCalledTimes(1)
+    const deleteChanges = callback.mock.calls[0]![0] as ChangesPayload<{
+      value: string
+    }>
+    expect(deleteChanges).toEqual([
+      {
+        type: `delete`,
+        key: 1,
+        value: { id: 1, value: `initial` },
+      },
+    ])
+    expect(collection.state.has(1)).toBe(false)
+
+    subscription.unsubscribe()
+  })
+
   it(`truncate + optimistic insert: server did NOT reinsert key -> inserted optimistically`, async () => {
     const changeEvents: Array<any> = []
     let f: any = null
@@ -1288,15 +1354,15 @@ describe(`Collection.subscribeChanges`, () => {
 
     // Expect delete for id 1, and insert for id 2
     expect(changeEvents.some((e) => e.type === `delete` && e.key === 1)).toBe(
-      true
+      true,
     )
     expect(
       changeEvents.some(
         (e) =>
           e.type === `insert` &&
           e.key === 2 &&
-          e.value.value === `client-insert`
-      )
+          e.value.value === `client-insert`,
+      ),
     ).toBe(true)
     expect(collection.state.get(2)).toEqual({ id: 2, value: `client-insert` })
   })
@@ -1328,7 +1394,7 @@ describe(`Collection.subscribeChanges`, () => {
     tx.mutate(() =>
       collection.update(1, (draft) => {
         draft.value = `client-update`
-      })
+      }),
     )
 
     changeEvents.length = 0
@@ -1343,7 +1409,7 @@ describe(`Collection.subscribeChanges`, () => {
     const inserts = changeEvents.filter((e) => e.type === `insert`)
     expect(deletes.some((e) => e.key === 1)).toBe(true)
     expect(
-      inserts.some((e) => e.key === 1 && e.value.value === `client-update`)
+      inserts.some((e) => e.key === 1 && e.value.value === `client-update`),
     ).toBe(true)
     expect(collection.state.get(1)).toEqual({ id: 1, value: `client-update` })
   })
@@ -1776,7 +1842,7 @@ describe(`Collection.subscribeChanges`, () => {
       },
       {
         whereExpression: eq(new PropRef([`active`]), true),
-      }
+      },
     )
 
     const { begin, write, commit, markReady } = testSyncFunctions
@@ -1850,4 +1916,169 @@ describe(`Collection.subscribeChanges`, () => {
     expect(collection.status).toBe(`ready`)
     expect(collection.size).toBe(2)
   })
+
+  it(`should support where callback for filtering changes`, () => {
+    const callback = vi.fn()
+
+    // Create collection with items that have a status field
+    const collection = createCollection<{
+      id: number
+      value: string
+      status: `active` | `inactive`
+    }>({
+      id: `where-callback-test`,
+      getKey: (item) => item.id,
+      sync: {
+        sync: ({ begin, write, commit }) => {
+          // Start with some initial data
+          begin()
+          write({
+            type: `insert`,
+            value: { id: 1, value: `item1`, status: `inactive` },
+          })
+          write({
+            type: `insert`,
+            value: { id: 2, value: `item2`, status: `active` },
+          })
+          commit()
+        },
+      },
+    })
+
+    const mutationFn: MutationFn = async () => {}
+
+    // Subscribe to changes with a where callback for active items only
+    const subscription = collection.subscribeChanges(callback, {
+      includeInitialState: true,
+      where: (row) => eq(row.status, `active`),
+    })
+
+    // Should only receive the active item in initial state
+    expect(callback).toHaveBeenCalledTimes(1)
+    const initialChanges = callback.mock.calls[0]![0] as ChangesPayload<{
+      id: number
+      value: string
+      status: `active` | `inactive`
+    }>
+    expect(initialChanges).toHaveLength(1)
+    expect(initialChanges[0]!.key).toBe(2)
+    expect(initialChanges[0]!.type).toBe(`insert`)
+
+    // Reset mock
+    callback.mockReset()
+
+    // Update an inactive item to active (should emit insert)
+    const tx1 = createTransaction({ mutationFn })
+    tx1.mutate(() =>
+      collection.update(1, (draft) => {
+        draft.status = `active`
+      }),
+    )
+
+    // Should emit an insert event for the newly active item
+    expect(callback).toHaveBeenCalledTimes(1)
+    const insertChanges = callback.mock.calls[0]![0] as ChangesPayload<{
+      id: number
+      value: string
+      status: `active` | `inactive`
+    }>
+    expect(insertChanges).toHaveLength(1)
+    expect(insertChanges[0]!.type).toBe(`insert`)
+    expect(insertChanges[0]!.key).toBe(1)
+    expect(insertChanges[0]!.value.status).toBe(`active`)
+
+    // Reset mock
+    callback.mockReset()
+
+    // Update an active item to inactive (should emit delete)
+    const tx2 = createTransaction({ mutationFn })
+    tx2.mutate(() =>
+      collection.update(2, (draft) => {
+        draft.status = `inactive`
+      }),
+    )
+
+    // Should emit a delete event for the newly inactive item
+    expect(callback).toHaveBeenCalledTimes(1)
+    const deleteChanges = callback.mock.calls[0]![0] as ChangesPayload<{
+      id: number
+      value: string
+      status: `active` | `inactive`
+    }>
+    expect(deleteChanges).toHaveLength(1)
+    expect(deleteChanges[0]!.type).toBe(`delete`)
+    expect(deleteChanges[0]!.key).toBe(2)
+
+    // Clean up
+    subscription.unsubscribe()
+  })
+
+  it(`should support where callback with multiple conditions`, () => {
+    const callback = vi.fn()
+
+    // Create collection with items
+    const collection = createCollection<{
+      id: number
+      value: string
+      status: `active` | `inactive`
+      priority: number
+    }>({
+      id: `where-callback-and-test`,
+      getKey: (item) => item.id,
+      sync: {
+        sync: ({ begin, write, commit }) => {
+          begin()
+          write({
+            type: `insert`,
+            value: { id: 1, value: `item1`, status: `active`, priority: 3 },
+          })
+          write({
+            type: `insert`,
+            value: { id: 2, value: `item2`, status: `active`, priority: 8 },
+          })
+          write({
+            type: `insert`,
+            value: { id: 3, value: `item3`, status: `inactive`, priority: 10 },
+          })
+          commit()
+        },
+      },
+    })
+
+    // Subscribe with where callback using and() for multiple conditions
+    const subscription = collection.subscribeChanges(callback, {
+      includeInitialState: true,
+      where: (row) => and(eq(row.status, `active`), gt(row.priority, 5)),
+    })
+
+    // Should only receive item2 (active AND priority > 5)
+    expect(callback).toHaveBeenCalledTimes(1)
+    const initialChanges = callback.mock.calls[0]![0] as ChangesPayload<any>
+    expect(initialChanges).toHaveLength(1)
+    expect(initialChanges[0]!.key).toBe(2)
+    expect(initialChanges[0]!.value).toEqual({
+      id: 2,
+      value: `item2`,
+      status: `active`,
+      priority: 8,
+    })
+
+    // Clean up
+    subscription.unsubscribe()
+  })
+
+  it(`should throw if both where and whereExpression are provided`, () => {
+    const collection = createCollection<{ id: number; status: string }>({
+      id: `where-both-error-test`,
+      getKey: (item) => item.id,
+      sync: { sync: () => {} },
+    })
+
+    expect(() => {
+      collection.subscribeChanges(() => {}, {
+        where: (row) => eq(row.status, `active`),
+        whereExpression: eq(new PropRef([`status`]), `active`),
+      })
+    }).toThrow(`Cannot specify both 'where' and 'whereExpression' options`)
+  })
 })
diff --git a/packages/db/tests/collection-subscriber-duplicate-inserts.test.ts b/packages/db/tests/collection-subscriber-duplicate-inserts.test.ts
new file mode 100644
index 000000000..5657eb206
--- /dev/null
+++ b/packages/db/tests/collection-subscriber-duplicate-inserts.test.ts
@@ -0,0 +1,452 @@
+import { describe, expect, it } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
+import { createLiveQueryCollection, eq } from '../src/query/index.js'
+import { mockSyncCollectionOptions } from './utils.js'
+import type { ChangeMessage } from '../src/types.js'
+
+/**
+ * Tests for duplicate insert prevention in the D2 pipeline.
+ *
+ * The issue: When using live queries with orderBy + limit, the D2 pipeline
+ * uses multiplicity tracking. Each insert adds 1 to multiplicity, each delete
+ * subtracts 1. For an item to disappear, multiplicity must go from 1 to 0.
+ *
+ * If duplicate inserts reach D2, multiplicity becomes > 1, and deletes won't
+ * properly remove items (multiplicity goes from 2 to 1, not triggering removal).
+ *
+ * The fix: CollectionSubscriber tracks keys sent to D2 (sentToD2Keys) and
+ * filters out duplicate inserts before they reach the pipeline.
+ *
+ * Additionally, for JOIN queries with lazy sources:
+ * - The includeInitialState fix ensures internal lazy-loading subscriptions
+ *   don't trigger markAllStateAsSeen() which would disable filtering.
+ */
+
+type TestItem = {
+  id: string
+  value: number
+}
+
+type User = {
+  id: string
+  name: string
+}
+
+type Order = {
+  id: string
+  userId: string
+  amount: number
+}
+
+describe(`CollectionSubscriber duplicate insert prevention`, () => {
+  it(`should properly delete items from live query with orderBy + limit`, async () => {
+    // This test verifies that items can be properly deleted from a live query
+    // with orderBy + limit. If duplicate inserts reach D2, the delete won't work.
+
+    const initialData: Array<TestItem> = [
+      { id: `1`, value: 100 },
+      { id: `2`, value: 90 },
+      { id: `3`, value: 80 },
+    ]
+
+    const sourceCollection = createCollection(
+      mockSyncCollectionOptions({
+        id: `duplicate-d2-source`,
+        getKey: (item: TestItem) => item.id,
+        initialData,
+      }),
+    )
+
+    await sourceCollection.preload()
+
+    // Create live query with orderBy + limit (uses TopKWithFractionalIndexOperator)
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(2)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+        })),
+    )
+
+    await liveQueryCollection.preload()
+
+    // Verify initial results
+    const initialResults = Array.from(liveQueryCollection.values())
+    expect(initialResults).toHaveLength(2)
+    expect(initialResults.map((r) => r.id)).toEqual([`1`, `2`])
+
+    // Subscribe to changes to verify events
+    const allChanges: Array<ChangeMessage<TestItem>> = []
+    const subscription = liveQueryCollection.subscribeChanges(
+      (changes) => {
+        allChanges.push(...changes)
+      },
+      { includeInitialState: true },
+    )
+
+    // Wait for initial state
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // Clear changes
+    allChanges.length = 0
+
+    // Delete item 2 (which is in the visible set)
+    sourceCollection.delete(`2`)
+
+    // Wait for delete to propagate
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    // Verify delete event was emitted
+    const deleteEvents = allChanges.filter((c) => c.type === `delete`)
+    expect(
+      deleteEvents.some((e) => e.key === `2`),
+      `Expected delete event for key 2, but got: ${JSON.stringify(allChanges.map((c) => ({ type: c.type, key: c.key })))}`,
+    ).toBe(true)
+
+    // Verify item 3 moved into the visible set
+    const insertEvents = allChanges.filter((c) => c.type === `insert`)
+    expect(
+      insertEvents.some((e) => e.key === `3`),
+      `Expected insert event for key 3, but got: ${JSON.stringify(allChanges.map((c) => ({ type: c.type, key: c.key })))}`,
+    ).toBe(true)
+
+    // Verify final state
+    const finalResults = Array.from(liveQueryCollection.values())
+    expect(finalResults).toHaveLength(2)
+    expect(finalResults.map((r) => r.id)).toEqual([`1`, `3`])
+
+    subscription.unsubscribe()
+  })
+
+  it(`should not emit duplicate inserts to live query subscribers`, async () => {
+    // This test checks that live query subscribers don't receive duplicate inserts
+    // which would indicate D2 multiplicity issues
+
+    const initialData: Array<TestItem> = [
+      { id: `1`, value: 100 },
+      { id: `2`, value: 90 },
+    ]
+
+    const sourceCollection = createCollection(
+      mockSyncCollectionOptions({
+        id: `duplicate-d2-count`,
+        getKey: (item: TestItem) => item.id,
+        initialData,
+      }),
+    )
+
+    await sourceCollection.preload()
+
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(2)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+        })),
+    )
+
+    await liveQueryCollection.preload()
+
+    const allChanges: Array<ChangeMessage<TestItem>> = []
+    const subscription = liveQueryCollection.subscribeChanges(
+      (changes) => {
+        allChanges.push(...changes)
+      },
+      { includeInitialState: true },
+    )
+
+    // Wait for initial state
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // Count inserts per key
+    const insertCounts = new Map<string, number>()
+    for (const change of allChanges) {
+      if (change.type === `insert`) {
+        insertCounts.set(
+          change.key as string,
+          (insertCounts.get(change.key as string) || 0) + 1,
+        )
+      }
+    }
+
+    // Each key should only have ONE insert
+    for (const [key, count] of insertCounts) {
+      expect(
+        count,
+        `Key ${key} should only have 1 insert after initial state, got ${count}. ` +
+          `This indicates duplicate inserts are reaching D2.`,
+      ).toBe(1)
+    }
+
+    subscription.unsubscribe()
+  })
+
+  it(`should handle rapid updates without duplicate inserts`, async () => {
+    // This test simulates rapid updates that could cause race conditions
+    // leading to duplicate inserts
+
+    const initialData: Array<TestItem> = [
+      { id: `1`, value: 100 },
+      { id: `2`, value: 90 },
+    ]
+
+    const sourceCollection = createCollection(
+      mockSyncCollectionOptions({
+        id: `duplicate-d2-rapid`,
+        getKey: (item: TestItem) => item.id,
+        initialData,
+      }),
+    )
+
+    await sourceCollection.preload()
+
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(2)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+        })),
+    )
+
+    await liveQueryCollection.preload()
+
+    const allChanges: Array<ChangeMessage<TestItem>> = []
+    const subscription = liveQueryCollection.subscribeChanges(
+      (changes) => {
+        allChanges.push(...changes)
+      },
+      { includeInitialState: true },
+    )
+
+    // Wait for initial state
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // Clear changes
+    allChanges.length = 0
+
+    // Rapid updates to simulate potential race conditions
+    for (let i = 0; i < 5; i++) {
+      sourceCollection.update(`1`, (draft) => {
+        draft.value = 100 + i
+      })
+    }
+
+    // Wait for updates to propagate
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    // Should have update events, not duplicate inserts
+    const insertCounts = new Map<string, number>()
+    for (const change of allChanges) {
+      if (change.type === `insert`) {
+        insertCounts.set(
+          change.key as string,
+          (insertCounts.get(change.key as string) || 0) + 1,
+        )
+      }
+    }
+
+    // No duplicate inserts should occur during updates
+    for (const [key, count] of insertCounts) {
+      expect(
+        count,
+        `Key ${key} should not have duplicate inserts during updates, got ${count}.`,
+      ).toBeLessThanOrEqual(1)
+    }
+
+    subscription.unsubscribe()
+  })
+
+  it(`should handle mutation during live query subscription setup`, async () => {
+    // This test checks for race conditions where a mutation occurs
+    // during live query subscription initialization
+
+    const initialData: Array<TestItem> = [
+      { id: `1`, value: 100 },
+      { id: `2`, value: 90 },
+    ]
+
+    const sourceCollection = createCollection(
+      mockSyncCollectionOptions({
+        id: `duplicate-d2-mutation-during-setup`,
+        getKey: (item: TestItem) => item.id,
+        initialData,
+      }),
+    )
+
+    await sourceCollection.preload()
+
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(2)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+        })),
+    )
+
+    await liveQueryCollection.preload()
+
+    const allChanges: Array<ChangeMessage<TestItem>> = []
+
+    // Subscribe and immediately mutate the source
+    const subscription = liveQueryCollection.subscribeChanges(
+      (changes) => {
+        allChanges.push(...changes)
+
+        // Trigger mutation during callback (similar to race condition test)
+        const firstInsert = changes.find(
+          (c) => c.type === `insert` && c.key === `1`,
+        )
+        if (firstInsert) {
+          sourceCollection.update(`1`, (draft) => {
+            draft.value = 101
+          })
+        }
+      },
+      { includeInitialState: true },
+    )
+
+    // Wait for everything to settle
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    // Count inserts per key
+    const insertCounts = new Map<string, number>()
+    for (const change of allChanges) {
+      if (change.type === `insert`) {
+        insertCounts.set(
+          change.key as string,
+          (insertCounts.get(change.key as string) || 0) + 1,
+        )
+      }
+    }
+
+    console.log(
+      `Insert counts:`,
+      Object.fromEntries(insertCounts),
+      `All changes:`,
+      allChanges.map((c) => ({ type: c.type, key: c.key })),
+    )
+
+    // Each key should only have ONE insert initially
+    // (updates after initial insert are ok, but not duplicate inserts)
+    for (const [key, count] of insertCounts) {
+      expect(
+        count,
+        `Key ${key} should only have 1 insert, got ${count}. ` +
+          `Duplicate inserts indicate D2 multiplicity issues.`,
+      ).toBe(1)
+    }
+
+    // Verify we can still delete items (multiplicity is correct)
+    allChanges.length = 0
+    sourceCollection.delete(`2`)
+
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    const deleteEvents = allChanges.filter((c) => c.type === `delete`)
+    expect(deleteEvents.some((e) => e.key === `2`)).toBe(true)
+
+    subscription.unsubscribe()
+  })
+
+  it(`should properly handle deletes in join queries with lazy sources`, async () => {
+    // This test verifies that items can be properly deleted from a live query
+    // with a join where one collection is loaded lazily.
+    // The bug: includeInitialState: false was being passed to lazy sources,
+    // which triggered markAllStateAsSeen(), disabling filtering.
+
+    const users: Array<User> = [
+      { id: `u1`, name: `Alice` },
+      { id: `u2`, name: `Bob` },
+    ]
+
+    const orders: Array<Order> = [
+      { id: `o1`, userId: `u1`, amount: 100 },
+      { id: `o2`, userId: `u1`, amount: 200 },
+      { id: `o3`, userId: `u2`, amount: 150 },
+    ]
+
+    const usersCollection = createCollection(
+      mockSyncCollectionOptions({
+        id: `join-lazy-users`,
+        getKey: (item: User) => item.id,
+        initialData: users,
+      }),
+    )
+
+    const ordersCollection = createCollection(
+      mockSyncCollectionOptions({
+        id: `join-lazy-orders`,
+        getKey: (item: Order) => item.id,
+        initialData: orders,
+      }),
+    )
+
+    await Promise.all([usersCollection.preload(), ordersCollection.preload()])
+
+    // Create a join query - the orders collection should be lazy loaded
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ users: usersCollection })
+        .join({ orders: ordersCollection }, ({ users, orders }) =>
+          eq(users.id, orders.userId),
+        )
+        .select(({ users, orders }) => ({
+          orderId: orders!.id,
+          userName: users.name,
+          amount: orders!.amount,
+        })),
+    )
+
+    await liveQueryCollection.preload()
+
+    // Verify initial results
+    const initialResults = Array.from(liveQueryCollection.values())
+    expect(initialResults).toHaveLength(3)
+
+    // Subscribe to changes
+    const allChanges: Array<ChangeMessage<any>> = []
+    const subscription = liveQueryCollection.subscribeChanges(
+      (changes) => {
+        allChanges.push(...changes)
+      },
+      { includeInitialState: true },
+    )
+
+    // Wait for initial state
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    // Clear changes
+    allChanges.length = 0
+
+    // Delete an order
+    ordersCollection.delete(`o1`)
+
+    // Wait for delete to propagate
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    // Verify delete event was emitted
+    const deleteEvents = allChanges.filter((c) => c.type === `delete`)
+    expect(
+      deleteEvents.length,
+      `Expected at least 1 delete event, but got: ${JSON.stringify(allChanges.map((c) => ({ type: c.type, key: c.key })))}`,
+    ).toBeGreaterThan(0)
+
+    // Verify final state
+    const finalResults = Array.from(liveQueryCollection.values())
+    expect(finalResults).toHaveLength(2)
+
+    subscription.unsubscribe()
+  })
+})
diff --git a/packages/db/tests/collection-subscription.test.ts b/packages/db/tests/collection-subscription.test.ts
index 0b9e09384..65465a6a8 100644
--- a/packages/db/tests/collection-subscription.test.ts
+++ b/packages/db/tests/collection-subscription.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest"
-import { createCollection } from "../src/collection/index.js"
-import { flushPromises } from "./utils"
+import { describe, expect, it } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
+import { flushPromises } from './utils'
 
 describe(`CollectionSubscription status tracking`, () => {
   it(`subscription starts with status 'ready'`, () => {
diff --git a/packages/db/tests/collection-truncate.test.ts b/packages/db/tests/collection-truncate.test.ts
index f3630d0aa..1e12b0416 100644
--- a/packages/db/tests/collection-truncate.test.ts
+++ b/packages/db/tests/collection-truncate.test.ts
@@ -1,6 +1,6 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { createCollection } from "../src/collection/index.js"
-import type { SyncConfig } from "../src/types"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
+import type { LoadSubsetOptions, SyncConfig } from '../src/types'
 
 describe(`Collection truncate operations`, () => {
   beforeEach(() => {
@@ -81,7 +81,7 @@ describe(`Collection truncate operations`, () => {
 
     // Verify only one insert event for the optimistic item
     const key3Inserts = changeEvents.filter(
-      (e) => e.type === `insert` && e.key === 3
+      (e) => e.type === `insert` && e.key === 3,
     )
     expect(key3Inserts.length).toBe(1)
   })
@@ -198,7 +198,7 @@ describe(`Collection truncate operations`, () => {
 
     // Should not have duplicate insert events
     const insertCount = changeEvents.filter(
-      (e) => e.type === `insert` && e.key === 1
+      (e) => e.type === `insert` && e.key === 1,
     ).length
     expect(insertCount).toBeLessThanOrEqual(1)
   })
@@ -706,4 +706,428 @@ describe(`Collection truncate operations`, () => {
     expect(collection.state.has(2)).toBe(true)
     expect(collection.state.get(2)).toEqual({ id: 2, value: `optimistic` })
   })
+
+  it(`should buffer subscription changes during truncate until loadSubset refetch completes`, async () => {
+    // This test verifies that when a truncate occurs:
+    // 1. The subscription buffers delete events from the truncate
+    // 2. The subscription re-requests its previously loaded subsets
+    // 3. Insert events from the refetch are also buffered
+    // 4. All buffered events are emitted together when loadSubset completes
+    // This prevents a flash of missing content during must-refetch scenarios
+
+    const changeEvents: Array<any> = []
+    let syncOps:
+      | Parameters<SyncConfig<{ id: number; value: string }, number>[`sync`]>[0]
+      | undefined
+    let loadSubsetResolver: (() => void) | undefined
+    let loadSubsetCallCount = 0
+
+    const collection = createCollection<{ id: number; value: string }, number>({
+      id: `truncate-buffering-test`,
+      getKey: (item) => item.id,
+      startSync: true,
+      syncMode: `on-demand`,
+      sync: {
+        sync: (cfg) => {
+          syncOps = cfg
+          cfg.markReady()
+
+          return {
+            loadSubset: (_options: LoadSubsetOptions) => {
+              loadSubsetCallCount++
+
+              // Return a promise that we control
+              return new Promise<void>((resolve) => {
+                loadSubsetResolver = () => {
+                  // When resolved, write some data
+                  cfg.begin()
+                  cfg.write({
+                    type: `insert`,
+                    value: { id: 1, value: `refetched-1` },
+                  })
+                  cfg.write({
+                    type: `insert`,
+                    value: { id: 2, value: `refetched-2` },
+                  })
+                  cfg.commit()
+                  resolve()
+                }
+              })
+            },
+          }
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    // Subscribe with includeInitialState to trigger loadSubset
+    const subscription = collection.subscribeChanges(
+      (changes) => {
+        changeEvents.push(...changes)
+      },
+      {
+        includeInitialState: true,
+      },
+    )
+
+    // Initially empty, waiting for loadSubset
+    expect(changeEvents.length).toBe(0)
+    expect(loadSubsetCallCount).toBe(1)
+
+    // Resolve the first loadSubset to get initial data
+    loadSubsetResolver!()
+    await vi.waitFor(() => expect(changeEvents.length).toBe(2))
+
+    // Verify initial data arrived
+    expect(changeEvents).toEqual([
+      { type: `insert`, key: 1, value: { id: 1, value: `refetched-1` } },
+      { type: `insert`, key: 2, value: { id: 2, value: `refetched-2` } },
+    ])
+
+    // Clear events for next phase
+    changeEvents.length = 0
+    loadSubsetCallCount = 0
+
+    // Now trigger a truncate (simulating must-refetch)
+    syncOps!.begin()
+    syncOps!.truncate()
+    syncOps!.commit()
+
+    // The truncate event should trigger the subscription to buffer and re-request
+    // loadSubset should be called again
+    await vi.waitFor(() => expect(loadSubsetCallCount).toBe(1))
+
+    // Changes should be buffered - subscriber should NOT see deletes yet
+    // (The subscription is buffering until loadSubset completes)
+    expect(changeEvents.length).toBe(0)
+
+    // Now resolve the loadSubset - this should flush the buffer
+    loadSubsetResolver!()
+
+    // Wait for buffered events to be flushed
+    await vi.waitFor(() => expect(changeEvents.length).toBeGreaterThan(0))
+
+    // Verify we got all events in one batch (deletes + inserts)
+    // The subscription should have received:
+    // - Delete events for the old data (from truncate)
+    // - Insert events for the new data (from refetch)
+    const deletes = changeEvents.filter((e) => e.type === `delete`)
+    const inserts = changeEvents.filter((e) => e.type === `insert`)
+
+    expect(deletes.length).toBe(2) // Deleted the old items
+    expect(inserts.length).toBe(2) // Inserted the refetched items
+
+    // Verify final state is correct
+    expect(collection.state.size).toBe(2)
+    expect(collection.state.get(1)).toEqual({ id: 1, value: `refetched-1` })
+    expect(collection.state.get(2)).toEqual({ id: 2, value: `refetched-2` })
+
+    subscription.unsubscribe()
+  })
+
+  it(`should not buffer changes when there are no subsets to reload`, async () => {
+    // When a subscription has no previously loaded subsets,
+    // it should not enter buffering mode during truncate
+
+    const changeEvents: Array<any> = []
+    let syncOps:
+      | Parameters<SyncConfig<{ id: number; value: string }, number>[`sync`]>[0]
+      | undefined
+
+    const collection = createCollection<{ id: number; value: string }, number>({
+      id: `truncate-no-buffer-test`,
+      getKey: (item) => item.id,
+      startSync: true,
+      sync: {
+        sync: (cfg) => {
+          syncOps = cfg
+          cfg.begin()
+          cfg.write({ type: `insert`, value: { id: 1, value: `initial` } })
+          cfg.commit()
+          cfg.markReady()
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    // Subscribe WITHOUT includeInitialState - no loadSubset is called
+    collection.subscribeChanges((changes) => {
+      changeEvents.push(...changes)
+    })
+
+    // No initial events since includeInitialState is false
+    expect(changeEvents.length).toBe(0)
+
+    // Trigger truncate
+    syncOps!.begin()
+    syncOps!.truncate()
+    syncOps!.write({
+      type: `insert`,
+      value: { id: 1, value: `after-truncate` },
+    })
+    syncOps!.commit()
+
+    // Since there were no loaded subsets, changes should be emitted immediately
+    // (no buffering because there's nothing to refetch)
+    expect(changeEvents.length).toBeGreaterThan(0)
+  })
+
+  it(`should handle unsubscribe during truncate buffering`, async () => {
+    // Verifies that unsubscribing while buffering cleans up properly
+
+    let syncOps:
+      | Parameters<SyncConfig<{ id: number; value: string }, number>[`sync`]>[0]
+      | undefined
+    let loadSubsetResolver: (() => void) | undefined
+
+    const collection = createCollection<{ id: number; value: string }, number>({
+      id: `truncate-unsubscribe-during-buffer`,
+      getKey: (item) => item.id,
+      startSync: true,
+      syncMode: `on-demand`,
+      sync: {
+        sync: (cfg) => {
+          syncOps = cfg
+          cfg.markReady()
+
+          return {
+            loadSubset: (_options: LoadSubsetOptions) => {
+              return new Promise<void>((resolve) => {
+                loadSubsetResolver = () => {
+                  cfg.begin()
+                  cfg.write({
+                    type: `insert`,
+                    value: { id: 1, value: `data` },
+                  })
+                  cfg.commit()
+                  resolve()
+                }
+              })
+            },
+          }
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    const changeEvents: Array<any> = []
+    const subscription = collection.subscribeChanges(
+      (changes) => {
+        changeEvents.push(...changes)
+      },
+      { includeInitialState: true },
+    )
+
+    // Resolve initial load
+    loadSubsetResolver!()
+    await vi.waitFor(() => expect(changeEvents.length).toBe(1))
+    changeEvents.length = 0
+
+    // Trigger truncate
+    syncOps!.begin()
+    syncOps!.truncate()
+    syncOps!.commit()
+
+    // Unsubscribe before loadSubset completes
+    subscription.unsubscribe()
+
+    // Resolve the loadSubset - should not cause errors
+    loadSubsetResolver!()
+
+    // Give it time to process
+    await vi.advanceTimersByTimeAsync(10)
+
+    // No additional events should have been emitted to the unsubscribed callback
+    expect(changeEvents.length).toBe(0)
+  })
+
+  it(`should emit delete events after truncate when loadedInitialState was true`, async () => {
+    // This test specifically validates the edge case where:
+    // 1. requestSnapshot() is called without options (sets loadedInitialState = true)
+    // 2. When loadedInitialState is true, trackSentKeys early-returns, leaving sentKeys empty
+    // 3. On truncate, we must populate sentKeys BEFORE setting loadedInitialState = false
+    //    Otherwise, delete events would be filtered out by filterAndFlipChanges
+    //
+    // This is the scenario the reviewer identified where sentKeys could be empty.
+
+    const changeEvents: Array<any> = []
+    let syncOps:
+      | Parameters<SyncConfig<{ id: number; value: string }, number>[`sync`]>[0]
+      | undefined
+    let loadSubsetResolver: (() => void) | undefined
+    let loadSubsetCallCount = 0
+
+    const collection = createCollection<{ id: number; value: string }, number>({
+      id: `truncate-loadedInitialState-test`,
+      getKey: (item) => item.id,
+      startSync: true,
+      syncMode: `on-demand`,
+      sync: {
+        sync: (cfg) => {
+          syncOps = cfg
+          cfg.markReady()
+
+          return {
+            loadSubset: (_options: LoadSubsetOptions) => {
+              loadSubsetCallCount++
+
+              return new Promise<void>((resolve) => {
+                loadSubsetResolver = () => {
+                  cfg.begin()
+                  cfg.write({
+                    type: `insert`,
+                    value: { id: 1, value: `item-1` },
+                  })
+                  cfg.write({
+                    type: `insert`,
+                    value: { id: 2, value: `item-2` },
+                  })
+                  cfg.commit()
+                  resolve()
+                }
+              })
+            },
+          }
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    // Create subscription WITHOUT includeInitialState
+    // Then manually call requestSnapshot() without options to set loadedInitialState = true
+    const subscription = collection.subscribeChanges((changes) => {
+      changeEvents.push(...changes)
+    })
+
+    // Manually trigger requestSnapshot() without options
+    // This sets loadedInitialState = true and sentKeys stays empty
+    // (This mimics the lazy join fallback path in joins.ts line 310)
+    subscription.requestSnapshot()
+    expect(loadSubsetCallCount).toBe(1)
+
+    // Resolve the loadSubset promise
+    loadSubsetResolver!()
+    await vi.waitFor(() => expect(changeEvents.length).toBe(2))
+
+    // Verify initial data arrived
+    expect(changeEvents[0]).toMatchObject({ type: `insert`, key: 1 })
+    expect(changeEvents[1]).toMatchObject({ type: `insert`, key: 2 })
+
+    changeEvents.length = 0
+    const previousLoadSubsetCount = loadSubsetCallCount
+
+    // Now trigger a truncate
+    syncOps!.begin()
+    syncOps!.truncate()
+    syncOps!.commit()
+
+    // Wait for loadSubset to be called again
+    await vi.waitFor(() =>
+      expect(loadSubsetCallCount).toBeGreaterThan(previousLoadSubsetCount),
+    )
+
+    // Resolve the new loadSubset promise
+    loadSubsetResolver!()
+
+    // Wait for events to be emitted
+    await vi.waitFor(() => expect(changeEvents.length).toBeGreaterThan(0))
+
+    // The key assertion: we should have received delete events
+    // Without the fix, sentKeys would be empty and deletes would be filtered out
+    const deletes = changeEvents.filter((e) => e.type === `delete`)
+    expect(deletes.length).toBe(2) // Must have delete events!
+
+    subscription.unsubscribe()
+  })
+
+  it(`should buffer truncate deletes even when loadSubset is synchronous`, async () => {
+    // This test verifies that even when loadSubset returns synchronously (true),
+    // we still capture the truncate delete events in the buffer.
+    // The truncate event is emitted BEFORE delete events are sent, so if we
+    // flush immediately, we'd miss the deletes.
+
+    const changeEvents: Array<any> = []
+    let syncOps:
+      | Parameters<SyncConfig<{ id: number; value: string }, number>[`sync`]>[0]
+      | undefined
+
+    const collection = createCollection<{ id: number; value: string }, number>({
+      id: `truncate-sync-loadSubset-test`,
+      getKey: (item) => item.id,
+      startSync: true,
+      syncMode: `on-demand`,
+      sync: {
+        sync: (cfg) => {
+          syncOps = cfg
+          cfg.markReady()
+
+          return {
+            // loadSubset returns true (synchronous) - data already available
+            loadSubset: (_options: LoadSubsetOptions) => {
+              // Synchronously write data
+              cfg.begin()
+              cfg.write({
+                type: `insert`,
+                value: { id: 1, value: `sync-item-1` },
+              })
+              cfg.write({
+                type: `insert`,
+                value: { id: 2, value: `sync-item-2` },
+              })
+              cfg.commit()
+              return true // Synchronous return
+            },
+          }
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    // Subscribe with includeInitialState to trigger loadSubset
+    const subscription = collection.subscribeChanges(
+      (changes) => {
+        changeEvents.push(...changes)
+      },
+      { includeInitialState: true },
+    )
+
+    // Wait for initial data
+    await vi.waitFor(() => expect(changeEvents.length).toBe(2))
+    expect(collection.state.size).toBe(2)
+
+    changeEvents.length = 0
+
+    // Trigger truncate - loadSubset will return synchronously
+    syncOps!.begin()
+    syncOps!.truncate()
+    syncOps!.commit()
+
+    // Wait for events to settle
+    await vi.advanceTimersByTimeAsync(10)
+
+    // We should have received delete events even though loadSubset was sync
+    const deletes = changeEvents.filter((e) => e.type === `delete`)
+    const inserts = changeEvents.filter((e) => e.type === `insert`)
+
+    expect(deletes.length).toBe(2) // Should have 2 deletes
+    expect(inserts.length).toBe(2) // Should have 2 inserts
+
+    // Verify correct ordering: deletes should come before inserts
+    // (truncate clears old data, then refetch adds new data)
+    const firstDeleteIdx = changeEvents.findIndex((e) => e.type === `delete`)
+    const firstInsertIdx = changeEvents.findIndex((e) => e.type === `insert`)
+    expect(firstDeleteIdx).toBeLessThan(firstInsertIdx)
+
+    // Verify collection state is correct
+    expect(collection.state.size).toBe(2)
+    expect(collection.state.get(1)).toEqual({ id: 1, value: `sync-item-1` })
+    expect(collection.state.get(2)).toEqual({ id: 2, value: `sync-item-2` })
+
+    subscription.unsubscribe()
+  })
 })
diff --git a/packages/db/tests/collection.test-d.ts b/packages/db/tests/collection.test-d.ts
index d70d53e19..832e3b3cd 100644
--- a/packages/db/tests/collection.test-d.ts
+++ b/packages/db/tests/collection.test-d.ts
@@ -1,8 +1,8 @@
-import { assertType, describe, expectTypeOf, it } from "vitest"
-import { z } from "zod"
-import { createCollection } from "../src/collection/index.js"
-import type { OperationConfig } from "../src/types"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+import { assertType, describe, expectTypeOf, it } from 'vitest'
+import { z } from 'zod'
+import { createCollection } from '../src/collection/index.js'
+import type { OperationConfig } from '../src/types'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 describe(`Collection.update type tests`, () => {
   type TypeTestItem = { id: string; value: number; optional?: boolean }
diff --git a/packages/db/tests/collection.test.ts b/packages/db/tests/collection.test.ts
index a5a94fb06..ecb60361d 100644
--- a/packages/db/tests/collection.test.ts
+++ b/packages/db/tests/collection.test.ts
@@ -1,21 +1,22 @@
-import mitt from "mitt"
-import { describe, expect, it, vi } from "vitest"
-import { createCollection } from "../src/collection/index.js"
+import mitt from 'mitt'
+import { describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
 import {
   CollectionRequiresConfigError,
   DuplicateKeyError,
+  InvalidKeyError,
   KeyUpdateNotAllowedError,
   MissingDeleteHandlerError,
   MissingInsertHandlerError,
   MissingUpdateHandlerError,
-} from "../src/errors"
-import { createTransaction } from "../src/transactions"
+} from '../src/errors'
+import { createTransaction } from '../src/transactions'
 import {
   flushPromises,
   mockSyncCollectionOptionsNoInitialState,
   withExpectedRejection,
-} from "./utils"
-import type { ChangeMessage, MutationFn, PendingMutation } from "../src/types"
+} from './utils'
+import type { ChangeMessage, MutationFn, PendingMutation } from '../src/types'
 
 describe(`Collection`, () => {
   it(`should throw if there's no sync config`, () => {
@@ -213,13 +214,13 @@ describe(`Collection`, () => {
 
     // The merged value should immediately contain the new insert
     expect(collection.state).toEqual(
-      new Map([[insertedKey, { id: 1, value: `bar` }]])
+      new Map([[insertedKey, { id: 1, value: `bar` }]]),
     )
 
     // check there's a transaction in peristing state
     expect(
       // @ts-expect-error possibly undefined is ok in test
-      tx.mutations[0].changes
+      tx.mutations[0].changes,
     ).toEqual({
       id: 1,
       value: `bar`,
@@ -264,7 +265,7 @@ describe(`Collection`, () => {
     // optimistic update is gone & synced data & combined state are all updated.
     expect(collection._state.transactions.size).toEqual(0) // Transaction should be cleaned up
     expect(collection.state).toEqual(
-      new Map([[insertedKey, { id: 1, value: `bar` }]])
+      new Map([[insertedKey, { id: 1, value: `bar` }]]),
     )
     expect(collection._state.optimisticUpserts.size).toEqual(0)
 
@@ -297,7 +298,7 @@ describe(`Collection`, () => {
       collection.update([1], (item) => {
         // @ts-expect-error possibly undefined is ok in test
         item[0].value = `bar2`
-      })
+      }),
     )
 
     // The merged value should contain the update.
@@ -313,8 +314,8 @@ describe(`Collection`, () => {
         (item) => {
           item.value = `bar3`
           item.newProp = `new value`
-        }
-      )
+        },
+      ),
     )
 
     // The merged value should contain the update
@@ -336,7 +337,7 @@ describe(`Collection`, () => {
         (item) => {
           item.value = `bar3.1`
           item.newProp = `new value.1`
-        }
+        },
       )
       collection.update(
         insertedKey,
@@ -344,7 +345,7 @@ describe(`Collection`, () => {
         (item) => {
           item.value = `bar3`
           item.newProp = `new value`
-        }
+        },
       )
     })
 
@@ -369,8 +370,8 @@ describe(`Collection`, () => {
             draft.value += `-updated`
             draft.boolean = true
           })
-        }
-      )
+        },
+      ),
     )
 
     // Check bulk updates
@@ -405,7 +406,7 @@ describe(`Collection`, () => {
     tx8.mutate(() =>
       collection.delete(tx8insertKey, {
         metadata: { reason: `test delete` },
-      })
+      }),
     )
     expect(tx8.mutations[0]?.metadata).toEqual({ reason: `test delete` })
     expect(collection.state.has(tx8insertKey)).toBe(false)
@@ -471,7 +472,7 @@ describe(`Collection`, () => {
       collection.insert({
         id: 1,
         value: `bar`,
-      })
+      }),
     )
 
     // The merged value should immediately contain the new insert
@@ -481,7 +482,7 @@ describe(`Collection`, () => {
     expect(
       // @ts-expect-error possibly undefined is ok in test
       Array.from(collection._state.transactions.values())[0].mutations[0]
-        .changes
+        .changes,
     ).toEqual({
       id: 1,
       value: `bar`,
@@ -523,7 +524,7 @@ describe(`Collection`, () => {
     // Throw when trying to delete a non-existent ID
     const tx2 = createTransaction({ mutationFn })
     expect(() =>
-      tx2.mutate(() => collection.delete(`non-existent-id`))
+      tx2.mutate(() => collection.delete(`non-existent-id`)),
     ).toThrow()
 
     // Should not throw when deleting by ID
@@ -567,6 +568,196 @@ describe(`Collection`, () => {
     }).not.toThrow()
   })
 
+  it(`should not allow bulk inserting documents with duplicate IDs in the same batch`, async () => {
+    const collection = createCollection<{ id: number; value: string }>({
+      id: `bulk-duplicate-id-test`,
+      getKey: (item) => item.id,
+      startSync: true,
+      sync: {
+        sync: ({ begin, commit, markReady }) => {
+          begin()
+          commit()
+          markReady()
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    const mutationFn = async () => {}
+    const tx = createTransaction({ mutationFn })
+
+    // Try to bulk insert documents with duplicate IDs within the same batch
+    expect(() => {
+      tx.mutate(() =>
+        collection.insert([
+          { id: 1, value: `first` },
+          { id: 1, value: `second` }, // Same ID - should throw
+        ]),
+      )
+    }).toThrow(DuplicateKeyError)
+
+    // Should be able to bulk insert documents with different IDs
+    const tx2 = createTransaction({ mutationFn })
+    expect(() => {
+      tx2.mutate(() =>
+        collection.insert([
+          { id: 2, value: `first` },
+          { id: 3, value: `second` },
+        ]),
+      )
+    }).not.toThrow()
+
+    // Verify both items were inserted
+    expect(collection.state.get(2)).toEqual({ id: 2, value: `first` })
+    expect(collection.state.get(3)).toEqual({ id: 3, value: `second` })
+  })
+
+  it(`should throw InvalidKeyError when getKey returns null`, async () => {
+    const collection = createCollection<{ id: null; value: string }>({
+      id: `null-key-test`,
+      // @ts-expect-error - testing runtime behavior when getKey returns null
+      getKey: (item) => item.id,
+      startSync: true,
+      sync: {
+        sync: ({ begin, commit, markReady }) => {
+          begin()
+          commit()
+          markReady()
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    const mutationFn = async () => {}
+    const tx = createTransaction({ mutationFn })
+
+    expect(() => {
+      tx.mutate(() => collection.insert({ id: null, value: `test` }))
+    }).toThrow(InvalidKeyError)
+  })
+
+  it(`should throw InvalidKeyError when getKey returns an object`, async () => {
+    const collection = createCollection<{
+      id: { nested: string }
+      value: string
+    }>({
+      id: `object-key-test`,
+      // @ts-expect-error - testing runtime behavior when getKey returns an object
+      getKey: (item) => item.id,
+      startSync: true,
+      sync: {
+        sync: ({ begin, commit, markReady }) => {
+          begin()
+          commit()
+          markReady()
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    const mutationFn = async () => {}
+    const tx = createTransaction({ mutationFn })
+
+    expect(() => {
+      tx.mutate(() =>
+        collection.insert({ id: { nested: `value` }, value: `test` }),
+      )
+    }).toThrow(InvalidKeyError)
+  })
+
+  it(`should throw InvalidKeyError when getKey returns a boolean`, async () => {
+    const collection = createCollection<{ id: boolean; value: string }>({
+      id: `boolean-key-test`,
+      // @ts-expect-error - testing runtime behavior when getKey returns a boolean
+      getKey: (item) => item.id,
+      startSync: true,
+      sync: {
+        sync: ({ begin, commit, markReady }) => {
+          begin()
+          commit()
+          markReady()
+        },
+      },
+    })
+
+    await collection.stateWhenReady()
+
+    const mutationFn = async () => {}
+    const tx = createTransaction({ mutationFn })
+
+    expect(() => {
+      tx.mutate(() => collection.insert({ id: true, value: `test` }))
+    }).toThrow(InvalidKeyError)
+  })
+
+  it(`should accept valid string and number keys`, async () => {
+    const stringKeyCollection = createCollection<{ id: string; value: string }>(
+      {
+        id: `string-key-test`,
+        getKey: (item) => item.id,
+        startSync: true,
+        sync: {
+          sync: ({ begin, commit, markReady }) => {
+            begin()
+            commit()
+            markReady()
+          },
+        },
+      },
+    )
+
+    const numberKeyCollection = createCollection<{ id: number; value: string }>(
+      {
+        id: `number-key-test`,
+        getKey: (item) => item.id,
+        startSync: true,
+        sync: {
+          sync: ({ begin, commit, markReady }) => {
+            begin()
+            commit()
+            markReady()
+          },
+        },
+      },
+    )
+
+    await Promise.all([
+      stringKeyCollection.stateWhenReady(),
+      numberKeyCollection.stateWhenReady(),
+    ])
+
+    const mutationFn = async () => {}
+
+    // String key should work
+    const tx1 = createTransaction({ mutationFn })
+    expect(() => {
+      tx1.mutate(() =>
+        stringKeyCollection.insert({ id: `string-id`, value: `test` }),
+      )
+    }).not.toThrow()
+
+    // Number key should work
+    const tx2 = createTransaction({ mutationFn })
+    expect(() => {
+      tx2.mutate(() => numberKeyCollection.insert({ id: 123, value: `test` }))
+    }).not.toThrow()
+
+    // Empty string key should work
+    const tx3 = createTransaction({ mutationFn })
+    expect(() => {
+      tx3.mutate(() => stringKeyCollection.insert({ id: ``, value: `empty` }))
+    }).not.toThrow()
+
+    // Zero key should work
+    const tx4 = createTransaction({ mutationFn })
+    expect(() => {
+      tx4.mutate(() => numberKeyCollection.insert({ id: 0, value: `zero` }))
+    }).not.toThrow()
+  })
+
   it(`should support operation handler functions`, async () => {
     // Create mock handler functions
     const onInsertMock = vi.fn()
@@ -607,7 +798,7 @@ describe(`Collection`, () => {
     tx.mutate(() =>
       collection.update(1, (draft) => {
         draft.value = `updated value`
-      })
+      }),
     )
 
     // Test delete handler
@@ -782,7 +973,7 @@ describe(`Collection`, () => {
     // Test non-optimistic insert
     const nonOptimisticInsertTx = collection.insert(
       { id: 2, value: `non-optimistic insert` },
-      { optimistic: false }
+      { optimistic: false },
     )
 
     // Debug: Check the mutation was created with optimistic: false
@@ -810,7 +1001,7 @@ describe(`Collection`, () => {
       { optimistic: false },
       (draft) => {
         draft.value = `non-optimistic update`
-      }
+      },
     )
 
     // The original value should still be there immediately
@@ -901,7 +1092,7 @@ describe(`Collection`, () => {
     // Test explicit optimistic: true
     const explicitOptimisticTx = collection.insert(
       { id: 3, value: `explicit optimistic` },
-      { optimistic: true }
+      { optimistic: true },
     )
 
     // The item should appear immediately
@@ -920,7 +1111,7 @@ describe(`Collection`, () => {
       { optimistic: true },
       (draft) => {
         draft.value = `optimistic update`
-      }
+      },
     )
 
     // The update should be reflected immediately
@@ -1212,7 +1403,7 @@ describe(`Collection`, () => {
       mockSyncCollectionOptionsNoInitialState<Row>({
         id: `repro-truncate-open-transaction`,
         getKey: (r) => r.id,
-      })
+      }),
     )
     const preloadPromise = collection.preload()
 
@@ -1355,6 +1546,116 @@ describe(`Collection`, () => {
     const state = await collection.stateWhenReady()
     expect(state.size).toBe(3)
   })
+
+  it(`should allow deleting a row by passing only the key to write function`, async () => {
+    let testSyncFunctions: any = null
+
+    const collection = createCollection<{ id: number; value: string }>({
+      id: `delete-by-key`,
+      getKey: (item) => item.id,
+      startSync: true,
+      sync: {
+        sync: ({ begin, write, commit, markReady }) => {
+          // Store the sync functions for testing
+          testSyncFunctions = { begin, write, commit, markReady }
+        },
+      },
+    })
+
+    // Collection should start in loading state
+    expect(collection.status).toBe(`loading`)
+    expect(collection.size).toBe(0)
+
+    const { begin, write, commit, markReady } = testSyncFunctions
+
+    // Insert some initial data
+    begin()
+    write({ type: `insert`, value: { id: 1, value: `item 1` } })
+    write({ type: `insert`, value: { id: 2, value: `item 2` } })
+    write({ type: `insert`, value: { id: 3, value: `item 3` } })
+    commit()
+
+    // Verify data was inserted
+    expect(collection.size).toBe(3)
+    expect(collection.state.get(1)).toEqual({ id: 1, value: `item 1` })
+    expect(collection.state.get(2)).toEqual({ id: 2, value: `item 2` })
+    expect(collection.state.get(3)).toEqual({ id: 3, value: `item 3` })
+
+    // Delete a row by passing only the key (no value)
+    begin()
+    write({ type: `delete`, key: 2 })
+    commit()
+
+    // Verify the row is gone
+    expect(collection.size).toBe(2)
+    expect(collection.state.get(1)).toEqual({ id: 1, value: `item 1` })
+    expect(collection.state.get(2)).toBeUndefined()
+    expect(collection.state.get(3)).toEqual({ id: 3, value: `item 3` })
+
+    // Delete another row by key only
+    begin()
+    write({ type: `delete`, key: 1 })
+    commit()
+
+    // Verify both rows are gone
+    expect(collection.size).toBe(1)
+    expect(collection.state.get(1)).toBeUndefined()
+    expect(collection.state.get(2)).toBeUndefined()
+    expect(collection.state.get(3)).toEqual({ id: 3, value: `item 3` })
+
+    // Mark as ready
+    markReady()
+
+    // Verify final state
+    expect(collection.status).toBe(`ready`)
+    expect(collection.size).toBe(1)
+    expect(Array.from(collection.state.keys())).toEqual([3])
+  })
+
+  it(`should allow deleting a row by key with string keys`, async () => {
+    let testSyncFunctions: any = null
+
+    const collection = createCollection<{ id: string; name: string }>({
+      id: `delete-by-string-key`,
+      getKey: (item) => item.id,
+      startSync: true,
+      sync: {
+        sync: ({ begin, write, commit, markReady }) => {
+          // Store the sync functions for testing
+          testSyncFunctions = { begin, write, commit, markReady }
+        },
+      },
+    })
+
+    const { begin, write, commit, markReady } = testSyncFunctions
+
+    // Insert initial data
+    begin()
+    write({ type: `insert`, value: { id: `a`, name: `Alice` } })
+    write({ type: `insert`, value: { id: `b`, name: `Bob` } })
+    write({ type: `insert`, value: { id: `c`, name: `Charlie` } })
+    commit()
+
+    // Verify data was inserted
+    expect(collection.size).toBe(3)
+    expect(collection.state.get(`a`)).toEqual({ id: `a`, name: `Alice` })
+    expect(collection.state.get(`b`)).toEqual({ id: `b`, name: `Bob` })
+    expect(collection.state.get(`c`)).toEqual({ id: `c`, name: `Charlie` })
+
+    // Delete by key only
+    begin()
+    write({ type: `delete`, key: `b` })
+    commit()
+
+    // Verify the row is gone
+    expect(collection.size).toBe(2)
+    expect(collection.state.get(`a`)).toEqual({ id: `a`, name: `Alice` })
+    expect(collection.state.get(`b`)).toBeUndefined()
+    expect(collection.state.get(`c`)).toEqual({ id: `c`, name: `Charlie` })
+
+    markReady()
+    expect(collection.status).toBe(`ready`)
+  })
 })
 
 describe(`Collection isLoadingSubset property`, () => {
diff --git a/packages/db/tests/comparison.property.test.ts b/packages/db/tests/comparison.property.test.ts
new file mode 100644
index 000000000..dd6279001
--- /dev/null
+++ b/packages/db/tests/comparison.property.test.ts
@@ -0,0 +1,448 @@
+import { describe, expect } from 'vitest'
+import { fc, test as fcTest } from '@fast-check/vitest'
+import {
+  areValuesEqual,
+  ascComparator,
+  descComparator,
+  makeComparator,
+  normalizeValue,
+} from '../src/utils/comparison'
+import type { CompareOptions } from '../src/query/builder/types'
+
+/**
+ * Property-based tests for comparison functions
+ *
+ * A valid comparator must satisfy:
+ * 1. Consistency: compare(a, b) always returns the same value
+ * 2. Antisymmetry: sign(compare(a, b)) === -sign(compare(b, a))
+ * 3. Transitivity: if compare(a, b) <= 0 and compare(b, c) <= 0 then compare(a, c) <= 0
+ * 4. Reflexivity: compare(a, a) === 0
+ *
+ * Note: Object comparison uses stable IDs based on creation order, which means
+ * comparing two different object instances has order-dependent behavior.
+ * These tests focus on primitives, dates, and arrays where comparison is deterministic.
+ */
+
+const defaultOpts: CompareOptions = {
+  direction: `asc`,
+  nulls: `first`,
+  stringSort: `locale`,
+}
+
+const lexicalOpts: CompareOptions = {
+  direction: `asc`,
+  nulls: `first`,
+  stringSort: `lexical`,
+}
+
+const nullsLastOpts: CompareOptions = {
+  direction: `asc`,
+  nulls: `last`,
+  stringSort: `locale`,
+}
+
+// Comparator-compatible values (primitives that can be compared deterministically)
+// Note: We exclude plain objects because they use stable IDs which are creation-order dependent
+const arbitraryComparablePrimitive = fc.oneof(
+  fc.string(),
+  fc.integer(),
+  fc.double({ noNaN: true, noDefaultInfinity: true }),
+  fc.boolean(),
+)
+
+const arbitraryDate = fc.date({ noInvalidDate: true })
+
+const arbitraryComparableArray = fc.array(arbitraryComparablePrimitive, {
+  maxLength: 5,
+})
+
+// Helper to get sign of a number
+const sign = (n: number): -1 | 0 | 1 => {
+  if (n < 0) return -1
+  if (n > 0) return 1
+  return 0
+}
+
+/**
+ * Check antisymmetry property: sign(compare(a, b)) === -sign(compare(b, a))
+ * This handles the +0/-0 JavaScript edge case where -0 !== 0 in Object.is
+ */
+const checkAntisymmetry = (ab: number, ba: number): boolean => {
+  const signAB = sign(ab)
+  const signBA = sign(ba)
+  // Both zero, or opposite signs
+  return (signAB === 0 && signBA === 0) || signAB === -signBA
+}
+
+// Same-type arbitraries for comparator tests (cross-type comparison is not guaranteed to be total ordering)
+const arbitrarySameTypeString = fc.tuple(fc.string(), fc.string())
+const arbitrarySameTypeInt = fc.tuple(fc.integer(), fc.integer())
+const arbitrarySameTypeDouble = fc.tuple(
+  fc.double({ noNaN: true, noDefaultInfinity: true }),
+  fc.double({ noNaN: true, noDefaultInfinity: true }),
+)
+const arbitrarySameTypeBool = fc.tuple(fc.boolean(), fc.boolean())
+const arbitrarySameTypeDate = fc.tuple(
+  fc.date({ noInvalidDate: true }),
+  fc.date({ noInvalidDate: true }),
+)
+const arbitrarySameTypeArray = fc.tuple(
+  fc.array(fc.integer(), { maxLength: 5 }),
+  fc.array(fc.integer(), { maxLength: 5 }),
+)
+
+// Pair of same-type comparable values
+const arbitrarySameTypePair = fc.oneof(
+  arbitrarySameTypeString,
+  arbitrarySameTypeInt,
+  arbitrarySameTypeDouble,
+  arbitrarySameTypeBool,
+  arbitrarySameTypeDate,
+  arbitrarySameTypeArray,
+)
+
+// Triple of same-type values for transitivity
+const arbitrarySameTypeTriple = fc.oneof(
+  fc.tuple(fc.integer(), fc.integer(), fc.integer()),
+  fc.tuple(fc.string(), fc.string(), fc.string()),
+  fc.tuple(
+    fc.double({ noNaN: true, noDefaultInfinity: true }),
+    fc.double({ noNaN: true, noDefaultInfinity: true }),
+    fc.double({ noNaN: true, noDefaultInfinity: true }),
+  ),
+)
+
+describe(`ascComparator property-based tests`, () => {
+  describe(`comparator laws`, () => {
+    fcTest.prop([arbitraryComparablePrimitive])(
+      `reflexivity: compare(a, a) === 0`,
+      (a) => {
+        expect(ascComparator(a, a, defaultOpts)).toBe(0)
+      },
+    )
+
+    fcTest.prop([arbitrarySameTypePair])(
+      `antisymmetry: sign(compare(a, b)) === -sign(compare(b, a)) for same types`,
+      ([a, b]) => {
+        const ab = ascComparator(a, b, defaultOpts)
+        const ba = ascComparator(b, a, defaultOpts)
+        expect(checkAntisymmetry(ab, ba)).toBe(true)
+      },
+    )
+
+    fcTest.prop([arbitrarySameTypeTriple])(
+      `transitivity: if a <= b and b <= c then a <= c (same types)`,
+      ([a, b, c]) => {
+        const ab = ascComparator(a, b, defaultOpts)
+        const bc = ascComparator(b, c, defaultOpts)
+        const ac = ascComparator(a, c, defaultOpts)
+
+        if (ab <= 0 && bc <= 0) {
+          expect(ac).toBeLessThanOrEqual(0)
+        }
+      },
+    )
+
+    fcTest.prop([arbitrarySameTypePair])(
+      `consistency: compare(a, b) always returns the same value`,
+      ([a, b]) => {
+        const result1 = ascComparator(a, b, defaultOpts)
+        const result2 = ascComparator(a, b, defaultOpts)
+        expect(result1).toBe(result2)
+      },
+    )
+  })
+
+  describe(`null handling`, () => {
+    fcTest.prop([arbitraryComparablePrimitive])(
+      `nulls first: null comes before any non-null value`,
+      (a) => {
+        expect(ascComparator(null, a, defaultOpts)).toBeLessThan(0)
+        expect(ascComparator(a, null, defaultOpts)).toBeGreaterThan(0)
+      },
+    )
+
+    fcTest.prop([arbitraryComparablePrimitive])(
+      `nulls last: null comes after any non-null value`,
+      (a) => {
+        expect(ascComparator(null, a, nullsLastOpts)).toBeGreaterThan(0)
+        expect(ascComparator(a, null, nullsLastOpts)).toBeLessThan(0)
+      },
+    )
+
+    fcTest.prop([fc.constant(null), fc.constant(null)])(
+      `null equals null`,
+      (a, b) => {
+        expect(ascComparator(a, b, defaultOpts)).toBe(0)
+      },
+    )
+
+    fcTest.prop([fc.constant(undefined), fc.constant(undefined)])(
+      `undefined equals undefined`,
+      (a, b) => {
+        expect(ascComparator(a, b, defaultOpts)).toBe(0)
+      },
+    )
+
+    fcTest.prop([
+      fc.constantFrom(null, undefined),
+      fc.constantFrom(null, undefined),
+    ])(`null and undefined are treated the same for comparison`, (a, b) => {
+      // Both null and undefined are treated as "null-ish" values
+      expect(ascComparator(a, b, defaultOpts)).toBe(0)
+    })
+  })
+
+  describe(`string comparison`, () => {
+    fcTest.prop([fc.string()])(
+      `locale sort: reflexivity holds for strings`,
+      (a) => {
+        expect(ascComparator(a, a, defaultOpts)).toBe(0)
+      },
+    )
+
+    fcTest.prop([fc.string(), fc.string()])(
+      `lexical sort: antisymmetry holds for strings`,
+      (a, b) => {
+        const ab = ascComparator(a, b, lexicalOpts)
+        const ba = ascComparator(b, a, lexicalOpts)
+        expect(checkAntisymmetry(ab, ba)).toBe(true)
+      },
+    )
+  })
+
+  describe(`array comparison`, () => {
+    fcTest.prop([arbitraryComparableArray])(
+      `reflexivity: compare(arr, arr) === 0`,
+      (arr) => {
+        expect(ascComparator(arr, arr, defaultOpts)).toBe(0)
+      },
+    )
+
+    fcTest.prop([arbitrarySameTypeArray])(
+      `antisymmetry for arrays of same element type`,
+      ([a, b]) => {
+        const ab = ascComparator(a, b, defaultOpts)
+        const ba = ascComparator(b, a, defaultOpts)
+        expect(checkAntisymmetry(ab, ba)).toBe(true)
+      },
+    )
+
+    fcTest.prop([fc.array(fc.integer(), { maxLength: 5 })])(
+      `arrays with same elements compare equal`,
+      (arr) => {
+        const copy = [...arr]
+        expect(ascComparator(arr, copy, defaultOpts)).toBe(0)
+      },
+    )
+
+    fcTest.prop([fc.array(fc.integer(), { minLength: 1, maxLength: 5 })])(
+      `shorter prefix array comes before longer array`,
+      (arr) => {
+        const prefix = arr.slice(0, -1)
+        if (prefix.length < arr.length) {
+          expect(ascComparator(prefix, arr, defaultOpts)).toBeLessThan(0)
+          expect(ascComparator(arr, prefix, defaultOpts)).toBeGreaterThan(0)
+        }
+      },
+    )
+  })
+
+  describe(`date comparison`, () => {
+    fcTest.prop([arbitraryDate])(
+      `reflexivity: compare(date, date) === 0`,
+      (date) => {
+        expect(ascComparator(date, date, defaultOpts)).toBe(0)
+      },
+    )
+
+    fcTest.prop([arbitraryDate, arbitraryDate])(
+      `antisymmetry for dates`,
+      (a, b) => {
+        const ab = ascComparator(a, b, defaultOpts)
+        const ba = ascComparator(b, a, defaultOpts)
+        expect(checkAntisymmetry(ab, ba)).toBe(true)
+      },
+    )
+
+    fcTest.prop([arbitraryDate])(
+      `dates with same time compare equal`,
+      (date) => {
+        const copy = new Date(date.getTime())
+        expect(ascComparator(date, copy, defaultOpts)).toBe(0)
+      },
+    )
+
+    fcTest.prop([
+      // Use bounded dates to avoid overflow when adding offset
+      fc.date({ min: new Date(0), max: new Date(`2100-01-01`) }),
+      fc.integer({ min: 1, max: 1000000 }),
+    ])(`earlier date comes before later date`, (date, offset) => {
+      const later = new Date(date.getTime() + offset)
+      // Only test if the later date is valid
+      if (!isNaN(later.getTime())) {
+        expect(ascComparator(date, later, defaultOpts)).toBeLessThan(0)
+        expect(ascComparator(later, date, defaultOpts)).toBeGreaterThan(0)
+      }
+    })
+  })
+
+  describe(`number comparison`, () => {
+    fcTest.prop([fc.integer()])(`reflexivity for integers`, (n) => {
+      expect(ascComparator(n, n, defaultOpts)).toBe(0)
+    })
+
+    fcTest.prop([fc.double({ noNaN: true, noDefaultInfinity: true })])(
+      `reflexivity for doubles`,
+      (n) => {
+        expect(ascComparator(n, n, defaultOpts)).toBe(0)
+      },
+    )
+
+    fcTest.prop([fc.integer(), fc.integer()])(
+      `integer ordering is correct`,
+      (a, b) => {
+        const result = ascComparator(a, b, defaultOpts)
+        if (a < b) {
+          expect(result).toBeLessThan(0)
+        } else if (a > b) {
+          expect(result).toBeGreaterThan(0)
+        } else {
+          expect(result).toBe(0)
+        }
+      },
+    )
+  })
+})
+
+describe(`descComparator property-based tests`, () => {
+  fcTest.prop([arbitrarySameTypePair])(
+    `descComparator reverses ascComparator ordering (same types)`,
+    ([a, b]) => {
+      const asc = ascComparator(a, b, defaultOpts)
+      const desc = descComparator(a, b, defaultOpts)
+      expect(checkAntisymmetry(asc, desc)).toBe(true)
+    },
+  )
+
+  fcTest.prop([arbitraryComparablePrimitive])(
+    `reflexivity: descComparator(a, a) === 0`,
+    (a) => {
+      expect(descComparator(a, a, defaultOpts)).toBe(0)
+    },
+  )
+
+  fcTest.prop([fc.integer({ min: 1 })])(
+    `nulls first in desc: null sorts before non-null values`,
+    (a) => {
+      // With nulls: 'first', null should come before non-null values in sorted output
+      // If compare(a, b) < 0, then a comes before b in the result
+      const result = descComparator(null, a, defaultOpts)
+      expect(result).toBeLessThan(0)
+    },
+  )
+})
+
+describe(`makeComparator property-based tests`, () => {
+  fcTest.prop([
+    arbitrarySameTypePair,
+    fc.constantFrom(`asc`, `desc`),
+    fc.constantFrom(`first`, `last`),
+  ])(
+    `makeComparator produces valid comparator for any options (same types)`,
+    ([a, b], direction, nulls) => {
+      const opts: CompareOptions = {
+        direction: direction as `asc` | `desc`,
+        nulls: nulls as `first` | `last`,
+        stringSort: `locale`,
+      }
+      const comparator = makeComparator(opts)
+
+      // Reflexivity
+      expect(comparator(a, a)).toBe(0)
+
+      // Antisymmetry
+      const ab = comparator(a, b)
+      const ba = comparator(b, a)
+      expect(checkAntisymmetry(ab, ba)).toBe(true)
+    },
+  )
+})
+
+describe(`normalizeValue property-based tests`, () => {
+  fcTest.prop([arbitraryDate])(`dates normalize to their timestamp`, (date) => {
+    expect(normalizeValue(date)).toBe(date.getTime())
+  })
+
+  fcTest.prop([fc.uint8Array({ minLength: 0, maxLength: 128 })])(
+    `small Uint8Arrays normalize to string representation`,
+    (arr) => {
+      const normalized = normalizeValue(arr)
+      expect(typeof normalized).toBe(`string`)
+      expect(normalized).toMatch(/^__u8__/)
+    },
+  )
+
+  fcTest.prop([fc.uint8Array({ minLength: 129, maxLength: 200 })])(
+    `large Uint8Arrays are not normalized`,
+    (arr) => {
+      const normalized = normalizeValue(arr)
+      expect(normalized).toBe(arr)
+    },
+  )
+
+  fcTest.prop([fc.string()])(`strings pass through unchanged`, (str) => {
+    expect(normalizeValue(str)).toBe(str)
+  })
+
+  fcTest.prop([fc.integer()])(`integers pass through unchanged`, (n) => {
+    expect(normalizeValue(n)).toBe(n)
+  })
+
+  fcTest.prop([fc.uint8Array({ minLength: 0, maxLength: 128 })])(
+    `normalization is idempotent for Uint8Arrays`,
+    (arr) => {
+      const normalized1 = normalizeValue(arr)
+      // For strings (which small arrays become), normalizing again should be identity
+      expect(normalizeValue(normalized1)).toBe(normalized1)
+    },
+  )
+})
+
+describe(`areValuesEqual property-based tests`, () => {
+  fcTest.prop([fc.uint8Array({ minLength: 0, maxLength: 50 })])(
+    `Uint8Arrays with same content are equal`,
+    (arr) => {
+      const copy = new Uint8Array(arr)
+      expect(areValuesEqual(arr, copy)).toBe(true)
+    },
+  )
+
+  fcTest.prop([
+    fc.uint8Array({ minLength: 1, maxLength: 50 }),
+    fc.integer({ min: 0, max: 49 }),
+    fc.integer({ min: 0, max: 255 }),
+  ])(
+    `Uint8Arrays with different content are not equal`,
+    (arr, index, newValue) => {
+      if (index < arr.length && arr[index] !== newValue) {
+        const modified = new Uint8Array(arr)
+        modified[index] = newValue
+        expect(areValuesEqual(arr, modified)).toBe(false)
+      }
+    },
+  )
+
+  fcTest.prop([fc.integer()])(`reference equality for primitives`, (n) => {
+    expect(areValuesEqual(n, n)).toBe(true)
+  })
+
+  fcTest.prop([fc.integer(), fc.integer()])(
+    `different integers are not equal`,
+    (a, b) => {
+      if (a !== b) {
+        expect(areValuesEqual(a, b)).toBe(false)
+      }
+    },
+  )
+})
diff --git a/packages/db/tests/cursor.property.test.ts b/packages/db/tests/cursor.property.test.ts
new file mode 100644
index 000000000..04c2fa536
--- /dev/null
+++ b/packages/db/tests/cursor.property.test.ts
@@ -0,0 +1,370 @@
+import { describe, expect, it } from 'vitest'
+import { fc, test as fcTest } from '@fast-check/vitest'
+import { buildCursor } from '../src/utils/cursor'
+import { Func, PropRef, Value } from '../src/query/ir'
+import type { OrderBy, OrderByClause } from '../src/query/ir'
+import type { CompareOptions } from '../src/query/builder/types'
+
+/**
+ * Property-based tests for cursor building
+ *
+ * Key properties:
+ * 1. Empty inputs return undefined
+ * 2. Single column produces simple gt/lt based on direction
+ * 3. Direction affects operator choice (asc = gt, desc = lt)
+ * 4. Determinism - same inputs always produce same output
+ * 5. Result structure is always valid
+ */
+
+// Arbitraries for generating test data
+const arbitraryDirection = fc.constantFrom(`asc`, `desc`)
+
+const arbitraryNulls = fc.constantFrom(`first`, `last`)
+
+const arbitraryStringSort = fc.constantFrom(`locale`, `lexical`)
+
+const arbitraryCompareOptions = fc.record({
+  direction: arbitraryDirection,
+  nulls: arbitraryNulls,
+  stringSort: arbitraryStringSort,
+}) as fc.Arbitrary<CompareOptions>
+
+const arbitraryPropRef = fc
+  .array(fc.string({ minLength: 1, maxLength: 10 }), {
+    minLength: 1,
+    maxLength: 3,
+  })
+  .map((path) => new PropRef(path))
+
+const arbitraryOrderByClause = fc
+  .tuple(arbitraryPropRef, arbitraryCompareOptions)
+  .map(
+    ([expr, compareOptions]): OrderByClause => ({
+      expression: expr,
+      compareOptions,
+    }),
+  )
+
+const arbitraryOrderBy = (
+  minLength: number,
+  maxLength: number,
+): fc.Arbitrary<OrderBy> =>
+  fc.array(arbitraryOrderByClause, { minLength, maxLength })
+
+const arbitraryValue = fc.oneof(
+  fc.string(),
+  fc.integer(),
+  fc.double({ noNaN: true }),
+  fc.boolean(),
+  fc.constant(null),
+)
+
+const arbitraryValues = (
+  minLength: number,
+  maxLength: number,
+): fc.Arbitrary<Array<unknown>> =>
+  fc.array(arbitraryValue, { minLength, maxLength })
+
+// Helper to check if result is a Func
+function isFunc(expr: unknown): expr is Func {
+  return expr instanceof Func
+}
+
+// Helper to get operator name from Func
+function getFuncName(expr: Func): string {
+  return expr.name
+}
+
+// Helper to recursively count operators in an expression
+function countOperators(expr: unknown, name: string): number {
+  if (!isFunc(expr)) return 0
+  const selfCount = expr.name === name ? 1 : 0
+  return (
+    selfCount +
+    expr.args.reduce((sum, arg) => sum + countOperators(arg, name), 0)
+  )
+}
+
+describe(`buildCursor property-based tests`, () => {
+  describe(`empty input handling`, () => {
+    fcTest.prop([arbitraryOrderBy(0, 5)])(
+      `returns undefined for empty values array`,
+      (orderBy) => {
+        const result = buildCursor(orderBy, [])
+        expect(result).toBeUndefined()
+      },
+    )
+
+    fcTest.prop([arbitraryValues(0, 5)])(
+      `returns undefined for empty orderBy array`,
+      (values) => {
+        const result = buildCursor([], values)
+        expect(result).toBeUndefined()
+      },
+    )
+
+    it(`returns undefined for both empty`, () => {
+      expect(buildCursor([], [])).toBeUndefined()
+    })
+  })
+
+  describe(`single column cursor`, () => {
+    fcTest.prop([arbitraryOrderByClause, arbitraryValue])(
+      `produces a simple comparison for single column`,
+      (clause, value) => {
+        const result = buildCursor([clause], [value])
+
+        expect(result).toBeDefined()
+        expect(isFunc(result!)).toBe(true)
+
+        // Should be either 'gt' or 'lt' based on direction
+        const func = result as Func
+        expect([`gt`, `lt`]).toContain(getFuncName(func))
+      },
+    )
+
+    fcTest.prop([
+      arbitraryPropRef,
+      arbitraryNulls,
+      arbitraryStringSort,
+      arbitraryValue,
+    ])(
+      `ascending direction produces gt operator`,
+      (expr, nulls, stringSort, value) => {
+        const clause: OrderByClause = {
+          expression: expr,
+          compareOptions: {
+            direction: `asc`,
+            nulls: nulls as `first` | `last`,
+            stringSort: stringSort as `locale` | `lexical`,
+          },
+        }
+        const result = buildCursor([clause], [value])
+
+        expect(result).toBeDefined()
+        expect(getFuncName(result as Func)).toBe(`gt`)
+      },
+    )
+
+    fcTest.prop([
+      arbitraryPropRef,
+      arbitraryNulls,
+      arbitraryStringSort,
+      arbitraryValue,
+    ])(
+      `descending direction produces lt operator`,
+      (expr, nulls, stringSort, value) => {
+        const clause: OrderByClause = {
+          expression: expr,
+          compareOptions: {
+            direction: `desc`,
+            nulls: nulls as `first` | `last`,
+            stringSort: stringSort as `locale` | `lexical`,
+          },
+        }
+        const result = buildCursor([clause], [value])
+
+        expect(result).toBeDefined()
+        expect(getFuncName(result as Func)).toBe(`lt`)
+      },
+    )
+  })
+
+  describe(`multi-column cursor structure`, () => {
+    fcTest.prop([arbitraryOrderBy(2, 4), arbitraryValues(2, 4)])(
+      `multi-column produces or at top level when matching lengths`,
+      (orderBy, values) => {
+        // Ensure we have matching lengths for a valid multi-column cursor
+        const minLen = Math.min(orderBy.length, values.length)
+        if (minLen < 2) return // Skip if not enough for multi-column
+
+        const trimmedOrderBy = orderBy.slice(0, minLen)
+        const trimmedValues = values.slice(0, minLen)
+
+        const result = buildCursor(trimmedOrderBy, trimmedValues)
+
+        expect(result).toBeDefined()
+        expect(isFunc(result!)).toBe(true)
+
+        // For 2+ columns, top level should be 'or'
+        const func = result as Func
+        expect(getFuncName(func)).toBe(`or`)
+      },
+    )
+
+    fcTest.prop([
+      fc.tuple(arbitraryOrderByClause, arbitraryOrderByClause),
+      fc.tuple(arbitraryValue, arbitraryValue),
+    ])(
+      `two columns produces correct structure`,
+      ([clause1, clause2], [val1, val2]) => {
+        const result = buildCursor([clause1, clause2], [val1, val2])
+
+        expect(result).toBeDefined()
+        const func = result as Func
+
+        // Top level should be 'or'
+        expect(getFuncName(func)).toBe(`or`)
+
+        // Should have structure: or(comparison1, and(eq, comparison2))
+        expect(func.args).toHaveLength(2)
+
+        // First arg should be direct gt/lt
+        expect(isFunc(func.args[0])).toBe(true)
+        expect([`gt`, `lt`]).toContain(getFuncName(func.args[0] as Func))
+
+        // Second arg should be 'and' combining eq and comparison
+        expect(isFunc(func.args[1])).toBe(true)
+        expect(getFuncName(func.args[1] as Func)).toBe(`and`)
+      },
+    )
+  })
+
+  describe(`determinism`, () => {
+    fcTest.prop([arbitraryOrderBy(1, 3), arbitraryValues(1, 3)])(
+      `buildCursor is deterministic`,
+      (orderBy, values) => {
+        const result1 = buildCursor(orderBy, values)
+        const result2 = buildCursor(orderBy, values)
+
+        // Both should be defined or both undefined
+        expect(result1 === undefined).toBe(result2 === undefined)
+
+        if (result1 !== undefined && result2 !== undefined) {
+          // Compare structure by JSON representation
+          expect(JSON.stringify(result1)).toBe(JSON.stringify(result2))
+        }
+      },
+    )
+  })
+
+  describe(`value preservation`, () => {
+    fcTest.prop([arbitraryOrderByClause, arbitraryValue])(
+      `cursor contains the provided value`,
+      (clause, value) => {
+        const result = buildCursor([clause], [value])
+
+        expect(result).toBeDefined()
+        const func = result as Func
+
+        // Second argument should be a Value containing our value
+        expect(func.args[1]).toBeInstanceOf(Value)
+        expect((func.args[1] as Value).value).toBe(value)
+      },
+    )
+
+    fcTest.prop([arbitraryOrderByClause, arbitraryValue])(
+      `cursor references the correct property`,
+      (clause, value) => {
+        const result = buildCursor([clause], [value])
+
+        expect(result).toBeDefined()
+        const func = result as Func
+
+        // First argument should be the same PropRef
+        expect(func.args[0]).toBeInstanceOf(PropRef)
+        expect((func.args[0] as PropRef).path).toEqual(
+          (clause.expression as PropRef).path,
+        )
+      },
+    )
+  })
+
+  describe(`length mismatch handling`, () => {
+    fcTest.prop([arbitraryOrderBy(3, 5), arbitraryValues(1, 2)])(
+      `handles more orderBy columns than values gracefully`,
+      (orderBy, values) => {
+        // Should use the minimum of the two lengths
+        const result = buildCursor(orderBy, values)
+
+        if (values.length === 0) {
+          expect(result).toBeUndefined()
+        } else {
+          expect(result).toBeDefined()
+          expect(isFunc(result!)).toBe(true)
+        }
+      },
+    )
+
+    fcTest.prop([arbitraryOrderBy(1, 2), arbitraryValues(3, 5)])(
+      `handles more values than orderBy columns gracefully`,
+      (orderBy, values) => {
+        // Should use the minimum of the two lengths
+        const result = buildCursor(orderBy, values)
+
+        if (orderBy.length === 0) {
+          expect(result).toBeUndefined()
+        } else {
+          expect(result).toBeDefined()
+          expect(isFunc(result!)).toBe(true)
+        }
+      },
+    )
+  })
+
+  describe(`operator consistency`, () => {
+    fcTest.prop([
+      fc.array(
+        fc.tuple(arbitraryPropRef, arbitraryNulls, arbitraryStringSort),
+        { minLength: 2, maxLength: 4 },
+      ),
+      arbitraryValues(2, 4),
+    ])(`all ascending columns use gt operators`, (clauseParts, values) => {
+      const orderBy: OrderBy = clauseParts.map(([expr, nulls, stringSort]) => ({
+        expression: expr,
+        compareOptions: {
+          direction: `asc` as const,
+          nulls: nulls as `first` | `last`,
+          stringSort: stringSort as `locale` | `lexical`,
+        },
+      }))
+
+      const minLen = Math.min(orderBy.length, values.length)
+      const result = buildCursor(
+        orderBy.slice(0, minLen),
+        values.slice(0, minLen),
+      )
+
+      if (result) {
+        // Count gt operators - should equal number of columns
+        const gtCount = countOperators(result, `gt`)
+        expect(gtCount).toBe(minLen)
+        // Should have no lt operators
+        const ltCount = countOperators(result, `lt`)
+        expect(ltCount).toBe(0)
+      }
+    })
+
+    fcTest.prop([
+      fc.array(
+        fc.tuple(arbitraryPropRef, arbitraryNulls, arbitraryStringSort),
+        { minLength: 2, maxLength: 4 },
+      ),
+      arbitraryValues(2, 4),
+    ])(`all descending columns use lt operators`, (clauseParts, values) => {
+      const orderBy: OrderBy = clauseParts.map(([expr, nulls, stringSort]) => ({
+        expression: expr,
+        compareOptions: {
+          direction: `desc` as const,
+          nulls: nulls as `first` | `last`,
+          stringSort: stringSort as `locale` | `lexical`,
+        },
+      }))
+
+      const minLen = Math.min(orderBy.length, values.length)
+      const result = buildCursor(
+        orderBy.slice(0, minLen),
+        values.slice(0, minLen),
+      )
+
+      if (result) {
+        // Count lt operators - should equal number of columns
+        const ltCount = countOperators(result, `lt`)
+        expect(ltCount).toBe(minLen)
+        // Should have no gt operators
+        const gtCount = countOperators(result, `gt`)
+        expect(gtCount).toBe(0)
+      }
+    })
+  })
+})
diff --git a/packages/db/tests/cursor.test.ts b/packages/db/tests/cursor.test.ts
new file mode 100644
index 000000000..5d8f4a2f4
--- /dev/null
+++ b/packages/db/tests/cursor.test.ts
@@ -0,0 +1,226 @@
+import { describe, expect, it } from 'vitest'
+import { buildCursor } from '../src/utils/cursor.js'
+import { Func, PropRef, Value } from '../src/query/ir.js'
+import type { OrderBy, OrderByClause } from '../src/query/ir.js'
+import type { CompareOptions } from '../src/query/builder/types.js'
+
+// Helper to create an OrderByClause for testing
+function createOrderByClause(
+  path: string,
+  direction: `asc` | `desc`,
+): OrderByClause {
+  const compareOptions: CompareOptions = {
+    direction,
+    nulls: direction === `asc` ? `first` : `last`,
+  }
+  return {
+    expression: new PropRef([`t`, path]),
+    compareOptions,
+  }
+}
+
+// Helper to check if a Func has the expected structure
+function isFuncWithName(expr: unknown, name: string): expr is Func {
+  return expr instanceof Func && expr.name === name
+}
+
+describe(`buildCursor`, () => {
+  describe(`edge cases`, () => {
+    it(`returns undefined for empty values array`, () => {
+      const orderBy: OrderBy = [createOrderByClause(`col1`, `asc`)]
+      expect(buildCursor(orderBy, [])).toBeUndefined()
+    })
+
+    it(`returns undefined for empty orderBy array`, () => {
+      expect(buildCursor([], [1, 2, 3])).toBeUndefined()
+    })
+
+    it(`returns undefined for both empty`, () => {
+      expect(buildCursor([], [])).toBeUndefined()
+    })
+  })
+
+  describe(`single column`, () => {
+    it(`produces gt() for ASC direction`, () => {
+      const orderBy: OrderBy = [createOrderByClause(`col1`, `asc`)]
+      const result = buildCursor(orderBy, [10])
+
+      expect(result).toBeInstanceOf(Func)
+      expect(isFuncWithName(result, `gt`)).toBe(true)
+
+      const func = result as Func
+      expect(func.args).toHaveLength(2)
+      expect(func.args[0]).toBeInstanceOf(PropRef)
+      expect((func.args[0] as PropRef).path).toEqual([`t`, `col1`])
+      expect(func.args[1]).toBeInstanceOf(Value)
+      expect((func.args[1] as Value).value).toBe(10)
+    })
+
+    it(`produces lt() for DESC direction`, () => {
+      const orderBy: OrderBy = [createOrderByClause(`col1`, `desc`)]
+      const result = buildCursor(orderBy, [10])
+
+      expect(result).toBeInstanceOf(Func)
+      expect(isFuncWithName(result, `lt`)).toBe(true)
+
+      const func = result as Func
+      expect(func.args).toHaveLength(2)
+      expect(func.args[0]).toBeInstanceOf(PropRef)
+      expect((func.args[0] as PropRef).path).toEqual([`t`, `col1`])
+      expect(func.args[1]).toBeInstanceOf(Value)
+      expect((func.args[1] as Value).value).toBe(10)
+    })
+
+    it(`handles string cursor values`, () => {
+      const orderBy: OrderBy = [createOrderByClause(`name`, `asc`)]
+      const result = buildCursor(orderBy, [`alice`])
+
+      expect(result).toBeInstanceOf(Func)
+      const func = result as Func
+      expect(func.args[1]).toBeInstanceOf(Value)
+      expect((func.args[1] as Value).value).toBe(`alice`)
+    })
+
+    it(`handles null cursor values`, () => {
+      const orderBy: OrderBy = [createOrderByClause(`col1`, `asc`)]
+      const result = buildCursor(orderBy, [null])
+
+      expect(result).toBeInstanceOf(Func)
+      const func = result as Func
+      expect((func.args[1] as Value).value).toBeNull()
+    })
+  })
+
+  describe(`multi-column composite cursor`, () => {
+    it(`produces or(gt(col1), and(eq(col1), gt(col2))) for two ASC columns`, () => {
+      const orderBy: OrderBy = [
+        createOrderByClause(`col1`, `asc`),
+        createOrderByClause(`col2`, `asc`),
+      ]
+      const result = buildCursor(orderBy, [10, 20])
+
+      // Should be: or(gt(col1, 10), and(eq(col1, 10), gt(col2, 20)))
+      expect(result).toBeInstanceOf(Func)
+      expect(isFuncWithName(result, `or`)).toBe(true)
+
+      const orFunc = result as Func
+      expect(orFunc.args).toHaveLength(2)
+
+      // First arg: gt(col1, 10)
+      const gtCol1 = orFunc.args[0]
+      expect(isFuncWithName(gtCol1, `gt`)).toBe(true)
+      expect((gtCol1 as Func).args[0]).toBeInstanceOf(PropRef)
+      expect(((gtCol1 as Func).args[0] as PropRef).path).toEqual([`t`, `col1`])
+      expect(((gtCol1 as Func).args[1] as Value).value).toBe(10)
+
+      // Second arg: and(eq(col1, 10), gt(col2, 20))
+      const andClause = orFunc.args[1]
+      expect(isFuncWithName(andClause, `and`)).toBe(true)
+      const andFunc = andClause as Func
+      expect(andFunc.args).toHaveLength(2)
+
+      // eq(col1, 10)
+      expect(isFuncWithName(andFunc.args[0], `eq`)).toBe(true)
+      const eqCol1 = andFunc.args[0] as Func
+      expect((eqCol1.args[0] as PropRef).path).toEqual([`t`, `col1`])
+      expect((eqCol1.args[1] as Value).value).toBe(10)
+
+      // gt(col2, 20)
+      expect(isFuncWithName(andFunc.args[1], `gt`)).toBe(true)
+      const gtCol2 = andFunc.args[1] as Func
+      expect((gtCol2.args[0] as PropRef).path).toEqual([`t`, `col2`])
+      expect((gtCol2.args[1] as Value).value).toBe(20)
+    })
+
+    it(`handles mixed ASC/DESC directions`, () => {
+      const orderBy: OrderBy = [
+        createOrderByClause(`col1`, `asc`),
+        createOrderByClause(`col2`, `desc`),
+      ]
+      const result = buildCursor(orderBy, [10, 20])
+
+      // Should be: or(gt(col1, 10), and(eq(col1, 10), lt(col2, 20)))
+      expect(isFuncWithName(result, `or`)).toBe(true)
+
+      const orFunc = result as Func
+      const andClause = orFunc.args[1] as Func
+
+      // Second column should use lt() for DESC
+      expect(isFuncWithName(andClause.args[1], `lt`)).toBe(true)
+    })
+
+    it(`handles three columns correctly`, () => {
+      const orderBy: OrderBy = [
+        createOrderByClause(`col1`, `asc`),
+        createOrderByClause(`col2`, `asc`),
+        createOrderByClause(`col3`, `desc`),
+      ]
+      const result = buildCursor(orderBy, [1, 2, 3])
+
+      // Should be: or(
+      //   gt(col1, 1),
+      //   and(eq(col1, 1), gt(col2, 2)),
+      //   and(eq(col1, 1), eq(col2, 2), lt(col3, 3))
+      // )
+      expect(isFuncWithName(result, `or`)).toBe(true)
+
+      const outerOr = result as Func
+      // The structure is: or(or(gt, and), and) due to reduce
+      expect(outerOr.args).toHaveLength(2)
+
+      // First arg is or(gt(col1, 1), and(eq(col1, 1), gt(col2, 2)))
+      const innerOr = outerOr.args[0]
+      expect(isFuncWithName(innerOr, `or`)).toBe(true)
+
+      // Second arg is and(and(eq(col1, 1), eq(col2, 2)), lt(col3, 3))
+      const thirdClause = outerOr.args[1]
+      expect(isFuncWithName(thirdClause, `and`)).toBe(true)
+
+      // The innermost and should have eq conditions and lt for col3
+      const innerAnd = thirdClause as Func
+      // Due to reduce, the structure is nested: and(and(eq, eq), lt)
+      expect(isFuncWithName(innerAnd.args[1], `lt`)).toBe(true)
+      const ltCol3 = innerAnd.args[1] as Func
+      expect((ltCol3.args[0] as PropRef).path).toEqual([`t`, `col3`])
+      expect((ltCol3.args[1] as Value).value).toBe(3)
+    })
+  })
+
+  describe(`partial values`, () => {
+    it(`handles fewer values than orderBy columns`, () => {
+      const orderBy: OrderBy = [
+        createOrderByClause(`col1`, `asc`),
+        createOrderByClause(`col2`, `asc`),
+        createOrderByClause(`col3`, `asc`),
+      ]
+      const result = buildCursor(orderBy, [10, 20])
+
+      // Should only use first two columns
+      expect(isFuncWithName(result, `or`)).toBe(true)
+
+      const orFunc = result as Func
+      expect(orFunc.args).toHaveLength(2)
+
+      // First clause: gt(col1, 10)
+      expect(isFuncWithName(orFunc.args[0], `gt`)).toBe(true)
+
+      // Second clause: and(eq(col1, 10), gt(col2, 20))
+      expect(isFuncWithName(orFunc.args[1], `and`)).toBe(true)
+    })
+
+    it(`handles single value for multi-column orderBy`, () => {
+      const orderBy: OrderBy = [
+        createOrderByClause(`col1`, `asc`),
+        createOrderByClause(`col2`, `asc`),
+      ]
+      const result = buildCursor(orderBy, [10])
+
+      // Should just be gt(col1, 10) since only one value provided
+      expect(isFuncWithName(result, `gt`)).toBe(true)
+
+      const gtFunc = result as Func
+      expect((gtFunc.args[0] as PropRef).path).toEqual([`t`, `col1`])
+      expect((gtFunc.args[1] as Value).value).toBe(10)
+    })
+  })
+})
diff --git a/packages/db/tests/deferred.test.ts b/packages/db/tests/deferred.test.ts
index ad5b285e3..4897e30ed 100644
--- a/packages/db/tests/deferred.test.ts
+++ b/packages/db/tests/deferred.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest"
-import { createDeferred } from "../src/deferred"
-import type { Deferred } from "../src/deferred"
+import { describe, expect, it } from 'vitest'
+import { createDeferred } from '../src/deferred'
+import type { Deferred } from '../src/deferred'
 
 describe(`Deferred`, () => {
   it(`should create a deferred object with the correct shape`, () => {
diff --git a/packages/db/tests/deterministic-ordering.test.ts b/packages/db/tests/deterministic-ordering.test.ts
new file mode 100644
index 000000000..f25e3db93
--- /dev/null
+++ b/packages/db/tests/deterministic-ordering.test.ts
@@ -0,0 +1,398 @@
+import { describe, expect, it } from 'vitest'
+import { SortedMap } from '../src/SortedMap'
+import { BTreeIndex } from '../src/indexes/btree-index'
+import { createCollection } from '../src/collection/index.js'
+import { PropRef } from '../src/query/ir'
+import { mockSyncCollectionOptions } from './utils'
+
+/**
+ * These tests verify deterministic ordering behavior when values compare as equal.
+ *
+ * The issue: When multiple items have the same "sort value" (e.g., same priority),
+ * their relative ordering should be deterministic and stable based on their key.
+ * Without key-based tie-breaking, the order depends on insertion order, which
+ * can vary between page loads, sync operations, etc.
+ */
+
+describe(`Deterministic Ordering`, () => {
+  describe(`SortedMap`, () => {
+    it(`should maintain deterministic order when values are equal`, () => {
+      // All values are the same (priority = 1), so they compare as equal
+      const map = new SortedMap<string, { priority: number }>(
+        (a, b) => a.priority - b.priority,
+      )
+
+      // Insert in "random" order
+      map.set(`c`, { priority: 1 })
+      map.set(`a`, { priority: 1 })
+      map.set(`b`, { priority: 1 })
+
+      // With key-based tie-breaking, should always iterate in key order: a, b, c
+      const keys = Array.from(map.keys())
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+
+    it(`should maintain deterministic order with mixed equal and different values`, () => {
+      const map = new SortedMap<string, { priority: number }>(
+        (a, b) => a.priority - b.priority,
+      )
+
+      // Mix of equal and different priorities
+      map.set(`d`, { priority: 2 })
+      map.set(`c`, { priority: 1 })
+      map.set(`a`, { priority: 1 })
+      map.set(`e`, { priority: 2 })
+      map.set(`b`, { priority: 1 })
+
+      // Expected: priority 1 items (a, b, c) sorted by key, then priority 2 items (d, e) sorted by key
+      const keys = Array.from(map.keys())
+      expect(keys).toEqual([`a`, `b`, `c`, `d`, `e`])
+    })
+
+    it(`should maintain deterministic order with numeric keys`, () => {
+      const map = new SortedMap<number, { priority: number }>(
+        (a, b) => a.priority - b.priority,
+      )
+
+      map.set(30, { priority: 1 })
+      map.set(10, { priority: 1 })
+      map.set(20, { priority: 1 })
+
+      const keys = Array.from(map.keys())
+      expect(keys).toEqual([10, 20, 30])
+    })
+
+    it(`should maintain deterministic order after updates`, () => {
+      const map = new SortedMap<string, { priority: number }>(
+        (a, b) => a.priority - b.priority,
+      )
+
+      map.set(`c`, { priority: 1 })
+      map.set(`a`, { priority: 1 })
+      map.set(`b`, { priority: 1 })
+
+      // Update 'b' with same priority
+      map.set(`b`, { priority: 1 })
+
+      const keys = Array.from(map.keys())
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+
+    it(`should maintain deterministic order after delete and re-insert`, () => {
+      const map = new SortedMap<string, { priority: number }>(
+        (a, b) => a.priority - b.priority,
+      )
+
+      map.set(`c`, { priority: 1 })
+      map.set(`a`, { priority: 1 })
+      map.set(`b`, { priority: 1 })
+
+      map.delete(`b`)
+      map.set(`b`, { priority: 1 })
+
+      const keys = Array.from(map.keys())
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+
+    it(`should use key as tie-breaker even without custom comparator`, () => {
+      // When no comparator is provided, all items have "equal" sort value (default behavior)
+      // They should still be ordered by key
+      const map = new SortedMap<string, { name: string }>()
+
+      map.set(`c`, { name: `Charlie` })
+      map.set(`a`, { name: `Alice` })
+      map.set(`b`, { name: `Bob` })
+
+      const keys = Array.from(map.keys())
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+  })
+
+  describe(`BTreeIndex`, () => {
+    it(`should return keys in deterministic order when indexed values are equal`, () => {
+      const index = new BTreeIndex<string>(
+        1,
+        new PropRef([`priority`]),
+        `priority_index`,
+      )
+
+      // All have same priority
+      index.add(`c`, { priority: 1 })
+      index.add(`a`, { priority: 1 })
+      index.add(`b`, { priority: 1 })
+
+      // take() should return keys in key-sorted order when priorities are equal
+      const keys = index.take(3)
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+
+    it(`should return keys in deterministic order with mixed equal and different values`, () => {
+      const index = new BTreeIndex<string>(
+        1,
+        new PropRef([`priority`]),
+        `priority_index`,
+      )
+
+      index.add(`d`, { priority: 2 })
+      index.add(`c`, { priority: 1 })
+      index.add(`a`, { priority: 1 })
+      index.add(`e`, { priority: 2 })
+      index.add(`b`, { priority: 1 })
+
+      // take() should return priority 1 keys sorted by key, then priority 2 keys sorted by key
+      const keys = index.take(5)
+      expect(keys).toEqual([`a`, `b`, `c`, `d`, `e`])
+    })
+
+    it(`should return keys in deterministic order with numeric keys`, () => {
+      const index = new BTreeIndex<number>(
+        1,
+        new PropRef([`priority`]),
+        `priority_index`,
+      )
+
+      index.add(30, { priority: 1 })
+      index.add(10, { priority: 1 })
+      index.add(20, { priority: 1 })
+
+      const keys = index.take(3)
+      expect(keys).toEqual([10, 20, 30])
+    })
+
+    it(`should return keys in deterministic order for takeReversed`, () => {
+      const index = new BTreeIndex<string>(
+        1,
+        new PropRef([`priority`]),
+        `priority_index`,
+      )
+
+      index.add(`c`, { priority: 1 })
+      index.add(`a`, { priority: 1 })
+      index.add(`b`, { priority: 1 })
+
+      // takeReversed should return keys in reverse key order when priorities are equal
+      const keys = index.takeReversed(3)
+      expect(keys).toEqual([`c`, `b`, `a`])
+    })
+
+    it(`should maintain deterministic order after remove and re-add`, () => {
+      const index = new BTreeIndex<string>(
+        1,
+        new PropRef([`priority`]),
+        `priority_index`,
+      )
+
+      index.add(`c`, { priority: 1 })
+      index.add(`a`, { priority: 1 })
+      index.add(`b`, { priority: 1 })
+
+      index.remove(`b`, { priority: 1 })
+      index.add(`b`, { priority: 1 })
+
+      const keys = index.take(3)
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+
+    it(`should return keys in deterministic order with take from cursor across different values`, () => {
+      const index = new BTreeIndex<string>(
+        1,
+        new PropRef([`priority`]),
+        `priority_index`,
+      )
+
+      // Add keys with different priorities
+      index.add(`e`, { priority: 2 })
+      index.add(`c`, { priority: 1 })
+      index.add(`a`, { priority: 1 })
+      index.add(`f`, { priority: 2 })
+      index.add(`d`, { priority: 2 })
+      index.add(`b`, { priority: 1 })
+
+      // First batch - should get priority 1 keys in key order
+      const firstBatch = index.take(3)
+      expect(firstBatch).toEqual([`a`, `b`, `c`])
+
+      // Continue from cursor value 1 (exclusive) - should get priority 2 keys in key order
+      const secondBatch = index.take(3, 1)
+      expect(secondBatch).toEqual([`d`, `e`, `f`])
+    })
+  })
+
+  describe(`Collection iteration`, () => {
+    it(`should iterate in deterministic order when compare function returns equal`, () => {
+      type Item = { id: string; priority: number }
+
+      const options = mockSyncCollectionOptions<Item>({
+        id: `test-collection`,
+        getKey: (item) => item.id,
+        initialData: [],
+      })
+
+      const collection = createCollection({
+        ...options,
+        // Compare by priority only - items with same priority compare as equal
+        compare: (a, b) => a.priority - b.priority,
+      })
+
+      // Insert via sync in "random" order
+      options.utils.begin()
+      options.utils.write({ type: `insert`, value: { id: `c`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `a`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `b`, priority: 1 } })
+      options.utils.commit()
+
+      // Should iterate in key order when priorities are equal
+      const keys = [...collection.keys()]
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+
+    it(`should iterate in deterministic order with mixed priorities`, () => {
+      type Item = { id: string; priority: number }
+
+      const options = mockSyncCollectionOptions<Item>({
+        id: `test-collection-mixed`,
+        getKey: (item) => item.id,
+        initialData: [],
+      })
+
+      const collection = createCollection({
+        ...options,
+        compare: (a, b) => a.priority - b.priority,
+      })
+
+      options.utils.begin()
+      options.utils.write({ type: `insert`, value: { id: `d`, priority: 2 } })
+      options.utils.write({ type: `insert`, value: { id: `c`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `a`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `e`, priority: 2 } })
+      options.utils.write({ type: `insert`, value: { id: `b`, priority: 1 } })
+      options.utils.commit()
+
+      // Priority 1 items sorted by key, then priority 2 items sorted by key
+      const keys = [...collection.keys()]
+      expect(keys).toEqual([`a`, `b`, `c`, `d`, `e`])
+    })
+
+    it(`should maintain deterministic order after incremental sync`, () => {
+      type Item = { id: string; priority: number }
+
+      const options = mockSyncCollectionOptions<Item>({
+        id: `test-collection-incremental`,
+        getKey: (item) => item.id,
+        initialData: [],
+      })
+
+      const collection = createCollection({
+        ...options,
+        compare: (a, b) => a.priority - b.priority,
+      })
+
+      // First sync batch
+      options.utils.begin()
+      options.utils.write({ type: `insert`, value: { id: `c`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `a`, priority: 1 } })
+      options.utils.commit()
+
+      // Second sync batch (simulating incremental load)
+      options.utils.begin()
+      options.utils.write({ type: `insert`, value: { id: `b`, priority: 1 } })
+      options.utils.commit()
+
+      // Order should be deterministic regardless of sync batch order
+      const keys = [...collection.keys()]
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+
+    it(`should maintain deterministic order when collection has no compare function`, () => {
+      // Even without a compare function, iteration order should be deterministic (by key)
+      type Item = { id: string; name: string }
+
+      const options = mockSyncCollectionOptions<Item>({
+        id: `test-collection-no-compare`,
+        getKey: (item) => item.id,
+        initialData: [],
+      })
+
+      const collection = createCollection(options)
+
+      options.utils.begin()
+      options.utils.write({
+        type: `insert`,
+        value: { id: `c`, name: `Charlie` },
+      })
+      options.utils.write({ type: `insert`, value: { id: `a`, name: `Alice` } })
+      options.utils.write({ type: `insert`, value: { id: `b`, name: `Bob` } })
+      options.utils.commit()
+
+      // Without compare function, should still iterate in key order
+      const keys = [...collection.keys()]
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+  })
+
+  describe(`Collection currentStateAsChanges with orderBy`, () => {
+    it(`should return changes in deterministic order when orderBy values are equal`, () => {
+      type Item = { id: string; priority: number }
+
+      const options = mockSyncCollectionOptions<Item>({
+        id: `test-collection-changes`,
+        getKey: (item) => item.id,
+        initialData: [],
+      })
+
+      const collection = createCollection(options)
+
+      options.utils.begin()
+      options.utils.write({ type: `insert`, value: { id: `c`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `a`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `b`, priority: 1 } })
+      options.utils.commit()
+
+      const changes = collection.currentStateAsChanges({
+        orderBy: [
+          {
+            expression: new PropRef([`priority`]),
+            compareOptions: { direction: `asc`, nulls: `last` },
+          },
+        ],
+      })
+
+      const keys = changes?.map((c) => c.key)
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+
+    it(`should return changes in deterministic order with limit`, () => {
+      type Item = { id: string; priority: number }
+
+      const options = mockSyncCollectionOptions<Item>({
+        id: `test-collection-changes-limit`,
+        getKey: (item) => item.id,
+        initialData: [],
+      })
+
+      const collection = createCollection(options)
+
+      options.utils.begin()
+      options.utils.write({ type: `insert`, value: { id: `e`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `c`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `a`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `d`, priority: 1 } })
+      options.utils.write({ type: `insert`, value: { id: `b`, priority: 1 } })
+      options.utils.commit()
+
+      const changes = collection.currentStateAsChanges({
+        orderBy: [
+          {
+            expression: new PropRef([`priority`]),
+            compareOptions: { direction: `asc`, nulls: `last` },
+          },
+        ],
+        limit: 3,
+      })
+
+      // First 3 in key order: a, b, c
+      const keys = changes?.map((c) => c.key)
+      expect(keys).toEqual([`a`, `b`, `c`])
+    })
+  })
+})
diff --git a/packages/db/tests/errors.test.ts b/packages/db/tests/errors.test.ts
index 4f21eb655..9972d0a47 100644
--- a/packages/db/tests/errors.test.ts
+++ b/packages/db/tests/errors.test.ts
@@ -1,5 +1,5 @@
-import { describe, expect, it } from "vitest"
-import { NonRetriableError } from "../src/errors"
+import { describe, expect, it } from 'vitest'
+import { NonRetriableError } from '../src/errors'
 
 describe(`Errors`, () => {
   it(`should create a NonRetriableError with the correct name and message`, () => {
diff --git a/packages/db/tests/integration/uint8array-id-comparison.test.ts b/packages/db/tests/integration/uint8array-id-comparison.test.ts
new file mode 100644
index 000000000..7b13c04f6
--- /dev/null
+++ b/packages/db/tests/integration/uint8array-id-comparison.test.ts
@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest'
+import { createCollection, eq } from '../../src/index.js'
+import { createLiveQueryCollection } from '../../src/query/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+
+interface Item {
+  id: Uint8Array
+  name: string
+}
+
+describe(`Uint8Array ID comparison (user reproduction)`, () => {
+  it(`should find items by Uint8Array ID using eq`, async () => {
+    const makeItemName = (index: number) => `Item ${index}`
+
+    // Create data exactly like the user's reproduction
+    const data = Array.from({ length: 10 }).map(
+      (_, index): Item => ({
+        id: new Uint8Array(index), // Creates arrays of different lengths
+        name: makeItemName(index),
+      }),
+    )
+
+    const itemCollection = createCollection(
+      mockSyncCollectionOptions<Item>({
+        id: `uint8array-test`,
+        getKey: (item) => item.id.toString(),
+        initialData: data,
+        autoIndex: `eager`, // Enable auto-indexing to test index lookups
+      }),
+    )
+
+    const selectedItemIndex = 5
+
+    // Test: Find item by Uint8Array ID (this is what the user is trying to do)
+    const queryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ item: itemCollection })
+        .where(({ item }) => eq(item.id, new Uint8Array(selectedItemIndex)))
+        .findOne(),
+    )
+
+    await queryCollection.preload()
+
+    // For findOne(), get the single result from entries
+    const result = Array.from(queryCollection.entries())[0]?.[1]
+
+    // Should find "Item 5"
+    expect(result).toBeDefined()
+    expect(result?.name).toBe(makeItemName(selectedItemIndex))
+
+    // Test with a different index
+    const queryCollection2 = createLiveQueryCollection((q) =>
+      q
+        .from({ item: itemCollection })
+        .where(({ item }) => eq(item.id, new Uint8Array(0)))
+        .findOne(),
+    )
+
+    await queryCollection2.preload()
+
+    const result2 = Array.from(queryCollection2.entries())[0]?.[1]
+
+    expect(result2).toBeDefined()
+    expect(result2?.name).toBe(makeItemName(0))
+
+    // Test: Find by string name (this should work)
+    const queryByName = createLiveQueryCollection((q) =>
+      q
+        .from({ item: itemCollection })
+        .where(({ item }) => eq(item.name, makeItemName(selectedItemIndex)))
+        .findOne(),
+    )
+
+    await queryByName.preload()
+
+    const resultByName = Array.from(queryByName.entries())[0]?.[1]
+
+    expect(resultByName).toBeDefined()
+    expect(resultByName?.name).toBe(makeItemName(selectedItemIndex))
+  })
+
+  it(`should use reference equality for large Uint8Arrays (> 128 bytes)`, async () => {
+    // Create a large Uint8Array (> 128 bytes) that should use reference equality
+    const largeId = new Uint8Array(200).fill(42)
+
+    interface LargeItem {
+      id: Uint8Array
+      name: string
+    }
+
+    const data: Array<LargeItem> = [
+      { id: largeId, name: `Large Item` },
+      { id: new Uint8Array(200).fill(99), name: `Other Large Item` },
+    ]
+
+    const collection = createCollection(
+      mockSyncCollectionOptions<LargeItem>({
+        id: `large-uint8array-test`,
+        getKey: (item) => item.name,
+        initialData: data,
+        autoIndex: `eager`,
+      }),
+    )
+
+    // Query with the exact same reference - this should work
+    const queryWithSameRef = createLiveQueryCollection((q) =>
+      q
+        .from({ item: collection })
+        .where(({ item }) => eq(item.id, largeId))
+        .findOne(),
+    )
+
+    await queryWithSameRef.preload()
+    const resultWithSameRef = Array.from(queryWithSameRef.entries())[0]?.[1]
+
+    // Should find the item because we're using the same reference
+    expect(resultWithSameRef).toBeDefined()
+    expect(resultWithSameRef?.name).toBe(`Large Item`)
+
+    // Query with a different instance but same content - this will NOT work
+    // because large arrays use reference equality
+    const differentInstance = new Uint8Array(200).fill(42)
+    const queryWithDifferentRef = createLiveQueryCollection((q) =>
+      q
+        .from({ item: collection })
+        .where(({ item }) => eq(item.id, differentInstance))
+        .findOne(),
+    )
+
+    await queryWithDifferentRef.preload()
+    const resultWithDifferentRef = Array.from(
+      queryWithDifferentRef.entries(),
+    )[0]?.[1]
+
+    // Should NOT find the item because large arrays use reference equality
+    // This is expected behavior to avoid memory overhead
+    expect(resultWithDifferentRef).toBeUndefined()
+  })
+})
diff --git a/packages/db/tests/local-only.test-d.ts b/packages/db/tests/local-only.test-d.ts
index 512903713..471a266b3 100644
--- a/packages/db/tests/local-only.test-d.ts
+++ b/packages/db/tests/local-only.test-d.ts
@@ -1,7 +1,7 @@
-import { describe, expectTypeOf, it } from "vitest"
-import { z } from "zod"
-import { createCollection } from "../src/index"
-import { localOnlyCollectionOptions } from "../src/local-only"
+import { describe, expectTypeOf, it } from 'vitest'
+import { z } from 'zod'
+import { createCollection } from '../src/index'
+import { localOnlyCollectionOptions } from '../src/local-only'
 
 interface TestItem extends Record<string, unknown> {
   id: number
@@ -158,19 +158,19 @@ describe(`LocalOnly Collection Types`, () => {
       schema: testSchema,
       onInsert: (params) => {
         expectTypeOf(
-          params.transaction.mutations[0].modified
+          params.transaction.mutations[0].modified,
         ).toEqualTypeOf<ExpectedType>()
         return Promise.resolve()
       },
       onUpdate: (params) => {
         expectTypeOf(
-          params.transaction.mutations[0].modified
+          params.transaction.mutations[0].modified,
         ).toEqualTypeOf<ExpectedType>()
         return Promise.resolve()
       },
       onDelete: (params) => {
         expectTypeOf(
-          params.transaction.mutations[0].modified
+          params.transaction.mutations[0].modified,
         ).toEqualTypeOf<ExpectedType>()
         return Promise.resolve()
       },
@@ -215,23 +215,23 @@ describe(`LocalOnly Collection Types`, () => {
         schema: testSchema,
         onInsert: (params) => {
           expectTypeOf(
-            params.transaction.mutations[0].modified
+            params.transaction.mutations[0].modified,
           ).toEqualTypeOf<ExpectedType>()
           return Promise.resolve()
         },
         onUpdate: (params) => {
           expectTypeOf(
-            params.transaction.mutations[0].modified
+            params.transaction.mutations[0].modified,
           ).toEqualTypeOf<ExpectedType>()
           return Promise.resolve()
         },
         onDelete: (params) => {
           expectTypeOf(
-            params.transaction.mutations[0].modified
+            params.transaction.mutations[0].modified,
           ).toEqualTypeOf<ExpectedType>()
           return Promise.resolve()
         },
-      })
+      }),
     )
 
     collection.insert({
diff --git a/packages/db/tests/local-only.test.ts b/packages/db/tests/local-only.test.ts
index 94c29a8fa..1eb8ac0b5 100644
--- a/packages/db/tests/local-only.test.ts
+++ b/packages/db/tests/local-only.test.ts
@@ -1,10 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from "vitest"
-import { createCollection, liveQueryCollectionOptions } from "../src/index"
-import { sum } from "../src/query/builder/functions"
-import { localOnlyCollectionOptions } from "../src/local-only"
-import { createTransaction } from "../src/transactions"
-import type { LocalOnlyCollectionUtils } from "../src/local-only"
-import type { Collection } from "../src/index"
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection, liveQueryCollectionOptions } from '../src/index'
+import { sum } from '../src/query/builder/functions'
+import { localOnlyCollectionOptions } from '../src/local-only'
+import { createTransaction } from '../src/transactions'
+import type { LocalOnlyCollectionUtils } from '../src/local-only'
+import type { Collection } from '../src/index'
 
 interface TestItem extends Record<string, unknown> {
   id: number
@@ -22,7 +22,7 @@ describe(`LocalOnly Collection`, () => {
       localOnlyCollectionOptions({
         id: `test-local-only`,
         getKey: (item: TestItem) => item.id,
-      })
+      }),
     )
   })
 
@@ -161,7 +161,7 @@ describe(`LocalOnly Collection`, () => {
         { id: 1, name: `Item 1` },
         { id: 2, name: `Item 2` },
         { id: 3, name: `Item 3` },
-      ])
+      ]),
     )
   })
 
@@ -179,7 +179,7 @@ describe(`LocalOnly Collection`, () => {
       expect.arrayContaining([
         [1, { id: 1, name: `Item 1` }],
         [2, { id: 2, name: `Item 2` }],
-      ])
+      ]),
     )
 
     // Test values iteration
@@ -234,7 +234,7 @@ describe(`LocalOnly Collection`, () => {
         localOnlyCollectionOptions({
           id: `test-schema`,
           getKey: (item: TestItem) => item.id,
-        })
+        }),
       )
 
       // Basic operations should still work
@@ -259,7 +259,7 @@ describe(`LocalOnly Collection`, () => {
           id: `test-custom-callbacks`,
           getKey: (item: TestItem) => item.id,
           onInsert: onInsertSpy,
-        })
+        }),
       )
 
       testCollection.insert({ id: 1, name: `Test Item` })
@@ -275,7 +275,7 @@ describe(`LocalOnly Collection`, () => {
               }),
             ]),
           }),
-        })
+        }),
       )
 
       // Collection should still work normally
@@ -290,7 +290,7 @@ describe(`LocalOnly Collection`, () => {
           id: `test-custom-update`,
           getKey: (item: TestItem) => item.id,
           onUpdate: onUpdateSpy,
-        })
+        }),
       )
 
       testCollection.insert({ id: 1, name: `Test Item` })
@@ -309,7 +309,7 @@ describe(`LocalOnly Collection`, () => {
               }),
             ]),
           }),
-        })
+        }),
       )
 
       // Collection should still work normally
@@ -324,7 +324,7 @@ describe(`LocalOnly Collection`, () => {
           id: `test-custom-delete`,
           getKey: (item: TestItem) => item.id,
           onDelete: onDeleteSpy,
-        })
+        }),
       )
 
       testCollection.insert({ id: 1, name: `Test Item` })
@@ -341,7 +341,7 @@ describe(`LocalOnly Collection`, () => {
               }),
             ]),
           }),
-        })
+        }),
       )
 
       // Collection should still work normally
@@ -353,7 +353,7 @@ describe(`LocalOnly Collection`, () => {
         localOnlyCollectionOptions({
           id: `test-no-callbacks`,
           getKey: (item: TestItem) => item.id,
-        })
+        }),
       )
 
       // Should work normally without callbacks
@@ -380,7 +380,7 @@ describe(`LocalOnly Collection`, () => {
           id: `test-initial-data`,
           getKey: (item: TestItem) => item.id,
           initialData: initialItems,
-        })
+        }),
       )
 
       // Collection should be populated with initial data
@@ -396,7 +396,7 @@ describe(`LocalOnly Collection`, () => {
           id: `test-empty-initial-data`,
           getKey: (item: TestItem) => item.id,
           initialData: [],
-        })
+        }),
       )
 
       // Collection should be empty
@@ -408,7 +408,7 @@ describe(`LocalOnly Collection`, () => {
         localOnlyCollectionOptions({
           id: `test-no-initial-data`,
           getKey: (item: TestItem) => item.id,
-        })
+        }),
       )
 
       // Collection should be empty
@@ -423,7 +423,7 @@ describe(`LocalOnly Collection`, () => {
           id: `test-initial-plus-more`,
           getKey: (item: TestItem) => item.id,
           initialData: initialItems,
-        })
+        }),
       )
 
       // Should start with initial data
@@ -459,7 +459,7 @@ describe(`LocalOnly Collection`, () => {
             return Promise.resolve()
           },
           autoIndex: `off`,
-        })
+        }),
       )
 
       const query = createCollection(
@@ -469,7 +469,7 @@ describe(`LocalOnly Collection`, () => {
             q.from({ numbers: testCollection }).select(({ numbers }) => ({
               totalNumber: sum(numbers.number),
             })),
-        })
+        }),
       )
 
       testCollection.delete(0)
@@ -517,7 +517,7 @@ describe(`LocalOnly Collection`, () => {
         localOnlyCollectionOptions({
           id: `other-collection`,
           getKey: (item) => item.id,
-        })
+        }),
       )
 
       const tx = createTransaction({
diff --git a/packages/db/tests/local-storage.test-d.ts b/packages/db/tests/local-storage.test-d.ts
index aaf48049b..3321b2e66 100644
--- a/packages/db/tests/local-storage.test-d.ts
+++ b/packages/db/tests/local-storage.test-d.ts
@@ -1,12 +1,12 @@
-import { describe, expectTypeOf, it } from "vitest"
-import { z } from "zod"
-import { createCollection } from "../src/index"
-import { localStorageCollectionOptions } from "../src/local-storage"
+import { describe, expectTypeOf, it } from 'vitest'
+import { z } from 'zod'
+import { createCollection } from '../src/index'
+import { localStorageCollectionOptions } from '../src/local-storage'
 import type {
   LocalStorageCollectionConfig,
   StorageApi,
   StorageEventApi,
-} from "../src/local-storage"
+} from '../src/local-storage'
 
 type ItemOf<T> = T extends Array<infer U> ? U : T
 
@@ -173,21 +173,21 @@ describe(`LocalStorage collection type resolution tests`, () => {
       onInsert: (params) => {
         // Verify that the mutation value has the correct type
         expectTypeOf(
-          params.transaction.mutations[0].modified
+          params.transaction.mutations[0].modified,
         ).toEqualTypeOf<ExplicitType>()
         return Promise.resolve({ success: true })
       },
       onUpdate: (params) => {
         // Verify that the mutation value has the correct type
         expectTypeOf(
-          params.transaction.mutations[0].modified
+          params.transaction.mutations[0].modified,
         ).toEqualTypeOf<ExplicitType>()
         return Promise.resolve({ success: true })
       },
       onDelete: (params) => {
         // Verify that the mutation value has the correct type
         expectTypeOf(
-          params.transaction.mutations[0].original
+          params.transaction.mutations[0].original,
         ).toEqualTypeOf<ExplicitType>()
         return Promise.resolve({ success: true })
       },
@@ -286,11 +286,11 @@ describe(`LocalStorage collection type resolution tests`, () => {
     const windowEventApi: {
       addEventListener: (
         type: `storage`,
-        listener: (event: StorageEvent) => void
+        listener: (event: StorageEvent) => void,
       ) => void
       removeEventListener: (
         type: `storage`,
-        listener: (event: StorageEvent) => void
+        listener: (event: StorageEvent) => void,
       ) => void
     } = {
       addEventListener: () => {},
@@ -323,23 +323,23 @@ describe(`LocalStorage collection type resolution tests`, () => {
         schema: testSchemaWithSchema,
         onInsert: (params) => {
           expectTypeOf(
-            params.transaction.mutations[0].modified
+            params.transaction.mutations[0].modified,
           ).toEqualTypeOf<ExpectedType>()
           return Promise.resolve()
         },
         onUpdate: (params) => {
           expectTypeOf(
-            params.transaction.mutations[0].modified
+            params.transaction.mutations[0].modified,
           ).toEqualTypeOf<ExpectedType>()
           return Promise.resolve()
         },
         onDelete: (params) => {
           expectTypeOf(
-            params.transaction.mutations[0].modified
+            params.transaction.mutations[0].modified,
           ).toEqualTypeOf<ExpectedType>()
           return Promise.resolve()
         },
-      })
+      }),
     )
 
     collection.insert({
diff --git a/packages/db/tests/local-storage.test.ts b/packages/db/tests/local-storage.test.ts
index b991622dc..878e570ea 100644
--- a/packages/db/tests/local-storage.test.ts
+++ b/packages/db/tests/local-storage.test.ts
@@ -1,9 +1,10 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { createCollection } from "../src/index"
-import { localStorageCollectionOptions } from "../src/local-storage"
-import { createTransaction } from "../src/transactions"
-import { StorageKeyRequiredError } from "../src/errors"
-import type { StorageEventApi } from "../src/local-storage"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import superjson from 'superjson'
+import { createCollection } from '../src/index'
+import { localStorageCollectionOptions } from '../src/local-storage'
+import { createTransaction } from '../src/transactions'
+import { StorageKeyRequiredError } from '../src/errors'
+import type { StorageEventApi } from '../src/local-storage'
 
 // Mock storage implementation for testing that properly implements Storage interface
 class MockStorage implements Storage {
@@ -41,14 +42,14 @@ class MockStorageEventApi implements StorageEventApi {
 
   addEventListener(
     type: `storage`,
-    listener: (event: StorageEvent) => void
+    listener: (event: StorageEvent) => void,
   ): void {
     this.listeners.push(listener)
   }
 
   removeEventListener(
     type: `storage`,
-    listener: (event: StorageEvent) => void
+    listener: (event: StorageEvent) => void,
   ): void {
     const index = this.listeners.indexOf(listener)
     if (index > -1) {
@@ -92,7 +93,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       expect(collection).toBeDefined()
@@ -130,7 +131,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (item: any) => item.id,
-        })
+        }),
       ).toThrow(StorageKeyRequiredError)
     })
 
@@ -175,13 +176,47 @@ describe(`localStorage collection`, () => {
       // Restore window
       globalThis.window = originalWindow
     })
+
+    it(`should support custom parsers like superjson`, async () => {
+      const collection = createCollection(
+        localStorageCollectionOptions<Todo>({
+          storageKey: `todos`,
+          storage: mockStorage,
+          storageEventApi: mockStorageEventApi,
+          getKey: (item) => item.id,
+          parser: superjson,
+        }),
+      )
+
+      const todo: Todo = {
+        id: `1`,
+        title: `superjson`,
+        completed: false,
+        createdAt: new Date(),
+      }
+
+      const insertTx = collection.insert(todo)
+
+      await insertTx.isPersisted.promise
+
+      const storedData = mockStorage.getItem(`todos`)
+      expect(storedData).toBeDefined()
+
+      const parsed = superjson.parse<Record<string, { data: Todo }>>(
+        storedData!,
+      )
+
+      expect(parsed[`s:1`]?.data.title).toBe(`superjson`)
+      expect(parsed[`s:1`]?.data.completed).toBe(false)
+      expect(parsed[`s:1`]?.data.createdAt).toBeInstanceOf(Date)
+    })
   })
 
   describe(`data persistence`, () => {
     it(`should load existing data from storage on initialization`, () => {
       // Pre-populate storage with new versioned format
       const existingTodos = {
-        "1": {
+        's:1': {
           versionKey: `test-version-1`,
           data: {
             id: `1`,
@@ -200,7 +235,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       // Subscribe to trigger sync
@@ -223,7 +258,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       // Should initialize with empty collection
@@ -237,7 +272,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       // Should initialize with empty collection
@@ -254,7 +289,7 @@ describe(`localStorage collection`, () => {
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
           // No onInsert, onUpdate, or onDelete handlers provided
-        })
+        }),
       )
 
       // Subscribe to trigger sync
@@ -275,7 +310,7 @@ describe(`localStorage collection`, () => {
       let storedData = mockStorage.getItem(`todos`)
       expect(storedData).toBeDefined()
       let parsed = JSON.parse(storedData!)
-      expect(parsed[`1`].data.title).toBe(`Test Todo Without Handlers`)
+      expect(parsed[`s:1`].data.title).toBe(`Test Todo Without Handlers`)
 
       // Update without handlers should still persist
       const updateTx = collection.update(`1`, (draft) => {
@@ -287,7 +322,7 @@ describe(`localStorage collection`, () => {
       storedData = mockStorage.getItem(`todos`)
       expect(storedData).toBeDefined()
       parsed = JSON.parse(storedData!)
-      expect(parsed[`1`].data.title).toBe(`Updated Without Handlers`)
+      expect(parsed[`s:1`].data.title).toBe(`Updated Without Handlers`)
 
       // Delete without handlers should still persist
       const deleteTx = collection.delete(`1`)
@@ -297,7 +332,7 @@ describe(`localStorage collection`, () => {
       storedData = mockStorage.getItem(`todos`)
       expect(storedData).toBeDefined()
       parsed = JSON.parse(storedData!)
-      expect(parsed[`1`]).toBeUndefined()
+      expect(parsed[`s:1`]).toBeUndefined()
 
       subscription.unsubscribe()
     })
@@ -316,7 +351,7 @@ describe(`localStorage collection`, () => {
           onInsert: insertSpy,
           onUpdate: updateSpy,
           onDelete: deleteSpy,
-        })
+        }),
       )
 
       // Subscribe to trigger sync
@@ -337,7 +372,7 @@ describe(`localStorage collection`, () => {
       let storedData = mockStorage.getItem(`todos`)
       expect(storedData).toBeDefined()
       let parsed = JSON.parse(storedData!)
-      expect(parsed[`1`].data.title).toBe(`Test Todo With Handlers`)
+      expect(parsed[`s:1`].data.title).toBe(`Test Todo With Handlers`)
 
       // Update should call handler AND persist
       const updateTx = collection.update(`1`, (draft) => {
@@ -349,7 +384,7 @@ describe(`localStorage collection`, () => {
       storedData = mockStorage.getItem(`todos`)
       expect(storedData).toBeDefined()
       parsed = JSON.parse(storedData!)
-      expect(parsed[`1`].data.title).toBe(`Updated With Handlers`)
+      expect(parsed[`s:1`].data.title).toBe(`Updated With Handlers`)
 
       // Delete should call handler AND persist
       const deleteTx = collection.delete(`1`)
@@ -359,7 +394,7 @@ describe(`localStorage collection`, () => {
       storedData = mockStorage.getItem(`todos`)
       expect(storedData).toBeDefined()
       parsed = JSON.parse(storedData!)
-      expect(parsed[`1`]).toBeUndefined()
+      expect(parsed[`s:1`]).toBeUndefined()
 
       subscription.unsubscribe()
     })
@@ -372,7 +407,7 @@ describe(`localStorage collection`, () => {
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
           onInsert: () => Promise.resolve({ success: true }),
-        })
+        }),
       )
 
       const todo: Todo = {
@@ -393,17 +428,17 @@ describe(`localStorage collection`, () => {
 
       const parsed = JSON.parse(storedData!)
       expect(typeof parsed).toBe(`object`)
-      expect(parsed[`1`]).toBeDefined()
-      expect(parsed[`1`].versionKey).toBeDefined()
-      expect(typeof parsed[`1`].versionKey).toBe(`string`)
-      expect(parsed[`1`].data.id).toBe(`1`)
-      expect(parsed[`1`].data.title).toBe(`Test Todo`)
+      expect(parsed[`s:1`]).toBeDefined()
+      expect(parsed[`s:1`].versionKey).toBeDefined()
+      expect(typeof parsed[`s:1`].versionKey).toBe(`string`)
+      expect(parsed[`s:1`].data.id).toBe(`1`)
+      expect(parsed[`s:1`].data.title).toBe(`Test Todo`)
     })
 
     it(`should perform update operations and update storage`, async () => {
       // Pre-populate storage
       const initialData = {
-        "1": {
+        's:1': {
           versionKey: `initial-version`,
           data: {
             id: `1`,
@@ -422,7 +457,7 @@ describe(`localStorage collection`, () => {
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
           onUpdate: () => Promise.resolve({ success: true }),
-        })
+        }),
       )
 
       // Subscribe to trigger sync
@@ -439,8 +474,8 @@ describe(`localStorage collection`, () => {
       expect(storedData).toBeDefined()
 
       const parsed = JSON.parse(storedData!)
-      expect(parsed[`1`].versionKey).not.toBe(`initial-version`) // Should have new version key
-      expect(parsed[`1`].data.title).toBe(`Updated Todo`)
+      expect(parsed[`s:1`].versionKey).not.toBe(`initial-version`) // Should have new version key
+      expect(parsed[`s:1`].data.title).toBe(`Updated Todo`)
 
       subscription.unsubscribe()
     })
@@ -448,7 +483,7 @@ describe(`localStorage collection`, () => {
     it(`should perform delete operations and update storage`, async () => {
       // Pre-populate storage
       const initialData = {
-        "1": {
+        's:1': {
           versionKey: `test-version`,
           data: {
             id: `1`,
@@ -467,7 +502,7 @@ describe(`localStorage collection`, () => {
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
           onDelete: () => Promise.resolve({ success: true }),
-        })
+        }),
       )
 
       // Subscribe to trigger sync
@@ -482,7 +517,7 @@ describe(`localStorage collection`, () => {
       expect(storedData).toBeDefined()
 
       const parsed = JSON.parse(storedData!)
-      expect(parsed[`1`]).toBeUndefined()
+      expect(parsed[`s:1`]).toBeUndefined()
 
       subscription.unsubscribe()
     })
@@ -496,7 +531,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       // Subscribe to trigger sync
@@ -504,7 +539,7 @@ describe(`localStorage collection`, () => {
 
       // Simulate data being added from another tab
       const newTodoData = {
-        "1": {
+        '1': {
           versionKey: `from-other-tab`,
           data: {
             id: `1`,
@@ -545,7 +580,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       // Create a mock storage event for different key
@@ -574,7 +609,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       // Create a mock storage event from different storage area
@@ -605,7 +640,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       collection.utils.clearStorage()
@@ -620,7 +655,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       expect(collection.utils.getStorageSize()).toBe(0)
@@ -654,7 +689,7 @@ describe(`localStorage collection`, () => {
     it(`should detect version key changes for updates`, () => {
       // Pre-populate storage
       const initialData = {
-        "1": {
+        's:1': {
           versionKey: `version-1`,
           data: {
             id: `1`,
@@ -672,7 +707,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       // Subscribe to trigger sync
@@ -683,7 +718,7 @@ describe(`localStorage collection`, () => {
 
       // Simulate change from another tab with different version key but same data
       const updatedData = {
-        "1": {
+        's:1': {
           versionKey: `version-2`, // Different version key
           data: {
             id: `1`,
@@ -720,7 +755,7 @@ describe(`localStorage collection`, () => {
 
       // Pre-populate storage
       const initialData = {
-        "1": {
+        's:1': {
           versionKey: `version-1`,
           data: {
             id: `1`,
@@ -738,7 +773,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       // Subscribe to changes to monitor
@@ -746,7 +781,7 @@ describe(`localStorage collection`, () => {
 
       // Simulate "change" from another tab with same version key
       const sameData = {
-        "1": {
+        's:1': {
           versionKey: `version-1`, // Same version key
           data: {
             id: `1`,
@@ -784,7 +819,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       // Subscribe to trigger sync
@@ -834,8 +869,8 @@ describe(`localStorage collection`, () => {
       const storedData = mockStorage.getItem(`todos`)
       expect(storedData).toBeDefined()
       const parsed = JSON.parse(storedData!)
-      expect(parsed[`tx-1`].data.title).toBe(`Manual Tx Insert`)
-      expect(parsed[`tx-2`].data.title).toBe(`Manual Tx Insert 2`)
+      expect(parsed[`s:tx-1`].data.title).toBe(`Manual Tx Insert`)
+      expect(parsed[`s:tx-2`].data.title).toBe(`Manual Tx Insert 2`)
 
       subscription.unsubscribe()
     })
@@ -847,7 +882,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       const collection2 = createCollection(
@@ -856,7 +891,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       const subscription1 = collection1.subscribeChanges(() => {})
@@ -892,7 +927,7 @@ describe(`localStorage collection`, () => {
       const stored1 = mockStorage.getItem(`todos-1`)
       expect(stored1).toBeDefined()
       const parsed1 = JSON.parse(stored1!)
-      expect(parsed1[`c1-item`].data.title).toBe(`Collection 1`)
+      expect(parsed1[`s:c1-item`].data.title).toBe(`Collection 1`)
 
       // Second collection mutations should NOT be in storage (remains optimistic)
       const stored2 = mockStorage.getItem(`todos-2`)
@@ -909,7 +944,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       const subscription = collection.subscribeChanges(() => {})
@@ -953,9 +988,9 @@ describe(`localStorage collection`, () => {
       const parsed = JSON.parse(storedData!)
 
       // Updated item should be in storage with new title
-      expect(parsed[`existing`].data.title).toBe(`Updated Item`)
+      expect(parsed[`s:existing`].data.title).toBe(`Updated Item`)
       // Deleted item should not be in storage
-      expect(parsed[`new`]).toBeUndefined()
+      expect(parsed[`s:new`]).toBeUndefined()
 
       subscription.unsubscribe()
     })
@@ -967,7 +1002,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       const subscription = collection.subscribeChanges(() => {})
@@ -1000,7 +1035,7 @@ describe(`localStorage collection`, () => {
       const storedData = mockStorage.getItem(`todos`)
       expect(storedData).toBeDefined()
       const parsed = JSON.parse(storedData!)
-      expect(parsed[`to-delete`]).toBeUndefined()
+      expect(parsed[`s:to-delete`]).toBeUndefined()
 
       // Collection should also not have the item
       expect(collection.has(`to-delete`)).toBe(false)
@@ -1015,7 +1050,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       const subscription = collection.subscribeChanges(() => {})
@@ -1069,7 +1104,7 @@ describe(`localStorage collection`, () => {
           storage: mockStorage,
           storageEventApi: mockStorageEventApi,
           getKey: (todo) => todo.id,
-        })
+        }),
       )
 
       const subscription = collection.subscribeChanges(() => {})
@@ -1102,7 +1137,967 @@ describe(`localStorage collection`, () => {
       const storedData = mockStorage.getItem(`todos`)
       expect(storedData).toBeDefined()
       const parsed = JSON.parse(storedData!)
-      expect(parsed[`after-api`].data.title).toBe(`After API`)
+      expect(parsed[`s:after-api`].data.title).toBe(`After API`)
+
+      subscription.unsubscribe()
+    })
+  })
+
+  describe(`Rapid mutations and cache consistency`, () => {
+    describe(`Rapid sequential mutations`, () => {
+      it(`should handle multiple rapid mutations without data loss`, async () => {
+        const collection = createCollection(
+          localStorageCollectionOptions<Todo>({
+            storageKey: `todos`,
+            storage: mockStorage,
+            storageEventApi: mockStorageEventApi,
+            getKey: (todo) => todo.id,
+          }),
+        )
+
+        const subscription = collection.subscribeChanges(() => {})
+
+        // Simulate rapid text input: multiple mutations without awaiting
+        const tx1 = collection.insert({
+          id: `1`,
+          title: `First`,
+          completed: false,
+          createdAt: new Date(),
+        })
+
+        const tx2 = collection.update(`1`, (draft) => {
+          draft.title = `Second`
+        })
+
+        const tx3 = collection.insert({
+          id: `2`,
+          title: `Third`,
+          completed: false,
+          createdAt: new Date(),
+        })
+
+        const tx4 = collection.update(`1`, (draft) => {
+          draft.title = `Fourth`
+        })
+
+        const tx5 = collection.delete(`2`)
+
+        // Wait for all mutations to complete
+        await Promise.all([
+          tx1.isPersisted.promise,
+          tx2.isPersisted.promise,
+          tx3.isPersisted.promise,
+          tx4.isPersisted.promise,
+          tx5.isPersisted.promise,
+        ])
+
+        // Verify final state in storage
+        const storedData = mockStorage.getItem(`todos`)
+        expect(storedData).toBeDefined()
+        const parsed = JSON.parse(storedData!)
+
+        // Item 1 should have the last update
+        expect(parsed[`s:1`].data.title).toBe(`Fourth`)
+        // Item 2 should be deleted
+        expect(parsed[`s:2`]).toBeUndefined()
+
+        // Verify collection matches storage
+        expect(collection.get(`1`)?.title).toBe(`Fourth`)
+        expect(collection.has(`2`)).toBe(false)
+
+        subscription.unsubscribe()
+      })
+
+      it(`should handle rapid mutations with manual transactions`, async () => {
+        const collection = createCollection(
+          localStorageCollectionOptions<Todo>({
+            storageKey: `todos`,
+            storage: mockStorage,
+            storageEventApi: mockStorageEventApi,
+            getKey: (todo) => todo.id,
+          }),
+        )
+
+        const subscription = collection.subscribeChanges(() => {})
+
+        const tx = createTransaction({
+          mutationFn: async ({ transaction }: any) => {
+            await Promise.resolve()
+            collection.utils.acceptMutations(transaction)
+          },
+          autoCommit: false,
+        })
+
+        // Rapid mutations within a transaction
+        tx.mutate(() => {
+          collection.insert({
+            id: `1`,
+            title: `A`,
+            completed: false,
+            createdAt: new Date(),
+          })
+          collection.update(`1`, (draft) => {
+            draft.title = `B`
+          })
+          collection.update(`1`, (draft) => {
+            draft.title = `C`
+          })
+          collection.insert({
+            id: `2`,
+            title: `D`,
+            completed: false,
+            createdAt: new Date(),
+          })
+          collection.delete(`2`)
+        })
+
+        await tx.commit()
+
+        // Verify final state
+        const storedData = mockStorage.getItem(`todos`)
+        const parsed = JSON.parse(storedData!)
+
+        expect(parsed[`s:1`].data.title).toBe(`C`)
+        expect(parsed[`s:2`]).toBeUndefined()
+
+        subscription.unsubscribe()
+      })
+    })
+
+    describe(`Cross-tab sync during mutations`, () => {
+      it(`should correctly handle storage events during local mutations`, async () => {
+        const collection = createCollection(
+          localStorageCollectionOptions<Todo>({
+            storageKey: `todos`,
+            storage: mockStorage,
+            storageEventApi: mockStorageEventApi,
+            getKey: (todo) => todo.id,
+          }),
+        )
+
+        const subscription = collection.subscribeChanges(() => {})
+
+        // Start a local mutation (don't await)
+        const localTx = collection.insert({
+          id: `local`,
+          title: `Local Change`,
+          completed: false,
+          createdAt: new Date(),
+        })
+
+        // Simulate another tab making a change while local mutation is in progress
+        const remoteData = {
+          's:local': {
+            versionKey: `local-version`,
+            data: {
+              id: `local`,
+              title: `Local Change`,
+              completed: false,
+              createdAt: new Date(),
+            },
+          },
+          's:remote': {
+            versionKey: `remote-version`,
+            data: {
+              id: `remote`,
+              title: `Remote Change`,
+              completed: false,
+              createdAt: new Date(),
+            },
+          },
+        }
+
+        mockStorage.setItem(`todos`, JSON.stringify(remoteData))
+
+        const storageEvent = {
+          type: `storage`,
+          key: `todos`,
+          oldValue: null,
+          newValue: JSON.stringify(remoteData),
+          url: `http://localhost`,
+          storageArea: mockStorage,
+        } as unknown as StorageEvent
+
+        mockStorageEventApi.triggerStorageEvent(storageEvent)
+
+        // Wait for local mutation to complete
+        await localTx.isPersisted.promise
+
+        // Both items should exist
+        expect(collection.has(`local`)).toBe(true)
+        expect(collection.has(`remote`)).toBe(true)
+
+        subscription.unsubscribe()
+      })
+
+      it(`should maintain lastKnownData consistency after cross-tab updates`, async () => {
+        const collection = createCollection(
+          localStorageCollectionOptions<Todo>({
+            storageKey: `todos`,
+            storage: mockStorage,
+            storageEventApi: mockStorageEventApi,
+            getKey: (todo) => todo.id,
+          }),
+        )
+
+        const subscription = collection.subscribeChanges(() => {})
+
+        // Insert initial item
+        const tx1 = collection.insert({
+          id: `1`,
+          title: `Initial`,
+          completed: false,
+          createdAt: new Date(),
+        })
+        await tx1.isPersisted.promise
+
+        // Simulate another tab updating the item
+        const remoteData = {
+          's:1': {
+            versionKey: `remote-version-1`,
+            data: {
+              id: `1`,
+              title: `Remote Update`,
+              completed: true,
+              createdAt: new Date(),
+            },
+          },
+        }
+
+        mockStorage.setItem(`todos`, JSON.stringify(remoteData))
+
+        const storageEvent = {
+          type: `storage`,
+          key: `todos`,
+          oldValue: null,
+          newValue: JSON.stringify(remoteData),
+          url: `http://localhost`,
+          storageArea: mockStorage,
+        } as unknown as StorageEvent
+
+        mockStorageEventApi.triggerStorageEvent(storageEvent)
+
+        // Now perform a local update - should work with updated lastKnownData
+        const tx2 = collection.update(`1`, (draft) => {
+          draft.title = `Local Update After Remote`
+        })
+        await tx2.isPersisted.promise
+
+        // Verify final state
+        const storedData = mockStorage.getItem(`todos`)
+        const parsed = JSON.parse(storedData!)
+
+        expect(parsed[`s:1`].data.title).toBe(`Local Update After Remote`)
+        expect(parsed[`s:1`].data.completed).toBe(true) // Should preserve remote's completed state
+
+        subscription.unsubscribe()
+      })
+    })
+
+    describe(`acceptMutations edge cases`, () => {
+      it(`should handle acceptMutations before collection is fully initialized`, async () => {
+        const collection = createCollection(
+          localStorageCollectionOptions<Todo>({
+            storageKey: `todos`,
+            storage: mockStorage,
+            storageEventApi: mockStorageEventApi,
+            getKey: (todo) => todo.id,
+          }),
+        )
+
+        // Don't subscribe - collection sync may not be initialized yet
+        const tx = createTransaction({
+          mutationFn: async ({ transaction }: any) => {
+            await Promise.resolve()
+            // This should handle the case where sync isn't ready
+            collection.utils.acceptMutations(transaction)
+          },
+          autoCommit: false,
+        })
+
+        tx.mutate(() => {
+          collection.insert({
+            id: `early`,
+            title: `Early Mutation`,
+            completed: false,
+            createdAt: new Date(),
+          })
+        })
+
+        // Commit before subscribing
+        await tx.commit()
+
+        // Now subscribe to initialize sync
+        const subscription = collection.subscribeChanges(() => {})
+
+        // Item should eventually be in collection
+        expect(collection.has(`early`)).toBe(true)
+
+        // And in storage
+        const storedData = mockStorage.getItem(`todos`)
+        expect(storedData).toBeDefined()
+        const parsed = JSON.parse(storedData!)
+        expect(parsed[`s:early`].data.title).toBe(`Early Mutation`)
+
+        subscription.unsubscribe()
+      })
+
+      it(`should handle mixing automatic mutations and manual transactions`, async () => {
+        const collection = createCollection(
+          localStorageCollectionOptions<Todo>({
+            storageKey: `todos`,
+            storage: mockStorage,
+            storageEventApi: mockStorageEventApi,
+            getKey: (todo) => todo.id,
+          }),
+        )
+
+        const subscription = collection.subscribeChanges(() => {})
+
+        // Automatic mutation
+        const auto1 = collection.insert({
+          id: `auto1`,
+          title: `Auto 1`,
+          completed: false,
+          createdAt: new Date(),
+        })
+        await auto1.isPersisted.promise
+
+        // Manual transaction
+        const tx = createTransaction({
+          mutationFn: async ({ transaction }: any) => {
+            await Promise.resolve()
+            collection.utils.acceptMutations(transaction)
+          },
+          autoCommit: false,
+        })
+
+        tx.mutate(() => {
+          collection.insert({
+            id: `manual1`,
+            title: `Manual 1`,
+            completed: false,
+            createdAt: new Date(),
+          })
+          collection.update(`auto1`, (draft) => {
+            draft.title = `Auto 1 Updated`
+          })
+        })
+
+        await tx.commit()
+
+        // Another automatic mutation
+        const auto2 = collection.insert({
+          id: `auto2`,
+          title: `Auto 2`,
+          completed: false,
+          createdAt: new Date(),
+        })
+        await auto2.isPersisted.promise
+
+        // Verify all items in storage
+        const storedData = mockStorage.getItem(`todos`)
+        const parsed = JSON.parse(storedData!)
+
+        expect(parsed[`s:auto1`].data.title).toBe(`Auto 1 Updated`)
+        expect(parsed[`s:manual1`].data.title).toBe(`Manual 1`)
+        expect(parsed[`s:auto2`].data.title).toBe(`Auto 2`)
+
+        subscription.unsubscribe()
+      })
+    })
+
+    describe(`Storage write failure scenarios`, () => {
+      it(`should handle storage.setItem failures gracefully`, async () => {
+        const failingStorage = new MockStorage()
+        const originalSetItem = failingStorage.setItem.bind(failingStorage)
+
+        // Make setItem fail once
+        let callCount = 0
+        failingStorage.setItem = vi.fn((key: string, value: string) => {
+          callCount++
+          if (callCount === 1) {
+            throw new Error(`QuotaExceededError: Storage full`)
+          }
+          originalSetItem(key, value)
+        })
+
+        const collection = createCollection(
+          localStorageCollectionOptions<Todo>({
+            storageKey: `todos`,
+            storage: failingStorage,
+            storageEventApi: mockStorageEventApi,
+            getKey: (todo) => todo.id,
+          }),
+        )
+
+        const subscription = collection.subscribeChanges(() => {})
+
+        // This insert should fail on storage write
+        const tx = collection.insert({
+          id: `1`,
+          title: `Test`,
+          completed: false,
+          createdAt: new Date(),
+        })
+
+        // The transaction should reject
+        await expect(tx.isPersisted.promise).rejects.toThrow()
+
+        subscription.unsubscribe()
+      })
+    })
+
+    describe(`lastKnownData consistency`, () => {
+      it(`should keep lastKnownData in sync with storage after every operation`, async () => {
+        const collection = createCollection(
+          localStorageCollectionOptions<Todo>({
+            storageKey: `todos`,
+            storage: mockStorage,
+            storageEventApi: mockStorageEventApi,
+            getKey: (todo) => todo.id,
+          }),
+        )
+
+        const subscription = collection.subscribeChanges(() => {})
+
+        // Helper to verify lastKnownData matches storage
+        const verifyConsistency = () => {
+          const storedData = mockStorage.getItem(`todos`)
+          if (!storedData) return true
+
+          const parsed = JSON.parse(storedData)
+
+          // Check that collection has all items from storage
+          // Note: storage keys are encoded (e.g., "s:1"), but we need to decode them
+          // to check collection membership
+          for (const encodedKey of Object.keys(parsed)) {
+            // Decode the storage key to get the actual item key
+            const itemKey = encodedKey.startsWith(`s:`)
+              ? encodedKey.slice(2)
+              : encodedKey.startsWith(`n:`)
+                ? Number(encodedKey.slice(2))
+                : encodedKey
+            if (!collection.has(itemKey)) {
+              return false
+            }
+          }
+
+          return true
+        }
+
+        // Insert
+        const tx1 = collection.insert({
+          id: `1`,
+          title: `First`,
+          completed: false,
+          createdAt: new Date(),
+        })
+        await tx1.isPersisted.promise
+        expect(verifyConsistency()).toBe(true)
+
+        // Update
+        const tx2 = collection.update(`1`, (draft) => {
+          draft.title = `Updated`
+        })
+        await tx2.isPersisted.promise
+        expect(verifyConsistency()).toBe(true)
+
+        // Insert another
+        const tx3 = collection.insert({
+          id: `2`,
+          title: `Second`,
+          completed: false,
+          createdAt: new Date(),
+        })
+        await tx3.isPersisted.promise
+        expect(verifyConsistency()).toBe(true)
+
+        // Delete
+        const tx4 = collection.delete(`1`)
+        await tx4.isPersisted.promise
+        expect(verifyConsistency()).toBe(true)
+
+        subscription.unsubscribe()
+      })
+    })
+  })
+
+  describe(`numeric and string ID handling`, () => {
+    it(`should update the correct item when multiple items exist (direct operations)`, async () => {
+      const collection = createCollection(
+        localStorageCollectionOptions<Todo>({
+          storageKey: `todos`,
+          storage: mockStorage,
+          storageEventApi: mockStorageEventApi,
+          getKey: (todo) => todo.id,
+        }),
+      )
+
+      const subscription = collection.subscribeChanges(() => {})
+
+      // Insert multiple items
+      const tx1 = collection.insert({
+        id: `first`,
+        title: `First Todo`,
+        completed: false,
+        createdAt: new Date(),
+      })
+      await tx1.isPersisted.promise
+
+      const tx2 = collection.insert({
+        id: `second`,
+        title: `Second Todo`,
+        completed: false,
+        createdAt: new Date(),
+      })
+      await tx2.isPersisted.promise
+
+      const tx3 = collection.insert({
+        id: `third`,
+        title: `Third Todo`,
+        completed: false,
+        createdAt: new Date(),
+      })
+      await tx3.isPersisted.promise
+
+      // Update the FIRST item specifically
+      const updateTx = collection.update(`first`, (draft) => {
+        draft.completed = true
+      })
+      await updateTx.isPersisted.promise
+
+      // Verify that the FIRST item was updated, not the last one
+      expect(collection.get(`first`)?.completed).toBe(true)
+      expect(collection.get(`second`)?.completed).toBe(false)
+      expect(collection.get(`third`)?.completed).toBe(false)
+
+      // Verify in storage
+      const storedData = mockStorage.getItem(`todos`)
+      expect(storedData).toBeDefined()
+      const parsed = JSON.parse(storedData!)
+      expect(parsed[`s:first`].data.completed).toBe(true)
+      expect(parsed[`s:second`].data.completed).toBe(false)
+      expect(parsed[`s:third`].data.completed).toBe(false)
+
+      subscription.unsubscribe()
+    })
+
+    it(`should delete the correct item when multiple items exist`, async () => {
+      const collection = createCollection(
+        localStorageCollectionOptions<Todo>({
+          storageKey: `todos`,
+          storage: mockStorage,
+          storageEventApi: mockStorageEventApi,
+          getKey: (todo) => todo.id,
+        }),
+      )
+
+      const subscription = collection.subscribeChanges(() => {})
+
+      // Insert multiple items
+      const tx1 = collection.insert({
+        id: `first`,
+        title: `First Todo`,
+        completed: false,
+        createdAt: new Date(),
+      })
+      await tx1.isPersisted.promise
+
+      const tx2 = collection.insert({
+        id: `second`,
+        title: `Second Todo`,
+        completed: false,
+        createdAt: new Date(),
+      })
+      await tx2.isPersisted.promise
+
+      const tx3 = collection.insert({
+        id: `third`,
+        title: `Third Todo`,
+        completed: false,
+        createdAt: new Date(),
+      })
+      await tx3.isPersisted.promise
+
+      // Delete the FIRST item specifically
+      const deleteTx = collection.delete(`first`)
+      await deleteTx.isPersisted.promise
+
+      // Verify that the FIRST item was deleted, not the last one
+      expect(collection.has(`first`)).toBe(false)
+      expect(collection.has(`second`)).toBe(true)
+      expect(collection.has(`third`)).toBe(true)
+
+      // Verify in storage
+      const storedData = mockStorage.getItem(`todos`)
+      expect(storedData).toBeDefined()
+      const parsed = JSON.parse(storedData!)
+      expect(parsed[`s:first`]).toBeUndefined()
+      expect(parsed[`s:second`]).toBeDefined()
+      expect(parsed[`s:third`]).toBeDefined()
+
+      subscription.unsubscribe()
+    })
+
+    it(`should update the correct item when using numeric IDs`, async () => {
+      interface NumericTodo {
+        id: number
+        title: string
+        completed: boolean
+      }
+
+      const collection = createCollection(
+        localStorageCollectionOptions<NumericTodo>({
+          storageKey: `numeric-todos`,
+          storage: mockStorage,
+          storageEventApi: mockStorageEventApi,
+          getKey: (todo) => todo.id,
+        }),
+      )
+
+      const subscription = collection.subscribeChanges(() => {})
+
+      // Insert multiple items with numeric IDs
+      const tx1 = collection.insert({
+        id: 1,
+        title: `First Todo`,
+        completed: false,
+      })
+      await tx1.isPersisted.promise
+
+      const tx2 = collection.insert({
+        id: 2,
+        title: `Second Todo`,
+        completed: false,
+      })
+      await tx2.isPersisted.promise
+
+      const tx3 = collection.insert({
+        id: 3,
+        title: `Third Todo`,
+        completed: false,
+      })
+      await tx3.isPersisted.promise
+
+      // Update the FIRST item (id: 1) specifically
+      const updateTx = collection.update(1, (draft) => {
+        draft.completed = true
+      })
+      await updateTx.isPersisted.promise
+
+      // Verify that item with id:1 was updated, not the last one
+      expect(collection.get(1)?.completed).toBe(true)
+      expect(collection.get(2)?.completed).toBe(false)
+      expect(collection.get(3)?.completed).toBe(false)
+
+      // Verify in storage - numeric keys are encoded with "n:" prefix
+      const storedData = mockStorage.getItem(`numeric-todos`)
+      expect(storedData).toBeDefined()
+      const parsed = JSON.parse(storedData!)
+      expect(parsed[`n:1`].data.completed).toBe(true)
+      expect(parsed[`n:2`].data.completed).toBe(false)
+      expect(parsed[`n:3`].data.completed).toBe(false)
+
+      subscription.unsubscribe()
+    })
+
+    it(`should delete the correct item when using numeric IDs`, async () => {
+      interface NumericTodo {
+        id: number
+        title: string
+        completed: boolean
+      }
+
+      const collection = createCollection(
+        localStorageCollectionOptions<NumericTodo>({
+          storageKey: `numeric-todos-delete`,
+          storage: mockStorage,
+          storageEventApi: mockStorageEventApi,
+          getKey: (todo) => todo.id,
+        }),
+      )
+
+      const subscription = collection.subscribeChanges(() => {})
+
+      // Insert multiple items with numeric IDs
+      const tx1 = collection.insert({
+        id: 1,
+        title: `First Todo`,
+        completed: false,
+      })
+      await tx1.isPersisted.promise
+
+      const tx2 = collection.insert({
+        id: 2,
+        title: `Second Todo`,
+        completed: false,
+      })
+      await tx2.isPersisted.promise
+
+      const tx3 = collection.insert({
+        id: 3,
+        title: `Third Todo`,
+        completed: false,
+      })
+      await tx3.isPersisted.promise
+
+      // Delete the FIRST item (id: 1) specifically
+      const deleteTx = collection.delete(1)
+      await deleteTx.isPersisted.promise
+
+      // Verify that item with id:1 was deleted, not the last one
+      expect(collection.has(1)).toBe(false)
+      expect(collection.has(2)).toBe(true)
+      expect(collection.has(3)).toBe(true)
+
+      // Verify in storage - numeric keys are encoded with "n:" prefix
+      const storedData = mockStorage.getItem(`numeric-todos-delete`)
+      expect(storedData).toBeDefined()
+      const parsed = JSON.parse(storedData!)
+      expect(parsed[`n:1`]).toBeUndefined()
+      expect(parsed[`n:2`]).toBeDefined()
+      expect(parsed[`n:3`]).toBeDefined()
+
+      subscription.unsubscribe()
+    })
+
+    it(`should update items with numeric IDs after loading from storage`, async () => {
+      interface NumericTodo {
+        id: number
+        title: string
+        completed: boolean
+      }
+
+      // Pre-populate storage with numeric IDs (simulating existing data)
+      // Numeric keys are stored with "n:" prefix
+      const existingData = {
+        'n:1': {
+          versionKey: `version-1`,
+          data: { id: 1, title: `First Todo`, completed: false },
+        },
+        'n:2': {
+          versionKey: `version-2`,
+          data: { id: 2, title: `Second Todo`, completed: false },
+        },
+        'n:3': {
+          versionKey: `version-3`,
+          data: { id: 3, title: `Third Todo`, completed: false },
+        },
+      }
+      mockStorage.setItem(`numeric-todos-reload`, JSON.stringify(existingData))
+
+      // Create collection - this will load the existing data
+      const collection = createCollection(
+        localStorageCollectionOptions<NumericTodo>({
+          storageKey: `numeric-todos-reload`,
+          storage: mockStorage,
+          storageEventApi: mockStorageEventApi,
+          getKey: (todo) => todo.id,
+        }),
+      )
+
+      const subscription = collection.subscribeChanges(() => {})
+
+      // Wait for initial sync
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Verify items were loaded
+      expect(collection.size).toBe(3)
+
+      // Now try to update item with numeric id 1
+      const updateTx = collection.update(1, (draft) => {
+        draft.completed = true
+      })
+      await updateTx.isPersisted.promise
+
+      // Verify the correct item was updated
+      expect(collection.get(1)?.completed).toBe(true)
+      expect(collection.get(2)?.completed).toBe(false)
+      expect(collection.get(3)?.completed).toBe(false)
+
+      // Verify in storage - numeric keys are encoded with "n:" prefix
+      const storedData = mockStorage.getItem(`numeric-todos-reload`)
+      expect(storedData).toBeDefined()
+      const parsed = JSON.parse(storedData!)
+      expect(parsed[`n:1`].data.completed).toBe(true)
+      expect(parsed[`n:2`].data.completed).toBe(false)
+      expect(parsed[`n:3`].data.completed).toBe(false)
+
+      subscription.unsubscribe()
+    })
+
+    it(`should delete items with numeric IDs after loading from storage`, async () => {
+      interface NumericTodo {
+        id: number
+        title: string
+        completed: boolean
+      }
+
+      // Pre-populate storage with numeric IDs (simulating existing data)
+      // Numeric keys are stored with "n:" prefix
+      const existingData = {
+        'n:1': {
+          versionKey: `version-1`,
+          data: { id: 1, title: `First Todo`, completed: false },
+        },
+        'n:2': {
+          versionKey: `version-2`,
+          data: { id: 2, title: `Second Todo`, completed: false },
+        },
+        'n:3': {
+          versionKey: `version-3`,
+          data: { id: 3, title: `Third Todo`, completed: false },
+        },
+      }
+      mockStorage.setItem(
+        `numeric-todos-reload-delete`,
+        JSON.stringify(existingData),
+      )
+
+      // Create collection - this will load the existing data
+      const collection = createCollection(
+        localStorageCollectionOptions<NumericTodo>({
+          storageKey: `numeric-todos-reload-delete`,
+          storage: mockStorage,
+          storageEventApi: mockStorageEventApi,
+          getKey: (todo) => todo.id,
+        }),
+      )
+
+      const subscription = collection.subscribeChanges(() => {})
+
+      // Wait for initial sync
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Verify items were loaded
+      expect(collection.size).toBe(3)
+
+      // Now try to delete item with numeric id 1
+      const deleteTx = collection.delete(1)
+      await deleteTx.isPersisted.promise
+
+      // Verify the correct item was deleted
+      expect(collection.has(1)).toBe(false)
+      expect(collection.has(2)).toBe(true)
+      expect(collection.has(3)).toBe(true)
+
+      // Verify in storage - numeric keys are encoded with "n:" prefix
+      const storedData = mockStorage.getItem(`numeric-todos-reload-delete`)
+      expect(storedData).toBeDefined()
+      const parsed = JSON.parse(storedData!)
+      expect(parsed[`n:1`]).toBeUndefined()
+      expect(parsed[`n:2`]).toBeDefined()
+      expect(parsed[`n:3`]).toBeDefined()
+
+      subscription.unsubscribe()
+    })
+
+    it(`should handle numeric and string keys as distinct (no collision)`, async () => {
+      interface MixedIdTodo {
+        id: string | number
+        title: string
+      }
+
+      const collection = createCollection(
+        localStorageCollectionOptions<MixedIdTodo>({
+          storageKey: `mixed-id-todos`,
+          storage: mockStorage,
+          storageEventApi: mockStorageEventApi,
+          getKey: (todo) => todo.id,
+        }),
+      )
+
+      const subscription = collection.subscribeChanges(() => {})
+
+      // Insert item with numeric ID
+      const tx1 = collection.insert({
+        id: 1,
+        title: `Numeric ID`,
+      })
+      await tx1.isPersisted.promise
+
+      // Insert item with string ID "1"
+      // With prefixing, these won't collide:
+      // numeric 1 => "__number__1"
+      // string "1" => "1"
+      const tx2 = collection.insert({
+        id: `1`,
+        title: `String ID`,
+      })
+      await tx2.isPersisted.promise
+
+      // Both should exist in collection state
+      expect(collection.has(1)).toBe(true)
+      expect(collection.has(`1`)).toBe(true)
+
+      // Both should exist in localStorage with different keys
+      const storedData = mockStorage.getItem(`mixed-id-todos`)
+      expect(storedData).toBeDefined()
+      const parsed = JSON.parse(storedData!)
+
+      // There should be TWO entries in storage
+      expect(Object.keys(parsed).length).toBe(2)
+      // Numeric ID 1 is stored with key "n:1"
+      expect(parsed[`n:1`]).toBeDefined()
+      expect(parsed[`n:1`].data.title).toBe(`Numeric ID`)
+      // String ID "1" is stored with key "s:1"
+      expect(parsed[`s:1`]).toBeDefined()
+      expect(parsed[`s:1`].data.title).toBe(`String ID`)
+
+      subscription.unsubscribe()
+    })
+
+    it(`should prevent collision between numeric key and string key that matches the encoding pattern`, async () => {
+      interface MixedIdTodo {
+        id: string | number
+        title: string
+      }
+
+      const collection = createCollection(
+        localStorageCollectionOptions<MixedIdTodo>({
+          storageKey: `collision-test-todos`,
+          storage: mockStorage,
+          storageEventApi: mockStorageEventApi,
+          getKey: (todo) => todo.id,
+        }),
+      )
+
+      const subscription = collection.subscribeChanges(() => {})
+
+      // Insert item with numeric ID 1
+      const tx1 = collection.insert({
+        id: 1,
+        title: `Numeric 1`,
+      })
+      await tx1.isPersisted.promise
+
+      // Insert item with string ID "n:1" (which would collide with old "__number__1" approach)
+      const tx2 = collection.insert({
+        id: `n:1`,
+        title: `String n:1`,
+      })
+      await tx2.isPersisted.promise
+
+      // Both should exist in collection
+      expect(collection.has(1)).toBe(true)
+      expect(collection.has(`n:1`)).toBe(true)
+      expect(collection.get(1)?.title).toBe(`Numeric 1`)
+      expect(collection.get(`n:1`)?.title).toBe(`String n:1`)
+
+      // Verify in storage - they should have different encoded keys
+      const storedData = mockStorage.getItem(`collision-test-todos`)
+      expect(storedData).toBeDefined()
+      const parsed = JSON.parse(storedData!)
+
+      // There should be TWO distinct entries
+      expect(Object.keys(parsed).length).toBe(2)
+      // Numeric 1 → "n:1"
+      expect(parsed[`n:1`]).toBeDefined()
+      expect(parsed[`n:1`].data.title).toBe(`Numeric 1`)
+      // String "n:1" → "s:n:1"
+      expect(parsed[`s:n:1`]).toBeDefined()
+      expect(parsed[`s:n:1`].data.title).toBe(`String n:1`)
 
       subscription.unsubscribe()
     })
diff --git a/packages/db/tests/optimistic-action.test.ts b/packages/db/tests/optimistic-action.test.ts
index 25dd4c092..5b2572bc9 100644
--- a/packages/db/tests/optimistic-action.test.ts
+++ b/packages/db/tests/optimistic-action.test.ts
@@ -1,10 +1,10 @@
-import { describe, expect, expectTypeOf, it, vi } from "vitest"
-import { createCollection, createOptimisticAction } from "../src"
+import { describe, expect, expectTypeOf, it, vi } from 'vitest'
+import { createCollection, createOptimisticAction } from '../src'
 import type {
   MutationFnParams,
   Transaction,
   TransactionWithMutations,
-} from "../src"
+} from '../src'
 
 describe(`createOptimisticAction`, () => {
   // Runtime tests
@@ -58,6 +58,31 @@ describe(`createOptimisticAction`, () => {
     expect(mutationFnMock.mock.calls[0]?.[1]).toHaveProperty(`transaction`)
   })
 
+  it(`should throw if onMutate returns a promise`, () => {
+    const collection = createCollection<{ id: string; text: string }>({
+      id: `async-on-mutate-collection`,
+      getKey: (item) => item.id,
+      sync: {
+        sync: () => {
+          // No-op sync for testing
+        },
+      },
+    })
+
+    const addTodo = createOptimisticAction<string>({
+      onMutate: async (text) => {
+        collection.insert({ id: `1`, text })
+      },
+      mutationFn: async () => {
+        return Promise.resolve()
+      },
+    })
+
+    expect(() => addTodo(`Async Todo`)).toThrowError(
+      `onMutate must be synchronous`,
+    )
+  })
+
   // Test with complex object variables
   it(`should handle complex object variables correctly`, async () => {
     // Setup a mock collection
@@ -140,7 +165,7 @@ describe(`createOptimisticAction`, () => {
         expectTypeOf(text).toBeString()
         expectTypeOf(params).toEqualTypeOf<MutationFnParams>()
         expectTypeOf(
-          params.transaction
+          params.transaction,
         ).toEqualTypeOf<TransactionWithMutations>()
         return Promise.resolve({ success: true })
       },
@@ -171,7 +196,7 @@ describe(`createOptimisticAction`, () => {
         expectTypeOf(user.id).toBeNumber()
         expectTypeOf(params).toEqualTypeOf<MutationFnParams>()
         expectTypeOf(
-          params.transaction
+          params.transaction,
         ).toEqualTypeOf<TransactionWithMutations>()
         return Promise.resolve({ success: true })
       },
diff --git a/packages/db/tests/paced-mutations.test.ts b/packages/db/tests/paced-mutations.test.ts
new file mode 100644
index 000000000..026ed314a
--- /dev/null
+++ b/packages/db/tests/paced-mutations.test.ts
@@ -0,0 +1,598 @@
+import { describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../src/collection'
+import { createPacedMutations } from '../src/paced-mutations'
+import {
+  debounceStrategy,
+  queueStrategy,
+  throttleStrategy,
+} from '../src/strategies'
+import { mockSyncCollectionOptionsNoInitialState } from './utils'
+
+type Item = {
+  id: number
+  value: number
+}
+
+/**
+ * Helper to create a collection that's ready for testing.
+ * Handles all the boilerplate setup: preload, begin, commit, markReady.
+ */
+async function createReadyCollection<T extends object>(opts: {
+  id: string
+  getKey: (item: T) => string | number
+}) {
+  const collection = createCollection(
+    mockSyncCollectionOptionsNoInitialState<T>(opts),
+  )
+
+  const preloadPromise = collection.preload()
+  collection.utils.begin()
+  collection.utils.commit()
+  collection.utils.markReady()
+  await preloadPromise
+
+  return collection
+}
+
+describe(`createPacedMutations`, () => {
+  describe(`with debounce strategy`, () => {
+    it(`should batch multiple rapid mutations into a single transaction`, async () => {
+      const mutationFn = vi.fn(async () => {})
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      let insertCount = 0
+      const mutate = createPacedMutations<{ 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 }),
+      })
+
+      // Trigger three rapid mutations (all within 50ms debounce window)
+      const tx1 = mutate({ id: 1, value: 1 })
+      const tx2 = mutate({ id: 1, value: 2 })
+      const tx3 = mutate({ 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 = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      let insertCount = 0
+      const mutate = createPacedMutations<{ 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
+      mutate({ 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)
+      mutate({ 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 as any)[0]
+      expect(firstCall[0].transaction.mutations).toHaveLength(1)
+    })
+
+    it(`should execute on leading edge when leading: true`, async () => {
+      const mutationFn = vi.fn(async () => {})
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: debounceStrategy({ wait: 50, leading: true }),
+      })
+
+      // First mutation should execute immediately with leading: true
+      const tx1 = mutate({ id: 1, value: 1 })
+
+      // Small delay for immediate execution
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Should have been called immediately (leading edge)
+      expect(mutationFn).toHaveBeenCalledTimes(1)
+      expect(tx1.state).toBe(`completed`)
+    })
+  })
+
+  describe(`with throttle strategy`, () => {
+    it(`should throttle mutations with leading and trailing execution`, async () => {
+      const mutationFn = vi.fn(async () => {})
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: throttleStrategy({
+          wait: 100,
+          leading: true,
+          trailing: true,
+        }),
+      })
+
+      // First mutation at t=0 (should execute immediately due to leading: true)
+      const tx1 = mutate({ 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)
+      const tx2 = mutate({ id: 2, value: 2 })
+
+      // Third mutation at t=30 (during throttle period, should batch with second)
+      await new Promise((resolve) => setTimeout(resolve, 10))
+      const tx3 = mutate({ 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 leading: false option`, async () => {
+      const mutationFn = vi.fn(async () => {})
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: throttleStrategy({
+          wait: 50,
+          leading: false,
+          trailing: true,
+        }),
+      })
+
+      // First mutation should NOT execute immediately with leading: false
+      const tx1 = mutate({ id: 1, value: 1 })
+
+      // 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(`with queue strategy`, () => {
+    it(`should process mutations sequentially`, async () => {
+      const mutationFn = vi.fn(async () => {
+        // Quick execution
+        await new Promise((resolve) => setTimeout(resolve, 5))
+      })
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: queueStrategy({ wait: 10 }),
+      })
+
+      // Trigger rapid mutations - queue creates separate transactions
+      const tx1 = mutate({ id: 1, value: 1 })
+      const tx2 = mutate({ id: 2, value: 2 })
+      const tx3 = mutate({ id: 3, value: 3 })
+
+      // Each should be a different transaction
+      expect(tx1).not.toBe(tx2)
+      expect(tx2).not.toBe(tx3)
+
+      // Queue starts processing immediately
+      await new Promise((resolve) => setTimeout(resolve, 5))
+      expect(mutationFn).toHaveBeenCalledTimes(1)
+
+      // Wait for first 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)
+      expect(tx1.mutations[0]).toMatchObject({
+        type: `insert`,
+        changes: { id: 1, value: 1 },
+      })
+    })
+
+    it(`should ensure serialization - wait for each transaction to complete`, async () => {
+      const executionOrder: Array<number> = []
+      let currentlyExecuting = false
+
+      const mutationFn = vi.fn(async ({ transaction }) => {
+        // Verify no concurrent execution
+        expect(currentlyExecuting).toBe(false)
+        currentlyExecuting = true
+
+        const id = transaction.mutations[0].changes.id
+        executionOrder.push(id)
+
+        // Simulate async work
+        await new Promise((resolve) => setTimeout(resolve, 20))
+
+        currentlyExecuting = false
+      })
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: queueStrategy({ wait: 5 }),
+      })
+
+      // Trigger rapid mutations
+      const tx1 = mutate({ id: 1, value: 1 })
+      const tx2 = mutate({ id: 2, value: 2 })
+      const tx3 = mutate({ id: 3, value: 3 })
+
+      // Wait for all to complete
+      await Promise.all([
+        tx1.isPersisted.promise,
+        tx2.isPersisted.promise,
+        tx3.isPersisted.promise,
+      ])
+
+      // Should have executed in order
+      expect(executionOrder).toEqual([1, 2, 3])
+
+      // All should be completed
+      expect(tx1.state).toBe(`completed`)
+      expect(tx2.state).toBe(`completed`)
+      expect(tx3.state).toBe(`completed`)
+    })
+
+    it(`should process each mutation in its own transaction`, async () => {
+      const mutationFn = vi.fn(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 5))
+      })
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: queueStrategy({ wait: 5 }),
+      })
+
+      const tx1 = mutate({ id: 1, value: 1 })
+      const tx2 = mutate({ id: 2, value: 2 })
+      const tx3 = mutate({ id: 3, value: 3 })
+
+      // Each should be a separate transaction
+      expect(tx1).not.toBe(tx2)
+      expect(tx2).not.toBe(tx3)
+      expect(tx1).not.toBe(tx3)
+
+      await Promise.all([
+        tx1.isPersisted.promise,
+        tx2.isPersisted.promise,
+        tx3.isPersisted.promise,
+      ])
+
+      // All mutations should have been executed
+      expect(mutationFn).toHaveBeenCalledTimes(3)
+
+      // Each transaction should have exactly one mutation
+      expect(tx1.mutations).toHaveLength(1)
+      expect(tx2.mutations).toHaveLength(1)
+      expect(tx3.mutations).toHaveLength(1)
+    })
+
+    it(`should work with zero or no wait option`, async () => {
+      const mutationFn = vi.fn(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 5))
+      })
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      // Test with explicit wait: 0
+      const mutateExplicitZero = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: queueStrategy({ wait: 0 }),
+      })
+
+      const tx1 = mutateExplicitZero({ id: 1, value: 1 })
+      const tx2 = mutateExplicitZero({ id: 2, value: 2 })
+
+      // Should still process sequentially even with zero wait
+      await Promise.all([tx1.isPersisted.promise, tx2.isPersisted.promise])
+
+      expect(mutationFn).toHaveBeenCalledTimes(2)
+      expect(tx1.state).toBe(`completed`)
+      expect(tx2.state).toBe(`completed`)
+
+      mutationFn.mockClear()
+
+      // Test with no wait option (defaults to 0)
+      const mutateNoWait = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: queueStrategy(),
+      })
+
+      const tx3 = mutateNoWait({ id: 3, value: 3 })
+      const tx4 = mutateNoWait({ id: 4, value: 4 })
+
+      await Promise.all([tx3.isPersisted.promise, tx4.isPersisted.promise])
+
+      expect(mutationFn).toHaveBeenCalledTimes(2)
+      expect(tx3.state).toBe(`completed`)
+      expect(tx4.state).toBe(`completed`)
+    })
+  })
+
+  describe(`error handling`, () => {
+    it(`should handle mutationFn errors and set transaction to failed state`, async () => {
+      const error = new Error(`Mutation failed`)
+      const mutationFn = vi.fn(async () => {
+        throw error
+      })
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: debounceStrategy({ wait: 10 }),
+      })
+
+      const tx = mutate({ id: 1, value: 1 })
+
+      // Wait for debounce
+      await new Promise((resolve) => setTimeout(resolve, 30))
+
+      // Transaction should be in failed state
+      expect(tx.state).toBe(`failed`)
+      await expect(tx.isPersisted.promise).rejects.toThrow(`Mutation failed`)
+    })
+
+    it(`should continue processing queue after an error`, async () => {
+      const mutationFn = vi
+        .fn()
+        .mockRejectedValueOnce(new Error(`First failed`))
+        .mockResolvedValueOnce(undefined)
+        .mockResolvedValueOnce(undefined)
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: queueStrategy({ wait: 10 }),
+      })
+
+      const tx1 = mutate({ id: 1, value: 1 })
+      const tx2 = mutate({ id: 2, value: 2 })
+      const tx3 = mutate({ id: 3, value: 3 })
+
+      // Wait for all to settle
+      await Promise.allSettled([
+        tx1.isPersisted.promise,
+        tx2.isPersisted.promise,
+        tx3.isPersisted.promise,
+      ])
+
+      // First should fail, rest should succeed
+      expect(tx1.state).toBe(`failed`)
+      expect(tx2.state).toBe(`completed`)
+      expect(tx3.state).toBe(`completed`)
+
+      // All three should have been attempted
+      expect(mutationFn).toHaveBeenCalledTimes(3)
+    })
+  })
+
+  describe(`transaction batching`, () => {
+    it(`should merge mutations on the same key`, async () => {
+      const mutationFn = vi.fn(async () => {})
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      let insertCount = 0
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          if (insertCount === 0) {
+            collection.insert(item)
+            insertCount++
+          } else {
+            collection.update(item.id, (draft) => {
+              draft.value = item.value
+            })
+          }
+        },
+        mutationFn,
+        strategy: debounceStrategy({ wait: 50 }),
+      })
+
+      // Insert then update same key - should merge to single insert
+      mutate({ id: 1, value: 1 })
+      mutate({ id: 1, value: 2 })
+      mutate({ id: 1, value: 3 })
+
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      expect(mutationFn).toHaveBeenCalledTimes(1)
+      const call = (mutationFn.mock.calls as any)[0][0]
+      expect(call.transaction.mutations).toHaveLength(1)
+      expect(call.transaction.mutations[0]).toMatchObject({
+        type: `insert`,
+        changes: { id: 1, value: 3 }, // Final value
+      })
+    })
+
+    it(`should batch mutations on different keys`, async () => {
+      const mutationFn = vi.fn(async () => {})
+
+      const collection = await createReadyCollection<Item>({
+        id: `test`,
+        getKey: (item) => item.id,
+      })
+
+      const mutate = createPacedMutations<Item>({
+        onMutate: (item) => {
+          collection.insert(item)
+        },
+        mutationFn,
+        strategy: debounceStrategy({ wait: 50 }),
+      })
+
+      // Multiple inserts on different keys
+      mutate({ id: 1, value: 1 })
+      mutate({ id: 2, value: 2 })
+      mutate({ id: 3, value: 3 })
+
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      expect(mutationFn).toHaveBeenCalledTimes(1)
+      const call = (mutationFn.mock.calls as any)[0][0]
+      expect(call.transaction.mutations).toHaveLength(3)
+    })
+  })
+})
diff --git a/packages/db/tests/proxy.test.ts b/packages/db/tests/proxy.test.ts
index f063d43a7..40b5da5a3 100644
--- a/packages/db/tests/proxy.test.ts
+++ b/packages/db/tests/proxy.test.ts
@@ -1,11 +1,11 @@
-import { describe, expect, it } from "vitest"
-import { Temporal } from "temporal-polyfill"
+import { describe, expect, it } from 'vitest'
+import { Temporal } from 'temporal-polyfill'
 import {
   createArrayChangeProxy,
   createChangeProxy,
   withArrayChangeTracking,
   withChangeTracking,
-} from "../src/proxy"
+} from '../src/proxy'
 
 describe(`Proxy Library`, () => {
   describe(`createChangeProxy`, () => {
@@ -139,7 +139,7 @@ describe(`Proxy Library`, () => {
       obj.self = obj // Create circular reference
 
       const { proxy, getChanges } = createChangeProxy(
-        obj as Record<string | symbol, any>
+        obj as Record<string | symbol, any>,
       )
 
       proxy.name = `Jane`
@@ -360,125 +360,287 @@ describe(`Proxy Library`, () => {
     // })
   })
 
-  // describe(`Object.freeze and Object.seal handling`, () => {
-  //   it(`should handle Object.freeze correctly`, () => {
-  //     const obj = { name: `John`, age: 30 }
-  //     const { proxy, getChanges } = createChangeProxy(obj)
-  //
-  //     // Freeze the proxy
-  //     Object.freeze(proxy)
-  //
-  //     // Attempt to modify the frozen proxy (should throw in strict mode)
-  //     let errorThrown = false
-  //     let errorMessage = ``
-  //     try {
-  //       proxy.name = `Jane`
-  //     } catch (e) {
-  //       // Expected error
-  //       errorThrown = true
-  //       errorMessage = e instanceof Error ? e.message : String(e)
-  //     }
-  //
-  //     // In strict mode, an error should be thrown
-  //     if (errorThrown) {
-  //       // Verify the error message contains expected text about the property being read-only
-  //       expect(errorMessage).toContain(`read only property`)
-  //     }
-  //
-  //     // Either way, no changes should be tracked
-  //     expect(getChanges()).toEqual({})
-  //
-  //     // Check that the original object is unchanged
-  //     expect(obj).toEqual({
-  //       name: `John`,
-  //       age: 30,
-  //     })
-  //   })
-
-  // it(`should handle Object.seal correctly`, () => {
-  //   const obj = { name: `John`, age: 30 }
-  //   const { proxy, getChanges } = createChangeProxy(obj)
-  //
-  //   // Seal the proxy
-  //   Object.seal(proxy)
-  //
-  //   // Modify existing property (should work)
-  //   proxy.name = `Jane`
-  //
-  //   // Attempt to add a new property (should not work)
-  //   let errorThrown = false
-  //   let errorMessage = ``
-  //   try {
-  //     // @ts-expect-error ignore for test
-  //     proxy.role = `admin`
-  //   } catch (e) {
-  //     // Expected error
-  //     errorThrown = true
-  //     errorMessage = e instanceof Error ? e.message : String(e)
-  //   }
-  //
-  //   // In strict mode, an error should be thrown
-  //   if (errorThrown) {
-  //     // Verify the error message contains expected text about the object not being extensible
-  //     expect(errorMessage).toContain(`object is not extensible`)
-  //   }
-  //
-  //   // Check that only the name change was tracked
-  //   expect(getChanges()).toEqual({
-  //     name: `Jane`,
-  //   })
-  //
-  //   // Check that the original object has the name change but no new property
-  //   expect(obj).toEqual({
-  //     name: `Jane`,
-  //     age: 30,
-  //   })
-  //
-  //   expect(obj.hasOwnProperty(`role`)).toBe(false)
-  // })
-
-  // it(`should handle Object.preventExtensions correctly`, () => {
-  //   const obj = { name: `John`, age: 30 }
-  //   const { proxy, getChanges } = createChangeProxy(obj)
-  //
-  //   // Prevent extensions on the proxy
-  //   Object.preventExtensions(proxy)
-  //
-  //   // Modify existing property (should work)
-  //   proxy.name = `Jane`
-  //
-  //   // Attempt to add a new property (should not work)
-  //   let errorThrown = false
-  //   let errorMessage = ``
-  //   try {
-  //     // @ts-expect-error ignore for test
-  //     proxy.role = `admin`
-  //   } catch (e) {
-  //     // Expected error
-  //     errorThrown = true
-  //     errorMessage = e instanceof Error ? e.message : String(e)
-  //   }
-  //
-  //   // In strict mode, an error should be thrown
-  //   if (errorThrown) {
-  //     // Verify the error message contains expected text about the object not being extensible
-  //     expect(errorMessage).toContain(`object is not extensible`)
-  //   }
-  //
-  //   // Check that only the name change was tracked
-  //   expect(getChanges()).toEqual({
-  //     name: `Jane`,
-  //   })
-  //
-  //   // Check that the original object has the name change but no new property
-  //   expect(obj).toEqual({
-  //     name: `Jane`,
-  //     age: 30,
-  //   })
-  //
-  //   expect(obj.hasOwnProperty(`role`)).toBe(false)
-  // })
-  // })
+  describe(`Frozen object handling`, () => {
+    it(`should handle creating a proxy for an already-frozen object`, () => {
+      const obj = { name: `John`, age: 30 }
+      Object.freeze(obj)
+
+      // This should not throw - the proxy should work with frozen objects
+      const { proxy, getChanges } = createChangeProxy(obj)
+
+      // Modify properties via the proxy
+      proxy.name = `Jane`
+      proxy.age = 31
+
+      // Changes should be tracked
+      expect(getChanges()).toEqual({
+        name: `Jane`,
+        age: 31,
+      })
+
+      // Original frozen object should remain unchanged
+      expect(obj).toEqual({
+        name: `John`,
+        age: 30,
+      })
+      expect(Object.isFrozen(obj)).toBe(true)
+    })
+
+    it(`should handle deeply frozen nested objects`, () => {
+      const obj = {
+        user: {
+          name: `John`,
+          address: {
+            city: `NYC`,
+            zip: `10001`,
+          },
+        },
+      }
+      // Deep freeze the object
+      Object.freeze(obj)
+      Object.freeze(obj.user)
+      Object.freeze(obj.user.address)
+
+      const { proxy, getChanges } = createChangeProxy(obj)
+
+      // Modify nested properties
+      proxy.user.name = `Jane`
+      proxy.user.address.city = `LA`
+
+      // Changes should be tracked
+      expect(getChanges()).toEqual({
+        user: {
+          name: `Jane`,
+          address: {
+            city: `LA`,
+            zip: `10001`,
+          },
+        },
+      })
+
+      // Original should be unchanged
+      expect(obj.user.name).toBe(`John`)
+      expect(obj.user.address.city).toBe(`NYC`)
+    })
+
+    it(`should handle withArrayChangeTracking with frozen objects`, () => {
+      const item1 = { id: 1, name: `Item 1` }
+      const item2 = { id: 2, name: `Item 2` }
+      Object.freeze(item1)
+      Object.freeze(item2)
+      const frozenArray = [item1, item2]
+      Object.freeze(frozenArray)
+
+      // This should not throw - matches the RTK Query adapter use case
+      const changes = withArrayChangeTracking(frozenArray, (drafts) => {
+        if (drafts[0]) {
+          drafts[0].name = `Updated Item 1`
+        }
+      })
+
+      // Changes should be captured
+      expect(changes[0]).toEqual({ name: `Updated Item 1` })
+      expect(changes[1]).toEqual({})
+
+      // Original frozen objects should be unchanged
+      expect(item1.name).toBe(`Item 1`)
+      expect(Object.isFrozen(item1)).toBe(true)
+    })
+
+    it(`should handle withChangeTracking with a frozen object`, () => {
+      const obj = { id: 1, name: `Test`, value: 100 }
+      Object.freeze(obj)
+
+      const changes = withChangeTracking(obj, (draft) => {
+        draft.name = `Updated`
+        draft.value = 200
+      })
+
+      expect(changes).toEqual({
+        name: `Updated`,
+        value: 200,
+      })
+
+      // Original should be unchanged
+      expect(obj.name).toBe(`Test`)
+      expect(obj.value).toBe(100)
+    })
+
+    it(`should handle frozen arrays with nested frozen objects`, () => {
+      const data = [
+        { id: 1, details: { score: 10 } },
+        { id: 2, details: { score: 20 } },
+      ]
+      // Deep freeze everything
+      data.forEach((item) => {
+        Object.freeze(item.details)
+        Object.freeze(item)
+      })
+      Object.freeze(data)
+
+      const changes = withArrayChangeTracking(data, (drafts) => {
+        // Modify nested property
+        if (drafts[0]) {
+          drafts[0].details.score = 100
+        }
+      })
+
+      expect(changes[0]).toEqual({
+        details: { score: 100 },
+      })
+
+      // Original should be unchanged
+      expect(data[0]!.details.score).toBe(10)
+    })
+
+    it(`should handle iteration over frozen array elements`, () => {
+      const items = [
+        { id: 1, name: `A` },
+        { id: 2, name: `B` },
+        { id: 3, name: `C` },
+      ]
+      items.forEach((item) => Object.freeze(item))
+      Object.freeze(items)
+
+      const changes = withArrayChangeTracking(items, (drafts) => {
+        // Use find to locate and modify an item
+        const found = drafts.find((d) => d.id === 2)
+        if (found) {
+          found.name = `Updated B`
+        }
+      })
+
+      expect(changes[1]).toEqual({ name: `Updated B` })
+      expect(items[1]!.name).toBe(`B`) // Original unchanged
+    })
+
+    it(`should handle createArrayChangeProxy with frozen objects`, () => {
+      const items = [
+        { id: 1, status: `pending` },
+        { id: 2, status: `pending` },
+      ]
+      items.forEach((item) => Object.freeze(item))
+
+      const { proxies, getChanges } = createArrayChangeProxy(items)
+
+      proxies[0]!.status = `completed`
+      proxies[1]!.status = `in-progress`
+
+      const changes = getChanges()
+      expect(changes[0]).toEqual({ status: `completed` })
+      expect(changes[1]).toEqual({ status: `in-progress` })
+    })
+  })
+
+  describe(`Object.seal and Object.preventExtensions handling`, () => {
+    it(`should handle Object.seal correctly`, () => {
+      const obj = { name: `John`, age: 30 }
+      const { proxy, getChanges } = createChangeProxy(obj)
+
+      // Seal the proxy
+      Object.seal(proxy)
+
+      // Modify existing property (should work)
+      proxy.name = `Jane`
+
+      // Attempt to add a new property (should throw in strict mode)
+      expect(() => {
+        // @ts-expect-error testing runtime behavior
+        proxy.role = `admin`
+      }).toThrow(/not extensible/)
+
+      // Check that only the name change was tracked
+      expect(getChanges()).toEqual({
+        name: `Jane`,
+      })
+
+      // Original object should be unchanged
+      expect(obj).toEqual({
+        name: `John`,
+        age: 30,
+      })
+    })
+
+    it(`should handle Object.preventExtensions correctly`, () => {
+      const obj = { name: `John`, age: 30 }
+      const { proxy, getChanges } = createChangeProxy(obj)
+
+      // Prevent extensions on the proxy
+      Object.preventExtensions(proxy)
+
+      // Modify existing property (should work)
+      proxy.name = `Jane`
+
+      // Attempt to add a new property (should throw)
+      expect(() => {
+        // @ts-expect-error testing runtime behavior
+        proxy.role = `admin`
+      }).toThrow(/not extensible/)
+
+      // Check that only the name change was tracked
+      expect(getChanges()).toEqual({
+        name: `Jane`,
+      })
+
+      // Original object should be unchanged
+      expect(obj).toEqual({
+        name: `John`,
+        age: 30,
+      })
+    })
+
+    it(`should allow deleting properties with preventExtensions (but not seal)`, () => {
+      const obj = { name: `John`, age: 30 }
+      const { proxy, getChanges } = createChangeProxy(obj)
+
+      // Object.preventExtensions allows deletion of configurable properties
+      // Object.seal makes properties non-configurable, so delete wouldn't work
+      Object.preventExtensions(proxy)
+
+      // Modify and delete
+      proxy.name = `Jane`
+      // @ts-expect-error testing delete on non-optional property
+      delete proxy.age
+
+      // Only the modified property is returned by getChanges
+      // (deleted properties are tracked internally but not in the result)
+      const changes = getChanges()
+      expect(changes.name).toBe(`Jane`)
+    })
+
+    it(`should not allow deleting properties on sealed objects`, () => {
+      const obj = { name: `John`, age: 30 }
+      const { proxy } = createChangeProxy(obj)
+
+      // Object.seal makes properties non-configurable
+      Object.seal(proxy)
+
+      // In strict mode (which Vitest uses), deleting a non-configurable property throws
+      expect(() => {
+        // @ts-expect-error testing delete on non-optional property
+        delete proxy.age
+      }).toThrow()
+
+      // Property should still exist
+      expect(proxy.age).toBe(30)
+    })
+
+    it(`should handle sealing a proxy with nested objects`, () => {
+      const obj = { user: { name: `John` }, count: 0 }
+      const { proxy, getChanges } = createChangeProxy(obj)
+
+      Object.seal(proxy)
+
+      // Modifying nested objects should still work
+      proxy.user.name = `Jane`
+      proxy.count = 5
+
+      expect(getChanges()).toEqual({
+        user: { name: `Jane` },
+        count: 5,
+      })
+    })
+  })
 
   describe(`Enhanced Iterator Method Tracking`, () => {
     it(`should track changes when Map values are modified via iterator`, () => {
@@ -545,7 +707,7 @@ describe(`Proxy Library`, () => {
         expect.arrayContaining([
           { id: 1, value: `modified` },
           { id: 2, value: `two` },
-        ])
+        ]),
       )
     })
 
@@ -613,7 +775,7 @@ describe(`Proxy Library`, () => {
         expect.arrayContaining([
           { id: 1, value: `one` },
           { id: 2, value: `modified two` },
-        ])
+        ]),
       )
     })
 
@@ -697,7 +859,7 @@ describe(`Proxy Library`, () => {
         expect.arrayContaining([
           { id: 1, value: `modified` },
           { id: 2, value: `two` },
-        ])
+        ]),
       )
       expect(obj1.value).toBe(`one`) // Original unchanged
     })
@@ -762,7 +924,7 @@ describe(`Proxy Library`, () => {
         expect.arrayContaining([
           { id: 1, name: `Alice Admin` },
           { id: 2, name: `Bob` },
-        ])
+        ]),
       )
     })
   })
@@ -1653,5 +1815,166 @@ describe(`Proxy Library`, () => {
       })
       expect(obj.date).toEqual(originalDate)
     })
+
+    describe(`array iteration methods`, () => {
+      it(`should track changes when modifying array items retrieved via find()`, () => {
+        const obj = {
+          job: {
+            orders: [
+              { orderId: `order-1`, orderBinInt: 1 },
+              { orderId: `order-2`, orderBinInt: 2 },
+            ],
+          },
+        }
+        const { proxy, getChanges } = createChangeProxy(obj)
+
+        // Use find() to get an array item and modify it
+        const order = proxy.job.orders.find(
+          (order) => order.orderId === `order-1`,
+        )
+        if (order) {
+          order.orderBinInt = 99
+        }
+
+        const changes = getChanges()
+        expect(Object.keys(changes).length).toBeGreaterThan(0)
+        expect(changes.job?.orders?.[0]?.orderBinInt).toBe(99)
+      })
+
+      it(`should track changes when modifying array items via forEach`, () => {
+        const obj = {
+          items: [
+            { id: 1, value: 10 },
+            { id: 2, value: 20 },
+          ],
+        }
+        const { proxy, getChanges } = createChangeProxy(obj)
+
+        proxy.items.forEach((item) => {
+          item.value = item.value * 2
+        })
+
+        const changes = getChanges()
+        expect(Object.keys(changes).length).toBeGreaterThan(0)
+      })
+
+      it(`should track changes when modifying array items via for...of`, () => {
+        const obj = {
+          items: [
+            { id: 1, value: 10 },
+            { id: 2, value: 20 },
+          ],
+        }
+        const { proxy, getChanges } = createChangeProxy(obj)
+
+        for (const item of proxy.items) {
+          item.value = item.value * 2
+        }
+
+        const changes = getChanges()
+        expect(Object.keys(changes).length).toBeGreaterThan(0)
+      })
+
+      it(`should track changes when modifying array items via index access`, () => {
+        const obj = {
+          items: [
+            { id: 1, value: 10 },
+            { id: 2, value: 20 },
+          ],
+        }
+        const { proxy, getChanges } = createChangeProxy(obj)
+
+        // Direct index access should work
+        const firstItem = proxy.items[0]
+        if (firstItem) {
+          firstItem.value = 100
+        }
+
+        const changes = getChanges()
+        expect(Object.keys(changes).length).toBeGreaterThan(0)
+      })
+
+      it(`should track changes when modifying items from filter() result`, () => {
+        const obj = {
+          items: [
+            { id: 1, value: 10 },
+            { id: 2, value: 20 },
+          ],
+        }
+        const { proxy, getChanges } = createChangeProxy(obj)
+
+        const filtered = proxy.items.filter((item) => item.id === 1)
+        const first = filtered[0]
+        if (first) {
+          first.value = 42
+        }
+
+        const changes = getChanges()
+        expect(changes.items?.[0]?.value).toBe(42)
+      })
+
+      it(`should track changes when modifying array items retrieved via findLast()`, () => {
+        const obj = {
+          job: {
+            orders: [
+              { orderId: `order-1`, orderBinInt: 1 },
+              { orderId: `order-2`, orderBinInt: 2 },
+            ],
+          },
+        }
+        const { proxy, getChanges } = createChangeProxy(obj)
+
+        // Use type assertion to call findLast (ES2023 method)
+        type Order = { orderId: string; orderBinInt: number }
+        const orders = proxy.job.orders as unknown as {
+          findLast: (predicate: (o: Order) => boolean) => Order | undefined
+        }
+        const order = orders.findLast((o) => o.orderId.startsWith(`order-`))
+        if (order) {
+          order.orderBinInt = 123
+        }
+
+        const changes = getChanges()
+        expect(changes.job?.orders?.[1]?.orderBinInt).toBe(123)
+      })
+
+      it(`should track changes when modifying array items inside some() callback`, () => {
+        const obj = {
+          items: [
+            { id: 1, value: 10 },
+            { id: 2, value: 20 },
+          ],
+        }
+        const { proxy, getChanges } = createChangeProxy(obj)
+
+        proxy.items.some((item) => {
+          item.value = item.value * 2
+          return false
+        })
+
+        const changes = getChanges()
+        expect(changes.items?.[0]?.value).toBe(20)
+        expect(changes.items?.[1]?.value).toBe(40)
+      })
+
+      it(`should track changes when modifying array items inside reduce() callback`, () => {
+        const obj = {
+          items: [
+            { id: 1, value: 10 },
+            { id: 2, value: 20 },
+          ],
+        }
+        const { proxy, getChanges } = createChangeProxy(obj)
+
+        proxy.items.reduce((acc, item) => {
+          item.value = item.value + 1
+          return acc + item.value
+        }, 0)
+
+        const changes = getChanges()
+        expect(changes.items?.[0]?.value).toBe(11)
+        expect(changes.items?.[1]?.value).toBe(21)
+      })
+    })
   })
 })
diff --git a/packages/db/tests/query/basic.test-d.ts b/packages/db/tests/query/basic.test-d.ts
index 1817cd124..f4923172f 100644
--- a/packages/db/tests/query/basic.test-d.ts
+++ b/packages/db/tests/query/basic.test-d.ts
@@ -1,9 +1,9 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { z } from "zod"
-import { type } from "arktype"
-import { createLiveQueryCollection, eq, gt } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { z } from 'zod'
+import { type } from 'arktype'
+import { createLiveQueryCollection, eq, gt } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample user type for tests
 type User = {
@@ -26,7 +26,7 @@ function createUsersCollection() {
       id: `test-users`,
       getKey: (user) => user.id,
       initialData: sampleUsers,
-    })
+    }),
   )
 }
 
@@ -65,7 +65,7 @@ describe(`Query Basic Types`, () => {
         age: user.age,
         email: user.email,
         active: user.active,
-      }))
+      })),
     )
 
     const results = liveCollection.toArray
@@ -212,7 +212,7 @@ describe(`Query Basic Types`, () => {
 
   test(`query function syntax with no select returns original type`, () => {
     const liveCollection = createLiveQueryCollection((q) =>
-      q.from({ user: usersCollection }).where(({ user }) => gt(user.age, 20))
+      q.from({ user: usersCollection }).where(({ user }) => gt(user.age, 20)),
     )
 
     const results = liveCollection.toArray
@@ -233,7 +233,7 @@ describe(`Query Basic Types`, () => {
         id: `test-users-optional`,
         getKey: (user) => user.id,
         initialData: [],
-      })
+      }),
     )
 
     const liveCollection = createLiveQueryCollection({
@@ -330,7 +330,7 @@ describe(`Query Basic Types with ArkType Schemas`, () => {
     const userWithOptionalSchema = type({
       id: `number`,
       name: `string`,
-      "inserted_at?": `Date`, // Optional using "field?"
+      'inserted_at?': `Date`, // Optional using "field?"
     })
 
     const usersWithOptionalCollection = createCollection({
@@ -365,7 +365,7 @@ describe(`Query Basic Types with ArkType Schemas`, () => {
     const userWithUnionSchema = type({
       id: `number`,
       name: `string`,
-      "status?": `"active" | "inactive"`, // Union type with optional
+      'status?': `"active" | "inactive"`, // Union type with optional
     })
 
     const usersWithUnionCollection = createCollection({
@@ -402,7 +402,7 @@ describe(`Query Basic Types with ArkType Schemas`, () => {
     const userWithArraySchema = type({
       id: `number`,
       name: `string`,
-      "tags?": `string[]`, // Array type with optional
+      'tags?': `string[]`, // Array type with optional
     })
 
     const usersWithArrayCollection = createCollection({
@@ -440,7 +440,7 @@ describe(`Query Basic Types with ArkType Schemas`, () => {
       id: `number`,
       name: `string > 0`,
       age: `number.integer > 0`,
-      "email?": `string.email`,
+      'email?': `string.email`,
     })
 
     const usersCollection = createCollection({
diff --git a/packages/db/tests/query/basic.test.ts b/packages/db/tests/query/basic.test.ts
index dccb0eab0..1ca9c07d7 100644
--- a/packages/db/tests/query/basic.test.ts
+++ b/packages/db/tests/query/basic.test.ts
@@ -1,13 +1,13 @@
-import { beforeEach, describe, expect, test } from "vitest"
+import { beforeEach, describe, expect, test } from 'vitest'
 import {
   concat,
   createLiveQueryCollection,
   eq,
   gt,
   upper,
-} from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+} from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample user type for tests
 type User = {
@@ -102,7 +102,7 @@ function createUsersCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (user) => user.id,
       initialData: sampleUsers,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -131,7 +131,7 @@ function createBasicTests(autoIndex: `off` | `eager`) {
 
       expect(results).toHaveLength(4)
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Bob`, `Charlie`, `Dave`])
+        expect.arrayContaining([`Alice`, `Bob`, `Charlie`, `Dave`]),
       )
 
       // Insert a new user
@@ -184,7 +184,7 @@ function createBasicTests(autoIndex: `off` | `eager`) {
           age: user.age,
           email: user.email,
           active: user.active,
-        }))
+        })),
       )
 
       await liveCollection.preload()
@@ -193,7 +193,7 @@ function createBasicTests(autoIndex: `off` | `eager`) {
 
       expect(results).toHaveLength(4)
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Bob`, `Charlie`, `Dave`])
+        expect.arrayContaining([`Alice`, `Bob`, `Charlie`, `Dave`]),
       )
 
       // Insert a new user
@@ -257,7 +257,7 @@ function createBasicTests(autoIndex: `off` | `eager`) {
       expect(results).toHaveLength(3)
       expect(results.every((u) => u.active)).toBe(true)
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Bob`, `Dave`])
+        expect.arrayContaining([`Alice`, `Bob`, `Dave`]),
       )
 
       // Insert a new active user
@@ -354,7 +354,7 @@ function createBasicTests(autoIndex: `off` | `eager`) {
       })
 
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Charlie`, `Dave`])
+        expect.arrayContaining([`Alice`, `Charlie`, `Dave`]),
       )
 
       // Insert a new user over 20 (should be included)
@@ -615,7 +615,7 @@ function createBasicTests(autoIndex: `off` | `eager`) {
       })
 
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Bob`, `Dave`])
+        expect.arrayContaining([`Alice`, `Bob`, `Dave`]),
       )
 
       // Insert a new active user
@@ -659,7 +659,7 @@ function createBasicTests(autoIndex: `off` | `eager`) {
 
     test(`should return original collection type with query function syntax and no select`, async () => {
       const liveCollection = createLiveQueryCollection((q) =>
-        q.from({ user: usersCollection }).where(({ user }) => gt(user.age, 20))
+        q.from({ user: usersCollection }).where(({ user }) => gt(user.age, 20)),
       )
 
       await liveCollection.preload()
@@ -679,7 +679,7 @@ function createBasicTests(autoIndex: `off` | `eager`) {
       })
 
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Charlie`, `Dave`])
+        expect.arrayContaining([`Alice`, `Charlie`, `Dave`]),
       )
     })
 
@@ -712,12 +712,12 @@ function createBasicTests(autoIndex: `off` | `eager`) {
 
       // Verify that the computed field is correctly applied
       expect(results.map((u) => u.name_upper)).toEqual(
-        expect.arrayContaining([`ALICE`, `CHARLIE`, `DAVE`])
+        expect.arrayContaining([`ALICE`, `CHARLIE`, `DAVE`]),
       )
 
       // Verify original names are preserved
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Charlie`, `Dave`])
+        expect.arrayContaining([`Alice`, `Charlie`, `Dave`]),
       )
 
       // Test specific user data
@@ -787,7 +787,10 @@ function createBasicTests(autoIndex: `off` | `eager`) {
           q
             .from({ user: usersCollection })
             .where(({ user }) =>
-              eq(user.profile?.bio, `Software engineer with 5 years experience`)
+              eq(
+                user.profile?.bio,
+                `Software engineer with 5 years experience`,
+              ),
             )
             .select(({ user }) => ({
               id: user.id,
diff --git a/packages/db/tests/query/builder/buildQuery.test.ts b/packages/db/tests/query/builder/buildQuery.test.ts
index 9450c0656..431fbde06 100644
--- a/packages/db/tests/query/builder/buildQuery.test.ts
+++ b/packages/db/tests/query/builder/buildQuery.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, it } from "vitest"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { buildQuery } from "../../../src/query/builder/index.js"
-import { and, eq, gt, or } from "../../../src/query/builder/functions.js"
+import { describe, expect, it } from 'vitest'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { buildQuery } from '../../../src/query/builder/index.js'
+import { and, eq, gt, or } from '../../../src/query/builder/functions.js'
 
 /**
  * This is a set of tests for the buildQuery function.
@@ -46,7 +46,7 @@ describe(`buildQuery function`, () => {
         .select(({ employees }) => ({
           id: employees.id,
           name: employees.name,
-        }))
+        })),
     )
 
     // buildQuery returns Query IR directly
@@ -63,12 +63,12 @@ describe(`buildQuery function`, () => {
         .join(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
         .select(({ employees, departments }) => ({
           employee_name: employees.name,
           department_name: departments?.name,
-        }))
+        })),
     )
 
     expect(query.from).toBeDefined()
@@ -82,7 +82,7 @@ describe(`buildQuery function`, () => {
       q
         .from({ employees: employeesCollection })
         .where(({ employees }) =>
-          and(eq(employees.active, true), gt(employees.salary, 50000))
+          and(eq(employees.active, true), gt(employees.salary, 50000)),
         )
         .orderBy(({ employees }) => employees.name)
         .limit(10)
@@ -90,7 +90,7 @@ describe(`buildQuery function`, () => {
           id: employees.id,
           name: employees.name,
           salary: employees.salary,
-        }))
+        })),
     )
 
     expect(query.from).toBeDefined()
@@ -122,7 +122,7 @@ describe(`buildQuery function`, () => {
       q
         .from({ comment: commentsCollection })
         .join({ user: usersCollection }, ({ comment, user }) =>
-          eq(comment.user_id, user.id)
+          eq(comment.user_id, user.id),
         )
         .where(({ comment }) => or(eq(comment.id, 1), eq(comment.id, 2)))
         .orderBy(({ comment }) => comment.date, `desc`)
@@ -130,7 +130,7 @@ describe(`buildQuery function`, () => {
           id: comment.id,
           content: comment.content,
           user,
-        }))
+        })),
     )
 
     expect(query.from).toBeDefined()
diff --git a/packages/db/tests/query/builder/callback-types.test-d.ts b/packages/db/tests/query/builder/callback-types.test-d.ts
index e45b76bfa..0e901b7fb 100644
--- a/packages/db/tests/query/builder/callback-types.test-d.ts
+++ b/packages/db/tests/query/builder/callback-types.test-d.ts
@@ -1,7 +1,7 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { createCollection } from "../../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../../utils.js"
-import { Query } from "../../../src/query/builder/index.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { createCollection } from '../../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../../utils.js'
+import { Query } from '../../../src/query/builder/index.js'
 import {
   add,
   and,
@@ -24,9 +24,9 @@ import {
   or,
   sum,
   upper,
-} from "../../../src/query/builder/functions.js"
-import type { RefLeaf } from "../../../src/query/builder/types.js"
-import type { Aggregate, BasicExpression } from "../../../src/query/ir.js"
+} from '../../../src/query/builder/functions.js'
+import type { RefLeaf } from '../../../src/query/builder/types.js'
+import type { Aggregate, BasicExpression } from '../../../src/query/ir.js'
 
 // Sample data types for comprehensive callback type testing
 type User = {
@@ -64,7 +64,7 @@ function createTestCollections() {
       id: `test-users`,
       getKey: (user) => user.id,
       initialData: [],
-    })
+    }),
   )
 
   const departmentsCollection = createCollection(
@@ -72,7 +72,7 @@ function createTestCollections() {
       id: `test-departments`,
       getKey: (dept) => dept.id,
       initialData: [],
-    })
+    }),
   )
 
   const projectsCollection = createCollection(
@@ -80,7 +80,7 @@ function createTestCollections() {
       id: `test-projects`,
       getKey: (project) => project.id,
       initialData: [],
-    })
+    }),
   )
 
   return { usersCollection, departmentsCollection, projectsCollection }
@@ -115,12 +115,12 @@ describe(`Query Builder Callback Types`, () => {
       new Query()
         .from({ user: usersCollection })
         .join({ dept: departmentsCollection }, ({ user, dept }) =>
-          eq(user.department_id, dept.id)
+          eq(user.department_id, dept.id),
         )
         .select(({ user, dept }) => {
           // Test cross-table property access
           expectTypeOf(
-            user.department_id
+            user.department_id,
           ).toEqualTypeOf<RefLeaf<number> | null>()
           expectTypeOf(dept?.id).toEqualTypeOf<RefLeaf<number> | undefined>()
           expectTypeOf(dept?.name).toEqualTypeOf<RefLeaf<string> | undefined>()
@@ -229,7 +229,7 @@ describe(`Query Builder Callback Types`, () => {
         return and(
           eq(user.active, true),
           gt(user.age, 25),
-          like(user.email, `%@company.com`)
+          like(user.email, `%@company.com`),
         )
       })
     })
@@ -238,10 +238,10 @@ describe(`Query Builder Callback Types`, () => {
       new Query().from({ user: usersCollection }).where(({ user }) => {
         // Test logical operators
         expectTypeOf(
-          and(eq(user.active, true), gt(user.age, 25))
+          and(eq(user.active, true), gt(user.age, 25)),
         ).toEqualTypeOf<BasicExpression<boolean>>()
         expectTypeOf(
-          or(eq(user.active, false), lt(user.age, 18))
+          or(eq(user.active, false), lt(user.age, 18)),
         ).toEqualTypeOf<BasicExpression<boolean>>()
         expectTypeOf(not(eq(user.active, false))).toEqualTypeOf<
           BasicExpression<boolean>
@@ -250,7 +250,7 @@ describe(`Query Builder Callback Types`, () => {
         return and(
           eq(user.active, true),
           or(gt(user.age, 30), gte(user.salary, 75000)),
-          not(eq(user.department_id, null))
+          not(eq(user.department_id, null)),
         )
       })
     })
@@ -259,7 +259,7 @@ describe(`Query Builder Callback Types`, () => {
       new Query()
         .from({ user: usersCollection })
         .join({ dept: departmentsCollection }, ({ user, dept }) =>
-          eq(user.department_id, dept.id)
+          eq(user.department_id, dept.id),
         )
         .where(({ user, dept }) => {
           expectTypeOf(user.active).toEqualTypeOf<RefLeaf<boolean>>()
@@ -273,7 +273,7 @@ describe(`Query Builder Callback Types`, () => {
           return and(
             eq(user.active, true),
             eq(dept?.active, true),
-            gt(dept?.budget, 100000)
+            gt(dept?.budget, 100000),
           )
         })
     })
@@ -286,7 +286,7 @@ describe(`Query Builder Callback Types`, () => {
         .join({ dept: departmentsCollection }, ({ user, dept }) => {
           // Test property access for join conditions
           expectTypeOf(
-            user.department_id
+            user.department_id,
           ).toEqualTypeOf<RefLeaf<number> | null>()
           expectTypeOf(dept.id).toEqualTypeOf<RefLeaf<number>>()
 
@@ -300,7 +300,7 @@ describe(`Query Builder Callback Types`, () => {
         .join({ dept: departmentsCollection }, ({ user, dept }) => {
           // Test complex join conditions with multiple operators
           expectTypeOf(
-            and(eq(user.department_id, dept.id), eq(dept.active, true))
+            and(eq(user.department_id, dept.id), eq(dept.active, true)),
           ).toEqualTypeOf<BasicExpression<boolean>>()
 
           return and(eq(user.department_id, dept.id), eq(dept.active, true))
@@ -311,7 +311,7 @@ describe(`Query Builder Callback Types`, () => {
       new Query()
         .from({ user: usersCollection })
         .join({ dept: departmentsCollection }, ({ user, dept }) =>
-          eq(user.department_id, dept.id)
+          eq(user.department_id, dept.id),
         )
         .join({ project: projectsCollection }, ({ user, dept, project }) => {
           expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
@@ -321,7 +321,7 @@ describe(`Query Builder Callback Types`, () => {
 
           return and(
             eq(project.user_id, user.id),
-            eq(project.department_id, dept?.id)
+            eq(project.department_id, dept?.id),
           )
         })
     })
@@ -356,7 +356,7 @@ describe(`Query Builder Callback Types`, () => {
       new Query()
         .from({ user: usersCollection })
         .join({ dept: departmentsCollection }, ({ user, dept }) =>
-          eq(user.department_id, dept.id)
+          eq(user.department_id, dept.id),
         )
         .orderBy(({ user, dept }) => {
           expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
@@ -396,7 +396,7 @@ describe(`Query Builder Callback Types`, () => {
       new Query()
         .from({ user: usersCollection })
         .join({ dept: departmentsCollection }, ({ user, dept }) =>
-          eq(user.department_id, dept.id)
+          eq(user.department_id, dept.id),
         )
         .groupBy(({ user, dept }) => {
           expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
@@ -418,7 +418,7 @@ describe(`Query Builder Callback Types`, () => {
         .having(({ user }) => {
           expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
           expectTypeOf(
-            user.department_id
+            user.department_id,
           ).toEqualTypeOf<RefLeaf<number> | null>()
 
           return gt(count(user.id), 5)
@@ -432,7 +432,7 @@ describe(`Query Builder Callback Types`, () => {
         .having(({ user }) => {
           expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
           expectTypeOf(
-            user.department_id
+            user.department_id,
           ).toEqualTypeOf<RefLeaf<number> | null>()
           // Test aggregate functions in having
           expectTypeOf(count(user.id)).toEqualTypeOf<Aggregate<number>>()
@@ -444,7 +444,7 @@ describe(`Query Builder Callback Types`, () => {
           return and(
             gt(count(user.id), 5),
             gt(avg(user.age), 30),
-            gt(sum(user.salary), 300000)
+            gt(sum(user.salary), 300000),
           )
         })
     })
@@ -479,7 +479,7 @@ describe(`Query Builder Callback Types`, () => {
       new Query()
         .from({ user: usersCollection })
         .join({ dept: departmentsCollection }, ({ user, dept }) =>
-          eq(user.department_id, dept.id)
+          eq(user.department_id, dept.id),
         )
         .groupBy(({ dept }) => dept?.location)
         .having(({ user, dept }) => {
@@ -529,7 +529,7 @@ describe(`Query Builder Callback Types`, () => {
           return and(
             eq(user.active, true),
             eq(dept?.active, true),
-            eq(project?.status, `active`)
+            eq(project?.status, `active`),
           )
         })
         .groupBy(({ dept }) => {
@@ -570,4 +570,208 @@ describe(`Query Builder Callback Types`, () => {
         })
     })
   })
+
+  describe(`ORDER BY and HAVING with SELECT fields`, () => {
+    test(`orderBy callback can access aggregate fields from SELECT`, () => {
+      new Query()
+        .from({ user: usersCollection })
+        .groupBy(({ user }) => user.department_id)
+        .select(({ user }) => ({
+          department_id: user.department_id,
+          user_count: count(user.id),
+          avg_age: avg(user.age),
+          max_salary: max(user.salary),
+        }))
+        .orderBy(({ user, $selected }) => {
+          expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
+          expectTypeOf(
+            user.department_id,
+          ).toEqualTypeOf<RefLeaf<number> | null>()
+
+          expectTypeOf($selected.user_count).toEqualTypeOf<RefLeaf<number>>()
+          expectTypeOf($selected.avg_age).toEqualTypeOf<RefLeaf<number>>()
+          expectTypeOf($selected.max_salary).toEqualTypeOf<RefLeaf<number>>()
+          expectTypeOf(
+            $selected.department_id,
+          ).toEqualTypeOf<RefLeaf<number> | null>()
+
+          // Can now order by SELECT fields
+          return $selected.user_count
+        })
+    })
+
+    test(`orderBy callback can access non-aggregate fields from SELECT`, () => {
+      new Query()
+        .from({ user: usersCollection })
+        .groupBy(({ user }) => user.department_id)
+        .select(({ user }) => ({
+          taskId: user.department_id,
+          department_name: user.name, // Non-aggregate field
+          user_count: count(user.id),
+        }))
+        .orderBy(({ user, $selected }) => {
+          expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
+
+          expectTypeOf($selected.taskId).toEqualTypeOf<RefLeaf<number> | null>()
+          expectTypeOf($selected.department_name).toEqualTypeOf<
+            RefLeaf<string>
+          >()
+          expectTypeOf($selected.user_count).toEqualTypeOf<RefLeaf<number>>()
+
+          // Can now order by SELECT fields
+          return $selected.taskId
+        })
+    })
+
+    test(`having callback can access aggregate fields from SELECT`, () => {
+      new Query()
+        .from({ user: usersCollection })
+        .groupBy(({ user }) => user.department_id)
+        .select(({ user }) => ({
+          department_id: user.department_id,
+          user_count: count(user.id),
+          avg_age: avg(user.age),
+          total_salary: sum(user.salary),
+        }))
+        .having(({ user, $selected }) => {
+          expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
+
+          expectTypeOf($selected.user_count).toEqualTypeOf<RefLeaf<number>>()
+          expectTypeOf($selected.avg_age).toEqualTypeOf<RefLeaf<number>>()
+          expectTypeOf($selected.total_salary).toEqualTypeOf<RefLeaf<number>>()
+          expectTypeOf(
+            $selected.department_id,
+          ).toEqualTypeOf<RefLeaf<number> | null>()
+
+          // Can now use SELECT aliases in HAVING
+          return gt($selected.user_count, 5)
+        })
+    })
+
+    test(`having callback can access non-aggregate fields from SELECT`, () => {
+      new Query()
+        .from({ user: usersCollection })
+        .groupBy(({ user }) => user.department_id)
+        .select(({ user }) => ({
+          taskId: user.department_id,
+          department_name: user.name,
+          user_count: count(user.id),
+        }))
+        .having(({ user, $selected }) => {
+          expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
+
+          expectTypeOf($selected.taskId).toEqualTypeOf<RefLeaf<number> | null>()
+          expectTypeOf($selected.department_name).toEqualTypeOf<
+            RefLeaf<string>
+          >()
+          expectTypeOf($selected.user_count).toEqualTypeOf<RefLeaf<number>>()
+
+          // Can now use SELECT fields in HAVING
+          return gt($selected.user_count, 2)
+        })
+    })
+
+    test(`orderBy can access nested SELECT fields`, () => {
+      new Query()
+        .from({ user: usersCollection })
+        .select(({ user }) => ({
+          id: user.id,
+          profile: {
+            name: user.name,
+            email: user.email,
+          },
+          stats: {
+            age: user.age,
+            salary: user.salary,
+          },
+        }))
+        .orderBy(({ user, $selected }) => {
+          expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
+
+          expectTypeOf($selected.profile.name).toEqualTypeOf<RefLeaf<string>>()
+          expectTypeOf($selected.stats.age).toEqualTypeOf<RefLeaf<number>>()
+
+          return $selected.stats.age
+        })
+    })
+
+    test(`orderBy has access to SELECT fields via $selected`, () => {
+      new Query()
+        .from({ user: usersCollection })
+        .groupBy(({ user }) => user.department_id)
+        .select(({ user }) => ({
+          taskId: user.department_id,
+          latestActivity: max(user.created_at),
+          sessionCount: count(user.id),
+        }))
+        .orderBy(({ user, $selected }) => {
+          expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
+
+          expectTypeOf($selected.taskId).toEqualTypeOf<RefLeaf<number> | null>()
+          expectTypeOf($selected.sessionCount).toEqualTypeOf<RefLeaf<number>>()
+
+          return $selected.latestActivity
+        })
+    })
+
+    test(`having has access to SELECT fields via $selected`, () => {
+      new Query()
+        .from({ user: usersCollection })
+        .groupBy(({ user }) => user.department_id)
+        .select(({ user }) => ({
+          taskId: user.department_id,
+          user_count: count(user.id),
+          avg_salary: avg(user.salary),
+        }))
+        .having(({ user, $selected }) => {
+          expectTypeOf(user.id).toEqualTypeOf<RefLeaf<number>>()
+
+          expectTypeOf($selected.taskId).toEqualTypeOf<RefLeaf<number> | null>()
+          expectTypeOf($selected.user_count).toEqualTypeOf<RefLeaf<number>>()
+          expectTypeOf($selected.avg_salary).toEqualTypeOf<RefLeaf<number>>()
+
+          return gt($selected.user_count, 5)
+        })
+    })
+
+    test(`fn.having has access to SELECT fields via $selected`, () => {
+      new Query()
+        .from({ user: usersCollection })
+        .groupBy(({ user }) => user.department_id)
+        .select(({ user }) => ({
+          taskId: user.department_id,
+          user_count: count(user.id),
+          avg_salary: avg(user.salary),
+          total_salary: sum(user.salary),
+        }))
+        .fn.having(({ $selected }) => {
+          expectTypeOf($selected.taskId).toEqualTypeOf<number | null>()
+          expectTypeOf($selected.user_count).toEqualTypeOf<number>()
+          expectTypeOf($selected.avg_salary).toEqualTypeOf<number>()
+          expectTypeOf($selected.total_salary).toEqualTypeOf<number>()
+
+          return $selected.user_count > 5 && $selected.avg_salary > 50000
+        })
+    })
+
+    test(`fn.having can access nested SELECT fields`, () => {
+      new Query()
+        .from({ user: usersCollection })
+        .groupBy(({ user }) => user.department_id)
+        .select(({ user }) => ({
+          taskId: user.department_id,
+          stats: {
+            user_count: count(user.id),
+            avg_salary: avg(user.salary),
+          },
+        }))
+        .fn.having(({ $selected }) => {
+          expectTypeOf($selected.taskId).toEqualTypeOf<number | null>()
+          expectTypeOf($selected.stats.user_count).toEqualTypeOf<number>()
+          expectTypeOf($selected.stats.avg_salary).toEqualTypeOf<number>()
+
+          return $selected.stats.user_count > 2
+        })
+    })
+  })
 })
diff --git a/packages/db/tests/query/builder/from.test.ts b/packages/db/tests/query/builder/from.test.ts
index 62946b094..1f03a41d2 100644
--- a/packages/db/tests/query/builder/from.test.ts
+++ b/packages/db/tests/query/builder/from.test.ts
@@ -1,11 +1,12 @@
-import { describe, expect, it } from "vitest"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { Query, getQueryIR } from "../../../src/query/builder/index.js"
-import { eq } from "../../../src/query/builder/functions.js"
+import { describe, expect, it } from 'vitest'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { Query, getQueryIR } from '../../../src/query/builder/index.js'
+import { eq } from '../../../src/query/builder/functions.js'
 import {
+  InvalidSourceTypeError,
   OnlyOneSourceAllowedError,
   QueryMustHaveFromClauseError,
-} from "../../../src/errors"
+} from '../../../src/errors'
 
 // Test schema
 interface Employee {
@@ -108,4 +109,60 @@ describe(`QueryBuilder.from`, () => {
       } as any)
     }).toThrow(OnlyOneSourceAllowedError)
   })
+
+  it(`throws helpful error when passing a string instead of an object`, () => {
+    const builder = new Query()
+
+    expect(() => {
+      builder.from(`employees` as any)
+    }).toThrow(InvalidSourceTypeError)
+
+    expect(() => {
+      builder.from(`employees` as any)
+    }).toThrow(
+      /Invalid source for from clause: Expected an object with a single key-value pair/,
+    )
+  })
+
+  it(`throws helpful error when passing null`, () => {
+    const builder = new Query()
+
+    expect(() => {
+      builder.from(null as any)
+    }).toThrow(InvalidSourceTypeError)
+
+    expect(() => {
+      builder.from(null as any)
+    }).toThrow(
+      /Invalid source for from clause: Expected an object with a single key-value pair/,
+    )
+  })
+
+  it(`throws helpful error when passing an array`, () => {
+    const builder = new Query()
+
+    expect(() => {
+      builder.from([employeesCollection] as any)
+    }).toThrow(InvalidSourceTypeError)
+
+    expect(() => {
+      builder.from([employeesCollection] as any)
+    }).toThrow(
+      /Invalid source for from clause: Expected an object with a single key-value pair/,
+    )
+  })
+
+  it(`throws helpful error when passing undefined`, () => {
+    const builder = new Query()
+
+    expect(() => {
+      builder.from(undefined as any)
+    }).toThrow(InvalidSourceTypeError)
+
+    expect(() => {
+      builder.from(undefined as any)
+    }).toThrow(
+      /Invalid source for from clause: Expected an object with a single key-value pair/,
+    )
+  })
 })
diff --git a/packages/db/tests/query/builder/functional-variants.test.ts b/packages/db/tests/query/builder/functional-variants.test.ts
index 0ce18cf86..f39f914f7 100644
--- a/packages/db/tests/query/builder/functional-variants.test.ts
+++ b/packages/db/tests/query/builder/functional-variants.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, it } from "vitest"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { Query, getQueryIR } from "../../../src/query/builder/index.js"
-import { eq, gt } from "../../../src/query/builder/functions.js"
+import { describe, expect, it } from 'vitest'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { Query, getQueryIR } from '../../../src/query/builder/index.js'
+import { eq, gt } from '../../../src/query/builder/functions.js'
 
 // Test schema
 interface Employee {
@@ -75,7 +75,7 @@ describe(`QueryBuilder functional variants (fn)`, () => {
         .join(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
         .fn.select((row) => ({
           employeeName: row.employees.name,
@@ -132,7 +132,7 @@ describe(`QueryBuilder functional variants (fn)`, () => {
             row.employees.active &&
             row.employees.salary > 60000 &&
             (row.employees.department_id === 1 ||
-              row.employees.department_id === 2)
+              row.employees.department_id === 2),
         )
 
       const builtQuery = getQueryIR(query)
@@ -145,13 +145,13 @@ describe(`QueryBuilder functional variants (fn)`, () => {
         .join(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
         .fn.where(
           (row) =>
             row.employees.active &&
             row.departments !== undefined &&
-            row.departments.name !== `HR`
+            row.departments.name !== `HR`,
         )
 
       const builtQuery = getQueryIR(query)
@@ -219,14 +219,14 @@ describe(`QueryBuilder functional variants (fn)`, () => {
         .join(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
         .groupBy(({ departments }) => departments?.name)
         .fn.having(
           (row) =>
             row.employees.salary > 60000 &&
             row.departments !== undefined &&
-            row.departments.name !== `Temp`
+            row.departments.name !== `Temp`,
         )
 
       const builtQuery = getQueryIR(query)
@@ -241,7 +241,7 @@ describe(`QueryBuilder functional variants (fn)`, () => {
         .join(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
         .fn.where((row) => row.employees.active)
         .fn.where((row) => row.employees.salary > 40000)
diff --git a/packages/db/tests/query/builder/functions.test.ts b/packages/db/tests/query/builder/functions.test.ts
index 383771c7e..fb6cb4f35 100644
--- a/packages/db/tests/query/builder/functions.test.ts
+++ b/packages/db/tests/query/builder/functions.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { Query, getQueryIR } from "../../../src/query/builder/index.js"
+import { describe, expect, it } from 'vitest'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { Query, getQueryIR } from '../../../src/query/builder/index.js'
 import {
   add,
   and,
@@ -23,7 +23,7 @@ import {
   or,
   sum,
   upper,
-} from "../../../src/query/builder/functions.js"
+} from '../../../src/query/builder/functions.js'
 
 // Test schema
 interface Employee {
@@ -97,7 +97,7 @@ describe(`QueryBuilder Functions`, () => {
       const query = new Query()
         .from({ employees: employeesCollection })
         .where(({ employees }) =>
-          and(eq(employees.active, true), gt(employees.salary, 50000))
+          and(eq(employees.active, true), gt(employees.salary, 50000)),
         )
 
       const builtQuery = getQueryIR(query)
@@ -108,7 +108,7 @@ describe(`QueryBuilder Functions`, () => {
       const query = new Query()
         .from({ employees: employeesCollection })
         .where(({ employees }) =>
-          or(eq(employees.department_id, 1), eq(employees.department_id, 2))
+          or(eq(employees.department_id, 1), eq(employees.department_id, 2)),
         )
 
       const builtQuery = getQueryIR(query)
diff --git a/packages/db/tests/query/builder/group-by.test.ts b/packages/db/tests/query/builder/group-by.test.ts
index 3cbb9632f..3bec25303 100644
--- a/packages/db/tests/query/builder/group-by.test.ts
+++ b/packages/db/tests/query/builder/group-by.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, it } from "vitest"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { Query, getQueryIR } from "../../../src/query/builder/index.js"
-import { avg, count, eq, sum } from "../../../src/query/builder/functions.js"
+import { describe, expect, it } from 'vitest'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { Query, getQueryIR } from '../../../src/query/builder/index.js'
+import { avg, count, eq, sum } from '../../../src/query/builder/functions.js'
 
 // Test schema
 interface Employee {
diff --git a/packages/db/tests/query/builder/join.test.ts b/packages/db/tests/query/builder/join.test.ts
index 470ee3853..db75e3cbc 100644
--- a/packages/db/tests/query/builder/join.test.ts
+++ b/packages/db/tests/query/builder/join.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, it } from "vitest"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { Query, getQueryIR } from "../../../src/query/builder/index.js"
-import { and, eq, gt } from "../../../src/query/builder/functions.js"
+import { describe, expect, it } from 'vitest'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { Query, getQueryIR } from '../../../src/query/builder/index.js'
+import { and, eq, gt } from '../../../src/query/builder/functions.js'
 
 // Test schema
 interface Employee {
@@ -39,7 +39,7 @@ describe(`QueryBuilder.join`, () => {
       .join(
         { departments: departmentsCollection },
         ({ employees, departments }) =>
-          eq(employees.department_id, departments.id)
+          eq(employees.department_id, departments.id),
       )
 
     const builtQuery = getQueryIR(query)
@@ -72,10 +72,10 @@ describe(`QueryBuilder.join`, () => {
       .join(
         { departments: departmentsCollection },
         ({ employees, departments }) =>
-          eq(employees.department_id, departments.id)
+          eq(employees.department_id, departments.id),
       )
       .join({ projects: projectsCollection }, ({ departments, projects }) =>
-        eq(departments?.id, projects.department_id)
+        eq(departments?.id, projects.department_id),
       )
 
     const builtQuery = getQueryIR(query)
@@ -96,7 +96,7 @@ describe(`QueryBuilder.join`, () => {
       .join(
         { departments: departmentsCollection },
         ({ employees, departments }) =>
-          eq(employees.department_id, departments.id)
+          eq(employees.department_id, departments.id),
       )
       .select(({ employees, departments }) => ({
         id: employees.id,
@@ -120,7 +120,7 @@ describe(`QueryBuilder.join`, () => {
       .join(
         { departments: departmentsCollection },
         ({ employees, departments }) =>
-          eq(employees.department_id, departments.id)
+          eq(employees.department_id, departments.id),
       )
       .where(({ departments }) => gt(departments?.budget, 1000000))
 
@@ -138,7 +138,7 @@ describe(`QueryBuilder.join`, () => {
     const query = builder
       .from({ employees: employeesCollection })
       .join({ bigDepts: subQuery as any }, ({ employees, bigDepts }) =>
-        eq(employees.department_id, (bigDepts as any).id)
+        eq(employees.department_id, (bigDepts as any).id),
       )
 
     const builtQuery = getQueryIR(query)
@@ -157,10 +157,10 @@ describe(`QueryBuilder.join`, () => {
       .join(
         { departments: departmentsCollection },
         ({ employees, departments }) =>
-          eq(employees.department_id, departments.id)
+          eq(employees.department_id, departments.id),
       )
       .where(({ employees, departments }) =>
-        and(gt(employees.salary, 50000), gt(departments?.budget, 1000000))
+        and(gt(employees.salary, 50000), gt(departments?.budget, 1000000)),
       )
       .select(({ employees, departments }) => ({
         id: employees.id,
@@ -196,10 +196,10 @@ describe(`QueryBuilder.join`, () => {
       .join(
         { departments: departmentsCollection },
         ({ employees, departments }) =>
-          eq(employees.department_id, departments.id)
+          eq(employees.department_id, departments.id),
       )
       .join({ users: usersCollection }, ({ employees, users }) =>
-        eq(employees.id, users.employee_id)
+        eq(employees.id, users.employee_id),
       )
 
     const builtQuery = getQueryIR(query)
@@ -220,7 +220,7 @@ describe(`QueryBuilder.join`, () => {
       .join(
         { departments: departmentsCollection },
         ({ employees, departments }) =>
-          eq(employees.department_id, departments.id)
+          eq(employees.department_id, departments.id),
       )
       .select(({ employees, departments }) => ({
         employee: employees,
@@ -242,7 +242,7 @@ describe(`QueryBuilder.join`, () => {
           { departments: departmentsCollection },
           ({ employees, departments }) =>
             eq(employees.department_id, departments.id),
-          `left`
+          `left`,
         )
 
       const aliasQuery = builder
@@ -250,7 +250,7 @@ describe(`QueryBuilder.join`, () => {
         .leftJoin(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
 
       const explicitQueryIR = getQueryIR(explicitQuery)
@@ -268,7 +268,7 @@ describe(`QueryBuilder.join`, () => {
           { departments: departmentsCollection },
           ({ employees, departments }) =>
             eq(employees.department_id, departments.id),
-          `right`
+          `right`,
         )
 
       const aliasQuery = builder
@@ -276,7 +276,7 @@ describe(`QueryBuilder.join`, () => {
         .rightJoin(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
 
       const explicitQueryIR = getQueryIR(explicitQuery)
@@ -294,7 +294,7 @@ describe(`QueryBuilder.join`, () => {
           { departments: departmentsCollection },
           ({ employees, departments }) =>
             eq(employees.department_id, departments.id),
-          `inner`
+          `inner`,
         )
 
       const aliasQuery = builder
@@ -302,7 +302,7 @@ describe(`QueryBuilder.join`, () => {
         .innerJoin(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
 
       const explicitQueryIR = getQueryIR(explicitQuery)
@@ -320,7 +320,7 @@ describe(`QueryBuilder.join`, () => {
           { departments: departmentsCollection },
           ({ employees, departments }) =>
             eq(employees.department_id, departments.id),
-          `full`
+          `full`,
         )
 
       const aliasQuery = builder
@@ -328,7 +328,7 @@ describe(`QueryBuilder.join`, () => {
         .fullJoin(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
 
       const explicitQueryIR = getQueryIR(explicitQuery)
@@ -355,12 +355,12 @@ describe(`QueryBuilder.join`, () => {
         .leftJoin(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
         .innerJoin(
           { projects: projectsCollection },
           ({ departments, projects }) =>
-            eq(departments?.id, projects.department_id)
+            eq(departments?.id, projects.department_id),
         )
 
       const builtQuery = getQueryIR(query)
@@ -383,7 +383,7 @@ describe(`QueryBuilder.join`, () => {
         .innerJoin(
           { departments: departmentsCollection },
           ({ employees, departments }) =>
-            eq(employees.department_id, departments.id)
+            eq(employees.department_id, departments.id),
         )
         .where(({ departments }) => gt(departments.budget, 1000000))
         .select(({ employees, departments }) => ({
diff --git a/packages/db/tests/query/builder/order-by.test.ts b/packages/db/tests/query/builder/order-by.test.ts
index 378371d9e..10e23ce49 100644
--- a/packages/db/tests/query/builder/order-by.test.ts
+++ b/packages/db/tests/query/builder/order-by.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, it } from "vitest"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { Query, getQueryIR } from "../../../src/query/builder/index.js"
-import { eq, upper } from "../../../src/query/builder/functions.js"
+import { describe, expect, it } from 'vitest'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { Query, getQueryIR } from '../../../src/query/builder/index.js'
+import { eq, upper } from '../../../src/query/builder/functions.js'
 
 // Test schema
 interface Employee {
@@ -40,7 +40,7 @@ describe(`QueryBuilder.orderBy`, () => {
     ])
     expect(builtQuery.orderBy![0]!.compareOptions.direction).toBe(`asc`)
     expect(builtQuery.orderBy![0]!.compareOptions.nulls).toBe(`first`)
-    expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBe(`locale`)
+    expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBeUndefined()
   })
 
   it(`supports descending order`, () => {
@@ -62,7 +62,7 @@ describe(`QueryBuilder.orderBy`, () => {
     ])
     expect(builtQuery.orderBy![0]!.compareOptions.direction).toBe(`desc`)
     expect(builtQuery.orderBy![0]!.compareOptions.nulls).toBe(`first`)
-    expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBe(`locale`)
+    expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBeUndefined()
   })
 
   it(`supports ascending order explicitly`, () => {
@@ -94,7 +94,7 @@ describe(`QueryBuilder.orderBy`, () => {
     expect(builtQuery.orderBy).toHaveLength(1)
     expect(builtQuery.orderBy![0]!.compareOptions.direction).toBe(`asc`)
     expect(builtQuery.orderBy![0]!.compareOptions.nulls).toBe(`last`)
-    expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBe(`locale`)
+    expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBeUndefined()
   })
 
   it(`supports stringSort`, () => {
@@ -136,7 +136,7 @@ describe(`QueryBuilder.orderBy`, () => {
     expect(builtQuery.orderBy).toBeDefined()
     expect(builtQuery.orderBy).toHaveLength(1)
     expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBe(`locale`)
-    expect(builtQuery.orderBy![0]!.compareOptions.locale).toBe(`de-DE`)
+    expect((builtQuery.orderBy![0]!.compareOptions as any).locale).toBe(`de-DE`)
     expect(builtQuery.orderBy![0]!.compareOptions.nulls).toBe(`first`)
     expect(builtQuery.orderBy![0]!.compareOptions.direction).toBe(`asc`)
   })
@@ -160,8 +160,10 @@ describe(`QueryBuilder.orderBy`, () => {
     expect(builtQuery.orderBy).toBeDefined()
     expect(builtQuery.orderBy).toHaveLength(1)
     expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBe(`locale`)
-    expect(builtQuery.orderBy![0]!.compareOptions.locale).toBe(`de-DE`)
-    expect(builtQuery.orderBy![0]!.compareOptions.localeOptions).toEqual({
+    expect((builtQuery.orderBy![0]!.compareOptions as any).locale).toBe(`de-DE`)
+    expect(
+      (builtQuery.orderBy![0]!.compareOptions as any).localeOptions,
+    ).toEqual({
       sensitivity: `base`,
     })
     expect(builtQuery.orderBy![0]!.compareOptions.nulls).toBe(`first`)
@@ -202,7 +204,7 @@ describe(`QueryBuilder.orderBy`, () => {
     expect(orderByClause.expression.type).toBeDefined()
     expect(orderByClause.compareOptions.direction).toBe(`asc`)
     expect(orderByClause.compareOptions.nulls).toBe(`first`)
-    expect(orderByClause.compareOptions.stringSort).toBe(`locale`)
+    expect(orderByClause.compareOptions.stringSort).toBeUndefined()
   })
 
   it(`can be combined with other clauses`, () => {
@@ -241,14 +243,14 @@ describe(`QueryBuilder.orderBy`, () => {
     ])
     expect(builtQuery.orderBy![0]!.compareOptions.direction).toBe(`asc`)
     expect(builtQuery.orderBy![0]!.compareOptions.nulls).toBe(`first`)
-    expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBe(`locale`)
+    expect(builtQuery.orderBy![0]!.compareOptions.stringSort).toBeUndefined()
     expect((builtQuery.orderBy![1]!.expression as any).path).toEqual([
       `employees`,
       `salary`,
     ])
     expect(builtQuery.orderBy![1]!.compareOptions.direction).toBe(`desc`)
     expect(builtQuery.orderBy![1]!.compareOptions.nulls).toBe(`first`)
-    expect(builtQuery.orderBy![1]!.compareOptions.stringSort).toBe(`locale`)
+    expect(builtQuery.orderBy![1]!.compareOptions.stringSort).toBeUndefined()
   })
 
   it(`supports limit and offset with order by`, () => {
diff --git a/packages/db/tests/query/builder/ref-proxy.test.ts b/packages/db/tests/query/builder/ref-proxy.test.ts
index d979e0935..ec41351da 100644
--- a/packages/db/tests/query/builder/ref-proxy.test.ts
+++ b/packages/db/tests/query/builder/ref-proxy.test.ts
@@ -1,11 +1,11 @@
-import { describe, expect, it } from "vitest"
+import { describe, expect, it } from 'vitest'
 import {
   createRefProxy,
   isRefProxy,
   toExpression,
   val,
-} from "../../../src/query/builder/ref-proxy.js"
-import { PropRef, Value } from "../../../src/query/ir.js"
+} from '../../../src/query/builder/ref-proxy.js'
+import { PropRef, Value } from '../../../src/query/ir.js'
 
 describe(`ref-proxy`, () => {
   describe(`createRefProxy`, () => {
@@ -100,7 +100,7 @@ describe(`ref-proxy`, () => {
 
       const nonexistentDesc = Object.getOwnPropertyDescriptor(
         proxy,
-        `nonexistent`
+        `nonexistent`,
       )
       expect(nonexistentDesc).toBeUndefined()
     })
@@ -114,7 +114,7 @@ describe(`ref-proxy`, () => {
       const keys = Object.getOwnPropertyNames((proxy as any).users)
       // table spread sentinel should exist on table proxy
       expect(keys.some((k) => k.startsWith(`__SPREAD_SENTINEL__users__`))).toBe(
-        true
+        true,
       )
     })
 
diff --git a/packages/db/tests/query/builder/select.test.ts b/packages/db/tests/query/builder/select.test.ts
index 3c8ae4352..53d9c134e 100644
--- a/packages/db/tests/query/builder/select.test.ts
+++ b/packages/db/tests/query/builder/select.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { Query, getQueryIR } from "../../../src/query/builder/index.js"
+import { describe, expect, it } from 'vitest'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { Query, getQueryIR } from '../../../src/query/builder/index.js'
 import {
   avg,
   count,
@@ -9,7 +9,7 @@ import {
   length,
   not,
   upper,
-} from "../../../src/query/builder/functions.js"
+} from '../../../src/query/builder/functions.js'
 
 // Test schema
 interface Employee {
diff --git a/packages/db/tests/query/builder/subqueries.test-d.ts b/packages/db/tests/query/builder/subqueries.test-d.ts
index 88fdedd47..f8343e395 100644
--- a/packages/db/tests/query/builder/subqueries.test-d.ts
+++ b/packages/db/tests/query/builder/subqueries.test-d.ts
@@ -1,9 +1,9 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { Query } from "../../../src/query/builder/index.js"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { avg, count, eq } from "../../../src/query/builder/functions.js"
-import type { ExtractContext } from "../../../src/query/builder/index.js"
-import type { GetResult } from "../../../src/query/builder/types.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { Query } from '../../../src/query/builder/index.js'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { avg, count, eq } from '../../../src/query/builder/functions.js'
+import type { ExtractContext } from '../../../src/query/builder/index.js'
+import type { GetResult } from '../../../src/query/builder/types.js'
 
 // Test schema types
 interface Issue {
@@ -114,7 +114,7 @@ describe(`Subquery Types`, () => {
       const _query = new Query()
         .from({ issue: issuesCollection })
         .join({ activeUser: activeUsersQuery }, ({ issue, activeUser }) =>
-          eq(issue.userId, activeUser.id)
+          eq(issue.userId, activeUser.id),
         )
         .select(({ issue, activeUser }) => ({
           issueId: issue.id,
@@ -144,7 +144,7 @@ describe(`Subquery Types`, () => {
       const _query = new Query()
         .from({ issue: issuesCollection })
         .join({ activeUser: userNamesQuery }, ({ issue, activeUser }) =>
-          eq(issue.userId, activeUser.id)
+          eq(issue.userId, activeUser.id),
         )
         .select(({ issue, activeUser }) => ({
           issueId: issue.id,
@@ -246,7 +246,7 @@ describe(`Subquery Types`, () => {
       const _query = new Query()
         .from({ issue: issuesCollection })
         .join({ activeUser: activeUsers }, ({ issue, activeUser }) =>
-          eq(issue.userId, activeUser.id)
+          eq(issue.userId, activeUser.id),
         )
         .select(({ issue, activeUser }) => ({
           issueId: issue.id,
@@ -270,7 +270,7 @@ describe(`Subquery Types`, () => {
       const _query = new Query()
         .from({ issue: filteredIssues })
         .join({ user: usersCollection }, ({ issue, user }) =>
-          eq(issue.userId, user.id)
+          eq(issue.userId, user.id),
         )
         .select(({ issue, user }) => ({
           issueId: issue.id,
diff --git a/packages/db/tests/query/builder/where.test.ts b/packages/db/tests/query/builder/where.test.ts
index 7021cc790..78036d953 100644
--- a/packages/db/tests/query/builder/where.test.ts
+++ b/packages/db/tests/query/builder/where.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { Query, getQueryIR } from "../../../src/query/builder/index.js"
+import { describe, expect, it } from 'vitest'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { Query, getQueryIR } from '../../../src/query/builder/index.js'
 import {
   and,
   eq,
@@ -12,7 +12,8 @@ import {
   lte,
   not,
   or,
-} from "../../../src/query/builder/functions.js"
+} from '../../../src/query/builder/functions.js'
+import { InvalidWhereExpressionError } from '../../../src/errors.js'
 
 // Test schema
 interface Employee {
@@ -80,7 +81,7 @@ describe(`QueryBuilder.where`, () => {
     const andQuery = builder
       .from({ employees: employeesCollection })
       .where(({ employees }) =>
-        and(eq(employees.active, true), gt(employees.salary, 50000))
+        and(eq(employees.active, true), gt(employees.salary, 50000)),
       )
     expect((getQueryIR(andQuery).where as any)[0]?.name).toBe(`and`)
 
@@ -88,7 +89,7 @@ describe(`QueryBuilder.where`, () => {
     const orQuery = builder
       .from({ employees: employeesCollection })
       .where(({ employees }) =>
-        or(eq(employees.department_id, 1), eq(employees.department_id, 2))
+        or(eq(employees.department_id, 1), eq(employees.department_id, 2)),
       )
     expect((getQueryIR(orQuery).where as any)[0]?.name).toBe(`or`)
 
@@ -146,8 +147,8 @@ describe(`QueryBuilder.where`, () => {
       .where(({ employees }) =>
         and(
           eq(employees.active, true),
-          or(gt(employees.salary, 75000), eq(employees.department_id, 1))
-        )
+          or(gt(employees.salary, 75000), eq(employees.department_id, 1)),
+        ),
       )
 
     const builtQuery = getQueryIR(query)
@@ -185,4 +186,57 @@ describe(`QueryBuilder.where`, () => {
     expect((builtQuery.where as any)[0]?.name).toBe(`eq`)
     expect((builtQuery.where as any)[1]?.name).toBe(`gt`)
   })
+
+  describe(`error handling`, () => {
+    it(`throws InvalidWhereExpressionError when using JavaScript === operator`, () => {
+      const builder = new Query()
+      expect(() =>
+        builder
+          .from({ employees: employeesCollection })
+          // This is a common mistake - using JavaScript's === instead of eq()
+          .where(({ employees }) => (employees.id as any) === 1),
+      ).toThrow(InvalidWhereExpressionError)
+    })
+
+    it(`throws InvalidWhereExpressionError when callback returns a boolean`, () => {
+      const builder = new Query()
+      expect(() =>
+        builder
+          .from({ employees: employeesCollection })
+          .where(() => true as any),
+      ).toThrow(InvalidWhereExpressionError)
+    })
+
+    it(`throws InvalidWhereExpressionError when callback returns undefined`, () => {
+      const builder = new Query()
+      expect(() =>
+        builder
+          .from({ employees: employeesCollection })
+          .where(() => undefined as any),
+      ).toThrow(InvalidWhereExpressionError)
+    })
+
+    it(`throws InvalidWhereExpressionError when callback returns null`, () => {
+      const builder = new Query()
+      expect(() =>
+        builder
+          .from({ employees: employeesCollection })
+          .where(() => null as any),
+      ).toThrow(InvalidWhereExpressionError)
+    })
+
+    it(`throws InvalidWhereExpressionError with helpful message mentioning eq()`, () => {
+      const builder = new Query()
+      try {
+        builder
+          .from({ employees: employeesCollection })
+          .where(({ employees }) => (employees.id as any) === 1)
+        expect.fail(`Expected error to be thrown`)
+      } catch (e) {
+        expect(e).toBeInstanceOf(InvalidWhereExpressionError)
+        expect((e as Error).message).toContain(`eq(`)
+        expect((e as Error).message).toContain(`===`)
+      }
+    })
+  })
 })
diff --git a/packages/db/tests/query/compiler/basic.test.ts b/packages/db/tests/query/compiler/basic.test.ts
index 32c548d8e..66b7a1514 100644
--- a/packages/db/tests/query/compiler/basic.test.ts
+++ b/packages/db/tests/query/compiler/basic.test.ts
@@ -1,9 +1,9 @@
-import { describe, expect, test } from "vitest"
-import { D2, MultiSet, output } from "@tanstack/db-ivm"
-import { compileQuery } from "../../../src/query/compiler/index.js"
-import { CollectionRef, Func, PropRef, Value } from "../../../src/query/ir.js"
-import type { QueryIR } from "../../../src/query/ir.js"
-import type { CollectionImpl } from "../../../src/collection/index.js"
+import { describe, expect, test } from 'vitest'
+import { D2, MultiSet, output } from '@tanstack/db-ivm'
+import { compileQuery } from '../../../src/query/compiler/index.js'
+import { CollectionRef, Func, PropRef, Value } from '../../../src/query/ir.js'
+import type { QueryIR } from '../../../src/query/ir.js'
+import type { CollectionImpl } from '../../../src/collection/index.js'
 
 // Sample user type for tests
 type User = {
@@ -51,20 +51,20 @@ describe(`Query2 Compiler`, () => {
         {},
         new Set(),
         {},
-        () => {}
+        () => {},
       )
 
       const messages: Array<MultiSet<any>> = []
       pipeline.pipe(
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
 
       input.sendData(
-        new MultiSet(sampleUsers.map((user) => [[user.id, user], 1]))
+        new MultiSet(sampleUsers.map((user) => [[user.id, user], 1])),
       )
 
       graph.run()
@@ -107,20 +107,20 @@ describe(`Query2 Compiler`, () => {
         {},
         new Set(),
         {},
-        () => {}
+        () => {},
       )
 
       const messages: Array<MultiSet<any>> = []
       pipeline.pipe(
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
 
       input.sendData(
-        new MultiSet(sampleUsers.map((user) => [[user.id, user], 1]))
+        new MultiSet(sampleUsers.map((user) => [[user.id, user], 1])),
       )
 
       graph.run()
@@ -185,20 +185,20 @@ describe(`Query2 Compiler`, () => {
         {},
         new Set(),
         {},
-        () => {}
+        () => {},
       )
 
       const messages: Array<MultiSet<any>> = []
       pipeline.pipe(
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
 
       input.sendData(
-        new MultiSet(sampleUsers.map((user) => [[user.id, user], 1]))
+        new MultiSet(sampleUsers.map((user) => [[user.id, user], 1])),
       )
 
       graph.run()
@@ -251,20 +251,20 @@ describe(`Query2 Compiler`, () => {
         {},
         new Set(),
         {},
-        () => {}
+        () => {},
       )
 
       const messages: Array<MultiSet<any>> = []
       pipeline.pipe(
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
 
       input.sendData(
-        new MultiSet(sampleUsers.map((user) => [[user.id, user], 1]))
+        new MultiSet(sampleUsers.map((user) => [[user.id, user], 1])),
       )
 
       graph.run()
diff --git a/packages/db/tests/query/compiler/evaluators.test.ts b/packages/db/tests/query/compiler/evaluators.test.ts
index 1cb987321..68e08d7ea 100644
--- a/packages/db/tests/query/compiler/evaluators.test.ts
+++ b/packages/db/tests/query/compiler/evaluators.test.ts
@@ -1,14 +1,14 @@
-import { describe, expect, it } from "vitest"
-import { compileExpression } from "../../../src/query/compiler/evaluators.js"
-import { Func, PropRef, Value } from "../../../src/query/ir.js"
-import type { NamespacedRow } from "../../../src/types.js"
+import { describe, expect, it } from 'vitest'
+import { compileExpression } from '../../../src/query/compiler/evaluators.js'
+import { Func, PropRef, Value } from '../../../src/query/ir.js'
+import type { NamespacedRow } from '../../../src/types.js'
 
 describe(`evaluators`, () => {
   describe(`compileExpression`, () => {
     it(`handles unknown expression type`, () => {
       const unknownExpr = { type: `unknown` } as any
       expect(() => compileExpression(unknownExpr)).toThrow(
-        `Unknown expression type: unknown`
+        `Unknown expression type: unknown`,
       )
     })
 
@@ -16,7 +16,7 @@ describe(`evaluators`, () => {
       it(`throws error for empty reference path`, () => {
         const emptyRef = new PropRef([])
         expect(() => compileExpression(emptyRef)).toThrow(
-          `Reference path cannot be empty`
+          `Reference path cannot be empty`,
         )
       })
 
@@ -75,7 +75,7 @@ describe(`evaluators`, () => {
       it(`throws error for unknown function`, () => {
         const unknownFunc = new Func(`unknownFunc`, [])
         expect(() => compileExpression(unknownFunc)).toThrow(
-          `Unknown function: unknownFunc`
+          `Unknown function: unknownFunc`,
         )
       })
 
@@ -168,11 +168,33 @@ describe(`evaluators`, () => {
         })
 
         it(`handles in with array`, () => {
-          const func = new Func(`in`, [new Value(2), new Value([1, 2, 3])])
+          const func = new Func(`in`, [
+            new Value(2),
+            new Value([1, 2, 3, null]),
+          ])
           const compiled = compileExpression(func)
 
           expect(compiled({})).toBe(true)
         })
+
+        it(`handles in with null value (3-valued logic)`, () => {
+          const func = new Func(`in`, [new Value(null), new Value([1, 2, 3])])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, null in array returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles in with undefined value (3-valued logic)`, () => {
+          const func = new Func(`in`, [
+            new Value(undefined),
+            new Value([1, 2, 3]),
+          ])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, undefined in array returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
       })
 
       describe(`math functions`, () => {
@@ -257,6 +279,44 @@ describe(`evaluators`, () => {
           expect(compiled({})).toBe(true)
         })
 
+        it(`handles like with null value (3-valued logic)`, () => {
+          const func = new Func(`like`, [new Value(null), new Value(`hello%`)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, like with null value returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles like with undefined value (3-valued logic)`, () => {
+          const func = new Func(`like`, [
+            new Value(undefined),
+            new Value(`hello%`),
+          ])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, like with undefined value returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles like with null pattern (3-valued logic)`, () => {
+          const func = new Func(`like`, [new Value(`hello`), new Value(null)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, like with null pattern returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles like with undefined pattern (3-valued logic)`, () => {
+          const func = new Func(`like`, [
+            new Value(`hello`),
+            new Value(undefined),
+          ])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, like with undefined pattern returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
+
         it(`handles ilike (case insensitive)`, () => {
           const func = new Func(`ilike`, [
             new Value(`HELLO`),
@@ -276,6 +336,347 @@ describe(`evaluators`, () => {
 
           expect(compiled({})).toBe(true)
         })
+
+        it(`handles ilike with null value (3-valued logic)`, () => {
+          const func = new Func(`ilike`, [new Value(null), new Value(`hello%`)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, ilike with null value returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles ilike with undefined value (3-valued logic)`, () => {
+          const func = new Func(`ilike`, [
+            new Value(undefined),
+            new Value(`hello%`),
+          ])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, ilike with undefined value returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles ilike with null pattern (3-valued logic)`, () => {
+          const func = new Func(`ilike`, [new Value(`hello`), new Value(null)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, ilike with null pattern returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles ilike with undefined pattern (3-valued logic)`, () => {
+          const func = new Func(`ilike`, [
+            new Value(`hello`),
+            new Value(undefined),
+          ])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, ilike with undefined pattern returns UNKNOWN (null)
+          expect(compiled({})).toBe(null)
+        })
+      })
+
+      describe(`comparison operators`, () => {
+        describe(`eq (equality)`, () => {
+          it(`handles eq with null and null (3-valued logic)`, () => {
+            const func = new Func(`eq`, [new Value(null), new Value(null)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, null = null returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles eq with null and value (3-valued logic)`, () => {
+            const func = new Func(`eq`, [new Value(null), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, null = value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles eq with value and null (3-valued logic)`, () => {
+            const func = new Func(`eq`, [new Value(5), new Value(null)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, value = null returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles eq with undefined and value (3-valued logic)`, () => {
+            const func = new Func(`eq`, [new Value(undefined), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, undefined = value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles eq with matching values`, () => {
+            const func = new Func(`eq`, [new Value(5), new Value(5)])
+            const compiled = compileExpression(func)
+
+            expect(compiled({})).toBe(true)
+          })
+
+          it(`handles eq with non-matching values`, () => {
+            const func = new Func(`eq`, [new Value(5), new Value(10)])
+            const compiled = compileExpression(func)
+
+            expect(compiled({})).toBe(false)
+          })
+
+          it(`handles eq with matching Uint8Arrays (content equality)`, () => {
+            const array1 = new Uint8Array([1, 2, 3, 4, 5])
+            const array2 = new Uint8Array([1, 2, 3, 4, 5])
+            const func = new Func(`eq`, [new Value(array1), new Value(array2)])
+            const compiled = compileExpression(func)
+
+            // Should return true because content is the same
+            expect(compiled({})).toBe(true)
+          })
+
+          it(`handles eq with non-matching Uint8Arrays (different content)`, () => {
+            const array1 = new Uint8Array([1, 2, 3, 4, 5])
+            const array2 = new Uint8Array([1, 2, 3, 4, 6])
+            const func = new Func(`eq`, [new Value(array1), new Value(array2)])
+            const compiled = compileExpression(func)
+
+            // Should return false because content is different
+            expect(compiled({})).toBe(false)
+          })
+
+          it(`handles eq with Uint8Arrays of different lengths`, () => {
+            const array1 = new Uint8Array([1, 2, 3, 4])
+            const array2 = new Uint8Array([1, 2, 3, 4, 5])
+            const func = new Func(`eq`, [new Value(array1), new Value(array2)])
+            const compiled = compileExpression(func)
+
+            // Should return false because lengths are different
+            expect(compiled({})).toBe(false)
+          })
+
+          it(`handles eq with same Uint8Array reference`, () => {
+            const array = new Uint8Array([1, 2, 3, 4, 5])
+            const func = new Func(`eq`, [new Value(array), new Value(array)])
+            const compiled = compileExpression(func)
+
+            // Should return true (fast path for reference equality)
+            expect(compiled({})).toBe(true)
+          })
+
+          it(`handles eq with Uint8Array and non-Uint8Array`, () => {
+            const array = new Uint8Array([1, 2, 3])
+            const value = [1, 2, 3]
+            const func = new Func(`eq`, [new Value(array), new Value(value)])
+            const compiled = compileExpression(func)
+
+            // Should return false because types are different
+            expect(compiled({})).toBe(false)
+          })
+
+          it(`handles eq with ULIDs (16-byte Uint8Arrays)`, () => {
+            // Simulate ULID comparison - 16 bytes
+            const ulid1 = new Uint8Array(16)
+            const ulid2 = new Uint8Array(16)
+
+            // Fill with same values
+            for (let i = 0; i < 16; i++) {
+              ulid1[i] = i
+              ulid2[i] = i
+            }
+
+            const func = new Func(`eq`, [new Value(ulid1), new Value(ulid2)])
+            const compiled = compileExpression(func)
+
+            // Should return true because content is identical
+            expect(compiled({})).toBe(true)
+          })
+
+          it(`handles eq with Buffers (if available)`, () => {
+            if (typeof Buffer !== `undefined`) {
+              const buffer1 = Buffer.from([1, 2, 3, 4, 5])
+              const buffer2 = Buffer.from([1, 2, 3, 4, 5])
+              const func = new Func(`eq`, [
+                new Value(buffer1),
+                new Value(buffer2),
+              ])
+              const compiled = compileExpression(func)
+
+              // Should return true because content is the same
+              expect(compiled({})).toBe(true)
+            }
+          })
+
+          it(`handles eq with Date objects (should compare by getTime(), not reference)`, () => {
+            // Create two Date objects with the same time value
+            // They are different object instances but represent the same moment
+            const date1 = new Date(`2024-01-15T10:30:45.123Z`)
+            const date2 = new Date(`2024-01-15T10:30:45.123Z`)
+
+            // Verify they are different object references
+            expect(date1).not.toBe(date2)
+            // But they have the same time value
+            expect(date1.getTime()).toBe(date2.getTime())
+
+            const func = new Func(`eq`, [new Value(date1), new Value(date2)])
+            const compiled = compileExpression(func)
+
+            // Should return true because they represent the same time
+            // Currently this fails because eq() does referential comparison
+            expect(compiled({})).toBe(true)
+          })
+
+          it(`handles eq with Date objects with different times`, () => {
+            const date1 = new Date(`2024-01-15T10:30:45.123Z`)
+            const date2 = new Date(`2024-01-15T10:30:45.124Z`) // 1ms later
+
+            const func = new Func(`eq`, [new Value(date1), new Value(date2)])
+            const compiled = compileExpression(func)
+
+            // Should return false because they represent different times
+            expect(compiled({})).toBe(false)
+          })
+
+          it(`handles eq with Uint8Arrays created with length (repro case)`, () => {
+            // Reproduction of user's issue: new Uint8Array(5) creates [0,0,0,0,0]
+            const array1 = new Uint8Array(5) // Creates array of length 5, all zeros
+            const array2 = new Uint8Array(5) // Creates another array of length 5, all zeros
+            const func = new Func(`eq`, [new Value(array1), new Value(array2)])
+            const compiled = compileExpression(func)
+
+            // Should return true because both have same content (all zeros)
+            expect(compiled({})).toBe(true)
+          })
+
+          it(`handles eq with empty Uint8Arrays`, () => {
+            const array1 = new Uint8Array(0)
+            const array2 = new Uint8Array(0)
+            const func = new Func(`eq`, [new Value(array1), new Value(array2)])
+            const compiled = compileExpression(func)
+
+            // Empty arrays should be equal
+            expect(compiled({})).toBe(true)
+          })
+
+          it(`still handles eq with strings correctly`, () => {
+            const func1 = new Func(`eq`, [
+              new Value(`hello`),
+              new Value(`hello`),
+            ])
+            const compiled1 = compileExpression(func1)
+            expect(compiled1({})).toBe(true)
+
+            const func2 = new Func(`eq`, [
+              new Value(`hello`),
+              new Value(`world`),
+            ])
+            const compiled2 = compileExpression(func2)
+            expect(compiled2({})).toBe(false)
+          })
+
+          it(`still handles eq with numbers correctly`, () => {
+            const func1 = new Func(`eq`, [new Value(42), new Value(42)])
+            const compiled1 = compileExpression(func1)
+            expect(compiled1({})).toBe(true)
+
+            const func2 = new Func(`eq`, [new Value(42), new Value(43)])
+            const compiled2 = compileExpression(func2)
+            expect(compiled2({})).toBe(false)
+          })
+        })
+
+        describe(`gt (greater than)`, () => {
+          it(`handles gt with null and value (3-valued logic)`, () => {
+            const func = new Func(`gt`, [new Value(null), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, null > value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles gt with value and null (3-valued logic)`, () => {
+            const func = new Func(`gt`, [new Value(5), new Value(null)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, value > null returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles gt with undefined (3-valued logic)`, () => {
+            const func = new Func(`gt`, [new Value(undefined), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, undefined > value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles gt with valid values`, () => {
+            const func = new Func(`gt`, [new Value(10), new Value(5)])
+            const compiled = compileExpression(func)
+
+            expect(compiled({})).toBe(true)
+          })
+        })
+
+        describe(`gte (greater than or equal)`, () => {
+          it(`handles gte with null (3-valued logic)`, () => {
+            const func = new Func(`gte`, [new Value(null), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, null >= value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles gte with undefined (3-valued logic)`, () => {
+            const func = new Func(`gte`, [new Value(undefined), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, undefined >= value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+        })
+
+        describe(`lt (less than)`, () => {
+          it(`handles lt with null (3-valued logic)`, () => {
+            const func = new Func(`lt`, [new Value(null), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, null < value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles lt with undefined (3-valued logic)`, () => {
+            const func = new Func(`lt`, [new Value(undefined), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, undefined < value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles lt with valid values`, () => {
+            const func = new Func(`lt`, [new Value(3), new Value(5)])
+            const compiled = compileExpression(func)
+
+            expect(compiled({})).toBe(true)
+          })
+        })
+
+        describe(`lte (less than or equal)`, () => {
+          it(`handles lte with null (3-valued logic)`, () => {
+            const func = new Func(`lte`, [new Value(null), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, null <= value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+
+          it(`handles lte with undefined (3-valued logic)`, () => {
+            const func = new Func(`lte`, [new Value(undefined), new Value(5)])
+            const compiled = compileExpression(func)
+
+            // In 3-valued logic, undefined <= value returns UNKNOWN (null)
+            expect(compiled({})).toBe(null)
+          })
+        })
       })
 
       describe(`boolean operators`, () => {
@@ -289,6 +690,37 @@ describe(`evaluators`, () => {
           expect(compiled({})).toBe(false)
         })
 
+        it(`handles and with null value (3-valued logic)`, () => {
+          const func = new Func(`and`, [new Value(true), new Value(null)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, true AND null = null (UNKNOWN)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles and with undefined value (3-valued logic)`, () => {
+          const func = new Func(`and`, [new Value(true), new Value(undefined)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, true AND undefined = null (UNKNOWN)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles and with null and false (3-valued logic)`, () => {
+          const func = new Func(`and`, [new Value(null), new Value(false)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, null AND false = false
+          expect(compiled({})).toBe(false)
+        })
+
+        it(`handles and with all true values`, () => {
+          const func = new Func(`and`, [new Value(true), new Value(true)])
+          const compiled = compileExpression(func)
+
+          expect(compiled({})).toBe(true)
+        })
+
         it(`handles or with short-circuit evaluation`, () => {
           const func = new Func(`or`, [
             new Value(true),
@@ -299,7 +731,7 @@ describe(`evaluators`, () => {
           expect(compiled({})).toBe(true)
         })
 
-        it(`handles or with all false values`, () => {
+        it(`handles or with null value (3-valued logic)`, () => {
           const func = new Func(`or`, [
             new Value(false),
             new Value(0),
@@ -307,8 +739,65 @@ describe(`evaluators`, () => {
           ])
           const compiled = compileExpression(func)
 
+          // In 3-valued logic, false OR null = null (UNKNOWN)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles or with undefined value (3-valued logic)`, () => {
+          const func = new Func(`or`, [
+            new Value(false),
+            new Value(0),
+            new Value(undefined),
+          ])
+          const compiled = compileExpression(func)
+          // In 3-valued logic, false OR undefined = null (UNKNOWN)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles or with null and true (3-valued logic)`, () => {
+          const func = new Func(`or`, [new Value(null), new Value(true)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, null OR true = true
+          expect(compiled({})).toBe(true)
+        })
+
+        it(`handles or with all false values`, () => {
+          const func = new Func(`or`, [new Value(false), new Value(0)])
+          const compiled = compileExpression(func)
+
           expect(compiled({})).toBe(false)
         })
+
+        it(`handles not with null value (3-valued logic)`, () => {
+          const func = new Func(`not`, [new Value(null)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, NOT null = null (UNKNOWN)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles not with undefined value (3-valued logic)`, () => {
+          const func = new Func(`not`, [new Value(undefined)])
+          const compiled = compileExpression(func)
+
+          // In 3-valued logic, NOT undefined = null (UNKNOWN)
+          expect(compiled({})).toBe(null)
+        })
+
+        it(`handles not with true value`, () => {
+          const func = new Func(`not`, [new Value(true)])
+          const compiled = compileExpression(func)
+
+          expect(compiled({})).toBe(false)
+        })
+
+        it(`handles not with false value`, () => {
+          const func = new Func(`not`, [new Value(false)])
+          const compiled = compileExpression(func)
+
+          expect(compiled({})).toBe(true)
+        })
       })
     })
 
diff --git a/packages/db/tests/query/compiler/group-by.test.ts b/packages/db/tests/query/compiler/group-by.test.ts
index 56ac3611d..c34282d44 100644
--- a/packages/db/tests/query/compiler/group-by.test.ts
+++ b/packages/db/tests/query/compiler/group-by.test.ts
@@ -1,11 +1,11 @@
-import { describe, expect, it } from "vitest"
-import { Aggregate, Func, PropRef, Value } from "../../../src/query/ir.js"
+import { describe, expect, it } from 'vitest'
+import { Aggregate, Func, PropRef, Value } from '../../../src/query/ir.js'
 
 // Import the validation function that we want to test directly
 // Since we can't easily mock the D2 streams, we'll test the validation logic separately
 function validateSelectAgainstGroupBy(
   groupByClause: Array<any>,
-  selectClause: any
+  selectClause: any,
 ): void {
   // This is the same validation logic from group-by.ts
   for (const [alias, expr] of Object.entries(selectClause)) {
@@ -16,12 +16,12 @@ function validateSelectAgainstGroupBy(
 
     // Non-aggregate expression must be in GROUP BY
     const groupIndex = groupByClause.findIndex((groupExpr) =>
-      expressionsEqual(expr, groupExpr)
+      expressionsEqual(expr, groupExpr),
     )
 
     if (groupIndex === -1) {
       throw new Error(
-        `Non-aggregate expression '${alias}' in SELECT must also appear in GROUP BY clause`
+        `Non-aggregate expression '${alias}' in SELECT must also appear in GROUP BY clause`,
       )
     }
   }
@@ -44,7 +44,7 @@ function expressionsEqual(expr1: any, expr2: any): boolean {
       expr1.name === expr2.name &&
       expr1.args.length === expr2.args.length &&
       expr1.args.every((arg: any, i: number) =>
-        expressionsEqual(arg, expr2.args[i])
+        expressionsEqual(arg, expr2.args[i]),
       )
     )
   }
@@ -65,7 +65,7 @@ describe(`group-by compiler`, () => {
         expect(() => {
           validateSelectAgainstGroupBy(groupByClause, selectClause)
         }).toThrow(
-          `Non-aggregate expression 'invalidField' in SELECT must also appear in GROUP BY clause`
+          `Non-aggregate expression 'invalidField' in SELECT must also appear in GROUP BY clause`,
         )
       })
 
diff --git a/packages/db/tests/query/compiler/select.test.ts b/packages/db/tests/query/compiler/select.test.ts
index ab60c7d2a..820209b09 100644
--- a/packages/db/tests/query/compiler/select.test.ts
+++ b/packages/db/tests/query/compiler/select.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest"
-import { processArgument } from "../../../src/query/compiler/select.js"
-import { Aggregate, Func, PropRef, Value } from "../../../src/query/ir.js"
+import { describe, expect, it } from 'vitest'
+import { processArgument } from '../../../src/query/compiler/select.js'
+import { Aggregate, Func, PropRef, Value } from '../../../src/query/ir.js'
 
 describe(`select compiler`, () => {
   // Note: Most of the select compilation logic is tested through the full integration
@@ -39,7 +39,7 @@ describe(`select compiler`, () => {
       expect(() => {
         processArgument(arg, namespacedRow)
       }).toThrow(
-        `Aggregate expressions are not supported in this context. Use GROUP BY clause for aggregates.`
+        `Aggregate expressions are not supported in this context. Use GROUP BY clause for aggregates.`,
       )
     })
 
diff --git a/packages/db/tests/query/compiler/subqueries.test.ts b/packages/db/tests/query/compiler/subqueries.test.ts
index f06e7b7f0..4b41eec18 100644
--- a/packages/db/tests/query/compiler/subqueries.test.ts
+++ b/packages/db/tests/query/compiler/subqueries.test.ts
@@ -1,10 +1,10 @@
-import { describe, expect, it } from "vitest"
-import { D2, MultiSet, output } from "@tanstack/db-ivm"
-import { Query, getQueryIR } from "../../../src/query/builder/index.js"
-import { compileQuery } from "../../../src/query/compiler/index.js"
-import { CollectionImpl } from "../../../src/collection/index.js"
-import { avg, count, eq } from "../../../src/query/builder/functions.js"
-import type { CollectionSubscription } from "../../../src/collection/subscription.js"
+import { describe, expect, it } from 'vitest'
+import { D2, MultiSet, output } from '@tanstack/db-ivm'
+import { Query, getQueryIR } from '../../../src/query/builder/index.js'
+import { compileQuery } from '../../../src/query/compiler/index.js'
+import { CollectionImpl } from '../../../src/collection/index.js'
+import { avg, count, eq } from '../../../src/query/builder/functions.js'
+import type { CollectionSubscription } from '../../../src/collection/subscription.js'
 
 // Test schema types
 interface Issue {
@@ -105,8 +105,8 @@ const sendIssueData = (input: any, issues: Array<Issue>) => {
       issues.map((issue) => [
         [issue.id, issue as unknown as Record<string, unknown>],
         1,
-      ])
-    )
+      ]),
+    ),
   )
 }
 
@@ -116,8 +116,8 @@ const sendUserData = (input: any, users: Array<User>) => {
       users.map((user) => [
         [user.id, user as unknown as Record<string, unknown>],
         1,
-      ])
-    )
+      ]),
+    ),
   )
 }
 
@@ -178,14 +178,14 @@ describe(`Query2 Subqueries`, () => {
         {},
         new Set(),
         {},
-        () => {}
+        () => {},
       )
 
       const messages: Array<MultiSet<any>> = []
       pipeline.pipe(
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -227,7 +227,7 @@ describe(`Query2 Subqueries`, () => {
       const query = new Query()
         .from({ issue: issuesCollection })
         .join({ activeUser: activeUsersQuery }, ({ issue, activeUser }) =>
-          eq(issue.userId, activeUser.id)
+          eq(issue.userId, activeUser.id),
         )
         .select(({ issue, activeUser }) => ({
           issueId: issue.id,
@@ -262,7 +262,7 @@ describe(`Query2 Subqueries`, () => {
       const query = new Query()
         .from({ issue: issuesCollection })
         .join({ activeUser: activeUsersQuery }, ({ issue, activeUser }) =>
-          eq(issue.userId, activeUser.id)
+          eq(issue.userId, activeUser.id),
         )
         .select(({ issue, activeUser }) => ({
           issueId: issue.id,
@@ -297,7 +297,7 @@ describe(`Query2 Subqueries`, () => {
         { issue: dummyCallbacks, user: dummyCallbacks },
         lazySources,
         {},
-        () => {}
+        () => {},
       )
       const { pipeline } = compilation
 
@@ -310,7 +310,7 @@ describe(`Query2 Subqueries`, () => {
       pipeline.pipe(
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
@@ -358,7 +358,7 @@ describe(`Query2 Subqueries`, () => {
       const outerQuery = new Query()
         .from({ issue: issuesCollection })
         .join({ userInfo: middleQuery }, ({ issue, userInfo }) =>
-          eq(issue.userId, userInfo.id)
+          eq(issue.userId, userInfo.id),
         )
         .select(({ issue, userInfo }) => ({
           issueId: issue.id,
@@ -398,7 +398,7 @@ describe(`Query2 Subqueries`, () => {
         { issue: dummyCallbacks, user: dummyCallbacks },
         lazyCollections,
         {},
-        () => {}
+        () => {},
       )
 
       // Verify that alias metadata includes aliases from the query
@@ -443,14 +443,14 @@ describe(`Query2 Subqueries`, () => {
         {},
         new Set(),
         {},
-        () => {}
+        () => {},
       )
 
       const messages: Array<MultiSet<any>> = []
       pipeline.pipe(
         output((message) => {
           messages.push(message)
-        })
+        }),
       )
 
       graph.finalize()
diff --git a/packages/db/tests/query/compiler/subquery-caching.test.ts b/packages/db/tests/query/compiler/subquery-caching.test.ts
index 5360ce55c..769cd7e7a 100644
--- a/packages/db/tests/query/compiler/subquery-caching.test.ts
+++ b/packages/db/tests/query/compiler/subquery-caching.test.ts
@@ -1,9 +1,9 @@
-import { describe, expect, it } from "vitest"
-import { D2 } from "@tanstack/db-ivm"
-import { compileQuery } from "../../../src/query/compiler/index.js"
-import { CollectionRef, PropRef, QueryRef } from "../../../src/query/ir.js"
-import type { QueryIR } from "../../../src/query/ir.js"
-import type { CollectionImpl } from "../../../src/collection/index.js"
+import { describe, expect, it } from 'vitest'
+import { D2 } from '@tanstack/db-ivm'
+import { compileQuery } from '../../../src/query/compiler/index.js'
+import { CollectionRef, PropRef, QueryRef } from '../../../src/query/ir.js'
+import type { QueryIR } from '../../../src/query/ir.js'
+import type { CollectionImpl } from '../../../src/collection/index.js'
 
 // Helper to create a minimal mock collection for compiler tests
 function createMockCollection(id: string): CollectionImpl {
@@ -70,7 +70,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       cache1,
-      queryMapping1
+      queryMapping1,
     )
 
     // Verify subquery is in first cache
@@ -90,7 +90,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       cache2,
-      queryMapping2
+      queryMapping2,
     )
 
     // Results should be different objects (different compilation)
@@ -111,7 +111,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       cache2,
-      new WeakMap()
+      new WeakMap(),
     )
 
     // Result should be the same object as #2 (reused from cache)
@@ -132,7 +132,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       cache2,
-      new WeakMap()
+      new WeakMap(),
     )
     const subqueryResult2 = compileQuery(
       subquery,
@@ -144,7 +144,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       cache2,
-      new WeakMap()
+      new WeakMap(),
     )
 
     // Both subquery compilations should return the same cached result
@@ -180,7 +180,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       sharedCache,
-      new WeakMap()
+      new WeakMap(),
     )
     expect(sharedCache.has(subquery)).toBe(true)
 
@@ -195,7 +195,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       sharedCache,
-      new WeakMap()
+      new WeakMap(),
     )
     expect(result1).toBe(result2) // Should be the exact same object reference
   })
@@ -240,7 +240,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       sharedCache,
-      new WeakMap()
+      new WeakMap(),
     )
     const result2 = compileQuery(
       subquery,
@@ -252,7 +252,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       sharedCache,
-      new WeakMap()
+      new WeakMap(),
     )
 
     // Should have different results since they are different objects
@@ -315,7 +315,7 @@ describe(`Subquery Caching`, () => {
       {},
       () => {},
       sharedCache,
-      new WeakMap()
+      new WeakMap(),
     )
     expect(result).toBeDefined()
 
diff --git a/packages/db/tests/query/composables.test.ts b/packages/db/tests/query/composables.test.ts
index a6bd43d10..e5744dde6 100644
--- a/packages/db/tests/query/composables.test.ts
+++ b/packages/db/tests/query/composables.test.ts
@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test } from "vitest"
+import { beforeEach, describe, expect, test } from 'vitest'
 import {
   Query,
   and,
@@ -9,10 +9,10 @@ import {
   lt,
   lte,
   upper,
-} from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
-import type { Ref } from "../../src/query/index.js"
+} from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+import type { Ref } from '../../src/query/index.js'
 
 // Sample user type for tests
 type User = {
@@ -90,7 +90,7 @@ function createUsersCollection() {
       id: `test-users`,
       getKey: (user) => user.id,
       initialData: sampleUsers,
-    })
+    }),
   )
 }
 
@@ -100,7 +100,7 @@ function createPostsCollection() {
       id: `test-posts`,
       getKey: (post) => post.id,
       initialData: samplePosts,
-    })
+    }),
   )
 }
 
@@ -139,10 +139,10 @@ describe(`Composables`, () => {
       // Should return Bob (19) and Dave (22) - both adult, active, and young
       expect(results).toHaveLength(2)
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Bob`, `Dave`])
+        expect.arrayContaining([`Bob`, `Dave`]),
       )
       expect(results.every((u) => u.age > 18 && u.age < 25 && u.active)).toBe(
-        true
+        true,
       )
     })
 
@@ -224,7 +224,7 @@ describe(`Composables`, () => {
 
       expect(results).toHaveLength(3) // Alice (25), Charlie (30), Dave (22)
       expect(results.map((u) => u.displayName)).toEqual(
-        expect.arrayContaining([`ALICE`, `CHARLIE`, `DAVE`])
+        expect.arrayContaining([`ALICE`, `CHARLIE`, `DAVE`]),
       )
 
       // Test that we can create a new query that combines the components differently
@@ -272,7 +272,7 @@ describe(`Composables`, () => {
             .join(
               { post: postsCollection },
               ({ user, post }) => eq(user.id, post.authorId),
-              `inner`
+              `inner`,
             )
             .where(userIsActive)
             .where(postIsPublished)
@@ -319,8 +319,8 @@ describe(`Composables`, () => {
               and(
                 userIsActive({ user }),
                 userIsAdult({ user }),
-                userIsYoung({ user })
-              )
+                userIsYoung({ user }),
+              ),
             ),
         startSync: true,
       })
@@ -377,7 +377,7 @@ describe(`Composables`, () => {
       expect(results).toHaveLength(3)
       expect(results.every((u) => u.category === `junior`)).toBe(true)
       expect(results.map((u) => u.userName)).toEqual(
-        expect.arrayContaining([`ALICE`, `BOB`, `DAVE`])
+        expect.arrayContaining([`ALICE`, `BOB`, `DAVE`]),
       )
     })
 
@@ -426,7 +426,7 @@ describe(`Composables`, () => {
             .join(
               { p: postsCollection },
               ({ u, p }) => eq(u.id, p.authorId),
-              `inner`
+              `inner`,
             )
             .where(joinedUserPostPredicate)
             .select(joinedSelect),
@@ -477,7 +477,7 @@ describe(`Composables`, () => {
       expect(results.every((u) => typeof u.name === `string`)).toBe(true)
       expect(results.every((u) => typeof u.email === `string`)).toBe(true)
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Bob`, `Dave`])
+        expect.arrayContaining([`Alice`, `Bob`, `Dave`]),
       )
 
       // Insert a new active user
diff --git a/packages/db/tests/query/distinct.test.ts b/packages/db/tests/query/distinct.test.ts
index 0d3b480fc..1979b03e4 100644
--- a/packages/db/tests/query/distinct.test.ts
+++ b/packages/db/tests/query/distinct.test.ts
@@ -1,9 +1,9 @@
-import { beforeEach, describe, expect, test } from "vitest"
-import { concat, createLiveQueryCollection } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
-import { DistinctRequiresSelectError } from "../../src/errors"
-import { count, eq, gte, not } from "../../src/query/builder/functions.js"
+import { beforeEach, describe, expect, test } from 'vitest'
+import { concat, createLiveQueryCollection } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+import { DistinctRequiresSelectError } from '../../src/errors'
+import { count, eq, gte, not } from '../../src/query/builder/functions.js'
 
 // Sample data types for comprehensive DISTINCT testing
 type User = {
@@ -117,7 +117,7 @@ function createUsersCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (user) => user.id,
       initialData: sampleUsers,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -143,7 +143,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctCountries.size).toBe(3) // USA, Canada, UK
 
         const countries = Array.from(distinctCountries.values()).map(
-          (user) => user.country
+          (user) => user.country,
         )
         expect(countries).toContain(`USA`)
         expect(countries).toContain(`Canada`)
@@ -172,7 +172,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctRoleSalary.size).toBe(4)
 
         const combinations = Array.from(distinctRoleSalary.values()).map(
-          (user) => `${user.role}-${user.salary}`
+          (user) => `${user.role}-${user.salary}`,
         )
         expect(combinations).toContain(`Developer-75000`)
         expect(combinations).toContain(`Developer-80000`)
@@ -186,7 +186,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
           createLiveQueryCollection({
             startSync: true,
             query: (q) => q.from({ users: usersCollection }).distinct(),
-          })
+          }),
         ).toThrow(DistinctRequiresSelectError)
       })
     })
@@ -218,7 +218,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctSalaryRanges.size).toBe(3) // High, Medium, Low
 
         const ranges = Array.from(distinctSalaryRanges.values()).map(
-          (user) => user.salary_range
+          (user) => user.salary_range,
         )
         expect(ranges).toContain(`High`)
         expect(ranges).toContain(`Medium`)
@@ -240,7 +240,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctFullNames.size).toBe(3) // All unique combinations of department and role
 
         const fullNames = Array.from(distinctFullNames.values()).map(
-          (user) => user.full_name
+          (user) => user.full_name,
         )
 
         expect(fullNames).toContain(`Engineering - Developer`)
@@ -309,7 +309,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctDepartments.size).toBe(4)
 
         const departments = Array.from(distinctDepartments.values()).map(
-          (user) => user.department
+          (user) => user.department,
         )
         expect(departments).toContain(`HR`)
       })
@@ -340,7 +340,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctCountries.size).toBe(4)
 
         const countries = Array.from(distinctCountries.values()).map(
-          (user) => user.country
+          (user) => user.country,
         )
         expect(countries).toContain(`Germany`)
 
@@ -359,7 +359,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctCountries.size).toBe(3)
 
         const finalCountries = Array.from(distinctCountries.values()).map(
-          (user) => user.country
+          (user) => user.country,
         )
         expect(finalCountries).not.toContain(`Germany`)
         expect(finalCountries).toContain(`Canada`)
@@ -391,7 +391,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctCities.size).toBe(4)
 
         const cities = Array.from(distinctCities.values()).map(
-          (user) => user.city
+          (user) => user.city,
         )
         expect(cities).not.toContain(`New York`)
       })
@@ -434,7 +434,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctDepartments.size).toBe(4) // Engineering, Marketing, Sales, null
 
         const departments = Array.from(distinctDepartments.values()).map(
-          (user) => user.department
+          (user) => user.department,
         )
         expect(departments).toContain(null)
       })
@@ -445,7 +445,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
             id: `empty-users`,
             getKey: (user) => user.id,
             initialData: [],
-          })
+          }),
         )
 
         const emptyDistinct = createLiveQueryCollection({
@@ -494,7 +494,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctActiveStatus.size).toBe(2) // true, false
 
         const statuses = Array.from(distinctActiveStatus.values()).map(
-          (user) => user.active
+          (user) => user.active,
         )
         expect(statuses).toContain(true)
         expect(statuses).toContain(false)
@@ -517,7 +517,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         // However, in this case each role has a salary range and those salary ranges don't overlap so it is deterministic
         // So we expect the results to be:  manager, developer, representative
         const distinctOrderedRoles = distinctOrderedData.toArray.map(
-          (r) => r.role
+          (r) => r.role,
         )
         expect(distinctOrderedRoles).toEqual([
           `Manager`,
@@ -541,7 +541,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctComputed.size).toBe(2)
 
         const locations = Array.from(distinctComputed.values()).map(
-          (user) => user.salary_tier
+          (user) => user.salary_tier,
         )
         expect(locations).toContain(`Senior`)
         expect(locations).toContain(`Junior`)
@@ -580,7 +580,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
 
         // Check that counts are correct
         const engineeringGroup = departments.find(
-          (d) => d.department === `Engineering`
+          (d) => d.department === `Engineering`,
         )
         expect(engineeringGroup?.user_count).toBe(5) // John, Jane, Alice, Diana, Frank
       })
@@ -599,7 +599,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctFilteredUsers.size).toBe(2)
 
         const countries = Array.from(distinctFilteredUsers.values()).map(
-          (u) => u.country
+          (u) => u.country,
         )
         expect(countries).toContain(`Canada`)
         expect(countries).toContain(`UK`)
@@ -619,7 +619,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(distinctOrderedCountries.size).toBe(3)
 
         const orderedCountries = distinctOrderedCountries.toArray.map(
-          (u) => u.country
+          (u) => u.country,
         )
         expect(orderedCountries).toEqual([`Canada`, `UK`, `USA`])
       })
@@ -666,7 +666,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
         expect(groupedDistinctSalaries.size).toBe(3)
 
         const counts = Array.from(groupedDistinctSalaries.values()).map(
-          (result) => result.count
+          (result) => result.count,
         )
 
         // All average salaries should be unique (distinct)
@@ -688,7 +688,7 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
             getKey: (dept) => dept.id,
             initialData: departmentsData,
             autoIndex,
-          })
+          }),
         )
 
         const distinctJoinedData = createLiveQueryCollection({
@@ -698,7 +698,8 @@ function createDistinctTests(autoIndex: `off` | `eager`): void {
               .from({ users: usersCollection })
               .join(
                 { departments: departmentsCollection },
-                ({ users, departments }) => eq(users.department, departments.id)
+                ({ users, departments }) =>
+                  eq(users.department, departments.id),
               )
               .where(({ users }) => eq(users.active, true))
               .select(({ departments }) => ({
diff --git a/packages/db/tests/query/expression-helpers.test.ts b/packages/db/tests/query/expression-helpers.test.ts
new file mode 100644
index 000000000..af5c06d1a
--- /dev/null
+++ b/packages/db/tests/query/expression-helpers.test.ts
@@ -0,0 +1,674 @@
+import { describe, expect, it } from 'vitest'
+import {
+  extractFieldPath,
+  extractSimpleComparisons,
+  extractValue,
+  parseLoadSubsetOptions,
+  parseOrderByExpression,
+  parseWhereExpression,
+  walkExpression,
+} from '../../src/query/expression-helpers'
+import { Func, PropRef, Value } from '../../src/query/ir.js'
+import type { IR } from '../../src/index.js'
+
+type OrderBy = IR.OrderBy
+
+describe(`Expression Helpers`, () => {
+  describe(`extractFieldPath`, () => {
+    it(`should extract field path from PropRef`, () => {
+      const expr = new PropRef([`product`, `category`])
+      const result = extractFieldPath(expr)
+      expect(result).toEqual([`product`, `category`])
+    })
+
+    it(`should return null for non-ref expressions`, () => {
+      const expr = new Value(`electronics`)
+      const result = extractFieldPath(expr)
+      expect(result).toBeNull()
+    })
+  })
+
+  describe(`extractValue`, () => {
+    it(`should extract value from Value expression`, () => {
+      const expr = new Value(`electronics`)
+      const result = extractValue(expr)
+      expect(result).toBe(`electronics`)
+    })
+
+    it(`should return undefined for non-value expressions`, () => {
+      const expr = new PropRef([`category`])
+      const result = extractValue(expr)
+      expect(result).toBeUndefined()
+    })
+  })
+
+  describe(`walkExpression`, () => {
+    it(`should visit all nodes in expression tree`, () => {
+      const visited: Array<string> = []
+
+      const expr = new Func(`and`, [
+        new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+        new Func(`lt`, [new PropRef([`price`]), new Value(100)]),
+      ])
+
+      walkExpression(expr, (node) => {
+        visited.push(node.type)
+      })
+
+      expect(visited).toEqual([
+        `func`,
+        `func`,
+        `ref`,
+        `val`,
+        `func`,
+        `ref`,
+        `val`,
+      ])
+    })
+
+    it(`should handle null/undefined expressions`, () => {
+      const visited: Array<string> = []
+
+      walkExpression(null, (node) => {
+        visited.push(node.type)
+      })
+
+      expect(visited).toEqual([])
+    })
+  })
+
+  describe(`parseWhereExpression`, () => {
+    it(`should parse simple equality expression`, () => {
+      const expr = new Func(`eq`, [
+        new PropRef([`category`]),
+        new Value(`electronics`),
+      ])
+
+      const result = parseWhereExpression(expr, {
+        handlers: {
+          eq: (field, value) => ({ [field.join(`.`)]: value }),
+        },
+      })
+
+      expect(result).toEqual({ category: `electronics` })
+    })
+
+    it(`should parse less than expression`, () => {
+      const expr = new Func(`lt`, [new PropRef([`price`]), new Value(100)])
+
+      const result = parseWhereExpression(expr, {
+        handlers: {
+          lt: (field, value) => ({ [`${field.join(`.`)}_lt`]: value }),
+        },
+      })
+
+      expect(result).toEqual({ price_lt: 100 })
+    })
+
+    it(`should parse AND expression with multiple conditions`, () => {
+      const expr = new Func(`and`, [
+        new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+        new Func(`lt`, [new PropRef([`price`]), new Value(100)]),
+      ])
+
+      const result = parseWhereExpression(expr, {
+        handlers: {
+          eq: (field, value) => ({ [field.join(`.`)]: value }),
+          lt: (field, value) => ({ [`${field.join(`.`)}_lt`]: value }),
+          and: (...filters) => Object.assign({}, ...filters),
+        },
+      })
+
+      expect(result).toEqual({ category: `electronics`, price_lt: 100 })
+    })
+
+    it(`should parse OR expression`, () => {
+      const expr = new Func(`or`, [
+        new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+        new Func(`eq`, [new PropRef([`category`]), new Value(`books`)]),
+      ])
+
+      const result = parseWhereExpression(expr, {
+        handlers: {
+          eq: (field, value) => ({ [field.join(`.`)]: value }),
+          or: (...filters) => ({ $or: filters }),
+        },
+      })
+
+      expect(result).toEqual({
+        $or: [{ category: `electronics` }, { category: `books` }],
+      })
+    })
+
+    it(`should handle nested field paths`, () => {
+      const expr = new Func(`eq`, [
+        new PropRef([`product`, `metadata`, `tags`]),
+        new Value(`featured`),
+      ])
+
+      const result = parseWhereExpression(expr, {
+        handlers: {
+          eq: (field, value) => ({ [field.join(`.`)]: value }),
+        },
+      })
+
+      expect(result).toEqual({ [`product.metadata.tags`]: `featured` })
+    })
+
+    it(`should throw error for unknown operator without handler`, () => {
+      const expr = new Func(`customOp`, [
+        new PropRef([`field`]),
+        new Value(`value`),
+      ])
+
+      expect(() => {
+        parseWhereExpression(expr, {
+          handlers: {
+            eq: (field, value) => ({ [field.join(`.`)]: value }),
+          },
+        })
+      }).toThrow(
+        `No handler provided for operator: customOp. Available handlers: eq`,
+      )
+    })
+
+    it(`should use onUnknownOperator callback for unknown operators`, () => {
+      const expr = new Func(`customOp`, [
+        new PropRef([`field`]),
+        new Value(`value`),
+      ])
+
+      const result = parseWhereExpression(expr, {
+        handlers: {
+          eq: (field, value) => ({ [field.join(`.`)]: value }),
+        },
+        onUnknownOperator: (operator) => {
+          return { custom: operator }
+        },
+      })
+
+      expect(result).toEqual({ custom: `customOp` })
+    })
+
+    it(`should handle null/undefined expressions`, () => {
+      const result = parseWhereExpression(null, {
+        handlers: {
+          eq: (field, value) => ({ [field.join(`.`)]: value }),
+        },
+      })
+
+      expect(result).toBeNull()
+    })
+
+    it(`should handle deeply nested AND/OR expressions`, () => {
+      const expr = new Func(`and`, [
+        new Func(`eq`, [new PropRef([`inStock`]), new Value(true)]),
+        new Func(`or`, [
+          new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+          new Func(`eq`, [new PropRef([`category`]), new Value(`books`)]),
+        ]),
+      ])
+
+      type FilterResult =
+        | { field: string; value: unknown }
+        | { AND: Array<FilterResult> }
+        | { OR: Array<FilterResult> }
+
+      const result = parseWhereExpression<FilterResult>(expr, {
+        handlers: {
+          eq: (field, value) => ({ field: field.join(`.`), value }),
+          and: (...filters) => ({ AND: filters }),
+          or: (...filters) => ({ OR: filters }),
+        },
+      })
+
+      expect(result).toEqual({
+        AND: [
+          { field: `inStock`, value: true },
+          {
+            OR: [
+              { field: `category`, value: `electronics` },
+              { field: `category`, value: `books` },
+            ],
+          },
+        ],
+      })
+    })
+  })
+
+  describe(`parseOrderByExpression`, () => {
+    it(`should parse single orderBy clause`, () => {
+      const orderBy: OrderBy = [
+        {
+          expression: new PropRef([`price`]),
+          compareOptions: {
+            direction: `asc`,
+            nulls: `last`,
+          },
+        },
+      ]
+
+      const result = parseOrderByExpression(orderBy)
+
+      expect(result).toEqual([
+        { field: [`price`], direction: `asc`, nulls: `last` },
+      ])
+    })
+
+    it(`should parse multiple orderBy clauses`, () => {
+      const orderBy: OrderBy = [
+        {
+          expression: new PropRef([`category`]),
+          compareOptions: {
+            direction: `asc`,
+            nulls: `last`,
+          },
+        },
+        {
+          expression: new PropRef([`price`]),
+          compareOptions: {
+            direction: `desc`,
+            nulls: `first`,
+          },
+        },
+      ]
+
+      const result = parseOrderByExpression(orderBy)
+
+      expect(result).toEqual([
+        { field: [`category`], direction: `asc`, nulls: `last` },
+        { field: [`price`], direction: `desc`, nulls: `first` },
+      ])
+    })
+
+    it(`should handle nested field paths`, () => {
+      const orderBy: OrderBy = [
+        {
+          expression: new PropRef([`product`, `metadata`, `rating`]),
+          compareOptions: {
+            direction: `desc`,
+            nulls: `last`,
+          },
+        },
+      ]
+
+      const result = parseOrderByExpression(orderBy)
+
+      expect(result).toEqual([
+        {
+          field: [`product`, `metadata`, `rating`],
+          direction: `desc`,
+          nulls: `last`,
+        },
+      ])
+    })
+
+    it(`should handle null/undefined orderBy`, () => {
+      expect(parseOrderByExpression(null)).toEqual([])
+      expect(parseOrderByExpression(undefined)).toEqual([])
+    })
+
+    it(`should handle empty orderBy array`, () => {
+      expect(parseOrderByExpression([])).toEqual([])
+    })
+
+    it(`should throw error for non-ref expressions`, () => {
+      const orderBy: OrderBy = [
+        {
+          expression: new Value(`invalid`) as any,
+          compareOptions: {
+            direction: `asc`,
+            nulls: `last`,
+          },
+        },
+      ]
+
+      expect(() => parseOrderByExpression(orderBy)).toThrow(
+        `ORDER BY expression must be a field reference, got: val`,
+      )
+    })
+  })
+
+  describe(`extractSimpleComparisons`, () => {
+    it(`should extract single equality comparison`, () => {
+      const expr = new Func(`eq`, [
+        new PropRef([`category`]),
+        new Value(`electronics`),
+      ])
+
+      const result = extractSimpleComparisons(expr)
+
+      expect(result).toEqual([
+        { field: [`category`], operator: `eq`, value: `electronics` },
+      ])
+    })
+
+    it(`should extract multiple AND-ed comparisons`, () => {
+      const expr = new Func(`and`, [
+        new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+        new Func(`lt`, [new PropRef([`price`]), new Value(100)]),
+        new Func(`eq`, [new PropRef([`inStock`]), new Value(true)]),
+      ])
+
+      const result = extractSimpleComparisons(expr)
+
+      expect(result).toEqual([
+        { field: [`category`], operator: `eq`, value: `electronics` },
+        { field: [`price`], operator: `lt`, value: 100 },
+        { field: [`inStock`], operator: `eq`, value: true },
+      ])
+    })
+
+    it(`should handle all comparison operators`, () => {
+      const expr = new Func(`and`, [
+        new Func(`eq`, [new PropRef([`a`]), new Value(1)]),
+        new Func(`gt`, [new PropRef([`b`]), new Value(2)]),
+        new Func(`gte`, [new PropRef([`c`]), new Value(3)]),
+        new Func(`lt`, [new PropRef([`d`]), new Value(4)]),
+        new Func(`lte`, [new PropRef([`e`]), new Value(5)]),
+        new Func(`in`, [new PropRef([`f`]), new Value([6, 7])]),
+      ])
+
+      const result = extractSimpleComparisons(expr)
+
+      expect(result).toEqual([
+        { field: [`a`], operator: `eq`, value: 1 },
+        { field: [`b`], operator: `gt`, value: 2 },
+        { field: [`c`], operator: `gte`, value: 3 },
+        { field: [`d`], operator: `lt`, value: 4 },
+        { field: [`e`], operator: `lte`, value: 5 },
+        { field: [`f`], operator: `in`, value: [6, 7] },
+      ])
+    })
+
+    it(`should handle nested AND expressions`, () => {
+      const expr = new Func(`and`, [
+        new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+        new Func(`and`, [
+          new Func(`lt`, [new PropRef([`price`]), new Value(100)]),
+          new Func(`eq`, [new PropRef([`inStock`]), new Value(true)]),
+        ]),
+      ])
+
+      const result = extractSimpleComparisons(expr)
+
+      expect(result).toEqual([
+        { field: [`category`], operator: `eq`, value: `electronics` },
+        { field: [`price`], operator: `lt`, value: 100 },
+        { field: [`inStock`], operator: `eq`, value: true },
+      ])
+    })
+
+    it(`should handle null/undefined expressions`, () => {
+      expect(extractSimpleComparisons(null)).toEqual([])
+      expect(extractSimpleComparisons(undefined)).toEqual([])
+    })
+
+    it(`should throw on OR expressions (not simple)`, () => {
+      const expr = new Func(`or`, [
+        new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+        new Func(`eq`, [new PropRef([`category`]), new Value(`books`)]),
+      ])
+
+      // OR is not supported by extractSimpleComparisons, so it throws
+      expect(() => extractSimpleComparisons(expr)).toThrow(
+        `extractSimpleComparisons does not support 'or' operator`,
+      )
+    })
+
+    it(`should handle nested field paths`, () => {
+      const expr = new Func(`eq`, [
+        new PropRef([`product`, `metadata`, `tags`]),
+        new Value(`featured`),
+      ])
+
+      const result = extractSimpleComparisons(expr)
+
+      expect(result).toEqual([
+        {
+          field: [`product`, `metadata`, `tags`],
+          operator: `eq`,
+          value: `featured`,
+        },
+      ])
+    })
+
+    it(`should handle NOT with comparison operators`, () => {
+      const expr = new Func(`not`, [
+        new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+      ])
+
+      const result = extractSimpleComparisons(expr)
+
+      expect(result).toEqual([
+        { field: [`category`], operator: `not_eq`, value: `electronics` },
+      ])
+    })
+
+    it(`should handle NOT with all comparison operators`, () => {
+      const expr = new Func(`and`, [
+        new Func(`not`, [new Func(`eq`, [new PropRef([`a`]), new Value(1)])]),
+        new Func(`not`, [new Func(`gt`, [new PropRef([`b`]), new Value(2)])]),
+        new Func(`not`, [new Func(`lt`, [new PropRef([`c`]), new Value(3)])]),
+        new Func(`not`, [
+          new Func(`in`, [new PropRef([`d`]), new Value([4, 5])]),
+        ]),
+      ])
+
+      const result = extractSimpleComparisons(expr)
+
+      expect(result).toEqual([
+        { field: [`a`], operator: `not_eq`, value: 1 },
+        { field: [`b`], operator: `not_gt`, value: 2 },
+        { field: [`c`], operator: `not_lt`, value: 3 },
+        { field: [`d`], operator: `not_in`, value: [4, 5] },
+      ])
+    })
+
+    it(`should handle NOT with null checks`, () => {
+      const expr = new Func(`and`, [
+        new Func(`not`, [new Func(`isNull`, [new PropRef([`email`])])]),
+        new Func(`not`, [new Func(`isUndefined`, [new PropRef([`name`])])]),
+      ])
+
+      const result = extractSimpleComparisons(expr)
+
+      expect(result).toEqual([
+        { field: [`email`], operator: `not_isNull` },
+        { field: [`name`], operator: `not_isUndefined` },
+      ])
+    })
+
+    it(`should handle mixed NOT and regular comparisons`, () => {
+      const expr = new Func(`and`, [
+        new Func(`eq`, [new PropRef([`status`]), new Value(`active`)]),
+        new Func(`not`, [
+          new Func(`eq`, [new PropRef([`category`]), new Value(`archived`)]),
+        ]),
+        new Func(`gt`, [new PropRef([`age`]), new Value(18)]),
+      ])
+
+      const result = extractSimpleComparisons(expr)
+
+      expect(result).toEqual([
+        { field: [`status`], operator: `eq`, value: `active` },
+        { field: [`category`], operator: `not_eq`, value: `archived` },
+        { field: [`age`], operator: `gt`, value: 18 },
+      ])
+    })
+
+    it(`should throw on NOT wrapping AND/OR (complex)`, () => {
+      const expr = new Func(`not`, [
+        new Func(`and`, [
+          new Func(`eq`, [new PropRef([`a`]), new Value(1)]),
+          new Func(`eq`, [new PropRef([`b`]), new Value(2)]),
+        ]),
+      ])
+
+      expect(() => extractSimpleComparisons(expr)).toThrow(
+        `extractSimpleComparisons does not support 'not(and)'`,
+      )
+    })
+  })
+
+  describe(`parseLoadSubsetOptions`, () => {
+    it(`should parse all options together`, () => {
+      const where = new Func(`and`, [
+        new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+        new Func(`lt`, [new PropRef([`price`]), new Value(100)]),
+      ])
+
+      const orderBy: OrderBy = [
+        {
+          expression: new PropRef([`price`]),
+          compareOptions: {
+            direction: `asc`,
+            nulls: `last`,
+          },
+        },
+      ]
+
+      const result = parseLoadSubsetOptions({
+        where,
+        orderBy,
+        limit: 10,
+      })
+
+      expect(result).toEqual({
+        filters: [
+          { field: [`category`], operator: `eq`, value: `electronics` },
+          { field: [`price`], operator: `lt`, value: 100 },
+        ],
+        sorts: [{ field: [`price`], direction: `asc`, nulls: `last` }],
+        limit: 10,
+      })
+    })
+
+    it(`should handle missing options`, () => {
+      const result = parseLoadSubsetOptions({})
+
+      expect(result).toEqual({
+        filters: [],
+        sorts: [],
+        limit: undefined,
+      })
+    })
+
+    it(`should handle null/undefined options`, () => {
+      expect(parseLoadSubsetOptions(null)).toEqual({
+        filters: [],
+        sorts: [],
+      })
+      expect(parseLoadSubsetOptions(undefined)).toEqual({
+        filters: [],
+        sorts: [],
+      })
+    })
+
+    it(`should handle only where clause`, () => {
+      const where = new Func(`eq`, [
+        new PropRef([`category`]),
+        new Value(`electronics`),
+      ])
+
+      const result = parseLoadSubsetOptions({ where })
+
+      expect(result).toEqual({
+        filters: [
+          { field: [`category`], operator: `eq`, value: `electronics` },
+        ],
+        sorts: [],
+        limit: undefined,
+      })
+    })
+
+    it(`should handle only orderBy clause`, () => {
+      const orderBy: OrderBy = [
+        {
+          expression: new PropRef([`price`]),
+          compareOptions: {
+            direction: `desc`,
+            nulls: `first`,
+          },
+        },
+      ]
+
+      const result = parseLoadSubsetOptions({ orderBy })
+
+      expect(result).toEqual({
+        filters: [],
+        sorts: [{ field: [`price`], direction: `desc`, nulls: `first` }],
+        limit: undefined,
+      })
+    })
+
+    it(`should handle only limit`, () => {
+      const result = parseLoadSubsetOptions({ limit: 20 })
+
+      expect(result).toEqual({
+        filters: [],
+        sorts: [],
+        limit: 20,
+      })
+    })
+  })
+
+  describe(`Integration tests`, () => {
+    it(`should handle complex real-world query`, () => {
+      // Simulate: WHERE (category = 'electronics' OR category = 'books')
+      //           AND price < 100
+      //           AND inStock = true
+      //           ORDER BY price ASC, name DESC
+      //           LIMIT 25
+
+      const where = new Func(`and`, [
+        new Func(`or`, [
+          new Func(`eq`, [new PropRef([`category`]), new Value(`electronics`)]),
+          new Func(`eq`, [new PropRef([`category`]), new Value(`books`)]),
+        ]),
+        new Func(`lt`, [new PropRef([`price`]), new Value(100)]),
+        new Func(`eq`, [new PropRef([`inStock`]), new Value(true)]),
+      ])
+
+      const orderBy: OrderBy = [
+        {
+          expression: new PropRef([`price`]),
+          compareOptions: {
+            direction: `asc`,
+            nulls: `last`,
+          },
+        },
+        {
+          expression: new PropRef([`name`]),
+          compareOptions: {
+            direction: `desc`,
+            nulls: `last`,
+          },
+        },
+      ]
+
+      // Use custom handlers to build JSON:API style query
+      const filters = parseWhereExpression(where, {
+        handlers: {
+          eq: (field, value) => ({ [field.join(`.`)]: value }),
+          lt: (field, value) => ({ [`${field.join(`.`)}_lt`]: value }),
+          and: (...conditions) => Object.assign({}, ...conditions),
+          or: (...conditions) => ({ _or: conditions }),
+        },
+      })
+
+      const sorts = parseOrderByExpression(orderBy)
+
+      expect(filters).toEqual({
+        _or: [{ category: `electronics` }, { category: `books` }],
+        price_lt: 100,
+        inStock: true,
+      })
+
+      expect(sorts).toEqual([
+        { field: [`price`], direction: `asc`, nulls: `last` },
+        { field: [`name`], direction: `desc`, nulls: `last` },
+      ])
+    })
+  })
+})
diff --git a/packages/db/tests/query/findone-joins.test-d.ts b/packages/db/tests/query/findone-joins.test-d.ts
new file mode 100644
index 000000000..849a7811d
--- /dev/null
+++ b/packages/db/tests/query/findone-joins.test-d.ts
@@ -0,0 +1,248 @@
+import { describe, expectTypeOf, test } from 'vitest'
+import { createLiveQueryCollection, eq } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+
+type Todo = {
+  id: string
+  text: string
+  order: number
+}
+
+type TodoOption = {
+  id: string
+  todoId: string
+  optionText: string
+}
+
+const todoCollection = createCollection(
+  mockSyncCollectionOptions<Todo>({
+    id: `test-todos-findone-joins`,
+    getKey: (todo) => todo.id,
+    initialData: [],
+  }),
+)
+
+const todoOptionsCollection = createCollection(
+  mockSyncCollectionOptions<TodoOption>({
+    id: `test-todo-options-findone-joins`,
+    getKey: (opt) => opt.id,
+    initialData: [],
+  }),
+)
+
+describe(`findOne() with joins`, () => {
+  test(`findOne() after leftJoin should infer correct types`, () => {
+    const query = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ todo: todoCollection })
+          .where(({ todo }) => eq(todo.id, `test-id`))
+          .orderBy(({ todo }) => todo.order, `asc`)
+          .leftJoin(
+            { todoOptions: todoOptionsCollection },
+            ({ todo, todoOptions }) => eq(todo.id, todoOptions.todoId),
+          )
+          .findOne(),
+    })
+
+    expectTypeOf(query.toArray).toEqualTypeOf<
+      Array<{
+        todo: Todo
+        todoOptions: TodoOption | undefined
+      }>
+    >()
+  })
+
+  test(`findOne() with innerJoin should infer correct types`, () => {
+    const query = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ todo: todoCollection })
+          .where(({ todo }) => eq(todo.id, `test-id`))
+          .innerJoin(
+            { todoOptions: todoOptionsCollection },
+            ({ todo, todoOptions }) => eq(todo.id, todoOptions.todoId),
+          )
+          .findOne(),
+    })
+
+    expectTypeOf(query.toArray).toEqualTypeOf<
+      Array<{
+        todo: Todo
+        todoOptions: TodoOption
+      }>
+    >()
+  })
+
+  test(`findOne() before join should infer correct types`, () => {
+    const query = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ todo: todoCollection })
+          .where(({ todo }) => eq(todo.id, `test-id`))
+          .findOne()
+          .leftJoin(
+            { todoOptions: todoOptionsCollection },
+            ({ todo, todoOptions }) => eq(todo.id, todoOptions.todoId),
+          ),
+    })
+
+    expectTypeOf(query.toArray).toEqualTypeOf<
+      Array<{
+        todo: Todo
+        todoOptions: TodoOption | undefined
+      }>
+    >()
+  })
+
+  test(`findOne() with rightJoin should infer correct types`, () => {
+    const query = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ todo: todoCollection })
+          .where(({ todo }) => eq(todo.id, `test-id`))
+          .rightJoin(
+            { todoOptions: todoOptionsCollection },
+            ({ todo, todoOptions }) => eq(todo.id, todoOptions.todoId),
+          )
+          .findOne(),
+    })
+
+    expectTypeOf(query.toArray).toEqualTypeOf<
+      Array<{
+        todo: Todo | undefined
+        todoOptions: TodoOption
+      }>
+    >()
+  })
+
+  test(`findOne() with fullJoin should infer correct types`, () => {
+    const query = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ todo: todoCollection })
+          .where(({ todo }) => eq(todo.id, `test-id`))
+          .fullJoin(
+            { todoOptions: todoOptionsCollection },
+            ({ todo, todoOptions }) => eq(todo.id, todoOptions.todoId),
+          )
+          .findOne(),
+    })
+
+    expectTypeOf(query.toArray).toEqualTypeOf<
+      Array<{
+        todo: Todo | undefined
+        todoOptions: TodoOption | undefined
+      }>
+    >()
+  })
+
+  test(`findOne() with multiple joins should infer correct types`, () => {
+    type TodoTag = {
+      id: string
+      todoId: string
+      tag: string
+    }
+
+    const todoTagsCollection = createCollection(
+      mockSyncCollectionOptions<TodoTag>({
+        id: `test-todo-tags-findone-multi`,
+        getKey: (tag) => tag.id,
+        initialData: [],
+      }),
+    )
+
+    const query = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ todo: todoCollection })
+          .leftJoin(
+            { todoOptions: todoOptionsCollection },
+            ({ todo, todoOptions }) => eq(todo.id, todoOptions.todoId),
+          )
+          .innerJoin({ tag: todoTagsCollection }, ({ todo, tag }) =>
+            eq(todo.id, tag.todoId),
+          )
+          .findOne(),
+    })
+
+    expectTypeOf(query.toArray).toEqualTypeOf<
+      Array<{
+        todo: Todo
+        todoOptions: TodoOption | undefined
+        tag: TodoTag
+      }>
+    >()
+  })
+
+  test(`findOne() with select() and joins should infer correct types`, () => {
+    const query = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ todo: todoCollection })
+          .leftJoin(
+            { todoOptions: todoOptionsCollection },
+            ({ todo, todoOptions }) => eq(todo.id, todoOptions.todoId),
+          )
+          .select(({ todo, todoOptions }) => ({
+            todoText: todo.text,
+            optionText: todoOptions?.optionText,
+          }))
+          .findOne(),
+    })
+
+    expectTypeOf(query.toArray).toEqualTypeOf<
+      Array<{
+        todoText: string
+        optionText: string | undefined
+      }>
+    >()
+  })
+
+  test(`findOne() before select() with joins should infer correct types`, () => {
+    const query = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ todo: todoCollection })
+          .leftJoin(
+            { todoOptions: todoOptionsCollection },
+            ({ todo, todoOptions }) => eq(todo.id, todoOptions.todoId),
+          )
+          .findOne()
+          .select(({ todo, todoOptions }) => ({
+            todoText: todo.text,
+            optionText: todoOptions?.optionText,
+          })),
+    })
+
+    expectTypeOf(query.toArray).toEqualTypeOf<
+      Array<{
+        todoText: string
+        optionText: string | undefined
+      }>
+    >()
+  })
+
+  test(`limit(1) should infer array type`, () => {
+    const query = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ todo: todoCollection })
+          .where(({ todo }) => eq(todo.id, `test-id`))
+          .orderBy(({ todo }) => todo.order, `asc`)
+          .leftJoin(
+            { todoOptions: todoOptionsCollection },
+            ({ todo, todoOptions }) => eq(todo.id, todoOptions.todoId),
+          )
+          .limit(1),
+    })
+
+    expectTypeOf(query.toArray).toEqualTypeOf<
+      Array<{
+        todo: Todo
+        todoOptions: TodoOption | undefined
+      }>
+    >()
+  })
+})
diff --git a/packages/db/tests/query/functional-variants.test-d.ts b/packages/db/tests/query/functional-variants.test-d.ts
index 51e6628d8..f39083047 100644
--- a/packages/db/tests/query/functional-variants.test-d.ts
+++ b/packages/db/tests/query/functional-variants.test-d.ts
@@ -1,12 +1,12 @@
-import { describe, expectTypeOf, test } from "vitest"
+import { describe, expectTypeOf, test } from 'vitest'
 import {
   count,
   createLiveQueryCollection,
   eq,
   gt,
-} from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+} from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample user type for tests
 type User = {
@@ -57,7 +57,7 @@ function createUsersCollection() {
       id: `test-users`,
       getKey: (user) => user.id,
       initialData: sampleUsers,
-    })
+    }),
   )
 }
 
@@ -67,7 +67,7 @@ function createDepartmentsCollection() {
       id: `test-departments`,
       getKey: (dept) => dept.id,
       initialData: sampleDepartments,
-    })
+    }),
   )
 }
 
@@ -204,7 +204,7 @@ describe(`Functional Variants Types`, () => {
         q
           .from({ user: usersCollection })
           .join({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           )
           .fn.select((row) => ({
             employeeInfo: `${row.user.name} works in ${row.dept?.name || `Unknown`}`,
@@ -237,11 +237,11 @@ describe(`Functional Variants Types`, () => {
         q
           .from({ user: usersCollection })
           .join({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           )
           .fn.where(
             (row) =>
-              row.user.active && (row.dept?.name === `Engineering` || false)
+              row.user.active && (row.dept?.name === `Engineering` || false),
           ),
     })
 
@@ -261,7 +261,7 @@ describe(`Functional Variants Types`, () => {
         q
           .from({ user: usersCollection })
           .join({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           )
           .fn.where((row) => row.user.active)
           .fn.where((row) => row.user.salary > 60000)
@@ -410,7 +410,7 @@ describe(`Functional Variants Types`, () => {
         .fn.select((row) => ({
           name: row.user.name,
           isActive: row.user.active,
-        }))
+        })),
     )
 
     const results = liveCollection.toArray
@@ -448,7 +448,7 @@ describe(`Functional Variants Types`, () => {
         q
           .from({ user: usersCollection })
           .join({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           )
           .groupBy(({ dept }) => dept?.name)
           .fn.having((row) => row.dept?.name !== `HR`)
@@ -468,4 +468,56 @@ describe(`Functional Variants Types`, () => {
       }>
     >()
   })
+
+  test(`fn.select with orderBy has access to $selected`, () => {
+    const liveCollection = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ user: usersCollection })
+          .fn.select((row) => ({
+            name: row.user.name,
+            salaryInThousands: row.user.salary / 1000,
+            ageCategory:
+              row.user.age > 30
+                ? (`senior` as const)
+                : row.user.age > 25
+                  ? (`mid` as const)
+                  : (`junior` as const),
+          }))
+          .orderBy(({ $selected }) => $selected.salaryInThousands),
+    })
+
+    const results = liveCollection.toArray
+    expectTypeOf(results).toEqualTypeOf<
+      Array<{
+        name: string
+        salaryInThousands: number
+        ageCategory: `senior` | `mid` | `junior`
+      }>
+    >()
+  })
+
+  test(`fn.select with multiple orderBy clauses using $selected`, () => {
+    const liveCollection = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ user: usersCollection })
+          .fn.select((row) => ({
+            displayName: row.user.name,
+            isActive: row.user.active,
+            salary: row.user.salary,
+          }))
+          .orderBy(({ $selected }) => $selected.isActive, `desc`)
+          .orderBy(({ $selected }) => $selected.salary),
+    })
+
+    const results = liveCollection.toArray
+    expectTypeOf(results).toEqualTypeOf<
+      Array<{
+        displayName: string
+        isActive: boolean
+        salary: number
+      }>
+    >()
+  })
 })
diff --git a/packages/db/tests/query/functional-variants.test.ts b/packages/db/tests/query/functional-variants.test.ts
index 2c12e020e..e9913f5d3 100644
--- a/packages/db/tests/query/functional-variants.test.ts
+++ b/packages/db/tests/query/functional-variants.test.ts
@@ -1,12 +1,12 @@
-import { beforeEach, describe, expect, test } from "vitest"
+import { beforeEach, describe, expect, test } from 'vitest'
 import {
   count,
   createLiveQueryCollection,
   eq,
   gt,
-} from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+} from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample user type for tests
 type User = {
@@ -85,7 +85,7 @@ function createUsersCollection() {
       id: `test-users`,
       getKey: (user) => user.id,
       initialData: sampleUsers,
-    })
+    }),
   )
 }
 
@@ -95,7 +95,7 @@ function createDepartmentsCollection() {
       id: `test-departments`,
       getKey: (dept) => dept.id,
       initialData: sampleDepartments,
-    })
+    }),
   )
 }
 
@@ -190,7 +190,7 @@ describe(`Functional Variants Query`, () => {
           q
             .from({ user: usersCollection })
             .join({ dept: departmentsCollection }, ({ user, dept }) =>
-              eq(user.department_id, dept.id)
+              eq(user.department_id, dept.id),
             )
             .fn.select((row) => ({
               employeeInfo: `${row.user.name} works in ${row.dept?.name || `Unknown`}`,
@@ -241,7 +241,7 @@ describe(`Functional Variants Query`, () => {
 
       expect(results).toHaveLength(2) // Alice (25, active) and Eve (28, active)
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Eve`])
+        expect.arrayContaining([`Alice`, `Eve`]),
       )
 
       // Insert user that meets criteria
@@ -310,7 +310,7 @@ describe(`Functional Variants Query`, () => {
       // Should only include: Alice (active, 75k, dept 1), Dave (active, 65k, dept 2)
       expect(results).toHaveLength(2)
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Dave`])
+        expect.arrayContaining([`Alice`, `Dave`]),
       )
 
       // All results should meet all criteria
@@ -337,7 +337,7 @@ describe(`Functional Variants Query`, () => {
       // Should include: Alice (25, active, 75k), Dave (22, active, 65k)
       expect(results).toHaveLength(2)
       expect(results.map((u) => u.name)).toEqual(
-        expect.arrayContaining([`Alice`, `Dave`])
+        expect.arrayContaining([`Alice`, `Dave`]),
       )
 
       results.forEach((user) => {
@@ -366,7 +366,7 @@ describe(`Functional Variants Query`, () => {
               department_id: user.department_id,
               employee_count: count(user.id),
             }))
-            .fn.having((row) => (row as any).result.employee_count > 1),
+            .fn.having((row) => (row as any).$selected.employee_count > 1),
       })
 
       const results = liveCollection.toArray
@@ -477,6 +477,219 @@ describe(`Functional Variants Query`, () => {
     })
   })
 
+  describe(`fn.select with orderBy using $selected`, () => {
+    let usersCollection: ReturnType<typeof createUsersCollection>
+
+    beforeEach(() => {
+      usersCollection = createUsersCollection()
+    })
+
+    test(`should allow orderBy to reference $selected fields from fn.select`, () => {
+      const liveCollection = createLiveQueryCollection({
+        startSync: true,
+        query: (q) =>
+          q
+            .from({ user: usersCollection })
+            .fn.select((row) => ({
+              name: row.user.name,
+              salaryInThousands: row.user.salary / 1000,
+            }))
+            .orderBy(({ $selected }) => $selected.salaryInThousands, `desc`),
+      })
+
+      const results = liveCollection.toArray
+
+      expect(results).toHaveLength(5)
+      // Should be ordered by salary descending
+      expect(results.map((r) => r.name)).toEqual([
+        `Charlie`, // 85k
+        `Alice`, // 75k
+        `Dave`, // 65k
+        `Eve`, // 55k
+        `Bob`, // 45k
+      ])
+    })
+
+    test(`should allow orderBy with $selected on computed string fields`, () => {
+      const liveCollection = createLiveQueryCollection({
+        startSync: true,
+        query: (q) =>
+          q
+            .from({ user: usersCollection })
+            .fn.select((row) => ({
+              displayName: `${row.user.name} (${row.user.age})`,
+              lastName: row.user.name.toLowerCase(),
+            }))
+            .orderBy(({ $selected }) => $selected.lastName),
+      })
+
+      const results = liveCollection.toArray
+
+      expect(results).toHaveLength(5)
+      // Should be ordered alphabetically by lowercase name
+      expect(results.map((r) => r.displayName)).toEqual([
+        `Alice (25)`,
+        `Bob (19)`,
+        `Charlie (30)`,
+        `Dave (22)`,
+        `Eve (28)`,
+      ])
+    })
+
+    test(`should allow multiple orderBy clauses with fn.select`, () => {
+      const liveCollection = createLiveQueryCollection({
+        startSync: true,
+        query: (q) =>
+          q
+            .from({ user: usersCollection })
+            .fn.select((row) => ({
+              name: row.user.name,
+              isActive: row.user.active,
+              salary: row.user.salary,
+            }))
+            .orderBy(({ $selected }) => $selected.isActive, `desc`)
+            .orderBy(({ $selected }) => $selected.salary, `desc`),
+      })
+
+      const results = liveCollection.toArray
+
+      expect(results).toHaveLength(5)
+      // Should be ordered by active (true first), then by salary desc
+      // Active users: Alice (75k), Dave (65k), Eve (55k), Bob (45k)
+      // Inactive users: Charlie (85k)
+      expect(results.map((r) => r.name)).toEqual([
+        `Alice`, // active, 75k
+        `Dave`, // active, 65k
+        `Eve`, // active, 55k
+        `Bob`, // active, 45k
+        `Charlie`, // inactive, 85k
+      ])
+    })
+
+    test(`should react to changes when using fn.select with orderBy`, () => {
+      const liveCollection = createLiveQueryCollection({
+        startSync: true,
+        query: (q) =>
+          q
+            .from({ user: usersCollection })
+            .fn.select((row) => ({
+              name: row.user.name,
+              salary: row.user.salary,
+            }))
+            .orderBy(({ $selected }) => $selected.salary),
+      })
+
+      // Initial order (ascending by salary)
+      expect(liveCollection.toArray.map((r) => r.name)).toEqual([
+        `Bob`, // 45k
+        `Eve`, // 55k
+        `Dave`, // 65k
+        `Alice`, // 75k
+        `Charlie`, // 85k
+      ])
+
+      // Update Bob's salary to be the highest
+      const bob = sampleUsers.find((u) => u.name === `Bob`)!
+      const richBob = { ...bob, salary: 100000 }
+      usersCollection.utils.begin()
+      usersCollection.utils.write({ type: `update`, value: richBob })
+      usersCollection.utils.commit()
+
+      // Bob should now be at the end (highest salary)
+      expect(liveCollection.toArray.map((r) => r.name)).toEqual([
+        `Eve`, // 55k
+        `Dave`, // 65k
+        `Alice`, // 75k
+        `Charlie`, // 85k
+        `Bob`, // 100k
+      ])
+
+      // Clean up
+      usersCollection.utils.begin()
+      usersCollection.utils.write({ type: `update`, value: bob })
+      usersCollection.utils.commit()
+    })
+
+    test(`should allow orderBy with table refs after fn.select`, () => {
+      const liveCollection = createLiveQueryCollection({
+        startSync: true,
+        query: (q) =>
+          q
+            .from({ user: usersCollection })
+            .fn.select((row) => ({
+              displayName: row.user.name,
+              salary: row.user.salary,
+            }))
+            .orderBy(({ user }) => user.age),
+      })
+
+      const results = liveCollection.toArray
+
+      expect(results).toHaveLength(5)
+      // Should be ordered by age (from original table, not $selected)
+      expect(results.map((r) => r.displayName)).toEqual([
+        `Bob`, // 19
+        `Dave`, // 22
+        `Alice`, // 25
+        `Eve`, // 28
+        `Charlie`, // 30
+      ])
+    })
+
+    test(`should allow fn.having to reference $selected fields from fn.select`, () => {
+      const liveCollection = createLiveQueryCollection({
+        startSync: true,
+        query: (q) =>
+          q
+            .from({ user: usersCollection })
+            .fn.select((row) => ({
+              name: row.user.name,
+              salaryTier: row.user.salary > 60000 ? `high` : `low`,
+            }))
+            .fn.having(({ $selected }) => $selected.salaryTier === `high`),
+      })
+
+      const results = liveCollection.toArray
+
+      // Only users with salary > 60k: Alice (75k), Charlie (85k), Dave (65k)
+      expect(results).toHaveLength(3)
+      expect(results.map((r) => r.name).sort()).toEqual([
+        `Alice`,
+        `Charlie`,
+        `Dave`,
+      ])
+    })
+
+    test(`should allow orderBy with both table refs and $selected`, () => {
+      const liveCollection = createLiveQueryCollection({
+        startSync: true,
+        query: (q) =>
+          q
+            .from({ user: usersCollection })
+            .fn.select((row) => ({
+              name: row.user.name,
+              salaryTier: row.user.salary > 60000 ? `high` : `low`,
+            }))
+            .orderBy(({ $selected }) => $selected.salaryTier)
+            .orderBy(({ user }) => user.age, `desc`),
+      })
+
+      const results = liveCollection.toArray
+
+      expect(results).toHaveLength(5)
+      // First by salaryTier (high < low alphabetically), then by age desc
+      // High tier (>60k): Charlie (30), Alice (25), Dave (22)
+      // Low tier (<=60k): Eve (28), Bob (19)
+      expect(results.map((r) => r.name)).toEqual([
+        `Charlie`, // high, 30
+        `Alice`, // high, 25
+        `Dave`, // high, 22
+        `Eve`, // low, 28
+        `Bob`, // low, 19
+      ])
+    })
+  })
+
   describe(`combinations`, () => {
     let usersCollection: ReturnType<typeof createUsersCollection>
     let departmentsCollection: ReturnType<typeof createDepartmentsCollection>
@@ -494,7 +707,7 @@ describe(`Functional Variants Query`, () => {
           q
             .from({ user: usersCollection })
             .join({ dept: departmentsCollection }, ({ user, dept }) =>
-              eq(user.department_id, dept.id)
+              eq(user.department_id, dept.id),
             )
             .fn.where((row) => row.user.active)
             .fn.where((row) => row.user.salary > 60000)
diff --git a/packages/db/tests/query/group-by.test-d.ts b/packages/db/tests/query/group-by.test-d.ts
index 4d7aac0c9..2f6a4c8c3 100644
--- a/packages/db/tests/query/group-by.test-d.ts
+++ b/packages/db/tests/query/group-by.test-d.ts
@@ -1,7 +1,7 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { createLiveQueryCollection } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { createLiveQueryCollection } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 import {
   and,
   avg,
@@ -14,7 +14,7 @@ import {
   min,
   or,
   sum,
-} from "../../src/query/builder/functions.js"
+} from '../../src/query/builder/functions.js'
 
 // Sample data types for comprehensive GROUP BY testing
 type Order = {
@@ -64,7 +64,7 @@ function createOrdersCollection() {
       id: `test-orders`,
       getKey: (order) => order.id,
       initialData: sampleOrders,
-    })
+    }),
   )
 }
 
@@ -300,7 +300,7 @@ describe(`Query GROUP BY Types`, () => {
             avg_amount: avg(orders.amount),
           }))
           .having(({ orders }) =>
-            and(gt(count(orders.id), 1), gte(sum(orders.amount), 450))
+            and(gt(count(orders.id), 1), gte(sum(orders.amount), 450)),
           ),
     })
 
@@ -329,7 +329,7 @@ describe(`Query GROUP BY Types`, () => {
             min_amount: min(orders.amount),
           }))
           .having(({ orders }) =>
-            or(gt(count(orders.id), 2), lt(min(orders.amount), 100))
+            or(gt(count(orders.id), 2), lt(min(orders.amount), 100)),
           ),
     })
 
diff --git a/packages/db/tests/query/group-by.test.ts b/packages/db/tests/query/group-by.test.ts
index aec23a9f8..62f112b83 100644
--- a/packages/db/tests/query/group-by.test.ts
+++ b/packages/db/tests/query/group-by.test.ts
@@ -1,7 +1,7 @@
-import { beforeEach, describe, expect, test } from "vitest"
-import { createLiveQueryCollection } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { beforeEach, describe, expect, test } from 'vitest'
+import { createLiveQueryCollection } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 import {
   and,
   avg,
@@ -16,7 +16,7 @@ import {
   not,
   or,
   sum,
-} from "../../src/query/builder/functions.js"
+} from '../../src/query/builder/functions.js'
 
 // Sample data types for comprehensive GROUP BY testing
 type Order = {
@@ -215,7 +215,7 @@ function createOrdersCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (order) => order.id,
       initialData: sampleOrders,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -259,10 +259,10 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
         expect(customer1?.min_amount).toBe(100)
         expect(customer1?.max_amount).toBe(400)
         expect(customer1?.min_date.toISOString()).toBe(
-          new Date(`2023-01-01`).toISOString()
+          new Date(`2023-01-01`).toISOString(),
         )
         expect(customer1?.max_date.toISOString()).toBe(
-          new Date(`2023-03-01`).toISOString()
+          new Date(`2023-03-01`).toISOString(),
         )
 
         // Customer 2: orders 3, 4 (amounts: 150, 300)
@@ -275,10 +275,10 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
         expect(customer2?.min_amount).toBe(150)
         expect(customer2?.max_amount).toBe(300)
         expect(customer2?.min_date.toISOString()).toBe(
-          new Date(`2023-01-20`).toISOString()
+          new Date(`2023-01-20`).toISOString(),
         )
         expect(customer2?.max_date.toISOString()).toBe(
-          new Date(`2023-02-01`).toISOString()
+          new Date(`2023-02-01`).toISOString(),
         )
 
         // Customer 3: orders 5, 6 (amounts: 250, 75)
@@ -291,10 +291,10 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
         expect(customer3?.min_amount).toBe(75)
         expect(customer3?.max_amount).toBe(250)
         expect(customer3?.min_date.toISOString()).toBe(
-          new Date(`2023-02-10`).toISOString()
+          new Date(`2023-02-10`).toISOString(),
         )
         expect(customer3?.max_date.toISOString()).toBe(
-          new Date(`2023-02-15`).toISOString()
+          new Date(`2023-02-15`).toISOString(),
         )
       })
 
@@ -402,6 +402,49 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
         expect(books?.order_count).toBe(3)
         expect(books?.total_amount).toBe(800) // 150+250+400
       })
+
+      test(`min/max on string fields`, () => {
+        const categorySummary = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ orders: ordersCollection })
+              .groupBy(({ orders }) => orders.customer_id)
+              .select(({ orders }) => ({
+                customer_id: orders.customer_id,
+                first_status: min(orders.status), // alphabetically first
+                last_status: max(orders.status), // alphabetically last
+                first_category: min(orders.product_category),
+                last_category: max(orders.product_category),
+              })),
+        })
+
+        expect(categorySummary.size).toBe(3) // 3 customers
+
+        // Customer 1: orders 1, 2, 7 (statuses: completed, completed, completed; categories: electronics, electronics, books)
+        const customer1 = categorySummary.get(1)
+        expect(customer1?.customer_id).toBe(1)
+        expect(customer1?.first_status).toBe(`completed`) // all completed
+        expect(customer1?.last_status).toBe(`completed`)
+        expect(customer1?.first_category).toBe(`books`) // alphabetically books < electronics
+        expect(customer1?.last_category).toBe(`electronics`)
+
+        // Customer 2: orders 3, 4 (statuses: pending, completed; categories: books, electronics)
+        const customer2 = categorySummary.get(2)
+        expect(customer2?.customer_id).toBe(2)
+        expect(customer2?.first_status).toBe(`completed`) // alphabetically completed < pending
+        expect(customer2?.last_status).toBe(`pending`)
+        expect(customer2?.first_category).toBe(`books`)
+        expect(customer2?.last_category).toBe(`electronics`)
+
+        // Customer 3: orders 5, 6 (statuses: pending, cancelled; categories: books, electronics)
+        const customer3 = categorySummary.get(3)
+        expect(customer3?.customer_id).toBe(3)
+        expect(customer3?.first_status).toBe(`cancelled`) // alphabetically cancelled < pending
+        expect(customer3?.last_status).toBe(`pending`)
+        expect(customer3?.first_category).toBe(`books`)
+        expect(customer3?.last_category).toBe(`electronics`)
+      })
     })
 
     describe(`Multiple Column Grouping`, () => {
@@ -484,7 +527,7 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
 
         // Completed electronics: orders 1, 2, 4
         const completedElectronics = statusCategorySummary.get(
-          `["completed","electronics"]`
+          `["completed","electronics"]`,
         )
         expect(completedElectronics?.status).toBe(`completed`)
         expect(completedElectronics?.product_category).toBe(`electronics`)
@@ -542,9 +585,9 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
                   gt(orders.amount, 150),
                   or(
                     eq(orders.status, `completed`),
-                    eq(orders.status, `pending`)
-                  )
-                )
+                    eq(orders.status, `pending`),
+                  ),
+                ),
               )
               .groupBy(({ orders }) => orders.product_category)
               .select(({ orders }) => ({
@@ -669,7 +712,7 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
                 avg_amount: avg(orders.amount),
               }))
               .having(({ orders }) =>
-                and(gt(count(orders.id), 1), gte(sum(orders.amount), 450))
+                and(gt(count(orders.id), 1), gte(sum(orders.amount), 450)),
               ),
         })
 
@@ -699,7 +742,7 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
                 min_amount: min(orders.amount),
               }))
               .having(({ orders }) =>
-                or(gt(count(orders.id), 2), lt(min(orders.amount), 100))
+                or(gt(count(orders.id), 2), lt(min(orders.amount), 100)),
               ),
         })
 
@@ -761,8 +804,8 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
                 and(
                   gte(min(orders.amount), 75),
                   gte(max(orders.amount), 300),
-                  gte(max(orders.date), new Date(`2020-09-17`))
-                )
+                  gte(max(orders.date), new Date(`2020-09-17`)),
+                ),
               ),
         })
 
@@ -1032,7 +1075,7 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
             id: `empty-orders`,
             getKey: (order) => order.id,
             initialData: [],
-          })
+          }),
         )
 
         const emptyGroupBy = createLiveQueryCollection({
@@ -1108,6 +1151,345 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
         expect(customer1?.min_quantity).toBe(1)
         expect(customer1?.max_quantity).toBe(2)
       })
+
+      test(`group by BigInt column should not throw JSON.stringify error`, () => {
+        // Define a type with BigInt field (simulating a Postgres bigint column)
+        type District = {
+          id: number
+          district_id: bigint
+          name: string
+          status: string
+        }
+
+        // Use BigInt values beyond MAX_SAFE_INTEGER to test BigInt serialization
+        const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER + 1)
+
+        const sampleDistricts: Array<District> = [
+          {
+            id: 1,
+            district_id: MAX_SAFE_BIGINT,
+            name: 'District A',
+            status: 'active',
+          },
+          {
+            id: 2,
+            district_id: MAX_SAFE_BIGINT + 1n,
+            name: 'District B',
+            status: 'active',
+          },
+          {
+            id: 3,
+            district_id: MAX_SAFE_BIGINT, // Same as first
+            name: 'District C',
+            status: 'inactive',
+          },
+          {
+            id: 4,
+            district_id: MAX_SAFE_BIGINT + 2n,
+            name: 'District D',
+            status: 'active',
+          },
+        ]
+
+        const districtsCollection = createCollection(
+          mockSyncCollectionOptions<District>({
+            id: `test-districts`,
+            getKey: (district) => district.id,
+            initialData: sampleDistricts,
+            autoIndex,
+          }),
+        )
+
+        // This should not throw "Do not know how to serialize a BigInt" error
+        const districtSummary = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ districts: districtsCollection })
+              .groupBy(({ districts }) => districts.district_id)
+              .select(({ districts }) => ({
+                district_id: districts.district_id,
+                count: count(districts.id),
+              })),
+        })
+
+        // Should have 3 groups (two districts share the same district_id)
+        expect(districtSummary.size).toBe(3)
+
+        // Check the group with MAX_SAFE_BIGINT
+        const group1 = Array.from(districtSummary.values()).find(
+          (d) => d.district_id === MAX_SAFE_BIGINT,
+        )
+        expect(group1).toBeDefined()
+        expect(group1?.count).toBe(2) // Districts 1 and 3
+
+        // Check the group with MAX_SAFE_BIGINT + 1n
+        const group2 = Array.from(districtSummary.values()).find(
+          (d) => d.district_id === MAX_SAFE_BIGINT + 1n,
+        )
+        expect(group2).toBeDefined()
+        expect(group2?.count).toBe(1) // District 2
+
+        // Check the group with MAX_SAFE_BIGINT + 2n
+        const group3 = Array.from(districtSummary.values()).find(
+          (d) => d.district_id === MAX_SAFE_BIGINT + 2n,
+        )
+        expect(group3).toBeDefined()
+        expect(group3?.count).toBe(1) // District 4
+      })
+
+      test(`group by Date column should serialize correctly`, () => {
+        type Event = {
+          id: number
+          event_date: Date
+          name: string
+          category: string
+        }
+
+        const date1 = new Date('2023-01-15T10:00:00Z')
+        const date2 = new Date('2023-01-20T14:30:00Z')
+        const date3 = new Date('2023-01-15T10:00:00Z') // Same as date1
+
+        const sampleEvents: Array<Event> = [
+          {
+            id: 1,
+            event_date: date1,
+            name: 'Event A',
+            category: 'conference',
+          },
+          {
+            id: 2,
+            event_date: date2,
+            name: 'Event B',
+            category: 'workshop',
+          },
+          {
+            id: 3,
+            event_date: date3, // Same date as Event A
+            name: 'Event C',
+            category: 'conference',
+          },
+          {
+            id: 4,
+            event_date: new Date('2023-02-01T09:00:00Z'),
+            name: 'Event D',
+            category: 'workshop',
+          },
+        ]
+
+        const eventsCollection = createCollection(
+          mockSyncCollectionOptions<Event>({
+            id: `test-events`,
+            getKey: (event) => event.id,
+            initialData: sampleEvents,
+            autoIndex,
+          }),
+        )
+
+        // Group by Date - should serialize dates to ISO strings for keys
+        const eventSummary = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ events: eventsCollection })
+              .groupBy(({ events }) => events.event_date)
+              .select(({ events }) => ({
+                event_date: events.event_date,
+                count: count(events.id),
+              })),
+        })
+
+        // Should have 3 groups (two events share the same date)
+        expect(eventSummary.size).toBe(3)
+
+        // Check the group with date1 (which equals date3)
+        const group1 = Array.from(eventSummary.values()).find(
+          (e) => e.event_date.getTime() === date1.getTime(),
+        )
+        expect(group1).toBeDefined()
+        expect(group1?.count).toBe(2) // Events 1 and 3
+
+        // Check the group with date2
+        const group2 = Array.from(eventSummary.values()).find(
+          (e) => e.event_date.getTime() === date2.getTime(),
+        )
+        expect(group2).toBeDefined()
+        expect(group2?.count).toBe(1) // Event 2
+
+        // Check the group with the February date
+        const group3 = Array.from(eventSummary.values()).find(
+          (e) =>
+            e.event_date.getTime() ===
+            new Date('2023-02-01T09:00:00Z').getTime(),
+        )
+        expect(group3).toBeDefined()
+        expect(group3?.count).toBe(1) // Event 4
+      })
+
+      test(`group by multiple columns including Date should not throw error`, () => {
+        type LogEntry = {
+          id: number
+          timestamp: Date
+          level: string
+          service: string
+        }
+
+        const timestamp1 = new Date('2023-01-15T10:00:00Z')
+        const timestamp2 = new Date('2023-01-15T10:00:00Z') // Same as timestamp1
+
+        const sampleLogs: Array<LogEntry> = [
+          {
+            id: 1,
+            timestamp: timestamp1,
+            level: 'error',
+            service: 'api',
+          },
+          {
+            id: 2,
+            timestamp: timestamp1,
+            level: 'info',
+            service: 'api',
+          },
+          {
+            id: 3,
+            timestamp: timestamp2,
+            level: 'error',
+            service: 'worker',
+          },
+          {
+            id: 4,
+            timestamp: new Date('2023-01-20T14:30:00Z'),
+            level: 'warning',
+            service: 'api',
+          },
+        ]
+
+        const logsCollection = createCollection(
+          mockSyncCollectionOptions<LogEntry>({
+            id: `test-logs`,
+            getKey: (log) => log.id,
+            initialData: sampleLogs,
+            autoIndex,
+          }),
+        )
+
+        // Group by both Date and string - should not throw
+        const logSummary = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ logs: logsCollection })
+              .groupBy(({ logs }) => [logs.timestamp, logs.level])
+              .select(({ logs }) => ({
+                timestamp: logs.timestamp,
+                level: logs.level,
+                count: count(logs.id),
+              })),
+        })
+
+        expect(logSummary.size).toBe(3) // Three distinct combinations
+
+        // Find the group with timestamp1 and 'error'
+        const group1 = Array.from(logSummary.values()).find(
+          (l) =>
+            l.timestamp.getTime() === timestamp1.getTime() &&
+            l.level === 'error',
+        )
+        expect(group1).toBeDefined()
+        expect(group1?.count).toBe(2) // Logs 1 and 3 (same timestamp, same level)
+
+        // Find the group with timestamp1 and 'info'
+        const group2 = Array.from(logSummary.values()).find(
+          (l) =>
+            l.timestamp.getTime() === timestamp1.getTime() &&
+            l.level === 'info',
+        )
+        expect(group2).toBeDefined()
+        expect(group2?.count).toBe(1) // Log 2
+
+        // Find the group with the different timestamp and 'warning'
+        const group3 = Array.from(logSummary.values()).find(
+          (l) =>
+            l.timestamp.getTime() ===
+              new Date('2023-01-20T14:30:00Z').getTime() &&
+            l.level === 'warning',
+        )
+        expect(group3).toBeDefined()
+        expect(group3?.count).toBe(1) // Log 4
+      })
+
+      test(`group by multiple columns including BigInt should not throw error`, () => {
+        type School = {
+          id: number
+          district_id: bigint
+          name: string
+          status: string
+        }
+
+        // Use BigInt values beyond MAX_SAFE_INTEGER to test BigInt serialization
+        const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER + 1)
+
+        const sampleSchools: Array<School> = [
+          {
+            id: 1,
+            district_id: MAX_SAFE_BIGINT,
+            name: 'School A',
+            status: 'active',
+          },
+          {
+            id: 2,
+            district_id: MAX_SAFE_BIGINT,
+            name: 'School B',
+            status: 'active',
+          },
+          {
+            id: 3,
+            district_id: MAX_SAFE_BIGINT + 1n,
+            name: 'School C',
+            status: 'inactive',
+          },
+        ]
+
+        const schoolsCollection = createCollection(
+          mockSyncCollectionOptions<School>({
+            id: `test-schools`,
+            getKey: (school) => school.id,
+            initialData: sampleSchools,
+            autoIndex,
+          }),
+        )
+
+        // Group by both BigInt and string - should not throw
+        const schoolSummary = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ schools: schoolsCollection })
+              .groupBy(({ schools }) => [schools.district_id, schools.status])
+              .select(({ schools }) => ({
+                district_id: schools.district_id,
+                status: schools.status,
+                count: count(schools.id),
+              })),
+        })
+
+        expect(schoolSummary.size).toBe(2) // Two distinct combinations
+
+        // Find the group with MAX_SAFE_BIGINT and 'active'
+        const group1 = Array.from(schoolSummary.values()).find(
+          (s) => s.district_id === MAX_SAFE_BIGINT && s.status === 'active',
+        )
+        expect(group1).toBeDefined()
+        expect(group1?.count).toBe(2) // Schools 1 and 2
+
+        // Find the group with MAX_SAFE_BIGINT + 1n and 'inactive'
+        const group2 = Array.from(schoolSummary.values()).find(
+          (s) =>
+            s.district_id === MAX_SAFE_BIGINT + 1n && s.status === 'inactive',
+        )
+        expect(group2).toBeDefined()
+        expect(group2?.count).toBe(1) // School 3
+      })
     })
 
     describe(`Nested Object GroupBy`, () => {
@@ -1218,8 +1600,8 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
               .where(({ orders }) =>
                 and(
                   not(isUndefined(orders.customer)),
-                  not(isUndefined(orders.shipping))
-                )
+                  not(isUndefined(orders.shipping)),
+                ),
               )
               .groupBy(({ orders }) => orders.customer?.tier)
               .groupBy(({ orders }) => orders.shipping?.method)
@@ -1236,14 +1618,14 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
 
         // Should have groups for each tier-method combination
         const goldExpress = results.find(
-          (r) => r.tier === `gold` && r.method === `express`
+          (r) => r.tier === `gold` && r.method === `express`,
         )
         expect(goldExpress).toBeDefined()
         expect(goldExpress?.order_count).toBe(1)
         expect(goldExpress?.total_amount).toBe(100)
 
         const goldStandard = results.find(
-          (r) => r.tier === `gold` && r.method === `standard`
+          (r) => r.tier === `gold` && r.method === `standard`,
         )
         expect(goldStandard).toBeDefined()
         expect(goldStandard?.order_count).toBe(1)
@@ -1257,7 +1639,7 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
             q
               .from({ orders: ordersCollection })
               .where(({ orders }) =>
-                not(isUndefined(orders.customer?.preferences))
+                not(isUndefined(orders.customer?.preferences)),
               )
               .groupBy(({ orders }) => orders.customer?.preferences.newsletter)
               .select(({ orders }) => ({
@@ -1272,14 +1654,14 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
         expect(results).toHaveLength(2) // true and false
 
         const subscribedUsers = results.find(
-          (r) => r.newsletter_subscribed === true
+          (r) => r.newsletter_subscribed === true,
         )
         expect(subscribedUsers).toBeDefined()
         expect(subscribedUsers?.order_count).toBe(2) // Orders from John Doe (gold tier)
         expect(subscribedUsers?.total_amount).toBe(300) // 100 + 200
 
         const unsubscribedUsers = results.find(
-          (r) => r.newsletter_subscribed === false
+          (r) => r.newsletter_subscribed === false,
         )
         expect(unsubscribedUsers).toBeDefined()
         expect(unsubscribedUsers?.order_count).toBe(1) // Order from Jane Smith
@@ -1293,7 +1675,7 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
             q
               .from({ orders: ordersCollection })
               .groupBy(({ orders }) =>
-                not(isUndefined(orders.shipping?.tracking))
+                not(isUndefined(orders.shipping?.tracking)),
               )
               .select(({ orders }) => ({
                 tracking_status: not(isUndefined(orders.shipping?.tracking)),
@@ -1380,6 +1762,208 @@ function createGroupByTests(autoIndex: `off` | `eager`): void {
         expect(goldTier?.order_count).toBe(initialGoldCount)
       })
     })
+
+    describe(`ORDER BY and HAVING with SELECT fields`, () => {
+      let sessionsCollection: ReturnType<typeof createOrdersCollection>
+
+      beforeEach(() => {
+        // Reuse ordersCollection as sessionsCollection for testing
+        sessionsCollection = createOrdersCollection(autoIndex)
+      })
+
+      test(`orderBy can reference aggregate field from SELECT`, () => {
+        const sessionStats = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ sessions: sessionsCollection })
+              .where(({ sessions }) => eq(sessions.status, `completed`))
+              .groupBy(({ sessions }) => sessions.customer_id)
+              .select(({ sessions }) => ({
+                taskId: sessions.customer_id,
+                latestActivity: max(sessions.date),
+                sessionCount: count(sessions.id),
+              }))
+              .orderBy(({ $selected }) => $selected.latestActivity),
+        })
+
+        expect(sessionStats.toArray).toEqual([
+          {
+            taskId: 2,
+            latestActivity: new Date(`2023-02-01`),
+            sessionCount: 1,
+          },
+          {
+            taskId: 1,
+            latestActivity: new Date(`2023-03-01`),
+            sessionCount: 3,
+          },
+        ])
+      })
+
+      test(`orderBy can reference non-aggregate field from SELECT`, () => {
+        const sessionStats = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ sessions: sessionsCollection })
+              .where(({ sessions }) => eq(sessions.status, `completed`))
+              .groupBy(({ sessions }) => sessions.customer_id)
+              .select(({ sessions }) => ({
+                taskId: sessions.customer_id,
+                latestActivity: max(sessions.date),
+                sessionCount: count(sessions.id),
+              }))
+              .orderBy(({ $selected }) => $selected.taskId, {
+                direction: `desc`,
+              }),
+        })
+
+        expect(sessionStats.toArray).toEqual([
+          {
+            taskId: 2,
+            latestActivity: new Date(`2023-02-01`),
+            sessionCount: 1,
+          },
+          {
+            taskId: 1,
+            latestActivity: new Date(`2023-03-01`),
+            sessionCount: 3,
+          },
+        ])
+      })
+
+      test(`HAVING can reference aggregate field from SELECT`, () => {
+        const sessionStats = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ sessions: sessionsCollection })
+              .where(({ sessions }) => eq(sessions.status, `completed`))
+              .groupBy(({ sessions }) => sessions.customer_id)
+              .select(({ sessions }) => ({
+                taskId: sessions.customer_id,
+                latestActivity: max(sessions.date),
+                sessionCount: count(sessions.id),
+              }))
+              .having(({ $selected }) => gt($selected.sessionCount, 2)),
+        })
+
+        expect(sessionStats.toArray).toEqual([
+          {
+            taskId: 1,
+            latestActivity: new Date(`2023-03-01`),
+            sessionCount: 3,
+          },
+        ])
+      })
+
+      test(`HAVING can reference non-aggregate field from SELECT`, () => {
+        const sessionStats = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ sessions: sessionsCollection })
+              .where(({ sessions }) => eq(sessions.status, `completed`))
+              .groupBy(({ sessions }) => sessions.customer_id)
+              .select(({ sessions }) => ({
+                taskId: sessions.customer_id,
+                latestActivity: max(sessions.date),
+                sessionCount: count(sessions.id),
+              }))
+              .having(({ $selected }) => gt($selected.taskId, 0)),
+        })
+
+        // Once bug is fixed, this should filter groups where taskId > 0
+        expect(sessionStats.size).toBe(2)
+      })
+
+      test(`fn.having can reference aggregate field from SELECT`, () => {
+        const sessionStats = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ sessions: sessionsCollection })
+              .where(({ sessions }) => eq(sessions.status, `completed`))
+              .groupBy(({ sessions }) => sessions.customer_id)
+              .select(({ sessions }) => ({
+                taskId: sessions.customer_id,
+                latestActivity: max(sessions.date),
+                sessionCount: count(sessions.id),
+                totalAmount: sum(sessions.amount),
+              }))
+              .fn.having(({ $selected }) => $selected.sessionCount > 2),
+        })
+
+        // Should only include groups where sessionCount > 2
+        // Customer 1 has 3 completed sessions, Customer 2 has 1
+        expect(sessionStats.size).toBe(1)
+
+        const result = sessionStats.toArray[0]
+        expect(result).toBeDefined()
+        expect(result?.taskId).toBe(1)
+        expect(result?.sessionCount).toBe(3)
+        expect(result?.totalAmount).toBe(700) // 100 + 200 + 400
+      })
+
+      test(`fn.having can reference non-aggregate field from SELECT`, () => {
+        const sessionStats = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ sessions: sessionsCollection })
+              .where(({ sessions }) => eq(sessions.status, `completed`))
+              .groupBy(({ sessions }) => sessions.customer_id)
+              .select(({ sessions }) => ({
+                taskId: sessions.customer_id,
+                latestActivity: max(sessions.date),
+                sessionCount: count(sessions.id),
+              }))
+              .fn.having(({ $selected }) => $selected.taskId > 1),
+        })
+
+        // Should only include groups where taskId > 1
+        // Customer 1 has taskId 1, Customer 2 has taskId 2
+        expect(sessionStats.size).toBe(1)
+
+        const result = sessionStats.toArray[0]
+        expect(result).toBeDefined()
+        expect(result?.taskId).toBe(2)
+        expect(result?.sessionCount).toBe(1)
+      })
+
+      test(`fn.having can use multiple SELECT fields in complex conditions`, () => {
+        const sessionStats = createLiveQueryCollection({
+          startSync: true,
+          query: (q) =>
+            q
+              .from({ sessions: sessionsCollection })
+              .where(({ sessions }) => eq(sessions.status, `completed`))
+              .groupBy(({ sessions }) => sessions.customer_id)
+              .select(({ sessions }) => ({
+                taskId: sessions.customer_id,
+                latestActivity: max(sessions.date),
+                sessionCount: count(sessions.id),
+                totalAmount: sum(sessions.amount),
+              }))
+              .fn.having(
+                ({ $selected }) =>
+                  $selected.sessionCount >= 2 && $selected.totalAmount > 300,
+              ),
+        })
+
+        // Should include groups where sessionCount >= 2 AND totalAmount > 300
+        // Customer 1: 3 sessions, 700 total ✓
+        // Customer 2: 1 session ✗
+        expect(sessionStats.size).toBe(1)
+
+        const result = sessionStats.toArray[0]
+        expect(result).toBeDefined()
+        expect(result?.taskId).toBe(1)
+        expect(result?.sessionCount).toBe(3)
+        expect(result?.totalAmount).toBe(700)
+      })
+    })
   })
 }
 
diff --git a/packages/db/tests/query/indexes.test.ts b/packages/db/tests/query/indexes.test.ts
index 4fdf16e0c..9b221443c 100644
--- a/packages/db/tests/query/indexes.test.ts
+++ b/packages/db/tests/query/indexes.test.ts
@@ -1,7 +1,7 @@
-import { beforeEach, describe, expect, it } from "vitest"
-import { createCollection } from "../../src/collection/index.js"
+import { beforeEach, describe, expect, it } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
 
-import { createLiveQueryCollection } from "../../src/query/live-query-collection"
+import { createLiveQueryCollection } from '../../src/query/live-query-collection'
 import {
   and,
   count,
@@ -11,8 +11,8 @@ import {
   inArray,
   length,
   or,
-} from "../../src/query/builder/functions"
-import { mockSyncCollectionOptions } from "../utils"
+} from '../../src/query/builder/functions'
+import { mockSyncCollectionOptions } from '../utils'
 
 interface TestItem {
   id: string
@@ -57,7 +57,7 @@ function createIndexUsageTracker(collection: any): {
   // Mock the indexes getter to intercept index access
   const originalIndexesGetter = Object.getOwnPropertyDescriptor(
     Object.getPrototypeOf(collection),
-    `indexes`
+    `indexes`,
   )?.get
   Object.defineProperty(collection, `indexes`, {
     get: function () {
@@ -138,7 +138,7 @@ function expectIndexUsage(
     shouldUseFullScan?: boolean
     indexCallCount?: number
     fullScanCallCount?: number
-  }
+  },
 ) {
   if (expectations.shouldUseIndex) {
     expect(stats.rangeQueryCalls).toBeGreaterThan(0)
@@ -168,7 +168,7 @@ function expectIndexUsage(
 // Helper to run a test with index usage tracking (automatically handles setup/cleanup)
 function withIndexTracking(
   collection: any,
-  testFn: (tracker: { stats: IndexUsageStats }) => void | Promise<void>
+  testFn: (tracker: { stats: IndexUsageStats }) => void | Promise<void>,
 ): void | Promise<void> {
   const tracker = createIndexUsageTracker(collection)
 
@@ -234,7 +234,7 @@ function createTestItemCollection(autoIndex: `off` | `eager` = `off`) {
       getKey: (item) => item.id,
       initialData: testData,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -344,7 +344,7 @@ describe(`Query Index Optimization`, () => {
             q
               .from({ item: collection })
               .where(({ item }: any) =>
-                and(eq(item.status, `active`), gte(item.age, 25))
+                and(eq(item.status, `active`), gte(item.age, 25)),
               )
               .select(({ item }: any) => ({
                 id: item.id,
@@ -441,7 +441,7 @@ describe(`Query Index Optimization`, () => {
             q
               .from({ item: collection })
               .where(({ item }: any) =>
-                inArray(item.status, [`active`, `pending`])
+                inArray(item.status, [`active`, `pending`]),
               )
               .select(({ item }: any) => ({
                 id: item.id,
@@ -537,7 +537,7 @@ describe(`Query Index Optimization`, () => {
             q
               .from({ item: collection })
               .join({ other: secondCollection }, ({ item, other }: any) =>
-                eq(item.status, other.status)
+                eq(item.status, other.status),
               )
               .where(({ item }: any) => eq(item.age, 25))
               .select(({ item, other }: any) => ({
@@ -645,10 +645,10 @@ describe(`Query Index Optimization`, () => {
             q
               .from({ item: collection })
               .join({ other: secondCollection }, ({ item, other }: any) =>
-                eq(item.id, other.id)
+                eq(item.id, other.id),
               )
               .where(({ item, other }: any) =>
-                and(eq(item.status, `active`), eq(other.status, `active`))
+                and(eq(item.status, `active`), eq(other.status, `active`)),
               )
               .select(({ item, other }: any) => ({
                 id: item.id,
@@ -749,10 +749,10 @@ describe(`Query Index Optimization`, () => {
               .join(
                 { other: secondCollection },
                 ({ item, other }: any) => eq(item.id, other.id2),
-                `inner`
+                `inner`,
               )
               .where(({ item, other }: any) =>
-                and(eq(item.status, `active`), eq(other.status, `active`))
+                and(eq(item.status, `active`), eq(other.status, `active`)),
               )
               .select(({ item, other }: any) => ({
                 id: item.id,
@@ -848,10 +848,10 @@ describe(`Query Index Optimization`, () => {
               .join(
                 { other: secondCollection },
                 ({ item, other }: any) => eq(item.id, other.id2),
-                `inner`
+                `inner`,
               )
               .where(({ item, other }: any) =>
-                and(eq(item.status, `active`), eq(other.status, `active`))
+                and(eq(item.status, `active`), eq(other.status, `active`)),
               )
               .select(({ item, other }: any) => ({
                 id: item.id,
@@ -941,10 +941,10 @@ describe(`Query Index Optimization`, () => {
               .join(
                 { other: secondCollection },
                 ({ item, other }: any) => eq(item.id, other.id2),
-                `left`
+                `left`,
               )
               .where(({ item, other }: any) =>
-                and(eq(item.status, `active`), eq(other.status, `active`))
+                and(eq(item.status, `active`), eq(other.status, `active`)),
               )
               .select(({ item, other }: any) => ({
                 id: item.id,
@@ -1060,10 +1060,10 @@ describe(`Query Index Optimization`, () => {
               .join(
                 { other: secondCollection },
                 ({ item, other }: any) => eq(item.id, other.id2),
-                `left`
+                `left`,
               )
               .where(({ item, other }: any) =>
-                and(eq(item.status, `active`), eq(other.status, `active`))
+                and(eq(item.status, `active`), eq(other.status, `active`)),
               )
               .select(({ item, other }: any) => ({
                 id: item.id,
@@ -1157,10 +1157,10 @@ describe(`Query Index Optimization`, () => {
               .join(
                 { other: secondCollection },
                 ({ item, other }: any) => eq(item.id, other.id2),
-                `right`
+                `right`,
               )
               .where(({ item, other }: any) =>
-                and(eq(item.status, `active`), eq(other.status, `active`))
+                and(eq(item.status, `active`), eq(other.status, `active`)),
               )
               .select(({ item, other }: any) => ({
                 id: item.id,
@@ -1253,10 +1253,10 @@ describe(`Query Index Optimization`, () => {
               .join(
                 { other: secondCollection },
                 ({ item, other }: any) => eq(item.id, other.id2),
-                `right`
+                `right`,
               )
               .where(({ item, other }: any) =>
-                and(eq(item.status, `active`), eq(other.status, `active`))
+                and(eq(item.status, `active`), eq(other.status, `active`)),
               )
               .select(({ item, other }: any) => ({
                 id: item.id,
diff --git a/packages/db/tests/query/join-subquery.test-d.ts b/packages/db/tests/query/join-subquery.test-d.ts
index f529d0e99..29d411854 100644
--- a/packages/db/tests/query/join-subquery.test-d.ts
+++ b/packages/db/tests/query/join-subquery.test-d.ts
@@ -1,7 +1,7 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { createLiveQueryCollection, eq, gt } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { createLiveQueryCollection, eq, gt } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample data types for join-subquery testing
 type Issue = {
@@ -67,7 +67,7 @@ function createIssuesCollection() {
       id: `join-subquery-test-issues-types`,
       getKey: (issue) => issue.id,
       initialData: sampleIssues,
-    })
+    }),
   )
 }
 
@@ -77,7 +77,7 @@ function createUsersCollection() {
       id: `join-subquery-test-users-types`,
       getKey: (user) => user.id,
       initialData: sampleUsers,
-    })
+    }),
   )
 }
 
@@ -101,7 +101,7 @@ describe(`Join Subquery Types`, () => {
             .join(
               { user: usersCollection },
               ({ issue, user }) => eq(issue.userId, user.id),
-              `inner`
+              `inner`,
             )
             .select(({ issue, user }) => ({
               issue_title: issue.title,
@@ -138,7 +138,7 @@ describe(`Join Subquery Types`, () => {
             .join(
               { activeUser: activeUsers },
               ({ issue, activeUser }) => eq(issue.userId, activeUser.id),
-              `left`
+              `left`,
             )
         },
       })
@@ -173,7 +173,7 @@ describe(`Join Subquery Types`, () => {
               { activeUser: activeUsers },
               ({ longIssue, activeUser }) =>
                 eq(longIssue.userId, activeUser.id),
-              `inner`
+              `inner`,
             )
             .select(({ longIssue, activeUser }) => ({
               issue_title: longIssue.title,
@@ -211,7 +211,7 @@ describe(`Join Subquery Types`, () => {
             .join(
               { engUser: engineeringUsers },
               ({ issue, engUser }) => eq(issue.userId, engUser.id),
-              `inner`
+              `inner`,
             )
             .select(({ issue, engUser }) => ({
               issue_title: issue.title,
@@ -245,7 +245,7 @@ describe(`Join Subquery Types`, () => {
             .join(
               { activeUser: activeUsers },
               ({ issue, activeUser }) => eq(issue.userId, activeUser.id),
-              `left`
+              `left`,
             )
         },
       })
@@ -292,7 +292,7 @@ describe(`Join Subquery Types`, () => {
             .join(
               { profile: userProfiles },
               ({ task, profile }) => eq(task.assigneeId, profile.profileId),
-              `inner`
+              `inner`,
             )
             .select(({ task, profile }) => ({
               id: task.taskId,
@@ -336,7 +336,7 @@ describe(`Join Subquery Types`, () => {
             .join(
               { user: usersCollection },
               ({ issue, user }) => eq(issue.userId, user.id),
-              `inner`
+              `inner`,
             )
             .select(({ issue, user }) => ({
               // Should have access to all original Issue properties
@@ -382,7 +382,7 @@ describe(`Join Subquery Types`, () => {
             .join(
               { activeUser: activeUsers },
               ({ issue, activeUser }) => eq(issue.userId, activeUser.id),
-              `left`
+              `left`,
             )
             .select(({ issue, activeUser }) => ({
               issue_title: issue.title,
diff --git a/packages/db/tests/query/join-subquery.test.ts b/packages/db/tests/query/join-subquery.test.ts
index bb7092d63..259fac7e2 100644
--- a/packages/db/tests/query/join-subquery.test.ts
+++ b/packages/db/tests/query/join-subquery.test.ts
@@ -1,7 +1,7 @@
-import { beforeEach, describe, expect, test } from "vitest"
-import { createLiveQueryCollection, eq, gt } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { beforeEach, describe, expect, test } from 'vitest'
+import { createLiveQueryCollection, eq, gt } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample data types for join-subquery testing
 type Issue = {
@@ -151,7 +151,7 @@ function createIssuesCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (issue) => issue.id,
       initialData: sampleIssues,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -162,7 +162,7 @@ function createUsersCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (user) => user.id,
       initialData: sampleUsers,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -173,7 +173,7 @@ function createProfilesCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (profile) => profile.id,
       initialData: sampleProfiles,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -184,7 +184,7 @@ function createProductsCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (product) => product.id,
       initialData: sampleProducts,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -195,7 +195,7 @@ function createTrialsCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (item) => `${item.productId}-${item.userId}`,
       initialData: sampleTrials,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -225,7 +225,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { user: usersCollection },
                 ({ issue, user }) => eq(issue.userId, user.id),
-                `inner`
+                `inner`,
               )
               .select(({ issue, user }) => ({
                 issue_title: issue.title,
@@ -264,7 +264,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { activeUser: activeUsers },
                 ({ issue, activeUser }) => eq(issue.userId, activeUser.id),
-                `left`
+                `left`,
               )
               .select(({ issue, activeUser }) => ({
                 issue_title: issue.title,
@@ -279,7 +279,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
 
         // Issues with active users should have user_name
         const activeUserIssues = results.filter(
-          (r) => r.user_name !== undefined
+          (r) => r.user_name !== undefined,
         )
         expect(activeUserIssues).toHaveLength(4) // Issues 1, 2, 3, 5 have active users
 
@@ -313,7 +313,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
                 { activeUser: activeUsers },
                 ({ longIssue, activeUser }) =>
                   eq(longIssue.userId, activeUser.id),
-                `inner`
+                `inner`,
               )
               .select(({ longIssue, activeUser }) => ({
                 issue_title: longIssue.title,
@@ -371,7 +371,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { engUser: engineeringUsers },
                 ({ issue, engUser }) => eq(issue.userId, engUser.id),
-                `inner`
+                `inner`,
               )
               .select(({ issue, engUser }) => ({
                 issue_title: issue.title,
@@ -407,7 +407,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { activeUser: activeUsers },
                 ({ issue, activeUser }) => eq(issue.userId, activeUser.id),
-                `left`
+                `left`,
               )
               .select(({ issue, activeUser }) => ({
                 issue_title: issue.title,
@@ -423,7 +423,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
 
         // Issues with active users should have user data
         const activeUserIssues = results.filter(
-          (r) => r.user_name !== undefined
+          (r) => r.user_name !== undefined,
         )
         expect(activeUserIssues).toHaveLength(4) // Issues 1, 2, 3, 5
 
@@ -449,7 +449,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
                     .where(({ tried }) => eq(tried.userId, 1)),
                 },
                 ({ tried, product }) => eq(tried.productId, product.id),
-                `left`
+                `left`,
               )
               .where(({ product }) => eq(product.id, 1))
               .select(({ product, tried }) => ({
@@ -485,7 +485,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
                     .limit(1),
                 },
                 ({ issue, users }) => eq(issue.userId, users.id),
-                `left`
+                `left`,
               )
               .orderBy(({ issue }) => issue.id, `desc`)
               .limit(1)
@@ -523,7 +523,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { issue: issuesCollection },
                 ({ issue, users }) => eq(issue.userId, users.id),
-                `right`
+                `right`,
               )
               .orderBy(({ issue }) => issue.id, `desc`)
               .limit(1)
@@ -580,7 +580,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { profile: userProfiles },
                 ({ task, profile }) => eq(task.assigneeId, profile.profileId),
-                `inner`
+                `inner`,
               )
               .select(({ task, profile }) => ({
                 id: task.taskId,
@@ -665,7 +665,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { profile: profilesCollection },
                 ({ user, profile }) => eq(user.id, profile.userId),
-                `inner`
+                `inner`,
               )
               .where(({ user }) => eq(user.status, `active`))
               .select(({ user, profile }) => ({
@@ -684,7 +684,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { issue: issuesCollection },
                 ({ activeUser, issue }) => eq(issue.userId, activeUser.userId),
-                `inner`
+                `inner`,
               )
               .select(({ activeUser, issue }) => ({
                 issue_title: issue.title,
@@ -703,7 +703,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
         expect(results).toHaveLength(4)
 
         const sortedResults = results.sort((a, b) =>
-          a.issue_title.localeCompare(b.issue_title)
+          a.issue_title.localeCompare(b.issue_title),
         )
 
         // Verify structure - should have both user data AND profile data
@@ -748,7 +748,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { profile: profilesCollection },
                 ({ user, profile }) => eq(user.id, profile.userId),
-                `inner`
+                `inner`,
               )
               .where(({ user }) => eq(user.status, `active`))
               .select(({ user, profile }) => ({
@@ -765,7 +765,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { author: usersWithProfiles },
                 ({ issue, author }) => eq(issue.userId, author.userId),
-                `left`
+                `left`,
               )
               .select(({ issue, author }) => ({
                 issue_id: issue.id,
@@ -802,7 +802,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { profile: profilesCollection },
                 ({ user, profile }) => eq(user.id, profile.userId),
-                `inner`
+                `inner`,
               )
               .select(({ user, profile }) => ({
                 userId: user.id,
@@ -829,7 +829,7 @@ function createJoinSubqueryTests(autoIndex: `off` | `eager`): void {
               .join(
                 { author: activeUsersWithProfiles },
                 ({ issue, author }) => eq(issue.userId, author.id),
-                `inner`
+                `inner`,
               )
               .select(({ issue, author }) => ({
                 issue_title: issue.title,
diff --git a/packages/db/tests/query/join.test-d.ts b/packages/db/tests/query/join.test-d.ts
index f453465c9..9fc1a6bde 100644
--- a/packages/db/tests/query/join.test-d.ts
+++ b/packages/db/tests/query/join.test-d.ts
@@ -1,9 +1,9 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { z } from "zod"
-import { type } from "arktype"
-import { createLiveQueryCollection, eq } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { z } from 'zod'
+import { type } from 'arktype'
+import { createLiveQueryCollection, eq } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample data types for join type testing
 type User = {
@@ -25,7 +25,7 @@ function createUsersCollection() {
       id: `test-users`,
       getKey: (user) => user.id,
       initialData: [],
-    })
+    }),
   )
 }
 
@@ -35,7 +35,7 @@ function createDepartmentsCollection() {
       id: `test-departments`,
       getKey: (dept) => dept.id,
       initialData: [],
-    })
+    }),
   )
 }
 
@@ -51,7 +51,7 @@ describe(`Join Types - Type Safety`, () => {
           .join(
             { dept: departmentsCollection },
             ({ user, dept }) => eq(user.department_id, dept.id),
-            `inner`
+            `inner`,
           ),
     })
 
@@ -77,7 +77,7 @@ describe(`Join Types - Type Safety`, () => {
           .join(
             { dept: departmentsCollection },
             ({ user, dept }) => eq(user.department_id, dept.id),
-            `left`
+            `left`,
           ),
     })
 
@@ -103,7 +103,7 @@ describe(`Join Types - Type Safety`, () => {
           .join(
             { dept: departmentsCollection },
             ({ user, dept }) => eq(user.department_id, dept.id),
-            `right`
+            `right`,
           ),
     })
 
@@ -129,7 +129,7 @@ describe(`Join Types - Type Safety`, () => {
           .join(
             { dept: departmentsCollection },
             ({ user, dept }) => eq(user.department_id, dept.id),
-            `full`
+            `full`,
           ),
     })
 
@@ -160,7 +160,7 @@ describe(`Join Types - Type Safety`, () => {
         id: `test-projects`,
         getKey: (project) => project.id,
         initialData: [],
-      })
+      }),
     )
 
     const multipleJoinQuery = createLiveQueryCollection({
@@ -170,12 +170,12 @@ describe(`Join Types - Type Safety`, () => {
           .join(
             { dept: departmentsCollection },
             ({ user, dept }) => eq(user.department_id, dept.id),
-            `left` // dept is optional
+            `left`, // dept is optional
           )
           .join(
             { project: projectsCollection },
             ({ user, project }) => eq(user.id, project.user_id),
-            `right` // user becomes optional, project required
+            `right`, // user becomes optional, project required
           ),
     })
 
@@ -205,7 +205,7 @@ describe(`Join Types - Type Safety`, () => {
           .join(
             { dept: departmentsCollection },
             ({ user, dept }) => eq(user.department_id, dept.id),
-            `left`
+            `left`,
           )
           .select(({ user, dept }) => ({
             userName: user.name,
@@ -237,7 +237,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         q
           .from({ user: usersCollection })
           .leftJoin({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           ),
     })
 
@@ -261,7 +261,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         q
           .from({ user: usersCollection })
           .rightJoin({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           ),
     })
 
@@ -285,7 +285,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         q
           .from({ user: usersCollection })
           .innerJoin({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           ),
     })
 
@@ -309,7 +309,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         q
           .from({ user: usersCollection })
           .fullJoin({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           ),
     })
 
@@ -340,7 +340,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         id: `test-projects`,
         getKey: (project) => project.id,
         initialData: [],
-      })
+      }),
     )
 
     const multipleJoinQuery = createLiveQueryCollection({
@@ -348,10 +348,10 @@ describe(`Join Alias Methods - Type Safety`, () => {
         q
           .from({ user: usersCollection })
           .leftJoin({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           )
           .rightJoin({ project: projectsCollection }, ({ user, project }) =>
-            eq(user.id, project.user_id)
+            eq(user.id, project.user_id),
           ),
     })
 
@@ -379,7 +379,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         q
           .from({ user: usersCollection })
           .leftJoin({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           )
           .select(({ user, dept }) => ({
             userName: user.name,
@@ -409,7 +409,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         q
           .from({ user: usersCollection })
           .innerJoin({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           )
           .select(({ user, dept }) => ({
             userName: user.name,
@@ -445,7 +445,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         id: `test-projects`,
         getKey: (project) => project.id,
         initialData: [],
-      })
+      }),
     )
 
     const mixedJoinQuery = createLiveQueryCollection({
@@ -453,12 +453,12 @@ describe(`Join Alias Methods - Type Safety`, () => {
         q
           .from({ user: usersCollection })
           .leftJoin({ dept: departmentsCollection }, ({ user, dept }) =>
-            eq(user.department_id, dept.id)
+            eq(user.department_id, dept.id),
           )
           .join(
             { project: projectsCollection },
             ({ dept, project }) => eq(dept?.id, project.department_id),
-            `inner`
+            `inner`,
           ),
     })
 
@@ -495,7 +495,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         id: `test-users-join-optional`,
         getKey: (user) => user.id,
         initialData: [],
-      })
+      }),
     )
 
     const eventCollection = createCollection(
@@ -503,7 +503,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
         id: `test-events-join-optional`,
         getKey: (event) => event.id,
         initialData: [],
-      })
+      }),
     )
 
     // This should not cause TypeScript errors - optional field as first argument
@@ -513,7 +513,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
           .from({ event: eventCollection })
           .innerJoin(
             { user: userCollection },
-            ({ event, user }) => eq(event.user_id, user.id) // Should work with optional field
+            ({ event, user }) => eq(event.user_id, user.id), // Should work with optional field
           )
           .select(({ event, user }) => ({
             eventTitle: event.title,
@@ -528,7 +528,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
           .from({ event: eventCollection })
           .innerJoin(
             { user: userCollection },
-            ({ event, user }) => eq(user.id, event.user_id) // Swapped argument order
+            ({ event, user }) => eq(user.id, event.user_id), // Swapped argument order
           )
           .select(({ event, user }) => ({
             eventTitle: event.title,
@@ -598,7 +598,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
           .from({ event: eventCollection })
           .innerJoin(
             { user: userCollection },
-            ({ event, user }) => eq(event.user_id, user.id) // Should work with optional field
+            ({ event, user }) => eq(event.user_id, user.id), // Should work with optional field
           )
           .select(({ event, user }) => ({
             eventTitle: event.title,
@@ -613,7 +613,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
           .from({ event: eventCollection })
           .innerJoin(
             { user: userCollection },
-            ({ event, user }) => eq(user.id, event.user_id) // Swapped argument order
+            ({ event, user }) => eq(user.id, event.user_id), // Swapped argument order
           )
           .select(({ event, user }) => ({
             eventTitle: event.title,
@@ -683,7 +683,7 @@ describe(`Join Alias Methods - Type Safety`, () => {
           .from({ post: postCollection })
           .leftJoin(
             { user: userCollection },
-            ({ post, user }) => eq(post.author_id, user.id) // Should work with nullable field
+            ({ post, user }) => eq(post.author_id, user.id), // Should work with nullable field
           )
           .select(({ post, user }) => ({
             postTitle: post.title,
@@ -711,7 +711,7 @@ describe(`Join with ArkType Schemas`, () => {
 
     const eventSchema = type({
       id: `string.uuid`,
-      "user_id?": `string.uuid`, // Optional foreign key using "field?"
+      'user_id?': `string.uuid`, // Optional foreign key using "field?"
       title: `string`,
     })
 
@@ -746,7 +746,7 @@ describe(`Join with ArkType Schemas`, () => {
           .from({ event: eventCollection })
           .innerJoin(
             { user: userCollection },
-            ({ event, user }) => eq(event.user_id, user.id) // Should work with optional field
+            ({ event, user }) => eq(event.user_id, user.id), // Should work with optional field
           )
           .select(({ event, user }) => ({
             eventTitle: event.title,
@@ -761,7 +761,7 @@ describe(`Join with ArkType Schemas`, () => {
           .from({ event: eventCollection })
           .innerJoin(
             { user: userCollection },
-            ({ event, user }) => eq(user.id, event.user_id) // Swapped argument order
+            ({ event, user }) => eq(user.id, event.user_id), // Swapped argument order
           )
           .select(({ event, user }) => ({
             eventTitle: event.title,
@@ -831,7 +831,7 @@ describe(`Join with ArkType Schemas`, () => {
           .from({ post: postCollection })
           .leftJoin(
             { user: userCollection },
-            ({ post, user }) => eq(post.author_id, user.id) // Should work with nullable field
+            ({ post, user }) => eq(post.author_id, user.id), // Should work with nullable field
           )
           .select(({ post, user }) => ({
             postTitle: post.title,
@@ -854,7 +854,7 @@ describe(`Join with ArkType Schemas`, () => {
       id: `number`,
       name: `string > 0`,
       email: `string.email`,
-      "status?": `"active" | "inactive"`,
+      'status?': `"active" | "inactive"`,
     })
 
     const postSchema = type({
@@ -862,7 +862,7 @@ describe(`Join with ArkType Schemas`, () => {
       title: `string > 0`,
       content: `string > 10`,
       user_id: `number`,
-      "category?": `"tech" | "lifestyle" | "news"`,
+      'category?': `"tech" | "lifestyle" | "news"`,
     })
 
     const userCollection = createCollection({
@@ -895,7 +895,7 @@ describe(`Join with ArkType Schemas`, () => {
         q
           .from({ post: postCollection })
           .innerJoin({ user: userCollection }, ({ post, user }) =>
-            eq(post.user_id, user.id)
+            eq(post.user_id, user.id),
           )
           .select(({ post, user }) => ({
             postTitle: post.title,
diff --git a/packages/db/tests/query/join.test.ts b/packages/db/tests/query/join.test.ts
index 67d302293..edb632c30 100644
--- a/packages/db/tests/query/join.test.ts
+++ b/packages/db/tests/query/join.test.ts
@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test } from "vitest"
+import { beforeEach, describe, expect, test } from 'vitest'
 import {
   concat,
   createLiveQueryCollection,
@@ -9,9 +9,9 @@ import {
   lt,
   not,
   or,
-} from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+} from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample data types for join testing
 type User = {
@@ -49,7 +49,7 @@ function createUsersCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (user) => user.id,
       initialData: sampleUsers,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -60,7 +60,7 @@ function createDepartmentsCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (dept) => dept.id,
       initialData: sampleDepartments,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -115,7 +115,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
             .join(
               { dept: departmentsCollection },
               ({ user, dept }) => eq(user.department_id, dept.id),
-              joinType
+              joinType,
             )
             .select(({ user, dept }) => ({
               user_name: user?.name,
@@ -203,7 +203,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
             .join(
               { dept: departmentsCollection },
               ({ user, dept }) => eq(user.department_id, dept.id),
-              joinType
+              joinType,
             ),
       })
 
@@ -296,7 +296,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
             .join(
               { dept: departmentsCollection },
               ({ user, dept }) => eq(user.department_id, dept.id),
-              joinType
+              joinType,
             )
             .select(({ user, dept }) => ({
               user_name: user?.name,
@@ -339,7 +339,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
             .join(
               { dept: departmentsCollection },
               ({ user, dept }) => eq(user.department_id, dept.id),
-              joinType
+              joinType,
             )
             .select(({ user, dept }) => ({
               user_name: user?.name,
@@ -378,7 +378,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
               .join(
                 { dept: departmentsCollection },
                 ({ user, dept }) => eq(user.department_id, dept.id),
-                joinType
+                joinType,
               )
               .select(({ user, dept }) => ({
                 user_name: user?.name,
@@ -427,7 +427,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
               .join(
                 { dept: departmentsCollection },
                 ({ user, dept }) => eq(user.department_id, dept.id),
-                joinType
+                joinType,
               )
               .select(({ user, dept }) => ({
                 user_name: user?.name,
@@ -437,7 +437,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
 
         // Initially Marketing has no users
         const marketingResults = joinQuery.toArray.filter(
-          (r) => r.department_name === `Marketing`
+          (r) => r.department_name === `Marketing`,
         )
         expect(marketingResults).toHaveLength(1)
         expect(marketingResults[0]?.user_name).toBeUndefined()
@@ -456,7 +456,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
 
         // Should now have Eve in Marketing instead of null
         const updatedMarketingResults = joinQuery.toArray.filter(
-          (r) => r.department_name === `Marketing`
+          (r) => r.department_name === `Marketing`,
         )
         expect(updatedMarketingResults).toHaveLength(1)
         expect(updatedMarketingResults[0]).toMatchObject({
@@ -504,7 +504,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
           getKey: (team) => team.id,
           initialData: teams,
           autoIndex,
-        })
+        }),
       )
 
       const teamMembersCollection = createCollection(
@@ -513,7 +513,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
           getKey: (member) => member.id,
           initialData: teamMembers,
           autoIndex,
-        })
+        }),
       )
 
       // Test WHERE clause that filters on the nullable side based on join type
@@ -528,7 +528,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
             q
               .from({ team: teamsCollection })
               .leftJoin({ member: teamMembersCollection }, ({ team, member }) =>
-                eq(team.id, member.team_id)
+                eq(team.id, member.team_id),
               )
               .where(({ member }) => eq(member?.user_id, 100))
               .select(({ team, member }) => ({
@@ -548,7 +548,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
               .from({ team: teamsCollection })
               .rightJoin(
                 { member: teamMembersCollection },
-                ({ team, member }) => eq(team.id, member.team_id)
+                ({ team, member }) => eq(team.id, member.team_id),
               )
               .where(({ team }) => eq(team?.active, true))
               .select(({ team, member }) => ({
@@ -567,7 +567,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
             q
               .from({ team: teamsCollection })
               .fullJoin({ member: teamMembersCollection }, ({ team, member }) =>
-                eq(team.id, member.team_id)
+                eq(team.id, member.team_id),
               )
               .where(({ member }) => eq(member?.role, `admin`))
               .select(({ team, member }) => ({
@@ -587,7 +587,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
               .from({ team: teamsCollection })
               .innerJoin(
                 { member: teamMembersCollection },
-                ({ team, member }) => eq(team.id, member.team_id)
+                ({ team, member }) => eq(team.id, member.team_id),
               )
               .where(({ member }) => eq(member.user_id, 100))
               .select(({ team, member }) => ({
@@ -698,7 +698,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
           getKey: (company) => company.id,
           initialData: companies,
           autoIndex,
-        })
+        }),
       )
 
       const projectsCollection = createCollection(
@@ -707,7 +707,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
           getKey: (project) => project.id,
           initialData: projects,
           autoIndex,
-        })
+        }),
       )
 
       const tasksCollection = createCollection(
@@ -716,7 +716,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
           getKey: (task) => task.id,
           initialData: tasks,
           autoIndex,
-        })
+        }),
       )
 
       // Create chained join query: Company -> Project -> Task
@@ -729,12 +729,12 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
             .join(
               { project: projectsCollection },
               ({ company, project }) => eq(project.company_id, company.id),
-              joinType
+              joinType,
             )
             .join(
               { task: tasksCollection },
               ({ task, project }) => eq(task.project_id, project?.id),
-              joinType
+              joinType,
             )
             .select(({ company, project, task }) => ({
               company_name: company?.name,
@@ -753,13 +753,13 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
         (r) =>
           r.company_name === `TechCorp` &&
           r.project_name === `Website` &&
-          r.task_name === `Design`
+          r.task_name === `Design`,
       )
       const dataIncChain = results.find(
         (r) =>
           r.company_name === `DataInc` &&
           r.project_name === `Analytics` &&
-          r.task_name === `Research`
+          r.task_name === `Research`,
       )
 
       expect(techCorpChain).toBeDefined()
@@ -784,7 +784,7 @@ function testJoinType(joinType: JoinType, autoIndex: `off` | `eager`) {
       expect(resultsAfterInsert.length).toBeGreaterThanOrEqual(initialCount)
 
       const newTaskResult = resultsAfterInsert.find(
-        (r) => r.task_name === `New Task`
+        (r) => r.task_name === `New Task`,
       )
       expect(newTaskResult).toBeDefined()
       expect(newTaskResult!.project_name).toBe(`Website`)
@@ -818,7 +818,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
               .join(
                 { dept: departmentsCollection },
                 ({ user, dept }) => eq(user.department_id, dept.id),
-                `inner`
+                `inner`,
               )
               .select(({ user, dept }) => ({
                 user_name: user.name,
@@ -868,7 +868,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
         expect(resultNames).toEqual([`Bob`, `Charlie`, `Dave`, `Eve`])
 
         const daveResult = innerJoinQuery.toArray.find(
-          (r) => r.user_name === `Dave`
+          (r) => r.user_name === `Dave`,
         )
         expect(daveResult).toMatchObject({
           user_name: `Dave`,
@@ -882,7 +882,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
             id: `empty-users`,
             getKey: (user) => user.id,
             initialData: [],
-          })
+          }),
         )
 
         const innerJoinQuery = createLiveQueryCollection({
@@ -893,7 +893,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
               .join(
                 { dept: departmentsCollection },
                 ({ user, dept }) => eq(user.department_id, dept.id),
-                `inner`
+                `inner`,
               )
               .select(({ user, dept }) => ({
                 user_name: user.name,
@@ -932,7 +932,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
               .join(
                 { dept: departmentsCollection },
                 ({ user, dept }) => eq(user.department_id, dept.id),
-                `left`
+                `left`,
               )
               .select(({ user, dept }) => ({
                 user_id: user.id,
@@ -970,9 +970,9 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
                 ({ user, dept }) =>
                   eq(
                     concat(`dept`, user.department_id),
-                    concat(`dept`, dept.id)
+                    concat(`dept`, dept.id),
                   ),
-                `inner`
+                `inner`,
               )
               .select(({ user, dept }) => ({
                 user_name: user.name,
@@ -1030,7 +1030,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           getKey: (player) => player.name,
           initialData: samplePlayers,
           autoIndex,
-        })
+        }),
       )
 
       const clientsCollection = createCollection(
@@ -1039,7 +1039,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           getKey: (client) => client.name,
           initialData: sampleClients,
           autoIndex,
-        })
+        }),
       )
 
       const balancesCollection = createCollection(
@@ -1048,7 +1048,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           getKey: (balance) => balance.name,
           initialData: sampleBalances,
           autoIndex,
-        })
+        }),
       )
 
       // Create chained join query: Player -> Client -> Balance
@@ -1061,10 +1061,10 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           q
             .from({ player: playersCollection })
             .innerJoin({ client: clientsCollection }, ({ client, player }) =>
-              eq(client.player, player.name)
+              eq(client.player, player.name),
             )
             .innerJoin({ balance: balancesCollection }, ({ balance, client }) =>
-              eq(balance.client, client.name)
+              eq(balance.client, client.name),
             )
             .select(({ player, client, balance }) => ({
               player_name: player.name,
@@ -1101,7 +1101,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
       expect(resultsAfterClientUpdate).toHaveLength(3)
 
       const updatedResult1 = resultsAfterClientUpdate.find(
-        (r) => r.player_name === `player1`
+        (r) => r.player_name === `player1`,
       )
       expect(updatedResult1!.client_email).toBe(`updated-client1@example.com`)
       expect(updatedResult1!.balance_amount).toBe(1000) // Balance should remain the same
@@ -1124,7 +1124,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
       expect(resultsAfterBalanceUpdate).toHaveLength(3)
 
       const updatedResult2 = resultsAfterBalanceUpdate.find(
-        (r) => r.player_name === `player2`
+        (r) => r.player_name === `player2`,
       )
       expect(updatedResult2!.balance_amount).toBe(3000) // Updated amount
       expect(updatedResult2!.client_name).toBe(`client2`) // Client should remain the same
@@ -1160,7 +1160,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
       expect(resultsAfterBalanceInsert).toHaveLength(4)
 
       const newResult = resultsAfterBalanceInsert.find(
-        (r) => r.client_name === `client4`
+        (r) => r.client_name === `client4`,
       )
       expect(newResult).toBeDefined()
       expect(newResult!.player_name).toBe(`player1`)
@@ -1175,7 +1175,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
       const resultsAfterClientDelete = chainedJoinQuery.toArray
       expect(resultsAfterClientDelete).toHaveLength(3)
       expect(
-        resultsAfterClientDelete.find((r) => r.client_name === `client4`)
+        resultsAfterClientDelete.find((r) => r.client_name === `client4`),
       ).toBeUndefined()
     })
 
@@ -1200,7 +1200,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           id: `test-users-self-join`,
           getKey: (user) => user.id,
           initialData: selfJoinSampleUsers,
-        })
+        }),
       )
 
       const selfJoinQuery = createLiveQueryCollection({
@@ -1211,7 +1211,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
             .join(
               { parentUsers: selfJoinUsersCollection },
               ({ users, parentUsers }) => eq(users.parentId, parentUsers.id),
-              `inner`
+              `inner`,
             )
             .select(({ users, parentUsers }) => ({
               user_id: users.id,
@@ -1271,7 +1271,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           id: `test-users-bidirectional`,
           getKey: (user) => user.id,
           initialData: bidirectionalSampleUsers,
-        })
+        }),
       )
 
       // Test forward direction: eq(users.parentId, parentUsers.id)
@@ -1283,7 +1283,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
             .join(
               { parentUsers: bidirectionalUsersCollection },
               ({ users, parentUsers }) => eq(users.parentId, parentUsers.id),
-              `inner`
+              `inner`,
             )
             .select(({ users, parentUsers }) => ({
               user_name: users.name,
@@ -1303,7 +1303,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
             .join(
               { parentUsers: bidirectionalUsersCollection },
               ({ users, parentUsers }) => eq(parentUsers.id, users.parentId),
-              `inner`
+              `inner`,
             )
             .select(({ users, parentUsers }) => ({
               user_name: users.name,
@@ -1333,7 +1333,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           id: `test-users-same-table`,
           getKey: (user) => user.id,
           initialData: sampleUsers,
-        })
+        }),
       )
 
       const departmentsCollection = createDepartmentsCollection(autoIndex)
@@ -1345,11 +1345,11 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
             q.from({ user: usersCollection }).join(
               { dept: departmentsCollection },
               ({ user }) => eq(user.id, user.department_id), // Both refer to 'user' table
-              `inner`
+              `inner`,
             ),
         })
       }).toThrow(
-        `Invalid join condition: both expressions refer to the same source "user"`
+        `Invalid join condition: both expressions refer to the same source "user"`,
       )
     })
 
@@ -1359,7 +1359,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           id: `test-users-no-refs`,
           getKey: (user) => user.id,
           initialData: sampleUsers,
-        })
+        }),
       )
 
       const departmentsCollection = createDepartmentsCollection(autoIndex)
@@ -1371,11 +1371,11 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
             q.from({ user: usersCollection }).join(
               { dept: departmentsCollection },
               () => eq(1, 2), // Constants, no table references
-              `inner`
+              `inner`,
             ),
         })
       }).toThrow(
-        `Invalid join condition: expressions must reference source aliases`
+        `Invalid join condition: expressions must reference source aliases`,
       )
     })
 
@@ -1385,7 +1385,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           id: `test-users-no-refs`,
           getKey: (user) => user.id,
           initialData: sampleUsers,
-        })
+        }),
       )
 
       const departmentsCollection = createDepartmentsCollection(autoIndex)
@@ -1401,16 +1401,16 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
               .join(
                 { dept: departmentsCollection },
                 ({ user, dept }) => eq(dept.id, user.department_id),
-                `inner`
+                `inner`,
               )
               .join(
                 { dept2: departmentsCollection2 },
                 ({ user, dept }) => eq(dept.id, user.department_id),
-                `inner`
+                `inner`,
               ),
         })
       }).toThrow(
-        `Invalid join condition: right expression does not refer to the joined source "dept2"`
+        `Invalid join condition: right expression does not refer to the joined source "dept2"`,
       )
     })
 
@@ -1420,7 +1420,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           id: `test-users-mixed-refs`,
           getKey: (user) => user.id,
           initialData: sampleUsers,
-        })
+        }),
       )
 
       const departmentsCollection = createDepartmentsCollection(autoIndex)
@@ -1432,11 +1432,11 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
             q.from({ user: usersCollection }).join(
               { dept: departmentsCollection },
               ({ user }) => eq(user.id, user.department_id), // Both refer to 'user' table
-              `inner`
+              `inner`,
             ),
         })
       }).toThrow(
-        `Invalid join condition: both expressions refer to the same source "user"`
+        `Invalid join condition: both expressions refer to the same source "user"`,
       )
     })
 
@@ -1447,7 +1447,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           id: `special-users`,
           getKey: (user) => user.id,
           initialData: [{ id: 1, special: true }],
-        })
+        }),
       )
 
       const joinQuery = createLiveQueryCollection({
@@ -1457,7 +1457,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
             .from({ user: usersCollection })
             .leftJoin(
               { special: specialUsersCollection },
-              ({ user, special }) => eq(user.id, special.id)
+              ({ user, special }) => eq(user.id, special.id),
             )
             .where(({ special }) => isUndefined(special)),
       })
@@ -1514,7 +1514,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           getKey: (event) => event.id,
           initialData: sampleEvents,
           autoIndex,
-        })
+        }),
       )
 
       const queryWithWhere = createLiveQueryCollection({
@@ -1523,12 +1523,12 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           q
             .from({ event: eventCollection })
             .where(({ event }) =>
-              eq(event.id, `3770a4a6-3260-4566-9f79-f50864ebdd46`)
+              eq(event.id, `3770a4a6-3260-4566-9f79-f50864ebdd46`),
             )
             .join(
               { parent: eventCollection },
               ({ event, parent }) => eq(parent.id, event.parent_id),
-              `left`
+              `left`,
             )
             .select(({ event, parent }) => ({
               id: event.id,
@@ -1546,13 +1546,13 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
       expect(childEventWithWhere).toBeDefined()
 
       expect(childEventWithWhere.id).toBe(
-        `3770a4a6-3260-4566-9f79-f50864ebdd46`
+        `3770a4a6-3260-4566-9f79-f50864ebdd46`,
       )
       expect(childEventWithWhere.parent_id).toBe(
-        `ba224e71-a464-418d-a0a9-5959b490775d`
+        `ba224e71-a464-418d-a0a9-5959b490775d`,
       )
       expect(childEventWithWhere.parent.id).toBe(
-        `ba224e71-a464-418d-a0a9-5959b490775d`
+        `ba224e71-a464-418d-a0a9-5959b490775d`,
       )
     })
 
@@ -1580,7 +1580,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
           getKey: (person) => person.id,
           initialData: samplePeople,
           autoIndex,
-        })
+        }),
       )
 
       // Query: Find employees aged > 30 and their managers aged > 35
@@ -1593,10 +1593,10 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
             .join(
               { manager: peopleCollection },
               ({ employee, manager }) => eq(employee.manager_id, manager.id),
-              `left`
+              `left`,
             )
             .where(({ manager }) =>
-              or(isNull(manager?.id), gt(manager?.age, 35))
+              or(isNull(manager?.id), gt(manager?.age, 35)),
             )
             .select(({ employee, manager }) => ({
               employeeId: employee.id,
@@ -1664,7 +1664,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
         getKey: (item) => item.id,
         initialData: collection1Data,
         autoIndex,
-      })
+      }),
     )
 
     const collection2 = createCollection(
@@ -1673,7 +1673,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
         getKey: (item) => item.id,
         initialData: collection2Data,
         autoIndex,
-      })
+      }),
     )
 
     const multipleJoinQuery = createLiveQueryCollection({
@@ -1688,7 +1688,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
                 .where(({ join1 }) => not(gt(join1.other, 20))),
             },
             ({ main, join1 }) => eq(main.value, join1.value),
-            `left`
+            `left`,
           )
           .join(
             {
@@ -1697,7 +1697,7 @@ function createJoinTests(autoIndex: `off` | `eager`): void {
                 .where(({ join2 }) => not(lt(join2.other, 20))),
             },
             ({ main, join2 }) => eq(main.value, join2.value),
-            `left`
+            `left`,
           ),
     })
 
diff --git a/packages/db/tests/query/live-query-collection.test.ts b/packages/db/tests/query/live-query-collection.test.ts
index 87f407f2c..58ed050ea 100644
--- a/packages/db/tests/query/live-query-collection.test.ts
+++ b/packages/db/tests/query/live-query-collection.test.ts
@@ -1,19 +1,21 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { Temporal } from "temporal-polyfill"
-import { createCollection } from "../../src/collection/index.js"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { Temporal } from 'temporal-polyfill'
+import { createCollection } from '../../src/collection/index.js'
 import {
   and,
   createLiveQueryCollection,
   eq,
+  ilike,
   liveQueryCollectionOptions,
-} from "../../src/query/index.js"
-import { Query } from "../../src/query/builder/index.js"
+} from '../../src/query/index.js'
+import { Query } from '../../src/query/builder/index.js'
 import {
+  flushPromises,
   mockSyncCollectionOptions,
   mockSyncCollectionOptionsNoInitialState,
-} from "../utils.js"
-import { createDeferred } from "../../src/deferred"
-import type { ChangeMessage } from "../../src/types.js"
+} from '../utils.js'
+import { createDeferred } from '../../src/deferred'
+import type { ChangeMessage, LoadSubsetOptions } from '../../src/types.js'
 
 // Sample user type for tests
 type User = {
@@ -35,7 +37,7 @@ function createUsersCollection() {
       id: `test-users`,
       getKey: (user) => user.id,
       initialData: sampleUsers,
-    })
+    }),
   )
 }
 
@@ -50,7 +52,7 @@ describe(`createLiveQueryCollection`, () => {
     const activeUsers = createLiveQueryCollection((q) =>
       q
         .from({ user: usersCollection })
-        .where(({ user }) => eq(user.active, true))
+        .where(({ user }) => eq(user.active, true)),
     )
 
     await activeUsers.preload()
@@ -79,7 +81,7 @@ describe(`createLiveQueryCollection`, () => {
     const activeUsers1 = createLiveQueryCollection((q) =>
       q
         .from({ user: usersCollection })
-        .where(({ user }) => eq(user.active, true))
+        .where(({ user }) => eq(user.active, true)),
     )
 
     // Test with QueryBuilder instance via config
@@ -100,6 +102,139 @@ describe(`createLiveQueryCollection`, () => {
     expect(activeUsers2.size).toBe(2)
   })
 
+  describe(`compareOptions inheritance`, () => {
+    it(`should inherit compareOptions from FROM collection`, async () => {
+      // Create a collection with non-default compareOptions
+      const sourceCollection = createCollection(
+        mockSyncCollectionOptions<User>({
+          id: `source-with-lexical`,
+          getKey: (user) => user.id,
+          initialData: sampleUsers,
+          defaultStringCollation: {
+            stringSort: `lexical`,
+          },
+        }),
+      )
+
+      // Create a live query collection from the source collection
+      const liveQuery = createLiveQueryCollection((q) =>
+        q.from({ user: sourceCollection }),
+      )
+
+      // The live query should inherit the compareOptions from the source collection
+      expect(liveQuery.compareOptions).toEqual({
+        stringSort: `lexical`,
+      })
+      expect(sourceCollection.compareOptions).toEqual({
+        stringSort: `lexical`,
+      })
+    })
+
+    it(`should inherit compareOptions from FROM collection via subquery`, async () => {
+      // Create a collection with non-default compareOptions
+      const sourceCollection = createCollection(
+        mockSyncCollectionOptions<User>({
+          id: `source-with-locale`,
+          getKey: (user) => user.id,
+          initialData: sampleUsers,
+          defaultStringCollation: {
+            stringSort: `locale`,
+            locale: `de-DE`,
+          },
+        }),
+      )
+
+      // Create a live query collection with a subquery
+      const liveQuery = createLiveQueryCollection((q) => {
+        // Build the subquery first
+        const filteredUsers = q
+          .from({ user: sourceCollection })
+          .where(({ user }) => eq(user.active, true))
+
+        // Use the subquery in the main query
+        return q.from({ filteredUser: filteredUsers })
+      })
+
+      // The live query should inherit the compareOptions from the source collection
+      // (which is the FROM collection of the subquery)
+      expect(liveQuery.compareOptions).toEqual({
+        stringSort: `locale`,
+        locale: `de-DE`,
+      })
+      expect(sourceCollection.compareOptions).toEqual({
+        stringSort: `locale`,
+        locale: `de-DE`,
+      })
+    })
+
+    it(`should use default compareOptions when FROM collection has no compareOptions`, async () => {
+      // Create a collection without compareOptions (uses defaults)
+      const sourceCollection = createCollection(
+        mockSyncCollectionOptions<User>({
+          id: `source-with-defaults`,
+          getKey: (user) => user.id,
+          initialData: sampleUsers,
+          // No compareOptions specified - uses defaults
+        }),
+      )
+
+      // Create a live query collection with a subquery
+      const liveQuery = createLiveQueryCollection((q) => {
+        // Build the subquery first
+        const filteredUsers = q
+          .from({ user: sourceCollection })
+          .where(({ user }) => eq(user.active, true))
+
+        // Use the subquery in the main query
+        return q.from({ filteredUser: filteredUsers })
+      })
+
+      // The live query should use default compareOptions (locale)
+      // when the source collection doesn't specify compareOptions
+      expect(liveQuery.compareOptions).toEqual({
+        stringSort: `locale`,
+      })
+      expect(sourceCollection.compareOptions).toEqual({
+        stringSort: `locale`,
+      })
+    })
+
+    it(`should use explicitly provided compareOptions instead of inheriting from FROM collection`, async () => {
+      // Create a collection with non-default compareOptions
+      const sourceCollection = createCollection(
+        mockSyncCollectionOptions<User>({
+          id: `source-with-lexical`,
+          getKey: (user) => user.id,
+          initialData: sampleUsers,
+          defaultStringCollation: {
+            stringSort: `lexical`,
+          },
+        }),
+      )
+
+      // Create a live query collection with explicitly provided compareOptions
+      // that differ from the source collection's compareOptions
+      const liveQuery = createLiveQueryCollection({
+        query: (q) => q.from({ user: sourceCollection }),
+        defaultStringCollation: {
+          stringSort: `locale`,
+          locale: `en-US`,
+        },
+      })
+
+      // The live query should use the explicitly provided compareOptions,
+      // not the inherited ones from the source collection
+      expect(liveQuery.compareOptions).toEqual({
+        stringSort: `locale`,
+        locale: `en-US`,
+      })
+      // The source collection should still have its original compareOptions
+      expect(sourceCollection.compareOptions).toEqual({
+        stringSort: `lexical`,
+      })
+    })
+  })
+
   it(`should call markReady when source collection returns empty array`, async () => {
     // Create an empty source collection using the mock sync options
     const emptyUsersCollection = createCollection(
@@ -107,14 +242,14 @@ describe(`createLiveQueryCollection`, () => {
         id: `empty-test-users`,
         getKey: (user) => user.id,
         initialData: [], // Empty initial data
-      })
+      }),
     )
 
     // Create a live query collection that depends on the empty source collection
     const liveQuery = createLiveQueryCollection((q) =>
       q
         .from({ user: emptyUsersCollection })
-        .where(({ user }) => eq(user.active, true))
+        .where(({ user }) => eq(user.active, true)),
     )
 
     // This should resolve and not hang, even though the source collection is empty
@@ -142,7 +277,7 @@ describe(`createLiveQueryCollection`, () => {
 
     // Create a live query collection that depends on the problematic source collection
     const liveQuery = createLiveQueryCollection((q) =>
-      q.from({ user: problemCollection })
+      q.from({ user: problemCollection }),
     )
 
     // This should resolve and not hang, even though the source collection doesn't commit data
@@ -172,7 +307,7 @@ describe(`createLiveQueryCollection`, () => {
     const liveQuery = createLiveQueryCollection((q) =>
       q
         .from({ user: problemCollection })
-        .where(({ user }) => eq(user.active, true))
+        .where(({ user }) => eq(user.active, true)),
     )
 
     // This should resolve and not hang, even though the source collection doesn't commit data
@@ -244,7 +379,7 @@ describe(`createLiveQueryCollection`, () => {
     const liveQuery = createLiveQueryCollection((q) =>
       q
         .from({ user: sourceCollection })
-        .where(({ user }) => eq(user.active, true))
+        .where(({ user }) => eq(user.active, true)),
     )
 
     // Initially, the live query should be in idle state (default startSync: false)
@@ -335,7 +470,7 @@ describe(`createLiveQueryCollection`, () => {
           { id: `t1`, last_email_id: `e1`, last_sent_at: 3 },
           { id: `t2`, last_email_id: `e2`, last_sent_at: 2 },
         ],
-      })
+      }),
     )
 
     const labelsByEmail = createCollection(
@@ -346,7 +481,7 @@ describe(`createLiveQueryCollection`, () => {
           { email_id: `e1`, label: `inbox` },
           { email_id: `e2`, label: `work` },
         ],
-      })
+      }),
     )
 
     // Source live query (pre-created)
@@ -374,7 +509,7 @@ describe(`createLiveQueryCollection`, () => {
               { label: labelsByEmail },
               ({ thread, label }: any) =>
                 eq(thread.last_email_id, label.email_id),
-              `inner`
+              `inner`,
             )
             .orderBy(({ thread }: any) => thread.last_sent_at, {
               direction: `desc`,
@@ -464,12 +599,12 @@ describe(`createLiveQueryCollection`, () => {
         id: `test-tasks`,
         getKey: (task) => task.id,
         initialData: [initialTask],
-      })
+      }),
     )
 
     // Create a live query collection that includes the temporal value
     const liveQuery = createLiveQueryCollection((q) =>
-      q.from({ task: taskCollection })
+      q.from({ task: taskCollection }),
     )
 
     await liveQuery.preload()
@@ -514,7 +649,7 @@ describe(`createLiveQueryCollection`, () => {
           id: `player`,
           getKey: (post) => post.id,
           autoIndex,
-        })
+        }),
       )
 
       const challenge1Collection = createCollection(
@@ -522,7 +657,7 @@ describe(`createLiveQueryCollection`, () => {
           id: `challenge1`,
           getKey: (post) => post.id,
           autoIndex,
-        })
+        }),
       )
 
       const challenge2Collection = createCollection(
@@ -530,7 +665,7 @@ describe(`createLiveQueryCollection`, () => {
           id: `challenge2`,
           getKey: (post) => post.id,
           autoIndex,
-        })
+        }),
       )
 
       const liveQuery = createLiveQueryCollection((q) =>
@@ -538,12 +673,12 @@ describe(`createLiveQueryCollection`, () => {
           .from({ player: playerCollection })
           .leftJoin(
             { challenge1: challenge1Collection },
-            ({ player, challenge1 }) => eq(player.id, challenge1.id)
+            ({ player, challenge1 }) => eq(player.id, challenge1.id),
           )
           .leftJoin(
             { challenge2: challenge2Collection },
-            ({ player, challenge2 }) => eq(player.id, challenge2.id)
-          )
+            ({ player, challenge2 }) => eq(player.id, challenge2.id),
+          ),
       )
 
       // Start the query, but don't wait it, we are doing to write the data to the
@@ -608,7 +743,7 @@ describe(`createLiveQueryCollection`, () => {
         id: `test-tasks`,
         getKey: (task) => `source:${task.id}`,
         initialData: [initialTask],
-      })
+      }),
     )
 
     const liveQuery = createLiveQueryCollection({
@@ -767,7 +902,7 @@ describe(`createLiveQueryCollection`, () => {
           base.insert({
             id: `${index + 1}`,
             created_at: Date.now() + index,
-          })
+          }),
         )
 
         await vi.advanceTimersByTimeAsync(5000)
@@ -812,7 +947,7 @@ describe(`createLiveQueryCollection`, () => {
                 write({
                   type: `insert`,
                   value: todo,
-                })
+                }),
               )
               commit()
               markReady()
@@ -940,6 +1075,153 @@ describe(`createLiveQueryCollection`, () => {
   })
 
   describe(`isLoadingSubset integration`, () => {
+    it(`should not mark live query ready while isLoadingSubset is true`, async () => {
+      // This test demonstrates the bug where live query is marked ready
+      // before isLoadingSubset becomes false, causing "ready" status with no data
+
+      let resolveLoadSubset: () => void
+      const loadSubsetPromise = new Promise<void>((resolve) => {
+        resolveLoadSubset = resolve
+      })
+
+      // Track whether loadSubset was called
+      let loadSubsetCalled = false
+
+      const sourceCollection = createCollection<{ id: number; value: number }>({
+        id: `source-delayed-subset`,
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+        startSync: true,
+        sync: {
+          sync: ({ markReady, begin, write, commit }) => {
+            // Mark source ready immediately with some initial data
+            begin()
+            write({ type: `insert`, value: { id: 1, value: 10 } })
+            write({ type: `insert`, value: { id: 2, value: 20 } })
+            write({ type: `insert`, value: { id: 3, value: 30 } })
+            commit()
+            markReady()
+
+            return {
+              loadSubset: () => {
+                loadSubsetCalled = true
+                // Return a promise that we control to delay the subset loading
+                return loadSubsetPromise
+              },
+            }
+          },
+        },
+      })
+
+      // Create a live query with orderBy + limit that triggers lazy loading
+      const liveQuery = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: sourceCollection })
+            .orderBy(({ item }) => item.value, `asc`)
+            .limit(2),
+        startSync: true,
+      })
+
+      // Wait a bit for the subscription to start and trigger loadSubset
+      await flushPromises()
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Source should be ready
+      expect(sourceCollection.isReady()).toBe(true)
+
+      // loadSubset should have been called (verifying our test setup is correct)
+      expect(loadSubsetCalled).toBe(true)
+
+      // Live query should have isLoadingSubset = true
+      expect(liveQuery.isLoadingSubset).toBe(true)
+
+      // KEY ASSERTION: Live query should NOT be ready while isLoadingSubset is true
+      // This is the bug we're fixing - without the fix, status would be 'ready' here
+      expect(liveQuery.status).not.toBe(`ready`)
+
+      // Status should be 'loading', which means useLiveQuery would return isLoading=true
+      expect(liveQuery.status).toBe(`loading`)
+
+      // Now resolve the loadSubset promise
+      resolveLoadSubset!()
+      await flushPromises()
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Now isLoadingSubset should be false
+      expect(liveQuery.isLoadingSubset).toBe(false)
+
+      // Now the live query should be ready
+      expect(liveQuery.status).toBe(`ready`)
+    })
+
+    it(`should handle synchronously resolving loadSubset without race condition`, async () => {
+      // This test specifically targets the race condition where loadSubset resolves
+      // synchronously (or extremely fast). The fix must ensure we don't miss the
+      // transient loadingSubset -> ready transition even in this case.
+
+      // Track whether loadSubset was called
+      let loadSubsetCalled = false
+
+      const sourceCollection = createCollection<{ id: number; value: number }>({
+        id: `source-sync-subset`,
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+        startSync: true,
+        sync: {
+          sync: ({ markReady, begin, write, commit }) => {
+            // Mark source ready immediately with some initial data
+            begin()
+            write({ type: `insert`, value: { id: 1, value: 10 } })
+            write({ type: `insert`, value: { id: 2, value: 20 } })
+            write({ type: `insert`, value: { id: 3, value: 30 } })
+            commit()
+            markReady()
+
+            return {
+              loadSubset: () => {
+                loadSubsetCalled = true
+                // Return an IMMEDIATELY resolving promise - this is the tricky case
+                // where the status transition could be missed if listener registration
+                // happens after snapshot triggering
+                return Promise.resolve()
+              },
+            }
+          },
+        },
+      })
+
+      // Create a live query with orderBy + limit that triggers lazy loading
+      const liveQuery = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: sourceCollection })
+            .orderBy(({ item }) => item.value, `asc`)
+            .limit(2),
+        startSync: true,
+      })
+
+      // Wait for everything to settle
+      await flushPromises()
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Source should be ready
+      expect(sourceCollection.isReady()).toBe(true)
+
+      // loadSubset should have been called
+      expect(loadSubsetCalled).toBe(true)
+
+      // KEY ASSERTION: Even with sync resolution, isLoadingSubset should now be false
+      // (the promise resolved immediately)
+      expect(liveQuery.isLoadingSubset).toBe(false)
+
+      // And the live query should be ready (not stuck in loading)
+      expect(liveQuery.status).toBe(`ready`)
+
+      // Verify we have data (not empty due to race condition)
+      expect(liveQuery.size).toBeGreaterThan(0)
+    })
+
     it(`live query result collection has isLoadingSubset property`, async () => {
       const sourceCollection = createCollection<{ id: string; value: string }>({
         id: `source`,
@@ -952,7 +1234,7 @@ describe(`createLiveQueryCollection`, () => {
       })
 
       const liveQuery = createLiveQueryCollection((q) =>
-        q.from({ item: sourceCollection })
+        q.from({ item: sourceCollection }),
       )
 
       await liveQuery.preload()
@@ -982,12 +1264,16 @@ describe(`createLiveQueryCollection`, () => {
       expect(liveQuery.isLoadingSubset).toBe(false)
     })
 
-    it(`source collection isLoadingSubset is independent`, async () => {
-      let resolveLoadSubset: () => void
-      const loadSubsetPromise = new Promise<void>((resolve) => {
-        resolveLoadSubset = resolve
+    it(`source collection isLoadingSubset is independent from direct calls`, async () => {
+      // Create a pending promise for tracking direct loadSubset calls (not the initial subscription load)
+      let resolveDirectLoadSubset: () => void
+      const directLoadSubsetPromise = new Promise<void>((resolve) => {
+        resolveDirectLoadSubset = resolve
       })
 
+      // Track how many times loadSubset is called
+      let loadSubsetCallCount = 0
+
       const sourceCollection = createCollection<{ id: string; value: number }>({
         id: `source`,
         getKey: (item) => item.id,
@@ -999,7 +1285,15 @@ describe(`createLiveQueryCollection`, () => {
             commit()
             markReady()
             return {
-              loadSubset: () => loadSubsetPromise,
+              loadSubset: () => {
+                loadSubsetCallCount++
+                // First call is from the subscription's initial load - complete synchronously
+                // Subsequent calls (direct calls) use the pending promise
+                if (loadSubsetCallCount === 1) {
+                  return true // synchronous completion
+                }
+                return directLoadSubsetPromise
+              },
             }
           },
         },
@@ -1012,20 +1306,76 @@ describe(`createLiveQueryCollection`, () => {
 
       await liveQuery.preload()
 
+      // After preload, both should have isLoadingSubset = false
+      expect(sourceCollection.isLoadingSubset).toBe(false)
+      expect(liveQuery.isLoadingSubset).toBe(false)
+
       // Calling loadSubset directly on source collection sets its own isLoadingSubset
       sourceCollection._sync.loadSubset({})
       expect(sourceCollection.isLoadingSubset).toBe(true)
 
       // But live query isLoadingSubset tracks subscription-driven loads, not direct loadSubset calls
-      // so it remains false unless subscriptions trigger loads via predicate pushdown
+      // so it remains false when loadSubset is called directly on the source collection
       expect(liveQuery.isLoadingSubset).toBe(false)
 
-      resolveLoadSubset!()
+      resolveDirectLoadSubset!()
       await new Promise((resolve) => setTimeout(resolve, 10))
 
       expect(sourceCollection.isLoadingSubset).toBe(false)
       expect(liveQuery.isLoadingSubset).toBe(false)
     })
+
+    it(`status listener is registered before triggering snapshot to prevent race condition`, async () => {
+      // This test verifies the fix for the race condition where the subscription
+      // status could transition to 'loadingSubset' and back to 'ready' before
+      // the status listener was registered, causing the live query to miss
+      // tracking the loadSubset promise.
+      //
+      // The fix ensures the status listener is registered BEFORE calling
+      // triggerSnapshot() (which calls requestSnapshot/requestLimitedSnapshot).
+
+      // Track the order of events
+      const events: Array<string> = []
+
+      // Create a source collection where loadSubset synchronously calls the tracking
+      const sourceCollection = createCollection<{ id: number; name: string }>({
+        id: `race-condition-source`,
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+        sync: {
+          sync: ({ markReady }) => {
+            markReady()
+            return {
+              loadSubset: () => {
+                events.push(`loadSubset called`)
+                // Return a synchronously resolved promise to simulate the race condition
+                return Promise.resolve().then(() => {
+                  events.push(`loadSubset resolved`)
+                })
+              },
+            }
+          },
+        },
+      })
+
+      const liveQuery = createLiveQueryCollection({
+        query: (q) => q.from({ item: sourceCollection }),
+        startSync: true,
+      })
+
+      // Wait for the live query to be ready
+      await liveQuery.preload()
+
+      // Verify the events occurred
+      expect(events).toContain(`loadSubset called`)
+      expect(events).toContain(`loadSubset resolved`)
+
+      // The key assertion: the live query should be ready after preload
+      // This proves that even with a synchronously-resolved promise,
+      // the code path works correctly
+      expect(liveQuery.status).toBe(`ready`)
+      expect(liveQuery.isLoadingSubset).toBe(false)
+    })
   })
 
   describe(`move functionality`, () => {
@@ -1043,7 +1393,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 5, name: `Eve`, active: true },
             { id: 6, name: `Frank`, active: true },
           ],
-        })
+        }),
       )
 
       const activeUsers = createLiveQueryCollection((q) =>
@@ -1052,7 +1402,7 @@ describe(`createLiveQueryCollection`, () => {
           .where(({ user }) => eq(user.active, true))
           .orderBy(({ user }) => user.name, `desc`)
           .limit(3)
-          .offset(0)
+          .offset(0),
       )
 
       await activeUsers.preload()
@@ -1093,7 +1443,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 5, name: `Eve`, active: true },
             { id: 6, name: `Frank`, active: true },
           ],
-        })
+        }),
       )
 
       const activeUsers = createLiveQueryCollection((q) =>
@@ -1102,7 +1452,7 @@ describe(`createLiveQueryCollection`, () => {
           .where(({ user }) => eq(user.active, true))
           .orderBy(({ user }) => user.name, `asc`)
           .limit(3)
-          .offset(3)
+          .offset(3),
       )
 
       await activeUsers.preload()
@@ -1142,7 +1492,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 4, name: `David`, active: true },
             { id: 5, name: `Eve`, active: true },
           ],
-        })
+        }),
       )
 
       const activeUsers = createLiveQueryCollection((q) =>
@@ -1151,7 +1501,7 @@ describe(`createLiveQueryCollection`, () => {
           .where(({ user }) => eq(user.active, true))
           .orderBy(({ user }) => user.name, `asc`)
           .limit(2)
-          .offset(0)
+          .offset(0),
       )
 
       await activeUsers.preload()
@@ -1202,7 +1552,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 5, name: `Eve`, active: true },
             { id: 6, name: `Frank`, active: true },
           ],
-        })
+        }),
       )
 
       const activeUsers = createLiveQueryCollection((q) =>
@@ -1211,7 +1561,7 @@ describe(`createLiveQueryCollection`, () => {
           .where(({ user }) => eq(user.active, true))
           .orderBy(({ user }) => user.name, `asc`)
           .limit(2)
-          .offset(1)
+          .offset(1),
       )
 
       await activeUsers.preload()
@@ -1256,7 +1606,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 4, name: `David`, active: true },
             { id: 5, name: `Eve`, active: true },
           ],
-        })
+        }),
       )
 
       const activeUsers = createLiveQueryCollection((q) =>
@@ -1265,7 +1615,7 @@ describe(`createLiveQueryCollection`, () => {
           .where(({ user }) => eq(user.active, true))
           .orderBy(({ user }) => user.name, `asc`)
           .limit(2)
-          .offset(0)
+          .offset(0),
       )
 
       await activeUsers.preload()
@@ -1307,7 +1657,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 5, name: `Eve`, active: true },
             { id: 6, name: `Frank`, active: true },
           ],
-        })
+        }),
       )
 
       const activeUsers = createLiveQueryCollection((q) =>
@@ -1316,7 +1666,7 @@ describe(`createLiveQueryCollection`, () => {
           .where(({ user }) => eq(user.active, true))
           .orderBy(({ user }) => user.name, `asc`)
           .limit(2)
-          .offset(1)
+          .offset(1),
       )
 
       await activeUsers.preload()
@@ -1360,7 +1710,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 2, name: `Bob`, active: true },
             { id: 3, name: `Charlie`, active: true },
           ],
-        })
+        }),
       )
 
       const activeUsers = createLiveQueryCollection((q) =>
@@ -1369,7 +1719,7 @@ describe(`createLiveQueryCollection`, () => {
           .where(({ user }) => eq(user.active, true))
           .orderBy(({ user }) => user.name, `asc`)
           .limit(2)
-          .offset(0)
+          .offset(0),
       )
 
       await activeUsers.preload()
@@ -1429,7 +1779,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 5, name: `Eve`, active: true },
             { id: 6, name: `Frank`, active: true },
           ],
-        })
+        }),
       )
 
       const activeUsers = createLiveQueryCollection((q) =>
@@ -1438,7 +1788,7 @@ describe(`createLiveQueryCollection`, () => {
           .where(({ user }) => eq(user.active, true))
           .orderBy(({ user }) => user.name, `desc`)
           .limit(3)
-          .offset(0)
+          .offset(0),
       )
 
       await activeUsers.preload()
@@ -1471,7 +1821,7 @@ describe(`createLiveQueryCollection`, () => {
         (q) =>
           q
             .from({ user: usersCollection })
-            .where(({ user }) => eq(user.active, true))
+            .where(({ user }) => eq(user.active, true)),
         // No orderBy clause
       )
 
@@ -1484,7 +1834,7 @@ describe(`createLiveQueryCollection`, () => {
       expect(() => {
         activeUsers.utils.setWindow({ offset: 1, limit: 1 })
       }).toThrow(
-        /setWindow\(\) can only be called on collections with an ORDER BY clause/
+        /setWindow\(\) can only be called on collections with an ORDER BY clause/,
       )
     })
 
@@ -1508,7 +1858,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 5, title: `Post E`, authorId: 1, published: true },
             { id: 6, title: `Post F`, authorId: 2, published: true },
           ],
-        })
+        }),
       )
 
       const userPosts = createLiveQueryCollection((q) =>
@@ -1517,14 +1867,14 @@ describe(`createLiveQueryCollection`, () => {
           .join(
             { post: posts },
             ({ user, post }) => eq(user.id, post.authorId),
-            `inner`
+            `inner`,
           )
           .where(({ user, post }) =>
-            and(eq(user.active, true), eq(post.published, true))
+            and(eq(user.active, true), eq(post.published, true)),
           )
           .orderBy(({ post }) => post.title, `asc`)
           .limit(3)
-          .offset(0)
+          .offset(0),
       )
 
       await userPosts.preload()
@@ -1562,7 +1912,7 @@ describe(`createLiveQueryCollection`, () => {
             { id: 2, name: `Bob`, active: true },
             { id: 3, name: `Charlie`, active: true },
           ],
-        })
+        }),
       )
 
       const activeUsers = createLiveQueryCollection((q) =>
@@ -1570,7 +1920,7 @@ describe(`createLiveQueryCollection`, () => {
           .from({ user: extendedUsers })
           .where(({ user }) => eq(user.active, true))
           .orderBy(({ user }) => user.name, `asc`)
-          .limit(2)
+          .limit(2),
       )
 
       await activeUsers.preload()
@@ -1706,4 +2056,327 @@ describe(`createLiveQueryCollection`, () => {
       }
     })
   })
+
+  describe(`custom getKey with joins error handling`, () => {
+    it(`should allow custom getKey with joins (1:1 relationships)`, async () => {
+      // Custom getKey with joins is allowed for 1:1 relationships
+      // where the join produces unique keys per row
+      const base = createCollection(
+        mockSyncCollectionOptions<{ id: string; name: string }>({
+          id: `base-with-custom-key`,
+          getKey: (item) => item.id,
+          initialData: [{ id: `1`, name: `Item 1` }],
+        }),
+      )
+
+      const related = createCollection(
+        mockSyncCollectionOptions<{ id: string; value: number }>({
+          id: `related-with-custom-key`,
+          getKey: (item) => item.id,
+          initialData: [{ id: `1`, value: 100 }],
+        }),
+      )
+
+      // Custom getKey is allowed - error only occurs if actual duplicates happen
+      const liveQuery = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ base })
+            .join({ related }, ({ base: b, related: r }) => eq(b.id, r.id))
+            .select(({ base: b, related: r }) => ({
+              id: b.id,
+              name: b.name,
+              value: r?.value,
+            })),
+        getKey: (item) => item.id, // Valid for 1:1 joins with unique keys
+      })
+
+      await liveQuery.preload()
+      expect(liveQuery.size).toBe(1)
+    })
+
+    it(`should throw enhanced error when duplicate keys occur with custom getKey + joins`, async () => {
+      const usersOptions = mockSyncCollectionOptions<{
+        id: string
+        name: string
+      }>({
+        id: `users-duplicate-test`,
+        getKey: (item) => item.id,
+        initialData: [{ id: `user1`, name: `User 1` }],
+      })
+      const users = createCollection(usersOptions)
+
+      const commentsOptions = mockSyncCollectionOptions<{
+        id: string
+        userId: string
+        text: string
+      }>({
+        id: `comments-duplicate-test`,
+        getKey: (item) => item.id,
+        initialData: [
+          { id: `comment1`, userId: `user1`, text: `First comment` },
+        ],
+      })
+      const comments = createCollection(commentsOptions)
+
+      const liveQuery = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ comments })
+            .join({ users }, ({ comments: c, users: u }) => eq(c.userId, u.id))
+            .select(({ comments: c, users: u }) => ({
+              id: c.id,
+              userId: u?.id ?? c.userId,
+              text: c.text,
+              userName: u?.name,
+            })),
+        getKey: (item) => item.userId,
+        startSync: true,
+      })
+
+      await liveQuery.preload()
+      expect(liveQuery.size).toBe(1)
+
+      try {
+        commentsOptions.utils.begin()
+        commentsOptions.utils.write({
+          type: `insert`,
+          value: { id: `comment2`, userId: `user1`, text: `Second comment` },
+        })
+        commentsOptions.utils.commit()
+        await new Promise((resolve) => setTimeout(resolve, 10))
+      } catch (error: any) {
+        expect(error.message).toContain(`already exists in the collection`)
+        expect(error.message).toContain(`custom getKey`)
+        expect(error.message).toContain(`joined queries`)
+        expect(error.message).toContain(`composite key`)
+        return
+      }
+
+      throw new Error(`Expected DuplicateKeySyncError to be thrown`)
+    })
+  })
+
+  describe(`where clauses passed to loadSubset`, () => {
+    it(`passes eq where clause to loadSubset`, async () => {
+      const capturedOptions: Array<LoadSubsetOptions> = []
+      let resolveLoadSubset: () => void
+      const loadSubsetPromise = new Promise<void>((resolve) => {
+        resolveLoadSubset = resolve
+      })
+
+      const baseCollection = createCollection<{ id: number; name: string }>({
+        id: `test-base`,
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+        sync: {
+          sync: ({ markReady }) => {
+            markReady()
+            return {
+              loadSubset: (options: LoadSubsetOptions) => {
+                capturedOptions.push(options)
+                return loadSubsetPromise
+              },
+            }
+          },
+        },
+      })
+
+      // Create a live query collection with a where clause
+      // This will go through convertToBasicExpression
+      const liveQueryCollection = createLiveQueryCollection((q) =>
+        q.from({ item: baseCollection }).where(({ item }) => eq(item.id, 2)),
+      )
+
+      // Trigger sync which will call loadSubset
+      await liveQueryCollection.preload()
+      await flushPromises()
+
+      expect(capturedOptions.length).toBeGreaterThan(0)
+      const lastCall = capturedOptions[capturedOptions.length - 1]
+      expect(lastCall?.where).toBeDefined()
+      // The where clause should be normalized (alias removed), so it should be eq(ref(['id']), 2)
+      expect(lastCall?.where?.type).toBe(`func`)
+      if (lastCall?.where?.type === `func`) {
+        expect(lastCall.where.name).toBe(`eq`)
+      }
+
+      resolveLoadSubset!()
+      await flushPromises()
+    })
+
+    it(`passes ilike where clause to loadSubset`, async () => {
+      const capturedOptions: Array<LoadSubsetOptions> = []
+      let resolveLoadSubset: () => void
+      const loadSubsetPromise = new Promise<void>((resolve) => {
+        resolveLoadSubset = resolve
+      })
+
+      const baseCollection = createCollection<{ id: number; name: string }>({
+        id: `test-base`,
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+        sync: {
+          sync: ({ markReady }) => {
+            markReady()
+            return {
+              loadSubset: (options: LoadSubsetOptions) => {
+                capturedOptions.push(options)
+                return loadSubsetPromise
+              },
+            }
+          },
+        },
+      })
+
+      // Create a live query collection with an ilike where clause
+      // This will go through convertToBasicExpression
+      const liveQueryCollection = createLiveQueryCollection((q) =>
+        q
+          .from({ item: baseCollection })
+          .where(({ item }) => ilike(item.name, `%test%`)),
+      )
+
+      // Trigger sync which will call loadSubset
+      await liveQueryCollection.preload()
+      await flushPromises()
+
+      expect(capturedOptions.length).toBeGreaterThan(0)
+      const lastCall = capturedOptions[capturedOptions.length - 1]
+      // Without the fix: where would be undefined/null
+      // With the fix: where should be defined with the ilike expression
+      expect(lastCall?.where).toBeDefined()
+      expect(lastCall?.where).not.toBeNull()
+      // The where clause should be normalized (alias removed), so it should be ilike(ref(['name']), '%test%')
+      expect(lastCall?.where?.type).toBe(`func`)
+      if (lastCall?.where?.type === `func`) {
+        expect(lastCall.where.name).toBe(`ilike`)
+      }
+
+      resolveLoadSubset!()
+      await flushPromises()
+    })
+
+    it(`passes single orderBy clause to loadSubset when using limit`, async () => {
+      const capturedOptions: Array<LoadSubsetOptions> = []
+      let resolveLoadSubset: () => void
+      const loadSubsetPromise = new Promise<void>((resolve) => {
+        resolveLoadSubset = resolve
+      })
+
+      const baseCollection = createCollection<{
+        id: number
+        name: string
+        age: number
+      }>({
+        id: `test-base-orderby`,
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+        sync: {
+          sync: ({ markReady }) => {
+            markReady()
+            return {
+              loadSubset: (options: LoadSubsetOptions) => {
+                capturedOptions.push(options)
+                return loadSubsetPromise
+              },
+            }
+          },
+        },
+      })
+
+      // Create a live query collection with orderBy and limit
+      const liveQueryCollection = createLiveQueryCollection((q) =>
+        q
+          .from({ item: baseCollection })
+          .orderBy(({ item }) => item.age, `asc`)
+          .limit(10),
+      )
+
+      // Start preload (don't await yet - it won't resolve until loadSubset completes)
+      const preloadPromise = liveQueryCollection.preload()
+      await flushPromises()
+
+      // Verify loadSubset was called with the correct options
+      expect(capturedOptions.length).toBeGreaterThan(0)
+
+      // Find the call that has orderBy (the limited snapshot request)
+      const callWithOrderBy = capturedOptions.find(
+        (opt) => opt.orderBy !== undefined,
+      )
+      expect(callWithOrderBy).toBeDefined()
+      expect(callWithOrderBy?.orderBy).toHaveLength(1)
+      expect(callWithOrderBy?.orderBy?.[0]?.expression.type).toBe(`ref`)
+      expect(callWithOrderBy?.limit).toBe(10)
+
+      // Resolve the loadSubset promise so preload can complete
+      resolveLoadSubset!()
+      await flushPromises()
+      await preloadPromise
+    })
+
+    it(`passes multiple orderBy columns to loadSubset when using limit`, async () => {
+      const capturedOptions: Array<LoadSubsetOptions> = []
+      let resolveLoadSubset: () => void
+      const loadSubsetPromise = new Promise<void>((resolve) => {
+        resolveLoadSubset = resolve
+      })
+
+      const baseCollection = createCollection<{
+        id: number
+        name: string
+        age: number
+        department: string
+      }>({
+        id: `test-base-multi-orderby`,
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+        sync: {
+          sync: ({ markReady }) => {
+            markReady()
+            return {
+              loadSubset: (options: LoadSubsetOptions) => {
+                capturedOptions.push(options)
+                return loadSubsetPromise
+              },
+            }
+          },
+        },
+      })
+
+      // Create a live query collection with multiple orderBy columns and limit
+      const liveQueryCollection = createLiveQueryCollection((q) =>
+        q
+          .from({ item: baseCollection })
+          .orderBy(({ item }) => item.department, `asc`)
+          .orderBy(({ item }) => item.age, `desc`)
+          .limit(10),
+      )
+
+      // Start preload (don't await yet - it won't resolve until loadSubset completes)
+      const preloadPromise = liveQueryCollection.preload()
+      await flushPromises()
+
+      // Verify loadSubset was called with the correct options
+      expect(capturedOptions.length).toBeGreaterThan(0)
+
+      // Find the call that has orderBy with multiple columns
+      const callWithMultiOrderBy = capturedOptions.find(
+        (opt) => opt.orderBy !== undefined && opt.orderBy.length > 1,
+      )
+
+      // Multi-column orderBy should be passed to loadSubset so the sync layer
+      // can optimize the query if the backend supports composite ordering
+      expect(callWithMultiOrderBy).toBeDefined()
+      expect(callWithMultiOrderBy?.orderBy).toHaveLength(2)
+      expect(callWithMultiOrderBy?.orderBy?.[0]?.expression.type).toBe(`ref`)
+      expect(callWithMultiOrderBy?.orderBy?.[1]?.expression.type).toBe(`ref`)
+      expect(callWithMultiOrderBy?.limit).toBe(10)
+
+      // Resolve the loadSubset promise so preload can complete
+      resolveLoadSubset!()
+      await flushPromises()
+      await preloadPromise
+    })
+  })
 })
diff --git a/packages/db/tests/query/load-subset-subquery.test.ts b/packages/db/tests/query/load-subset-subquery.test.ts
new file mode 100644
index 000000000..27ce7207c
--- /dev/null
+++ b/packages/db/tests/query/load-subset-subquery.test.ts
@@ -0,0 +1,268 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
+import {
+  and,
+  createLiveQueryCollection,
+  eq,
+  gte,
+} from '../../src/query/index.js'
+import { PropRef, Value } from '../../src/query/ir.js'
+import type { Collection } from '../../src/collection/index.js'
+import type {
+  LoadSubsetOptions,
+  NonSingleResult,
+  UtilsRecord,
+} from '../../src/types.js'
+import type { OrderBy } from '../../src/query/ir.js'
+
+// Sample types for testing
+type Order = {
+  id: number
+  scheduled_at: string
+  status: string
+  address_id: number
+}
+
+type Charge = {
+  id: number
+  address_id: number
+  amount: number
+}
+
+// Sample data
+const sampleOrders: Array<Order> = [
+  {
+    id: 1,
+    scheduled_at: `2024-01-15`,
+    status: `queued`,
+    address_id: 1,
+  },
+  {
+    id: 2,
+    scheduled_at: `2024-01-10`,
+    status: `queued`,
+    address_id: 2,
+  },
+  {
+    id: 3,
+    scheduled_at: `2024-01-20`,
+    status: `completed`,
+    address_id: 1,
+  },
+]
+
+const sampleCharges: Array<Charge> = [
+  { id: 1, address_id: 1, amount: 100 },
+  { id: 2, address_id: 2, amount: 200 },
+]
+
+type ChargersCollection = Collection<
+  Charge,
+  string | number,
+  UtilsRecord,
+  never,
+  Charge
+> &
+  NonSingleResult
+
+type OrdersCollection = Collection<
+  Order,
+  string | number,
+  UtilsRecord,
+  never,
+  Order
+> &
+  NonSingleResult
+
+describe(`loadSubset with subqueries`, () => {
+  let chargesCollection: ChargersCollection
+
+  beforeEach(() => {
+    // Create charges collection
+    chargesCollection = createCollection<Charge>({
+      id: `charges`,
+      getKey: (charge) => charge.id,
+      sync: {
+        sync: ({ begin, write, commit, markReady }) => {
+          begin()
+          for (const charge of sampleCharges) {
+            write({ type: `insert`, value: charge })
+          }
+          commit()
+          markReady()
+        },
+      },
+    })
+  })
+
+  function createOrdersCollectionWithTracking(): {
+    collection: OrdersCollection
+    loadSubsetCalls: Array<LoadSubsetOptions>
+  } {
+    const loadSubsetCalls: Array<LoadSubsetOptions> = []
+
+    const collection = createCollection<Order>({
+      id: `orders`,
+      getKey: (order) => order.id,
+      syncMode: `on-demand`,
+      sync: {
+        sync: ({ begin, write, commit, markReady }) => {
+          begin()
+          for (const order of sampleOrders) {
+            write({ type: `insert`, value: order })
+          }
+          commit()
+          markReady()
+          return {
+            loadSubset: vi.fn((options: LoadSubsetOptions) => {
+              loadSubsetCalls.push(options)
+              return Promise.resolve()
+            }),
+          }
+        },
+      },
+    })
+
+    return { collection, loadSubsetCalls }
+  }
+
+  it(`should call loadSubset with where clause for direct query`, async () => {
+    const today = `2024-01-12`
+    const { collection: ordersCollection, loadSubsetCalls } =
+      createOrdersCollectionWithTracking()
+
+    const directQuery = createLiveQueryCollection((q) =>
+      q
+        .from({ order: ordersCollection })
+        .where(({ order }) => gte(order.scheduled_at, today))
+        .where(({ order }) => eq(order.status, `queued`)),
+    )
+
+    await directQuery.preload()
+
+    // Verify loadSubset was called
+    expect(loadSubsetCalls.length).toBeGreaterThan(0)
+
+    // Verify the last call (or any call) has the where clause
+    const lastCall = loadSubsetCalls[loadSubsetCalls.length - 1]
+    expect(lastCall).toBeDefined()
+    expect(lastCall!.where).toBeDefined()
+
+    const expectedWhereClause = and(
+      gte(new PropRef([`scheduled_at`]), new Value(today)),
+      eq(new PropRef([`status`]), new Value(`queued`)),
+    )
+
+    expect(lastCall!.where).toEqual(expectedWhereClause)
+  })
+
+  it(`should call loadSubset with where clause for subquery`, async () => {
+    const today = `2024-01-12`
+    const { collection: ordersCollection, loadSubsetCalls } =
+      createOrdersCollectionWithTracking()
+
+    const subqueryQuery = createLiveQueryCollection((q) => {
+      // Build subquery with filters
+      const prepaidOrderQ = q
+        .from({ prepaidOrder: ordersCollection })
+        .where(({ prepaidOrder }) => gte(prepaidOrder.scheduled_at, today))
+        .where(({ prepaidOrder }) => eq(prepaidOrder.status, `queued`))
+
+      // Use subquery in main query
+      return q
+        .from({ charge: chargesCollection })
+        .fullJoin({ prepaidOrder: prepaidOrderQ }, ({ charge, prepaidOrder }) =>
+          eq(charge.address_id, prepaidOrder.address_id),
+        )
+    })
+
+    await subqueryQuery.preload()
+
+    // Verify loadSubset was called for the orders collection
+    expect(loadSubsetCalls.length).toBeGreaterThan(0)
+
+    // Verify the last call (or any call) has the where clause
+    const lastCall = loadSubsetCalls[loadSubsetCalls.length - 1]
+    expect(lastCall).toBeDefined()
+    expect(lastCall!.where).toBeDefined()
+
+    const expectedWhereClause = and(
+      gte(new PropRef([`scheduled_at`]), new Value(today)),
+      eq(new PropRef([`status`]), new Value(`queued`)),
+    )
+
+    expect(lastCall!.where).toEqual(expectedWhereClause)
+  })
+
+  it(`should call loadSubset with orderBy clause for direct query`, async () => {
+    const { collection: ordersCollection, loadSubsetCalls } =
+      createOrdersCollectionWithTracking()
+
+    const directQuery = createLiveQueryCollection((q) =>
+      q
+        .from({ order: ordersCollection })
+        .orderBy(({ order }) => order.scheduled_at, `desc`)
+        .limit(2),
+    )
+
+    await directQuery.preload()
+
+    // Verify loadSubset was called
+    expect(loadSubsetCalls.length).toBeGreaterThan(0)
+
+    // Verify the last call has the orderBy clause and limit
+    const lastCall = loadSubsetCalls[loadSubsetCalls.length - 1]
+    expect(lastCall).toBeDefined()
+    expect(lastCall!.orderBy).toBeDefined()
+    expect(lastCall!.limit).toBe(2)
+
+    const expectedOrderBy: OrderBy = [
+      {
+        expression: new PropRef([`scheduled_at`]),
+        compareOptions: { direction: `desc`, nulls: `first` },
+      },
+    ]
+
+    expect(lastCall!.orderBy).toEqual(expectedOrderBy)
+  })
+
+  it(`should call loadSubset with orderBy clause for subquery`, async () => {
+    const { collection: ordersCollection, loadSubsetCalls } =
+      createOrdersCollectionWithTracking()
+
+    const subqueryQuery = createLiveQueryCollection((q) => {
+      // Build subquery with orderBy and limit
+      const prepaidOrderQ = q
+        .from({ prepaidOrder: ordersCollection })
+        .orderBy(({ prepaidOrder }) => prepaidOrder.scheduled_at, `desc`)
+        .limit(2)
+
+      // Use subquery in main query
+      return q
+        .from({ charge: chargesCollection })
+        .fullJoin({ prepaidOrder: prepaidOrderQ }, ({ charge, prepaidOrder }) =>
+          eq(charge.address_id, prepaidOrder.address_id),
+        )
+    })
+
+    await subqueryQuery.preload()
+
+    // Verify loadSubset was called for the orders collection
+    expect(loadSubsetCalls.length).toBeGreaterThan(0)
+
+    // Verify the last call has the orderBy clause and limit
+    const lastCall = loadSubsetCalls[loadSubsetCalls.length - 1]
+    expect(lastCall).toBeDefined()
+    expect(lastCall!.orderBy).toBeDefined()
+    expect(lastCall!.limit).toBe(2)
+
+    const expectedOrderBy: OrderBy = [
+      {
+        expression: new PropRef([`scheduled_at`]),
+        compareOptions: { direction: `desc`, nulls: `first` },
+      },
+    ]
+
+    expect(lastCall!.orderBy).toEqual(expectedOrderBy)
+  })
+})
diff --git a/packages/db/tests/query/nested-props.test-d.ts b/packages/db/tests/query/nested-props.test-d.ts
index 801b099c1..6fbe2d56c 100644
--- a/packages/db/tests/query/nested-props.test-d.ts
+++ b/packages/db/tests/query/nested-props.test-d.ts
@@ -1,13 +1,13 @@
-import { describe, expectTypeOf, test } from "vitest"
+import { describe, expectTypeOf, test } from 'vitest'
 import {
   and,
   createLiveQueryCollection,
   eq,
   gt,
   or,
-} from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+} from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Complex nested type for testing with optional properties
 type Person = {
@@ -69,7 +69,7 @@ function createPersonsCollection() {
       id: `test-persons`,
       getKey: (person) => person.id,
       initialData: samplePersons,
-    })
+    }),
   )
 }
 
@@ -149,9 +149,9 @@ describe(`Nested Properties Types`, () => {
               gt(persons.profile?.score, 90),
               and(
                 gt(persons.profile?.stats.tasksCompleted, 100),
-                gt(persons.profile?.stats.rating, 4.5)
-              )
-            )
+                gt(persons.profile?.stats.rating, 4.5),
+              ),
+            ),
           )
           .select(({ persons }) => ({
             id: persons.id,
diff --git a/packages/db/tests/query/optimistic-delete-with-limit.test.ts b/packages/db/tests/query/optimistic-delete-with-limit.test.ts
new file mode 100644
index 000000000..2eec67d7b
--- /dev/null
+++ b/packages/db/tests/query/optimistic-delete-with-limit.test.ts
@@ -0,0 +1,596 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+import { createLiveQueryCollection } from '../../src/query/live-query-collection.js'
+import { like } from '../../src/query/builder/functions.js'
+import type { ChangeMessage } from '../../src/types.js'
+import type { Collection } from '../../src/collection/index.js'
+
+type Item = {
+  id: string
+  value: number
+  name: string
+}
+
+const initialData: Array<Item> = [
+  { id: `1`, value: 100, name: `Item A` },
+  { id: `2`, value: 90, name: `Item B` },
+  { id: `3`, value: 80, name: `Item C` },
+  { id: `4`, value: 70, name: `Item D` },
+  { id: `5`, value: 60, name: `Item E` },
+]
+
+describe(`Optimistic delete with limit`, () => {
+  let sourceCollection: Collection<Item>
+
+  beforeEach(async () => {
+    sourceCollection = createCollection(
+      mockSyncCollectionOptions({
+        id: `items`,
+        getKey: (item: Item) => item.id,
+        initialData,
+      }),
+    )
+
+    // Wait for the collection to be ready
+    await sourceCollection.preload()
+  })
+
+  it(`should emit delete event with limit`, async () => {
+    // Create a live query with orderBy and limit (matching the user's pattern)
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(3)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+          name: items.name,
+        })),
+    )
+
+    // Wait for the live query collection to be ready
+    await liveQueryCollection.preload()
+
+    // Check initial results
+    const initialResults = Array.from(liveQueryCollection.values())
+    expect(initialResults).toHaveLength(3)
+    expect(initialResults.map((r) => r.id)).toEqual([`1`, `2`, `3`])
+
+    // Subscribe to changes on the live query collection
+    const changeCallback = vi.fn()
+    const subscription = liveQueryCollection.subscribeChanges(changeCallback, {
+      includeInitialState: false,
+    })
+
+    // Clear any initial calls from subscription setup
+    changeCallback.mockClear()
+
+    // Optimistically delete item 2 (which is in the visible top 3)
+    sourceCollection.delete(`2`)
+
+    // Wait for microtasks to process
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // The callback should have been called with the delete event
+    expect(changeCallback).toHaveBeenCalled()
+
+    // Get the changes from all calls
+    const allChanges = changeCallback.mock.calls.flatMap((call) => call[0])
+    console.log(
+      `All changes (with limit):`,
+      JSON.stringify(allChanges, null, 2),
+    )
+
+    // Should have a delete for item 2
+    const deleteEvents = allChanges.filter(
+      (c: ChangeMessage<Item>) => c.type === `delete`,
+    )
+    expect(deleteEvents.length).toBeGreaterThan(0)
+    expect(deleteEvents.some((e: ChangeMessage<Item>) => e.key === `2`)).toBe(
+      true,
+    )
+
+    subscription.unsubscribe()
+  })
+
+  it(`should emit delete event without limit (baseline)`, async () => {
+    // Create a live query WITHOUT limit (for comparison)
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+          name: items.name,
+        })),
+    )
+
+    // Wait for the live query collection to be ready
+    await liveQueryCollection.preload()
+
+    // Check initial results
+    const initialResults = Array.from(liveQueryCollection.values())
+    expect(initialResults).toHaveLength(5)
+
+    // Subscribe to changes on the live query collection
+    const changeCallback = vi.fn()
+    const subscription = liveQueryCollection.subscribeChanges(changeCallback, {
+      includeInitialState: false,
+    })
+
+    // Clear any initial calls from subscription setup
+    changeCallback.mockClear()
+
+    // Optimistically delete item 2
+    sourceCollection.delete(`2`)
+
+    // Wait for microtasks to process
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // The callback should have been called with the delete event
+    expect(changeCallback).toHaveBeenCalled()
+
+    // Get the changes from all calls
+    const allChanges = changeCallback.mock.calls.flatMap((call) => call[0])
+    console.log(
+      `All changes (without limit):`,
+      JSON.stringify(allChanges, null, 2),
+    )
+
+    // Should have a delete for item 2
+    const deleteEvents = allChanges.filter(
+      (c: ChangeMessage<Item>) => c.type === `delete`,
+    )
+    expect(deleteEvents.length).toBeGreaterThan(0)
+    expect(deleteEvents.some((e: ChangeMessage<Item>) => e.key === `2`)).toBe(
+      true,
+    )
+
+    subscription.unsubscribe()
+  })
+
+  it(`should emit delete event with limit and includeInitialState: true`, async () => {
+    // Create a live query with orderBy and limit (matching the user's exact pattern)
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(3)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+          name: items.name,
+        })),
+    )
+
+    // Wait for the live query collection to be ready
+    await liveQueryCollection.preload()
+
+    // Check initial results
+    const initialResults = Array.from(liveQueryCollection.values())
+    expect(initialResults).toHaveLength(3)
+    expect(initialResults.map((r) => r.id)).toEqual([`1`, `2`, `3`])
+
+    // Subscribe to changes on the live query collection with includeInitialState: true
+    // This is what the user is doing
+    const changeCallback = vi.fn()
+    const subscription = liveQueryCollection.subscribeChanges(changeCallback, {
+      includeInitialState: true,
+    })
+
+    // Wait for initial state to be sent
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // Clear initial state calls
+    changeCallback.mockClear()
+
+    // Optimistically delete item 2 (which is in the visible top 3)
+    sourceCollection.delete(`2`)
+
+    // Wait for microtasks to process
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // The callback should have been called with the delete event
+    expect(changeCallback).toHaveBeenCalled()
+
+    // Get the changes from all calls
+    const allChanges = changeCallback.mock.calls.flatMap((call) => call[0])
+    console.log(
+      `All changes (with limit, includeInitialState: true):`,
+      JSON.stringify(allChanges, null, 2),
+    )
+
+    // Should have a delete for item 2
+    const deleteEvents = allChanges.filter(
+      (c: ChangeMessage<Item>) => c.type === `delete`,
+    )
+    expect(deleteEvents.length).toBeGreaterThan(0)
+    expect(deleteEvents.some((e: ChangeMessage<Item>) => e.key === `2`)).toBe(
+      true,
+    )
+
+    subscription.unsubscribe()
+  })
+
+  it(`should emit delete event with limit and offset`, async () => {
+    // Create a live query with orderBy, limit AND offset (matching the user's exact pattern)
+    const pageSize = 2
+    const pageIndex = 0
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(pageSize)
+        .offset(pageIndex * pageSize)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+          name: items.name,
+        })),
+    )
+
+    // Wait for the live query collection to be ready
+    await liveQueryCollection.preload()
+
+    // Check initial results - should be items 1 and 2 (highest values)
+    const initialResults = Array.from(liveQueryCollection.values())
+    expect(initialResults).toHaveLength(2)
+    expect(initialResults.map((r) => r.id)).toEqual([`1`, `2`])
+
+    // Subscribe to changes with includeInitialState: true (same as user)
+    const changeCallback = vi.fn()
+    const subscription = liveQueryCollection.subscribeChanges(changeCallback, {
+      includeInitialState: true,
+    })
+
+    // Wait for initial state to be sent
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // Clear initial state calls
+    changeCallback.mockClear()
+
+    // Delete item 2 (which is in the visible page)
+    sourceCollection.delete(`2`)
+
+    // Wait for microtasks to process
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // The callback should have been called with the delete event
+    console.log(
+      `All changes (with limit+offset, includeInitialState: true):`,
+      JSON.stringify(
+        changeCallback.mock.calls.flatMap((call) => call[0]),
+        null,
+        2,
+      ),
+    )
+    expect(changeCallback).toHaveBeenCalled()
+
+    // Get the changes from all calls
+    const allChanges = changeCallback.mock.calls.flatMap((call) => call[0])
+
+    // Should have a delete for item 2
+    const deleteEvents = allChanges.filter(
+      (c: ChangeMessage<Item>) => c.type === `delete`,
+    )
+    expect(deleteEvents.length).toBeGreaterThan(0)
+    expect(deleteEvents.some((e: ChangeMessage<Item>) => e.key === `2`)).toBe(
+      true,
+    )
+
+    subscription.unsubscribe()
+  })
+
+  it(`should emit delete event with where clause, limit and offset (matching user's exact pattern)`, async () => {
+    // Create a live query that matches the user's pattern:
+    // query.where(...).orderBy(...).limit(pageSize).offset(pageIndex * pageSize)
+    const pageSize = 2
+    const pageIndex = 0
+    const search = `Item` // Simulating their search filter
+
+    const liveQueryCollection = createLiveQueryCollection((q) => {
+      let query = q.from({ items: sourceCollection })
+      // Add a where clause like the user does
+      query = query.where(({ items }) => like(items.name, `%${search}%`))
+      return query
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(pageSize)
+        .offset(pageIndex * pageSize)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+          name: items.name,
+        }))
+    })
+
+    // Wait for the live query collection to be ready
+    await liveQueryCollection.preload()
+
+    // Check initial results - should be items 1 and 2 (highest values matching search)
+    const initialResults = Array.from(liveQueryCollection.values())
+    console.log(
+      `Initial results (where + limit + offset):`,
+      JSON.stringify(initialResults, null, 2),
+    )
+    expect(initialResults).toHaveLength(2)
+    expect(initialResults.map((r) => r.id)).toEqual([`1`, `2`])
+
+    // Subscribe to changes with includeInitialState: true (same as user)
+    const changeCallback = vi.fn()
+    const subscription = liveQueryCollection.subscribeChanges(changeCallback, {
+      includeInitialState: true,
+    })
+
+    // Wait for initial state to be sent
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // Clear initial state calls
+    changeCallback.mockClear()
+
+    // Delete item 2 (which is in the visible page)
+    sourceCollection.delete(`2`)
+
+    // Wait for microtasks to process
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // The callback should have been called with the delete event
+    console.log(
+      `All changes (where + limit + offset, includeInitialState: true):`,
+      JSON.stringify(
+        changeCallback.mock.calls.flatMap((call) => call[0]),
+        null,
+        2,
+      ),
+    )
+    expect(changeCallback).toHaveBeenCalled()
+
+    // Get the changes from all calls
+    const allChanges = changeCallback.mock.calls.flatMap((call) => call[0])
+
+    // Should have a delete for item 2
+    const deleteEvents = allChanges.filter(
+      (c: ChangeMessage<Item>) => c.type === `delete`,
+    )
+    expect(deleteEvents.length).toBeGreaterThan(0)
+    expect(deleteEvents.some((e: ChangeMessage<Item>) => e.key === `2`)).toBe(
+      true,
+    )
+
+    subscription.unsubscribe()
+  })
+
+  it(`should emit delete and update when deleting from different page (page 1 delete while viewing page 2)`, async () => {
+    // This test captures the scenario from Marius's environment:
+    // - Viewing page 2 (items 3 and 4 with offset=2, limit=2)
+    // - Delete an item from page 1 (item 2)
+    // - The live query should update because items shift:
+    //   - After delete, sorted order is: 1, 3, 4, 5
+    //   - Page 2 (offset=2, limit=2) should now show items 4 and 5
+    //   - So: item 3 should be deleted from result, item 5 should be inserted
+
+    const pageSize = 2
+    const pageIndex = 1 // page 2 (0-indexed)
+
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(pageSize)
+        .offset(pageIndex * pageSize)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+          name: items.name,
+        })),
+    )
+
+    // Wait for the live query collection to be ready
+    await liveQueryCollection.preload()
+
+    // Check initial results - page 2 should show items 3 and 4 (offset 2, limit 2)
+    // Sorted by value desc: 1 (100), 2 (90), 3 (80), 4 (70), 5 (60)
+    // Page 2 = offset 2 = items 3 and 4
+    const initialResults = Array.from(liveQueryCollection.values())
+    console.log(
+      `Initial results (page 2):`,
+      JSON.stringify(initialResults, null, 2),
+    )
+    expect(initialResults).toHaveLength(2)
+    expect(initialResults.map((r) => r.id)).toEqual([`3`, `4`])
+
+    // Subscribe to changes with includeInitialState: true
+    const changeCallback = vi.fn()
+    const subscription = liveQueryCollection.subscribeChanges(changeCallback, {
+      includeInitialState: true,
+    })
+
+    // Wait for initial state to be sent
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // Clear initial state calls
+    changeCallback.mockClear()
+
+    // Delete item 2 (which is on page 1, NOT in current view)
+    console.log(`Deleting item 2 (on page 1, not visible on page 2)...`)
+    sourceCollection.delete(`2`)
+
+    // Wait for microtasks to process
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    // After deleting item 2:
+    // - Sorted order becomes: 1 (100), 3 (80), 4 (70), 5 (60)
+    // - Page 2 (offset 2, limit 2) should now show items 4 and 5
+    // - So: item 3 should be deleted from result, item 5 should be inserted
+
+    // Check the state after delete
+    const resultsAfterDelete = Array.from(liveQueryCollection.values())
+    console.log(
+      `Results after delete:`,
+      JSON.stringify(resultsAfterDelete, null, 2),
+    )
+
+    // The live query collection should now show items 4 and 5
+    expect(resultsAfterDelete).toHaveLength(2)
+    expect(resultsAfterDelete.map((r) => r.id)).toEqual([`4`, `5`])
+
+    // Check that we got the expected change events
+    console.log(
+      `All changes (page 2 after deleting from page 1):`,
+      JSON.stringify(
+        changeCallback.mock.calls.flatMap((call) => call[0]),
+        null,
+        2,
+      ),
+    )
+
+    // We should have received change events (delete for item 3, insert for item 5)
+    expect(changeCallback).toHaveBeenCalled()
+
+    const allChanges = changeCallback.mock.calls.flatMap((call) => call[0])
+
+    // Should have a delete for item 3 (shifted out of page 2)
+    const deleteEvents = allChanges.filter(
+      (c: ChangeMessage<Item>) => c.type === `delete`,
+    )
+    expect(deleteEvents.some((e: ChangeMessage<Item>) => e.key === `3`)).toBe(
+      true,
+    )
+
+    // Should have an insert for item 5 (shifted into page 2)
+    const insertEvents = allChanges.filter(
+      (c: ChangeMessage<Item>) => c.type === `insert`,
+    )
+    expect(insertEvents.some((e: ChangeMessage<Item>) => e.key === `5`)).toBe(
+      true,
+    )
+
+    subscription.unsubscribe()
+  })
+
+  it(`should NOT update when deleting item beyond TopK window (no-op case)`, async () => {
+    // Test scenario: delete an item that's AFTER the TopK window
+    // - Page 1: items 1 and 2 (offset=0, limit=2)
+    // - Delete item 5 (which is on page 3)
+    // - Page 1 should NOT change (items 1 and 2 are still there)
+
+    const pageSize = 2
+    const pageIndex = 0 // page 1
+
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(pageSize)
+        .offset(pageIndex * pageSize)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+          name: items.name,
+        })),
+    )
+
+    // Wait for the live query collection to be ready
+    await liveQueryCollection.preload()
+
+    // Check initial results - page 1 should show items 1 and 2
+    const initialResults = Array.from(liveQueryCollection.values())
+    console.log(
+      `Initial results (page 1 for no-op test):`,
+      JSON.stringify(initialResults, null, 2),
+    )
+    expect(initialResults).toHaveLength(2)
+    expect(initialResults.map((r) => r.id)).toEqual([`1`, `2`])
+
+    // Subscribe to changes
+    const changeCallback = vi.fn()
+    const subscription = liveQueryCollection.subscribeChanges(changeCallback, {
+      includeInitialState: true,
+    })
+
+    // Wait for initial state to be sent
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // Clear initial state calls
+    changeCallback.mockClear()
+
+    // Delete item 5 (which is on page 3, beyond the TopK window)
+    console.log(`Deleting item 5 (on page 3, beyond TopK window)...`)
+    sourceCollection.delete(`5`)
+
+    // Wait for microtasks to process
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    // After deleting item 5:
+    // - Sorted order becomes: 1 (100), 2 (90), 3 (80), 4 (70)
+    // - Page 1 (offset 0, limit 2) still shows items 1 and 2
+    // - No change to page 1
+
+    // Check the state after delete
+    const resultsAfterDelete = Array.from(liveQueryCollection.values())
+    console.log(
+      `Results after delete (no-op):`,
+      JSON.stringify(resultsAfterDelete, null, 2),
+    )
+
+    // The live query collection should still show items 1 and 2
+    expect(resultsAfterDelete).toHaveLength(2)
+    expect(resultsAfterDelete.map((r) => r.id)).toEqual([`1`, `2`])
+
+    // Check that we did NOT receive any change events
+    console.log(
+      `Change events (should be empty):`,
+      JSON.stringify(
+        changeCallback.mock.calls.flatMap((call) => call[0]),
+        null,
+        2,
+      ),
+    )
+
+    // No changes expected since item 5 is outside the window
+    const allChanges = changeCallback.mock.calls.flatMap((call) => call[0])
+    expect(allChanges).toHaveLength(0)
+
+    subscription.unsubscribe()
+  })
+
+  it(`should update state correctly after delete with limit`, async () => {
+    // Create a live query with orderBy and limit
+    const liveQueryCollection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .orderBy(({ items }) => items.value, `desc`)
+        .limit(3)
+        .select(({ items }) => ({
+          id: items.id,
+          value: items.value,
+          name: items.name,
+        })),
+    )
+
+    // Wait for the live query collection to be ready
+    await liveQueryCollection.preload()
+
+    // Check initial results
+    let results = Array.from(liveQueryCollection.values())
+    expect(results.map((r) => r.id)).toEqual([`1`, `2`, `3`])
+
+    // Subscribe to changes
+    liveQueryCollection.subscribeChanges(() => {}, {
+      includeInitialState: false,
+    })
+
+    // Optimistically delete item 2 (which is in the visible top 3)
+    sourceCollection.delete(`2`)
+
+    // Wait for microtasks to process
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    // Check that the state is updated
+    // Item 2 should be gone, and item 4 should move into the top 3
+    results = Array.from(liveQueryCollection.values())
+    expect(results.map((r) => r.id)).toEqual([`1`, `3`, `4`])
+  })
+})
diff --git a/packages/db/tests/query/optimizer.test.ts b/packages/db/tests/query/optimizer.test.ts
index 9e25bb2d4..77ff8cbed 100644
--- a/packages/db/tests/query/optimizer.test.ts
+++ b/packages/db/tests/query/optimizer.test.ts
@@ -1,5 +1,5 @@
-import { describe, expect, test } from "vitest"
-import { optimizeQuery } from "../../src/query/optimizer.js"
+import { describe, expect, test } from 'vitest'
+import { optimizeQuery } from '../../src/query/optimizer.js'
 import {
   Aggregate,
   CollectionRef,
@@ -7,8 +7,8 @@ import {
   PropRef,
   QueryRef,
   Value,
-} from "../../src/query/ir.js"
-import type { QueryIR } from "../../src/query/ir.js"
+} from '../../src/query/ir.js'
+import type { QueryIR } from '../../src/query/ir.js'
 
 // Mock collection for testing
 const mockCollection = {
@@ -69,16 +69,41 @@ describe(`Query Optimizer`, () => {
       expect(optimized).toEqual(query)
     })
 
-    test(`should skip optimization for queries without joins`, () => {
+    test(`should skip optimization for queries without joins and single WHERE clause`, () => {
       const query: QueryIR = {
         from: new CollectionRef(mockCollection, `u`),
         where: [createEq(createPropRef(`u`, `department_id`), createValue(1))],
       }
 
       const { optimizedQuery: optimized } = optimizeQuery(query)
-      // Query should remain unchanged since there are no joins to optimize
+      // Query should remain unchanged since there is only one WHERE clause
       expect(optimized).toEqual(query)
     })
+
+    test(`should combine multiple WHERE clauses for queries without joins`, () => {
+      const query: QueryIR = {
+        from: new CollectionRef(mockCollection, `u`),
+        where: [
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
+          createGt(createPropRef(`u`, `salary`), createValue(50000)),
+          createEq(createPropRef(`u`, `active`), createValue(true)),
+        ],
+      }
+
+      const { optimizedQuery: optimized } = optimizeQuery(query)
+
+      // The WHERE clauses should be combined into a single AND expression
+      expect(optimized.where).toHaveLength(1)
+      expect(optimized.where![0]).toMatchObject({
+        type: `func`,
+        name: `and`,
+        args: [
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
+          createGt(createPropRef(`u`, `salary`), createValue(50000)),
+          createEq(createPropRef(`u`, `active`), createValue(true)),
+        ],
+      })
+    })
   })
 
   describe(`Single Source Optimization with Joins`, () => {
@@ -106,7 +131,7 @@ describe(`Query Optimizer`, () => {
       if (optimized.from.type === `queryRef`) {
         expect(optimized.from.query.where).toHaveLength(1)
         expect(optimized.from.query.where![0]).toEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
         )
       }
     })
@@ -173,7 +198,7 @@ describe(`Query Optimizer`, () => {
       if (optimized.from.type === `queryRef`) {
         expect(optimized.from.query.where).toHaveLength(1)
         expect(optimized.from.query.where![0]).toEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
         )
       }
 
@@ -185,7 +210,7 @@ describe(`Query Optimizer`, () => {
           expect(joinClause.from.query.where).toHaveLength(1)
           if (joinClause.from.query.where) {
             expect(joinClause.from.query.where[0]).toEqual(
-              createGt(createPropRef(`p`, `views`), createValue(100))
+              createGt(createPropRef(`p`, `views`), createValue(100)),
             )
           }
         }
@@ -214,7 +239,7 @@ describe(`Query Optimizer`, () => {
       // The main query should have the multi-source where clause
       expect(optimized.where).toHaveLength(1)
       expect(optimized.where![0]).toEqual(
-        createEq(createPropRef(`u`, `id`), createPropRef(`p`, `user_id`))
+        createEq(createPropRef(`u`, `id`), createPropRef(`p`, `user_id`)),
       )
 
       // The from should be a QueryRef with the single-source where clause
@@ -222,7 +247,7 @@ describe(`Query Optimizer`, () => {
       if (optimized.from.type === `queryRef`) {
         expect(optimized.from.query.where).toHaveLength(1)
         expect(optimized.from.query.where![0]).toEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
         )
       }
     })
@@ -243,7 +268,7 @@ describe(`Query Optimizer`, () => {
         where: [
           createAnd(
             createEq(createPropRef(`u`, `department_id`), createValue(1)),
-            createGt(createPropRef(`u`, `id`), createValue(100))
+            createGt(createPropRef(`u`, `id`), createValue(100)),
           ),
         ],
       }
@@ -278,7 +303,7 @@ describe(`Query Optimizer`, () => {
         where: [
           createOr(
             createEq(createPropRef(`u`, `department_id`), createValue(1)),
-            createEq(createPropRef(`u`, `department_id`), createValue(2))
+            createEq(createPropRef(`u`, `department_id`), createValue(2)),
           ),
         ],
       }
@@ -314,9 +339,9 @@ describe(`Query Optimizer`, () => {
           createAnd(
             createAnd(
               createEq(createPropRef(`u`, `department_id`), createValue(1)),
-              createGt(createPropRef(`u`, `id`), createValue(100))
+              createGt(createPropRef(`u`, `id`), createValue(100)),
             ),
-            createLt(createPropRef(`u`, `age`), createValue(65))
+            createLt(createPropRef(`u`, `age`), createValue(65)),
           ),
         ],
       }
@@ -360,7 +385,7 @@ describe(`Query Optimizer`, () => {
         having: [
           createGt(
             createAgg(`count`, createPropRef(`p`, `id`)),
-            createValue(5)
+            createValue(5),
           ),
         ],
         orderBy: [
@@ -423,7 +448,7 @@ describe(`Query Optimizer`, () => {
       if (optimized.from.type === `queryRef`) {
         expect(optimized.from.query.where).toHaveLength(1)
         expect(optimized.from.query.where![0]).toEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
         )
       }
     })
@@ -442,7 +467,7 @@ describe(`Query Optimizer`, () => {
         where: [
           createGt(
             createAgg(`count`, createPropRef(`p`, `id`)),
-            createValue(5)
+            createValue(5),
           ),
         ],
       }
@@ -460,8 +485,8 @@ describe(`Query Optimizer`, () => {
           expect(joinClause.from.query.where![0]).toEqual(
             createGt(
               createAgg(`count`, createPropRef(`p`, `id`)),
-              createValue(5)
-            )
+              createValue(5),
+            ),
           )
         }
       }
@@ -482,7 +507,7 @@ describe(`Query Optimizer`, () => {
           createEq(createPropRef(`u`, `id`), createPropRef(`p`, `user_id`)),
           createGt(
             createPropRef(`u`, `created_at`),
-            createPropRef(`p`, `created_at`)
+            createPropRef(`p`, `created_at`),
           ),
         ],
       }
@@ -518,16 +543,19 @@ describe(`Query Optimizer`, () => {
 
       const { optimizedQuery: optimized } = optimizeQuery(query)
 
-      // The existing subquery should have both WHERE clauses
+      // The existing subquery should have WHERE clauses combined for performance
       expect(optimized.from.type).toBe(`queryRef`)
       if (optimized.from.type === `queryRef`) {
-        expect(optimized.from.query.where).toHaveLength(2)
-        expect(optimized.from.query.where![0]).toEqual(
-          createGt(createPropRef(`u`, `id`), createValue(50))
-        )
-        expect(optimized.from.query.where![1]).toEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
-        )
+        // After optimization, the WHERE clauses are combined into a single AND expression
+        expect(optimized.from.query.where).toHaveLength(1)
+        expect(optimized.from.query.where![0]).toMatchObject({
+          type: `func`,
+          name: `and`,
+          args: [
+            createGt(createPropRef(`u`, `id`), createValue(50)),
+            createEq(createPropRef(`u`, `department_id`), createValue(1)),
+          ],
+        })
       }
     })
 
@@ -538,7 +566,7 @@ describe(`Query Optimizer`, () => {
             from: new CollectionRef(mockCollection, `u`),
             where: [createGt(createPropRef(`u`, `id`), createValue(10))],
           },
-          `u`
+          `u`,
         ),
         where: [createLt(createPropRef(`u`, `age`), createValue(50))],
       }
@@ -558,10 +586,11 @@ describe(`Query Optimizer`, () => {
 
       const { optimizedQuery: optimized } = optimizeQuery(query)
 
-      // The deeply nested structure should be preserved and new WHERE clause added
+      // The deeply nested structure should be preserved and WHERE clauses combined
       expect(optimized.from.type).toBe(`queryRef`)
       if (optimized.from.type === `queryRef`) {
-        expect(optimized.from.query.where).toHaveLength(2)
+        // WHERE clauses are combined for performance
+        expect(optimized.from.query.where).toHaveLength(1)
         expect(optimized.from.query.from.type).toBe(`queryRef`)
       }
     })
@@ -612,7 +641,7 @@ describe(`Query Optimizer`, () => {
       // Multi-source clause should remain in main query
       expect(optimized.where).toHaveLength(1)
       expect(optimized.where![0]).toEqual(
-        createEq(createPropRef(`u`, `id`), createPropRef(`p`, `user_id`))
+        createEq(createPropRef(`u`, `id`), createPropRef(`p`, `user_id`)),
       )
 
       // Single-source clauses should be moved to subqueries
@@ -685,7 +714,7 @@ describe(`Query Optimizer`, () => {
       if (optimized.from.type === `queryRef`) {
         expect(optimized.from.query.where).toHaveLength(1)
         expect(optimized.from.query.where![0]).toEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
         )
       }
     })
@@ -716,7 +745,7 @@ describe(`Query Optimizer`, () => {
       if (optimized.from.type === `queryRef`) {
         expect(optimized.from.query.where).toHaveLength(1)
         expect(optimized.from.query.where![0]).toEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
         )
       }
     })
@@ -731,7 +760,7 @@ describe(`Query Optimizer`, () => {
             from: new CollectionRef(mockCollection, `u`),
             where: [createGt(createPropRef(`u`, `id`), createValue(10))],
           },
-          `u`
+          `u`,
         ),
         join: [
           {
@@ -746,18 +775,20 @@ describe(`Query Optimizer`, () => {
 
       const { optimizedQuery: optimized } = optimizeQuery(nestedQuery)
 
-      // The new WHERE clause should be pushed to the nested level
+      // The new WHERE clause should be pushed to the nested level and combined
       expect(optimized.where).toEqual([])
       expect(optimized.from.type).toBe(`queryRef`)
       if (optimized.from.type === `queryRef`) {
-        // Should have both WHERE clauses at the inner level
-        expect(optimized.from.query.where).toHaveLength(2)
-        expect(optimized.from.query.where).toContainEqual(
-          createGt(createPropRef(`u`, `id`), createValue(10))
-        )
-        expect(optimized.from.query.where).toContainEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
-        )
+        // WHERE clauses are combined into a single AND expression for performance
+        expect(optimized.from.query.where).toHaveLength(1)
+        expect(optimized.from.query.where![0]).toMatchObject({
+          type: `func`,
+          name: `and`,
+          args: [
+            createGt(createPropRef(`u`, `id`), createValue(10)),
+            createEq(createPropRef(`u`, `department_id`), createValue(1)),
+          ],
+        })
       }
     })
 
@@ -771,11 +802,11 @@ describe(`Query Optimizer`, () => {
                 from: new CollectionRef(mockCollection, `u`),
                 where: [createGt(createPropRef(`u`, `id`), createValue(10))],
               },
-              `u`
+              `u`,
             ),
             where: [createLt(createPropRef(`u`, `age`), createValue(50))],
           },
-          `u`
+          `u`,
         ),
         join: [
           {
@@ -790,19 +821,24 @@ describe(`Query Optimizer`, () => {
 
       const { optimizedQuery: optimized } = optimizeQuery(deeplyNestedQuery)
 
-      // Should at least push the top-level WHERE clause down one level
+      // Should at least push the top-level WHERE clause down one level and combine them
       expect(optimized.where).toEqual([])
       expect(optimized.from.type).toBe(`queryRef`)
       if (optimized.from.type === `queryRef`) {
         const innerQuery = optimized.from.query
-        // The department_id clause should be pushed to this level
-        expect(innerQuery.where).toContainEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
+        // The WHERE clauses should be combined into a single AND expression
+        expect(innerQuery.where).toHaveLength(1)
+        expect(innerQuery.where![0]).toMatchObject({
+          type: `func`,
+          name: `and`,
+        })
+        // Verify both conditions are in the combined expression
+        const combinedWhere = innerQuery.where![0] as any
+        expect(combinedWhere.args).toContainEqual(
+          createLt(createPropRef(`u`, `age`), createValue(50)),
         )
-
-        // The age clause should remain here or be pushed deeper
-        expect(innerQuery.where).toContainEqual(
-          createLt(createPropRef(`u`, `age`), createValue(50))
+        expect(combinedWhere.args).toContainEqual(
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
         )
       }
     })
@@ -816,10 +852,10 @@ describe(`Query Optimizer`, () => {
               {
                 from: new CollectionRef(mockCollection, `u`),
               },
-              `u`
+              `u`,
             ),
           },
-          `u`
+          `u`,
         ),
         join: [
           {
@@ -833,7 +869,7 @@ describe(`Query Optimizer`, () => {
       }
 
       const { optimizedQuery: optimized } = optimizeQuery(
-        queryWithRedundantSubqueries
+        queryWithRedundantSubqueries,
       )
 
       // Redundant nested subqueries should be removed, leaving a direct reference to the collection
@@ -842,7 +878,7 @@ describe(`Query Optimizer`, () => {
         expect(optimized.from.query.from.type).toBe(`collectionRef`)
         expect(optimized.from.query.where).toHaveLength(1)
         expect(optimized.from.query.where![0]).toEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
         )
       }
     })
@@ -854,7 +890,7 @@ describe(`Query Optimizer`, () => {
             from: new CollectionRef(mockCollection, `u`),
             where: [createGt(createPropRef(`u`, `age`), createValue(25))],
           },
-          `u`
+          `u`,
         ),
         join: [
           {
@@ -863,7 +899,7 @@ describe(`Query Optimizer`, () => {
                 from: new CollectionRef(mockCollection, `p`),
                 where: [createGt(createPropRef(`p`, `views`), createValue(50))],
               },
-              `p`
+              `p`,
             ),
             type: `inner`,
             left: createPropRef(`u`, `id`),
@@ -882,19 +918,22 @@ describe(`Query Optimizer`, () => {
       // Multi-source clause should remain in main query
       expect(optimized.where).toHaveLength(1)
       expect(optimized.where![0]).toEqual(
-        createEq(createPropRef(`u`, `id`), createPropRef(`p`, `author_id`))
+        createEq(createPropRef(`u`, `id`), createPropRef(`p`, `author_id`)),
       )
 
-      // Single-source clauses should be pushed to their respective subqueries
+      // Single-source clauses should be pushed to their respective subqueries and combined
       expect(optimized.from.type).toBe(`queryRef`)
       if (optimized.from.type === `queryRef`) {
-        expect(optimized.from.query.where).toHaveLength(2) // Original + new clause
-        expect(optimized.from.query.where).toContainEqual(
-          createGt(createPropRef(`u`, `age`), createValue(25))
-        )
-        expect(optimized.from.query.where).toContainEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
-        )
+        // WHERE clauses are combined for performance
+        expect(optimized.from.query.where).toHaveLength(1)
+        expect(optimized.from.query.where![0]).toMatchObject({
+          type: `func`,
+          name: `and`,
+          args: [
+            createGt(createPropRef(`u`, `age`), createValue(25)),
+            createEq(createPropRef(`u`, `department_id`), createValue(1)),
+          ],
+        })
       }
 
       expect(optimized.join).toHaveLength(1)
@@ -902,13 +941,16 @@ describe(`Query Optimizer`, () => {
         const joinClause = optimized.join[0]!
         expect(joinClause.from.type).toBe(`queryRef`)
         if (joinClause.from.type === `queryRef`) {
-          expect(joinClause.from.query.where).toHaveLength(2) // Original + new clause
-          expect(joinClause.from.query.where).toContainEqual(
-            createGt(createPropRef(`p`, `views`), createValue(50))
-          )
-          expect(joinClause.from.query.where).toContainEqual(
-            createGt(createPropRef(`p`, `rating`), createValue(4))
-          )
+          // WHERE clauses are combined for performance
+          expect(joinClause.from.query.where).toHaveLength(1)
+          expect(joinClause.from.query.where![0]).toMatchObject({
+            type: `func`,
+            name: `and`,
+            args: [
+              createGt(createPropRef(`p`, `views`), createValue(50)),
+              createGt(createPropRef(`p`, `rating`), createValue(4)),
+            ],
+          })
         }
       }
     })
@@ -922,11 +964,11 @@ describe(`Query Optimizer`, () => {
                 from: new CollectionRef(mockCollection, `u`),
                 where: [createGt(createPropRef(`u`, `id`), createValue(10))],
               },
-              `u`
+              `u`,
             ),
             select: { name: createPropRef(`u`, `name`) }, // This makes the subquery non-redundant
           },
-          `u`
+          `u`,
         ),
         join: [
           {
@@ -940,7 +982,7 @@ describe(`Query Optimizer`, () => {
       }
 
       const { optimizedQuery: optimized } = optimizeQuery(
-        queryWithMeaningfulSubqueries
+        queryWithMeaningfulSubqueries,
       )
 
       // Should preserve the subquery with SELECT clause and push WHERE clause down at least one level
@@ -950,7 +992,7 @@ describe(`Query Optimizer`, () => {
         expect(optimized.from.query.select).toBeDefined()
         // The new WHERE clause should be pushed to this level or deeper
         expect(optimized.from.query.where).toContainEqual(
-          createEq(createPropRef(`u`, `department_id`), createValue(1))
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
         )
       }
     })
@@ -1018,7 +1060,7 @@ describe(`Query Optimizer`, () => {
             from: new CollectionRef(mockCollection, `u`),
             where: [createGt(createPropRef(`u`, `age`), createValue(18))],
           },
-          `u`
+          `u`,
         ),
         join: [
           {
@@ -1033,26 +1075,29 @@ describe(`Query Optimizer`, () => {
             createEq(createPropRef(`u`, `department_id`), createValue(1)),
             createOr(
               createGt(createPropRef(`u`, `salary`), createValue(50000)),
-              createEq(createPropRef(`u`, `role`), createValue(`manager`))
-            )
+              createEq(createPropRef(`u`, `role`), createValue(`manager`)),
+            ),
           ),
         ],
       }
 
       const { optimizedQuery: optimized } = optimizeQuery(complexQuery)
 
-      // AND clause should be split and single-source parts pushed down
+      // AND clause should be split and single-source parts pushed down, then combined for performance
       expect(optimized.where).toEqual([])
       expect(optimized.from.type).toBe(`queryRef`)
       if (optimized.from.type === `queryRef`) {
-        // Should contain the original condition plus the AND clause (which gets split)
-        expect(optimized.from.query.where).toContainEqual(
-          createGt(createPropRef(`u`, `age`), createValue(18))
+        // WHERE clauses should be combined into a single AND expression
+        expect(optimized.from.query.where).toHaveLength(1)
+        expect(optimized.from.query.where![0]).toMatchObject({
+          type: `func`,
+          name: `and`,
+        })
+        // Verify it contains the original condition and the new conditions
+        const combinedWhere = optimized.from.query.where![0] as any
+        expect(combinedWhere.args).toContainEqual(
+          createGt(createPropRef(`u`, `age`), createValue(18)),
         )
-
-        // Should have the AND clause pushed down (may be split into components)
-        const whereClausesLength = optimized.from.query.where?.length || 0
-        expect(whereClausesLength).toBeGreaterThan(1) // Should have at least the original + new conditions
       }
     })
   })
@@ -1082,11 +1127,11 @@ describe(`Query Optimizer`, () => {
         where: [
           createEq(
             createPropRef(`main_users`, `department_id`),
-            createValue(1)
+            createValue(1),
           ), // Should only affect main_users context
           createEq(
             createPropRef(`other_users`, `department_id`),
-            createValue(2)
+            createValue(2),
           ), // Should only affect other_users context
         ],
       }
@@ -1100,7 +1145,10 @@ describe(`Query Optimizer`, () => {
       expect(optimized.from.type).toBe(`queryRef`)
       if (optimized.from.type === `queryRef`) {
         expect(optimized.from.query.where).toContainEqual(
-          createEq(createPropRef(`main_users`, `department_id`), createValue(1))
+          createEq(
+            createPropRef(`main_users`, `department_id`),
+            createValue(1),
+          ),
         )
       }
 
@@ -1113,8 +1161,8 @@ describe(`Query Optimizer`, () => {
           expect(joinClause.from.query.where).toContainEqual(
             createEq(
               createPropRef(`other_users`, `department_id`),
-              createValue(2)
-            )
+              createValue(2),
+            ),
           )
         }
       }
@@ -1151,7 +1199,7 @@ describe(`Query Optimizer`, () => {
       // would change the aggregation results
       expect(optimized.where).toHaveLength(1)
       expect(optimized.where![0]).toEqual(
-        createGt(createPropRef(`stats`, `user_count`), createValue(5))
+        createGt(createPropRef(`stats`, `user_count`), createValue(5)),
       )
     })
 
@@ -1192,7 +1240,7 @@ describe(`Query Optimizer`, () => {
       // would change which users are in the "top 10"
       expect(optimized.where).toHaveLength(1)
       expect(optimized.where![0]).toEqual(
-        createEq(createPropRef(`top_users`, `department_id`), createValue(1))
+        createEq(createPropRef(`top_users`, `department_id`), createValue(1)),
       )
     })
 
@@ -1219,7 +1267,7 @@ describe(`Query Optimizer`, () => {
         where: [
           createEq(
             createPropRef(`filtered_users`, `department_id`),
-            createValue(1)
+            createValue(1),
           ), // Can be pushed down safely
         ],
       }
@@ -1233,8 +1281,8 @@ describe(`Query Optimizer`, () => {
         expect(optimized.from.query.where).toContainEqual(
           createEq(
             createPropRef(`filtered_users`, `department_id`),
-            createValue(1)
-          )
+            createValue(1),
+          ),
         )
       }
     })
@@ -1250,7 +1298,7 @@ describe(`Query Optimizer`, () => {
         having: [
           createGt(
             createAgg(`avg`, createPropRef(`u`, `salary`)),
-            createValue(50000)
+            createValue(50000),
           ),
         ],
       }
@@ -1268,7 +1316,7 @@ describe(`Query Optimizer`, () => {
         where: [
           createGt(
             createPropRef(`dept_stats`, `avg_salary`),
-            createValue(60000)
+            createValue(60000),
           ),
         ],
       }
@@ -1278,7 +1326,7 @@ describe(`Query Optimizer`, () => {
       // Should not optimize due to HAVING clause
       expect(optimized.where).toHaveLength(1)
       expect(optimized.where![0]).toEqual(
-        createGt(createPropRef(`dept_stats`, `avg_salary`), createValue(60000))
+        createGt(createPropRef(`dept_stats`, `avg_salary`), createValue(60000)),
       )
     })
 
@@ -1301,7 +1349,7 @@ describe(`Query Optimizer`, () => {
         where: [
           createEq(
             createPropRef(`computed_users`, `department_id`),
-            createValue(1)
+            createValue(1),
           ),
         ],
       }
@@ -1313,8 +1361,8 @@ describe(`Query Optimizer`, () => {
       expect(optimized.where![0]).toEqual(
         createEq(
           createPropRef(`computed_users`, `department_id`),
-          createValue(1)
-        )
+          createValue(1),
+        ),
       )
     })
 
@@ -1347,7 +1395,7 @@ describe(`Query Optimizer`, () => {
         where: [
           createEq(
             createPropRef(`sorted_users`, `department_id`),
-            createValue(1)
+            createValue(1),
           ),
         ],
       }
@@ -1361,8 +1409,8 @@ describe(`Query Optimizer`, () => {
         expect(optimized.from.query.where).toContainEqual(
           createEq(
             createPropRef(`sorted_users`, `department_id`),
-            createValue(1)
-          )
+            createValue(1),
+          ),
         )
       }
     })
@@ -1408,17 +1456,165 @@ describe(`Query Optimizer`, () => {
       // Only the unsafe clause should remain
       expect(optimized.where).toHaveLength(1)
       expect(optimized.where![0]).toEqual(
-        createGt(createPropRef(`dept_stats`, `user_count`), createValue(10))
+        createGt(createPropRef(`dept_stats`, `user_count`), createValue(10)),
       )
 
       // Safe subquery should be optimized
       expect(optimized.from.type).toBe(`queryRef`)
       if (optimized.from.type === `queryRef`) {
         expect(optimized.from.query.where).toContainEqual(
-          createEq(createPropRef(`users`, `department_id`), createValue(1))
+          createEq(createPropRef(`users`, `department_id`), createValue(1)),
         )
       }
     })
+
+    test(`should combine multiple remaining WHERE clauses after optimization`, () => {
+      // This test verifies that if multiple WHERE clauses remain after optimization
+      // (e.g., because some can't be pushed down), they are combined into a single clause
+      const subqueryWithAggregates: QueryIR = {
+        from: new CollectionRef(mockCollection, `u`),
+        select: {
+          department_id: createPropRef(`u`, `department_id`),
+          user_count: createAgg(`count`, createPropRef(`u`, `id`)),
+        },
+        groupBy: [createPropRef(`u`, `department_id`)],
+      }
+
+      const query: QueryIR = {
+        from: new QueryRef(subqueryWithAggregates, `stats`),
+        join: [
+          {
+            from: new CollectionRef(mockCollection, `p`),
+            type: `inner`,
+            left: createPropRef(`stats`, `department_id`),
+            right: createPropRef(`p`, `department_id`),
+          },
+        ],
+        where: [
+          createGt(createPropRef(`stats`, `user_count`), createValue(5)), // Can't push down - GROUP BY
+          createGt(createPropRef(`p`, `views`), createValue(100)), // Can push down
+          createEq(
+            createPropRef(`stats`, `department_id`),
+            createPropRef(`p`, `author_dept`),
+          ), // Multi-source
+        ],
+      }
+
+      const { optimizedQuery: optimized } = optimizeQuery(query)
+
+      // The posts clause should be pushed down
+      expect(optimized.join).toHaveLength(1)
+      if (optimized.join && optimized.join[0]) {
+        expect(optimized.join[0].from.type).toBe(`queryRef`)
+        if (optimized.join[0].from.type === `queryRef`) {
+          expect(optimized.join[0].from.query.where).toHaveLength(1)
+        }
+      }
+
+      // The stats clause and multi-source clause should remain BUT be combined into ONE
+      console.log(
+        `Remaining WHERE clauses: ${optimized.where?.length || 0}`,
+        JSON.stringify(optimized.where, null, 2),
+      )
+      expect(optimized.where).toBeDefined()
+      // This is the KEY assertion - all remaining clauses should be combined
+      // Currently this might FAIL if step 3 is missing
+      expect(optimized.where!.length).toBe(1)
+      expect(optimized.where![0]).toMatchObject({
+        type: `func`,
+        name: `and`,
+      })
+    })
+
+    test(`should flatten nested AND expressions when combining remaining clauses`, () => {
+      // This test verifies that if remaining WHERE clauses already contain AND expressions,
+      // they are flattened to avoid and(and(...), ...) nesting
+      const subqueryWithAggregates: QueryIR = {
+        from: new CollectionRef(mockCollection, `u`),
+        select: {
+          department_id: createPropRef(`u`, `department_id`),
+          user_count: createAgg(`count`, createPropRef(`u`, `id`)),
+        },
+        groupBy: [createPropRef(`u`, `department_id`)],
+      }
+
+      const query: QueryIR = {
+        from: new QueryRef(subqueryWithAggregates, `stats`),
+        join: [
+          {
+            from: new CollectionRef(mockCollection, `p`),
+            type: `inner`,
+            left: createPropRef(`stats`, `department_id`),
+            right: createPropRef(`p`, `department_id`),
+          },
+        ],
+        where: [
+          // This is an AND expression that can't be pushed down
+          createAnd(
+            createGt(createPropRef(`stats`, `user_count`), createValue(5)),
+            createEq(createPropRef(`stats`, `department_id`), createValue(1)),
+          ),
+          createGt(createPropRef(`p`, `views`), createValue(100)), // Can push down
+          createEq(
+            createPropRef(`stats`, `department_id`),
+            createPropRef(`p`, `author_dept`),
+          ), // Multi-source
+        ],
+      }
+
+      const { optimizedQuery: optimized } = optimizeQuery(query)
+
+      // The posts clause should be pushed down
+      expect(optimized.join).toHaveLength(1)
+      if (optimized.join && optimized.join[0]) {
+        expect(optimized.join[0].from.type).toBe(`queryRef`)
+      }
+
+      // The remaining clauses should be combined WITHOUT nested AND
+      expect(optimized.where).toBeDefined()
+      expect(optimized.where!.length).toBe(1)
+      const combinedWhere = optimized.where![0] as any
+      expect(combinedWhere.type).toBe(`func`)
+      expect(combinedWhere.name).toBe(`and`)
+      // Should have 4 args (the 2 from the nested AND + the multi-source clause),
+      // NOT 2 args where one is itself an AND
+      expect(combinedWhere.args).toHaveLength(3)
+      // Verify none of the args are AND expressions (i.e., fully flattened)
+      const argTypes = combinedWhere.args.map((arg: any) => ({
+        type: arg.type,
+        name: arg.name,
+      }))
+      expect(argTypes).not.toContainEqual({ type: `func`, name: `and` })
+    })
+
+    test(`should not combine functional WHERE clauses`, () => {
+      // Verify that fn.where() clauses remain separate and are not combined
+      const query: QueryIR = {
+        from: new CollectionRef(mockCollection, `u`),
+        where: [
+          createEq(createPropRef(`u`, `department_id`), createValue(1)),
+          createGt(createPropRef(`u`, `age`), createValue(25)),
+        ],
+        fnWhere: [
+          (row: any) => row.u.name.startsWith(`A`),
+          (row: any) => row.u.email !== null,
+        ],
+      }
+
+      const { optimizedQuery: optimized } = optimizeQuery(query)
+
+      // Regular WHERE clauses should be combined into one
+      expect(optimized.where).toHaveLength(1)
+      expect(optimized.where![0]).toMatchObject({
+        type: `func`,
+        name: `and`,
+      })
+
+      // Functional WHERE clauses should remain separate (not combined)
+      expect(optimized.fnWhere).toHaveLength(2)
+      expect(optimized.fnWhere![0]).toBeTypeOf(`function`)
+      expect(optimized.fnWhere![1]).toBeTypeOf(`function`)
+    })
   })
 
   describe(`JOIN semantics preservation`, () => {
@@ -1458,7 +1654,7 @@ describe(`Query Optimizer`, () => {
       expect(optimizedQuery.where![0]).toEqual({
         expression: createEq(
           createPropRef(`teamMember`, `user_id`),
-          createValue(100)
+          createValue(100),
         ),
         residual: true,
       })
@@ -1476,7 +1672,7 @@ describe(`Query Optimizer`, () => {
           expect(optimizedQuery.where).toContainEqual({
             expression: createEq(
               createPropRef(`teamMember`, `user_id`),
-              createValue(100)
+              createValue(100),
             ),
             residual: true,
           })
@@ -1524,7 +1720,7 @@ describe(`Query Optimizer`, () => {
       expect(optimizedQuery.where![0]).toEqual({
         expression: createEq(
           createPropRef(`user`, `department_id`),
-          createValue(1)
+          createValue(1),
         ),
         residual: true,
       })
@@ -1539,7 +1735,7 @@ describe(`Query Optimizer`, () => {
           expect(optimizedQuery.where).toContainEqual({
             expression: createEq(
               createPropRef(`user`, `department_id`),
-              createValue(1)
+              createValue(1),
             ),
             residual: true,
           })
@@ -1587,7 +1783,7 @@ describe(`Query Optimizer`, () => {
       expect(optimizedQuery.where![0]).toEqual({
         expression: createGt(
           createPropRef(`payment`, `amount`),
-          createValue(100)
+          createValue(100),
         ),
         residual: true,
       })
@@ -1605,7 +1801,7 @@ describe(`Query Optimizer`, () => {
           expect(optimizedQuery.where).toContainEqual({
             expression: createGt(
               createPropRef(`payment`, `amount`),
-              createValue(100)
+              createValue(100),
             ),
             residual: true,
           })
@@ -1655,7 +1851,7 @@ describe(`Query Optimizer`, () => {
       if (optimizedQuery.join![0]?.from.type === `queryRef`) {
         const deptSubquery = optimizedQuery.join![0].from.query
         expect(deptSubquery.where).toContainEqual(
-          createEq(createPropRef(`dept`, `budget`), createValue(100000))
+          createEq(createPropRef(`dept`, `budget`), createValue(100000)),
         )
       }
     })
diff --git a/packages/db/tests/query/optional-fields-negative.test-d.ts b/packages/db/tests/query/optional-fields-negative.test-d.ts
index 153361b68..56436d10c 100644
--- a/packages/db/tests/query/optional-fields-negative.test-d.ts
+++ b/packages/db/tests/query/optional-fields-negative.test-d.ts
@@ -1,7 +1,7 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { createLiveQueryCollection, eq, gt } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { createLiveQueryCollection, eq, gt } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Test types with optional fields
 type UserWithOptional = {
@@ -24,7 +24,7 @@ function createUsersCollection() {
       id: `test-users`,
       getKey: (user) => user.id,
       initialData: [],
-    })
+    }),
   )
 }
 
@@ -34,7 +34,7 @@ function createDepartmentsCollection() {
       id: `test-departments`,
       getKey: (dept) => dept.id,
       initialData: [],
-    })
+    }),
   )
 }
 
@@ -80,7 +80,7 @@ describe(`Optional Fields - Type Safety Tests`, () => {
             // This should work correctly - department_id is optional but can be used in join
             return eq(user.department_id, dept.id)
           },
-          `inner`
+          `inner`,
         ),
     })
 
@@ -149,7 +149,7 @@ describe(`Optional Fields - Type Safety Tests`, () => {
           .join(
             { dept: departmentsCollection },
             ({ user, dept }) => eq(user.department_id, dept.id),
-            `left`
+            `left`,
           )
           .select(({ user, dept }) => ({
             user_name: user.name,
diff --git a/packages/db/tests/query/optional-fields-runtime.test.ts b/packages/db/tests/query/optional-fields-runtime.test.ts
index 41fa4888d..158df33bf 100644
--- a/packages/db/tests/query/optional-fields-runtime.test.ts
+++ b/packages/db/tests/query/optional-fields-runtime.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, it } from "vitest"
-import { createLiveQueryCollection, eq } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { describe, expect, it } from 'vitest'
+import { createLiveQueryCollection, eq } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Test types with optional fields
 type UserWithOptional = {
@@ -46,7 +46,7 @@ function createUsersCollection() {
           department_id: `dept2`,
         },
       ],
-    })
+    }),
   )
 }
 
@@ -67,7 +67,7 @@ function createDepartmentsCollection() {
           budget: 50000,
         },
       ],
-    })
+    }),
   )
 }
 
@@ -162,7 +162,7 @@ describe(`Optional Fields - Runtime Tests`, () => {
           .join(
             { dept: departmentsCollection },
             ({ user, dept }) => eq(user.department_id, dept.id),
-            `left`
+            `left`,
           )
           .select(({ user, dept }) => ({
             user_name: user.name,
@@ -207,7 +207,7 @@ describe(`Optional Fields - Runtime Tests`, () => {
 
     // Check that we have a group for undefined department_id (Bob)
     const undefinedDeptGroup = groupByResults.find(
-      (r) => r.department_id === undefined
+      (r) => r.department_id === undefined,
     )
     expect(undefinedDeptGroup).toBeDefined()
 
diff --git a/packages/db/tests/query/order-by.test.ts b/packages/db/tests/query/order-by.test.ts
index d0ec8c6f4..c35760599 100644
--- a/packages/db/tests/query/order-by.test.ts
+++ b/packages/db/tests/query/order-by.test.ts
@@ -1,7 +1,7 @@
-import { beforeEach, describe, expect, it } from "vitest"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
-import { createLiveQueryCollection } from "../../src/query/live-query-collection.js"
+import { beforeEach, describe, expect, it } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+import { createLiveQueryCollection } from '../../src/query/live-query-collection.js'
 import {
   eq,
   gt,
@@ -9,7 +9,8 @@ import {
   lt,
   max,
   not,
-} from "../../src/query/builder/functions.js"
+} from '../../src/query/builder/functions.js'
+import { createFilterFunctionFromExpression } from '../../src/collection/change-events.js'
 
 type Person = {
   id: string
@@ -224,7 +225,7 @@ function createEmployeesCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (employee) => employee.id,
       initialData: employeeData,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -235,12 +236,12 @@ function createDepartmentsCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (department) => department.id,
       initialData: departmentData,
       autoIndex,
-    })
+    }),
   )
 }
 
 function createEmployeesWithNullableCollection(
-  autoIndex: `off` | `eager` = `eager`
+  autoIndex: `off` | `eager` = `eager`,
 ) {
   return createCollection(
     mockSyncCollectionOptions<EmployeeWithNullableFields>({
@@ -248,7 +249,7 @@ function createEmployeesWithNullableCollection(
       getKey: (employee) => employee.id,
       initialData: employeeWithNullableData,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -271,7 +272,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .select(({ employees }) => ({
               id: employees.id,
               name: employees.name,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -296,7 +297,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -316,7 +317,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .select(({ employees }) => ({
               id: employees.id,
               name: employees.name,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -339,7 +340,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               name: employees.name,
               department_id: employees.department_id,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -351,7 +352,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
         // Department 1: Charlie (55000), Eve (52000), Alice (50000)
         // Department 2: Diana (65000), Bob (60000)
         expect(
-          results.map((r) => ({ dept: r.department_id, salary: r.salary }))
+          results.map((r) => ({ dept: r.department_id, salary: r.salary })),
         ).toEqual([
           { dept: 1, salary: 55000 }, // Charlie
           { dept: 1, salary: 52000 }, // Eve
@@ -371,7 +372,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               hire_date: employees.hire_date,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -395,7 +396,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -415,7 +416,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -436,7 +437,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -455,10 +456,10 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               .select(({ employees }) => ({
                 id: employees.id,
                 name: employees.name,
-              }))
+              })),
           )
         }).toThrow(
-          `LIMIT and OFFSET require an ORDER BY clause to ensure deterministic results`
+          `LIMIT and OFFSET require an ORDER BY clause to ensure deterministic results`,
         )
       })
 
@@ -473,7 +474,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -520,7 +521,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -567,7 +568,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -618,7 +619,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -661,7 +662,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -704,7 +705,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -732,6 +733,38 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
           [5, 52_000],
         ])
       })
+
+      it(`handles deletion from partial page with limit larger than data`, async () => {
+        const collection = createLiveQueryCollection((q) =>
+          q
+            .from({ employees: employeesCollection })
+            .orderBy(({ employees }) => employees.salary, `desc`)
+            .limit(20) // Limit larger than number of employees (5)
+            .select(({ employees }) => ({
+              id: employees.id,
+              name: employees.name,
+              salary: employees.salary,
+            })),
+        )
+        await collection.preload()
+
+        const results = Array.from(collection.values())
+        expect(results).toHaveLength(5)
+        expect(results[0]!.name).toBe(`Diana`)
+
+        // Delete Diana (the highest paid employee, first in DESC order)
+        const dianaData = employeeData.find((e) => e.id === 4)!
+        employeesCollection.utils.begin()
+        employeesCollection.utils.write({
+          type: `delete`,
+          value: dianaData,
+        })
+        employeesCollection.utils.commit()
+
+        const newResults = Array.from(collection.values())
+        expect(newResults).toHaveLength(4)
+        expect(newResults[0]!.name).toBe(`Bob`)
+      })
     })
 
     describe(`OrderBy with Joins`, () => {
@@ -742,7 +775,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .join(
               { departments: departmentsCollection },
               ({ employees, departments }) =>
-                eq(employees.department_id, departments.id)
+                eq(employees.department_id, departments.id),
             )
             .orderBy(({ departments }) => departments?.name, `asc`)
             .orderBy(({ employees }) => employees.salary, `desc`)
@@ -751,7 +784,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               employee_name: employees.name,
               department_name: departments?.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -763,7 +796,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
         // Engineering: Charlie (55000), Eve (52000), Alice (50000)
         // Sales: Diana (65000), Bob (60000)
         expect(
-          results.map((r) => ({ dept: r.department_name, salary: r.salary }))
+          results.map((r) => ({ dept: r.department_name, salary: r.salary })),
         ).toEqual([
           { dept: `Engineering`, salary: 55000 }, // Charlie
           { dept: `Engineering`, salary: 52000 }, // Eve
@@ -794,7 +827,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             getKey: (doc) => doc.id,
             autoIndex: `eager`,
             initialData: vehicleDocumentsData,
-          })
+          }),
         )
 
         const liveQuery = createLiveQueryCollection({
@@ -850,7 +883,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             getKey: (doc) => doc.id,
             autoIndex: `eager`,
             initialData: vehicleDocumentsData,
-          })
+          }),
         )
 
         const liveQuery = createLiveQueryCollection({
@@ -905,7 +938,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -926,7 +959,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -948,7 +981,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -970,7 +1003,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1015,7 +1048,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1050,7 +1083,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1077,7 +1110,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             id: `test-string-id-sequence`,
             getKey: (person: Person) => person.id,
             initialData: initialPersons,
-          })
+          }),
         )
 
         const liveQuery = createLiveQueryCollection((q) =>
@@ -1087,7 +1120,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: c.id,
               name: c.name,
             }))
-            .orderBy(({ collection: c }) => c.id, `asc`)
+            .orderBy(({ collection: c }) => c.id, `asc`),
         )
         await liveQuery.preload()
 
@@ -1170,7 +1203,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             id: `test-empty-employees`,
             getKey: (employee) => employee.id,
             initialData: [],
-          })
+          }),
         )
 
         const collection = createLiveQueryCollection((q) =>
@@ -1180,7 +1213,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .select(({ employees }) => ({
               id: employees.id,
               name: employees.name,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1212,7 +1245,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               },
             ],
             autoIndex,
-          })
+          }),
         )
 
         // When autoIndex is `eager` this creates an index on the date field
@@ -1220,7 +1253,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
           q
             .from({ numbers: dateCollection })
             .orderBy(({ numbers }) => numbers.date, `asc`)
-            .limit(1)
+            .limit(1),
         )
         await firstQuery.preload()
 
@@ -1229,7 +1262,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
           q
             .from({ numbers: dateCollection })
             .orderBy(({ numbers }) => numbers.value, `asc`)
-            .limit(1)
+            .limit(1),
         )
         await orderByQuery.preload()
 
@@ -1269,7 +1302,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               },
             ],
             autoIndex,
-          })
+          }),
         )
 
         // When autoIndex is `eager` this creates an index on the date field
@@ -1281,7 +1314,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .select(({ numbers }) => ({
               id: numbers.id,
               date: numbers.date,
-            }))
+            })),
         )
         await firstQuery.preload()
 
@@ -1294,7 +1327,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .select(({ numbers }) => ({
               id: numbers.id,
               date: numbers.date,
-            }))
+            })),
         )
         await orderByQuery.preload()
 
@@ -1330,7 +1363,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               },
             ],
             autoIndex,
-          })
+          }),
         )
 
         // When autoIndex is `eager` this creates an index on the date field
@@ -1341,7 +1374,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               direction: `asc`,
               nulls: `last`,
             })
-            .limit(3)
+            .limit(3),
         )
         await query1.preload()
 
@@ -1349,18 +1382,18 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
         expect(result1).toHaveLength(3)
         expect(result1.map((r) => r.age)).toEqual([14, 25, null])
 
-        // The default compare options defaults to nulls first
+        // With 3-valued logic, lt(null, 18) returns UNKNOWN (null), which excludes the row
         const query2 = createLiveQueryCollection((q) =>
           q
             .from({ persons: personsCollection })
-            .where(({ persons }) => lt(persons.age, 18))
+            .where(({ persons }) => lt(persons.age, 18)),
         )
         await query2.preload()
 
         const result2 = Array.from(query2.values())
         const ages = result2.map((r) => r.age)
-        expect(ages).toHaveLength(2)
-        expect(ages).toContain(null)
+        // null should NOT be included because lt(null, 18) returns UNKNOWN in 3-valued logic
+        expect(ages).toHaveLength(1)
         expect(ages).toContain(14)
 
         // The default compare options defaults to nulls first
@@ -1368,7 +1401,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
         const query3 = createLiveQueryCollection((q) =>
           q
             .from({ persons: personsCollection })
-            .where(({ persons }) => gt(persons.age, 18))
+            .where(({ persons }) => gt(persons.age, 18)),
         )
         await query3.preload()
 
@@ -1403,7 +1436,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               },
             ],
             autoIndex,
-          })
+          }),
         )
 
         // When autoIndex is `eager` this creates an index on the date field
@@ -1414,7 +1447,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               direction: `asc`,
               stringSort: `lexical`,
             })
-            .limit(2)
+            .limit(2),
         )
         await query1.preload()
 
@@ -1430,7 +1463,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               stringSort: `locale`,
               locale: `en-US`,
             })
-            .limit(2)
+            .limit(2),
         )
         await query2.preload()
 
@@ -1467,7 +1500,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               },
             ],
             autoIndex,
-          })
+          }),
         )
 
         // When autoIndex is `eager` this creates an index on the value field with nulls first
@@ -1482,7 +1515,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .select(({ items }) => ({
               id: items.id,
               value: items.value,
-            }))
+            })),
         )
         await query1.preload()
 
@@ -1501,7 +1534,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .select(({ items }) => ({
               id: items.id,
               value: items.value,
-            }))
+            })),
         )
         await query2.preload()
 
@@ -1532,7 +1565,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1563,7 +1596,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1594,7 +1627,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1625,7 +1658,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1661,7 +1694,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               name: employees.name,
               department_id: employees.department_id,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1674,7 +1707,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
         // Department 1: Alice (50000), Eve (52000)
         // Department 2: Diana (65000), Bob (null)
         expect(
-          results.map((r) => ({ dept: r.department_id, salary: r.salary }))
+          results.map((r) => ({ dept: r.department_id, salary: r.salary })),
         ).toEqual([
           { dept: null, salary: 55000 }, // Charlie
           { dept: null, salary: null }, // Frank
@@ -1697,7 +1730,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: employees.id,
               name: employees.name,
               salary: employees.salary,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -1773,7 +1806,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
                   id: employees.id,
                   name: employees.name,
                   salary: employees.salary,
-                }))
+                })),
             )
 
             await collection.preload()
@@ -1781,12 +1814,12 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             const builder = (collection as any).config.__builder
             expect(builder).toBeTruthy()
             expect(
-              Object.keys(builder.optimizableOrderByCollections)
+              Object.keys(builder.optimizableOrderByCollections),
             ).toContain(employeesCollection.id)
           } finally {
             CollectionConfigBuilder.prototype.getConfig = originalGetConfig
           }
-        }
+        },
       )
 
       itWhenAutoIndex(
@@ -1811,7 +1844,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
                 .join(
                   { departments: departmentsCollection },
                   ({ employees, departments }) =>
-                    eq(employees.department_id, departments.id)
+                    eq(employees.department_id, departments.id),
                 )
                 .orderBy(({ departments }) => departments?.name, `asc`)
                 .limit(5)
@@ -1819,7 +1852,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
                   employeeId: employees.id,
                   employeeName: employees.name,
                   departmentName: departments?.name,
-                }))
+                })),
             )
 
             await collection.preload()
@@ -1829,7 +1862,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
 
             // Verify that the order-by optimization is scoped to the departments alias
             const orderByInfo = Object.values(
-              builder.optimizableOrderByCollections
+              builder.optimizableOrderByCollections,
             )[0] as any
             expect(orderByInfo).toBeDefined()
             expect(orderByInfo.alias).toBe(`departments`)
@@ -1838,7 +1871,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
           } finally {
             CollectionConfigBuilder.prototype.getConfig = originalGetConfig
           }
-        }
+        },
       )
 
       itWhenAutoIndex(
@@ -1866,7 +1899,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
                   id: employees.id,
                   name: employees.name,
                   salary: employees.salary,
-                }))
+                })),
             )
 
             await collection.preload()
@@ -1874,12 +1907,12 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             const builder = (collection as any).config.__builder
             expect(builder).toBeTruthy()
             expect(
-              Object.keys(builder.optimizableOrderByCollections)
+              Object.keys(builder.optimizableOrderByCollections),
             ).toContain(employeesCollection.id)
           } finally {
             CollectionConfigBuilder.prototype.getConfig = originalGetConfig
           }
-        }
+        },
       )
     })
 
@@ -1915,7 +1948,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             getKey: (employee) => employee.id,
             initialData: numericEmployees,
             autoIndex,
-          })
+          }),
         )
 
         // Test lexical sorting (should sort by character code)
@@ -1929,7 +1962,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .select(({ employees }) => ({
               id: employees.id,
               name: employees.name,
-            }))
+            })),
         )
         await lexicalCollection.preload()
 
@@ -1949,7 +1982,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             .select(({ employees }) => ({
               id: employees.id,
               name: employees.name,
-            }))
+            })),
         )
         await localeCollection.preload()
 
@@ -1970,7 +2003,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
             getKey: (person) => person.id,
             initialData: initialPersons,
             autoIndex,
-          })
+          }),
         )
       }
 
@@ -1989,7 +2022,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: persons.id,
               name: persons.name,
               score: persons.profile?.score,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -2012,7 +2045,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: persons.id,
               name: persons.name,
               score: persons.profile?.score,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -2036,7 +2069,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               name: persons.name,
               rating: persons.profile?.stats.rating,
               tasksCompleted: persons.profile?.stats.tasksCompleted,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -2061,7 +2094,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               name: persons.name,
               team: persons.team,
               score: persons.profile?.score,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -2091,7 +2124,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               name: persons.name,
               city: persons.address?.city,
               lat: persons.address?.coordinates.lat,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -2127,7 +2160,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: persons.id,
               name: persons.name,
               score: persons.profile?.score,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -2148,7 +2181,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: persons.id,
               name: persons.name,
               score: persons.profile?.score,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -2196,7 +2229,7 @@ function createOrderByTests(autoIndex: `off` | `eager`): void {
               id: persons.id,
               name: persons.name,
               city: persons.address?.city,
-            }))
+            })),
         )
         await collection.preload()
 
@@ -2225,6 +2258,161 @@ describe(`Query2 OrderBy Compiler`, () => {
   createOrderByTests(`eager`)
 })
 
+describe(`OrderBy with collection-level StringSortOpts`, () => {
+  type StringItem = {
+    id: number
+    name: string
+  }
+
+  const stringItemsData: Array<StringItem> = [
+    { id: 1, name: `Charlie` },
+    { id: 2, name: `alice` },
+    { id: 3, name: `bob` },
+  ]
+
+  it(`should use collection's compareOptions when query doesn't specify stringSort`, async () => {
+    // Create collection with lexical string sorting as default
+    const collectionWithLexical = createCollection(
+      mockSyncCollectionOptions<StringItem>({
+        id: `test-lexical-collection`,
+        getKey: (item) => item.id,
+        initialData: stringItemsData,
+        defaultStringCollation: {
+          stringSort: `lexical`,
+        },
+      }),
+    )
+
+    // Query without specifying stringSort should use collection's lexical default
+    const lexicalQuery = createLiveQueryCollection((q) =>
+      q
+        .from({ items: collectionWithLexical })
+        .orderBy(({ items }) => items.name, `asc`)
+        .select(({ items }) => ({
+          id: items.id,
+          name: items.name,
+        })),
+    )
+    await lexicalQuery.preload()
+
+    // In lexical comparison, uppercase letters come before lowercase letters
+    const lexicalResults = Array.from(lexicalQuery.values())
+    expect(lexicalResults.map((r) => r.name)).toEqual([
+      `Charlie`,
+      `alice`,
+      `bob`,
+    ])
+  })
+
+  it(`should override collection's compareOptions when query specifies stringSort`, async () => {
+    // Create collection with lexical string sorting as default
+    const collectionWithLexical = createCollection(
+      mockSyncCollectionOptions<StringItem>({
+        id: `test-lexical-collection-override`,
+        getKey: (item) => item.id,
+        initialData: stringItemsData,
+        defaultStringCollation: {
+          stringSort: `lexical`,
+        },
+      }),
+    )
+
+    // Query with explicit locale stringSort should override collection's lexical default
+    const localeQuery = createLiveQueryCollection((q) =>
+      q
+        .from({ items: collectionWithLexical })
+        .orderBy(({ items }) => items.name, {
+          direction: `asc`,
+          stringSort: `locale`,
+          locale: `en-US`,
+        })
+        .select(({ items }) => ({
+          id: items.id,
+          name: items.name,
+        })),
+    )
+    await localeQuery.preload()
+
+    // In locale comparison, case-insensitive sorting puts lowercase first
+    const localeResults = Array.from(localeQuery.values())
+    expect(localeResults.map((r) => r.name)).toEqual([
+      `alice`,
+      `bob`,
+      `Charlie`,
+    ])
+  })
+
+  it(`should use collection default and allow query overrides`, async () => {
+    // Create collection with lexical string sorting as default
+    const collectionWithLexical = createCollection(
+      mockSyncCollectionOptions<StringItem>({
+        id: `test-lexical-collection-sequence`,
+        getKey: (item) => item.id,
+        initialData: stringItemsData,
+        defaultStringCollation: {
+          stringSort: `lexical`,
+        },
+      }),
+    )
+
+    // First query without specifying stringSort should use collection's lexical default
+    const firstQuery = createLiveQueryCollection((q) =>
+      q
+        .from({ items: collectionWithLexical })
+        .orderBy(({ items }) => items.name, `asc`)
+        .select(({ items }) => ({
+          id: items.id,
+          name: items.name,
+        })),
+    )
+    await firstQuery.preload()
+
+    // In lexical comparison, uppercase letters come before lowercase letters
+    const firstResults = Array.from(firstQuery.values())
+    expect(firstResults.map((r) => r.name)).toEqual([`Charlie`, `alice`, `bob`])
+
+    // Second query with explicit locale stringSort should override collection's lexical default
+    const secondQuery = createLiveQueryCollection((q) =>
+      q
+        .from({ items: collectionWithLexical })
+        .orderBy(({ items }) => items.name, {
+          direction: `asc`,
+          stringSort: `locale`,
+          locale: `en-US`,
+        })
+        .select(({ items }) => ({
+          id: items.id,
+          name: items.name,
+        })),
+    )
+    await secondQuery.preload()
+
+    // Should use locale sorting (case-insensitive) for this query
+    const secondResults = Array.from(secondQuery.values())
+    expect(secondResults.map((r) => r.name)).toEqual([
+      `alice`,
+      `bob`,
+      `Charlie`,
+    ])
+
+    // Third query without specifying stringSort should use collection's lexical default again
+    const thirdQuery = createLiveQueryCollection((q) =>
+      q
+        .from({ items: collectionWithLexical })
+        .orderBy(({ items }) => items.name, `desc`)
+        .select(({ items }) => ({
+          id: items.id,
+          name: items.name,
+        })),
+    )
+    await thirdQuery.preload()
+
+    // Should revert back to lexical sorting (collection default)
+    const thirdResults = Array.from(thirdQuery.values())
+    expect(thirdResults.map((r) => r.name)).toEqual([`bob`, `alice`, `Charlie`])
+  })
+})
+
 describe(`OrderBy with collection alias conflicts`, () => {
   type EmailSchema = {
     email: string
@@ -2301,3 +2489,772 @@ describe(`OrderBy with collection alias conflicts`, () => {
     expect(result[2]?.email).toBe(`third@test.com`)
   })
 })
+
+describe(`OrderBy with duplicate values`, () => {
+  type TestItem = {
+    id: number
+    a: number
+    keep: boolean
+  }
+
+  function createOrderByBugTests(autoIndex: `off` | `eager`): void {
+    describe(`with autoIndex ${autoIndex}`, () => {
+      it(`should correctly advance window when there are duplicate values`, async () => {
+        // Create test data that reproduces the specific bug described:
+        // Items with many duplicates at value 5, then normal progression
+        const duplicateTestData: Array<TestItem> = [
+          { id: 1, a: 1, keep: true },
+          { id: 2, a: 2, keep: true },
+          { id: 3, a: 3, keep: true },
+          { id: 4, a: 4, keep: true },
+          { id: 5, a: 5, keep: true },
+          { id: 6, a: 5, keep: true },
+          { id: 7, a: 5, keep: true },
+          { id: 8, a: 5, keep: true },
+          { id: 9, a: 5, keep: true },
+          { id: 10, a: 5, keep: true },
+          { id: 11, a: 11, keep: true },
+          { id: 12, a: 12, keep: true },
+          { id: 13, a: 13, keep: true },
+          { id: 14, a: 14, keep: true },
+          { id: 15, a: 15, keep: true },
+          { id: 16, a: 16, keep: true },
+        ]
+
+        const duplicateCollection = createCollection(
+          mockSyncCollectionOptions<TestItem>({
+            id: `test-duplicate-window-bug`,
+            getKey: (item) => item.id,
+            initialData: duplicateTestData,
+            autoIndex,
+          }),
+        )
+
+        // Create a live query with offset 0, limit 5 (first page)
+        const collection = createLiveQueryCollection((q) =>
+          q
+            .from({ items: duplicateCollection })
+            .where(({ items }) => eq(items.keep, true))
+            .orderBy(({ items }) => items.a, `asc`)
+            .offset(0)
+            .limit(5)
+            .select(({ items }) => ({
+              id: items.id,
+              a: items.a,
+              keep: items.keep,
+            })),
+        )
+        await collection.preload()
+
+        // First page should return items 1-5
+        let results = Array.from(collection.values()).sort(
+          (a, b) => a.id - b.id,
+        )
+        expect(results).toEqual([
+          { id: 1, a: 1, keep: true },
+          { id: 2, a: 2, keep: true },
+          { id: 3, a: 3, keep: true },
+          { id: 4, a: 4, keep: true },
+          { id: 5, a: 5, keep: true },
+        ])
+
+        // Now move to next page (offset 5, limit 5)
+        collection.utils.setWindow({ offset: 5, limit: 5 })
+        await collection.stateWhenReady()
+
+        // Second page should return items 6-10 (all with value 5)
+        results = Array.from(collection.values()).sort((a, b) => a.id - b.id)
+        expect(results).toEqual([
+          { id: 6, a: 5, keep: true },
+          { id: 7, a: 5, keep: true },
+          { id: 8, a: 5, keep: true },
+          { id: 9, a: 5, keep: true },
+          { id: 10, a: 5, keep: true },
+        ])
+
+        // Now move to third page (offset 10, limit 5)
+        // It should advance past the duplicate 5s
+        collection.utils.setWindow({ offset: 10, limit: 5 })
+        await collection.stateWhenReady()
+
+        // Third page should return items 11-13 (the items after the duplicate 5s)
+        // The bug would cause this to stall and return empty or get stuck
+        results = Array.from(collection.values()).sort((a, b) => a.id - b.id)
+        expect(results).toEqual([
+          { id: 11, a: 11, keep: true },
+          { id: 12, a: 12, keep: true },
+          { id: 13, a: 13, keep: true },
+          { id: 14, a: 14, keep: true },
+          { id: 15, a: 15, keep: true },
+        ])
+
+        // Verify we can continue to next page
+        collection.utils.setWindow({ offset: 15, limit: 5 })
+        await collection.stateWhenReady()
+
+        // Should be empty since we've exhausted all items
+        results = Array.from(collection.values())
+        expect(results).toEqual([{ id: 16, a: 16, keep: true }])
+      })
+
+      it(`should correctly advance window when there are duplicate values loaded from sync layer`, async () => {
+        // Create test data that reproduces the specific bug described:
+        // Items with many duplicates at value 5, then normal progression
+        // Note: loadSubset now receives cursor expressions (whereFrom/whereCurrent) separately from where
+        const allTestData: Array<TestItem> = [
+          { id: 1, a: 1, keep: true },
+          { id: 2, a: 2, keep: true },
+          { id: 3, a: 3, keep: true },
+          { id: 4, a: 4, keep: true },
+          { id: 5, a: 5, keep: true },
+          { id: 6, a: 5, keep: true },
+          { id: 7, a: 5, keep: true },
+          { id: 8, a: 5, keep: true },
+          { id: 9, a: 5, keep: true },
+          { id: 10, a: 5, keep: true },
+          { id: 11, a: 11, keep: true },
+          { id: 12, a: 12, keep: true },
+          { id: 13, a: 13, keep: true },
+          { id: 14, a: 14, keep: true },
+          { id: 15, a: 15, keep: true },
+          { id: 16, a: 16, keep: true },
+        ]
+
+        // Start with only the first 5 items in the local collection
+        const initialData = allTestData.slice(0, 5)
+        let loadSubsetCallCount = 0
+        const loadSubsetCursors: Array<unknown> = []
+
+        const duplicateCollection = createCollection(
+          mockSyncCollectionOptions<TestItem>({
+            id: `test-duplicate-sync-layer-bug`,
+            getKey: (item) => item.id,
+            initialData,
+            autoIndex,
+            syncMode: `on-demand`,
+            sync: {
+              sync: ({ begin, write, commit, markReady }) => {
+                // Load initial data
+                begin()
+                initialData.forEach((item) => {
+                  write({
+                    type: `insert`,
+                    value: item,
+                  })
+                })
+                commit()
+                markReady()
+
+                return {
+                  loadSubset: (options) => {
+                    loadSubsetCallCount++
+                    loadSubsetCursors.push(options.cursor)
+
+                    // Simulate async loading from remote source
+                    return new Promise<void>((resolve) => {
+                      setTimeout(() => {
+                        begin()
+
+                        // Order all test data by field 'a' in ascending order
+                        const sortedData = [...allTestData].sort(
+                          (a, b) => a.a - b.a,
+                        )
+
+                        // Apply where clause filter if present
+                        let filteredData = sortedData
+                        if (options.where) {
+                          try {
+                            const filterFn = createFilterFunctionFromExpression(
+                              options.where,
+                            )
+                            filteredData = sortedData.filter(filterFn)
+                          } catch (error) {
+                            console.log(`Error compiling where clause:`, error)
+                            // If compilation fails, use all data
+                            filteredData = sortedData
+                          }
+                        }
+
+                        // Apply cursor expressions if present (cursor-based pagination)
+                        // For proper cursor-based pagination:
+                        // - whereCurrent should load ALL ties (no limit)
+                        // - whereFrom should load with remaining limit
+                        if (options.cursor) {
+                          const { whereFrom, whereCurrent } = options.cursor
+                          const { limit } = options
+                          try {
+                            // Get ALL rows matching whereCurrent (no limit for ties)
+                            const whereCurrentFn =
+                              createFilterFunctionFromExpression(whereCurrent)
+                            const currentData =
+                              filteredData.filter(whereCurrentFn)
+
+                            // Get rows matching whereFrom with limit (for next page data)
+                            const whereFromFn =
+                              createFilterFunctionFromExpression(whereFrom)
+                            const fromData = filteredData.filter(whereFromFn)
+                            const limitedFromData = limit
+                              ? fromData.slice(0, limit)
+                              : fromData
+
+                            // Combine: current rows + from rows (deduplicated)
+                            const seenIds = new Set<number>()
+                            filteredData = []
+                            for (const item of currentData) {
+                              if (!seenIds.has(item.id)) {
+                                seenIds.add(item.id)
+                                filteredData.push(item)
+                              }
+                            }
+                            for (const item of limitedFromData) {
+                              if (!seenIds.has(item.id)) {
+                                seenIds.add(item.id)
+                                filteredData.push(item)
+                              }
+                            }
+                            // Re-sort after combining
+                            filteredData.sort((a, b) => a.a - b.a)
+                          } catch (error) {
+                            console.log(`Error applying cursor:`, error)
+                          }
+                        }
+
+                        // Apply limit for initial page load (no cursor).
+                        // When cursor is present, limit was already applied in the cursor block above.
+                        const { limit } = options
+                        const dataToLoad =
+                          limit && !options.cursor
+                            ? filteredData.slice(0, limit)
+                            : filteredData
+
+                        dataToLoad.forEach((item) => {
+                          write({
+                            type: `insert`,
+                            value: item,
+                          })
+                        })
+
+                        commit()
+                        resolve()
+                      }, 10) // Small delay to simulate network
+                    })
+                  },
+                }
+              },
+            },
+          }),
+        )
+
+        // Create a live query with offset 0, limit 5 (first page)
+        const collection = createLiveQueryCollection((q) =>
+          q
+            .from({ items: duplicateCollection })
+            .where(({ items }) => eq(items.keep, true))
+            .orderBy(({ items }) => items.a, `asc`)
+            .offset(0)
+            .limit(5)
+            .select(({ items }) => ({
+              id: items.id,
+              a: items.a,
+              keep: items.keep,
+            })),
+        )
+        await collection.preload()
+
+        // First page should return items 1-5 (all local data)
+        let results = Array.from(collection.values()).sort(
+          (a, b) => a.id - b.id,
+        )
+        expect(results).toEqual([
+          { id: 1, a: 1, keep: true },
+          { id: 2, a: 2, keep: true },
+          { id: 3, a: 3, keep: true },
+          { id: 4, a: 4, keep: true },
+          { id: 5, a: 5, keep: true },
+        ])
+        expect(loadSubsetCallCount).toBe(1)
+        // First loadSubset call (initial page at offset 0) has no cursor
+        expect(loadSubsetCursors[0]).toBeUndefined()
+
+        // Now move to next page (offset 5, limit 5) - this should trigger loadSubset with a cursor
+        const moveToSecondPage = collection.utils.setWindow({
+          offset: 5,
+          limit: 5,
+        })
+        expect(moveToSecondPage).toBeInstanceOf(Promise)
+        await moveToSecondPage
+
+        // Second page should return items 6-10 (all with value 5, loaded from sync layer)
+        results = Array.from(collection.values()).sort((a, b) => a.id - b.id)
+        expect(results).toEqual([
+          { id: 6, a: 5, keep: true },
+          { id: 7, a: 5, keep: true },
+          { id: 8, a: 5, keep: true },
+          { id: 9, a: 5, keep: true },
+          { id: 10, a: 5, keep: true },
+        ])
+        // we expect 1 new loadSubset call (cursor expressions for whereFrom/whereCurrent are now combined in single call)
+        expect(loadSubsetCallCount).toBe(2)
+        // Second loadSubset call (pagination) has a cursor with whereFrom and whereCurrent
+        expect(loadSubsetCursors[1]).toBeDefined()
+        expect(loadSubsetCursors[1]).toHaveProperty(`whereFrom`)
+        expect(loadSubsetCursors[1]).toHaveProperty(`whereCurrent`)
+
+        // Now move to third page (offset 10, limit 5)
+        // It should advance past the duplicate 5s
+        const moveToThirdPage = collection.utils.setWindow({
+          offset: 10,
+          limit: 5,
+        })
+
+        // Now it is `true` because we already have that page
+        // because when we loaded the 2nd page we loaded all the duplicate 5s and then we loaded
+        // values > 5 with limit 5 but since the entire 2nd page is filled with the duplicate 5s
+        // we in fact already loaded the third page so it is immediately available here
+        expect(moveToThirdPage).toBe(true)
+
+        // Third page should return items 11-13 (the items after the duplicate 5s)
+        // The bug would cause this to stall and return empty or get stuck
+        results = Array.from(collection.values()).sort((a, b) => a.id - b.id)
+        expect(results).toEqual([
+          { id: 11, a: 11, keep: true },
+          { id: 12, a: 12, keep: true },
+          { id: 13, a: 13, keep: true },
+          { id: 14, a: 14, keep: true },
+          { id: 15, a: 15, keep: true },
+        ])
+        // We expect no more loadSubset calls because when we loaded the previous page
+        // we asked for all data equal to max value and LIMIT values greater than max value
+        // and the LIMIT values greater than max value already loaded the next page
+        expect(loadSubsetCallCount).toBe(2)
+      })
+
+      it(`should correctly advance window when there are duplicate values loaded from both local collection and sync layer`, async () => {
+        // Create test data that reproduces the specific bug described:
+        // Items with many duplicates at value 5, then normal progression
+        // Note: loadSubset now receives cursor expressions (whereFrom/whereCurrent) separately from where
+        const allTestData: Array<TestItem> = [
+          { id: 1, a: 1, keep: true },
+          { id: 2, a: 2, keep: true },
+          { id: 3, a: 3, keep: true },
+          { id: 4, a: 4, keep: true },
+          { id: 5, a: 5, keep: true },
+          { id: 6, a: 5, keep: true },
+          { id: 7, a: 5, keep: true },
+          { id: 8, a: 5, keep: true },
+          { id: 9, a: 5, keep: true },
+          { id: 10, a: 5, keep: true },
+          { id: 11, a: 11, keep: true },
+          { id: 12, a: 12, keep: true },
+          { id: 13, a: 13, keep: true },
+          { id: 14, a: 14, keep: true },
+          { id: 15, a: 15, keep: true },
+          { id: 16, a: 16, keep: true },
+        ]
+
+        // Start with the first 10 items in the local collection (includes all duplicates)
+        const initialData = allTestData.slice(0, 10)
+        let loadSubsetCallCount = 0
+        const loadSubsetCursors: Array<unknown> = []
+
+        const duplicateCollection = createCollection(
+          mockSyncCollectionOptions<TestItem>({
+            id: `test-duplicate-sync-layer-bug`,
+            getKey: (item) => item.id,
+            initialData,
+            autoIndex,
+            syncMode: `on-demand`,
+            sync: {
+              sync: ({ begin, write, commit, markReady }) => {
+                // Load initial data
+                begin()
+                initialData.forEach((item) => {
+                  write({
+                    type: `insert`,
+                    value: item,
+                  })
+                })
+                commit()
+                markReady()
+
+                return {
+                  loadSubset: (options) => {
+                    loadSubsetCallCount++
+                    loadSubsetCursors.push(options.cursor)
+
+                    // Simulate async loading from remote source
+                    return new Promise<void>((resolve) => {
+                      setTimeout(() => {
+                        begin()
+
+                        // Order all test data by field 'a' in ascending order
+                        const sortedData = [...allTestData].sort(
+                          (a, b) => a.a - b.a,
+                        )
+
+                        // Apply where clause filter if present
+                        let filteredData = sortedData
+                        if (options.where) {
+                          try {
+                            const filterFn = createFilterFunctionFromExpression(
+                              options.where,
+                            )
+                            filteredData = sortedData.filter(filterFn)
+                          } catch (error) {
+                            console.log(`Error compiling where clause:`, error)
+                            // If compilation fails, use all data
+                            filteredData = sortedData
+                          }
+                        }
+
+                        // Apply cursor expressions if present (cursor-based pagination)
+                        // For proper cursor-based pagination:
+                        // - whereCurrent should load ALL ties (no limit)
+                        // - whereFrom should load with remaining limit
+                        if (options.cursor) {
+                          const { whereFrom, whereCurrent } = options.cursor
+                          const { limit } = options
+                          try {
+                            // Get ALL rows matching whereCurrent (no limit for ties)
+                            const whereCurrentFn =
+                              createFilterFunctionFromExpression(whereCurrent)
+                            const currentData =
+                              filteredData.filter(whereCurrentFn)
+
+                            // Get rows matching whereFrom with limit (for next page data)
+                            const whereFromFn =
+                              createFilterFunctionFromExpression(whereFrom)
+                            const fromData = filteredData.filter(whereFromFn)
+                            const limitedFromData = limit
+                              ? fromData.slice(0, limit)
+                              : fromData
+
+                            // Combine: current rows + from rows (deduplicated)
+                            const seenIds = new Set<number>()
+                            filteredData = []
+                            for (const item of currentData) {
+                              if (!seenIds.has(item.id)) {
+                                seenIds.add(item.id)
+                                filteredData.push(item)
+                              }
+                            }
+                            for (const item of limitedFromData) {
+                              if (!seenIds.has(item.id)) {
+                                seenIds.add(item.id)
+                                filteredData.push(item)
+                              }
+                            }
+                            // Re-sort after combining
+                            filteredData.sort((a, b) => a.a - b.a)
+                          } catch (error) {
+                            console.log(`Error applying cursor:`, error)
+                          }
+                        }
+
+                        // Apply limit for initial page load (no cursor).
+                        // When cursor is present, limit was already applied in the cursor block above.
+                        const { limit } = options
+                        const dataToLoad =
+                          limit && !options.cursor
+                            ? filteredData.slice(0, limit)
+                            : filteredData
+
+                        dataToLoad.forEach((item) => {
+                          write({
+                            type: `insert`,
+                            value: item,
+                          })
+                        })
+
+                        commit()
+                        resolve()
+                      }, 10) // Small delay to simulate network
+                    })
+                  },
+                }
+              },
+            },
+          }),
+        )
+
+        // Create a live query with offset 0, limit 5 (first page)
+        const collection = createLiveQueryCollection((q) =>
+          q
+            .from({ items: duplicateCollection })
+            .where(({ items }) => eq(items.keep, true))
+            .orderBy(({ items }) => items.a, `asc`)
+            .offset(0)
+            .limit(5)
+            .select(({ items }) => ({
+              id: items.id,
+              a: items.a,
+              keep: items.keep,
+            })),
+        )
+        await collection.preload()
+
+        // First page should return items 1-5 (all local data)
+        let results = Array.from(collection.values()).sort(
+          (a, b) => a.id - b.id,
+        )
+        expect(results).toEqual([
+          { id: 1, a: 1, keep: true },
+          { id: 2, a: 2, keep: true },
+          { id: 3, a: 3, keep: true },
+          { id: 4, a: 4, keep: true },
+          { id: 5, a: 5, keep: true },
+        ])
+        expect(loadSubsetCallCount).toBe(1)
+        // First loadSubset call (initial page at offset 0) has no cursor
+        expect(loadSubsetCursors[0]).toBeUndefined()
+
+        // Now move to next page (offset 5, limit 5) - this should trigger loadSubset with a cursor
+        const moveToSecondPage = collection.utils.setWindow({
+          offset: 5,
+          limit: 5,
+        })
+        expect(moveToSecondPage).toBeInstanceOf(Promise)
+        await moveToSecondPage
+
+        // Second page should return items 6-10 (all with value 5, loaded from sync layer)
+        results = Array.from(collection.values()).sort((a, b) => a.id - b.id)
+        expect(results).toEqual([
+          { id: 6, a: 5, keep: true },
+          { id: 7, a: 5, keep: true },
+          { id: 8, a: 5, keep: true },
+          { id: 9, a: 5, keep: true },
+          { id: 10, a: 5, keep: true },
+        ])
+        // we expect 1 new loadSubset call (cursor expressions for whereFrom/whereCurrent are now combined in single call)
+        expect(loadSubsetCallCount).toBe(2)
+        // Second loadSubset call (pagination) has a cursor with whereFrom and whereCurrent
+        expect(loadSubsetCursors[1]).toBeDefined()
+        expect(loadSubsetCursors[1]).toHaveProperty(`whereFrom`)
+        expect(loadSubsetCursors[1]).toHaveProperty(`whereCurrent`)
+
+        // Now move to third page (offset 10, limit 5)
+        // It should advance past the duplicate 5s
+        const moveToThirdPage = collection.utils.setWindow({
+          offset: 10,
+          limit: 5,
+        })
+
+        // Now it is `true` because we already have that page
+        // because when we loaded the 2nd page we loaded all the duplicate 5s and then we loaded
+        // values > 5 with limit 5 but since the entire 2nd page is filled with the duplicate 5s
+        // we in fact already loaded the third page so it is immediately available here
+        expect(moveToThirdPage).toBe(true)
+
+        // Third page should return items 11-13 (the items after the duplicate 5s)
+        // The bug would cause this to stall and return empty or get stuck
+        results = Array.from(collection.values()).sort((a, b) => a.id - b.id)
+        expect(results).toEqual([
+          { id: 11, a: 11, keep: true },
+          { id: 12, a: 12, keep: true },
+          { id: 13, a: 13, keep: true },
+          { id: 14, a: 14, keep: true },
+          { id: 15, a: 15, keep: true },
+        ])
+        // We expect no more loadSubset calls because when we loaded the previous page
+        // we asked for all data equal to max value and LIMIT values greater than max value
+        // and the LIMIT values greater than max value already loaded the next page
+        expect(loadSubsetCallCount).toBe(2)
+      })
+    })
+  }
+
+  createOrderByBugTests(`eager`)
+})
+
+describe(`OrderBy with Date values and precision differences`, () => {
+  type TestItemWithDate = {
+    id: number
+    createdAt: Date
+    keep: boolean
+  }
+
+  it(`should use range query for Date values to handle backend precision differences`, async () => {
+    // This test verifies that when paginating with Date orderBy values,
+    // the code uses a range query (gte/lt) instead of exact equality (eq)
+    // to handle backends with higher precision than JavaScript's millisecond precision.
+    //
+    // The bug: PostgreSQL stores timestamps with microsecond precision.
+    // When JS has a Date "2024-01-15T10:30:45.123Z", the backend might have multiple
+    // rows with 123.000μs, 123.100μs, 123.200μs, etc. Using eq() would only match
+    // 123.000μs, missing the others. The fix uses gte/lt to match the full 1ms range.
+
+    const baseTime = new Date(`2024-01-15T10:30:45.123Z`)
+
+    const testData: Array<TestItemWithDate> = [
+      { id: 1, createdAt: new Date(`2024-01-15T10:30:45.120Z`), keep: true },
+      { id: 2, createdAt: new Date(`2024-01-15T10:30:45.121Z`), keep: true },
+      { id: 3, createdAt: new Date(`2024-01-15T10:30:45.122Z`), keep: true },
+      { id: 4, createdAt: new Date(`2024-01-15T10:30:45.122Z`), keep: true },
+      { id: 5, createdAt: baseTime, keep: true },
+      { id: 6, createdAt: baseTime, keep: true },
+      { id: 7, createdAt: baseTime, keep: true },
+      { id: 8, createdAt: baseTime, keep: true },
+      { id: 9, createdAt: baseTime, keep: true },
+      { id: 10, createdAt: baseTime, keep: true },
+      { id: 11, createdAt: new Date(`2024-01-15T10:30:45.124Z`), keep: true },
+      { id: 12, createdAt: new Date(`2024-01-15T10:30:45.125Z`), keep: true },
+    ]
+
+    const initialData = testData.slice(0, 5)
+
+    // Track the cursor expressions sent to loadSubset
+    // Note: cursor expressions are now passed separately from where (whereFrom/whereCurrent/lastKey)
+    const loadSubsetCursors: Array<any> = []
+
+    const sourceCollection = createCollection(
+      mockSyncCollectionOptions<TestItemWithDate>({
+        id: `test-date-precision-query`,
+        getKey: (item) => item.id,
+        initialData,
+        autoIndex: `eager`,
+        syncMode: `on-demand`,
+        sync: {
+          sync: ({ begin, write, commit, markReady }) => {
+            begin()
+            initialData.forEach((item) => {
+              write({ type: `insert`, value: item })
+            })
+            commit()
+            markReady()
+
+            return {
+              loadSubset: (options) => {
+                // Capture the cursor for inspection (now contains whereFrom/whereCurrent/lastKey)
+                loadSubsetCursors.push(options.cursor)
+
+                return new Promise<void>((resolve) => {
+                  setTimeout(() => {
+                    begin()
+                    const sortedData = [...testData].sort(
+                      (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+                    )
+
+                    let filteredData = sortedData
+                    if (options.where) {
+                      try {
+                        const filterFn = createFilterFunctionFromExpression(
+                          options.where,
+                        )
+                        filteredData = sortedData.filter(filterFn)
+                      } catch {
+                        filteredData = sortedData
+                      }
+                    }
+
+                    // Apply cursor expressions if present
+                    if (options.cursor) {
+                      const { whereFrom, whereCurrent } = options.cursor
+                      try {
+                        const whereFromFn =
+                          createFilterFunctionFromExpression(whereFrom)
+                        const fromData = filteredData.filter(whereFromFn)
+
+                        const whereCurrentFn =
+                          createFilterFunctionFromExpression(whereCurrent)
+                        const currentData = filteredData.filter(whereCurrentFn)
+
+                        // Combine and deduplicate
+                        const seenIds = new Set<number>()
+                        filteredData = []
+                        for (const item of currentData) {
+                          if (!seenIds.has(item.id)) {
+                            seenIds.add(item.id)
+                            filteredData.push(item)
+                          }
+                        }
+                        for (const item of fromData) {
+                          if (!seenIds.has(item.id)) {
+                            seenIds.add(item.id)
+                            filteredData.push(item)
+                          }
+                        }
+                        filteredData.sort(
+                          (a, b) =>
+                            a.createdAt.getTime() - b.createdAt.getTime(),
+                        )
+                      } catch (error) {
+                        console.log(`Error applying cursor:`, error)
+                      }
+                    }
+
+                    const { limit } = options
+                    const dataToLoad = limit
+                      ? filteredData.slice(0, limit)
+                      : filteredData
+
+                    dataToLoad.forEach((item) => {
+                      write({ type: `insert`, value: item })
+                    })
+
+                    commit()
+                    resolve()
+                  }, 10)
+                })
+              },
+            }
+          },
+        },
+      }),
+    )
+
+    const collection = createLiveQueryCollection((q) =>
+      q
+        .from({ items: sourceCollection })
+        .where(({ items }) => eq(items.keep, true))
+        .orderBy(({ items }) => items.createdAt, `asc`)
+        .offset(0)
+        .limit(5)
+        .select(({ items }) => ({
+          id: items.id,
+          createdAt: items.createdAt,
+          keep: items.keep,
+        })),
+    )
+    await collection.preload()
+
+    // First page loads
+    const results = Array.from(collection.values()).sort((a, b) => a.id - b.id)
+    expect(results.map((r) => r.id)).toEqual([1, 2, 3, 4, 5])
+
+    // Clear tracked cursors before moving to next page
+    loadSubsetCursors.length = 0
+
+    // Move to next page - this should trigger the Date precision handling
+    const moveToSecondPage = collection.utils.setWindow({ offset: 5, limit: 5 })
+    await moveToSecondPage
+
+    // Find the cursor that contains the "whereCurrent" expression (the minValue query)
+    // With the fix, whereCurrent should be: and(gte(createdAt, baseTime), lt(createdAt, baseTime+1ms))
+    // Without the fix, this would be: eq(createdAt, baseTime)
+    const cursorWithDateRange = loadSubsetCursors.find((cursor) => {
+      if (!cursor?.whereCurrent) return false
+      const whereCurrent = cursor.whereCurrent
+      // Check if whereCurrent is an 'and' with 'gte' and 'lt' (the fix)
+      if (whereCurrent.name === `and` && whereCurrent.args?.length === 2) {
+        const [first, second] = whereCurrent.args
+        return first?.name === `gte` && second?.name === `lt`
+      }
+      return false
+    })
+
+    // The fix should produce a range query (and(gte, lt)) for Date values
+    // instead of an exact equality query (eq)
+    expect(cursorWithDateRange).toBeDefined()
+    const equalValuesQuery = cursorWithDateRange.whereCurrent
+    expect(equalValuesQuery.name).toBe(`and`)
+    expect(equalValuesQuery.args[0].name).toBe(`gte`)
+    expect(equalValuesQuery.args[1].name).toBe(`lt`)
+
+    // Verify the range is exactly 1ms
+    const gteValue = equalValuesQuery.args[0].args[1].value
+    const ltValue = equalValuesQuery.args[1].args[1].value
+    expect(gteValue).toBeInstanceOf(Date)
+    expect(ltValue).toBeInstanceOf(Date)
+    expect(ltValue.getTime() - gteValue.getTime()).toBe(1) // 1ms difference
+  })
+})
diff --git a/packages/db/tests/query/predicate-utils.test.ts b/packages/db/tests/query/predicate-utils.test.ts
new file mode 100644
index 000000000..0cb14ec20
--- /dev/null
+++ b/packages/db/tests/query/predicate-utils.test.ts
@@ -0,0 +1,1388 @@
+import { describe, expect, it } from 'vitest'
+import {
+  isLimitSubset,
+  isOffsetLimitSubset,
+  isOrderBySubset,
+  isPredicateSubset,
+  isWhereSubset,
+  minusWherePredicates,
+  unionWherePredicates,
+} from '../../src/query/predicate-utils'
+import { Func, PropRef, Value } from '../../src/query/ir'
+import type {
+  BasicExpression,
+  OrderBy,
+  OrderByClause,
+} from '../../src/query/ir'
+import type { LoadSubsetOptions } from '../../src/types'
+
+// Helper functions to build expressions more easily
+function ref(path: string | Array<string>): PropRef {
+  return new PropRef(typeof path === `string` ? [path] : path)
+}
+
+function val(value: any): Value {
+  return new Value(value)
+}
+
+function func(name: string, ...args: Array<BasicExpression>): Func {
+  return new Func(name, args)
+}
+
+function eq(left: BasicExpression, right: BasicExpression): Func {
+  return func(`eq`, left, right)
+}
+
+function gt(left: BasicExpression, right: BasicExpression): Func {
+  return func(`gt`, left, right)
+}
+
+function gte(left: BasicExpression, right: BasicExpression): Func {
+  return func(`gte`, left, right)
+}
+
+function lt(left: BasicExpression, right: BasicExpression): Func {
+  return func(`lt`, left, right)
+}
+
+function lte(left: BasicExpression, right: BasicExpression): Func {
+  return func(`lte`, left, right)
+}
+
+function and(...args: Array<BasicExpression>): Func {
+  return func(`and`, ...args)
+}
+
+function or(...args: Array<BasicExpression>): Func {
+  return func(`or`, ...args)
+}
+
+function inOp(left: BasicExpression, values: Array<any>): Func {
+  return func(`in`, left, val(values))
+}
+
+function orderByClause(
+  expression: BasicExpression,
+  direction: `asc` | `desc` = `asc`,
+): OrderByClause {
+  return {
+    expression,
+    compareOptions: {
+      direction,
+      nulls: `last`,
+      stringSort: `lexical`,
+    },
+  }
+}
+
+describe(`isWhereSubset`, () => {
+  describe(`basic cases`, () => {
+    it(`should return true for both undefined (all data is subset of all data)`, () => {
+      expect(isWhereSubset(undefined, undefined)).toBe(true)
+    })
+
+    it(`should return false for undefined subset with constrained superset`, () => {
+      // Requesting ALL data but only loaded SOME data = NOT subset
+      expect(isWhereSubset(undefined, gt(ref(`age`), val(10)))).toBe(false)
+    })
+
+    it(`should return true for constrained subset with undefined superset`, () => {
+      // Loaded ALL data, so any constrained subset is covered
+      expect(isWhereSubset(gt(ref(`age`), val(20)), undefined)).toBe(true)
+    })
+
+    it(`should return true for identical expressions`, () => {
+      const expr = gt(ref(`age`), val(10))
+      expect(isWhereSubset(expr, expr)).toBe(true)
+    })
+
+    it(`should return true for structurally equal expressions`, () => {
+      expect(
+        isWhereSubset(gt(ref(`age`), val(10)), gt(ref(`age`), val(10))),
+      ).toBe(true)
+    })
+
+    it(`should return true when subset is false`, () => {
+      // When subset is false the result will always be the empty set
+      // and the empty set is a subset of any set
+      expect(isWhereSubset(val(false), gt(ref(`age`), val(10)))).toBe(true)
+    })
+  })
+
+  describe(`comparison operators`, () => {
+    it(`should handle gt: age > 20 is subset of age > 10`, () => {
+      expect(
+        isWhereSubset(gt(ref(`age`), val(20)), gt(ref(`age`), val(10))),
+      ).toBe(true)
+    })
+
+    it(`should handle gt: age > 10 is NOT subset of age > 20`, () => {
+      expect(
+        isWhereSubset(gt(ref(`age`), val(10)), gt(ref(`age`), val(20))),
+      ).toBe(false)
+    })
+
+    it(`should handle gte: age >= 20 is subset of age >= 10`, () => {
+      expect(
+        isWhereSubset(gte(ref(`age`), val(20)), gte(ref(`age`), val(10))),
+      ).toBe(true)
+    })
+
+    it(`should handle lt: age < 10 is subset of age < 20`, () => {
+      expect(
+        isWhereSubset(lt(ref(`age`), val(10)), lt(ref(`age`), val(20))),
+      ).toBe(true)
+    })
+
+    it(`should handle lt: age < 20 is NOT subset of age < 10`, () => {
+      expect(
+        isWhereSubset(lt(ref(`age`), val(20)), lt(ref(`age`), val(10))),
+      ).toBe(false)
+    })
+
+    it(`should handle lte: age <= 10 is subset of age <= 20`, () => {
+      expect(
+        isWhereSubset(lte(ref(`age`), val(10)), lte(ref(`age`), val(20))),
+      ).toBe(true)
+    })
+
+    it(`should handle eq: age = 15 is subset of age > 10`, () => {
+      expect(
+        isWhereSubset(eq(ref(`age`), val(15)), gt(ref(`age`), val(10))),
+      ).toBe(true)
+    })
+
+    it(`should handle eq: age = 5 is NOT subset of age > 10`, () => {
+      expect(
+        isWhereSubset(eq(ref(`age`), val(5)), gt(ref(`age`), val(10))),
+      ).toBe(false)
+    })
+
+    it(`should handle eq: age = 15 is subset of age >= 15`, () => {
+      expect(
+        isWhereSubset(eq(ref(`age`), val(15)), gte(ref(`age`), val(15))),
+      ).toBe(true)
+    })
+
+    it(`should handle eq: age = 15 is subset of age < 20`, () => {
+      expect(
+        isWhereSubset(eq(ref(`age`), val(15)), lt(ref(`age`), val(20))),
+      ).toBe(true)
+    })
+
+    it(`should handle mixed operators: gt vs gte`, () => {
+      expect(
+        isWhereSubset(gt(ref(`age`), val(10)), gte(ref(`age`), val(10))),
+      ).toBe(true)
+    })
+
+    it(`should handle mixed operators: gte vs gt`, () => {
+      expect(
+        isWhereSubset(gte(ref(`age`), val(11)), gt(ref(`age`), val(10))),
+      ).toBe(true)
+      expect(
+        isWhereSubset(gte(ref(`age`), val(10)), gt(ref(`age`), val(10))),
+      ).toBe(false)
+    })
+  })
+
+  describe(`IN operator`, () => {
+    it(`should handle eq vs in: age = 5 is subset of age IN [5, 10, 15]`, () => {
+      expect(
+        isWhereSubset(eq(ref(`age`), val(5)), inOp(ref(`age`), [5, 10, 15])),
+      ).toBe(true)
+    })
+
+    it(`should handle eq vs in: age = 20 is NOT subset of age IN [5, 10, 15]`, () => {
+      expect(
+        isWhereSubset(eq(ref(`age`), val(20)), inOp(ref(`age`), [5, 10, 15])),
+      ).toBe(false)
+    })
+
+    it(`should handle in vs in: [5, 10] is subset of [5, 10, 15]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [5, 10]), inOp(ref(`age`), [5, 10, 15])),
+      ).toBe(true)
+    })
+
+    it(`should handle in vs in: [5, 20] is NOT subset of [5, 10, 15]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [5, 20]), inOp(ref(`age`), [5, 10, 15])),
+      ).toBe(false)
+    })
+
+    it(`should handle empty IN array: age IN [] is subset of age IN []`, () => {
+      expect(isWhereSubset(inOp(ref(`age`), []), inOp(ref(`age`), []))).toBe(
+        true,
+      )
+    })
+
+    it(`should handle empty IN array: age IN [] is subset of age IN [5, 10]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), []), inOp(ref(`age`), [5, 10])),
+      ).toBe(true)
+    })
+
+    it(`should handle empty IN array: age IN [5, 10] is NOT subset of age IN []`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [5, 10]), inOp(ref(`age`), [])),
+      ).toBe(false)
+    })
+
+    it(`should handle singleton IN array: age = 5 is subset of age IN [5]`, () => {
+      expect(isWhereSubset(eq(ref(`age`), val(5)), inOp(ref(`age`), [5]))).toBe(
+        true,
+      )
+    })
+
+    it(`should handle singleton IN array: age = 10 is NOT subset of age IN [5]`, () => {
+      expect(
+        isWhereSubset(eq(ref(`age`), val(10)), inOp(ref(`age`), [5])),
+      ).toBe(false)
+    })
+
+    it(`should handle singleton IN array: age IN [5] is subset of age IN [5, 10, 15]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [5]), inOp(ref(`age`), [5, 10, 15])),
+      ).toBe(true)
+    })
+
+    it(`should handle singleton IN array: age IN [20] is NOT subset of age IN [5, 10, 15]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [20]), inOp(ref(`age`), [5, 10, 15])),
+      ).toBe(false)
+    })
+
+    it(`should handle singleton IN array: age IN [5, 10, 15] is NOT subset of age IN [5]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [5, 10, 15]), inOp(ref(`age`), [5])),
+      ).toBe(false)
+    })
+  })
+
+  describe(`AND combinations`, () => {
+    it(`should handle AND in subset: (A AND B) is subset of A`, () => {
+      expect(
+        isWhereSubset(
+          and(gt(ref(`age`), val(10)), eq(ref(`status`), val(`active`))),
+          gt(ref(`age`), val(10)),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should handle AND in subset: (A AND B) is NOT subset of C (different field)`, () => {
+      expect(
+        isWhereSubset(
+          and(gt(ref(`age`), val(10)), eq(ref(`status`), val(`active`))),
+          eq(ref(`name`), val(`John`)),
+        ),
+      ).toBe(false)
+    })
+
+    it(`should handle AND in superset: A is subset of (A AND B) is false (superset is more restrictive)`, () => {
+      expect(
+        isWhereSubset(
+          gt(ref(`age`), val(10)),
+          and(gt(ref(`age`), val(10)), eq(ref(`status`), val(`active`))),
+        ),
+      ).toBe(false)
+    })
+
+    it(`should handle AND in both: (age > 20 AND status = 'active') is subset of (age > 10 AND status = 'active')`, () => {
+      expect(
+        isWhereSubset(
+          and(gt(ref(`age`), val(20)), eq(ref(`status`), val(`active`))),
+          and(gt(ref(`age`), val(10)), eq(ref(`status`), val(`active`))),
+        ),
+      ).toBe(true)
+    })
+  })
+
+  describe(`OR combinations`, () => {
+    it(`should handle OR in superset: A is subset of (A OR B)`, () => {
+      expect(
+        isWhereSubset(
+          gt(ref(`age`), val(10)),
+          or(gt(ref(`age`), val(10)), eq(ref(`status`), val(`active`))),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should return false when subset doesn't imply any branch of OR superset`, () => {
+      expect(
+        isWhereSubset(
+          eq(ref(`age`), val(10)),
+          or(gt(ref(`age`), val(10)), lt(ref(`age`), val(5))),
+        ),
+      ).toBe(false)
+    })
+
+    it(`should handle OR in subset: (A OR B) is subset of C only if both A and B are subsets of C`, () => {
+      expect(
+        isWhereSubset(
+          or(gt(ref(`age`), val(20)), gt(ref(`age`), val(30))),
+          gt(ref(`age`), val(10)),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should handle OR in both: (age > 20 OR status = 'active') is subset of (age > 10 OR status = 'active')`, () => {
+      expect(
+        isWhereSubset(
+          or(gt(ref(`age`), val(20)), eq(ref(`status`), val(`active`))),
+          or(gt(ref(`age`), val(10)), eq(ref(`status`), val(`active`))),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should handle OR in subset: (A OR B) is NOT subset of C if either is not a subset`, () => {
+      expect(
+        isWhereSubset(
+          or(gt(ref(`age`), val(20)), lt(ref(`age`), val(5))),
+          gt(ref(`age`), val(10)),
+        ),
+      ).toBe(false)
+    })
+  })
+
+  describe(`different fields`, () => {
+    it(`should return false for different fields with no relationship`, () => {
+      expect(
+        isWhereSubset(gt(ref(`age`), val(20)), gt(ref(`salary`), val(1000))),
+      ).toBe(false)
+    })
+  })
+
+  describe(`Date support`, () => {
+    const date1 = new Date(`2024-01-01`)
+    const date2 = new Date(`2024-01-15`)
+    const date3 = new Date(`2024-02-01`)
+
+    it(`should handle Date equality`, () => {
+      expect(
+        isWhereSubset(
+          eq(ref(`createdAt`), val(date2)),
+          eq(ref(`createdAt`), val(date2)),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should handle Date range comparisons: date > 2024-01-15 is subset of date > 2024-01-01`, () => {
+      expect(
+        isWhereSubset(
+          gt(ref(`createdAt`), val(date2)),
+          gt(ref(`createdAt`), val(date1)),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should handle Date range comparisons: date < 2024-01-15 is subset of date < 2024-02-01`, () => {
+      expect(
+        isWhereSubset(
+          lt(ref(`createdAt`), val(date2)),
+          lt(ref(`createdAt`), val(date3)),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should handle Date equality vs range: date = 2024-01-15 is subset of date > 2024-01-01`, () => {
+      expect(
+        isWhereSubset(
+          eq(ref(`createdAt`), val(date2)),
+          gt(ref(`createdAt`), val(date1)),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should handle Date equality vs IN: date = 2024-01-15 is subset of date IN [2024-01-01, 2024-01-15, 2024-02-01]`, () => {
+      expect(
+        isWhereSubset(
+          eq(ref(`createdAt`), val(date2)),
+          inOp(ref(`createdAt`), [date1, date2, date3]),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should handle Date IN subset: date IN [2024-01-01, 2024-01-15] is subset of date IN [2024-01-01, 2024-01-15, 2024-02-01]`, () => {
+      expect(
+        isWhereSubset(
+          inOp(ref(`createdAt`), [date1, date2]),
+          inOp(ref(`createdAt`), [date1, date2, date3]),
+        ),
+      ).toBe(true)
+    })
+
+    it(`should return false when Date not in IN set`, () => {
+      expect(
+        isWhereSubset(
+          eq(ref(`createdAt`), val(date1)),
+          inOp(ref(`createdAt`), [date2, date3]),
+        ),
+      ).toBe(false)
+    })
+  })
+})
+
+describe(`unionWherePredicates`, () => {
+  describe(`basic cases`, () => {
+    it(`should return false for empty array`, () => {
+      const result = unionWherePredicates([])
+      expect(result.type).toBe(`val`)
+      expect((result as Value).value).toBe(false)
+    })
+
+    it(`should return the single predicate as-is`, () => {
+      const pred = gt(ref(`age`), val(10))
+      const result = unionWherePredicates([pred])
+      expect(result).toBe(pred)
+    })
+  })
+
+  describe(`same field comparisons`, () => {
+    it(`should take least restrictive for gt: age > 10 OR age > 20 → age > 10`, () => {
+      const result = unionWherePredicates([
+        gt(ref(`age`), val(10)),
+        gt(ref(`age`), val(20)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`gt`)
+      const field = (result as Func).args[1] as Value
+      expect(field.value).toBe(10)
+    })
+
+    it(`should take least restrictive for gte: age >= 10 OR age >= 20 → age >= 10`, () => {
+      const result = unionWherePredicates([
+        gte(ref(`age`), val(10)),
+        gte(ref(`age`), val(20)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`gte`)
+      const field = (result as Func).args[1] as Value
+      expect(field.value).toBe(10)
+    })
+
+    it(`should take least restrictive for lt: age < 20 OR age < 10 → age < 20`, () => {
+      const result = unionWherePredicates([
+        lt(ref(`age`), val(20)),
+        lt(ref(`age`), val(10)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`lt`)
+      const field = (result as Func).args[1] as Value
+      expect(field.value).toBe(20)
+    })
+
+    it(`should combine eq into IN: age = 5 OR age = 10 → age IN [5, 10]`, () => {
+      const result = unionWherePredicates([
+        eq(ref(`age`), val(5)),
+        eq(ref(`age`), val(10)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`in`)
+      const values = ((result as Func).args[1] as Value).value
+      expect(values).toContain(5)
+      expect(values).toContain(10)
+      expect(values.length).toBe(2)
+    })
+
+    it(`should fold IN and equality into single IN: age IN [1,2] OR age = 3 → age IN [1,2,3]`, () => {
+      const result = unionWherePredicates([
+        inOp(ref(`age`), [1, 2]),
+        eq(ref(`age`), val(3)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`in`)
+      const values = ((result as Func).args[1] as Value).value
+      expect(values).toContain(1)
+      expect(values).toContain(2)
+      expect(values).toContain(3)
+      expect(values.length).toBe(3)
+    })
+
+    it(`should handle gte and gt together: age > 10 OR age >= 15 → age > 10`, () => {
+      const result = unionWherePredicates([
+        gt(ref(`age`), val(10)),
+        gte(ref(`age`), val(15)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`gt`)
+      const field = (result as Func).args[1] as Value
+      expect(field.value).toBe(10)
+    })
+  })
+
+  describe(`different fields`, () => {
+    it(`should combine with OR: age > 10 OR status = 'active'`, () => {
+      const result = unionWherePredicates([
+        gt(ref(`age`), val(10)),
+        eq(ref(`status`), val(`active`)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`or`)
+      expect((result as Func).args.length).toBe(2)
+    })
+  })
+
+  describe(`flatten OR`, () => {
+    it(`should flatten nested ORs`, () => {
+      const result = unionWherePredicates([
+        or(gt(ref(`age`), val(10)), eq(ref(`status`), val(`active`))),
+        eq(ref(`name`), val(`John`)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`or`)
+      expect((result as Func).args.length).toBe(3)
+    })
+  })
+
+  describe(`Date support`, () => {
+    const date1 = new Date(`2024-01-01`)
+    const date2 = new Date(`2024-01-15`)
+    const date3 = new Date(`2024-02-01`)
+
+    it(`should combine Date equalities into IN: date = date1 OR date = date2 → date IN [date1, date2]`, () => {
+      const result = unionWherePredicates([
+        eq(ref(`createdAt`), val(date1)),
+        eq(ref(`createdAt`), val(date2)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`in`)
+      const values = ((result as Func).args[1] as Value).value
+      expect(values.length).toBe(2)
+      expect(values).toContainEqual(date1)
+      expect(values).toContainEqual(date2)
+    })
+
+    it(`should fold Date IN and equality: date IN [date1,date2] OR date = date3 → date IN [date1,date2,date3]`, () => {
+      const result = unionWherePredicates([
+        inOp(ref(`createdAt`), [date1, date2]),
+        eq(ref(`createdAt`), val(date3)),
+      ])
+      expect(result.type).toBe(`func`)
+      expect((result as Func).name).toBe(`in`)
+      const values = ((result as Func).args[1] as Value).value
+      expect(values.length).toBe(3)
+      expect(values).toContainEqual(date1)
+      expect(values).toContainEqual(date2)
+      expect(values).toContainEqual(date3)
+    })
+  })
+})
+
+describe(`isOrderBySubset`, () => {
+  it(`should return true for undefined subset`, () => {
+    const orderBy: OrderBy = [orderByClause(ref(`age`), `asc`)]
+    expect(isOrderBySubset(undefined, orderBy)).toBe(true)
+    expect(isOrderBySubset([], orderBy)).toBe(true)
+  })
+
+  it(`should return false for undefined superset with non-empty subset`, () => {
+    const orderBy: OrderBy = [orderByClause(ref(`age`), `asc`)]
+    expect(isOrderBySubset(orderBy, undefined)).toBe(false)
+    expect(isOrderBySubset(orderBy, [])).toBe(false)
+  })
+
+  it(`should return true for identical orderBy`, () => {
+    const orderBy: OrderBy = [orderByClause(ref(`age`), `asc`)]
+    expect(isOrderBySubset(orderBy, orderBy)).toBe(true)
+  })
+
+  it(`should return true when subset is prefix of superset`, () => {
+    const subset: OrderBy = [orderByClause(ref(`age`), `asc`)]
+    const superset: OrderBy = [
+      orderByClause(ref(`age`), `asc`),
+      orderByClause(ref(`name`), `desc`),
+    ]
+    expect(isOrderBySubset(subset, superset)).toBe(true)
+  })
+
+  it(`should return false when subset is not a prefix`, () => {
+    const subset: OrderBy = [orderByClause(ref(`name`), `desc`)]
+    const superset: OrderBy = [
+      orderByClause(ref(`age`), `asc`),
+      orderByClause(ref(`name`), `desc`),
+    ]
+    expect(isOrderBySubset(subset, superset)).toBe(false)
+  })
+
+  it(`should return false when directions differ`, () => {
+    const subset: OrderBy = [orderByClause(ref(`age`), `desc`)]
+    const superset: OrderBy = [orderByClause(ref(`age`), `asc`)]
+    expect(isOrderBySubset(subset, superset)).toBe(false)
+  })
+
+  it(`should return false when subset is longer than superset`, () => {
+    const subset: OrderBy = [
+      orderByClause(ref(`age`), `asc`),
+      orderByClause(ref(`name`), `desc`),
+      orderByClause(ref(`status`), `asc`),
+    ]
+    const superset: OrderBy = [
+      orderByClause(ref(`age`), `asc`),
+      orderByClause(ref(`name`), `desc`),
+    ]
+    expect(isOrderBySubset(subset, superset)).toBe(false)
+  })
+})
+
+describe(`isLimitSubset`, () => {
+  it(`should return false for undefined subset with limited superset (requesting all data but only have limited)`, () => {
+    expect(isLimitSubset(undefined, 10)).toBe(false)
+  })
+
+  it(`should return true for undefined subset with undefined superset (requesting all data and have all data)`, () => {
+    expect(isLimitSubset(undefined, undefined)).toBe(true)
+  })
+
+  it(`should return true for undefined superset`, () => {
+    expect(isLimitSubset(10, undefined)).toBe(true)
+  })
+
+  it(`should return true when subset <= superset`, () => {
+    expect(isLimitSubset(10, 20)).toBe(true)
+    expect(isLimitSubset(10, 10)).toBe(true)
+  })
+
+  it(`should return false when subset > superset`, () => {
+    expect(isLimitSubset(20, 10)).toBe(false)
+  })
+})
+
+describe(`isOffsetLimitSubset`, () => {
+  it(`should return true when subset range is within superset range (same offset)`, () => {
+    expect(
+      isOffsetLimitSubset({ offset: 0, limit: 5 }, { offset: 0, limit: 10 }),
+    ).toBe(true)
+    expect(
+      isOffsetLimitSubset({ offset: 0, limit: 10 }, { offset: 0, limit: 10 }),
+    ).toBe(true)
+  })
+
+  it(`should return true when subset starts later but is still within superset range`, () => {
+    // superset loads rows [0, 10), subset loads rows [5, 10) - subset is within superset
+    expect(
+      isOffsetLimitSubset({ offset: 5, limit: 5 }, { offset: 0, limit: 10 }),
+    ).toBe(true)
+  })
+
+  it(`should return false when subset extends beyond superset range`, () => {
+    // superset loads rows [0, 10), subset loads rows [5, 15) - subset extends beyond
+    expect(
+      isOffsetLimitSubset({ offset: 5, limit: 10 }, { offset: 0, limit: 10 }),
+    ).toBe(false)
+  })
+
+  it(`should return false when subset is completely outside superset range`, () => {
+    // superset loads rows [0, 10), subset loads rows [20, 30) - no overlap
+    expect(
+      isOffsetLimitSubset({ offset: 20, limit: 10 }, { offset: 0, limit: 10 }),
+    ).toBe(false)
+  })
+
+  it(`should return false when superset starts after subset`, () => {
+    // superset loads rows [10, 20), subset loads rows [0, 10) - superset starts too late
+    expect(
+      isOffsetLimitSubset({ offset: 0, limit: 10 }, { offset: 10, limit: 10 }),
+    ).toBe(false)
+  })
+
+  it(`should return true when superset is unlimited`, () => {
+    expect(isOffsetLimitSubset({ offset: 0, limit: 10 }, { offset: 0 })).toBe(
+      true,
+    )
+    expect(isOffsetLimitSubset({ offset: 20, limit: 10 }, { offset: 0 })).toBe(
+      true,
+    )
+  })
+
+  it(`should return false when superset is unlimited but starts after subset`, () => {
+    // superset loads rows [10, ∞), subset loads rows [0, 10) - superset starts too late
+    expect(isOffsetLimitSubset({ offset: 0, limit: 10 }, { offset: 10 })).toBe(
+      false,
+    )
+  })
+
+  it(`should return false when subset is unlimited but superset has a limit`, () => {
+    expect(isOffsetLimitSubset({ offset: 0 }, { offset: 0, limit: 10 })).toBe(
+      false,
+    )
+  })
+
+  it(`should return true when both are unlimited and superset starts at or before subset`, () => {
+    expect(isOffsetLimitSubset({ offset: 10 }, { offset: 0 })).toBe(true)
+    expect(isOffsetLimitSubset({ offset: 10 }, { offset: 10 })).toBe(true)
+  })
+
+  it(`should return false when both are unlimited but superset starts after subset`, () => {
+    expect(isOffsetLimitSubset({ offset: 0 }, { offset: 10 })).toBe(false)
+  })
+
+  it(`should default offset to 0 when undefined`, () => {
+    expect(isOffsetLimitSubset({ limit: 5 }, { limit: 10 })).toBe(true)
+    expect(isOffsetLimitSubset({ offset: 0, limit: 5 }, { limit: 10 })).toBe(
+      true,
+    )
+    expect(isOffsetLimitSubset({ limit: 5 }, { offset: 0, limit: 10 })).toBe(
+      true,
+    )
+  })
+})
+
+describe(`isPredicateSubset`, () => {
+  it(`should check all components for unlimited superset`, () => {
+    // For unlimited supersets, where-subset logic applies
+    const subset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(20)),
+      orderBy: [orderByClause(ref(`age`), `asc`)],
+      limit: 10,
+    }
+    const superset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(10)),
+      orderBy: [
+        orderByClause(ref(`age`), `asc`),
+        orderByClause(ref(`name`), `desc`),
+      ],
+      // No limit - unlimited superset
+    }
+    expect(isPredicateSubset(subset, superset)).toBe(true)
+  })
+
+  it(`should require equal where clauses for limited supersets`, () => {
+    // For limited supersets, where clauses must be EQUAL
+    const sameWhere = gt(ref(`age`), val(10))
+
+    const subset: LoadSubsetOptions = {
+      where: sameWhere,
+      orderBy: [orderByClause(ref(`age`), `asc`)],
+      limit: 5,
+    }
+    const superset: LoadSubsetOptions = {
+      where: sameWhere, // Same where clause
+      orderBy: [
+        orderByClause(ref(`age`), `asc`),
+        orderByClause(ref(`name`), `desc`),
+      ],
+      limit: 20,
+    }
+    expect(isPredicateSubset(subset, superset)).toBe(true)
+  })
+
+  it(`should return false for limited superset with different where clause`, () => {
+    // Even if subset's where is more restrictive, it can't be a subset
+    // of a limited superset with a different where clause.
+    // The top N items of "age > 20" may not be in the top M items of "age > 10"
+    const subset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(20)), // More restrictive
+      orderBy: [orderByClause(ref(`age`), `asc`)],
+      limit: 5,
+    }
+    const superset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(10)), // Less restrictive but LIMITED
+      orderBy: [orderByClause(ref(`age`), `asc`)],
+      limit: 20,
+    }
+    // This should be FALSE because the top 5 of "age > 20"
+    // might include items outside the top 20 of "age > 10"
+    expect(isPredicateSubset(subset, superset)).toBe(false)
+  })
+
+  it(`should return false for limited superset with no where vs subset with where`, () => {
+    // This is the reported bug case: pagination with search filter
+    const subset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(20)), // Has a filter
+      orderBy: [orderByClause(ref(`age`), `asc`)],
+      limit: 10,
+    }
+    const superset: LoadSubsetOptions = {
+      where: undefined, // No filter but LIMITED
+      orderBy: [orderByClause(ref(`age`), `asc`)],
+      limit: 10,
+    }
+    // The filtered results might include items outside the unfiltered top 10
+    expect(isPredicateSubset(subset, superset)).toBe(false)
+  })
+
+  it(`should return false if where is not subset`, () => {
+    const subset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(5)),
+      limit: 10,
+    }
+    const superset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(10)),
+      limit: 20,
+    }
+    expect(isPredicateSubset(subset, superset)).toBe(false)
+  })
+
+  it(`should return false if orderBy is not subset`, () => {
+    const subset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(20)),
+      orderBy: [orderByClause(ref(`name`), `desc`)],
+    }
+    const superset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(10)),
+      orderBy: [orderByClause(ref(`age`), `asc`)],
+    }
+    expect(isPredicateSubset(subset, superset)).toBe(false)
+  })
+
+  it(`should return false if limit is not subset`, () => {
+    const subset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(20)),
+      limit: 30,
+    }
+    const superset: LoadSubsetOptions = {
+      where: gt(ref(`age`), val(10)),
+      limit: 20,
+    }
+    expect(isPredicateSubset(subset, superset)).toBe(false)
+  })
+
+  describe(`with offset`, () => {
+    it(`should return true when subset offset+limit is within superset range`, () => {
+      const sameWhere = gt(ref(`age`), val(10))
+      const subset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 5,
+        limit: 5,
+      }
+      const superset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 0,
+        limit: 10,
+      }
+      // subset loads rows [5, 10), superset loads rows [0, 10) - subset is within
+      expect(isPredicateSubset(subset, superset)).toBe(true)
+    })
+
+    it(`should return false when subset is at different offset outside superset range`, () => {
+      const sameWhere = gt(ref(`age`), val(10))
+      const subset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 20,
+        limit: 10,
+      }
+      const superset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 0,
+        limit: 10,
+      }
+      // subset loads rows [20, 30), superset loads rows [0, 10) - no overlap
+      expect(isPredicateSubset(subset, superset)).toBe(false)
+    })
+
+    it(`should return false when subset extends beyond superset even with same where`, () => {
+      const sameWhere = gt(ref(`age`), val(10))
+      const subset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 5,
+        limit: 10,
+      }
+      const superset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 0,
+        limit: 10,
+      }
+      // subset loads rows [5, 15), superset loads rows [0, 10) - subset extends beyond
+      expect(isPredicateSubset(subset, superset)).toBe(false)
+    })
+
+    it(`should return true for unlimited superset with any subset offset`, () => {
+      const sameWhere = gt(ref(`age`), val(10))
+      const subset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 100,
+        limit: 10,
+      }
+      const superset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        // No limit - unlimited
+      }
+      expect(isPredicateSubset(subset, superset)).toBe(true)
+    })
+
+    it(`should return false when superset has offset that starts after subset needs`, () => {
+      const sameWhere = gt(ref(`age`), val(10))
+      const subset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 0,
+        limit: 10,
+      }
+      const superset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 5,
+        limit: 10,
+      }
+      // subset needs rows [0, 10), superset only has rows [5, 15)
+      expect(isPredicateSubset(subset, superset)).toBe(false)
+    })
+
+    it(`should handle pagination correctly - page 2 not subset of page 1`, () => {
+      const sameWhere = gt(ref(`age`), val(10))
+      // Page 1: offset 0, limit 10
+      const page1: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 0,
+        limit: 10,
+      }
+      // Page 2: offset 10, limit 10
+      const page2: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 10,
+        limit: 10,
+      }
+      // Page 2 is NOT a subset of page 1 (different rows)
+      expect(isPredicateSubset(page2, page1)).toBe(false)
+      // Page 1 is NOT a subset of page 2 (different rows)
+      expect(isPredicateSubset(page1, page2)).toBe(false)
+    })
+
+    it(`should return true when superset covers multiple pages`, () => {
+      const sameWhere = gt(ref(`age`), val(10))
+      // Superset: offset 0, limit 30 (covers pages 1-3)
+      const superset: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 0,
+        limit: 30,
+      }
+      // Page 2: offset 10, limit 10
+      const page2: LoadSubsetOptions = {
+        where: sameWhere,
+        orderBy: [orderByClause(ref(`age`), `asc`)],
+        offset: 10,
+        limit: 10,
+      }
+      // Page 2 IS a subset of superset (rows 10-19 within 0-29)
+      expect(isPredicateSubset(page2, superset)).toBe(true)
+    })
+  })
+})
+
+describe(`minusWherePredicates`, () => {
+  describe(`basic cases`, () => {
+    it(`should return original predicate when nothing to subtract`, () => {
+      const pred = gt(ref(`age`), val(10))
+      const result = minusWherePredicates(pred, undefined)
+
+      expect(result).toEqual(pred)
+    })
+
+    it(`should return null when from is undefined (can't simplify NOT(B))`, () => {
+      const subtract = gt(ref(`age`), val(10))
+      const result = minusWherePredicates(undefined, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `not`,
+        args: [subtract],
+      })
+    })
+
+    it(`should return empty set when from is subset of subtract`, () => {
+      const from = gt(ref(`age`), val(20)) // age > 20
+      const subtract = gt(ref(`age`), val(10)) // age > 10
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({ type: `val`, value: false })
+    })
+
+    it(`should return null when predicates are on different fields`, () => {
+      const from = gt(ref(`age`), val(10))
+      const subtract = eq(ref(`status`), val(`active`))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe(`IN minus IN`, () => {
+    it(`should compute set difference: IN [A,B,C,D] - IN [B,C] = IN [A,D]`, () => {
+      const from = inOp(ref(`status`), [`A`, `B`, `C`, `D`])
+      const subtract = inOp(ref(`status`), [`B`, `C`])
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `in`,
+        args: [ref(`status`), val([`A`, `D`])],
+      })
+    })
+
+    it(`should return empty set when all values are subtracted`, () => {
+      const from = inOp(ref(`status`), [`A`, `B`])
+      const subtract = inOp(ref(`status`), [`A`, `B`])
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({ type: `val`, value: false })
+    })
+
+    it(`should return original when no overlap`, () => {
+      const from = inOp(ref(`status`), [`A`, `B`])
+      const subtract = inOp(ref(`status`), [`C`, `D`])
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual(from)
+    })
+
+    it(`should collapse to equality when one value remains`, () => {
+      const from = inOp(ref(`status`), [`A`, `B`])
+      const subtract = inOp(ref(`status`), [`B`])
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `eq`,
+        args: [ref(`status`), val(`A`)],
+      })
+    })
+  })
+
+  describe(`IN minus equality`, () => {
+    it(`should remove value from IN: IN [A,B,C] - eq(B) = IN [A,C]`, () => {
+      const from = inOp(ref(`status`), [`A`, `B`, `C`])
+      const subtract = eq(ref(`status`), val(`B`))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `in`,
+        args: [ref(`status`), val([`A`, `C`])],
+      })
+    })
+
+    it(`should collapse to equality when one value remains`, () => {
+      const from = inOp(ref(`status`), [`A`, `B`])
+      const subtract = eq(ref(`status`), val(`A`))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `eq`,
+        args: [ref(`status`), val(`B`)],
+      })
+    })
+
+    it(`should return empty set when removing last value`, () => {
+      const from = inOp(ref(`status`), [`A`])
+      const subtract = eq(ref(`status`), val(`A`))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({ type: `val`, value: false })
+    })
+  })
+
+  describe(`equality minus equality`, () => {
+    it(`should return empty set when same value`, () => {
+      const from = eq(ref(`age`), val(15))
+      const subtract = eq(ref(`age`), val(15))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({ type: `val`, value: false })
+    })
+
+    it(`should return original when different values`, () => {
+      const from = eq(ref(`age`), val(15))
+      const subtract = eq(ref(`age`), val(20))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual(from)
+    })
+  })
+
+  describe(`range minus range - gt/gte`, () => {
+    it(`should compute difference: age > 10 - age > 20 = (age > 10 AND age <= 20)`, () => {
+      const from = gt(ref(`age`), val(10))
+      const subtract = gt(ref(`age`), val(20))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [gt(ref(`age`), val(10)), lte(ref(`age`), val(20))],
+      })
+    })
+
+    it(`should return original when no overlap: age > 20 - age > 10`, () => {
+      const from = gt(ref(`age`), val(20))
+      const subtract = gt(ref(`age`), val(10))
+      const result = minusWherePredicates(from, subtract)
+
+      // age > 20 is subset of age > 10, so result is empty
+      expect(result).toEqual({ type: `val`, value: false })
+    })
+
+    it(`should compute difference: age >= 10 - age >= 20 = (age >= 10 AND age < 20)`, () => {
+      const from = gte(ref(`age`), val(10))
+      const subtract = gte(ref(`age`), val(20))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [gte(ref(`age`), val(10)), lt(ref(`age`), val(20))],
+      })
+    })
+
+    it(`should compute difference: age > 10 - age >= 20 = (age > 10 AND age < 20)`, () => {
+      const from = gt(ref(`age`), val(10))
+      const subtract = gte(ref(`age`), val(20))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [gt(ref(`age`), val(10)), lt(ref(`age`), val(20))],
+      })
+    })
+
+    it(`should compute difference: age >= 10 - age > 20 = (age >= 10 AND age <= 20)`, () => {
+      const from = gte(ref(`age`), val(10))
+      const subtract = gt(ref(`age`), val(20))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [gte(ref(`age`), val(10)), lte(ref(`age`), val(20))],
+      })
+    })
+  })
+
+  describe(`range minus range - lt/lte`, () => {
+    it(`should compute difference: age < 30 - age < 20 = (age >= 20 AND age < 30)`, () => {
+      const from = lt(ref(`age`), val(30))
+      const subtract = lt(ref(`age`), val(20))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [gte(ref(`age`), val(20)), lt(ref(`age`), val(30))],
+      })
+    })
+
+    it(`should return original when no overlap: age < 20 - age < 30`, () => {
+      const from = lt(ref(`age`), val(20))
+      const subtract = lt(ref(`age`), val(30))
+      const result = minusWherePredicates(from, subtract)
+
+      // age < 20 is subset of age < 30, so result is empty
+      expect(result).toEqual({ type: `val`, value: false })
+    })
+
+    it(`should compute difference: age <= 30 - age <= 20 = (age > 20 AND age <= 30)`, () => {
+      const from = lte(ref(`age`), val(30))
+      const subtract = lte(ref(`age`), val(20))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [gt(ref(`age`), val(20)), lte(ref(`age`), val(30))],
+      })
+    })
+
+    it(`should compute difference: age < 30 - age <= 20 = (age > 20 AND age < 30)`, () => {
+      const from = lt(ref(`age`), val(30))
+      const subtract = lte(ref(`age`), val(20))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [gt(ref(`age`), val(20)), lt(ref(`age`), val(30))],
+      })
+    })
+
+    it(`should compute difference: age <= 30 - age < 20 = (age >= 20 AND age <= 30)`, () => {
+      const from = lte(ref(`age`), val(30))
+      const subtract = lt(ref(`age`), val(20))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [gte(ref(`age`), val(20)), lte(ref(`age`), val(30))],
+      })
+    })
+  })
+
+  describe(`common conditions`, () => {
+    it(`should handle common conditions: (age > 10 AND status = 'active') - (age > 20 AND status = 'active') = (age > 10 AND age <= 20 AND status = 'active')`, () => {
+      const from = and(
+        gt(ref(`age`), val(10)),
+        eq(ref(`status`), val(`active`)),
+      )
+      const subtract = and(
+        gt(ref(`age`), val(20)),
+        eq(ref(`status`), val(`active`)),
+      )
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [
+          eq(ref(`status`), val(`active`)), // common condition
+          gt(ref(`age`), val(10)),
+          lte(ref(`age`), val(20)),
+        ],
+      })
+    })
+
+    it(`should handle multiple common conditions`, () => {
+      const from = and(
+        gt(ref(`age`), val(10)),
+        eq(ref(`status`), val(`active`)),
+        eq(ref(`department`), val(`engineering`)),
+      )
+      const subtract = and(
+        gt(ref(`age`), val(20)),
+        eq(ref(`status`), val(`active`)),
+        eq(ref(`department`), val(`engineering`)),
+      )
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [
+          eq(ref(`status`), val(`active`)), // common condition
+          eq(ref(`department`), val(`engineering`)), // common condition
+          gt(ref(`age`), val(10)),
+          lte(ref(`age`), val(20)),
+        ],
+      })
+    })
+
+    it(`should handle IN with common conditions: (age IN [10,20,30] AND status = 'active') - (age IN [20,30] AND status = 'active') = (age IN [10] AND status = 'active')`, () => {
+      const from = and(
+        inOp(ref(`age`), [10, 20, 30]),
+        eq(ref(`status`), val(`active`)),
+      )
+      const subtract = and(
+        inOp(ref(`age`), [20, 30]),
+        eq(ref(`status`), val(`active`)),
+      )
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [
+          eq(ref(`status`), val(`active`)), // common condition
+          {
+            type: `func`,
+            name: `eq`,
+            args: [ref(`age`), val(10)],
+          },
+        ],
+      })
+    })
+
+    it(`should return null when common conditions exist but remaining difference cannot be simplified`, () => {
+      const from = and(
+        gt(ref(`age`), val(10)),
+        eq(ref(`status`), val(`active`)),
+      )
+      const subtract = and(
+        gt(ref(`name`), val(`Z`)),
+        eq(ref(`status`), val(`active`)),
+      )
+      const result = minusWherePredicates(from, subtract)
+
+      // Can't simplify age > 10 - name > 'Z' (different fields), so returns null
+      expect(result).toBeNull()
+    })
+  })
+
+  describe(`Date support`, () => {
+    it(`should handle Date IN minus Date IN`, () => {
+      const date1 = new Date(`2024-01-01`)
+      const date2 = new Date(`2024-01-15`)
+      const date3 = new Date(`2024-02-01`)
+
+      const from = inOp(ref(`createdAt`), [date1, date2, date3])
+      const subtract = inOp(ref(`createdAt`), [date2])
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `in`,
+        args: [ref(`createdAt`), val([date1, date3])],
+      })
+    })
+
+    it(`should handle Date range difference: date > 2024-01-01 - date > 2024-01-15`, () => {
+      const date1 = new Date(`2024-01-01`)
+      const date15 = new Date(`2024-01-15`)
+
+      const from = gt(ref(`createdAt`), val(date1))
+      const subtract = gt(ref(`createdAt`), val(date15))
+      const result = minusWherePredicates(from, subtract)
+
+      expect(result).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [
+          gt(ref(`createdAt`), val(date1)),
+          lte(ref(`createdAt`), val(date15)),
+        ],
+      })
+    })
+  })
+
+  describe(`real-world sync scenarios`, () => {
+    it(`should compute missing data range: need age > 10, already have age > 20`, () => {
+      const requested = gt(ref(`age`), val(10))
+      const alreadyLoaded = gt(ref(`age`), val(20))
+      const needToFetch = minusWherePredicates(requested, alreadyLoaded)
+
+      // Need to fetch: 10 < age <= 20
+      expect(needToFetch).toEqual({
+        type: `func`,
+        name: `and`,
+        args: [gt(ref(`age`), val(10)), lte(ref(`age`), val(20))],
+      })
+    })
+
+    it(`should compute missing IDs: need IN [1..100], already have IN [50..100]`, () => {
+      const allIds = Array.from({ length: 100 }, (_, i) => i + 1)
+      const loadedIds = Array.from({ length: 51 }, (_, i) => i + 50)
+
+      const requested = inOp(ref(`id`), allIds)
+      const alreadyLoaded = inOp(ref(`id`), loadedIds)
+      const needToFetch = minusWherePredicates(requested, alreadyLoaded)
+
+      // Need to fetch: ids 1..49
+      const expectedIds = Array.from({ length: 49 }, (_, i) => i + 1)
+      expect(needToFetch).toEqual({
+        type: `func`,
+        name: `in`,
+        args: [ref(`id`), val(expectedIds)],
+      })
+    })
+
+    it(`should return empty when all requested data is already loaded`, () => {
+      const requested = gt(ref(`age`), val(20))
+      const alreadyLoaded = gt(ref(`age`), val(10))
+      const needToFetch = minusWherePredicates(requested, alreadyLoaded)
+
+      // Requested is subset of already loaded - nothing more to fetch
+      expect(needToFetch).toEqual({ type: `val`, value: false })
+    })
+  })
+})
diff --git a/packages/db/tests/query/query-while-syncing.test.ts b/packages/db/tests/query/query-while-syncing.test.ts
index 81c57da3e..5616e08a8 100644
--- a/packages/db/tests/query/query-while-syncing.test.ts
+++ b/packages/db/tests/query/query-while-syncing.test.ts
@@ -1,7 +1,7 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
-import { createLiveQueryCollection, eq, gt } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { createTransaction } from "../../src/transactions.js"
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { createLiveQueryCollection, eq, gt } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { createTransaction } from '../../src/transactions.js'
 
 // Sample user type for tests
 type User = {
@@ -303,7 +303,7 @@ describe(`Query while syncing`, () => {
               .join(
                 { dept: departmentsCollection },
                 ({ user, dept }) => eq(user.department_id, dept.id),
-                `inner`
+                `inner`,
               )
               .select(({ user, dept }) => ({
                 user_name: user.name,
@@ -423,7 +423,7 @@ describe(`Query while syncing`, () => {
             q
               .from({ user: usersCollection })
               .leftJoin({ dept: departmentsCollection }, ({ user, dept }) =>
-                eq(user.department_id, dept.id)
+                eq(user.department_id, dept.id),
               )
               .select(({ user, dept }) => ({
                 user_name: user.name,
@@ -551,12 +551,12 @@ describe(`Query while syncing`, () => {
               .join(
                 { c2: collection2 },
                 ({ c1, c2 }) => eq(c1.id, c2.id),
-                `inner`
+                `inner`,
               )
               .join(
                 { c3: collection3 },
                 ({ c1, c3 }) => eq(c1.id, c3.id),
-                `inner`
+                `inner`,
               )
               .select(({ c1 }) => ({
                 id: c1.id,
@@ -882,7 +882,7 @@ describe(`Query while syncing`, () => {
               .join(
                 { dept: departmentsCollection },
                 ({ user, dept }) => eq(user.department_id, dept.id),
-                `inner`
+                `inner`,
               )
               .select(({ user, dept }) => ({
                 user_name: user.name,
diff --git a/packages/db/tests/query/scheduler.test.ts b/packages/db/tests/query/scheduler.test.ts
index a2b6026c5..adb85c979 100644
--- a/packages/db/tests/query/scheduler.test.ts
+++ b/packages/db/tests/query/scheduler.test.ts
@@ -1,11 +1,13 @@
-import { afterEach, describe, expect, it, vi } from "vitest"
-import { createCollection } from "../../src/collection/index.js"
-import { createLiveQueryCollection, eq } from "../../src/query/index.js"
-import { createTransaction } from "../../src/transactions.js"
-import { transactionScopedScheduler } from "../../src/scheduler.js"
-import { CollectionConfigBuilder } from "../../src/query/live/collection-config-builder.js"
-import type { FullSyncState } from "../../src/query/live/types.js"
-import type { SyncConfig } from "../../src/types.js"
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
+import { createLiveQueryCollection, eq, isNull } from '../../src/query/index.js'
+import { createTransaction } from '../../src/transactions.js'
+import { createOptimisticAction } from '../../src/optimistic-action.js'
+import { transactionScopedScheduler } from '../../src/scheduler.js'
+import { CollectionConfigBuilder } from '../../src/query/live/collection-config-builder.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+import type { FullSyncState } from '../../src/query/live/types.js'
+import type { SyncConfig } from '../../src/types.js'
 
 interface ChangeMessageLike {
   type: string
@@ -272,7 +274,7 @@ describe(`live query scheduler`, () => {
           .join(
             { right: liveQueryB },
             ({ left, right }) => eq(left.id, right.id),
-            `full`
+            `full`,
           )
           .select(({ left, right }) => ({
             left: left?.value,
@@ -359,7 +361,7 @@ describe(`live query scheduler`, () => {
           .join(
             { right: collectionB },
             ({ left, right }) => eq(left.id, right.id),
-            `full`
+            `full`,
           )
           .select(({ left, right }) => ({
             left: left?.value,
@@ -442,7 +444,7 @@ describe(`live query scheduler`, () => {
           .join(
             { right: collectionB },
             ({ left, right }) => eq(left.id, right.id),
-            `full`
+            `full`,
           )
           .select(({ left, right }) => ({
             left: left?.value,
@@ -524,4 +526,237 @@ describe(`live query scheduler`, () => {
 
     maybeRunGraphSpy.mockRestore()
   })
+
+  it(`should handle optimistic mutations with nested left joins without scheduler errors`, async () => {
+    // This test verifies that optimistic mutations on collections with nested live query
+    // collections using left joins complete successfully without scheduler errors.
+    //
+    // Expected behavior:
+    // 1. Collections are pre-populated with initialData (via mockSyncCollectionOptions)
+    // 2. Nested live query collections use left joins
+    // 3. An optimistic action updates an existing item using draft mutations
+    // 4. The scheduler should flush the transaction successfully without detecting unresolved dependencies
+
+    interface Account {
+      id: string
+      user_id: string
+      name: string
+    }
+
+    interface UserProfile {
+      id: string
+      profile: string
+    }
+
+    interface Team {
+      id: string
+      account_id: string
+      deleted_ts: string | null
+    }
+
+    // Use mockSyncCollectionOptions with initialData to match the failing test
+    // Note: mockSyncCollectionOptions already sets startSync: true internally
+    const accounts = createCollection<Account>(
+      mockSyncCollectionOptions({
+        id: `left-join-bug-accounts`,
+        getKey: (account) => account.id,
+        initialData: [
+          { id: `account-1`, user_id: `user-1`, name: `Account 1` },
+        ],
+      }),
+    )
+
+    const users = createCollection<UserProfile>(
+      mockSyncCollectionOptions({
+        id: `left-join-bug-users`,
+        getKey: (user) => user.id,
+        initialData: [{ id: `user-1`, profile: `Profile 1` }],
+      }),
+    )
+
+    const teams = createCollection<Team>(
+      mockSyncCollectionOptions({
+        id: `left-join-bug-teams`,
+        getKey: (team) => team.id,
+        initialData: [
+          {
+            id: `team-1`,
+            account_id: `account-1`,
+            deleted_ts: null as string | null,
+          },
+        ],
+      }),
+    )
+
+    // Create nested live query collections similar to the bug report
+    const accountsWithUsers = createLiveQueryCollection({
+      id: `left-join-bug-accounts-with-users`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ account: accounts })
+          .join({ user: users }, ({ user, account }) =>
+            eq(user.id, account.user_id),
+          )
+          .select(({ account, user }) => ({
+            account: account,
+            profile: user?.profile,
+          })),
+    })
+
+    const activeTeams = createLiveQueryCollection({
+      id: `left-join-bug-active-teams`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ team: teams })
+          .where(({ team }) => isNull(team.deleted_ts))
+          .select(({ team }) => ({ team })),
+    })
+
+    const accountsWithTeams = createLiveQueryCollection({
+      id: `left-join-bug-accounts-with-teams`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ accountWithUser: accountsWithUsers })
+          .leftJoin({ team: activeTeams }, ({ accountWithUser, team }) =>
+            eq(team.team.account_id, accountWithUser.account.id),
+          )
+          .select(({ accountWithUser, team }) => ({
+            account: accountWithUser.account,
+            profile: accountWithUser.profile,
+            team: team?.team,
+          })),
+    })
+
+    // Wait for all queries to be ready
+    await Promise.all([
+      accountsWithUsers.preload(),
+      activeTeams.preload(),
+      accountsWithTeams.preload(),
+    ])
+
+    // Create an optimistic action that mutates using draft
+    const testAction = createOptimisticAction<string>({
+      onMutate: (id) => {
+        // Update existing data using draft mutation
+        accounts.update(id, (draft) => {
+          draft.name = `new name here`
+        })
+      },
+      mutationFn: (_id, _params) => {
+        return Promise.resolve({ txid: 0 })
+      },
+    })
+
+    // Execute the optimistic action and flush - this should complete without scheduler errors
+    let error: Error | undefined
+    let transaction: any
+
+    try {
+      transaction = testAction(`account-1`)
+
+      // Wait for the transaction to process
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // The scheduler should flush successfully without detecting unresolved dependencies
+      transactionScopedScheduler.flushAll()
+    } catch (e) {
+      error = e as Error
+    }
+
+    // The scheduler should not throw unresolved dependency errors
+    expect(error).toBeUndefined()
+
+    // Verify the transaction was created successfully
+    expect(transaction).toBeDefined()
+  })
+
+  it(`should prevent stale data when lazy source also depends on modified collection`, async () => {
+    interface BaseItem {
+      id: string
+      value: number
+    }
+
+    // Base collection
+    const baseCollection = createCollection<BaseItem>(
+      mockSyncCollectionOptions({
+        id: `race-base`,
+        getKey: (item) => item.id,
+        initialData: [{ id: `1`, value: 10 }],
+      }),
+    )
+
+    // QueryA: depends on base
+    const queryA = createLiveQueryCollection({
+      id: `race-queryA`,
+      startSync: true,
+      query: (q) =>
+        q.from({ item: baseCollection }).select(({ item }) => ({
+          id: item.id,
+          value: item.value,
+        })),
+    })
+
+    // QueryB: also depends on base (independent from queryA)
+    const queryB = createLiveQueryCollection({
+      id: `race-queryB`,
+      startSync: true,
+      query: (q) =>
+        q.from({ item: baseCollection }).select(({ item }) => ({
+          id: item.id,
+          value: item.value,
+        })),
+    })
+
+    // QueryC: depends on queryA, left joins queryB (lazy)
+    const queryC = createLiveQueryCollection({
+      id: `race-queryC`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ a: queryA })
+          .leftJoin({ b: queryB }, ({ a, b }) => eq(a.id, b.id))
+          .select(({ a, b }) => ({
+            id: a.id,
+            aValue: a.value,
+            bValue: b?.value ?? null,
+          })),
+    })
+
+    // Wait for initial sync
+    await Promise.all([queryA.preload(), queryB.preload(), queryC.preload()])
+
+    // Verify initial state
+    const initialC = [...queryC.values()][0]
+    expect(initialC?.aValue).toBe(10)
+    expect(initialC?.bValue).toBe(10)
+
+    // Mutate the base collection
+    const action = createOptimisticAction<string>({
+      autoCommit: false,
+      onMutate: (id) => {
+        baseCollection.update(id, (draft) => {
+          draft.value = 100
+        })
+      },
+      mutationFn: (_id) => Promise.resolve({ txid: 0 }),
+    })
+
+    let error: Error | undefined
+    try {
+      action(`1`)
+      await new Promise((resolve) => setTimeout(resolve, 10))
+      transactionScopedScheduler.flushAll()
+    } catch (e) {
+      error = e as Error
+    }
+
+    expect(error).toBeUndefined()
+
+    const finalC = [...queryC.values()][0]
+    expect(finalC?.aValue).toBe(100)
+    expect(finalC?.bValue).toBe(100)
+  })
 })
diff --git a/packages/db/tests/query/select-spread.test-d.ts b/packages/db/tests/query/select-spread.test-d.ts
index a578a6401..272c42afb 100644
--- a/packages/db/tests/query/select-spread.test-d.ts
+++ b/packages/db/tests/query/select-spread.test-d.ts
@@ -1,8 +1,8 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { createCollection } from "../../src/collection/index.js"
-import { createLiveQueryCollection } from "../../src/query/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
-import { add, length, upper } from "../../src/query/builder/functions.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
+import { createLiveQueryCollection } from '../../src/query/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+import { add, length, upper } from '../../src/query/builder/functions.js'
 
 // Base type used in bug report
 type Message = {
@@ -22,7 +22,7 @@ function createMessagesCollection() {
       id: `messages`,
       getKey: (m) => m.id,
       initialData: initialMessages,
-    })
+    }),
   )
 }
 
diff --git a/packages/db/tests/query/select-spread.test.ts b/packages/db/tests/query/select-spread.test.ts
index ee713c667..30665f0fe 100644
--- a/packages/db/tests/query/select-spread.test.ts
+++ b/packages/db/tests/query/select-spread.test.ts
@@ -1,8 +1,8 @@
-import { beforeEach, describe, expect, it } from "vitest"
-import { createCollection } from "../../src/collection/index.js"
-import { createLiveQueryCollection } from "../../src/query/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
-import { add, eq, upper } from "../../src/query/builder/functions.js"
+import { beforeEach, describe, expect, it } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
+import { createLiveQueryCollection } from '../../src/query/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+import { add, eq, upper } from '../../src/query/builder/functions.js'
 
 // Base type used in bug report
 interface Message {
@@ -22,7 +22,7 @@ function createMessagesCollection() {
       id: `messages-select-spread`,
       getKey: (m) => m.id,
       initialData: initialMessages,
-    })
+    }),
   )
 }
 
@@ -58,7 +58,7 @@ function createMessagesWithMetaCollection() {
       id: `messages-select-spread-nested`,
       getKey: (m) => m.id,
       initialData: nestedMessages,
-    })
+    }),
   )
 }
 
@@ -79,7 +79,7 @@ function createUsersCollection() {
       id: `users-select-spread`,
       getKey: (u) => u.id,
       initialData: usersData,
-    })
+    }),
   )
 }
 
@@ -94,7 +94,7 @@ describe(`select spreads (runtime)`, () => {
     const collection = createLiveQueryCollection((q) =>
       q.from({ message: messagesCollection }).select(({ message }) => ({
         ...message,
-      }))
+      })),
     )
     await collection.preload()
 
@@ -112,7 +112,7 @@ describe(`select spreads (runtime)`, () => {
         ...message,
         idPlusOne: add(message.id, 1),
         upperText: upper(message.text),
-      }))
+      })),
     )
     await collection.preload()
 
@@ -134,7 +134,7 @@ describe(`select spreads (runtime)`, () => {
       q.from({ message: messagesCollection }).select(({ message }) => ({
         ...message,
         user: upper(message.user),
-      }))
+      })),
     )
     await collection.preload()
 
@@ -149,7 +149,7 @@ describe(`select spreads (runtime)`, () => {
         // @ts-expect-error - user is overridden by spread
         user: upper(message.user),
         ...message,
-      }))
+      })),
     )
     await collection.preload()
 
@@ -163,7 +163,7 @@ describe(`select spreads (runtime)`, () => {
     const collection = createLiveQueryCollection((q) =>
       q.from({ message: messagesCollection }).select(({ message }) => ({
         ...message,
-      }))
+      })),
     )
     await collection.preload()
 
@@ -185,7 +185,7 @@ describe(`select spreads (runtime)`, () => {
     const collection = createLiveQueryCollection((q) =>
       q.from({ m: messagesNested }).select(({ m }) => ({
         ...m,
-      }))
+      })),
     )
     await collection.preload()
 
@@ -207,7 +207,7 @@ describe(`select spreads (runtime)`, () => {
         ...message,
         // and a final override wins over the last spread
         text: upper(message.text),
-      }))
+      })),
     )
     await collection.preload()
 
@@ -227,7 +227,7 @@ describe(`select spreads (runtime)`, () => {
         .select(({ m, u }) => ({
           ...m,
           ...u,
-        }))
+        })),
     )
     await collection.preload()
 
@@ -248,7 +248,7 @@ describe(`select spreads (runtime)`, () => {
           // desired: spread meta fields under meta key
           ...m.meta,
         },
-      }))
+      })),
     )
     await collection.preload()
 
@@ -270,7 +270,7 @@ describe(`select spreads (runtime)`, () => {
           // last spread restores original author
           ...m.meta,
         },
-      }))
+      })),
     )
     await collection.preload()
 
diff --git a/packages/db/tests/query/select.test-d.ts b/packages/db/tests/query/select.test-d.ts
index b41bb60a6..97549ee4c 100644
--- a/packages/db/tests/query/select.test-d.ts
+++ b/packages/db/tests/query/select.test-d.ts
@@ -1,8 +1,8 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { createCollection } from "../../src/collection/index.js"
-import { createLiveQueryCollection } from "../../src/query/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
-import { upper } from "../../src/query/builder/functions.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
+import { createLiveQueryCollection } from '../../src/query/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+import { upper } from '../../src/query/builder/functions.js'
 
 type User = {
   id: number
@@ -31,7 +31,7 @@ function createUsers() {
       id: `nested-select-users-type`,
       getKey: (u) => u.id,
       initialData: [],
-    })
+    }),
   )
 }
 
@@ -42,7 +42,7 @@ describe(`select types`, () => {
       q.from({ u: users }).select(({ u }) => ({
         id: u.id,
         nameUpper: upper(u.name),
-      }))
+      })),
     )
 
     type Expected = {
@@ -63,7 +63,7 @@ describe(`select types`, () => {
         joinedDate: u.joinedDate,
         name: u.name,
         something: u.something,
-      }))
+      })),
     )
 
     type Expected = {
@@ -87,7 +87,7 @@ describe(`select types`, () => {
           city: u.address?.city,
           coords: u.address?.coordinates,
         },
-      }))
+      })),
     )
 
     type Expected = {
diff --git a/packages/db/tests/query/select.test.ts b/packages/db/tests/query/select.test.ts
index 0a14e1b18..79dd481bb 100644
--- a/packages/db/tests/query/select.test.ts
+++ b/packages/db/tests/query/select.test.ts
@@ -1,8 +1,8 @@
-import { beforeEach, describe, expect, it } from "vitest"
-import { createCollection } from "../../src/collection/index.js"
-import { createLiveQueryCollection } from "../../src/query/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
-import { upper } from "../../src/query/builder/functions.js"
+import { beforeEach, describe, expect, it } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
+import { createLiveQueryCollection } from '../../src/query/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+import { upper } from '../../src/query/builder/functions.js'
 
 type User = {
   id: number
@@ -49,7 +49,7 @@ function createUsers() {
       id: `nested-select-users`,
       getKey: (u) => u.id,
       initialData: data,
-    })
+    }),
   )
 }
 
@@ -68,7 +68,7 @@ describe(`nested select projections`, () => {
           city: u.address?.city,
           coords: u.address?.coordinates,
         },
-      }))
+      })),
     )
 
     await collection.preload()
@@ -93,7 +93,7 @@ describe(`nested select projections`, () => {
           // spread all preference fields under preferences
           ...u.profile.preferences,
         },
-      }))
+      })),
     )
 
     await collection.preload()
@@ -115,7 +115,7 @@ describe(`nested select projections`, () => {
             ...u.profile,
           },
         },
-      }))
+      })),
     )
 
     await collection.preload()
diff --git a/packages/db/tests/query/subquery.test-d.ts b/packages/db/tests/query/subquery.test-d.ts
index 5c169eeb4..c3906da01 100644
--- a/packages/db/tests/query/subquery.test-d.ts
+++ b/packages/db/tests/query/subquery.test-d.ts
@@ -1,7 +1,7 @@
-import { describe, expectTypeOf, test } from "vitest"
-import { createLiveQueryCollection, eq, gt } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { describe, expectTypeOf, test } from 'vitest'
+import { createLiveQueryCollection, eq, gt } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample types for subquery testing
 type Issue = {
@@ -51,7 +51,7 @@ function createIssuesCollection() {
       id: `subquery-test-issues-types`,
       getKey: (issue) => issue.id,
       initialData: sampleIssues,
-    })
+    }),
   )
 }
 
diff --git a/packages/db/tests/query/subquery.test.ts b/packages/db/tests/query/subquery.test.ts
index 80b5bdd15..e7049a182 100644
--- a/packages/db/tests/query/subquery.test.ts
+++ b/packages/db/tests/query/subquery.test.ts
@@ -1,7 +1,7 @@
-import { beforeEach, describe, expect, test } from "vitest"
-import { createLiveQueryCollection, eq, gt } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { beforeEach, describe, expect, test } from 'vitest'
+import { createLiveQueryCollection, eq, gt } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 
 // Sample types for subquery testing
 type Issue = {
@@ -70,7 +70,7 @@ function createIssuesCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (issue) => issue.id,
       initialData: sampleIssues,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -106,7 +106,7 @@ function createSubqueryTests(autoIndex: `off` | `eager`): void {
 
         expect(results.map((r) => r.id).sort()).toEqual([1, 2, 3, 5])
         expect(results.map((r) => r.title)).toEqual(
-          expect.arrayContaining([`Bug 1`, `Bug 2`, `Feature 1`, `Feature 2`])
+          expect.arrayContaining([`Bug 1`, `Bug 2`, `Feature 1`, `Feature 2`]),
         )
       })
 
@@ -130,8 +130,8 @@ function createSubqueryTests(autoIndex: `off` | `eager`): void {
         expect(results.map((r) => r.id).sort()).toEqual([1, 4])
         expect(
           results.every(
-            (r) => sampleIssues.find((i) => i.id === r.id)?.status === `open`
-          )
+            (r) => sampleIssues.find((i) => i.id === r.id)?.status === `open`,
+          ),
         ).toBe(true)
       })
 
diff --git a/packages/db/tests/query/subset-dedupe.test.ts b/packages/db/tests/query/subset-dedupe.test.ts
new file mode 100644
index 000000000..9067c931f
--- /dev/null
+++ b/packages/db/tests/query/subset-dedupe.test.ts
@@ -0,0 +1,885 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  DeduplicatedLoadSubset,
+  cloneOptions,
+} from '../../src/query/subset-dedupe'
+import { Func, PropRef, Value } from '../../src/query/ir'
+import { minusWherePredicates } from '../../src/query/predicate-utils'
+import type { BasicExpression, OrderBy } from '../../src/query/ir'
+import type { LoadSubsetOptions } from '../../src/types'
+
+// Helper functions to build expressions more easily
+function ref(path: string | Array<string>): PropRef {
+  return new PropRef(typeof path === `string` ? [path] : path)
+}
+
+function val<T>(value: T): Value<T> {
+  return new Value(value)
+}
+
+function gt(left: BasicExpression<any>, right: BasicExpression<any>): Func {
+  return new Func(`gt`, [left, right])
+}
+
+function lt(left: BasicExpression<any>, right: BasicExpression<any>): Func {
+  return new Func(`lt`, [left, right])
+}
+
+function eq(left: BasicExpression<any>, right: BasicExpression<any>): Func {
+  return new Func(`eq`, [left, right])
+}
+
+function and(...expressions: Array<BasicExpression<boolean>>): Func {
+  return new Func(`and`, expressions)
+}
+
+function inOp(left: BasicExpression<any>, values: Array<any>): Func {
+  return new Func(`in`, [left, new Value(values)])
+}
+
+function lte(left: BasicExpression<any>, right: BasicExpression<any>): Func {
+  return new Func(`lte`, [left, right])
+}
+
+function not(expression: BasicExpression<boolean>): Func {
+  return new Func(`not`, [expression])
+}
+
+describe(`createDeduplicatedLoadSubset`, () => {
+  it(`should call underlying loadSubset on first call`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+    await deduplicated.loadSubset({ where: gt(ref(`age`), val(10)) })
+
+    expect(callCount).toBe(1)
+  })
+
+  it(`should return true immediately for subset unlimited calls`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    // First call: age > 10
+    await deduplicated.loadSubset({ where: gt(ref(`age`), val(10)) })
+    expect(callCount).toBe(1)
+
+    // Second call: age > 20 (subset of age > 10)
+    const result = await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(20)),
+    })
+    expect(result).toBe(true)
+    expect(callCount).toBe(1) // Should not call underlying function
+  })
+
+  it(`should call underlying loadSubset for non-subset unlimited calls`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    // First call: age > 20
+    await deduplicated.loadSubset({ where: gt(ref(`age`), val(20)) })
+    expect(callCount).toBe(1)
+
+    // Second call: age > 10 (NOT a subset of age > 20)
+    await deduplicated.loadSubset({ where: gt(ref(`age`), val(10)) })
+    expect(callCount).toBe(2) // Should call underlying function
+  })
+
+  it(`should combine unlimited calls with union`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    // First call: age > 20
+    await deduplicated.loadSubset({ where: gt(ref(`age`), val(20)) })
+    expect(callCount).toBe(1)
+
+    // Second call: age < 10 (different range)
+    await deduplicated.loadSubset({ where: lt(ref(`age`), val(10)) })
+    expect(callCount).toBe(2)
+
+    // Third call: age > 25 (subset of age > 20)
+    const result = await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(25)),
+    })
+    expect(result).toBe(true)
+    expect(callCount).toBe(2) // Should not call - covered by first call
+  })
+
+  it(`should track limited calls separately`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    const orderBy1: OrderBy = [
+      {
+        expression: ref(`age`),
+        compareOptions: {
+          direction: `asc`,
+          nulls: `last`,
+          stringSort: `lexical`,
+        },
+      },
+    ]
+
+    const whereClause = gt(ref(`age`), val(10))
+
+    // First call: age > 10, orderBy age asc, limit 10
+    await deduplicated.loadSubset({
+      where: whereClause,
+      orderBy: orderBy1,
+      limit: 10,
+    })
+    expect(callCount).toBe(1)
+
+    // Second call: SAME where clause, same orderBy, smaller limit (subset)
+    // For limited queries, where clauses must be EQUAL for subset relationship
+    const result = await deduplicated.loadSubset({
+      where: whereClause, // Same where clause
+      orderBy: orderBy1,
+      limit: 5,
+    })
+    expect(result).toBe(true)
+    expect(callCount).toBe(1) // Should not call - subset of first
+  })
+
+  it(`should NOT dedupe limited calls with different where clauses`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    const orderBy1: OrderBy = [
+      {
+        expression: ref(`age`),
+        compareOptions: {
+          direction: `asc`,
+          nulls: `last`,
+          stringSort: `lexical`,
+        },
+      },
+    ]
+
+    // First call: age > 10, orderBy age asc, limit 10
+    await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(10)),
+      orderBy: orderBy1,
+      limit: 10,
+    })
+    expect(callCount).toBe(1)
+
+    // Second call: DIFFERENT where clause (age > 20) - should NOT be deduped
+    // even though age > 20 is "more restrictive" than age > 10,
+    // the top 5 of age > 20 might not be in the top 10 of age > 10
+    await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(20)),
+      orderBy: orderBy1,
+      limit: 5,
+    })
+    expect(callCount).toBe(2) // Should call - different where clause
+  })
+
+  it(`should call underlying for non-subset limited calls`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    const orderBy1: OrderBy = [
+      {
+        expression: ref(`age`),
+        compareOptions: {
+          direction: `asc`,
+          nulls: `last`,
+          stringSort: `lexical`,
+        },
+      },
+    ]
+
+    // First call: age > 10, orderBy age asc, limit 10
+    await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(10)),
+      orderBy: orderBy1,
+      limit: 10,
+    })
+    expect(callCount).toBe(1)
+
+    // Second call: age > 10, orderBy age asc, limit 20 (NOT a subset)
+    await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(10)),
+      orderBy: orderBy1,
+      limit: 20,
+    })
+    expect(callCount).toBe(2) // Should call - limit is larger
+  })
+
+  it(`should check limited calls against unlimited combined predicate`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    const orderBy1: OrderBy = [
+      {
+        expression: ref(`age`),
+        compareOptions: {
+          direction: `asc`,
+          nulls: `last`,
+          stringSort: `lexical`,
+        },
+      },
+    ]
+
+    // First call: unlimited age > 10
+    await deduplicated.loadSubset({ where: gt(ref(`age`), val(10)) })
+    expect(callCount).toBe(1)
+
+    // Second call: limited age > 20 with orderBy + limit
+    // Even though it has a limit, it's covered by the unlimited call
+    const result = await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(20)),
+      orderBy: orderBy1,
+      limit: 10,
+    })
+    expect(result).toBe(true)
+    expect(callCount).toBe(1) // Should not call - covered by unlimited
+  })
+
+  it(`should ignore orderBy for unlimited calls`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    const orderBy1: OrderBy = [
+      {
+        expression: ref(`age`),
+        compareOptions: {
+          direction: `asc`,
+          nulls: `last`,
+          stringSort: `lexical`,
+        },
+      },
+    ]
+
+    // First call: unlimited with orderBy
+    await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(10)),
+      orderBy: orderBy1,
+    })
+    expect(callCount).toBe(1)
+
+    // Second call: subset where, different orderBy, no limit
+    const result = await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(20)),
+    })
+    expect(result).toBe(true)
+    expect(callCount).toBe(1) // Should not call - orderBy ignored for unlimited
+  })
+
+  it(`should handle undefined where clauses`, async () => {
+    let callCount = 0
+    const mockLoadSubset = () => {
+      callCount++
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    // First call: no where clause (all data)
+    await deduplicated.loadSubset({})
+    expect(callCount).toBe(1)
+
+    // Second call: with where clause (should be covered)
+    const result = await deduplicated.loadSubset({
+      where: gt(ref(`age`), val(10)),
+    })
+    expect(result).toBe(true)
+    expect(callCount).toBe(1) // Should not call - all data already loaded
+  })
+
+  it(`should handle complex real-world scenario`, async () => {
+    let callCount = 0
+    const calls: Array<LoadSubsetOptions> = []
+    const mockLoadSubset = (options: LoadSubsetOptions) => {
+      callCount++
+      calls.push(options)
+      return Promise.resolve()
+    }
+
+    const deduplicated = new DeduplicatedLoadSubset({
+      loadSubset: mockLoadSubset,
+    })
+
+    const orderBy1: OrderBy = [
+      {
+        expression: ref(`createdAt`),
+        compareOptions: {
+          direction: `desc`,
+          nulls: `last`,
+          stringSort: `lexical`,
+        },
+      },
+    ]
+
+    // Load all active users
+    await deduplicated.loadSubset({ where: eq(ref(`status`), val(`active`)) })
+    expect(callCount).toBe(1)
+
+    // Load top 10 active users by createdAt
+    const result1 = await deduplicated.loadSubset({
+      where: eq(ref(`status`), val(`active`)),
+      orderBy: orderBy1,
+      limit: 10,
+    })
+    expect(result1).toBe(true) // Covered by unlimited call
+    expect(callCount).toBe(1)
+
+    // Load all inactive users
+    await deduplicated.loadSubset({ where: eq(ref(`status`), val(`inactive`)) })
+    expect(callCount).toBe(2)
+
+    // Load top 5 inactive users
+    const result2 = await deduplicated.loadSubset({
+      where: eq(ref(`status`), val(`inactive`)),
+      orderBy: orderBy1,
+      limit: 5,
+    })
+    expect(result2).toBe(true) // Covered by unlimited inactive call
+    expect(callCount).toBe(2)
+
+    // Verify only 2 actual calls were made
+    expect(calls).toHaveLength(2)
+    expect(calls[0]).toEqual({ where: eq(ref(`status`), val(`active`)) })
+    expect(calls[1]).toEqual({ where: eq(ref(`status`), val(`inactive`)) })
+  })
+
+  describe(`subset deduplication with minusWherePredicates`, () => {
+    it(`should request only the difference for range predicates`, async () => {
+      let callCount = 0
+      const calls: Array<LoadSubsetOptions> = []
+      const mockLoadSubset = (options: LoadSubsetOptions) => {
+        callCount++
+        calls.push(cloneOptions(options))
+        return Promise.resolve()
+      }
+
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+      })
+
+      // First call: age > 20 (loads data for age > 20)
+      await deduplicated.loadSubset({ where: gt(ref(`age`), val(20)) })
+      expect(callCount).toBe(1)
+      expect(calls[0]).toEqual({ where: gt(ref(`age`), val(20)) })
+
+      // Second call: age > 10 (should request only age > 10 AND age <= 20)
+      await deduplicated.loadSubset({ where: gt(ref(`age`), val(10)) })
+      expect(callCount).toBe(2)
+      expect(calls[1]).toEqual({
+        where: and(gt(ref(`age`), val(10)), lte(ref(`age`), val(20))),
+      })
+    })
+
+    it(`should request only the difference for set predicates`, async () => {
+      let callCount = 0
+      const calls: Array<LoadSubsetOptions> = []
+      const mockLoadSubset = (options: LoadSubsetOptions) => {
+        callCount++
+        calls.push(cloneOptions(options))
+        return Promise.resolve()
+      }
+
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+      })
+
+      // First call: status IN ['B', 'C'] (loads data for B and C)
+      await deduplicated.loadSubset({
+        where: inOp(ref(`status`), [`B`, `C`]),
+      })
+      expect(callCount).toBe(1)
+      expect(calls[0]).toEqual({ where: inOp(ref(`status`), [`B`, `C`]) })
+
+      // Second call: status IN ['A', 'B', 'C', 'D'] (should request only A and D)
+      await deduplicated.loadSubset({
+        where: inOp(ref(`status`), [`A`, `B`, `C`, `D`]),
+      })
+      expect(callCount).toBe(2)
+      expect(calls[1]).toEqual({
+        where: inOp(ref(`status`), [`A`, `D`]),
+      })
+    })
+
+    it(`should return true immediately for complete overlap`, async () => {
+      let callCount = 0
+      const calls: Array<LoadSubsetOptions> = []
+      const mockLoadSubset = (options: LoadSubsetOptions) => {
+        callCount++
+        calls.push(cloneOptions(options))
+        return Promise.resolve()
+      }
+
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+      })
+
+      // First call: age > 10 (loads data for age > 10)
+      await deduplicated.loadSubset({ where: gt(ref(`age`), val(10)) })
+      expect(callCount).toBe(1)
+
+      // Second call: age > 20 (completely covered by first call)
+      const result = await deduplicated.loadSubset({
+        where: gt(ref(`age`), val(20)),
+      })
+      expect(result).toBe(true)
+      expect(callCount).toBe(1) // Should not make additional call
+    })
+
+    it(`should handle complex predicate differences`, async () => {
+      let callCount = 0
+      const calls: Array<LoadSubsetOptions> = []
+      const mockLoadSubset = (options: LoadSubsetOptions) => {
+        callCount++
+        calls.push(cloneOptions(options))
+        return Promise.resolve()
+      }
+
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+      })
+
+      // First call: age > 20 AND status = 'active'
+      const firstPredicate = and(
+        gt(ref(`age`), val(20)),
+        eq(ref(`status`), val(`active`)),
+      )
+      await deduplicated.loadSubset({ where: firstPredicate })
+      expect(callCount).toBe(1)
+      expect(calls[0]).toEqual({ where: firstPredicate })
+
+      // Second call: age > 10 AND status = 'active' (should request only age > 10 AND age <= 20 AND status = 'active')
+      const secondPredicate = and(
+        gt(ref(`age`), val(10)),
+        eq(ref(`status`), val(`active`)),
+      )
+
+      const test = minusWherePredicates(secondPredicate, firstPredicate)
+      console.log(`test`, test)
+
+      await deduplicated.loadSubset({ where: secondPredicate })
+      expect(callCount).toBe(2)
+      expect(calls[1]).toEqual({
+        where: and(
+          eq(ref(`status`), val(`active`)),
+          gt(ref(`age`), val(10)),
+          lte(ref(`age`), val(20)),
+        ),
+      })
+    })
+
+    it(`should not apply subset logic to limited calls`, async () => {
+      let callCount = 0
+      const calls: Array<LoadSubsetOptions> = []
+      const mockLoadSubset = (options: LoadSubsetOptions) => {
+        callCount++
+        calls.push(cloneOptions(options))
+        return Promise.resolve()
+      }
+
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+      })
+
+      const orderBy1: OrderBy = [
+        {
+          expression: ref(`age`),
+          compareOptions: {
+            direction: `asc`,
+            nulls: `last`,
+            stringSort: `lexical`,
+          },
+        },
+      ]
+
+      // First call: unlimited age > 20
+      await deduplicated.loadSubset({ where: gt(ref(`age`), val(20)) })
+      expect(callCount).toBe(1)
+
+      // Second call: limited age > 10 with orderBy + limit
+      // Should request the full predicate, not the difference, because it's limited
+      await deduplicated.loadSubset({
+        where: gt(ref(`age`), val(10)),
+        orderBy: orderBy1,
+        limit: 10,
+      })
+      expect(callCount).toBe(2)
+      expect(calls[1]).toEqual({
+        where: gt(ref(`age`), val(10)),
+        orderBy: orderBy1,
+        limit: 10,
+      })
+    })
+
+    it(`should handle undefined where clauses in subset logic`, async () => {
+      let callCount = 0
+      const calls: Array<LoadSubsetOptions> = []
+      const mockLoadSubset = (options: LoadSubsetOptions) => {
+        callCount++
+        calls.push(cloneOptions(options))
+        return Promise.resolve()
+      }
+
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+      })
+
+      // First call: age > 20
+      await deduplicated.loadSubset({ where: gt(ref(`age`), val(20)) })
+      expect(callCount).toBe(1)
+
+      // Second call: no where clause (all data)
+      // Should request all data except what we already loaded
+      // i.e. should request NOT (age > 20)
+      await deduplicated.loadSubset({})
+      expect(callCount).toBe(2)
+      expect(calls[1]).toEqual({ where: not(gt(ref(`age`), val(20))) }) // Should request all data except what we already loaded
+    })
+
+    it(`should handle multiple overlapping unlimited calls`, async () => {
+      let callCount = 0
+      const calls: Array<LoadSubsetOptions> = []
+      const mockLoadSubset = (options: LoadSubsetOptions) => {
+        callCount++
+        calls.push(cloneOptions(options))
+        return Promise.resolve()
+      }
+
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+      })
+
+      // First call: age > 20
+      await deduplicated.loadSubset({ where: gt(ref(`age`), val(20)) })
+      expect(callCount).toBe(1)
+
+      // Second call: age < 10 (different range)
+      await deduplicated.loadSubset({ where: lt(ref(`age`), val(10)) })
+      expect(callCount).toBe(2)
+
+      // Third call: age > 5 (should request only age >= 10 AND age <= 20, since age < 10 is already covered)
+      await deduplicated.loadSubset({ where: gt(ref(`age`), val(5)) })
+      expect(callCount).toBe(3)
+
+      // Ideally it would be smart enough to optimize it to request only age >= 10 AND age <= 20, since age < 10 is already covered
+      // However, it doesn't do that currently, so it will not optimize and execute the original query
+      expect(calls[2]).toEqual({
+        where: gt(ref(`age`), val(5)),
+      })
+
+      /*
+      expect(calls[2]).toEqual({
+        where: and(gte(ref(`age`), val(10)), lte(ref(`age`), val(20))),
+      })
+      */
+    })
+  })
+
+  describe(`onDeduplicate callback`, () => {
+    it(`should call onDeduplicate when all data already loaded`, async () => {
+      let callCount = 0
+      const mockLoadSubset = () => {
+        callCount++
+        return Promise.resolve()
+      }
+
+      const onDeduplicate = vi.fn()
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+        onDeduplicate,
+      })
+
+      // Load all data
+      await deduplicated.loadSubset({})
+      expect(callCount).toBe(1)
+
+      // Any subsequent request should be deduplicated
+      const subsetOptions = { where: gt(ref(`age`), val(10)) }
+      const result = await deduplicated.loadSubset(subsetOptions)
+      expect(result).toBe(true)
+      expect(callCount).toBe(1)
+      expect(onDeduplicate).toHaveBeenCalledTimes(1)
+      expect(onDeduplicate).toHaveBeenCalledWith(subsetOptions)
+    })
+
+    it(`should call onDeduplicate when unlimited superset already loaded`, async () => {
+      let callCount = 0
+      const mockLoadSubset = () => {
+        callCount++
+        return Promise.resolve()
+      }
+
+      const onDeduplicate = vi.fn()
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+        onDeduplicate: onDeduplicate,
+      })
+
+      // First call loads a broader set
+      await deduplicated.loadSubset({ where: gt(ref(`age`), val(10)) })
+      expect(callCount).toBe(1)
+
+      // Second call is a subset of the first; should dedupe and call callback
+      const subsetOptions = { where: gt(ref(`age`), val(20)) }
+      const result = await deduplicated.loadSubset(subsetOptions)
+      expect(result).toBe(true)
+      expect(callCount).toBe(1)
+      expect(onDeduplicate).toHaveBeenCalledTimes(1)
+      expect(onDeduplicate).toHaveBeenCalledWith(subsetOptions)
+    })
+
+    it(`should call onDeduplicate for limited subset requests`, async () => {
+      let callCount = 0
+      const mockLoadSubset = () => {
+        callCount++
+        return Promise.resolve()
+      }
+
+      const onDeduplicate = vi.fn()
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+        onDeduplicate,
+      })
+
+      const orderBy1: OrderBy = [
+        {
+          expression: ref(`age`),
+          compareOptions: {
+            direction: `asc`,
+            nulls: `last`,
+            stringSort: `lexical`,
+          },
+        },
+      ]
+
+      const whereClause = gt(ref(`age`), val(10))
+
+      // First limited call
+      await deduplicated.loadSubset({
+        where: whereClause,
+        orderBy: orderBy1,
+        limit: 10,
+      })
+      expect(callCount).toBe(1)
+
+      // Second limited call is a subset (SAME where clause and smaller limit)
+      // For limited queries, where clauses must be EQUAL for subset relationship
+      const subsetOptions = {
+        where: whereClause, // Same where clause
+        orderBy: orderBy1,
+        limit: 5,
+      }
+      const result = await deduplicated.loadSubset(subsetOptions)
+      expect(result).toBe(true)
+      expect(callCount).toBe(1)
+      expect(onDeduplicate).toHaveBeenCalledTimes(1)
+      expect(onDeduplicate).toHaveBeenCalledWith(subsetOptions)
+    })
+
+    it(`should delay onDeduplicate until covering in-flight request completes`, async () => {
+      let resolveFirst: (() => void) | undefined
+      let callCount = 0
+      const firstPromise = new Promise<void>((resolve) => {
+        resolveFirst = () => resolve()
+      })
+
+      // First call will remain in-flight until we resolve it
+      let first = true
+      const mockLoadSubset = (_options: LoadSubsetOptions) => {
+        callCount++
+        if (first) {
+          first = false
+          return firstPromise
+        }
+        return Promise.resolve()
+      }
+
+      const onDeduplicate = vi.fn()
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+        onDeduplicate: onDeduplicate,
+      })
+
+      // Start a broad in-flight request
+      const inflightOptions = { where: gt(ref(`age`), val(10)) }
+      const inflight = deduplicated.loadSubset(inflightOptions)
+      expect(inflight).toBeInstanceOf(Promise)
+      expect(callCount).toBe(1)
+
+      // Issue a subset request while first is still in-flight
+      const subsetOptions = { where: gt(ref(`age`), val(20)) }
+      const subsetPromise = deduplicated.loadSubset(subsetOptions)
+      expect(subsetPromise).toBeInstanceOf(Promise)
+
+      // onDeduplicate should NOT have fired yet
+      expect(onDeduplicate).not.toHaveBeenCalled()
+
+      // Complete the first request
+      resolveFirst?.()
+
+      // Wait for the subset promise to settle (which chains the first)
+      await subsetPromise
+
+      // Now the callback should have been called exactly once, with the subset options
+      expect(onDeduplicate).toHaveBeenCalledTimes(1)
+      expect(onDeduplicate).toHaveBeenCalledWith(subsetOptions)
+    })
+  })
+
+  describe(`limited queries with different where clauses`, () => {
+    // When a query has a limit, only the top N rows (by orderBy) are loaded.
+    // A subsequent query with a different where clause cannot reuse that data,
+    // even if the new where clause is "more restrictive", because the filtered
+    // top N might include rows outside the original unfiltered top N.
+
+    it(`should NOT dedupe when where clause differs on limited queries`, async () => {
+      let callCount = 0
+      const calls: Array<LoadSubsetOptions> = []
+      const mockLoadSubset = (options: LoadSubsetOptions) => {
+        callCount++
+        calls.push(options)
+        return Promise.resolve()
+      }
+
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+      })
+
+      const orderByCreatedAt: OrderBy = [
+        {
+          expression: ref(`created_at`),
+          compareOptions: {
+            direction: `desc`,
+            nulls: `last`,
+            stringSort: `lexical`,
+          },
+        },
+      ]
+
+      // First query: top 10 items with no filter
+      await deduplicated.loadSubset({
+        where: undefined,
+        orderBy: orderByCreatedAt,
+        limit: 10,
+      })
+      expect(callCount).toBe(1)
+
+      // Second query: top 10 items WITH a filter
+      // This requires a separate request because the filtered top 10
+      // might include items outside the unfiltered top 10
+      const searchWhere = and(eq(ref(`title`), val(`test`)))
+      await deduplicated.loadSubset({
+        where: searchWhere,
+        orderBy: orderByCreatedAt,
+        limit: 10,
+      })
+
+      expect(callCount).toBe(2)
+      expect(calls[1]?.where).toEqual(searchWhere)
+    })
+
+    it(`should dedupe when where clause is identical on limited queries`, async () => {
+      let callCount = 0
+      const mockLoadSubset = () => {
+        callCount++
+        return Promise.resolve()
+      }
+
+      const deduplicated = new DeduplicatedLoadSubset({
+        loadSubset: mockLoadSubset,
+      })
+
+      const orderByCreatedAt: OrderBy = [
+        {
+          expression: ref(`created_at`),
+          compareOptions: {
+            direction: `desc`,
+            nulls: `last`,
+            stringSort: `lexical`,
+          },
+        },
+      ]
+
+      // First query: top 10 items with no filter
+      await deduplicated.loadSubset({
+        where: undefined,
+        orderBy: orderByCreatedAt,
+        limit: 10,
+      })
+      expect(callCount).toBe(1)
+
+      // Second query: same where clause (undefined), smaller limit
+      // The top 5 are contained within the already-loaded top 10
+      const result = await deduplicated.loadSubset({
+        where: undefined,
+        orderBy: orderByCreatedAt,
+        limit: 5,
+      })
+      expect(result).toBe(true)
+      expect(callCount).toBe(1)
+    })
+  })
+})
diff --git a/packages/db/tests/query/validate-aliases.test.ts b/packages/db/tests/query/validate-aliases.test.ts
new file mode 100644
index 000000000..b4c29da38
--- /dev/null
+++ b/packages/db/tests/query/validate-aliases.test.ts
@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, test } from 'vitest'
+import { createLiveQueryCollection, eq } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+
+type Lock = { _id: number; name: string }
+type Vote = { _id: number; lockId: number; percent: number }
+
+const locks: Array<Lock> = [
+  { _id: 1, name: `Lock A` },
+  { _id: 2, name: `Lock B` },
+]
+
+const votes: Array<Vote> = [
+  { _id: 1, lockId: 1, percent: 10 },
+  { _id: 2, lockId: 1, percent: 20 },
+  { _id: 3, lockId: 2, percent: 30 },
+]
+
+function createTestCollections() {
+  return {
+    locksCollection: createCollection(
+      mockSyncCollectionOptions<Lock>({
+        id: `locks`,
+        getKey: (lock) => lock._id,
+        initialData: locks,
+        autoIndex: `eager`,
+      }),
+    ),
+    votesCollection: createCollection(
+      mockSyncCollectionOptions<Vote>({
+        id: `votes`,
+        getKey: (vote) => vote._id,
+        initialData: votes,
+        autoIndex: `eager`,
+      }),
+    ),
+  }
+}
+
+describe(`Alias validation in subqueries`, () => {
+  let locksCollection: ReturnType<
+    typeof createTestCollections
+  >[`locksCollection`]
+  let votesCollection: ReturnType<
+    typeof createTestCollections
+  >[`votesCollection`]
+
+  beforeEach(() => {
+    const collections = createTestCollections()
+    locksCollection = collections.locksCollection
+    votesCollection = collections.votesCollection
+  })
+
+  test(`should throw DuplicateAliasInSubqueryError when subquery reuses a parent query collection alias`, () => {
+    expect(() => {
+      createLiveQueryCollection({
+        startSync: true,
+        query: (q) => {
+          const locksAgg = q
+            .from({ lock: locksCollection })
+            .join({ vote: votesCollection }, ({ lock, vote }) =>
+              eq(lock._id, vote.lockId),
+            )
+            .select(({ lock }) => ({
+              _id: lock._id,
+              lockName: lock.name,
+            }))
+
+          return q
+            .from({ vote: votesCollection }) // Reuses "vote" alias from subquery
+            .join({ lock: locksAgg }, ({ vote, lock }) =>
+              eq(lock._id, vote.lockId),
+            )
+            .select(({ vote, lock }) => ({
+              voteId: vote._id,
+              lockName: lock!.lockName,
+            }))
+        },
+      })
+    }).toThrow(/Subquery uses alias "vote"/)
+  })
+
+  test(`should allow subqueries when all collection aliases are unique`, () => {
+    const query = createLiveQueryCollection({
+      startSync: true,
+      query: (q) => {
+        const locksAgg = q
+          .from({ lock: locksCollection })
+          .join(
+            { v: votesCollection }, // Uses unique alias "v" instead of "vote"
+            ({ lock, v }) => eq(lock._id, v.lockId),
+          )
+          .select(({ lock }) => ({
+            _id: lock._id,
+            lockName: lock.name,
+          }))
+
+        return q
+          .from({ vote: votesCollection })
+          .join({ lock: locksAgg }, ({ vote, lock }) =>
+            eq(lock._id, vote.lockId),
+          )
+          .select(({ vote, lock }) => ({
+            voteId: vote._id,
+            lockName: lock!.lockName,
+          }))
+      },
+    })
+
+    const results = query.toArray
+
+    // Should successfully execute and return results
+    expect(results.length).toBeGreaterThan(0)
+    expect(results.every((r) => r.lockName)).toBe(true)
+  })
+})
diff --git a/packages/db/tests/query/where.test.ts b/packages/db/tests/query/where.test.ts
index 2eb78a38b..2e20da187 100644
--- a/packages/db/tests/query/where.test.ts
+++ b/packages/db/tests/query/where.test.ts
@@ -1,7 +1,7 @@
-import { beforeEach, describe, expect, test } from "vitest"
-import { createLiveQueryCollection } from "../../src/query/index.js"
-import { createCollection } from "../../src/collection/index.js"
-import { mockSyncCollectionOptions } from "../utils.js"
+import { beforeEach, describe, expect, test } from 'vitest'
+import { createLiveQueryCollection } from '../../src/query/index.js'
+import { createCollection } from '../../src/collection/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
 import {
   add,
   and,
@@ -21,7 +21,7 @@ import {
   not,
   or,
   upper,
-} from "../../src/query/builder/functions.js"
+} from '../../src/query/builder/functions.js'
 
 // Sample data types for comprehensive testing
 type Employee = {
@@ -228,7 +228,7 @@ function createEmployeesCollection(autoIndex: `off` | `eager` = `eager`) {
       getKey: (emp) => emp.id,
       initialData: sampleEmployees,
       autoIndex,
-    })
+    }),
   )
 }
 
@@ -339,7 +339,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
 
         expect(highEarners.size).toBe(3) // Alice (75k), Charlie (85k), Diana (95k)
         expect(highEarners.toArray.every((emp) => emp.salary > 70000)).toBe(
-          true
+          true,
         )
 
         // Test with age
@@ -430,7 +430,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
         })
 
         expect(exactMatch.toArray.some((emp) => emp.salary === 65000)).toBe(
-          true
+          true,
         ) // Bob
       })
 
@@ -450,7 +450,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
 
         expect(juniorSalary.size).toBe(2) // Eve (55k), Frank (45k)
         expect(juniorSalary.toArray.every((emp) => emp.salary < 60000)).toBe(
-          true
+          true,
         )
 
         // Test with age
@@ -505,12 +505,12 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
 
         expect(modestSalary.size).toBe(3) // Bob, Eve, Frank
         expect(modestSalary.toArray.every((emp) => emp.salary <= 65000)).toBe(
-          true
+          true,
         )
 
         // Test boundary condition
         expect(modestSalary.toArray.some((emp) => emp.salary === 65000)).toBe(
-          true
+          true,
         ) // Bob
       })
     })
@@ -529,7 +529,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
             q
               .from({ emp: employeesCollection })
               .where(({ emp }) =>
-                and(eq(emp.active, true), gt(emp.salary, 70000))
+                and(eq(emp.active, true), gt(emp.salary, 70000)),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -542,8 +542,8 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
         expect(activeHighEarners.size).toBe(2) // Alice (75k), Diana (95k)
         expect(
           activeHighEarners.toArray.every(
-            (emp) => emp.active && emp.salary > 70000
-          )
+            (emp) => emp.active && emp.salary > 70000,
+          ),
         ).toBe(true)
 
         // Test with three conditions
@@ -556,8 +556,8 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
                 and(
                   eq(emp.active, true),
                   gte(emp.age, 25),
-                  lte(emp.salary, 75000)
-                )
+                  lte(emp.salary, 75000),
+                ),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -594,7 +594,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
             q
               .from({ emp: employeesCollection })
               .where(({ emp }) =>
-                or(eq(emp.department_id, 1), eq(emp.department_id, 3))
+                or(eq(emp.department_id, 1), eq(emp.department_id, 3)),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -639,7 +639,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
 
         expect(notHighEarners.size).toBe(3) // Bob, Eve, Frank
         expect(notHighEarners.toArray.every((emp) => emp.salary <= 70000)).toBe(
-          true
+          true,
         )
       })
 
@@ -654,9 +654,9 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
                   eq(emp.active, true),
                   or(
                     and(eq(emp.department_id, 1), gt(emp.salary, 70000)),
-                    and(eq(emp.department_id, 2), lt(emp.age, 30))
-                  )
-                )
+                    and(eq(emp.department_id, 2), lt(emp.age, 30)),
+                  ),
+                ),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -753,8 +753,8 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
         expect(specificDepartments.size).toBe(4) // Alice, Bob, Charlie, Eve
         expect(
           specificDepartments.toArray.every(
-            (emp) => emp.department_id === 1 || emp.department_id === 2
-          )
+            (emp) => emp.department_id === 1 || emp.department_id === 2,
+          ),
         ).toBe(true)
 
         // Test with specific IDs
@@ -794,13 +794,13 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
         employeesCollection = createEmployeesCollection()
       })
 
-      test(`null equality comparison`, () => {
+      test(`isNull check`, () => {
         const nullEmails = createLiveQueryCollection({
           startSync: true,
           query: (q) =>
             q
               .from({ emp: employeesCollection })
-              .where(({ emp }) => eq(emp.email, null))
+              .where(({ emp }) => isNull(emp.email))
               .select(({ emp }) => ({
                 id: emp.id,
                 name: emp.name,
@@ -816,7 +816,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
           query: (q) =>
             q
               .from({ emp: employeesCollection })
-              .where(({ emp }) => eq(emp.department_id, null))
+              .where(({ emp }) => isNull(emp.department_id))
               .select(({ emp }) => ({
                 id: emp.id,
                 name: emp.name,
@@ -828,13 +828,13 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
         expect(nullDepartments.get(6)?.department_id).toBeNull()
       })
 
-      test(`not null comparison`, () => {
+      test(`not isNull check`, () => {
         const hasEmail = createLiveQueryCollection({
           startSync: true,
           query: (q) =>
             q
               .from({ emp: employeesCollection })
-              .where(({ emp }) => not(eq(emp.email, null)))
+              .where(({ emp }) => not(isNull(emp.email)))
               .select(({ emp }) => ({
                 id: emp.id,
                 name: emp.name,
@@ -850,7 +850,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
           query: (q) =>
             q
               .from({ emp: employeesCollection })
-              .where(({ emp }) => not(eq(emp.department_id, null)))
+              .where(({ emp }) => not(isNull(emp.department_id)))
               .select(({ emp }) => ({
                 id: emp.id,
                 name: emp.name,
@@ -913,7 +913,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
 
         expect(shortNames.size).toBe(2) // Bob (3), Eve (3)
         expect(
-          shortNames.toArray.every((emp) => emp.first_name.length < 4)
+          shortNames.toArray.every((emp) => emp.first_name.length < 4),
         ).toBe(true)
 
         const longNames = createLiveQueryCollection({
@@ -939,7 +939,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
             q
               .from({ emp: employeesCollection })
               .where(({ emp }) =>
-                eq(concat(emp.first_name, ` `, emp.last_name), `Alice Johnson`)
+                eq(concat(emp.first_name, ` `, emp.last_name), `Alice Johnson`),
               )
               .select(({ emp }) => ({ id: emp.id, name: emp.name })),
         })
@@ -955,7 +955,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
             q
               .from({ emp: employeesCollection })
               .where(({ emp }) =>
-                like(coalesce(emp.email, `no-email@company.com`), `%no-email%`)
+                like(coalesce(emp.email, `no-email@company.com`), `%no-email%`),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -992,7 +992,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
 
         expect(salaryPlusBonus.size).toBe(3) // Alice (85k), Charlie (95k), Diana (105k)
         expect(
-          salaryPlusBonus.toArray.every((emp) => emp.salary + 10000 > 80000)
+          salaryPlusBonus.toArray.every((emp) => emp.salary + 10000 > 80000),
         ).toBe(true)
 
         // Test age calculation
@@ -1032,9 +1032,9 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
                   eq(emp.active, true),
                   or(
                     and(gte(emp.salary, 70000), lt(emp.age, 35)),
-                    eq(emp.department_id, 2)
-                  )
-                )
+                    eq(emp.department_id, 2),
+                  ),
+                ),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -1156,7 +1156,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
           query: (q) =>
             q
               .from({ emp: employeesCollection })
-              .where(({ emp }) => eq(emp.email, null))
+              .where(({ emp }) => isNull(emp.email))
               .select(({ emp }) => ({
                 id: emp.id,
                 name: emp.name,
@@ -1217,7 +1217,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
             id: `empty-employees`,
             getKey: (emp) => emp.id,
             initialData: [],
-          })
+          }),
         )
 
         const emptyQuery = createLiveQueryCollection({
@@ -1259,7 +1259,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
             q
               .from({ emp: employeesCollection })
               .where(({ emp }) =>
-                and(gte(emp.salary, 60000), lte(emp.salary, 80000))
+                and(gte(emp.salary, 60000), lte(emp.salary, 80000)),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -1271,8 +1271,8 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
         expect(salaryRange.size).toBe(2) // Bob (65k), Alice (75k)
         expect(
           salaryRange.toArray.every(
-            (emp) => emp.salary >= 60000 && emp.salary <= 80000
-          )
+            (emp) => emp.salary >= 60000 && emp.salary <= 80000,
+          ),
         ).toBe(true)
       })
 
@@ -1288,11 +1288,11 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
                     eq(emp.active, true),
                     or(
                       and(eq(emp.department_id, 1), gt(emp.salary, 70000)),
-                      and(eq(emp.department_id, 2), lt(emp.age, 30))
-                    )
+                      and(eq(emp.department_id, 2), lt(emp.age, 30)),
+                    ),
                   ),
-                  and(eq(emp.active, false), gt(emp.age, 35))
-                )
+                  and(eq(emp.active, false), gt(emp.age, 35)),
+                ),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -1332,7 +1332,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
 
         const resultArray = result.toArray
         expect(
-          resultArray.every((emp) => emp.active && emp.salary > 70000)
+          resultArray.every((emp) => emp.active && emp.salary > 70000),
         ).toBe(true)
 
         const names = resultArray.map((emp) => emp.name).sort()
@@ -1365,8 +1365,8 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
         const resultArray = result.toArray
         expect(
           resultArray.every(
-            (emp) => emp.active && emp.salary >= 65000 && emp.age < 35
-          )
+            (emp) => emp.active && emp.salary >= 65000 && emp.age < 35,
+          ),
         ).toBe(true)
 
         const names = resultArray.map((emp) => emp.name).sort()
@@ -1470,7 +1470,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
             q
               .from({ emp: employeesCollection })
               .where(({ emp }) =>
-                eq(emp.contact?.address?.city, `San Francisco`)
+                eq(emp.contact?.address?.city, `San Francisco`),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -1481,7 +1481,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
 
         expect(sfEmployees.size).toBe(2) // Alice and Diana
         expect(
-          sfEmployees.toArray.every((e) => e.city === `San Francisco`)
+          sfEmployees.toArray.every((e) => e.city === `San Francisco`),
         ).toBe(true)
       })
 
@@ -1492,7 +1492,7 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
           query: (q) =>
             q
               .from({ emp: employeesCollection })
-              .where(({ emp }) => eq(emp.contact?.address, null))
+              .where(({ emp }) => isNull(emp.contact?.address))
               .select(({ emp }) => ({
                 id: emp.id,
                 name: emp.name,
@@ -1534,8 +1534,8 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
                 and(
                   eq(emp.active, true),
                   eq(emp.contact?.address?.state, `CA`),
-                  gte(emp.profile?.experience.years, 5)
-                )
+                  gte(emp.profile?.experience.years, 5),
+                ),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -1562,8 +1562,8 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
               .where(({ emp }) =>
                 and(
                   gt(emp.salary, 60000),
-                  inArray(`Python`, emp.profile?.skills)
-                )
+                  inArray(`Python`, emp.profile?.skills),
+                ),
               )
               .select(({ emp }) => ({
                 id: emp.id,
@@ -1694,8 +1694,8 @@ function createWhereTests(autoIndex: `off` | `eager`): void {
               .where(({ emp }) =>
                 or(
                   eq(emp.contact?.address?.city, `San Francisco`),
-                  inArray(`Python`, emp.profile?.skills)
-                )
+                  inArray(`Python`, emp.profile?.skills),
+                ),
               )
               .select(({ emp }) => ({
                 id: emp.id,
diff --git a/packages/db/tests/test-setup.ts b/packages/db/tests/test-setup.ts
index b9e762299..a9d0dd31a 100644
--- a/packages/db/tests/test-setup.ts
+++ b/packages/db/tests/test-setup.ts
@@ -1 +1 @@
-import "@testing-library/jest-dom/vitest"
+import '@testing-library/jest-dom/vitest'
diff --git a/packages/db/tests/transaction-types.test.ts b/packages/db/tests/transaction-types.test.ts
index d69e80f73..0efc4498e 100644
--- a/packages/db/tests/transaction-types.test.ts
+++ b/packages/db/tests/transaction-types.test.ts
@@ -1,11 +1,11 @@
-import { describe, expect, it } from "vitest"
-import type { Collection } from "../src/collection/index.js"
+import { describe, expect, it } from 'vitest'
+import type { Collection } from '../src/collection/index.js'
 import type {
   MutationFn,
   PendingMutation,
   Transaction,
   TransactionConfig,
-} from "../src/types"
+} from '../src/types'
 
 describe(`Transaction Types`, () => {
   it(`should validate PendingMutation structure with collection`, () => {
diff --git a/packages/db/tests/transactions.test.ts b/packages/db/tests/transactions.test.ts
index 4b7cac1db..a0c716052 100644
--- a/packages/db/tests/transactions.test.ts
+++ b/packages/db/tests/transactions.test.ts
@@ -1,12 +1,12 @@
-import { describe, expect, it } from "vitest"
-import { createTransaction } from "../src/transactions"
-import { createCollection } from "../src/collection/index.js"
+import { describe, expect, it } from 'vitest'
+import { createTransaction } from '../src/transactions'
+import { createCollection } from '../src/collection/index.js'
 import {
   MissingMutationFunctionError,
   TransactionAlreadyCompletedRollbackError,
   TransactionNotPendingCommitError,
   TransactionNotPendingMutateError,
-} from "../src/errors"
+} from '../src/errors'
 
 describe(`Transactions`, () => {
   it(`calling createTransaction creates a transaction`, () => {
@@ -39,13 +39,13 @@ describe(`Transactions`, () => {
     await transaction.commit()
 
     await expect(transaction.commit()).rejects.toThrow(
-      TransactionNotPendingCommitError
+      TransactionNotPendingCommitError,
     )
     expect(() => transaction.rollback()).toThrow(
-      TransactionAlreadyCompletedRollbackError
+      TransactionAlreadyCompletedRollbackError,
     )
     expect(() => transaction.mutate(() => {})).toThrow(
-      TransactionNotPendingMutateError
+      TransactionNotPendingMutateError,
     )
   })
   it(`should allow manually controlling the transaction lifecycle`, () => {
@@ -553,4 +553,36 @@ describe(`Transactions`, () => {
     expect(transaction2.state).toBe(`completed`)
     expect(transaction3.state).toBe(`failed`)
   })
+
+  describe(`duplicate instance detection`, () => {
+    it(`sets a global marker in dev mode when in browser top window`, () => {
+      // The duplicate instance marker should be set when the module loads in dev mode
+      const marker = Symbol.for(`@tanstack/db/instance-marker`)
+      // This will only be true if we're in dev mode AND in a browser top window
+      // In test environment (vitest), we should have these conditions met
+      expect((globalThis as any)[marker]).toBe(true)
+    })
+
+    it(`marker is only set in development mode`, () => {
+      // This test verifies the marker exists in our test environment
+      // In production (NODE_ENV=production), the marker would NOT be set
+      const marker = Symbol.for(`@tanstack/db/instance-marker`)
+      const isDev =
+        typeof process !== `undefined` && process.env.NODE_ENV !== `production`
+
+      if (isDev) {
+        expect((globalThis as any)[marker]).toBe(true)
+      }
+      // Note: We can't easily test the production case without changing NODE_ENV
+      // which would affect the entire test suite
+    })
+
+    it(`can be disabled with environment variable`, () => {
+      // This test documents that TANSTACK_DB_DISABLE_DUP_CHECK=1 disables the check
+      // We can't easily test the actual behavior without reloading the module,
+      // but the implementation in transactions.ts checks this variable
+      const disableCheck = process.env.TANSTACK_DB_DISABLE_DUP_CHECK === `1`
+      expect(typeof disableCheck).toBe(`boolean`)
+    })
+  })
 })
diff --git a/packages/db/tests/utility-exposure.test.ts b/packages/db/tests/utility-exposure.test.ts
index 4412443db..9a4ab7ed7 100644
--- a/packages/db/tests/utility-exposure.test.ts
+++ b/packages/db/tests/utility-exposure.test.ts
@@ -1,6 +1,6 @@
-import { describe, expect, test } from "vitest"
-import { createCollection } from "../src/collection/index.js"
-import type { CollectionConfig, SyncConfig, UtilsRecord } from "../src/types"
+import { describe, expect, test } from 'vitest'
+import { createCollection } from '../src/collection/index.js'
+import type { CollectionConfig, SyncConfig, UtilsRecord } from '../src/types'
 
 // Mock utility functions for testing
 interface TestUtils extends UtilsRecord {
@@ -87,7 +87,7 @@ describe(`Utility exposure pattern`, () => {
 
     // Create collection with utilities
     const collection = createCollection<TestItem, string | number, TestUtils>(
-      options
+      options,
     )
 
     // Let's verify utilities work with the collection
diff --git a/packages/db/tests/utils.property.test.ts b/packages/db/tests/utils.property.test.ts
new file mode 100644
index 000000000..eb03cef64
--- /dev/null
+++ b/packages/db/tests/utils.property.test.ts
@@ -0,0 +1,348 @@
+import { describe, expect, it } from 'vitest'
+import { fc, test as fcTest } from '@fast-check/vitest'
+import { Temporal } from 'temporal-polyfill'
+import { deepEquals } from '../src/utils'
+
+/**
+ * Custom arbitraries for generating values that deepEquals handles.
+ *
+ * Note: We use same-type arbitraries for symmetry/transitivity tests because
+ * deepEquals has known asymmetric behavior when comparing certain cross-type
+ * values (e.g., Date vs Temporal.Duration). This is documented in the
+ * "known edge cases" section below.
+ */
+const arbitraryPrimitive = fc.oneof(
+  fc.string(),
+  fc.integer(),
+  fc.double({ noNaN: true }), // NaN !== NaN, which would break reflexivity
+  fc.boolean(),
+  fc.constant(null),
+  fc.constant(undefined),
+)
+
+const arbitraryDate = fc.date().map((d) => new Date(d.getTime()))
+
+const arbitraryRegExp = fc
+  .tuple(fc.string(), fc.constantFrom(``, `g`, `i`, `gi`, `m`, `gim`))
+  .map(([source, flags]) => {
+    try {
+      // Escape special regex characters to avoid invalid patterns
+      const escapedSource = source.replace(/[.*+?^${}()|[\]\\]/g, `\\$&`)
+      return new RegExp(escapedSource, flags)
+    } catch {
+      return /test/
+    }
+  })
+
+const arbitraryUint8Array = fc.uint8Array({ minLength: 0, maxLength: 20 })
+
+const arbitraryFloat32Array = fc
+  .array(fc.float({ noNaN: true }), { minLength: 0, maxLength: 10 })
+  .map((arr) => new Float32Array(arr))
+
+const arbitraryTemporalPlainDate = fc
+  .tuple(
+    fc.integer({ min: 1, max: 9999 }),
+    fc.integer({ min: 1, max: 12 }),
+    fc.integer({ min: 1, max: 28 }), // Safe day range
+  )
+  .map(([year, month, day]) => new Temporal.PlainDate(year, month, day))
+
+const arbitraryTemporalDuration = fc
+  .tuple(
+    fc.integer({ min: 0, max: 100 }),
+    fc.integer({ min: 0, max: 59 }),
+    fc.integer({ min: 0, max: 59 }),
+  )
+  .map(([hours, minutes, seconds]) =>
+    Temporal.Duration.from({ hours, minutes, seconds }),
+  )
+
+// Same-type value arbitraries for testing equivalence properties
+// These avoid cross-type comparisons that have known asymmetric behavior
+const arbitrarySameTypePrimitive = fc.oneof(
+  fc.tuple(fc.string(), fc.string()),
+  fc.tuple(fc.integer(), fc.integer()),
+  fc.tuple(fc.double({ noNaN: true }), fc.double({ noNaN: true })),
+  fc.tuple(fc.boolean(), fc.boolean()),
+)
+
+const arbitrarySameTypeDate = fc.tuple(arbitraryDate, arbitraryDate)
+const arbitrarySameTypeRegExp = fc.tuple(arbitraryRegExp, arbitraryRegExp)
+const arbitrarySameTypeUint8Array = fc.tuple(
+  arbitraryUint8Array,
+  arbitraryUint8Array,
+)
+const arbitrarySameTypeTemporalDate = fc.tuple(
+  arbitraryTemporalPlainDate,
+  arbitraryTemporalPlainDate,
+)
+const arbitrarySameTypeTemporalDuration = fc.tuple(
+  arbitraryTemporalDuration,
+  arbitraryTemporalDuration,
+)
+
+// Pair of values of the same type
+const arbitrarySameTypePair = fc.oneof(
+  arbitrarySameTypePrimitive,
+  arbitrarySameTypeDate,
+  arbitrarySameTypeRegExp,
+  arbitrarySameTypeUint8Array,
+  arbitrarySameTypeTemporalDate,
+  arbitrarySameTypeTemporalDuration,
+  fc.tuple(
+    fc.array(fc.integer(), { maxLength: 5 }),
+    fc.array(fc.integer(), { maxLength: 5 }),
+  ),
+  fc.tuple(
+    fc.dictionary(fc.string(), fc.integer(), { maxKeys: 5 }),
+    fc.dictionary(fc.string(), fc.integer(), { maxKeys: 5 }),
+  ),
+)
+
+// Single values for reflexivity tests
+const arbitrarySingleValue = fc.oneof(
+  arbitraryPrimitive,
+  arbitraryDate,
+  arbitraryRegExp,
+  arbitraryUint8Array,
+  arbitraryFloat32Array,
+  arbitraryTemporalPlainDate,
+  arbitraryTemporalDuration,
+  fc.array(fc.integer(), { maxLength: 5 }),
+  fc.dictionary(fc.string(), fc.integer(), { maxKeys: 5 }),
+)
+
+describe(`deepEquals property-based tests`, () => {
+  describe(`equivalence relation properties`, () => {
+    fcTest.prop([arbitrarySingleValue])(
+      `reflexivity: deepEquals(a, a) is always true`,
+      (a) => {
+        expect(deepEquals(a, a)).toBe(true)
+      },
+    )
+
+    fcTest.prop([arbitrarySameTypePair])(
+      `symmetry: deepEquals(a, b) === deepEquals(b, a) for same-type values`,
+      ([a, b]) => {
+        expect(deepEquals(a, b)).toBe(deepEquals(b, a))
+      },
+    )
+
+    fcTest.prop([fc.array(fc.integer(), { maxLength: 5 })])(
+      `transitivity: if deepEquals(a, b) && deepEquals(b, c) then deepEquals(a, c)`,
+      (arr) => {
+        // Create three copies to test transitivity
+        const a = [...arr]
+        const b = [...arr]
+        const c = [...arr]
+        if (deepEquals(a, b) && deepEquals(b, c)) {
+          expect(deepEquals(a, c)).toBe(true)
+        }
+      },
+    )
+  })
+
+  describe(`cross-type comparisons`, () => {
+    it(`Date and Temporal.Duration are not equal in either direction`, () => {
+      const date = new Date(`1970-01-01T00:00:00.000Z`)
+      const duration = Temporal.Duration.from({
+        hours: 0,
+        minutes: 0,
+        seconds: 0,
+      })
+
+      // Both directions should return false for different types (symmetric)
+      expect(deepEquals(date, duration)).toBe(false)
+      expect(deepEquals(duration, date)).toBe(false)
+    })
+
+    it(`Date and Temporal.PlainDate are not equal in either direction`, () => {
+      const date = new Date(`2023-01-01T00:00:00.000Z`)
+      const plainDate = new Temporal.PlainDate(2023, 1, 1)
+
+      expect(deepEquals(date, plainDate)).toBe(false)
+      expect(deepEquals(plainDate, date)).toBe(false)
+    })
+
+    it(`RegExp and object are not equal in either direction`, () => {
+      const regex = /test/g
+      const obj = { source: `test`, flags: `g` }
+
+      expect(deepEquals(regex, obj)).toBe(false)
+      expect(deepEquals(obj, regex)).toBe(false)
+    })
+
+    it(`Map and object are not equal in either direction`, () => {
+      const map = new Map([[`a`, 1]])
+      const obj = { a: 1 }
+
+      expect(deepEquals(map, obj)).toBe(false)
+      expect(deepEquals(obj, map)).toBe(false)
+    })
+
+    it(`Set and array are not equal in either direction`, () => {
+      const set = new Set([1, 2, 3])
+      const arr = [1, 2, 3]
+
+      expect(deepEquals(set, arr)).toBe(false)
+      expect(deepEquals(arr, set)).toBe(false)
+    })
+
+    it(`Uint8Array and array are not equal in either direction`, () => {
+      const typedArr = new Uint8Array([1, 2, 3])
+      const arr = [1, 2, 3]
+
+      expect(deepEquals(typedArr, arr)).toBe(false)
+      expect(deepEquals(arr, typedArr)).toBe(false)
+    })
+  })
+
+  describe(`structural equality`, () => {
+    fcTest.prop([fc.array(fc.integer(), { minLength: 0, maxLength: 10 })])(
+      `arrays with same elements are equal`,
+      (arr) => {
+        const copy = [...arr]
+        expect(deepEquals(arr, copy)).toBe(true)
+      },
+    )
+
+    fcTest.prop([
+      fc.dictionary(fc.string(), fc.integer(), { minKeys: 0, maxKeys: 10 }),
+    ])(`objects with same properties are equal`, (obj) => {
+      const copy = { ...obj }
+      expect(deepEquals(obj, copy)).toBe(true)
+    })
+
+    fcTest.prop([
+      fc.array(fc.tuple(fc.string(), fc.integer()), {
+        minLength: 0,
+        maxLength: 5,
+      }),
+    ])(`Maps with same entries are equal`, (entries) => {
+      const map1 = new Map(entries)
+      const map2 = new Map(entries)
+      expect(deepEquals(map1, map2)).toBe(true)
+    })
+
+    fcTest.prop([fc.array(fc.integer(), { minLength: 0, maxLength: 10 })])(
+      `Sets with same primitive values are equal`,
+      (arr) => {
+        const set1 = new Set(arr)
+        const set2 = new Set(arr)
+        expect(deepEquals(set1, set2)).toBe(true)
+      },
+    )
+
+    fcTest.prop([fc.uint8Array({ minLength: 0, maxLength: 50 })])(
+      `Uint8Arrays with same content are equal`,
+      (arr) => {
+        const copy = new Uint8Array(arr)
+        expect(deepEquals(arr, copy)).toBe(true)
+      },
+    )
+
+    fcTest.prop([arbitraryDate])(`Dates with same time are equal`, (date) => {
+      const copy = new Date(date.getTime())
+      expect(deepEquals(date, copy)).toBe(true)
+    })
+
+    fcTest.prop([arbitraryTemporalPlainDate])(
+      `Temporal.PlainDate with same values are equal`,
+      (date) => {
+        const copy = new Temporal.PlainDate(date.year, date.month, date.day)
+        expect(deepEquals(date, copy)).toBe(true)
+      },
+    )
+  })
+
+  describe(`inequality properties`, () => {
+    fcTest.prop([
+      fc.array(fc.integer(), { minLength: 1, maxLength: 10 }),
+      fc.integer(),
+    ])(`arrays with different elements are not equal`, (arr, extraElement) => {
+      const modified = [...arr, extraElement]
+      expect(deepEquals(arr, modified)).toBe(false)
+    })
+
+    fcTest.prop([
+      fc.dictionary(fc.string(), fc.integer(), { minKeys: 1, maxKeys: 5 }),
+      fc.string(),
+      fc.integer(),
+    ])(`objects with extra property are not equal`, (obj, newKey, newValue) => {
+      // Only test if the key doesn't already exist
+      if (!(newKey in obj)) {
+        const modified = { ...obj, [newKey]: newValue }
+        expect(deepEquals(obj, modified)).toBe(false)
+      }
+    })
+
+    fcTest.prop([fc.integer(), fc.string()])(
+      `different types are not equal`,
+      (num, str) => {
+        expect(deepEquals(num, str)).toBe(false)
+      },
+    )
+
+    fcTest.prop([fc.date(), fc.date()])(
+      `dates with different times are not equal`,
+      (date1, date2) => {
+        if (date1.getTime() !== date2.getTime()) {
+          expect(deepEquals(date1, date2)).toBe(false)
+        }
+      },
+    )
+  })
+
+  describe(`edge cases`, () => {
+    fcTest.prop([arbitrarySingleValue])(
+      `null is never equal to a non-null value`,
+      (a) => {
+        if (a !== null) {
+          expect(deepEquals(null, a)).toBe(false)
+          expect(deepEquals(a, null)).toBe(false)
+        }
+      },
+    )
+
+    fcTest.prop([arbitrarySingleValue])(
+      `undefined is never equal to a non-undefined value`,
+      (a) => {
+        if (a !== undefined) {
+          expect(deepEquals(undefined, a)).toBe(false)
+          expect(deepEquals(a, undefined)).toBe(false)
+        }
+      },
+    )
+
+    fcTest.prop([fc.array(fc.integer(), { minLength: 0, maxLength: 5 })])(
+      `array is never equal to object with same values`,
+      (arr) => {
+        const obj = { ...arr }
+        expect(deepEquals(arr, obj)).toBe(false)
+      },
+    )
+  })
+
+  describe(`nested structure consistency`, () => {
+    fcTest.prop([
+      fc.array(fc.array(fc.integer(), { maxLength: 3 }), { maxLength: 3 }),
+    ])(`nested arrays maintain equality through cloning`, (nestedArr) => {
+      const clone = nestedArr.map((inner) => [...inner])
+      expect(deepEquals(nestedArr, clone)).toBe(true)
+    })
+
+    fcTest.prop([
+      fc.dictionary(
+        fc.string(),
+        fc.dictionary(fc.string(), fc.integer(), { maxKeys: 3 }),
+        { maxKeys: 3 },
+      ),
+    ])(`nested objects maintain equality through cloning`, (nestedObj) => {
+      const clone = Object.fromEntries(
+        Object.entries(nestedObj).map(([k, v]) => [k, { ...v }]),
+      )
+      expect(deepEquals(nestedObj, clone)).toBe(true)
+    })
+  })
+})
diff --git a/packages/db/tests/utils.test.ts b/packages/db/tests/utils.test.ts
index f277a9923..d6bb5e368 100644
--- a/packages/db/tests/utils.test.ts
+++ b/packages/db/tests/utils.test.ts
@@ -1,6 +1,7 @@
-import { describe, expect, it } from "vitest"
-import { Temporal } from "temporal-polyfill"
-import { deepEquals } from "../src/utils"
+import { describe, expect, it } from 'vitest'
+import { Temporal } from 'temporal-polyfill'
+import { deepEquals } from '../src/utils'
+import { isPromiseLike } from '../src/utils/type-guards'
 
 describe(`deepEquals`, () => {
   describe(`primitives`, () => {
@@ -341,3 +342,65 @@ describe(`deepEquals`, () => {
     })
   })
 })
+
+describe(`isPromiseLike`, () => {
+  it(`should return true for native Promises`, () => {
+    const promise = Promise.resolve(42)
+    expect(isPromiseLike(promise)).toBe(true)
+  })
+
+  it(`should return true for objects with a then method`, () => {
+    const thenable = {
+      then: (onFulfilled?: any, _onRejected?: any) => {
+        onFulfilled?.(42)
+      },
+    }
+    expect(isPromiseLike(thenable)).toBe(true)
+  })
+
+  it(`should return true for functions with a then method`, () => {
+    const thenableFunction: any = function () {}
+    thenableFunction.then = (onFulfilled?: any) => {
+      onFulfilled?.(42)
+    }
+    expect(isPromiseLike(thenableFunction)).toBe(true)
+  })
+
+  it(`should return false for null`, () => {
+    expect(isPromiseLike(null)).toBe(false)
+  })
+
+  it(`should return false for undefined`, () => {
+    expect(isPromiseLike(undefined)).toBe(false)
+  })
+
+  it(`should return false for primitives`, () => {
+    expect(isPromiseLike(42)).toBe(false)
+    expect(isPromiseLike(`string`)).toBe(false)
+    expect(isPromiseLike(true)).toBe(false)
+    expect(isPromiseLike(false)).toBe(false)
+  })
+
+  it(`should return false for objects without a then method`, () => {
+    expect(isPromiseLike({})).toBe(false)
+    expect(isPromiseLike({ value: 42 })).toBe(false)
+    expect(isPromiseLike([])).toBe(false)
+    expect(isPromiseLike(new Map())).toBe(false)
+  })
+
+  it(`should return false for objects with a non-function then property`, () => {
+    const obj = { then: 42 }
+    expect(isPromiseLike(obj)).toBe(false)
+  })
+
+  it(`should return false for functions without a then method`, () => {
+    const fn = () => 42
+    expect(isPromiseLike(fn)).toBe(false)
+  })
+
+  it(`should handle async functions (which return promises)`, () => {
+    const asyncFn = () => Promise.resolve(42)
+    const result = asyncFn()
+    expect(isPromiseLike(result)).toBe(true)
+  })
+})
diff --git a/packages/db/tests/utils.ts b/packages/db/tests/utils.ts
index 66c301464..49b48db95 100644
--- a/packages/db/tests/utils.ts
+++ b/packages/db/tests/utils.ts
@@ -1,9 +1,10 @@
-import { expect } from "vitest"
+import { expect } from 'vitest'
 import type {
   CollectionConfig,
   MutationFnParams,
+  StringCollationConfig,
   SyncConfig,
-} from "../src/index.js"
+} from '../src/index.js'
 
 // Index usage tracking utilities
 export interface IndexUsageStats {
@@ -126,7 +127,7 @@ export function expectIndexUsage(
     shouldUseFullScan?: boolean
     indexCallCount?: number
     fullScanCallCount?: number
-  }
+  },
 ) {
   if (expectations.shouldUseIndex) {
     expect(stats.rangeQueryCalls).toBeGreaterThan(0)
@@ -156,7 +157,7 @@ export function expectIndexUsage(
 // Helper to run a test with index usage tracking (automatically handles setup/cleanup)
 export function withIndexTracking(
   collection: any,
-  testFn: (tracker: { stats: IndexUsageStats }) => void | Promise<void>
+  testFn: (tracker: { stats: IndexUsageStats }) => void | Promise<void>,
 ): void | Promise<void> {
   const tracker = createIndexUsageTracker(collection)
 
@@ -172,11 +173,14 @@ export function withIndexTracking(
   }
 }
 
-type MockSyncCollectionConfig<T> = {
+type MockSyncCollectionConfig<T extends object = Record<string, unknown>> = {
   id: string
   initialData: Array<T>
   getKey: (item: T) => string | number
   autoIndex?: `off` | `eager`
+  sync?: SyncConfig<T>
+  syncMode?: `eager` | `on-demand`
+  defaultStringCollation?: StringCollationConfig
 }
 
 export function mockSyncCollectionOptions<
@@ -218,27 +222,30 @@ export function mockSyncCollectionOptions<
     },
   }
 
+  const sync = config.sync ?? {
+    sync: (params: Parameters<SyncConfig<T>[`sync`]>[0]) => {
+      begin = params.begin
+      write = params.write
+      commit = params.commit
+      const markReady = params.markReady
+
+      begin()
+      config.initialData.forEach((item) => {
+        write({
+          type: `insert`,
+          value: item,
+        })
+      })
+      commit()
+      markReady()
+    },
+  }
+
   const options: CollectionConfig<T, string | number, never> & {
     utils: typeof utils
   } = {
-    sync: {
-      sync: (params: Parameters<SyncConfig<T>[`sync`]>[0]) => {
-        begin = params.begin
-        write = params.write
-        commit = params.commit
-        const markReady = params.markReady
-
-        begin()
-        config.initialData.forEach((item) => {
-          write({
-            type: `insert`,
-            value: item,
-          })
-        })
-        commit()
-        markReady()
-      },
-    },
+    sync,
+    ...(config.syncMode ? { syncMode: config.syncMode } : {}),
     startSync: true,
     onInsert: async (_params: MutationFnParams<T>) => {
       // TODO
@@ -374,7 +381,7 @@ export const flushPromises = () =>
  */
 export function withExpectedRejection<T>(
   expectedMessage: string,
-  testFn: () => T | Promise<T>
+  testFn: () => T | Promise<T>,
 ): Promise<T> {
   return new Promise((resolve, reject) => {
     // Find and temporarily remove the vitest unhandled rejection handler
@@ -406,8 +413,8 @@ export function withExpectedRejection<T>(
         if (!expectedRejectionCaught) {
           reject(
             new Error(
-              `Expected rejection with message "${expectedMessage}" was not caught`
-            )
+              `Expected rejection with message "${expectedMessage}" was not caught`,
+            ),
           )
           return
         }
diff --git a/packages/db/vite.config.ts b/packages/db/vite.config.ts
index 840a0f7b9..62e1a9df2 100644
--- a/packages/db/vite.config.ts
+++ b/packages/db/vite.config.ts
@@ -1,6 +1,6 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import packageJson from './package.json'
 
 const config = defineConfig({
   test: {
@@ -18,5 +18,5 @@ export default mergeConfig(
   tanstackViteConfig({
     entry: `./src/index.ts`,
     srcDir: `./src`,
-  })
+  }),
 )
diff --git a/packages/electric-db-collection/CHANGELOG.md b/packages/electric-db-collection/CHANGELOG.md
index f9316f247..190f071a7 100644
--- a/packages/electric-db-collection/CHANGELOG.md
+++ b/packages/electric-db-collection/CHANGELOG.md
@@ -1,5 +1,404 @@
 # @tanstack/electric-db-collection
 
+## 0.2.30
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 0.2.29
+
+### Patch Changes
+
+- Fix unhandled 409 errors during collection cleanup. When a collection is cleaned up while snapshot requests are in-flight, errors are now properly caught and ignored rather than propagating as unhandled promise rejections. ([#1174](https://github.com/TanStack/db/pull/1174))
+
+## 0.2.28
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 0.2.27
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 0.2.26
+
+### Patch Changes
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 0.2.25
+
+### Patch Changes
+
+- Fix empty string values being incorrectly omitted from SQL query params. Queries like `eq(column, '')` now correctly include the empty string parameter instead of producing a malformed query with a missing `$1` value. ([#1146](https://github.com/TanStack/db/pull/1146))
+
+## 0.2.24
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 0.2.23
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 0.2.22
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 0.2.21
+
+### Patch Changes
+
+- Fix orphan transactions after `must-refetch` in progressive sync mode ([#1069](https://github.com/TanStack/db/pull/1069))
+
+  When a `must-refetch` message was received in progressive mode, it started a transaction with `truncate()` but reset `hasReceivedUpToDate`, causing subsequent messages to be buffered instead of written to the existing transaction. On `up-to-date`, the atomic swap code would create a new transaction, leaving the first one uncommitted forever. This caused collections to become corrupted with undefined values.
+
+  The fix ensures that when a transaction is already started (e.g., from must-refetch), messages are written directly to it instead of being buffered for atomic swap.
+
+- Fix duplicate key error when overlapping subset queries return the same row with different values. ([#1070](https://github.com/TanStack/db/pull/1070))
+
+  When multiple subset queries return the same row (e.g., different WHERE clauses that both match the same record), the server sends `insert` operations for each response. If the row's data changed between requests (e.g., timestamp field updated), this caused a `DuplicateKeySyncError`. The adapter now tracks synced keys and converts subsequent inserts to updates.
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 0.2.20
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 0.2.19
+
+### Patch Changes
+
+- Fix slow onInsert awaitMatch performance issue ([#1062](https://github.com/TanStack/db/pull/1062))
+
+  The message buffer was being cleared at the start of each new batch, causing messages to be lost when multiple batches (including heartbeats) arrived before `awaitMatch` was called. This resulted in `awaitMatch` timing out (~3-5s per attempt) and transaction rollbacks.
+
+  The fix removes the buffer clearing between batches. Messages are now preserved until the buffer reaches MAX_BATCH_MESSAGES (1000), at which point the oldest messages are dropped. This ensures `awaitMatch` can find messages even when sync activity arrives before the API call completes.
+
+## 0.2.18
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 0.2.17
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 0.2.16
+
+### Patch Changes
+
+- Adds support for the new subset-end message introduced in Electric. ([#1004](https://github.com/TanStack/db/pull/1004))
+
+- Support tagged rows and move out events in Electric collection. ([#942](https://github.com/TanStack/db/pull/942))
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 0.2.15
+
+### Patch Changes
+
+- Don't pin @electric-sql/client version ([#1031](https://github.com/TanStack/db/pull/1031))
+
+## 0.2.14
+
+### Patch Changes
+
+- Fix awaitMatch race condition on inserts and export isChangeMessage/isControlMessage. ([#1000](https://github.com/TanStack/db/pull/1000))
+
+  **Bug fixes:**
+  - Fixed race condition where `awaitMatch` would timeout on inserts when Electric synced faster than the API call
+  - Messages are now preserved in buffer until next batch arrives, allowing `awaitMatch` to find them
+  - Added `batchCommitted` flag to track commit state, consistent with `awaitTxId` semantics
+  - Fixed `batchCommitted` to also trigger on `snapshot-end` in `on-demand` mode (matching "ready" semantics)
+
+  **Export fixes:**
+  - `isChangeMessage` and `isControlMessage` are now exported from the package index as documented
+
+- Fix invalid Electric proxy queries with missing params for null/undefined values ([#951](https://github.com/TanStack/db/pull/951))
+
+  When comparison operators were used with null/undefined values, the SQL compiler would generate placeholders ($1, $2) in the WHERE clause but skip adding the params to the dictionary. This resulted in invalid queries being sent to Electric.
+
+  Now all comparison operators (eq, gt, lt, gte, lte, like, ilike) throw a clear error when used with null/undefined values, since comparisons with NULL always evaluate to UNKNOWN in SQL. Users should use `isNull()` or `isUndefined()` to check for null values instead.
+
+## 0.2.13
+
+### Patch Changes
+
+- Enhanced LoadSubsetOptions with separate cursor expressions and offset for flexible pagination. ([#960](https://github.com/TanStack/db/pull/960))
+
+  **⚠️ Breaking Change for Custom Sync Layers / Query Collections:**
+
+  `LoadSubsetOptions.where` no longer includes cursor expressions for pagination. If you have a custom sync layer or query collection that implements `loadSubset`, you must now handle pagination separately:
+  - **Cursor-based pagination:** Use the new `cursor` property (`cursor.whereFrom` and `cursor.whereCurrent`) and combine them with `where` yourself
+  - **Offset-based pagination:** Use the new `offset` property
+
+  Previously, cursor expressions were baked into the `where` clause. Now they are passed separately so sync layers can choose their preferred pagination strategy.
+
+  **Changes:**
+  - Added `CursorExpressions` type with `whereFrom`, `whereCurrent`, and optional `lastKey` properties
+  - Added `cursor` to `LoadSubsetOptions` for cursor-based pagination (separate from `where`)
+  - Added `offset` to `LoadSubsetOptions` for offset-based pagination support
+  - Electric sync layer now makes two parallel `requestSnapshot` calls when cursor is present:
+    - One for `whereCurrent` (all ties at boundary, no limit)
+    - One for `whereFrom` (rows after cursor, with limit)
+  - Query collection serialization now includes `offset` for query key generation
+  - Added `truncate` event to collections, emitted when synced data is truncated (e.g., after `must-refetch`)
+  - Fixed `setWindow` pagination: cursor expressions are now correctly built when paging through results
+  - Fixed offset tracking: `loadNextItems` now passes the correct window offset to prevent incorrect deduplication
+  - `CollectionSubscriber` now listens for `truncate` events to reset cursor tracking state
+
+  **Benefits:**
+  - Sync layers can choose between cursor-based or offset-based pagination strategies
+  - Electric can efficiently handle tie-breaking with two targeted requests
+  - Better separation of concerns between filtering (`where`) and pagination (`cursor`/`offset`)
+  - `setWindow` correctly triggers backend loading for subsequent pages in multi-column orderBy queries
+  - Cursor state is properly reset after truncation, preventing stale cursor data from being used
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 0.2.12
+
+### Patch Changes
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 0.2.11
+
+### Patch Changes
+
+- Type utils in collection options as specific type (e.g. ElectricCollectionUtils) instead of generic UtilsRecord. ([#940](https://github.com/TanStack/db/pull/940))
+
+- fix: Add BigInt support to pg-serializer and fix error message for non-JSON-serializable values ([#932](https://github.com/TanStack/db/pull/932))
+  - Added support for serializing BigInt values to strings in the `serialize` function
+  - Fixed the error message when encountering unsupported types to handle values that cannot be serialized by `JSON.stringify` (like BigInt), preventing a secondary error from masking the original issue
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/db@0.5.10
+
+## 0.2.10
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+
+## 0.2.9
+
+### Patch Changes
+
+- Fix eager mode incorrectly committing data on `snapshot-end` before receiving the first `up-to-date` message. The `snapshot-end` in the Electric log can be from a significant period before the stream is actually up to date, so commits should only occur on `up-to-date` (or on `snapshot-end` after the first `up-to-date` has been received). This change does not affect `on-demand` mode where `snapshot-end` correctly triggers commits, or `progressive` mode which was already protected by its buffering mechanism. ([#924](https://github.com/TanStack/db/pull/924))
+
+## 0.2.8
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+
+## 0.2.7
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+
+## 0.2.6
+
+### Patch Changes
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 0.2.5
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 0.2.4
+
+### Patch Changes
+
+- Fixed bug where `like()` and `ilike()` operators were not working in on-demand mode. The SQL compiler was incorrectly treating these operators as function calls (`LIKE(column, pattern)`) instead of binary operators (`column LIKE pattern`). Now `like()` and `ilike()` correctly compile to SQL binary operator syntax, enabling search queries with pattern matching in on-demand mode. This fix supports patterns like `like(lower(offers.title), '%search%')` and combining multiple conditions with `or()`. ([#884](https://github.com/TanStack/db/pull/884))
+
+- Fix progressive mode to use fetchSnapshot and atomic swap ([#852](https://github.com/TanStack/db/pull/852))
+
+  Progressive mode was broken because `requestSnapshot()` injected snapshots into the stream in causally correct position, which didn't work properly with the `full` mode stream. This release fixes progressive mode by:
+
+  **Core Changes:**
+  - Use `fetchSnapshot()` during initial sync to fetch and apply snapshots immediately in sync transactions
+  - Buffer all stream messages during initial sync (renamed flag to `isBufferingInitialSync`)
+  - Perform atomic swap on first `up-to-date`: truncate snapshot data → apply buffered messages → mark ready
+  - Track txids/snapshots only after atomic swap (enables correct optimistic transaction confirmation)
+
+  **Test Infrastructure:**
+  - Added `ELECTRIC_TEST_HOOKS` symbol for test control (hidden from public API)
+  - Added `progressiveTestControl.releaseInitialSync()` to E2E test config for explicit transition control
+  - Created comprehensive progressive mode E2E test suite (8 tests):
+    - Explicit snapshot phase and atomic swap validation
+    - Txid tracking behavior (Electric-only)
+    - Multiple concurrent snapshots with deduplication
+    - Incremental updates after swap
+    - Predicate handling and resilience tests
+
+  **Bug Fixes:**
+  - Fixed type errors in test files
+  - All 166 unit tests + 95 E2E tests passing
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 0.2.3
+
+### Patch Changes
+
+- Improve type of mutations in transactions ([#854](https://github.com/TanStack/db/pull/854))
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 0.2.2
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+
+## 0.2.1
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 0.2.0
+
+### Minor Changes
+
+- Add timeout support to electricCollectionOptions matching strategies. You can now specify a custom timeout when returning txids from mutation handlers (onInsert, onUpdate, onDelete). ([#798](https://github.com/TanStack/db/pull/798))
+
+  Previously, users could only customize timeouts when manually calling `collection.utils.awaitTxId()`, but not when using the automatic txid matching strategy.
+
+  **Example:**
+
+  ```ts
+  const collection = createCollection(
+    electricCollectionOptions({
+      // ... other config
+      onInsert: async ({ transaction }) => {
+        const newItem = transaction.mutations[0].modified
+        const result = await api.todos.create({ data: newItem })
+        // Specify custom timeout (in milliseconds)
+        return { txid: result.txid, timeout: 10000 }
+      },
+    }),
+  )
+  ```
+
+  The timeout parameter is optional and defaults to 5000ms when not specified. It works with both single txids and arrays of txids.
+
+### Patch Changes
+
+- Fix array txid handling in electric collection handlers. When returning `{ txid: [txid1, txid2] }` from an `onInsert`, `onUpdate`, or `onDelete` handler, the system would timeout with `TimeoutWaitingForTxIdError` instead of properly waiting for all txids. The bug was caused by passing array indices as timeout parameters when calling `awaitTxId` via `.map()`. ([#795](https://github.com/TanStack/db/pull/795))
+
+- Handle predicates that are pushed down. ([#763](https://github.com/TanStack/db/pull/763))
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.1.44
+
+### Patch Changes
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.1.43
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.1.42
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.1.41
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+
+## 0.1.40
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+
+## 0.1.39
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+
+## 0.1.38
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+
+## 0.1.37
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+
+## 0.1.36
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+
 ## 0.1.35
 
 ### Patch Changes
@@ -47,7 +446,7 @@
   **Example Usage:**
 
   ```typescript
-  import { isChangeMessage } from "@tanstack/electric-db-collection"
+  import { isChangeMessage } from '@tanstack/electric-db-collection'
 
   const todosCollection = createCollection(
     electricCollectionOptions({
@@ -59,12 +458,12 @@
         await collection.utils.awaitMatch(
           (message) =>
             isChangeMessage(message) &&
-            message.headers.operation === "insert" &&
+            message.headers.operation === 'insert' &&
             message.value.text === newItem.text,
-          5000 // timeout in ms (optional, defaults to 5000)
+          5000, // timeout in ms (optional, defaults to 5000)
         )
       },
-    })
+    }),
   )
   ```
 
@@ -396,7 +795,7 @@
   try {
     collection.insert(data)
   } catch (error) {
-    if (error.message.includes("already exists")) {
+    if (error.message.includes('already exists')) {
       // Handle duplicate key error
     }
   }
@@ -405,7 +804,7 @@
   **After:**
 
   ```ts
-  import { DuplicateKeyError } from "@tanstack/db"
+  import { DuplicateKeyError } from '@tanstack/db'
 
   try {
     collection.insert(data)
@@ -422,14 +821,14 @@
 
   ```ts
   // Electric collection errors were imported from @tanstack/db
-  import { ElectricInsertHandlerMustReturnTxIdError } from "@tanstack/db"
+  import { ElectricInsertHandlerMustReturnTxIdError } from '@tanstack/db'
   ```
 
   **After:**
 
   ```ts
   // Now import from the specific adapter package
-  import { ElectricInsertHandlerMustReturnTxIdError } from "@tanstack/electric-db-collection"
+  import { ElectricInsertHandlerMustReturnTxIdError } from '@tanstack/electric-db-collection'
   ```
 
   ### Unified Error Handling
@@ -437,14 +836,14 @@
   **New:**
 
   ```ts
-  import { TanStackDBError } from "@tanstack/db"
+  import { TanStackDBError } from '@tanstack/db'
 
   try {
     // Any TanStack DB operation
   } catch (error) {
     if (error instanceof TanStackDBError) {
       // Handle all TanStack DB errors uniformly
-      console.log("TanStack DB error:", error.message)
+      console.log('TanStack DB error:', error.message)
     }
   }
   ```
diff --git a/packages/electric-db-collection/e2e/electric.e2e.test.ts b/packages/electric-db-collection/e2e/electric.e2e.test.ts
new file mode 100644
index 000000000..cb41e26da
--- /dev/null
+++ b/packages/electric-db-collection/e2e/electric.e2e.test.ts
@@ -0,0 +1,598 @@
+/**
+ * Electric Collection E2E Tests
+ *
+ * end-to-end tests using actual Postgres + Electric sync
+ */
+
+import { afterAll, afterEach, beforeAll, describe, inject } from 'vitest'
+import { createCollection } from '@tanstack/db'
+import { ELECTRIC_TEST_HOOKS, electricCollectionOptions } from '../src/electric'
+import { makePgClient } from '../../db-collection-e2e/support/global-setup'
+import {
+  createCollationTestSuite,
+  createDeduplicationTestSuite,
+  createJoinsTestSuite,
+  createLiveUpdatesTestSuite,
+  createMovesTestSuite,
+  createMutationsTestSuite,
+  createPaginationTestSuite,
+  createPredicatesTestSuite,
+  createProgressiveTestSuite,
+  generateSeedData,
+} from '../../db-collection-e2e/src/index'
+import { waitFor } from '../../db-collection-e2e/src/utils/helpers'
+import type { E2ETestConfig } from '../../db-collection-e2e/src/types'
+import type { Client } from 'pg'
+
+declare module 'vitest' {
+  export interface ProvidedContext {
+    baseUrl: string
+    testSchema: string
+  }
+}
+
+describe(`Electric Collection E2E Tests`, () => {
+  let config: E2ETestConfig & {
+    tagsTestSetup?: {
+      dbClient: Client
+      baseUrl: string
+      testSchema: string
+      usersTable: string
+      postsTable: string
+    }
+  }
+  let dbClient: Client
+  let usersTable: string
+  let postsTable: string
+  let commentsTable: string
+
+  beforeAll(async () => {
+    const baseUrl = inject(`baseUrl`)
+    const testSchema = inject(`testSchema`)
+    const seedData = generateSeedData()
+
+    // Create unique table names (quoted for Electric)
+    const testId = Date.now().toString(16)
+    usersTable = `"users_e2e_${testId}"`
+    postsTable = `"posts_e2e_${testId}"`
+    commentsTable = `"comments_e2e_${testId}"`
+
+    // Connect to database
+    dbClient = makePgClient({ options: `-csearch_path=${testSchema}` })
+    await dbClient.connect()
+    await dbClient.query(`SET search_path TO ${testSchema}`)
+
+    // Create tables
+    await dbClient.query(`
+      CREATE TABLE ${usersTable} (
+        id UUID PRIMARY KEY,
+        name TEXT NOT NULL,
+        email TEXT,
+        age INTEGER NOT NULL,
+        "isActive" BOOLEAN NOT NULL DEFAULT true,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT NOW(),
+        metadata JSONB,
+        "deletedAt" TIMESTAMP
+      )
+    `)
+
+    await dbClient.query(`
+      CREATE TABLE ${postsTable} (
+        id UUID PRIMARY KEY,
+        "userId" UUID NOT NULL,
+        title TEXT NOT NULL,
+        content TEXT,
+        "viewCount" INTEGER NOT NULL DEFAULT 0,
+        "largeViewCount" BIGINT NOT NULL,
+        "publishedAt" TIMESTAMP,
+        "deletedAt" TIMESTAMP
+      )
+    `)
+
+    await dbClient.query(`
+      CREATE TABLE ${commentsTable} (
+        id UUID PRIMARY KEY,
+        "postId" UUID NOT NULL,
+        "userId" UUID NOT NULL,
+        text TEXT NOT NULL,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT NOW(),
+        "deletedAt" TIMESTAMP
+      )
+    `)
+
+    // Insert seed data
+    console.log(`Inserting ${seedData.users.length} users...`)
+    for (const user of seedData.users) {
+      await dbClient.query(
+        `INSERT INTO ${usersTable} (id, name, email, age, "isActive", "createdAt", metadata, "deletedAt")
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+        [
+          user.id,
+          user.name,
+          user.email,
+          user.age,
+          user.isActive,
+          user.createdAt,
+          user.metadata ? JSON.stringify(user.metadata) : null,
+          user.deletedAt,
+        ],
+      )
+    }
+    console.log(`Inserted ${seedData.users.length} users successfully`)
+
+    for (const post of seedData.posts) {
+      await dbClient.query(
+        `INSERT INTO ${postsTable} (id, "userId", title, content, "viewCount", "largeViewCount", "publishedAt", "deletedAt")
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+        [
+          post.id,
+          post.userId,
+          post.title,
+          post.content,
+          post.viewCount,
+          post.largeViewCount.toString(), // BigInt must be converted to string for pg
+          post.publishedAt,
+          post.deletedAt,
+        ],
+      )
+    }
+
+    for (const comment of seedData.comments) {
+      await dbClient.query(
+        `INSERT INTO ${commentsTable} (id, "postId", "userId", text, "createdAt", "deletedAt")
+         VALUES ($1, $2, $3, $4, $5, $6)`,
+        [
+          comment.id,
+          comment.postId,
+          comment.userId,
+          comment.text,
+          comment.createdAt,
+          comment.deletedAt,
+        ],
+      )
+    }
+
+    // Wait for Electric to see the data because Electric's logical replication
+    // slot may be lagging a bit behind so we need to ensure that Electric has seen the data
+    // before we start the tests otherwise the tests are faster than the replication slot
+    // and won't see any data.
+    const tempUsersCollection = createCollection(
+      electricCollectionOptions({
+        id: `temp-verify-users-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${usersTable}`,
+          },
+        },
+        syncMode: `eager`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const tempPostsCollection = createCollection(
+      electricCollectionOptions({
+        id: `temp-verify-posts-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${postsTable}`,
+          },
+        },
+        syncMode: `eager`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const tempCommentsCollection = createCollection(
+      electricCollectionOptions({
+        id: `temp-verify-comments-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${commentsTable}`,
+          },
+        },
+        syncMode: `eager`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      }),
+    )
+
+    await Promise.all([
+      tempUsersCollection.preload(),
+      tempPostsCollection.preload(),
+      tempCommentsCollection.preload(),
+    ])
+
+    await Promise.all([
+      waitFor(() => tempUsersCollection.size >= seedData.users.length, {
+        timeout: 30000,
+        interval: 500,
+        message: `Electric replication has not processed WAL entries for users (got ${tempUsersCollection.size}/${seedData.users.length})`,
+      }),
+      waitFor(() => tempPostsCollection.size >= seedData.posts.length, {
+        timeout: 30000,
+        interval: 500,
+        message: `Electric replication has not processed WAL entries for posts (got ${tempPostsCollection.size}/${seedData.posts.length})`,
+      }),
+      waitFor(() => tempCommentsCollection.size >= seedData.comments.length, {
+        timeout: 30000,
+        interval: 500,
+        message: `Electric replication has not processed WAL entries for comments (got ${tempCommentsCollection.size}/${seedData.comments.length})`,
+      }),
+    ])
+
+    // Clean up the temporary collections
+    await Promise.all([
+      tempUsersCollection.cleanup(),
+      tempPostsCollection.cleanup(),
+      tempCommentsCollection.cleanup(),
+    ])
+
+    // Create REAL Electric collections
+    const eagerUsers = createCollection(
+      electricCollectionOptions({
+        id: `electric-e2e-users-eager-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${usersTable}`,
+          },
+        },
+        syncMode: `eager`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const eagerPosts = createCollection(
+      electricCollectionOptions({
+        id: `electric-e2e-posts-eager-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${postsTable}`,
+          },
+        },
+        syncMode: `eager`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const eagerComments = createCollection(
+      electricCollectionOptions({
+        id: `electric-e2e-comments-eager-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${commentsTable}`,
+          },
+        },
+        syncMode: `eager`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const onDemandUsers = createCollection(
+      electricCollectionOptions({
+        id: `electric-e2e-users-ondemand-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${usersTable}`,
+          },
+        },
+        syncMode: `on-demand`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const onDemandPosts = createCollection(
+      electricCollectionOptions({
+        id: `electric-e2e-posts-ondemand-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${postsTable}`,
+          },
+        },
+        syncMode: `on-demand`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const onDemandComments = createCollection(
+      electricCollectionOptions({
+        id: `electric-e2e-comments-ondemand-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${commentsTable}`,
+          },
+        },
+        syncMode: `on-demand`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      }),
+    )
+
+    // Create control mechanisms for progressive collections
+    // These allow tests to explicitly control when the atomic swap happens
+    // We use a ref object so each test can get a fresh promise
+    const usersUpToDateControl = {
+      current: null as (() => void) | null,
+      createPromise: () =>
+        new Promise<void>((resolve) => {
+          usersUpToDateControl.current = resolve
+        }),
+    }
+    const postsUpToDateControl = {
+      current: null as (() => void) | null,
+      createPromise: () =>
+        new Promise<void>((resolve) => {
+          postsUpToDateControl.current = resolve
+        }),
+    }
+    const commentsUpToDateControl = {
+      current: null as (() => void) | null,
+      createPromise: () =>
+        new Promise<void>((resolve) => {
+          commentsUpToDateControl.current = resolve
+        }),
+    }
+
+    const progressiveUsers = createCollection(
+      electricCollectionOptions({
+        id: `electric-e2e-users-progressive-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${usersTable}`,
+          },
+        },
+        syncMode: `progressive`,
+        getKey: (item: any) => item.id,
+        startSync: false, // Don't start immediately - tests will start when ready
+        [ELECTRIC_TEST_HOOKS]: {
+          beforeMarkingReady: () => usersUpToDateControl.createPromise(),
+        },
+      }),
+    )
+
+    const progressivePosts = createCollection(
+      electricCollectionOptions({
+        id: `electric-e2e-posts-progressive-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${postsTable}`,
+          },
+        },
+        syncMode: `progressive`,
+        getKey: (item: any) => item.id,
+        startSync: false, // Don't start immediately - tests will start when ready
+        [ELECTRIC_TEST_HOOKS]: {
+          beforeMarkingReady: () => postsUpToDateControl.createPromise(),
+        },
+      }),
+    )
+
+    const progressiveComments = createCollection(
+      electricCollectionOptions({
+        id: `electric-e2e-comments-progressive-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: {
+            table: `${testSchema}.${commentsTable}`,
+          },
+        },
+        syncMode: `progressive`,
+        getKey: (item: any) => item.id,
+        startSync: false, // Don't start immediately - tests will start when ready
+        [ELECTRIC_TEST_HOOKS]: {
+          beforeMarkingReady: () => commentsUpToDateControl.createPromise(),
+        },
+      }),
+    )
+
+    // Wait for eager collections to sync all data
+    await eagerUsers.preload()
+    await eagerPosts.preload()
+    await eagerComments.preload()
+
+    // Wait for on-demand collections to be ready (they start empty)
+    await onDemandUsers.preload()
+    await onDemandPosts.preload()
+    await onDemandComments.preload()
+
+    // Progressive collections start syncing in background
+    // Note: We DON'T call preload() here because the test hooks will block
+    // Individual progressive tests will handle preload and release as needed
+
+    config = {
+      collections: {
+        eager: {
+          users: eagerUsers as any,
+          posts: eagerPosts as any,
+          comments: eagerComments as any,
+        },
+        onDemand: {
+          users: onDemandUsers as any,
+          posts: onDemandPosts as any,
+          comments: onDemandComments as any,
+        },
+        progressive: {
+          users: progressiveUsers as any,
+          posts: progressivePosts as any,
+          comments: progressiveComments as any,
+        },
+      },
+      hasReplicationLag: true, // Electric has async replication lag
+      progressiveTestControl: {
+        releaseInitialSync: () => {
+          usersUpToDateControl.current?.()
+          postsUpToDateControl.current?.()
+          commentsUpToDateControl.current?.()
+        },
+      },
+      tagsTestSetup: {
+        dbClient,
+        baseUrl,
+        testSchema,
+        usersTable,
+        postsTable,
+      },
+      getTxid: async () => {
+        // Get the current transaction ID from the last operation
+        // This uses pg_current_xact_id_if_assigned() which returns the txid
+        // Note: This gets the CURRENT transaction's ID, so must be called
+        // immediately after an insert in the same transaction context
+        const result = await dbClient.query(
+          `SELECT pg_current_xact_id_if_assigned()::text::bigint as txid`,
+        )
+        return result.rows[0]?.txid || null
+      },
+      mutations: {
+        // Use direct SQL for Electric tests (simulates external changes)
+        // This tests that Electric sync picks up database changes
+        insertUser: async (user) => {
+          await dbClient.query(
+            `INSERT INTO ${usersTable} (id, name, email, age, "isActive", "createdAt", metadata, "deletedAt")
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+            [
+              user.id,
+              user.name,
+              user.email || null,
+              user.age,
+              user.isActive,
+              user.createdAt,
+              user.metadata ? JSON.stringify(user.metadata) : null,
+              user.deletedAt || null,
+            ],
+          )
+        },
+        updateUser: async (id, updates) => {
+          const setClauses: Array<string> = []
+          const values: Array<any> = []
+          let paramIndex = 1
+
+          if (updates.age !== undefined) {
+            setClauses.push(`age = $${paramIndex++}`)
+            values.push(updates.age)
+          }
+          if (updates.name !== undefined) {
+            setClauses.push(`name = $${paramIndex++}`)
+            values.push(updates.name)
+          }
+          if (updates.email !== undefined) {
+            setClauses.push(`email = $${paramIndex++}`)
+            values.push(updates.email)
+          }
+          if (updates.isActive !== undefined) {
+            setClauses.push(`"isActive" = $${paramIndex++}`)
+            values.push(updates.isActive)
+          }
+
+          values.push(id)
+          await dbClient.query(
+            `UPDATE ${usersTable} SET ${setClauses.join(`, `)} WHERE id = $${paramIndex}`,
+            values,
+          )
+        },
+        deleteUser: async (id) => {
+          await dbClient.query(`DELETE FROM ${usersTable} WHERE id = $1`, [id])
+        },
+        insertPost: async (post) => {
+          await dbClient.query(
+            `INSERT INTO ${postsTable} (id, "userId", title, content, "viewCount", "largeViewCount", "publishedAt", "deletedAt")
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+            [
+              post.id,
+              post.userId,
+              post.title,
+              post.content || null,
+              post.viewCount,
+              post.largeViewCount.toString(), // BigInt must be converted to string for pg
+              post.publishedAt || null,
+              post.deletedAt || null,
+            ],
+          )
+        },
+      },
+      setup: async () => {},
+      afterEach: async () => {
+        // Clean up and restart on-demand collections
+        // This validates cleanup() works and each test starts fresh
+        await onDemandUsers.cleanup()
+        await onDemandPosts.cleanup()
+        await onDemandComments.cleanup()
+
+        // Restart sync after cleanup
+        onDemandUsers.startSyncImmediate()
+        onDemandPosts.startSyncImmediate()
+        onDemandComments.startSyncImmediate()
+
+        // Wait for collections to be ready
+        await onDemandUsers.preload()
+        await onDemandPosts.preload()
+        await onDemandComments.preload()
+      },
+      teardown: async () => {
+        await Promise.all([
+          eagerUsers.cleanup(),
+          eagerPosts.cleanup(),
+          eagerComments.cleanup(),
+          onDemandUsers.cleanup(),
+          onDemandPosts.cleanup(),
+          onDemandComments.cleanup(),
+          progressiveUsers.cleanup(),
+          progressivePosts.cleanup(),
+          progressiveComments.cleanup(),
+        ])
+      },
+    }
+  }, 60000) // 60 second timeout for setup
+
+  afterEach(async () => {
+    if (config.afterEach) {
+      await config.afterEach()
+    }
+  })
+
+  afterAll(async () => {
+    await config.teardown()
+
+    // Drop tables
+    try {
+      await dbClient.query(`DROP TABLE IF EXISTS ${commentsTable}`)
+      await dbClient.query(`DROP TABLE IF EXISTS ${postsTable}`)
+      await dbClient.query(`DROP TABLE IF EXISTS ${usersTable}`)
+    } catch (e) {
+      console.error(`Error dropping tables:`, e)
+    }
+    await dbClient.end()
+  })
+
+  // Helper to get config
+  function getConfig() {
+    return Promise.resolve(config)
+  }
+
+  // Run all test suites
+  createPredicatesTestSuite(getConfig)
+  createPaginationTestSuite(getConfig)
+  createJoinsTestSuite(getConfig)
+  createDeduplicationTestSuite(getConfig)
+  createCollationTestSuite(getConfig)
+  createMutationsTestSuite(getConfig)
+  createLiveUpdatesTestSuite(getConfig)
+  createProgressiveTestSuite(getConfig)
+  createMovesTestSuite(getConfig as any)
+})
diff --git a/packages/electric-db-collection/package.json b/packages/electric-db-collection/package.json
index 1661d9ddb..76af411d8 100644
--- a/packages/electric-db-collection/package.json
+++ b/packages/electric-db-collection/package.json
@@ -1,18 +1,32 @@
 {
   "name": "@tanstack/electric-db-collection",
+  "version": "0.2.30",
   "description": "ElectricSQL collection for TanStack DB",
-  "version": "0.1.35",
-  "dependencies": {
-    "@electric-sql/client": "^1.0.14",
-    "@standard-schema/spec": "^1.0.0",
-    "@tanstack/db": "workspace:*",
-    "@tanstack/store": "^0.8.0",
-    "debug": "^4.4.3"
+  "author": "Kyle Mathews",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/db.git",
+    "directory": "packages/electric-db-collection"
   },
-  "devDependencies": {
-    "@types/debug": "^4.1.12",
-    "@vitest/coverage-istanbul": "^3.2.4"
+  "homepage": "https://tanstack.com/db",
+  "keywords": [
+    "electric",
+    "sql",
+    "optimistic",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "lint": "eslint . --fix",
+    "test": "vitest run",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts"
   },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -26,34 +40,22 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
-  "packageManager": "pnpm@10.18.3",
-  "author": "Kyle Mathews",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/TanStack/db.git",
-    "directory": "packages/electric-db-collection"
-  },
-  "homepage": "https://tanstack.com/db",
-  "keywords": [
-    "electric",
-    "sql",
-    "optimistic",
-    "typescript"
-  ],
-  "scripts": {
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "lint": "eslint . --fix",
-    "test": "npx vitest --run"
+  "dependencies": {
+    "@electric-sql/client": "^1.3.1",
+    "@standard-schema/spec": "^1.1.0",
+    "@tanstack/db": "workspace:*",
+    "@tanstack/store": "^0.8.0",
+    "debug": "^4.4.3"
   },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@types/pg": "^8.16.0",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "pg": "^8.16.3"
+  }
 }
diff --git a/packages/electric-db-collection/src/electric.ts b/packages/electric-db-collection/src/electric.ts
index bdd6f34a7..25bf29e53 100644
--- a/packages/electric-db-collection/src/electric.ts
+++ b/packages/electric-db-collection/src/electric.ts
@@ -3,25 +3,46 @@ import {
   isChangeMessage,
   isControlMessage,
   isVisibleInSnapshot,
-} from "@electric-sql/client"
-import { Store } from "@tanstack/store"
-import DebugModule from "debug"
+} from '@electric-sql/client'
+import { Store } from '@tanstack/store'
+import DebugModule from 'debug'
+import { DeduplicatedLoadSubset, and } from '@tanstack/db'
 import {
   ExpectedNumberInAwaitTxIdError,
   StreamAbortedError,
   TimeoutWaitingForMatchError,
   TimeoutWaitingForTxIdError,
-} from "./errors"
+} from './errors'
+import { compileSQL } from './sql-compiler'
+import {
+  addTagToIndex,
+  findRowsMatchingPattern,
+  getTagLength,
+  isMoveOutMessage,
+  removeTagFromIndex,
+  tagMatchesPattern,
+} from './tag-index'
+import type { ColumnEncoder } from './sql-compiler'
+import type {
+  MoveOutPattern,
+  MoveTag,
+  ParsedMoveTag,
+  RowId,
+  TagIndex,
+} from './tag-index'
 import type {
   BaseCollectionConfig,
+  ChangeMessageOrDeleteKeyMessage,
   CollectionConfig,
   DeleteMutationFnParams,
   InsertMutationFnParams,
+  LoadSubsetOptions,
   SyncConfig,
+  SyncMode,
   UpdateMutationFnParams,
   UtilsRecord,
-} from "@tanstack/db"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+} from '@tanstack/db'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type {
   ControlMessage,
   GetExtensions,
@@ -29,13 +50,29 @@ import type {
   PostgresSnapshot,
   Row,
   ShapeStreamOptions,
-} from "@electric-sql/client"
+} from '@electric-sql/client'
 
 // Re-export for user convenience in custom match functions
-export { isChangeMessage, isControlMessage } from "@electric-sql/client"
+export { isChangeMessage, isControlMessage } from '@electric-sql/client'
 
 const debug = DebugModule.debug(`ts/db:electric`)
 
+/**
+ * Symbol for internal test hooks (hidden from public API)
+ */
+export const ELECTRIC_TEST_HOOKS = Symbol(`electricTestHooks`)
+
+/**
+ * Internal test hooks interface (for testing only)
+ */
+export interface ElectricTestHooks {
+  /**
+   * Called before marking collection ready after first up-to-date in progressive mode
+   * Allows tests to pause and validate snapshot phase before atomic swap completes
+   */
+  beforeMarkingReady?: () => Promise<void>
+}
+
 /**
  * Type representing a transaction ID in ElectricSQL
  */
@@ -46,16 +83,22 @@ export type Txid = number
  * indicating if the mutation has been synchronized
  */
 export type MatchFunction<T extends Row<unknown>> = (
-  message: Message<T>
+  message: Message<T>,
 ) => boolean
 
 /**
  * Matching strategies for Electric synchronization
  * Handlers can return:
- * - Txid strategy: { txid: number | number[] } (recommended)
+ * - Txid strategy: { txid: number | number[], timeout?: number } (recommended)
  * - Void (no return value) - mutation completes without waiting
+ *
+ * The optional timeout property specifies how long to wait for the txid(s) in milliseconds.
+ * If not specified, defaults to 5000ms.
  */
-export type MatchingStrategy = { txid: Txid | Array<Txid> } | void
+export type MatchingStrategy = {
+  txid: Txid | Array<Txid>
+  timeout?: number
+} | void
 
 /**
  * Type representing a snapshot end message
@@ -72,6 +115,24 @@ type InferSchemaOutput<T> = T extends StandardSchemaV1
     : Record<string, unknown>
   : Record<string, unknown>
 
+/**
+ * The mode of sync to use for the collection.
+ * @default `eager`
+ * @description
+ * - `eager`:
+ *   - syncs all data immediately on preload
+ *   - collection will be marked as ready once the sync is complete
+ *   - there is no incremental sync
+ * - `on-demand`:
+ *   - syncs data in incremental snapshots when the collection is queried
+ *   - collection will be marked as ready immediately after the first snapshot is synced
+ * - `progressive`:
+ *   - syncs all data for the collection in the background
+ *   - uses incremental snapshots during the initial sync to provide a fast path to the data required for queries
+ *   - collection will be marked as ready once the full sync is complete
+ */
+export type ElectricSyncMode = SyncMode | `progressive`
+
 /**
  * Configuration interface for Electric collection options
  * @template T - The type of items in the collection
@@ -81,18 +142,31 @@ export interface ElectricCollectionConfig<
   T extends Row<unknown> = Row<unknown>,
   TSchema extends StandardSchemaV1 = never,
 > extends Omit<
-    BaseCollectionConfig<T, string | number, TSchema, UtilsRecord, any>,
-    `onInsert` | `onUpdate` | `onDelete`
-  > {
+  BaseCollectionConfig<
+    T,
+    string | number,
+    TSchema,
+    ElectricCollectionUtils<T>,
+    any
+  >,
+  `onInsert` | `onUpdate` | `onDelete` | `syncMode`
+> {
   /**
    * Configuration options for the ElectricSQL ShapeStream
    */
   shapeOptions: ShapeStreamOptions<GetExtensions<T>>
+  syncMode?: ElectricSyncMode
+
+  /**
+   * Internal test hooks (for testing only)
+   * Hidden via Symbol to prevent accidental usage in production
+   */
+  [ELECTRIC_TEST_HOOKS]?: ElectricTestHooks
 
   /**
    * Optional asynchronous handler function called before an insert operation
    * @param params Object containing transaction and collection information
-   * @returns Promise resolving to { txid } or void
+   * @returns Promise resolving to { txid, timeout? } or void
    * @example
    * // Basic Electric insert handler with txid (recommended)
    * onInsert: async ({ transaction }) => {
@@ -104,6 +178,16 @@ export interface ElectricCollectionConfig<
    * }
    *
    * @example
+   * // Insert handler with custom timeout
+   * onInsert: async ({ transaction }) => {
+   *   const newItem = transaction.mutations[0].modified
+   *   const result = await api.todos.create({
+   *     data: newItem
+   *   })
+   *   return { txid: result.txid, timeout: 10000 } // Wait up to 10 seconds
+   * }
+   *
+   * @example
    * // Insert handler with multiple items - return array of txids
    * onInsert: async ({ transaction }) => {
    *   const items = transaction.mutations.map(m => m.modified)
@@ -125,12 +209,18 @@ export interface ElectricCollectionConfig<
    *   )
    * }
    */
-  onInsert?: (params: InsertMutationFnParams<T>) => Promise<MatchingStrategy>
+  onInsert?: (
+    params: InsertMutationFnParams<
+      T,
+      string | number,
+      ElectricCollectionUtils<T>
+    >,
+  ) => Promise<MatchingStrategy>
 
   /**
    * Optional asynchronous handler function called before an update operation
    * @param params Object containing transaction and collection information
-   * @returns Promise resolving to { txid } or void
+   * @returns Promise resolving to { txid, timeout? } or void
    * @example
    * // Basic Electric update handler with txid (recommended)
    * onUpdate: async ({ transaction }) => {
@@ -154,12 +244,18 @@ export interface ElectricCollectionConfig<
    *   )
    * }
    */
-  onUpdate?: (params: UpdateMutationFnParams<T>) => Promise<MatchingStrategy>
+  onUpdate?: (
+    params: UpdateMutationFnParams<
+      T,
+      string | number,
+      ElectricCollectionUtils<T>
+    >,
+  ) => Promise<MatchingStrategy>
 
   /**
    * Optional asynchronous handler function called before a delete operation
    * @param params Object containing transaction and collection information
-   * @returns Promise resolving to { txid } or void
+   * @returns Promise resolving to { txid, timeout? } or void
    * @example
    * // Basic Electric delete handler with txid (recommended)
    * onDelete: async ({ transaction }) => {
@@ -182,27 +278,42 @@ export interface ElectricCollectionConfig<
    *   )
    * }
    */
-  onDelete?: (params: DeleteMutationFnParams<T>) => Promise<MatchingStrategy>
+  onDelete?: (
+    params: DeleteMutationFnParams<
+      T,
+      string | number,
+      ElectricCollectionUtils<T>
+    >,
+  ) => Promise<MatchingStrategy>
 }
 
 function isUpToDateMessage<T extends Row<unknown>>(
-  message: Message<T>
+  message: Message<T>,
 ): message is ControlMessage & { up_to_date: true } {
   return isControlMessage(message) && message.headers.control === `up-to-date`
 }
 
 function isMustRefetchMessage<T extends Row<unknown>>(
-  message: Message<T>
+  message: Message<T>,
 ): message is ControlMessage & { headers: { control: `must-refetch` } } {
   return isControlMessage(message) && message.headers.control === `must-refetch`
 }
 
 function isSnapshotEndMessage<T extends Row<unknown>>(
-  message: Message<T>
+  message: Message<T>,
 ): message is SnapshotEndMessage {
   return isControlMessage(message) && message.headers.control === `snapshot-end`
 }
 
+function isSubsetEndMessage<T extends Row<unknown>>(
+  message: Message<T>,
+): message is ControlMessage & { headers: { control: `subset-end` } } {
+  return (
+    isControlMessage(message) &&
+    (message.headers.control as string) === `subset-end`
+  )
+}
+
 function parseSnapshotMessage(message: SnapshotEndMessage): PostgresSnapshot {
   return {
     xmin: message.headers.xmin,
@@ -213,11 +324,155 @@ function parseSnapshotMessage(message: SnapshotEndMessage): PostgresSnapshot {
 
 // Check if a message contains txids in its headers
 function hasTxids<T extends Row<unknown>>(
-  message: Message<T>
+  message: Message<T>,
 ): message is Message<T> & { headers: { txids?: Array<Txid> } } {
   return `txids` in message.headers && Array.isArray(message.headers.txids)
 }
 
+/**
+ * Creates a deduplicated loadSubset handler for progressive/on-demand modes
+ * Returns null for eager mode, or a DeduplicatedLoadSubset instance for other modes.
+ * Handles fetching snapshots in progressive mode during buffering phase,
+ * and requesting snapshots in on-demand mode.
+ *
+ * When cursor expressions are provided (whereFrom/whereCurrent), makes two
+ * requestSnapshot calls:
+ * - One for whereFrom (rows > cursor) with limit
+ * - One for whereCurrent (rows = cursor, for tie-breaking) without limit
+ */
+function createLoadSubsetDedupe<T extends Row<unknown>>({
+  stream,
+  syncMode,
+  isBufferingInitialSync,
+  begin,
+  write,
+  commit,
+  collectionId,
+  encodeColumnName,
+  signal,
+}: {
+  stream: ShapeStream<T>
+  syncMode: ElectricSyncMode
+  isBufferingInitialSync: () => boolean
+  begin: () => void
+  write: (mutation: {
+    type: `insert` | `update` | `delete`
+    value: T
+    metadata: Record<string, unknown>
+  }) => void
+  commit: () => void
+  collectionId?: string
+  /**
+   * Optional function to encode column names (e.g., camelCase to snake_case).
+   * This is typically the `encode` function from shapeOptions.columnMapper.
+   */
+  encodeColumnName?: ColumnEncoder
+  /**
+   * Abort signal to check if the stream has been aborted during cleanup.
+   * When aborted, errors from requestSnapshot are silently ignored.
+   */
+  signal: AbortSignal
+}): DeduplicatedLoadSubset | null {
+  if (syncMode === `eager`) {
+    return null
+  }
+
+  const compileOptions = encodeColumnName ? { encodeColumnName } : undefined
+  const logPrefix = collectionId ? `[${collectionId}] ` : ``
+
+  /**
+   * Handles errors from snapshot operations. Returns true if the error was
+   * handled (signal aborted during cleanup), false if it should be re-thrown.
+   */
+  function handleSnapshotError(error: unknown, operation: string): boolean {
+    if (signal.aborted) {
+      debug(`${logPrefix}Ignoring ${operation} error during cleanup: %o`, error)
+      return true
+    }
+    debug(`${logPrefix}Error in ${operation}: %o`, error)
+    return false
+  }
+
+  const loadSubset = async (opts: LoadSubsetOptions) => {
+    if (isBufferingInitialSync()) {
+      const snapshotParams = compileSQL<T>(opts, compileOptions)
+      try {
+        const { data: rows } = await stream.fetchSnapshot(snapshotParams)
+
+        if (!isBufferingInitialSync()) {
+          debug(`${logPrefix}Ignoring snapshot - sync completed while fetching`)
+          return
+        }
+
+        if (rows.length > 0) {
+          begin()
+          for (const row of rows) {
+            write({
+              type: `insert`,
+              value: row.value,
+              metadata: { ...row.headers },
+            })
+          }
+          commit()
+          debug(`${logPrefix}Applied snapshot with ${rows.length} rows`)
+        }
+      } catch (error) {
+        if (handleSnapshotError(error, `fetchSnapshot`)) {
+          return
+        }
+        throw error
+      }
+      return
+    }
+
+    if (syncMode === `progressive`) {
+      return
+    }
+
+    const { cursor, where, orderBy, limit } = opts
+
+    try {
+      if (cursor) {
+        const whereCurrentOpts: LoadSubsetOptions = {
+          where: where ? and(where, cursor.whereCurrent) : cursor.whereCurrent,
+          orderBy,
+        }
+        const whereCurrentParams = compileSQL<T>(
+          whereCurrentOpts,
+          compileOptions,
+        )
+
+        const whereFromOpts: LoadSubsetOptions = {
+          where: where ? and(where, cursor.whereFrom) : cursor.whereFrom,
+          orderBy,
+          limit,
+        }
+        const whereFromParams = compileSQL<T>(whereFromOpts, compileOptions)
+
+        debug(`${logPrefix}Requesting cursor.whereCurrent snapshot (all ties)`)
+        debug(
+          `${logPrefix}Requesting cursor.whereFrom snapshot (with limit ${limit})`,
+        )
+
+        await Promise.all([
+          stream.requestSnapshot(whereCurrentParams),
+          stream.requestSnapshot(whereFromParams),
+        ])
+      } else {
+        const snapshotParams = compileSQL<T>(opts, compileOptions)
+        await stream.requestSnapshot(snapshotParams)
+      }
+    } catch (error) {
+      if (handleSnapshotError(error, `requestSnapshot`)) {
+        return
+      }
+      throw error
+    }
+  }
+
+  return new DeduplicatedLoadSubset({ loadSubset })
+}
+
 /**
  * Type for the awaitTxId utility function
  */
@@ -228,14 +483,15 @@ export type AwaitTxIdFn = (txId: Txid, timeout?: number) => Promise<boolean>
  */
 export type AwaitMatchFn<T extends Row<unknown>> = (
   matchFn: MatchFunction<T>,
-  timeout?: number
+  timeout?: number,
 ) => Promise<boolean>
 
 /**
  * Electric collection utilities type
  */
-export interface ElectricCollectionUtils<T extends Row<unknown> = Row<unknown>>
-  extends UtilsRecord {
+export interface ElectricCollectionUtils<
+  T extends Row<unknown> = Row<unknown>,
+> extends UtilsRecord {
   awaitTxId: AwaitTxIdFn
   awaitMatch: AwaitMatchFn<T>
 }
@@ -254,10 +510,10 @@ export interface ElectricCollectionUtils<T extends Row<unknown> = Row<unknown>>
 export function electricCollectionOptions<T extends StandardSchemaV1>(
   config: ElectricCollectionConfig<InferSchemaOutput<T>, T> & {
     schema: T
-  }
-): CollectionConfig<InferSchemaOutput<T>, string | number, T> & {
+  },
+): Omit<CollectionConfig<InferSchemaOutput<T>, string | number, T>, `utils`> & {
   id?: string
-  utils: ElectricCollectionUtils
+  utils: ElectricCollectionUtils<InferSchemaOutput<T>>
   schema: T
 }
 
@@ -265,22 +521,28 @@ export function electricCollectionOptions<T extends StandardSchemaV1>(
 export function electricCollectionOptions<T extends Row<unknown>>(
   config: ElectricCollectionConfig<T> & {
     schema?: never // prohibit schema
-  }
-): CollectionConfig<T, string | number> & {
+  },
+): Omit<CollectionConfig<T, string | number>, `utils`> & {
   id?: string
-  utils: ElectricCollectionUtils
+  utils: ElectricCollectionUtils<T>
   schema?: never // no schema in the result
 }
 
-export function electricCollectionOptions(
-  config: ElectricCollectionConfig<any, any>
-): CollectionConfig<any, string | number, any> & {
+export function electricCollectionOptions<T extends Row<unknown>>(
+  config: ElectricCollectionConfig<T, any>,
+): Omit<
+  CollectionConfig<T, string | number, any, ElectricCollectionUtils<T>>,
+  `utils`
+> & {
   id?: string
-  utils: ElectricCollectionUtils
+  utils: ElectricCollectionUtils<T>
   schema?: any
 } {
   const seenTxids = new Store<Set<Txid>>(new Set([]))
   const seenSnapshots = new Store<Array<PostgresSnapshot>>([])
+  const internalSyncMode = config.syncMode ?? `eager`
+  const finalSyncMode =
+    internalSyncMode === `progressive` ? `on-demand` : internalSyncMode
   const pendingMatches = new Store<
     Map<
       string,
@@ -297,6 +559,10 @@ export function electricCollectionOptions(
   // Buffer messages since last up-to-date to handle race conditions
   const currentBatchMessages = new Store<Array<Message<any>>>([])
 
+  // Track whether the current batch has been committed (up-to-date received)
+  // This allows awaitMatch to resolve immediately for messages from committed batches
+  const batchCommitted = new Store<boolean>(false)
+
   /**
    * Helper function to remove multiple matches from the pendingMatches store
    */
@@ -322,20 +588,23 @@ export function electricCollectionOptions(
         matchesToResolve.push(matchId)
         debug(
           `${config.id ? `[${config.id}] ` : ``}awaitMatch resolved on up-to-date for match %s`,
-          matchId
+          matchId,
         )
       }
     })
     removePendingMatches(matchesToResolve)
   }
-  const sync = createElectricSync<any>(config.shapeOptions, {
+  const sync = createElectricSync<T>(config.shapeOptions, {
     seenTxids,
     seenSnapshots,
+    syncMode: internalSyncMode,
     pendingMatches,
     currentBatchMessages,
+    batchCommitted,
     removePendingMatches,
     resolveMatchedPendingMatches,
     collectionId: config.id,
+    testHooks: config[ELECTRIC_TEST_HOOKS],
   })
 
   /**
@@ -346,11 +615,11 @@ export function electricCollectionOptions(
    */
   const awaitTxId: AwaitTxIdFn = async (
     txId: Txid,
-    timeout: number = 5000
+    timeout: number = 5000,
   ): Promise<boolean> => {
     debug(
       `${config.id ? `[${config.id}] ` : ``}awaitTxId called with txid %d`,
-      txId
+      txId,
     )
     if (typeof txId !== `number`) {
       throw new ExpectedNumberInAwaitTxIdError(typeof txId, config.id)
@@ -362,7 +631,7 @@ export function electricCollectionOptions(
 
     // Then check if the txid is in any of the seen snapshots
     const hasSnapshot = seenSnapshots.state.some((snapshot) =>
-      isVisibleInSnapshot(txId, snapshot)
+      isVisibleInSnapshot(txId, snapshot),
     )
     if (hasSnapshot) return true
 
@@ -377,7 +646,7 @@ export function electricCollectionOptions(
         if (seenTxids.state.has(txId)) {
           debug(
             `${config.id ? `[${config.id}] ` : ``}awaitTxId found match for txid %o`,
-            txId
+            txId,
           )
           clearTimeout(timeoutId)
           unsubscribeSeenTxids()
@@ -388,13 +657,13 @@ export function electricCollectionOptions(
 
       const unsubscribeSeenSnapshots = seenSnapshots.subscribe(() => {
         const visibleSnapshot = seenSnapshots.state.find((snapshot) =>
-          isVisibleInSnapshot(txId, snapshot)
+          isVisibleInSnapshot(txId, snapshot),
         )
         if (visibleSnapshot) {
           debug(
             `${config.id ? `[${config.id}] ` : ``}awaitTxId found match for txid %o in snapshot %o`,
             txId,
-            visibleSnapshot
+            visibleSnapshot,
           )
           clearTimeout(timeoutId)
           unsubscribeSeenSnapshots()
@@ -413,10 +682,10 @@ export function electricCollectionOptions(
    */
   const awaitMatch: AwaitMatchFn<any> = async (
     matchFn: MatchFunction<any>,
-    timeout: number = 3000
+    timeout: number = 3000,
   ): Promise<boolean> => {
     debug(
-      `${config.id ? `[${config.id}] ` : ``}awaitMatch called with custom function`
+      `${config.id ? `[${config.id}] ` : ``}awaitMatch called with custom function`,
     )
 
     return new Promise((resolve, reject) => {
@@ -442,7 +711,7 @@ export function electricCollectionOptions(
       const checkMatch = (message: Message<any>) => {
         if (matchFn(message)) {
           debug(
-            `${config.id ? `[${config.id}] ` : ``}awaitMatch found matching message, waiting for up-to-date`
+            `${config.id ? `[${config.id}] ` : ``}awaitMatch found matching message, waiting for up-to-date`,
           )
           // Mark as matched but don't resolve yet - wait for up-to-date
           pendingMatches.setState((current) => {
@@ -461,10 +730,21 @@ export function electricCollectionOptions(
       // Check against current batch messages first to handle race conditions
       for (const message of currentBatchMessages.state) {
         if (matchFn(message)) {
+          // If batch is committed (up-to-date already received), resolve immediately
+          // just like awaitTxId does when it finds a txid in seenTxids
+          if (batchCommitted.state) {
+            debug(
+              `${config.id ? `[${config.id}] ` : ``}awaitMatch found immediate match in committed batch, resolving immediately`,
+            )
+            clearTimeout(timeoutId)
+            resolve(true)
+            return
+          }
+
+          // If batch is not yet committed, register match and wait for up-to-date
           debug(
-            `${config.id ? `[${config.id}] ` : ``}awaitMatch found immediate match in current batch, waiting for up-to-date`
+            `${config.id ? `[${config.id}] ` : ``}awaitMatch found immediate match in current batch, waiting for up-to-date`,
           )
-          // Register match as already matched
           pendingMatches.setState((current) => {
             const newMatches = new Map(current)
             newMatches.set(matchId, {
@@ -472,7 +752,7 @@ export function electricCollectionOptions(
               resolve,
               reject,
               timeoutId,
-              matched: true, // Already matched
+              matched: true, // Already matched, will resolve on up-to-date
             })
             return newMatches
           })
@@ -500,15 +780,16 @@ export function electricCollectionOptions(
    * Process matching strategy and wait for synchronization
    */
   const processMatchingStrategy = async (
-    result: MatchingStrategy
+    result: MatchingStrategy,
   ): Promise<void> => {
     // Only wait if result contains txid
     if (result && `txid` in result) {
+      const timeout = result.timeout
       // Handle both single txid and array of txids
       if (Array.isArray(result.txid)) {
-        await Promise.all(result.txid.map(awaitTxId))
+        await Promise.all(result.txid.map((txid) => awaitTxId(txid, timeout)))
       } else {
-        await awaitTxId(result.txid)
+        await awaitTxId(result.txid, timeout)
       }
     }
     // If result is void/undefined, don't wait - mutation completes immediately
@@ -516,7 +797,13 @@ export function electricCollectionOptions(
 
   // Create wrapper handlers for direct persistence operations that handle different matching strategies
   const wrappedOnInsert = config.onInsert
-    ? async (params: InsertMutationFnParams<any>) => {
+    ? async (
+        params: InsertMutationFnParams<
+          any,
+          string | number,
+          ElectricCollectionUtils<T>
+        >,
+      ) => {
         const handlerResult = await config.onInsert!(params)
         await processMatchingStrategy(handlerResult)
         return handlerResult
@@ -524,7 +811,13 @@ export function electricCollectionOptions(
     : undefined
 
   const wrappedOnUpdate = config.onUpdate
-    ? async (params: UpdateMutationFnParams<any>) => {
+    ? async (
+        params: UpdateMutationFnParams<
+          any,
+          string | number,
+          ElectricCollectionUtils<T>
+        >,
+      ) => {
         const handlerResult = await config.onUpdate!(params)
         await processMatchingStrategy(handlerResult)
         return handlerResult
@@ -532,7 +825,13 @@ export function electricCollectionOptions(
     : undefined
 
   const wrappedOnDelete = config.onDelete
-    ? async (params: DeleteMutationFnParams<any>) => {
+    ? async (
+        params: DeleteMutationFnParams<
+          any,
+          string | number,
+          ElectricCollectionUtils<T>
+        >,
+      ) => {
         const handlerResult = await config.onDelete!(params)
         await processMatchingStrategy(handlerResult)
         return handlerResult
@@ -550,6 +849,7 @@ export function electricCollectionOptions(
 
   return {
     ...restConfig,
+    syncMode: finalSyncMode,
     sync,
     onInsert: wrappedOnInsert,
     onUpdate: wrappedOnUpdate,
@@ -557,7 +857,7 @@ export function electricCollectionOptions(
     utils: {
       awaitTxId,
       awaitMatch,
-    } as ElectricCollectionUtils<any>,
+    },
   }
 }
 
@@ -567,6 +867,7 @@ export function electricCollectionOptions(
 function createElectricSync<T extends Row<unknown>>(
   shapeOptions: ShapeStreamOptions<GetExtensions<T>>,
   options: {
+    syncMode: ElectricSyncMode
     seenTxids: Store<Set<Txid>>
     seenSnapshots: Store<Array<PostgresSnapshot>>
     pendingMatches: Store<
@@ -582,25 +883,255 @@ function createElectricSync<T extends Row<unknown>>(
       >
     >
     currentBatchMessages: Store<Array<Message<T>>>
+    batchCommitted: Store<boolean>
     removePendingMatches: (matchIds: Array<string>) => void
     resolveMatchedPendingMatches: () => void
     collectionId?: string
-  }
+    testHooks?: ElectricTestHooks
+  },
 ): SyncConfig<T> {
   const {
     seenTxids,
     seenSnapshots,
+    syncMode,
     pendingMatches,
     currentBatchMessages,
+    batchCommitted,
     removePendingMatches,
     resolveMatchedPendingMatches,
     collectionId,
+    testHooks,
   } = options
   const MAX_BATCH_MESSAGES = 1000 // Safety limit for message buffer
 
   // Store for the relation schema information
   const relationSchema = new Store<string | undefined>(undefined)
 
+  const tagCache = new Map<MoveTag, ParsedMoveTag>()
+
+  // Parses a tag string into a MoveTag.
+  // It memoizes the result parsed tag such that future calls
+  // for the same tag string return the same MoveTag array.
+  const parseTag = (tag: MoveTag): ParsedMoveTag => {
+    const cachedTag = tagCache.get(tag)
+    if (cachedTag) {
+      return cachedTag
+    }
+
+    const parsedTag = tag.split(`|`)
+    tagCache.set(tag, parsedTag)
+    return parsedTag
+  }
+
+  // Tag tracking state
+  const rowTagSets = new Map<RowId, Set<MoveTag>>()
+  const tagIndex: TagIndex = []
+  let tagLength: number | undefined = undefined
+
+  /**
+   * Initialize the tag index with the correct length
+   */
+  const initializeTagIndex = (length: number): void => {
+    if (tagIndex.length < length) {
+      // Extend the index array to the required length
+      for (let i = tagIndex.length; i < length; i++) {
+        tagIndex[i] = new Map()
+      }
+    }
+  }
+
+  /**
+   * Add tags to a row and update the tag index
+   */
+  const addTagsToRow = (
+    tags: Array<MoveTag>,
+    rowId: RowId,
+    rowTagSet: Set<MoveTag>,
+  ): void => {
+    for (const tag of tags) {
+      const parsedTag = parseTag(tag)
+
+      // Infer tag length from first tag
+      if (tagLength === undefined) {
+        tagLength = getTagLength(parsedTag)
+        initializeTagIndex(tagLength)
+      }
+
+      // Validate tag length matches
+      const currentTagLength = getTagLength(parsedTag)
+      if (currentTagLength !== tagLength) {
+        debug(
+          `${collectionId ? `[${collectionId}] ` : ``}Tag length mismatch: expected ${tagLength}, got ${currentTagLength}`,
+        )
+        continue
+      }
+
+      rowTagSet.add(tag)
+      addTagToIndex(parsedTag, rowId, tagIndex, tagLength)
+    }
+  }
+
+  /**
+   * Remove tags from a row and update the tag index
+   */
+  const removeTagsFromRow = (
+    removedTags: Array<MoveTag>,
+    rowId: RowId,
+    rowTagSet: Set<MoveTag>,
+  ): void => {
+    if (tagLength === undefined) {
+      return
+    }
+
+    for (const tag of removedTags) {
+      const parsedTag = parseTag(tag)
+      rowTagSet.delete(tag)
+      removeTagFromIndex(parsedTag, rowId, tagIndex, tagLength)
+      // We aggresively evict the tag from the cache
+      // if this tag is shared with another row
+      // and is not removed from that other row
+      // then next time we encounter the tag it will be parsed again
+      tagCache.delete(tag)
+    }
+  }
+
+  /**
+   * Process tags for a change message (add and remove tags)
+   */
+  const processTagsForChangeMessage = (
+    tags: Array<MoveTag> | undefined,
+    removedTags: Array<MoveTag> | undefined,
+    rowId: RowId,
+  ): Set<MoveTag> => {
+    // Initialize tag set for this row if it doesn't exist (needed for checking deletion)
+    if (!rowTagSets.has(rowId)) {
+      rowTagSets.set(rowId, new Set())
+    }
+    const rowTagSet = rowTagSets.get(rowId)!
+
+    // Add new tags
+    if (tags) {
+      addTagsToRow(tags, rowId, rowTagSet)
+    }
+
+    // Remove tags
+    if (removedTags) {
+      removeTagsFromRow(removedTags, rowId, rowTagSet)
+    }
+
+    return rowTagSet
+  }
+
+  /**
+   * Clear all tag tracking state (used when truncating)
+   */
+  const clearTagTrackingState = (): void => {
+    rowTagSets.clear()
+    tagIndex.length = 0
+    tagLength = undefined
+  }
+
+  /**
+   * Remove all tags for a row from both the tag set and the index
+   * Used when a row is deleted
+   */
+  const clearTagsForRow = (rowId: RowId): void => {
+    if (tagLength === undefined) {
+      return
+    }
+
+    const rowTagSet = rowTagSets.get(rowId)
+    if (!rowTagSet) {
+      return
+    }
+
+    // Remove each tag from the index
+    for (const tag of rowTagSet) {
+      const parsedTag = parseTag(tag)
+      const currentTagLength = getTagLength(parsedTag)
+      if (currentTagLength === tagLength) {
+        removeTagFromIndex(parsedTag, rowId, tagIndex, tagLength)
+      }
+      tagCache.delete(tag)
+    }
+
+    // Remove the row from the tag sets map
+    rowTagSets.delete(rowId)
+  }
+
+  /**
+   * Remove matching tags from a row based on a pattern
+   * Returns true if the row's tag set is now empty
+   */
+  const removeMatchingTagsFromRow = (
+    rowId: RowId,
+    pattern: MoveOutPattern,
+  ): boolean => {
+    const rowTagSet = rowTagSets.get(rowId)
+    if (!rowTagSet) {
+      return false
+    }
+
+    // Find tags that match this pattern and remove them
+    for (const tag of rowTagSet) {
+      const parsedTag = parseTag(tag)
+      if (tagMatchesPattern(parsedTag, pattern)) {
+        rowTagSet.delete(tag)
+        removeTagFromIndex(parsedTag, rowId, tagIndex, tagLength!)
+      }
+    }
+
+    // Check if row's tag set is now empty
+    if (rowTagSet.size === 0) {
+      rowTagSets.delete(rowId)
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Process move-out event: remove matching tags from rows and delete rows with empty tag sets
+   */
+  const processMoveOutEvent = (
+    patterns: Array<MoveOutPattern>,
+    begin: () => void,
+    write: (message: ChangeMessageOrDeleteKeyMessage<T>) => void,
+    transactionStarted: boolean,
+  ): boolean => {
+    if (tagLength === undefined) {
+      debug(
+        `${collectionId ? `[${collectionId}] ` : ``}Received move-out message but no tag length set yet, ignoring`,
+      )
+      return transactionStarted
+    }
+
+    let txStarted = transactionStarted
+
+    // Process all patterns and collect rows to delete
+    for (const pattern of patterns) {
+      // Find all rows that match this pattern
+      const affectedRowIds = findRowsMatchingPattern(pattern, tagIndex)
+
+      for (const rowId of affectedRowIds) {
+        if (removeMatchingTagsFromRow(rowId, pattern)) {
+          // Delete rows with empty tag sets
+          if (!txStarted) {
+            begin()
+            txStarted = true
+          }
+
+          write({
+            type: `delete`,
+            key: rowId,
+          })
+        }
+      }
+    }
+
+    return txStarted
+  }
+
   /**
    * Get the sync metadata for insert operations
    * @returns Record containing relation information
@@ -622,6 +1153,26 @@ function createElectricSync<T extends Row<unknown>>(
     sync: (params: Parameters<SyncConfig<T>[`sync`]>[0]) => {
       const { begin, write, commit, markReady, truncate, collection } = params
 
+      // Wrap markReady to wait for test hook in progressive mode
+      let progressiveReadyGate: Promise<void> | null = null
+      const wrappedMarkReady = (isBuffering: boolean) => {
+        // Only create gate if we're in buffering phase (first up-to-date)
+        if (
+          isBuffering &&
+          syncMode === `progressive` &&
+          testHooks?.beforeMarkingReady
+        ) {
+          // Create a new gate promise for this sync cycle
+          progressiveReadyGate = testHooks.beforeMarkingReady()
+          progressiveReadyGate.then(() => {
+            markReady()
+          })
+        } else {
+          // No hook, not buffering, or already past first up-to-date
+          markReady()
+        }
+      }
+
       // Abort controller for the stream - wraps the signal if provided
       const abortController = new AbortController()
 
@@ -633,7 +1184,7 @@ function createElectricSync<T extends Row<unknown>>(
           },
           {
             once: true,
-          }
+          },
         )
         if (shapeOptions.signal.aborted) {
           abortController.abort()
@@ -653,6 +1204,12 @@ function createElectricSync<T extends Row<unknown>>(
 
       const stream = new ShapeStream({
         ...shapeOptions,
+        // In on-demand mode, we only want to sync changes, so we set the log to `changes_only`
+        log: syncMode === `on-demand` ? `changes_only` : undefined,
+        // In on-demand mode, we only need the changes from the point of time the collection was created
+        // so we default to `now` when there is no saved offset.
+        offset:
+          shapeOptions.offset ?? (syncMode === `on-demand` ? `now` : undefined),
         signal: abortController.signal,
         onError: (errorParams) => {
           // Just immediately mark ready if there's an error to avoid blocking
@@ -669,7 +1226,7 @@ function createElectricSync<T extends Row<unknown>>(
               `An error occurred while syncing collection: ${collection.id}, \n` +
                 `it has been marked as ready to avoid blocking apps waiting for '.preload()' to finish. \n` +
                 `You can provide an 'onError' handler on the shapeOptions to handle this error, and this message will not be logged.`,
-              errorParams
+              errorParams,
             )
           }
 
@@ -679,13 +1236,97 @@ function createElectricSync<T extends Row<unknown>>(
       let transactionStarted = false
       const newTxids = new Set<Txid>()
       const newSnapshots: Array<PostgresSnapshot> = []
+      let hasReceivedUpToDate = false // Track if we've completed initial sync in progressive mode
+
+      // Progressive mode state
+      // Helper to determine if we're buffering the initial sync
+      const isBufferingInitialSync = () =>
+        syncMode === `progressive` && !hasReceivedUpToDate
+      const bufferedMessages: Array<Message<T>> = [] // Buffer change messages during initial sync
+
+      // Track keys that have been synced to handle overlapping subset queries.
+      // When multiple subset queries return the same row, the server sends `insert`
+      // for each response. We convert subsequent inserts to updates to avoid
+      // duplicate key errors when the row's data has changed between requests.
+      const syncedKeys = new Set<string | number>()
+
+      /**
+       * Process a change message: handle tags and write the mutation
+       */
+      const processChangeMessage = (changeMessage: Message<T>) => {
+        if (!isChangeMessage(changeMessage)) {
+          return
+        }
+
+        // Process tags if present
+        const tags = changeMessage.headers.tags
+        const removedTags = changeMessage.headers.removed_tags
+        const hasTags = tags || removedTags
+
+        const rowId = collection.getKeyFromItem(changeMessage.value)
+        const operation = changeMessage.headers.operation
+
+        // Track synced keys and handle overlapping subset queries.
+        // When multiple subset queries return the same row, the server sends
+        // `insert` for each response. We convert subsequent inserts to updates
+        // to avoid duplicate key errors when the row's data has changed.
+        const isDelete = operation === `delete`
+        const isDuplicateInsert =
+          operation === `insert` && syncedKeys.has(rowId)
+
+        if (isDelete) {
+          syncedKeys.delete(rowId)
+        } else {
+          syncedKeys.add(rowId)
+        }
+
+        if (isDelete) {
+          clearTagsForRow(rowId)
+        } else if (hasTags) {
+          processTagsForChangeMessage(tags, removedTags, rowId)
+        }
+
+        write({
+          type: isDuplicateInsert ? `update` : operation,
+          value: changeMessage.value,
+          // Include the primary key and relation info in the metadata
+          metadata: {
+            ...changeMessage.headers,
+          },
+        })
+      }
+
+      // Create deduplicated loadSubset wrapper for non-eager modes
+      // This prevents redundant snapshot requests when multiple concurrent
+      // live queries request overlapping or subset predicates
+      const loadSubsetDedupe = createLoadSubsetDedupe({
+        stream,
+        syncMode,
+        isBufferingInitialSync,
+        begin,
+        write,
+        commit,
+        collectionId,
+        // Pass the columnMapper's encode function to transform column names
+        // (e.g., camelCase to snake_case) when compiling SQL for subset queries
+        encodeColumnName: shapeOptions.columnMapper?.encode,
+        // Pass abort signal so requestSnapshot errors can be ignored during cleanup
+        signal: abortController.signal,
+      })
 
       unsubscribeStream = stream.subscribe((messages: Array<Message<T>>) => {
-        let hasUpToDate = false
+        // Track commit point type - up-to-date takes precedence as it also triggers progressive mode atomic swap
+        let commitPoint: `up-to-date` | `subset-end` | null = null
+
+        // Don't clear the buffer between batches - this preserves messages for awaitMatch
+        // to find even if multiple batches arrive before awaitMatch is called.
+        // The buffer is naturally limited by MAX_BATCH_MESSAGES (oldest messages are dropped).
+        // Reset batchCommitted since we're starting a new batch
+        batchCommitted.setState(() => false)
 
         for (const message of messages) {
           // Add message to current batch buffer (for race condition handling)
-          if (isChangeMessage(message)) {
+          if (isChangeMessage(message) || isMoveOutMessage(message)) {
             currentBatchMessages.setState((currentBuffer) => {
               const newBuffer = [...currentBuffer, message]
               // Limit buffer size for safety
@@ -697,7 +1338,13 @@ function createElectricSync<T extends Row<unknown>>(
           }
 
           // Check for txids in the message and add them to our store
-          if (hasTxids(message)) {
+          // Skip during buffered initial sync in progressive mode (txids will be extracted during atomic swap)
+          // EXCEPTION: If a transaction is already started (e.g., from must-refetch), track txids
+          // to avoid losing them when messages are written to the existing transaction.
+          if (
+            hasTxids(message) &&
+            (!isBufferingInitialSync() || transactionStarted)
+          ) {
             message.headers.txids?.forEach((txid) => newTxids.add(txid))
           }
 
@@ -712,7 +1359,7 @@ function createElectricSync<T extends Row<unknown>>(
                 // If matchFn throws, clean up and reject the promise
                 clearTimeout(match.timeoutId)
                 match.reject(
-                  err instanceof Error ? err : new Error(String(err))
+                  err instanceof Error ? err : new Error(String(err)),
                 )
                 matchesToRemove.push(matchId)
                 debug(`matchFn error: %o`, err)
@@ -731,26 +1378,54 @@ function createElectricSync<T extends Row<unknown>>(
               relationSchema.setState(() => schema)
             }
 
-            if (!transactionStarted) {
-              begin()
-              transactionStarted = true
-            }
+            // In buffered initial sync of progressive mode, buffer messages instead of writing
+            // EXCEPTION: If a transaction is already started (e.g., from must-refetch), write
+            // directly to it instead of buffering. This prevents orphan transactions.
+            if (isBufferingInitialSync() && !transactionStarted) {
+              bufferedMessages.push(message)
+            } else {
+              // Normal processing: write changes immediately
+              if (!transactionStarted) {
+                begin()
+                transactionStarted = true
+              }
 
-            write({
-              type: message.headers.operation,
-              value: message.value,
-              // Include the primary key and relation info in the metadata
-              metadata: {
-                ...message.headers,
-              },
-            })
+              processChangeMessage(message)
+            }
           } else if (isSnapshotEndMessage(message)) {
-            newSnapshots.push(parseSnapshotMessage(message))
+            // Track postgres snapshot metadata for resolving awaiting mutations
+            // Skip during buffered initial sync (will be extracted during atomic swap)
+            // EXCEPTION: If a transaction is already started (e.g., from must-refetch), track snapshots
+            // to avoid losing them when messages are written to the existing transaction.
+            if (!isBufferingInitialSync() || transactionStarted) {
+              newSnapshots.push(parseSnapshotMessage(message))
+            }
           } else if (isUpToDateMessage(message)) {
-            hasUpToDate = true
+            // up-to-date takes precedence - also triggers progressive mode atomic swap
+            commitPoint = `up-to-date`
+          } else if (isSubsetEndMessage(message)) {
+            // subset-end triggers commit but not progressive mode atomic swap
+            if (commitPoint !== `up-to-date`) {
+              commitPoint = `subset-end`
+            }
+          } else if (isMoveOutMessage(message)) {
+            // Handle move-out event: buffer if buffering, otherwise process immediately
+            // EXCEPTION: If a transaction is already started (e.g., from must-refetch), process
+            // immediately to avoid orphan transactions.
+            if (isBufferingInitialSync() && !transactionStarted) {
+              bufferedMessages.push(message)
+            } else {
+              // Normal processing: process move-out immediately
+              transactionStarted = processMoveOutEvent(
+                message.headers.patterns,
+                begin,
+                write,
+                transactionStarted,
+              )
+            }
           } else if (isMustRefetchMessage(message)) {
             debug(
-              `${collectionId ? `[${collectionId}] ` : ``}Received must-refetch message, starting transaction with truncate`
+              `${collectionId ? `[${collectionId}] ` : ``}Received must-refetch message, starting transaction with truncate`,
             )
 
             // Start a transaction and truncate the collection
@@ -761,23 +1436,97 @@ function createElectricSync<T extends Row<unknown>>(
 
             truncate()
 
-            // Reset hasUpToDate so we continue accumulating changes until next up-to-date
-            hasUpToDate = false
+            // Clear tag tracking state
+            clearTagTrackingState()
+
+            // Clear synced keys tracking since we're starting fresh
+            syncedKeys.clear()
+
+            // Reset the loadSubset deduplication state since we're starting fresh
+            // This ensures that previously loaded predicates don't prevent refetching after truncate
+            loadSubsetDedupe?.reset()
+
+            // Reset flags so we continue accumulating changes until next up-to-date
+            commitPoint = null
+            hasReceivedUpToDate = false // Reset for progressive mode (isBufferingInitialSync will reflect this)
+            bufferedMessages.length = 0 // Clear buffered messages
           }
         }
 
-        if (hasUpToDate) {
-          // Clear the current batch buffer since we're now up-to-date
-          currentBatchMessages.setState(() => [])
+        if (commitPoint !== null) {
+          // PROGRESSIVE MODE: Atomic swap on first up-to-date (not subset-end)
+          // EXCEPTION: Skip atomic swap if a transaction is already started (e.g., from must-refetch).
+          // In that case, do a normal commit to properly close the existing transaction.
+          if (
+            isBufferingInitialSync() &&
+            commitPoint === `up-to-date` &&
+            !transactionStarted
+          ) {
+            debug(
+              `${collectionId ? `[${collectionId}] ` : ``}Progressive mode: Performing atomic swap with ${bufferedMessages.length} buffered messages`,
+            )
+
+            // Start atomic swap transaction
+            begin()
+
+            // Truncate to clear all snapshot data
+            truncate()
+
+            // Clear tag tracking state for atomic swap
+            clearTagTrackingState()
+
+            // Clear synced keys tracking for atomic swap
+            syncedKeys.clear()
+
+            // Apply all buffered change messages and extract txids/snapshots
+            for (const bufferedMsg of bufferedMessages) {
+              if (isChangeMessage(bufferedMsg)) {
+                processChangeMessage(bufferedMsg)
+
+                // Extract txids from buffered messages (will be committed to store after transaction)
+                if (hasTxids(bufferedMsg)) {
+                  bufferedMsg.headers.txids?.forEach((txid) =>
+                    newTxids.add(txid),
+                  )
+                }
+              } else if (isSnapshotEndMessage(bufferedMsg)) {
+                // Extract snapshots from buffered messages (will be committed to store after transaction)
+                newSnapshots.push(parseSnapshotMessage(bufferedMsg))
+              } else if (isMoveOutMessage(bufferedMsg)) {
+                // Process buffered move-out messages during atomic swap
+                processMoveOutEvent(
+                  bufferedMsg.headers.patterns,
+                  begin,
+                  write,
+                  transactionStarted,
+                )
+              }
+            }
 
-          // Commit transaction if one was started
-          if (transactionStarted) {
+            // Commit the atomic swap
             commit()
-            transactionStarted = false
+
+            // Exit buffering phase by marking that we've received up-to-date
+            // isBufferingInitialSync() will now return false
+            bufferedMessages.length = 0
+
+            debug(
+              `${collectionId ? `[${collectionId}] ` : ``}Progressive mode: Atomic swap complete, now in normal sync mode`,
+            )
+          } else {
+            // Normal mode or on-demand: commit transaction if one was started
+            // Both up-to-date and subset-end trigger a commit
+            if (transactionStarted) {
+              commit()
+              transactionStarted = false
+            }
           }
+          wrappedMarkReady(isBufferingInitialSync())
 
-          // Mark the collection as ready now that sync is up to date
-          markReady()
+          // Track that we've received the first up-to-date for progressive mode
+          if (commitPoint === `up-to-date`) {
+            hasReceivedUpToDate = true
+          }
 
           // Always commit txids when we receive up-to-date, regardless of transaction state
           seenTxids.setState((currentTxids) => {
@@ -785,7 +1534,7 @@ function createElectricSync<T extends Row<unknown>>(
             if (newTxids.size > 0) {
               debug(
                 `${collectionId ? `[${collectionId}] ` : ``}new txids synced from pg %O`,
-                Array.from(newTxids)
+                Array.from(newTxids),
               )
             }
             newTxids.forEach((txid) => clonedSeen.add(txid))
@@ -799,24 +1548,34 @@ function createElectricSync<T extends Row<unknown>>(
             newSnapshots.forEach((snapshot) =>
               debug(
                 `${collectionId ? `[${collectionId}] ` : ``}new snapshot synced from pg %o`,
-                snapshot
-              )
+                snapshot,
+              ),
             )
             newSnapshots.length = 0
             return seen
           })
 
-          // Resolve all matched pending matches on up-to-date
+          // Resolve all matched pending matches on up-to-date or subset-end
+          // Set batchCommitted BEFORE resolving to avoid timing window where late awaitMatch
+          // calls could register as "matched" after resolver pass already ran
+          batchCommitted.setState(() => true)
+
           resolveMatchedPendingMatches()
         }
       })
 
-      // Return the unsubscribe function
-      return () => {
-        // Unsubscribe from the stream
-        unsubscribeStream()
-        // Abort the abort controller to stop the stream
-        abortController.abort()
+      // Return the deduplicated loadSubset if available (on-demand or progressive mode)
+      // The loadSubset method is auto-bound, so it can be safely returned directly
+      return {
+        loadSubset: loadSubsetDedupe?.loadSubset,
+        cleanup: () => {
+          // Unsubscribe from the stream
+          unsubscribeStream()
+          // Abort the abort controller to stop the stream
+          abortController.abort()
+          // Reset deduplication tracking so collection can load fresh data if restarted
+          loadSubsetDedupe?.reset()
+        },
       }
     },
     // Expose the getSyncMetadata function
diff --git a/packages/electric-db-collection/src/errors.ts b/packages/electric-db-collection/src/errors.ts
index 4f889c276..14ee6ab50 100644
--- a/packages/electric-db-collection/src/errors.ts
+++ b/packages/electric-db-collection/src/errors.ts
@@ -1,4 +1,4 @@
-import { TanStackDBError } from "@tanstack/db"
+import { TanStackDBError } from '@tanstack/db'
 
 // Electric DB Collection Errors
 export class ElectricDBCollectionError extends TanStackDBError {
diff --git a/packages/electric-db-collection/src/index.ts b/packages/electric-db-collection/src/index.ts
index ac436bcf7..31f615e56 100644
--- a/packages/electric-db-collection/src/index.ts
+++ b/packages/electric-db-collection/src/index.ts
@@ -1,9 +1,11 @@
 export {
   electricCollectionOptions,
+  isChangeMessage,
+  isControlMessage,
   type ElectricCollectionConfig,
   type ElectricCollectionUtils,
   type Txid,
   type AwaitTxIdFn,
-} from "./electric"
+} from './electric'
 
-export * from "./errors"
+export * from './errors'
diff --git a/packages/electric-db-collection/src/pg-serializer.ts b/packages/electric-db-collection/src/pg-serializer.ts
new file mode 100644
index 000000000..48b1cdd4b
--- /dev/null
+++ b/packages/electric-db-collection/src/pg-serializer.ts
@@ -0,0 +1,71 @@
+/**
+ * Serialize values for Electric SQL subset parameters.
+ *
+ * IMPORTANT: Electric expects RAW values, NOT SQL-formatted literals.
+ * Electric handles all type casting and escaping on the server side.
+ * The params Record<string, string> contains the actual values as strings,
+ * and Electric will parse/cast them based on the column type in the WHERE clause.
+ *
+ * @param value - The value to serialize
+ * @returns The raw value as a string (no SQL formatting/quoting)
+ */
+export function serialize(value: unknown): string {
+  // Handle null/undefined - return empty string
+  // Electric interprets empty string as NULL in typed column context
+  if (value === null || value === undefined) {
+    return ``
+  }
+
+  // Handle strings - return as-is (NO quotes, Electric handles escaping)
+  if (typeof value === `string`) {
+    return value
+  }
+
+  // Handle numbers - convert to string
+  if (typeof value === `number`) {
+    return value.toString()
+  }
+
+  // Handle bigints - convert to string
+  if (typeof value === `bigint`) {
+    return value.toString()
+  }
+
+  // Handle booleans - return as lowercase string
+  if (typeof value === `boolean`) {
+    return value ? `true` : `false`
+  }
+
+  // Handle dates - return ISO format (NO quotes)
+  if (value instanceof Date) {
+    return value.toISOString()
+  }
+
+  // Handle arrays - for = ANY() operator, serialize as Postgres array literal
+  // Format: {val1,val2,val3} with proper escaping
+  if (Array.isArray(value)) {
+    // Postgres array literal format uses curly braces
+    const elements = value.map((item) => {
+      if (item === null || item === undefined) {
+        return `NULL`
+      }
+      if (typeof item === `string`) {
+        // Escape quotes and backslashes for Postgres array literals
+        const escaped = item.replace(/\\/g, `\\\\`).replace(/"/g, `\\"`)
+        return `"${escaped}"`
+      }
+      return serialize(item)
+    })
+    return `{${elements.join(`,`)}}`
+  }
+
+  // Safely stringify the value for the error message
+  // JSON.stringify can't handle BigInt and other types, so we use a try-catch
+  let valueStr: string
+  try {
+    valueStr = JSON.stringify(value)
+  } catch {
+    valueStr = String(value)
+  }
+  throw new Error(`Cannot serialize value: ${valueStr}`)
+}
diff --git a/packages/electric-db-collection/src/sql-compiler.ts b/packages/electric-db-collection/src/sql-compiler.ts
new file mode 100644
index 000000000..698f38c83
--- /dev/null
+++ b/packages/electric-db-collection/src/sql-compiler.ts
@@ -0,0 +1,433 @@
+import { serialize } from './pg-serializer'
+import type { SubsetParams } from '@electric-sql/client'
+import type { IR, LoadSubsetOptions } from '@tanstack/db'
+
+export type CompiledSqlRecord = Omit<SubsetParams, `params`> & {
+  params?: Array<unknown>
+}
+
+/**
+ * Optional function to encode column names (e.g., camelCase to snake_case)
+ * This is typically the `encode` function from a columnMapper
+ */
+export type ColumnEncoder = (columnName: string) => string
+
+/**
+ * Options for SQL compilation
+ */
+export interface CompileSQLOptions {
+  /**
+   * Optional function to encode column names before quoting.
+   * Used to transform property names (e.g., camelCase) to database column names (e.g., snake_case).
+   * This should be the `encode` function from shapeOptions.columnMapper.
+   */
+  encodeColumnName?: ColumnEncoder
+}
+
+export function compileSQL<T>(
+  options: LoadSubsetOptions,
+  compileOptions?: CompileSQLOptions,
+): SubsetParams {
+  const { where, orderBy, limit } = options
+  const encodeColumnName = compileOptions?.encodeColumnName
+
+  const params: Array<T> = []
+  const compiledSQL: CompiledSqlRecord = { params }
+
+  if (where) {
+    // TODO: this only works when the where expression's PropRefs directly reference a column of the collection
+    //       doesn't work if it goes through aliases because then we need to know the entire query to be able to follow the reference until the base collection (cf. followRef function)
+    compiledSQL.where = compileBasicExpression(where, params, encodeColumnName)
+  }
+
+  if (orderBy) {
+    compiledSQL.orderBy = compileOrderBy(orderBy, params, encodeColumnName)
+  }
+
+  if (limit) {
+    compiledSQL.limit = limit
+  }
+
+  // WORKAROUND for Electric bug: Empty subset requests don't load data
+  // Add dummy "true = true" predicate when there's no where clause
+  // This is always true so doesn't filter data, just tricks Electric into loading
+  if (!where) {
+    compiledSQL.where = `true = true`
+  }
+
+  // Serialize the values in the params array into PG formatted strings
+  // and transform the array into a Record<string, string>
+  const paramsRecord = params.reduce(
+    (acc, param, index) => {
+      const serialized = serialize(param)
+      // Empty strings are valid query values (e.g., WHERE column = '')
+      // Only omit null/undefined values from params
+      if (param != null) {
+        acc[`${index + 1}`] = serialized
+      }
+      return acc
+    },
+    {} as Record<string, string>,
+  )
+
+  return {
+    ...compiledSQL,
+    params: paramsRecord,
+  }
+}
+
+/**
+ * Quote PostgreSQL identifiers to handle mixed case column names correctly.
+ * Electric/Postgres requires quotes for case-sensitive identifiers.
+ * @param name - The identifier to quote
+ * @param encodeColumnName - Optional function to encode the column name before quoting (e.g., camelCase to snake_case)
+ * @returns The quoted identifier
+ */
+function quoteIdentifier(
+  name: string,
+  encodeColumnName?: ColumnEncoder,
+): string {
+  const columnName = encodeColumnName ? encodeColumnName(name) : name
+  return `"${columnName}"`
+}
+
+/**
+ * Compiles the expression to a SQL string and mutates the params array with the values.
+ * @param exp - The expression to compile
+ * @param params - The params array
+ * @param encodeColumnName - Optional function to encode column names (e.g., camelCase to snake_case)
+ * @returns The compiled SQL string
+ */
+function compileBasicExpression(
+  exp: IR.BasicExpression<unknown>,
+  params: Array<unknown>,
+  encodeColumnName?: ColumnEncoder,
+): string {
+  switch (exp.type) {
+    case `val`:
+      params.push(exp.value)
+      return `$${params.length}`
+    case `ref`:
+      // TODO: doesn't yet support JSON(B) values which could be accessed with nested props
+      if (exp.path.length !== 1) {
+        throw new Error(
+          `Compiler can't handle nested properties: ${exp.path.join(`.`)}`,
+        )
+      }
+      return quoteIdentifier(exp.path[0]!, encodeColumnName)
+    case `func`:
+      return compileFunction(exp, params, encodeColumnName)
+    default:
+      throw new Error(`Unknown expression type`)
+  }
+}
+
+function compileOrderBy(
+  orderBy: IR.OrderBy,
+  params: Array<unknown>,
+  encodeColumnName?: ColumnEncoder,
+): string {
+  const compiledOrderByClauses = orderBy.map((clause: IR.OrderByClause) =>
+    compileOrderByClause(clause, params, encodeColumnName),
+  )
+  return compiledOrderByClauses.join(`,`)
+}
+
+function compileOrderByClause(
+  clause: IR.OrderByClause,
+  params: Array<unknown>,
+  encodeColumnName?: ColumnEncoder,
+): string {
+  // FIXME: We should handle stringSort and locale.
+  //        Correctly supporting them is tricky as it depends on Postgres' collation
+  const { expression, compareOptions } = clause
+  let sql = compileBasicExpression(expression, params, encodeColumnName)
+
+  if (compareOptions.direction === `desc`) {
+    sql = `${sql} DESC`
+  }
+
+  if (compareOptions.nulls === `first`) {
+    sql = `${sql} NULLS FIRST`
+  }
+
+  if (compareOptions.nulls === `last`) {
+    sql = `${sql} NULLS LAST`
+  }
+
+  return sql
+}
+
+/**
+ * Check if a BasicExpression represents a null/undefined value
+ */
+function isNullValue(exp: IR.BasicExpression<unknown>): boolean {
+  return exp.type === `val` && (exp.value === null || exp.value === undefined)
+}
+
+function compileFunction(
+  exp: IR.Func<unknown>,
+  params: Array<unknown> = [],
+  encodeColumnName?: ColumnEncoder,
+): string {
+  const { name, args } = exp
+
+  const opName = getOpName(name)
+
+  // Handle comparison operators with null/undefined values
+  // These would create invalid queries with missing params (e.g., "col = $1" with empty params)
+  // In SQL, all comparisons with NULL return UNKNOWN, so these are almost always mistakes
+  if (isComparisonOp(name)) {
+    const nullArgIndex = args.findIndex((arg: IR.BasicExpression) =>
+      isNullValue(arg),
+    )
+
+    if (nullArgIndex !== -1) {
+      // All comparison operators (including eq) throw an error for null values
+      // Users should use isNull() or isUndefined() to check for null values
+      throw new Error(
+        `Cannot use null/undefined value with '${name}' operator. ` +
+          `Comparisons with null always evaluate to UNKNOWN in SQL. ` +
+          `Use isNull() or isUndefined() to check for null values, ` +
+          `or filter out null values before building the query.`,
+      )
+    }
+  }
+
+  const compiledArgs = args.map((arg: IR.BasicExpression) =>
+    compileBasicExpression(arg, params, encodeColumnName),
+  )
+
+  // Special case for IS NULL / IS NOT NULL - these are postfix operators
+  if (name === `isNull` || name === `isUndefined`) {
+    if (compiledArgs.length !== 1) {
+      throw new Error(`${name} expects 1 argument`)
+    }
+    return `${compiledArgs[0]} ${opName}`
+  }
+
+  // Special case for NOT - unary prefix operator
+  if (name === `not`) {
+    if (compiledArgs.length !== 1) {
+      throw new Error(`NOT expects 1 argument`)
+    }
+    // Check if the argument is IS NULL to generate IS NOT NULL
+    const arg = args[0]
+    if (arg && arg.type === `func`) {
+      const funcArg = arg
+      if (funcArg.name === `isNull` || funcArg.name === `isUndefined`) {
+        const innerArg = compileBasicExpression(
+          funcArg.args[0]!,
+          params,
+          encodeColumnName,
+        )
+        return `${innerArg} IS NOT NULL`
+      }
+    }
+    return `${opName} (${compiledArgs[0]})`
+  }
+
+  if (isBinaryOp(name)) {
+    // Special handling for AND/OR which can be variadic
+    if ((name === `and` || name === `or`) && compiledArgs.length > 2) {
+      // Chain multiple arguments: (a AND b AND c) or (a OR b OR c)
+      return compiledArgs.map((arg) => `(${arg})`).join(` ${opName} `)
+    }
+
+    if (compiledArgs.length !== 2) {
+      throw new Error(`Binary operator ${name} expects 2 arguments`)
+    }
+    const [lhs, rhs] = compiledArgs
+
+    // Special case for comparison operators with boolean values
+    // PostgreSQL doesn't support < > <= >= on booleans
+    // Transform to equivalent equality checks or constant expressions
+    if (isBooleanComparisonOp(name)) {
+      const lhsArg = args[0]
+      const rhsArg = args[1]
+
+      // Check if RHS is a boolean literal value
+      if (
+        rhsArg &&
+        rhsArg.type === `val` &&
+        typeof rhsArg.value === `boolean`
+      ) {
+        const boolValue = rhsArg.value
+        // Remove the boolean param we just added since we'll transform the expression
+        params.pop()
+
+        // Transform based on operator and boolean value
+        // Boolean ordering: false < true
+        if (name === `lt`) {
+          if (boolValue === true) {
+            // lt(col, true) → col = false (only false is less than true)
+            params.push(false)
+            return `${lhs} = $${params.length}`
+          } else {
+            // lt(col, false) → nothing is less than false
+            return `false`
+          }
+        } else if (name === `gt`) {
+          if (boolValue === false) {
+            // gt(col, false) → col = true (only true is greater than false)
+            params.push(true)
+            return `${lhs} = $${params.length}`
+          } else {
+            // gt(col, true) → nothing is greater than true
+            return `false`
+          }
+        } else if (name === `lte`) {
+          if (boolValue === true) {
+            // lte(col, true) → everything is ≤ true
+            return `true`
+          } else {
+            // lte(col, false) → col = false
+            params.push(false)
+            return `${lhs} = $${params.length}`
+          }
+        } else if (name === `gte`) {
+          if (boolValue === false) {
+            // gte(col, false) → everything is ≥ false
+            return `true`
+          } else {
+            // gte(col, true) → col = true
+            params.push(true)
+            return `${lhs} = $${params.length}`
+          }
+        }
+      }
+
+      // Check if LHS is a boolean literal value (less common but handle it)
+      if (
+        lhsArg &&
+        lhsArg.type === `val` &&
+        typeof lhsArg.value === `boolean`
+      ) {
+        const boolValue = lhsArg.value
+        // Remove params for this expression and rebuild
+        params.pop() // remove RHS
+        params.pop() // remove LHS (boolean)
+
+        // Recompile RHS to get fresh param
+        const rhsCompiled = compileBasicExpression(
+          rhsArg!,
+          params,
+          encodeColumnName,
+        )
+
+        // Transform: flip the comparison (val op col → col flipped_op val)
+        if (name === `lt`) {
+          // lt(true, col) → gt(col, true) → col > true → nothing is greater than true
+          if (boolValue === true) {
+            return `false`
+          } else {
+            // lt(false, col) → gt(col, false) → col = true
+            params.push(true)
+            return `${rhsCompiled} = $${params.length}`
+          }
+        } else if (name === `gt`) {
+          // gt(true, col) → lt(col, true) → col = false
+          if (boolValue === true) {
+            params.push(false)
+            return `${rhsCompiled} = $${params.length}`
+          } else {
+            // gt(false, col) → lt(col, false) → nothing is less than false
+            return `false`
+          }
+        } else if (name === `lte`) {
+          if (boolValue === false) {
+            // lte(false, col) → gte(col, false) → everything
+            return `true`
+          } else {
+            // lte(true, col) → gte(col, true) → col = true
+            params.push(true)
+            return `${rhsCompiled} = $${params.length}`
+          }
+        } else if (name === `gte`) {
+          if (boolValue === true) {
+            // gte(true, col) → lte(col, true) → everything
+            return `true`
+          } else {
+            // gte(false, col) → lte(col, false) → col = false
+            params.push(false)
+            return `${rhsCompiled} = $${params.length}`
+          }
+        }
+      }
+    }
+
+    // Special case for = ANY operator which needs parentheses around the array parameter
+    if (name === `in`) {
+      return `${lhs} ${opName}(${rhs})`
+    }
+    return `${lhs} ${opName} ${rhs}`
+  }
+
+  return `${opName}(${compiledArgs.join(`,`)})`
+}
+
+function isBinaryOp(name: string): boolean {
+  const binaryOps = [
+    `eq`,
+    `gt`,
+    `gte`,
+    `lt`,
+    `lte`,
+    `and`,
+    `or`,
+    `in`,
+    `like`,
+    `ilike`,
+  ]
+  return binaryOps.includes(name)
+}
+
+/**
+ * Check if operator is a comparison operator that takes two values
+ * These operators cannot accept null/undefined as values
+ * (null comparisons in SQL always evaluate to UNKNOWN)
+ */
+function isComparisonOp(name: string): boolean {
+  const comparisonOps = [`eq`, `gt`, `gte`, `lt`, `lte`, `like`, `ilike`]
+  return comparisonOps.includes(name)
+}
+
+/**
+ * Checks if the operator is a comparison operator (excluding eq)
+ * These operators don't work on booleans in PostgreSQL without casting
+ */
+function isBooleanComparisonOp(name: string): boolean {
+  return [`gt`, `gte`, `lt`, `lte`].includes(name)
+}
+
+function getOpName(name: string): string {
+  const opNames = {
+    eq: `=`,
+    gt: `>`,
+    gte: `>=`,
+    lt: `<`,
+    lte: `<=`,
+    add: `+`,
+    and: `AND`,
+    or: `OR`,
+    not: `NOT`,
+    isUndefined: `IS NULL`,
+    isNull: `IS NULL`,
+    in: `= ANY`, // Use = ANY syntax for array parameters
+    like: `LIKE`,
+    ilike: `ILIKE`,
+    upper: `UPPER`,
+    lower: `LOWER`,
+    length: `LENGTH`,
+    concat: `CONCAT`,
+    coalesce: `COALESCE`,
+  }
+
+  const opName = opNames[name as keyof typeof opNames]
+
+  if (!opName) {
+    throw new Error(`Unknown operator/function: ${name}`)
+  }
+
+  return opName
+}
diff --git a/packages/electric-db-collection/src/tag-index.ts b/packages/electric-db-collection/src/tag-index.ts
new file mode 100644
index 000000000..eeecab67f
--- /dev/null
+++ b/packages/electric-db-collection/src/tag-index.ts
@@ -0,0 +1,160 @@
+// Import Row and Message types for the isEventMessage function
+import type { Message, Row } from '@electric-sql/client'
+
+export type RowId = string | number
+export type MoveTag = string
+export type ParsedMoveTag = Array<string>
+export type Position = number
+export type Value = string
+export type MoveOutPattern = {
+  pos: Position
+  value: Value
+}
+
+const TAG_WILDCARD = `_`
+
+/**
+ * Event message type for move-out events
+ */
+export interface EventMessage {
+  headers: {
+    event: `move-out`
+    patterns: Array<MoveOutPattern>
+  }
+}
+
+/**
+ * Tag index structure: array indexed by position, maps value to set of row IDs.
+ * For example:
+ * ```example
+ * const tag1 = [a, b, c]
+ * const tag2 = [a, b, d]
+ * const tag3 = [a, d, e]
+ *
+ * // Index is:
+ * [
+ *   new Map([a -> <rows with a on index 0>])
+ *   new Map([b -> <rows with b on index 1>, d -> <rows with d on index 1>])
+ *   new Map([c -> <rows with c on index 2>, d -> <rows with d on index 2>, e -> <rows with e on index 2>])
+ * ]
+ * ```
+ */
+export type TagIndex = Array<Map<Value, Set<RowId>>>
+
+/**
+ * Abstraction to get the value at a specific position in a tag
+ */
+export function getValue(tag: ParsedMoveTag, position: Position): Value {
+  if (position >= tag.length) {
+    throw new Error(`Position out of bounds`)
+  }
+  return tag[position]!
+}
+
+/**
+ * Abstraction to extract position and value from a pattern.
+ */
+function getPositionalValue(pattern: MoveOutPattern): {
+  pos: number
+  value: string
+} {
+  return pattern
+}
+
+/**
+ * Abstraction to get the length of a tag
+ */
+export function getTagLength(tag: ParsedMoveTag): number {
+  return tag.length
+}
+
+/**
+ * Check if a tag matches a pattern.
+ * A tag matches if the value at the pattern's position equals the pattern's value,
+ * or if the value at that position is "_" (wildcard).
+ */
+export function tagMatchesPattern(
+  tag: ParsedMoveTag,
+  pattern: MoveOutPattern,
+): boolean {
+  const { pos, value } = getPositionalValue(pattern)
+  const tagValue = getValue(tag, pos)
+  return tagValue === value || tagValue === TAG_WILDCARD
+}
+
+/**
+ * Add a tag to the index for efficient pattern matching
+ */
+export function addTagToIndex(
+  tag: ParsedMoveTag,
+  rowId: RowId,
+  index: TagIndex,
+  tagLength: number,
+): void {
+  for (let i = 0; i < tagLength; i++) {
+    const value = getValue(tag, i)
+
+    // Only index non-wildcard values
+    if (value !== TAG_WILDCARD) {
+      const positionIndex = index[i]!
+      if (!positionIndex.has(value)) {
+        positionIndex.set(value, new Set())
+      }
+
+      const tags = positionIndex.get(value)!
+      tags.add(rowId)
+    }
+  }
+}
+
+/**
+ * Remove a tag from the index
+ */
+export function removeTagFromIndex(
+  tag: ParsedMoveTag,
+  rowId: RowId,
+  index: TagIndex,
+  tagLength: number,
+): void {
+  for (let i = 0; i < tagLength; i++) {
+    const value = getValue(tag, i)
+
+    // Only remove non-wildcard values
+    if (value !== TAG_WILDCARD) {
+      const positionIndex = index[i]
+      if (positionIndex) {
+        const rowSet = positionIndex.get(value)
+        if (rowSet) {
+          rowSet.delete(rowId)
+
+          // Clean up empty sets
+          if (rowSet.size === 0) {
+            positionIndex.delete(value)
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Find all rows that match a given pattern
+ */
+export function findRowsMatchingPattern(
+  pattern: MoveOutPattern,
+  index: TagIndex,
+): Set<RowId> {
+  const { pos, value } = getPositionalValue(pattern)
+  const positionIndex = index[pos]
+  const rowSet = positionIndex?.get(value)
+  return rowSet ?? new Set()
+}
+
+/**
+ * Check if a message is an event message with move-out event
+ */
+export function isMoveOutMessage<T extends Row<unknown>>(
+  message: Message<T>,
+): message is Message<T> & EventMessage {
+  return message.headers.event === `move-out`
+}
diff --git a/packages/electric-db-collection/tests/electric-live-query.test.ts b/packages/electric-db-collection/tests/electric-live-query.test.ts
index b387f1756..2606bbfaf 100644
--- a/packages/electric-db-collection/tests/electric-live-query.test.ts
+++ b/packages/electric-db-collection/tests/electric-live-query.test.ts
@@ -1,15 +1,16 @@
-import { beforeEach, describe, expect, it, vi } from "vitest"
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   createCollection,
   createLiveQueryCollection,
   eq,
   gt,
-} from "@tanstack/db"
-import { electricCollectionOptions } from "../src/electric"
-import type { ElectricCollectionUtils } from "../src/electric"
-import type { Collection } from "@tanstack/db"
-import type { Message } from "@electric-sql/client"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+  lt,
+} from '@tanstack/db'
+import { electricCollectionOptions } from '../src/electric'
+import type { ElectricCollectionUtils } from '../src/electric'
+import type { Collection } from '@tanstack/db'
+import type { Message } from '@electric-sql/client'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 // Sample user type for tests
 type User = {
@@ -54,10 +55,49 @@ const sampleUsers: Array<User> = [
 
 // Mock the ShapeStream module
 const mockSubscribe = vi.fn()
+const mockRequestSnapshot = vi.fn()
+const mockFetchSnapshot = vi.fn()
 const mockStream = {
   subscribe: mockSubscribe,
+  fetchSnapshot: mockFetchSnapshot,
+  requestSnapshot: async (...args: any) => {
+    const result = await mockRequestSnapshot(...args)
+    const subscribers = mockSubscribe.mock.calls.map((call) => call[0])
+    const data = [...result.data]
+
+    const messages: Array<Message<any>> = data.map((row: any) => ({
+      value: row.value,
+      key: row.key,
+      headers: row.headers,
+    }))
+
+    if (messages.length > 0) {
+      // add an up-to-date message
+      messages.push({
+        headers: { control: `up-to-date` },
+      })
+    }
+
+    subscribers.forEach((subscriber) => subscriber(messages))
+    return result
+  },
 }
 
+// Mock the requestSnapshot method
+// to return an empty array of data
+// since most tests don't use it
+mockRequestSnapshot.mockResolvedValue({
+  data: [],
+})
+
+// Mock the fetchSnapshot method
+// to return empty data with metadata
+// since most tests don't use it
+mockFetchSnapshot.mockResolvedValue({
+  metadata: {},
+  data: [],
+})
+
 vi.mock(`@electric-sql/client`, async () => {
   const actual = await vi.importActual(`@electric-sql/client`)
   return {
@@ -105,7 +145,13 @@ describe.each([
     return createCollection({
       ...options,
       startSync: true,
-    })
+    }) as unknown as Collection<
+      User,
+      string | number,
+      ElectricCollectionUtils,
+      StandardSchemaV1<unknown, unknown>,
+      User
+    >
   }
 
   function simulateInitialSync(users: Array<User> = sampleUsers) {
@@ -437,4 +483,831 @@ describe.each([
     // Clean up
     subscription.unsubscribe()
   })
+  if (autoIndex === `eager`) {
+    it(`should load more data via requestSnapshot when creating live query with higher limit`, async () => {
+      // Create a new electric collection with on-demand syncMode for this test
+      vi.clearAllMocks()
+
+      let testSubscriber: (messages: Array<Message<User>>) => void = () => {}
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+
+      const testElectricCollection = createCollection(
+        electricCollectionOptions({
+          id: `test-incremental-loading`,
+          shapeOptions: {
+            url: `http://test-url`,
+            params: { table: `users` },
+          },
+          syncMode: `on-demand`,
+          getKey: (user: User) => user.id,
+          startSync: true,
+          autoIndex: `eager` as const,
+        }),
+      )
+
+      mockRequestSnapshot.mockResolvedValue({
+        data: [],
+      })
+
+      // Initial sync with limited data
+      testSubscriber([
+        ...sampleUsers.map((user) => ({
+          key: user.id.toString(),
+          value: user,
+          headers: { operation: `insert` as const },
+        })),
+        { headers: { control: `up-to-date` as const } },
+      ])
+
+      expect(testElectricCollection.status).toBe(`ready`)
+      expect(testElectricCollection.size).toBe(4)
+      expect(mockRequestSnapshot).toHaveBeenCalledTimes(0)
+
+      // Create first live query with limit of 2
+      const limitedLiveQuery = createLiveQueryCollection({
+        id: `limited-users-live-query`,
+        startSync: true,
+        query: (q) =>
+          q
+            .from({ user: testElectricCollection })
+            .where(({ user }) => eq(user.active, true))
+            .select(({ user }) => ({
+              id: user.id,
+              name: user.name,
+              active: user.active,
+              age: user.age,
+            }))
+            .orderBy(({ user }) => user.age, `asc`)
+            .limit(2),
+      })
+
+      // Wait for async subset loading to complete
+      await new Promise((resolve) => setTimeout(resolve, 0))
+
+      expect(limitedLiveQuery.status).toBe(`ready`)
+      expect(limitedLiveQuery.size).toBe(2) // Only first 2 active users
+      expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+
+      const callArgs = (index: number) =>
+        mockRequestSnapshot.mock.calls[index]?.[0]
+      expect(callArgs(0)).toMatchObject({
+        params: { '1': `true` },
+        where: `"active" = $1`,
+        orderBy: `"age" NULLS FIRST`,
+        limit: 2,
+      })
+
+      // Next call will return a snapshot containing 2 rows
+      // Calls after that will return the default empty snapshot
+      mockRequestSnapshot.mockResolvedValueOnce({
+        data: [
+          {
+            headers: { operation: `insert` },
+            key: 5,
+            value: {
+              id: 5,
+              name: `Eve`,
+              age: 30,
+              email: `eve@example.com`,
+              active: true,
+            },
+          },
+          {
+            headers: { operation: `insert` },
+            key: 6,
+            value: {
+              id: 6,
+              name: `Frank`,
+              age: 35,
+              email: `frank@example.com`,
+              active: true,
+            },
+          },
+        ],
+      })
+
+      // Create second live query with higher limit of 6
+      const expandedLiveQuery = createLiveQueryCollection({
+        id: `expanded-users-live-query`,
+        startSync: true,
+        query: (q) =>
+          q
+            .from({ user: testElectricCollection })
+            .where(({ user }) => eq(user.active, true))
+            .select(({ user }) => ({
+              id: user.id,
+              name: user.name,
+              active: user.active,
+            }))
+            .orderBy(({ user }) => user.age, `asc`)
+            .limit(6),
+      })
+
+      // Wait for the live query to process
+      await new Promise((resolve) => setTimeout(resolve, 0))
+
+      // Limited queries are only deduplicated when their where clauses are equal.
+      // Both queries have the same where clause (active = true), but the second query
+      // with limit 6 needs more data than the first query with limit 2 provided.
+      // With cursor-based pagination, initial loads (without cursor) make 1 requestSnapshot call each.
+      expect(mockRequestSnapshot).toHaveBeenCalledTimes(2)
+
+      // Check that first it requested a limit of 2 users (from first query)
+      expect(callArgs(0)).toMatchObject({
+        params: { '1': `true` },
+        where: `"active" = $1`,
+        orderBy: `"age" NULLS FIRST`,
+        limit: 2,
+      })
+
+      // Check that second it requested a limit of 6 users (from second query)
+      expect(callArgs(1)).toMatchObject({
+        params: { '1': `true` },
+        where: `"active" = $1`,
+        orderBy: `"age" NULLS FIRST`,
+        limit: 6,
+      })
+
+      // The expanded live query should have the locally available data
+      expect(expandedLiveQuery.status).toBe(`ready`)
+      // The mock returned 2 additional users (Eve and Frank) in response to the limit 6 request,
+      // plus the initial 3 active users (Alice, Bob, Dave) from the initial sync
+      expect(expandedLiveQuery.size).toBe(5)
+    })
+  }
+})
+
+// Tests specifically for syncMode behavior with live queries
+describe(`Electric Collection with Live Query - syncMode integration`, () => {
+  let subscriber: (messages: Array<Message<User>>) => void
+
+  function createElectricCollectionWithSyncMode(
+    syncMode: `eager` | `on-demand` | `progressive`,
+  ) {
+    vi.clearAllMocks()
+
+    mockSubscribe.mockImplementation((callback) => {
+      subscriber = callback
+      return () => {}
+    })
+
+    mockRequestSnapshot.mockResolvedValue({
+      data: [],
+    })
+
+    const config = {
+      id: `electric-users-${syncMode}`,
+      shapeOptions: {
+        url: `http://test-url`,
+        params: {
+          table: `users`,
+        },
+      },
+      syncMode,
+      getKey: (user: User) => user.id,
+    }
+
+    const options = electricCollectionOptions(config)
+    return createCollection({
+      ...options,
+      startSync: true,
+      autoIndex: `eager` as const,
+    })
+  }
+
+  function simulateInitialSync(users: Array<User> = sampleUsers) {
+    const messages: Array<Message<User>> = users.map((user) => ({
+      key: user.id.toString(),
+      value: user,
+      headers: { operation: `insert` },
+    }))
+
+    messages.push({
+      headers: { control: `up-to-date` },
+    })
+
+    subscriber(messages)
+  }
+
+  it(`should trigger requestSnapshot in on-demand mode when live query needs more data`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    // Initial sync with limited data
+    simulateInitialSync([sampleUsers[0]!, sampleUsers[1]!]) // Only Alice and Bob
+    expect(electricCollection.status).toBe(`ready`)
+    expect(electricCollection.size).toBe(2)
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(0)
+
+    // Mock requestSnapshot to return additional data
+    mockRequestSnapshot.mockResolvedValueOnce({
+      data: [
+        {
+          headers: { operation: `insert` },
+          key: 3,
+          value: sampleUsers[2]!, // Charlie
+        },
+        {
+          headers: { operation: `insert` },
+          key: 4,
+          value: sampleUsers[3]!, // Dave
+        },
+      ],
+    })
+
+    // Create live query with limit that exceeds available data
+    const liveQuery = createLiveQueryCollection({
+      id: `on-demand-live-query`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, true))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(5),
+    })
+
+    // Wait for the live query to process
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Should have requested more data from Electric with correct parameters
+    expect(mockRequestSnapshot).toHaveBeenCalledWith(
+      expect.objectContaining({
+        limit: 5, // Requests full limit from Electric
+        orderBy: `"age" NULLS FIRST`,
+        where: `"active" = $1`,
+        params: { 1: `true` }, // Parameters are stringified
+      }),
+    )
+    expect(liveQuery.size).toBeGreaterThan(2)
+  })
+
+  it(`should trigger fetchSnapshot in progressive mode when live query needs more data`, async () => {
+    const electricCollection =
+      createElectricCollectionWithSyncMode(`progressive`)
+
+    // In progressive mode, stream messages are buffered until up-to-date
+    // So collection starts empty even though we send data
+    subscriber([
+      {
+        key: sampleUsers[0]!.id.toString(),
+        value: sampleUsers[0]!,
+        headers: { operation: `insert` },
+      },
+      {
+        key: sampleUsers[1]!.id.toString(),
+        value: sampleUsers[1]!,
+        headers: { operation: `insert` },
+      },
+    ])
+
+    expect(electricCollection.status).toBe(`loading`) // Still syncing in progressive mode
+    // Messages are buffered, so size is 0 until up-to-date
+    expect(electricCollection.size).toBe(0)
+
+    // Mock fetchSnapshot to return data
+    mockFetchSnapshot.mockResolvedValueOnce({
+      metadata: {},
+      data: [
+        {
+          headers: { operation: `insert` },
+          key: sampleUsers[2]!.id.toString(),
+          value: sampleUsers[2]!, // Charlie
+        },
+      ],
+    })
+
+    // Create live query that needs more data
+    createLiveQueryCollection({
+      id: `progressive-live-query`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .orderBy(({ user }) => user.id, `asc`)
+          .limit(3),
+    })
+
+    // Wait for the live query to process
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Should have fetched more data from Electric with correct parameters
+    // Progressive mode uses fetchSnapshot, not requestSnapshot
+    expect(mockFetchSnapshot).toHaveBeenCalledWith(
+      expect.objectContaining({
+        limit: 3, // Requests full limit from Electric
+        orderBy: `"id" NULLS FIRST`,
+        params: {},
+      }),
+    )
+    expect(mockRequestSnapshot).not.toHaveBeenCalled()
+  })
+
+  it(`should NOT trigger requestSnapshot in eager mode even when live query needs more data`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`eager`)
+
+    // Initial sync with limited data
+    simulateInitialSync([sampleUsers[0]!, sampleUsers[1]!]) // Only Alice and Bob
+    expect(electricCollection.status).toBe(`ready`)
+    expect(electricCollection.size).toBe(2)
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(0)
+
+    // Create live query with limit that exceeds available data
+    const liveQuery = createLiveQueryCollection({
+      id: `eager-live-query`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, true))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(5),
+    })
+
+    // Wait for the live query to process
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Should NOT have requested more data (eager mode doesn't support incremental loading)
+    expect(mockRequestSnapshot).not.toHaveBeenCalled()
+    expect(liveQuery.size).toBe(2) // Only has the initially synced data
+  })
+
+  it(`should request additional snapshots progressively as live query expands in on-demand mode`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    // Initial sync with just Alice
+    simulateInitialSync([sampleUsers[0]!])
+    expect(electricCollection.size).toBe(1)
+
+    // First snapshot returns Bob and Charlie
+    mockRequestSnapshot.mockResolvedValueOnce({
+      data: [
+        {
+          headers: { operation: `insert` },
+          key: 2,
+          value: sampleUsers[1]!, // Bob
+        },
+        {
+          headers: { operation: `insert` },
+          key: 3,
+          value: sampleUsers[2]!, // Charlie
+        },
+      ],
+    })
+
+    // Create live query with limit of 3
+    createLiveQueryCollection({
+      id: `expanding-live-query`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(3),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Should have requested snapshot for limit 3
+    expect(mockRequestSnapshot).toHaveBeenCalledWith(
+      expect.objectContaining({
+        limit: 3,
+        orderBy: `"age" NULLS FIRST`,
+      }),
+    )
+
+    // For limited queries, only requests with identical where clauses can be deduplicated.
+    // With cursor-based pagination, initial loads (without cursor) make 1 requestSnapshot call.
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+  })
+
+  it(`should pass correct WHERE clause to requestSnapshot when live query has filters`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    simulateInitialSync([])
+    expect(electricCollection.size).toBe(0)
+
+    // Create filtered live query
+    createLiveQueryCollection({
+      id: `filtered-live-query`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, true))
+          .orderBy(({ user }) => user.name, `desc`)
+          .limit(10),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Should have requested snapshot with WHERE clause
+    expect(mockRequestSnapshot).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: `"active" = $1`,
+        params: { '1': `true` },
+        orderBy: `"name" DESC NULLS FIRST`,
+        limit: 10,
+      }),
+    )
+  })
+
+  it(`should handle complex filters in fetchSnapshot`, async () => {
+    const electricCollection =
+      createElectricCollectionWithSyncMode(`progressive`)
+
+    expect(electricCollection.status).toBe(`loading`) // Still syncing in progressive mode
+
+    // Create live query with complex WHERE clause
+    createLiveQueryCollection({
+      id: `complex-filter-live-query`,
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => gt(user.age, 20))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(5),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Should have called fetchSnapshot with complex WHERE clause (not requestSnapshot)
+    expect(mockFetchSnapshot).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: `"age" > $1`,
+        params: { '1': `20` },
+        orderBy: `"age" NULLS FIRST`,
+        limit: 5,
+      }),
+    )
+    expect(mockRequestSnapshot).not.toHaveBeenCalled()
+  })
+})
+
+// Tests specifically for loadSubset deduplication
+describe(`Electric Collection - loadSubset deduplication`, () => {
+  let subscriber: (messages: Array<Message<User>>) => void
+
+  function createElectricCollectionWithSyncMode(
+    syncMode: `on-demand` | `progressive`,
+  ) {
+    vi.clearAllMocks()
+
+    mockSubscribe.mockImplementation((callback) => {
+      subscriber = callback
+      return () => {}
+    })
+
+    mockRequestSnapshot.mockResolvedValue({
+      data: [],
+    })
+
+    const config = {
+      id: `electric-dedupe-test-${syncMode}`,
+      shapeOptions: {
+        url: `http://test-url`,
+        params: {
+          table: `users`,
+        },
+      },
+      syncMode,
+      getKey: (user: User) => user.id,
+    }
+
+    const options = electricCollectionOptions(config)
+    return createCollection({
+      ...options,
+      startSync: true,
+      autoIndex: `eager` as const,
+    })
+  }
+
+  function simulateInitialSync(users: Array<User> = sampleUsers) {
+    const messages: Array<Message<User>> = users.map((user) => ({
+      key: user.id.toString(),
+      value: user,
+      headers: { operation: `insert` },
+    }))
+
+    messages.push({
+      headers: { control: `up-to-date` },
+    })
+
+    subscriber(messages)
+  }
+
+  it(`should deduplicate identical concurrent loadSubset requests`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    simulateInitialSync([])
+    expect(electricCollection.status).toBe(`ready`)
+
+    // Create three identical live queries concurrently
+    // Without deduplication, this would trigger 3 requestSnapshot calls
+    // With deduplication, only 1 should be made
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, true))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(10),
+    })
+
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, true))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(10),
+    })
+
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, true))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(10),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // With deduplication, only 1 requestSnapshot call should be made
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+    expect(mockRequestSnapshot).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: `"active" = $1`,
+        params: { '1': `true` },
+        orderBy: `"age" NULLS FIRST`,
+        limit: 10,
+      }),
+    )
+  })
+
+  it(`should deduplicate subset loadSubset requests with same where clause`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    simulateInitialSync([])
+    expect(electricCollection.status).toBe(`ready`)
+
+    // Create a live query with limit 20
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => gt(user.age, 10))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(20),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+
+    // Create a live query with SAME where clause but smaller limit
+    // This SHOULD be deduped because where clauses are equal and limit is smaller
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => gt(user.age, 10)) // Same where clause
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(10), // Smaller limit
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Still only 1 call - the second was deduped (same where, smaller limit)
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+  })
+
+  it(`should NOT deduplicate limited queries with different where clauses`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    simulateInitialSync([])
+    expect(electricCollection.status).toBe(`ready`)
+
+    // Create a live query with a broader predicate
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => gt(user.age, 10))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(20),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+
+    // Create a live query with a DIFFERENT where clause (even if more restrictive)
+    // This should NOT be deduped because for limited queries, where clauses must be EQUAL.
+    // The top 10 of "age > 20" might include rows outside the top 20 of "age > 10".
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => gt(user.age, 20)) // Different where clause
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(10),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // 2 calls - the second was NOT deduped (different where clause with limit)
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(2)
+  })
+
+  it(`should NOT deduplicate non-subset loadSubset requests`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    simulateInitialSync([])
+    expect(electricCollection.status).toBe(`ready`)
+
+    // Create a live query with a narrower predicate
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => gt(user.age, 30))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(10),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+
+    // Create a live query with a broader predicate (age > 20 is NOT subset of age > 30)
+    // This should NOT be deduped - should trigger another requestSnapshot
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => gt(user.age, 20))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(10),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Should have 2 calls - the second was not a subset
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(2)
+  })
+
+  it(`should reset deduplication state on must-refetch/truncate`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    simulateInitialSync(sampleUsers)
+    expect(electricCollection.status).toBe(`ready`)
+
+    // Create a live query
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, true))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(10),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // For limited queries, only requests with identical where clauses can be deduplicated.
+    // With cursor-based pagination, initial loads (without cursor) make 1 requestSnapshot call.
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+
+    // Simulate a must-refetch (which triggers truncate and reset)
+    subscriber([{ headers: { control: `must-refetch` } }])
+    subscriber([{ headers: { control: `up-to-date` } }])
+
+    // Wait for the existing live query to re-request data after truncate
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // The existing live query re-requests its data after truncate
+    // After must-refetch, the query requests data again (1 initial + 1 after truncate)
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(2)
+
+    // Create the same live query again after reset
+    // This should NOT be deduped because the reset cleared the deduplication state,
+    // but it WILL be deduped because the existing live query just made the same request
+    // So creating a different query to ensure we test the reset
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, false))
+          .orderBy(({ user }) => user.age, `asc`)
+          .limit(10),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Should have more calls - the different query triggered a new request
+    // 1 initial + 1 after must-refetch + 1 for new query = 3
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(3)
+  })
+
+  it(`should deduplicate unlimited queries regardless of orderBy`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    simulateInitialSync([])
+    expect(electricCollection.status).toBe(`ready`)
+
+    // Create a live query without limit (unlimited)
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, true))
+          .orderBy(({ user }) => user.age, `asc`),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+
+    // Create another unlimited query with same where but different orderBy
+    // This should be deduped - orderBy is ignored for unlimited queries
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => eq(user.active, true))
+          .orderBy(({ user }) => user.name, `desc`),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Still only 1 call - different orderBy doesn't matter for unlimited queries
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+  })
+
+  it(`should combine multiple unlimited queries with union`, async () => {
+    const electricCollection = createElectricCollectionWithSyncMode(`on-demand`)
+
+    simulateInitialSync([])
+    expect(electricCollection.status).toBe(`ready`)
+
+    // Create first unlimited query (age > 30)
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => gt(user.age, 30)),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(1)
+
+    // Create second unlimited query (age < 20) - different range
+    // This should trigger a new request
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => lt(user.age, 20)),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(2)
+
+    // Create third query (age > 35) - this is a subset of (age > 30)
+    // This should be deduped
+    createLiveQueryCollection({
+      startSync: true,
+      query: (q) =>
+        q
+          .from({ user: electricCollection })
+          .where(({ user }) => gt(user.age, 35)),
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // Still 2 calls - third was covered by the union of first two
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(2)
+  })
 })
diff --git a/packages/electric-db-collection/tests/electric.test-d.ts b/packages/electric-db-collection/tests/electric.test-d.ts
index b45d47370..946e6496a 100644
--- a/packages/electric-db-collection/tests/electric.test-d.ts
+++ b/packages/electric-db-collection/tests/electric.test-d.ts
@@ -1,18 +1,22 @@
-import { describe, expectTypeOf, it } from "vitest"
-import { z } from "zod"
+import { describe, expectTypeOf, it } from 'vitest'
+import { z } from 'zod'
 import {
+  and,
   createCollection,
   createLiveQueryCollection,
   eq,
   gt,
-} from "@tanstack/db"
-import { electricCollectionOptions } from "../src/electric"
-import type { ElectricCollectionConfig } from "../src/electric"
+} from '@tanstack/db'
+import { electricCollectionOptions } from '../src/electric'
+import type {
+  ElectricCollectionConfig,
+  ElectricCollectionUtils,
+} from '../src/electric'
 import type {
   DeleteMutationFnParams,
   InsertMutationFnParams,
   UpdateMutationFnParams,
-} from "@tanstack/db"
+} from '@tanstack/db'
 
 describe(`Electric collection type resolution tests`, () => {
   // Define test types
@@ -96,6 +100,71 @@ describe(`Electric collection type resolution tests`, () => {
     expectTypeOf(options.getKey).parameters.toEqualTypeOf<[FallbackType]>()
   })
 
+  it(`should type collection.utils as ElectricCollectionUtils<T>`, () => {
+    const todoSchema = z.object({
+      id: z.string(),
+      title: z.string(),
+      completed: z.boolean(),
+    })
+
+    type TodoType = z.infer<typeof todoSchema>
+
+    const options = electricCollectionOptions({
+      id: `todos`,
+      getKey: (item) => item.id,
+      shapeOptions: {
+        url: `/api/todos`,
+        params: { table: `todos` },
+      },
+      schema: todoSchema,
+      onInsert: async ({ collection }) => {
+        const testCollectionUtils: ElectricCollectionUtils<TodoType> =
+          collection.utils
+        expectTypeOf(testCollectionUtils.awaitTxId).toBeFunction
+        expectTypeOf(collection.utils.awaitTxId).toBeFunction
+        return Promise.resolve({ txid: 1 })
+      },
+      onUpdate: async ({ collection }) => {
+        const testCollectionUtils: ElectricCollectionUtils<TodoType> =
+          collection.utils
+        expectTypeOf(testCollectionUtils.awaitTxId).toBeFunction
+        expectTypeOf(collection.utils.awaitTxId).toBeFunction
+        return Promise.resolve({ txid: 1 })
+      },
+      onDelete: async ({ collection }) => {
+        const testCollectionUtils: ElectricCollectionUtils<TodoType> =
+          collection.utils
+        expectTypeOf(testCollectionUtils.awaitTxId).toBeFunction
+        expectTypeOf(collection.utils.awaitTxId).toBeFunction
+        return Promise.resolve({ txid: 1 })
+      },
+    })
+
+    // Test that options.utils is typed as ElectricCollectionUtils<TodoType>
+    // The options object should have the correct type from electricCollectionOptions
+    const testOptionsUtils: ElectricCollectionUtils<TodoType> = options.utils
+
+    expectTypeOf(testOptionsUtils.awaitTxId).toBeFunction
+
+    const todosCollection = createCollection(options)
+
+    // Test that todosCollection.utils is ElectricCollectionUtils<TodoType>
+    // Note: We can't use expectTypeOf(...).toEqualTypeOf<ElectricCollectionUtils<T>> because
+    // expectTypeOf's toEqualTypeOf has a constraint that requires { [x: string]: any; [x: number]: never; },
+    // but ElectricCollectionUtils extends UtilsRecord which is Record<string, any> (no number index signature).
+    // This causes a constraint error instead of a type mismatch error.
+    // Instead, we test via type assignment which will show a proper type error if the types don't match.
+    // Currently this shows that todosCollection.utils is typed as UtilsRecord, not ElectricCollectionUtils<TodoType>
+    const testTodosUtils: ElectricCollectionUtils<TodoType> =
+      todosCollection.utils
+
+    expectTypeOf(testTodosUtils.awaitTxId).toBeFunction
+
+    // Verify the specific properties that define ElectricCollectionUtils exist and are functions
+    expectTypeOf(todosCollection.utils.awaitTxId).toBeFunction
+    expectTypeOf(todosCollection.utils.awaitMatch).toBeFunction
+  })
+
   it(`should properly type the onInsert, onUpdate, and onDelete handlers`, () => {
     const options = electricCollectionOptions<ExplicitType>({
       shapeOptions: {
@@ -106,21 +175,21 @@ describe(`Electric collection type resolution tests`, () => {
       onInsert: (params) => {
         // Verify that the mutation value has the correct type
         expectTypeOf(
-          params.transaction.mutations[0].modified
+          params.transaction.mutations[0].modified,
         ).toEqualTypeOf<ExplicitType>()
         return Promise.resolve({ txid: 1 })
       },
       onUpdate: (params) => {
         // Verify that the mutation value has the correct type
         expectTypeOf(
-          params.transaction.mutations[0].modified
+          params.transaction.mutations[0].modified,
         ).toEqualTypeOf<ExplicitType>()
         return Promise.resolve({ txid: 1 })
       },
       onDelete: (params) => {
         // Verify that the mutation value has the correct type
         expectTypeOf(
-          params.transaction.mutations[0].original
+          params.transaction.mutations[0].original,
         ).toEqualTypeOf<ExplicitType>()
         return Promise.resolve({ txid: 1 })
       },
@@ -140,6 +209,88 @@ describe(`Electric collection type resolution tests`, () => {
     >()
   })
 
+  it(`should correctly type mutations in transaction handlers when mapping over mutations array`, () => {
+    const schema = z.object({
+      id: z.string(),
+      title: z.string(),
+      completed: z.boolean(),
+    })
+
+    type TodoType = z.infer<typeof schema>
+
+    const options = electricCollectionOptions({
+      id: `todos`,
+      schema,
+      getKey: (item) => item.id,
+      shapeOptions: {
+        url: `/api/todos`,
+        params: { table: `todos` },
+      },
+      onDelete: (params) => {
+        // Direct index access should be correctly typed
+        expectTypeOf(
+          params.transaction.mutations[0].original,
+        ).toEqualTypeOf<TodoType>()
+
+        // Non-null assertion on second element should be correctly typed
+        expectTypeOf(
+          params.transaction.mutations[1]!.original,
+        ).toEqualTypeOf<TodoType>()
+
+        // When mapping over mutations, each mutation.original should be correctly typed
+        params.transaction.mutations.map((mutation) => {
+          expectTypeOf(mutation.original).toEqualTypeOf<TodoType>()
+          return mutation.original.id
+        })
+
+        return Promise.resolve({ txid: 1 })
+      },
+      onInsert: (params) => {
+        // Direct index access should be correctly typed
+        expectTypeOf(
+          params.transaction.mutations[0].modified,
+        ).toEqualTypeOf<TodoType>()
+
+        // When mapping over mutations, each mutation.modified should be correctly typed
+        params.transaction.mutations.map((mutation) => {
+          expectTypeOf(mutation.modified).toEqualTypeOf<TodoType>()
+          return mutation.modified.id
+        })
+
+        return Promise.resolve({ txid: 1 })
+      },
+      onUpdate: (params) => {
+        // Direct index access should be correctly typed
+        expectTypeOf(
+          params.transaction.mutations[0].original,
+        ).toEqualTypeOf<TodoType>()
+        expectTypeOf(
+          params.transaction.mutations[0].modified,
+        ).toEqualTypeOf<TodoType>()
+
+        // When mapping over mutations, each mutation should be correctly typed
+        params.transaction.mutations.map((mutation) => {
+          expectTypeOf(mutation.original).toEqualTypeOf<TodoType>()
+          expectTypeOf(mutation.modified).toEqualTypeOf<TodoType>()
+          return mutation.modified.id
+        })
+
+        return Promise.resolve({ txid: 1 })
+      },
+    })
+
+    // Verify that the handlers are properly typed
+    expectTypeOf(options.onDelete).parameters.toEqualTypeOf<
+      [DeleteMutationFnParams<TodoType>]
+    >()
+    expectTypeOf(options.onInsert).parameters.toEqualTypeOf<
+      [InsertMutationFnParams<TodoType>]
+    >()
+    expectTypeOf(options.onUpdate).parameters.toEqualTypeOf<
+      [UpdateMutationFnParams<TodoType>]
+    >()
+  })
+
   it(`should infer types from Zod schema through electric collection options to live query`, () => {
     // Define a Zod schema for a user with basic field types
     const userSchema = z.object({
@@ -200,7 +351,7 @@ describe(`Electric collection type resolution tests`, () => {
       query: (q) =>
         q
           .from({ user: usersCollection })
-          .where(({ user }) => eq(user.active, true) && gt(user.age, 18))
+          .where(({ user }) => and(eq(user.active, true), gt(user.age, 18)))
           .select(({ user }) => ({
             id: user.id,
             name: user.name,
diff --git a/packages/electric-db-collection/tests/electric.test.ts b/packages/electric-db-collection/tests/electric.test.ts
index bf059a021..7a8bc7384 100644
--- a/packages/electric-db-collection/tests/electric.test.ts
+++ b/packages/electric-db-collection/tests/electric.test.ts
@@ -1,11 +1,11 @@
-import { beforeEach, describe, expect, it, vi } from "vitest"
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   CollectionImpl,
   createCollection,
   createTransaction,
-} from "@tanstack/db"
-import { electricCollectionOptions, isChangeMessage } from "../src/electric"
-import type { ElectricCollectionUtils } from "../src/electric"
+} from '@tanstack/db'
+import { electricCollectionOptions, isChangeMessage } from '../src/electric'
+import type { ElectricCollectionUtils } from '../src/electric'
 import type {
   Collection,
   InsertMutationFnParams,
@@ -13,14 +13,18 @@ import type {
   PendingMutation,
   Transaction,
   TransactionWithMutations,
-} from "@tanstack/db"
-import type { Message, Row } from "@electric-sql/client"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+} from '@tanstack/db'
+import type { Message, Row } from '@electric-sql/client'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 // Mock the ShapeStream module
 const mockSubscribe = vi.fn()
+const mockRequestSnapshot = vi.fn()
+const mockFetchSnapshot = vi.fn()
 const mockStream = {
   subscribe: mockSubscribe,
+  requestSnapshot: mockRequestSnapshot,
+  fetchSnapshot: mockFetchSnapshot,
 }
 
 vi.mock(`@electric-sql/client`, async () => {
@@ -50,6 +54,9 @@ describe(`Electric Integration`, () => {
       return () => {}
     })
 
+    // Reset mock requestSnapshot
+    mockRequestSnapshot.mockResolvedValue(undefined)
+
     // Create collection with Electric configuration
     const config = {
       id: `test`,
@@ -67,7 +74,13 @@ describe(`Electric Integration`, () => {
     const options = electricCollectionOptions(config)
 
     // Create collection with Electric configuration using the new utility exposure pattern
-    collection = createCollection(options)
+    collection = createCollection(options) as unknown as Collection<
+      Row,
+      string | number,
+      ElectricCollectionUtils,
+      StandardSchemaV1<unknown, unknown>,
+      Row
+    >
   })
 
   it(`should commit an empty transaction when there's an up-to-date`, () => {
@@ -103,7 +116,7 @@ describe(`Electric Integration`, () => {
     ])
 
     expect(collection.state).toEqual(
-      new Map([[1, { id: 1, name: `Test User` }]])
+      new Map([[1, { id: 1, name: `Test User` }]]),
     )
   })
 
@@ -141,7 +154,7 @@ describe(`Electric Integration`, () => {
       new Map([
         [1, { id: 1, name: `Test User` }],
         [2, { id: 2, name: `Another User` }],
-      ])
+      ]),
     )
   })
 
@@ -172,7 +185,7 @@ describe(`Electric Integration`, () => {
     ])
 
     expect(collection.state).toEqual(
-      new Map([[1, { id: 1, name: `Updated User` }]])
+      new Map([[1, { id: 1, name: `Updated User` }]]),
     )
   })
 
@@ -301,9 +314,9 @@ describe(`Electric Integration`, () => {
       // awaitTxId throws if you pass it a string
       await expect(
         // @ts-expect-error
-        collection.utils.awaitTxId(`123`)
+        collection.utils.awaitTxId(`123`),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `[ExpectedNumberInAwaitTxIdError: [test] Expected number in awaitTxId, received string]`
+        `[ExpectedNumberInAwaitTxIdError: [test] Expected number in awaitTxId, received string]`,
       )
 
       // The txid should be tracked and awaitTxId should resolve immediately
@@ -344,7 +357,7 @@ describe(`Electric Integration`, () => {
 
       // The promise should reject with a timeout error
       await expect(promise).rejects.toThrow(
-        `Timeout waiting for txId: ${unknownTxid}`
+        `Timeout waiting for txId: ${unknownTxid}`,
       )
     })
 
@@ -436,7 +449,7 @@ describe(`Electric Integration`, () => {
         async ({ transaction }: { transaction: Transaction }) => {
           // Persist to fake backend and get txid
           const txid = await fakeBackend.persist(
-            transaction.mutations as Array<PendingMutation<Row>>
+            transaction.mutations as Array<PendingMutation<Row>>,
           )
 
           if (!txid) {
@@ -455,13 +468,13 @@ describe(`Electric Integration`, () => {
           await promise
 
           return Promise.resolve()
-        }
+        },
       )
 
       const tx1 = createTransaction({ mutationFn: testMutationFn })
 
       let transaction = tx1.mutate(() =>
-        collection.insert({ id: 1, name: `Test item 1` })
+        collection.insert({ id: 1, name: `Test item 1` }),
       )
 
       await transaction.isPersisted.promise
@@ -667,6 +680,115 @@ describe(`Electric Integration`, () => {
       expect(onInsert).toHaveBeenCalled()
     })
 
+    it(`should support custom timeout in matching strategy`, async () => {
+      const onInsert = vi.fn(() => {
+        // Return a txid that will never arrive with a very short timeout
+        return Promise.resolve({ txid: 999999, timeout: 100 })
+      })
+
+      const config = {
+        id: `test-custom-timeout`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        startSync: true,
+        getKey: (item: Row) => item.id as number,
+        onInsert,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Insert data - should timeout after 100ms
+      const tx = testCollection.insert({ id: 1, name: `Timeout Test` })
+
+      // Verify that our onInsert handler was called
+      expect(onInsert).toHaveBeenCalled()
+
+      // The transaction should reject due to timeout
+      await expect(tx.isPersisted.promise).rejects.toThrow(
+        `Timeout waiting for txId: 999999`,
+      )
+    })
+
+    it(`should handle array of txids returned from handler`, async () => {
+      // Create a fake backend that returns multiple txids
+      const fakeBackend = {
+        persist: (
+          mutations: Array<PendingMutation<Row>>,
+        ): Promise<Array<number>> => {
+          // Simulate multiple items being persisted and each getting a txid
+          const txids = mutations.map(() => Math.floor(Math.random() * 10000))
+          return Promise.resolve(txids)
+        },
+      }
+
+      // Create handler that returns array of txids
+      const onInsert = vi.fn(async (params: MutationFnParams<Row>) => {
+        const txids = await fakeBackend.persist(params.transaction.mutations)
+
+        // Simulate server sending sync messages on different ticks
+        // In the real world, multiple txids rarely arrive together
+        setTimeout(() => {
+          subscriber([
+            {
+              key: `1`,
+              value: { id: 1, name: `Item 1` },
+              headers: {
+                operation: `insert`,
+                txids: [txids[0]!],
+              },
+            },
+            { headers: { control: `up-to-date` } },
+          ])
+        }, 1)
+
+        setTimeout(() => {
+          subscriber([
+            {
+              key: `2`,
+              value: { id: 2, name: `Item 2` },
+              headers: {
+                operation: `insert`,
+                txids: [txids[1]!],
+              },
+            },
+            { headers: { control: `up-to-date` } },
+          ])
+        }, 2)
+
+        // Return array of txids - this is the pattern that's failing
+        return { txid: txids }
+      })
+
+      const config = {
+        id: `test-array-txids`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        startSync: true,
+        getKey: (item: Row) => item.id as number,
+        onInsert,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Insert multiple items
+      const tx = testCollection.insert([
+        { id: 1, name: `Item 1` },
+        { id: 2, name: `Item 2` },
+      ])
+
+      // This should resolve when all txids are seen
+      await expect(tx.isPersisted.promise).resolves.toBeDefined()
+      expect(onInsert).toHaveBeenCalled()
+
+      // Verify both items were added
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.has(2)).toBe(true)
+    })
+
     it(`should support custom match function using awaitMatch utility`, async () => {
       let resolveCustomMatch: () => void
       const customMatchPromise = new Promise<void>((resolve) => {
@@ -728,6 +850,9 @@ describe(`Electric Integration`, () => {
       expect(testCollection.has(1)).toBe(true)
     })
 
+    // NOTE: This test has a known issue with unhandled rejection warnings
+    // This is a pre-existing issue from main branch (not caused by merge)
+    // The test functionality works correctly, but vitest reports unhandled rejections
     it(`should timeout with custom match function when no match found`, async () => {
       vi.useFakeTimers()
 
@@ -736,7 +861,7 @@ describe(`Electric Integration`, () => {
         .mockImplementation(async ({ collection: col }) => {
           await col.utils.awaitMatch(
             () => false, // Never matches
-            1 // Short timeout for test
+            1, // Short timeout for test
           )
         })
 
@@ -754,100 +879,126 @@ describe(`Electric Integration`, () => {
       const testCollection = createCollection(electricCollectionOptions(config))
       const tx = testCollection.insert({ id: 1, name: `Timeout Test` })
 
-      // Add catch handler to prevent global unhandled rejection detection
-      tx.isPersisted.promise.catch(() => {})
+      // Capture the rejection promise before advancing timers
+      const rejectionPromise = expect(tx.isPersisted.promise).rejects.toThrow(
+        `Timeout waiting for custom match function`,
+      )
 
       // Advance timers to trigger timeout
       await vi.runOnlyPendingTimersAsync()
 
       // Should timeout and fail
-      await expect(tx.isPersisted.promise).rejects.toThrow()
+      await rejectionPromise
 
       vi.useRealTimers()
     })
-  })
 
-  // Tests for matching strategies utilities
-  describe(`Matching strategies utilities`, () => {
-    it(`should export isChangeMessage helper for custom match functions`, () => {
-      expect(typeof isChangeMessage).toBe(`function`)
+    it(`should find matching message in awaitMatch even when called after up-to-date`, async () => {
+      // This test verifies the fix for the race condition where:
+      // 1. Server receives insert and syncs it via Electric
+      // 2. Electric messages (including up-to-date) are processed
+      // 3. THEN awaitMatch is called - it should still find the message
 
-      // Test with a change message
-      const changeMessage = {
-        key: `1`,
-        value: { id: 1, name: `Test` },
-        headers: { operation: `insert` as const },
-      }
-      expect(isChangeMessage(changeMessage)).toBe(true)
+      let resolveServerCall: () => void
+      const serverCallPromise = new Promise<void>((resolve) => {
+        resolveServerCall = resolve
+      })
 
-      // Test with a control message
-      const controlMessage = {
-        headers: { control: `up-to-date` as const },
-      }
-      expect(isChangeMessage(controlMessage)).toBe(false)
-    })
+      const onInsert = vi
+        .fn()
+        .mockImplementation(async ({ transaction, collection: col }) => {
+          const item = transaction.mutations[0].modified
+
+          // Simulate waiting for server call to complete
+          // During this time, Electric messages will arrive and be processed
+          await serverCallPromise
+
+          // Now awaitMatch is called AFTER the messages were processed
+          // This should still find the message in the buffer
+          await col.utils.awaitMatch((message: any) => {
+            return (
+              isChangeMessage(message) &&
+              message.headers.operation === `insert` &&
+              message.value.id === item.id
+            )
+          }, 5000)
+        })
 
-    it(`should provide awaitMatch utility in collection utils`, () => {
       const config = {
-        id: `test-await-match`,
+        id: `test-await-match-after-up-to-date`,
         shapeOptions: {
           url: `http://test-url`,
           params: { table: `test_table` },
         },
+        startSync: true,
         getKey: (item: Row) => item.id as number,
+        onInsert,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
-      expect(typeof testCollection.utils.awaitMatch).toBe(`function`)
-    })
 
-    it(`should support multiple strategies in different handlers`, () => {
-      const onInsert = vi.fn().mockResolvedValue({ txid: 100 }) // Txid strategy
-      const onUpdate = vi.fn().mockResolvedValue(undefined) // Void strategy (no return)
-      const onDelete = vi
-        .fn()
-        .mockImplementation(async ({ collection: col }) => {
-          // Custom match using awaitMatch utility
-          await col.utils.awaitMatch(
-            (message: any) =>
-              isChangeMessage(message) && message.headers.operation === `delete`
-          )
-        })
+      // Start insert - will call onInsert which waits for serverCallPromise
+      const insertPromise = testCollection.insert({
+        id: 42,
+        name: `Race Condition Test`,
+      })
 
-      const config = {
-        id: `test-mixed-strategies`,
-        shapeOptions: {
-          url: `http://test-url`,
-          params: { table: `test_table` },
+      // Wait for onInsert to start and reach the await serverCallPromise
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Send Electric messages while onInsert is waiting for serverCallPromise
+      // This simulates the race condition where messages arrive while API call is in progress
+      subscriber([
+        {
+          key: `42`,
+          value: { id: 42, name: `Race Condition Test` },
+          headers: { operation: `insert` },
         },
-        getKey: (item: Row) => item.id as number,
-        onInsert,
-        onUpdate,
-        onDelete,
-      }
+        { headers: { control: `up-to-date` } },
+      ])
 
-      const options = electricCollectionOptions(config)
+      // Wait a tick to ensure messages are processed
+      await new Promise((resolve) => setTimeout(resolve, 10))
 
-      // All handlers should be wrapped properly
-      expect(options.onInsert).toBeDefined()
-      expect(options.onUpdate).toBeDefined()
-      expect(options.onDelete).toBeDefined()
+      // Now resolve the server call - awaitMatch will be called AFTER messages were processed
+      resolveServerCall!()
+
+      // Should complete successfully - awaitMatch should find the message in the buffer
+      await insertPromise.isPersisted.promise
+
+      expect(onInsert).toHaveBeenCalled()
+      expect(testCollection.has(42)).toBe(true)
     })
 
-    it(`should cleanup pending matches on timeout without memory leaks`, async () => {
-      vi.useFakeTimers()
+    it(`should wait for up-to-date when match found during batch processing`, async () => {
+      // This test verifies that if awaitMatch finds a match while the batch
+      // is still being processed (before up-to-date), it waits for up-to-date
+      // before resolving, ensuring data is committed before returning
+
+      let matchFoundTime: number | undefined
+      let resolveTime: number | undefined
 
       const onInsert = vi
         .fn()
-        .mockImplementation(async ({ collection: col }) => {
-          await col.utils.awaitMatch(
-            () => false, // Never matches
-            1 // Short timeout for test
-          )
+        .mockImplementation(async ({ transaction, collection: col }) => {
+          const item = transaction.mutations[0].modified
+
+          await col.utils.awaitMatch((message: any) => {
+            if (
+              isChangeMessage(message) &&
+              message.headers.operation === `insert` &&
+              message.value.id === item.id
+            ) {
+              matchFoundTime = Date.now()
+              return true
+            }
+            return false
+          }, 5000)
+          resolveTime = Date.now()
         })
 
       const config = {
-        id: `test-cleanup`,
+        id: `test-wait-for-up-to-date`,
         shapeOptions: {
           url: `http://test-url`,
           params: { table: `test_table` },
@@ -859,59 +1010,66 @@ describe(`Electric Integration`, () => {
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Start insert that will timeout
-      const tx = testCollection.insert({ id: 1, name: `Timeout Test` })
-
-      // Add catch handler to prevent global unhandled rejection detection
-      tx.isPersisted.promise.catch(() => {})
-
-      // Advance timers to trigger timeout
-      await vi.runOnlyPendingTimersAsync()
-
-      // Should timeout and fail
-      await expect(tx.isPersisted.promise).rejects.toThrow(
-        `Timeout waiting for custom match function`
-      )
+      const insertPromise = testCollection.insert({
+        id: 100,
+        name: `Wait Test`,
+      })
 
-      // Send a message after timeout - should not cause any side effects
-      // This verifies that the pending match was properly cleaned up
-      expect(() => {
+      // Send insert message first, then up-to-date after a delay
+      // This simulates awaitMatch finding the message before up-to-date
+      setTimeout(() => {
         subscriber([
           {
-            key: `1`,
-            value: { id: 1, name: `Timeout Test` },
+            key: `100`,
+            value: { id: 100, name: `Wait Test` },
             headers: { operation: `insert` },
           },
-          { headers: { control: `up-to-date` } },
         ])
-      }).not.toThrow()
+      }, 50)
 
-      vi.useRealTimers()
+      // Send up-to-date after another delay
+      setTimeout(() => {
+        subscriber([{ headers: { control: `up-to-date` } }])
+      }, 150)
+
+      await insertPromise.isPersisted.promise
+
+      expect(onInsert).toHaveBeenCalled()
+      // Match should have been found before resolve (both times should exist)
+      expect(matchFoundTime).toBeDefined()
+      expect(resolveTime).toBeDefined()
+      // Verify that resolve happened AFTER match was found (waited for up-to-date)
+      expect(resolveTime).toBeGreaterThanOrEqual(matchFoundTime!)
     })
 
-    it(`should wait for up-to-date after custom match (commit semantics)`, async () => {
-      let matchFound = false
-      let persistenceCompleted = false
+    it(`should clear buffer on new batch and match new messages`, async () => {
+      // Verify that when a new batch arrives, the old buffer is cleared
+      // and awaitMatch correctly matches messages from the new batch
+
+      let resolveServerCall: () => void
+      const serverCallPromise = new Promise<void>((resolve) => {
+        resolveServerCall = resolve
+      })
 
       const onInsert = vi
         .fn()
         .mockImplementation(async ({ transaction, collection: col }) => {
           const item = transaction.mutations[0].modified
+
+          // Simulate API call
+          await serverCallPromise
+
           await col.utils.awaitMatch((message: any) => {
-            if (
+            return (
               isChangeMessage(message) &&
               message.headers.operation === `insert` &&
-              message.value.name === item.name
-            ) {
-              matchFound = true
-              return true
-            }
-            return false
+              message.value.id === item.id
+            )
           }, 5000)
         })
 
       const config = {
-        id: `test-commit-semantics`,
+        id: `test-buffer-clearing`,
         shapeOptions: {
           url: `http://test-url`,
           params: { table: `test_table` },
@@ -923,59 +1081,64 @@ describe(`Electric Integration`, () => {
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Start insert
+      // Start insert for item 201
       const insertPromise = testCollection.insert({
-        id: 1,
-        name: `Commit Test`,
-      })
-
-      // Set up persistence completion tracking
-      insertPromise.isPersisted.promise.then(() => {
-        persistenceCompleted = true
+        id: 201,
+        name: `Second Item`,
       })
 
-      // Give a moment for handler setup
-      await new Promise((resolve) => setTimeout(resolve, 50))
+      // Wait for onInsert to start
+      await new Promise((resolve) => setTimeout(resolve, 10))
 
-      // Send matching message (should match but not complete persistence yet)
+      // First batch - insert different item 200 (simulating other sync activity)
       subscriber([
         {
-          key: `1`,
-          value: { id: 1, name: `Commit Test` },
+          key: `200`,
+          value: { id: 200, name: `First Item` },
           headers: { operation: `insert` },
         },
+        { headers: { control: `up-to-date` } },
       ])
 
-      // Give time for match to be processed
-      await new Promise((resolve) => setTimeout(resolve, 50))
+      await new Promise((resolve) => setTimeout(resolve, 10))
 
-      // Verify match was found but persistence not yet completed
-      expect(matchFound).toBe(true)
-      expect(persistenceCompleted).toBe(false)
+      // Second batch - insert item 201 (our target)
+      subscriber([
+        {
+          key: `201`,
+          value: { id: 201, name: `Second Item` },
+          headers: { operation: `insert` },
+        },
+        { headers: { control: `up-to-date` } },
+      ])
 
-      // Now send up-to-date (should complete persistence)
-      subscriber([{ headers: { control: `up-to-date` } }])
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Resolve server call - awaitMatch should find item 201 in the buffer
+      // even though item 200 from the first batch is no longer in the buffer
+      resolveServerCall!()
 
-      // Wait for persistence to complete
       await insertPromise.isPersisted.promise
 
-      // Verify persistence completed after up-to-date
-      expect(persistenceCompleted).toBe(true)
-      expect(testCollection._state.syncedData.has(1)).toBe(true)
+      expect(testCollection.has(201)).toBe(true)
     })
 
-    it(`should support custom timeout using setTimeout`, async () => {
-      vi.useFakeTimers()
-
-      const customTimeout = 500 // Custom short timeout
+    it(`should timeout when no match in committed batch and no new messages`, async () => {
+      // Verify that awaitMatch times out when the message isn't found
 
-      const onInsert = vi.fn().mockImplementation(async () => {
-        // Simple timeout approach
-        await new Promise((resolve) => setTimeout(resolve, customTimeout))
-      })
+      const onInsert = vi
+        .fn()
+        .mockImplementation(async ({ collection: col }) => {
+          // Look for a message that doesn't exist
+          await col.utils.awaitMatch(
+            (message: any) =>
+              isChangeMessage(message) && message.value.id === 999,
+            100, // Short timeout
+          )
+        })
 
       const config = {
-        id: `test-void-timeout`,
+        id: `test-no-match-timeout`,
         shapeOptions: {
           url: `http://test-url`,
           params: { table: `test_table` },
@@ -987,53 +1150,1776 @@ describe(`Electric Integration`, () => {
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Insert with custom void timeout
-      const tx = testCollection.insert({ id: 1, name: `Custom Timeout Test` })
+      // Send a batch with different items
+      subscriber([
+        {
+          key: `300`,
+          value: { id: 300, name: `Wrong Item` },
+          headers: { operation: `insert` },
+        },
+        { headers: { control: `up-to-date` } },
+      ])
 
-      // Use runOnlyPendingTimers to execute the timeout
-      await vi.runOnlyPendingTimersAsync()
+      await new Promise((resolve) => setTimeout(resolve, 20))
 
-      await expect(tx.isPersisted.promise).resolves.toBeDefined()
-      expect(onInsert).toHaveBeenCalled()
+      // Insert looking for id 999 which doesn't exist
+      const tx = testCollection.insert({ id: 301, name: `Test` })
+
+      await expect(tx.isPersisted.promise).rejects.toThrow(
+        `Timeout waiting for custom match function`,
+      )
+    })
+
+    it(`should resolve multiple awaitMatch calls from same committed batch`, async () => {
+      // Verify that multiple concurrent awaitMatch calls can all find their
+      // respective messages in the same committed batch
+
+      const matches: Array<number> = []
+      const serverCalls: Array<{ resolve: () => void }> = []
+
+      const onInsert = vi
+        .fn()
+        .mockImplementation(async ({ transaction, collection: col }) => {
+          const item = transaction.mutations[0].modified
+
+          // Create a promise for this insert's "API call"
+          const serverCallPromise = new Promise<void>((resolve) => {
+            serverCalls.push({ resolve })
+          })
+          await serverCallPromise
+
+          await col.utils.awaitMatch((message: any) => {
+            if (
+              isChangeMessage(message) &&
+              message.headers.operation === `insert` &&
+              message.value.id === item.id
+            ) {
+              matches.push(item.id)
+              return true
+            }
+            return false
+          }, 5000)
+        })
+
+      const config = {
+        id: `test-multiple-matches`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        startSync: true,
+        getKey: (item: Row) => item.id as number,
+        onInsert,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Start all three inserts concurrently
+      const insert1 = testCollection.insert({ id: 400, name: `Item A` })
+      const insert2 = testCollection.insert({ id: 401, name: `Item B` })
+      const insert3 = testCollection.insert({ id: 402, name: `Item C` })
+
+      // Wait for all onInsert handlers to start
+      await new Promise((resolve) => setTimeout(resolve, 20))
+
+      // Send batch with all three items (simulating fast sync from server)
+      subscriber([
+        {
+          key: `400`,
+          value: { id: 400, name: `Item A` },
+          headers: { operation: `insert` },
+        },
+        {
+          key: `401`,
+          value: { id: 401, name: `Item B` },
+          headers: { operation: `insert` },
+        },
+        {
+          key: `402`,
+          value: { id: 402, name: `Item C` },
+          headers: { operation: `insert` },
+        },
+        { headers: { control: `up-to-date` } },
+      ])
+
+      await new Promise((resolve) => setTimeout(resolve, 20))
+
+      // Resolve all server calls - all awaitMatch calls should find their messages
+      serverCalls.forEach((call) => call.resolve())
+
+      await Promise.all([
+        insert1.isPersisted.promise,
+        insert2.isPersisted.promise,
+        insert3.isPersisted.promise,
+      ])
+
+      expect(matches).toContain(400)
+      expect(matches).toContain(401)
+      expect(matches).toContain(402)
+      expect(testCollection.has(400)).toBe(true)
+      expect(testCollection.has(401)).toBe(true)
+      expect(testCollection.has(402)).toBe(true)
+    })
+
+    it(`should handle awaitMatch across multiple sequential batches`, async () => {
+      // Real-world scenario: continuous sync with multiple batches
+      // Each insert should find its matching message in the committed buffer
+
+      const serverCalls: Array<{ resolve: () => void; id: number }> = []
+
+      const onInsert = vi
+        .fn()
+        .mockImplementation(async ({ transaction, collection: col }) => {
+          const item = transaction.mutations[0].modified
+
+          // Create a promise for this insert's "API call"
+          const serverCallPromise = new Promise<void>((resolve) => {
+            serverCalls.push({ resolve, id: item.id })
+          })
+          await serverCallPromise
+
+          await col.utils.awaitMatch((message: any) => {
+            return (
+              isChangeMessage(message) &&
+              message.headers.operation === `insert` &&
+              message.value.id === item.id
+            )
+          }, 5000)
+        })
+
+      const config = {
+        id: `test-sequential-batches`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        startSync: true,
+        getKey: (item: Row) => item.id as number,
+        onInsert,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Insert 1 - starts waiting on server call
+      const insert1 = testCollection.insert({ id: 500, name: `Batch 1 Item` })
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Batch 1 arrives with item 500
+      subscriber([
+        {
+          key: `500`,
+          value: { id: 500, name: `Batch 1 Item` },
+          headers: { operation: `insert` },
+        },
+        { headers: { control: `up-to-date` } },
+      ])
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Resolve server call for insert 1
+      const call1 = serverCalls.find((c) => c.id === 500)
+      call1?.resolve()
+      await insert1.isPersisted.promise
+      expect(testCollection.has(500)).toBe(true)
+
+      // Insert 2 - starts waiting on server call
+      const insert2 = testCollection.insert({ id: 501, name: `Batch 2 Item` })
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Batch 2 arrives (clears batch 1 from buffer)
+      subscriber([
+        {
+          key: `501`,
+          value: { id: 501, name: `Batch 2 Item` },
+          headers: { operation: `insert` },
+        },
+        { headers: { control: `up-to-date` } },
+      ])
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Resolve server call for insert 2
+      const call2 = serverCalls.find((c) => c.id === 501)
+      call2?.resolve()
+      await insert2.isPersisted.promise
+      expect(testCollection.has(501)).toBe(true)
+
+      // Insert 3 - starts waiting on server call
+      const insert3 = testCollection.insert({ id: 502, name: `Batch 3 Item` })
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Batch 3 arrives
+      subscriber([
+        {
+          key: `502`,
+          value: { id: 502, name: `Batch 3 Item` },
+          headers: { operation: `insert` },
+        },
+        { headers: { control: `up-to-date` } },
+      ])
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Resolve server call for insert 3
+      const call3 = serverCalls.find((c) => c.id === 502)
+      call3?.resolve()
+      await insert3.isPersisted.promise
+      expect(testCollection.has(502)).toBe(true)
+    })
+
+    it(`should preserve buffer across heartbeat batches until awaitMatch is called`, async () => {
+      // This test verifies the fix for the race condition where:
+      // 1. Batch 1 arrives with insert message + up-to-date
+      // 2. Batch 2 arrives (heartbeat/empty) BEFORE awaitMatch is called
+      // 3. awaitMatch is called - should still find the message from Batch 1
+      // This was failing before because the buffer was cleared when Batch 2 arrived
+
+      let resolveServerCall: () => void
+      const serverCallPromise = new Promise<void>((resolve) => {
+        resolveServerCall = resolve
+      })
+
+      const onInsert = vi
+        .fn()
+        .mockImplementation(async ({ transaction, collection: col }) => {
+          const item = transaction.mutations[0].modified
+
+          // Simulate a slow API call
+          await serverCallPromise
+
+          // awaitMatch is called AFTER multiple batches have arrived
+          await col.utils.awaitMatch((message: any) => {
+            return (
+              isChangeMessage(message) &&
+              message.headers.operation === `insert` &&
+              message.value.id === item.id
+            )
+          }, 5000)
+        })
+
+      const config = {
+        id: `test-buffer-preserved-across-heartbeats`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        startSync: true,
+        getKey: (item: Row) => item.id as number,
+        onInsert,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Start insert - will call onInsert which waits for serverCallPromise
+      const insertPromise = testCollection.insert({
+        id: 600,
+        name: `Heartbeat Race Test`,
+      })
+
+      // Wait for onInsert to start
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Batch 1: insert message + up-to-date
+      subscriber([
+        {
+          key: `600`,
+          value: { id: 600, name: `Heartbeat Race Test` },
+          headers: { operation: `insert` },
+        },
+        { headers: { control: `up-to-date` } },
+      ])
+
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Batch 2: heartbeat (just up-to-date, no insert messages)
+      // This simulates Electric sending a heartbeat while the API call is still in progress
+      // Previously, this would clear the buffer and lose the insert message from Batch 1
+      subscriber([{ headers: { control: `up-to-date` } }])
+
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Batch 3: another heartbeat (to really stress the scenario)
+      subscriber([{ headers: { control: `up-to-date` } }])
+
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Now resolve the server call - awaitMatch should still find the message
+      // from Batch 1 despite Batches 2 and 3 arriving
+      resolveServerCall!()
+
+      // Should complete successfully
+      await insertPromise.isPersisted.promise
+
+      expect(onInsert).toHaveBeenCalled()
+      expect(testCollection.has(600)).toBe(true)
+    })
+  })
+
+  // Tests for matching strategies utilities
+  describe(`Matching strategies utilities`, () => {
+    it(`should export isChangeMessage helper for custom match functions`, () => {
+      expect(typeof isChangeMessage).toBe(`function`)
+
+      // Test with a change message
+      const changeMessage = {
+        key: `1`,
+        value: { id: 1, name: `Test` },
+        headers: { operation: `insert` as const },
+      }
+      expect(isChangeMessage(changeMessage)).toBe(true)
+
+      // Test with a control message
+      const controlMessage = {
+        headers: { control: `up-to-date` as const },
+      }
+      expect(isChangeMessage(controlMessage)).toBe(false)
+    })
+
+    it(`should export isChangeMessage and isControlMessage from package index`, async () => {
+      // Verify that the exports are available from the package's public API
+      // This tests the fix for the missing exports in index.ts
+      const exports = await import(`../src/index`)
+
+      expect(typeof exports.isChangeMessage).toBe(`function`)
+      expect(typeof exports.isControlMessage).toBe(`function`)
+
+      // Verify they work correctly
+      const changeMessage = {
+        key: `1`,
+        value: { id: 1, name: `Test` },
+        headers: { operation: `insert` as const },
+      }
+      expect(exports.isChangeMessage(changeMessage)).toBe(true)
+
+      const controlMessage = {
+        headers: { control: `up-to-date` as const },
+      }
+      expect(exports.isControlMessage(controlMessage)).toBe(true)
+      expect(exports.isChangeMessage(controlMessage)).toBe(false)
+    })
+
+    it(`should provide awaitMatch utility in collection utils`, () => {
+      const config = {
+        id: `test-await-match`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        getKey: (item: Row) => item.id as number,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+      expect(typeof testCollection.utils.awaitMatch).toBe(`function`)
+    })
+
+    it(`should support multiple strategies in different handlers`, () => {
+      const onInsert = vi.fn().mockResolvedValue({ txid: 100 }) // Txid strategy
+      const onUpdate = vi.fn().mockResolvedValue(undefined) // Void strategy (no return)
+      const onDelete = vi
+        .fn()
+        .mockImplementation(async ({ collection: col }) => {
+          // Custom match using awaitMatch utility
+          await col.utils.awaitMatch(
+            (message: any) =>
+              isChangeMessage(message) &&
+              message.headers.operation === `delete`,
+          )
+        })
+
+      const config = {
+        id: `test-mixed-strategies`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        getKey: (item: Row) => item.id as number,
+        onInsert,
+        onUpdate,
+        onDelete,
+      }
+
+      const options = electricCollectionOptions(config)
+
+      // All handlers should be wrapped properly
+      expect(options.onInsert).toBeDefined()
+      expect(options.onUpdate).toBeDefined()
+      expect(options.onDelete).toBeDefined()
+    })
+
+    // NOTE: This test has a known issue with unhandled rejection warnings
+    // This is a pre-existing issue from main branch (not caused by merge)
+    // The test functionality works correctly, but vitest reports unhandled rejections
+    it(`should cleanup pending matches on timeout without memory leaks`, async () => {
+      vi.useFakeTimers()
+
+      const onInsert = vi
+        .fn()
+        .mockImplementation(async ({ collection: col }) => {
+          await col.utils.awaitMatch(
+            () => false, // Never matches
+            1, // Short timeout for test
+          )
+        })
+
+      const config = {
+        id: `test-cleanup`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        startSync: true,
+        getKey: (item: Row) => item.id as number,
+        onInsert,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Start insert that will timeout
+      const tx = testCollection.insert({ id: 1, name: `Timeout Test` })
+
+      // Capture the rejection promise before advancing timers
+      const rejectionPromise = expect(tx.isPersisted.promise).rejects.toThrow(
+        `Timeout waiting for custom match function`,
+      )
+
+      // Advance timers to trigger timeout
+      await vi.runOnlyPendingTimersAsync()
+
+      // Should timeout and fail
+      await rejectionPromise
+
+      // Send a message after timeout - should not cause any side effects
+      // This verifies that the pending match was properly cleaned up
+      expect(() => {
+        subscriber([
+          {
+            key: `1`,
+            value: { id: 1, name: `Timeout Test` },
+            headers: { operation: `insert` },
+          },
+          { headers: { control: `up-to-date` } },
+        ])
+      }).not.toThrow()
+
+      vi.useRealTimers()
+    })
+
+    it(`should wait for up-to-date after custom match (commit semantics)`, async () => {
+      let matchFound = false
+      let persistenceCompleted = false
+
+      const onInsert = vi
+        .fn()
+        .mockImplementation(async ({ transaction, collection: col }) => {
+          const item = transaction.mutations[0].modified
+          await col.utils.awaitMatch((message: any) => {
+            if (
+              isChangeMessage(message) &&
+              message.headers.operation === `insert` &&
+              message.value.name === item.name
+            ) {
+              matchFound = true
+              return true
+            }
+            return false
+          }, 5000)
+        })
+
+      const config = {
+        id: `test-commit-semantics`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        startSync: true,
+        getKey: (item: Row) => item.id as number,
+        onInsert,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Start insert
+      const insertPromise = testCollection.insert({
+        id: 1,
+        name: `Commit Test`,
+      })
+
+      // Set up persistence completion tracking
+      insertPromise.isPersisted.promise.then(() => {
+        persistenceCompleted = true
+      })
+
+      // Give a moment for handler setup
+      await new Promise((resolve) => setTimeout(resolve, 50))
+
+      // Send matching message (should match but not complete persistence yet)
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Commit Test` },
+          headers: { operation: `insert` },
+        },
+      ])
+
+      // Give time for match to be processed
+      await new Promise((resolve) => setTimeout(resolve, 50))
+
+      // Verify match was found but persistence not yet completed
+      expect(matchFound).toBe(true)
+      expect(persistenceCompleted).toBe(false)
+
+      // Now send up-to-date (should complete persistence)
+      subscriber([{ headers: { control: `up-to-date` } }])
+
+      // Wait for persistence to complete
+      await insertPromise.isPersisted.promise
+
+      // Verify persistence completed after up-to-date
+      expect(persistenceCompleted).toBe(true)
+      expect(testCollection._state.syncedData.has(1)).toBe(true)
+    })
+
+    it(`should support custom timeout using setTimeout`, async () => {
+      vi.useFakeTimers()
+
+      const customTimeout = 500 // Custom short timeout
+
+      const onInsert = vi.fn().mockImplementation(async () => {
+        // Simple timeout approach
+        await new Promise((resolve) => setTimeout(resolve, customTimeout))
+      })
+
+      const config = {
+        id: `test-void-timeout`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        startSync: true,
+        getKey: (item: Row) => item.id as number,
+        onInsert,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Insert with custom void timeout
+      const tx = testCollection.insert({ id: 1, name: `Custom Timeout Test` })
+
+      // Use runOnlyPendingTimers to execute the timeout
+      await vi.runOnlyPendingTimersAsync()
+
+      await expect(tx.isPersisted.promise).resolves.toBeDefined()
+      expect(onInsert).toHaveBeenCalled()
 
       vi.useRealTimers()
     })
   })
 
-  // Tests for Electric stream lifecycle management
-  describe(`Electric stream lifecycle management`, () => {
-    let mockUnsubscribe: ReturnType<typeof vi.fn>
-    let mockAbortController: {
-      abort: ReturnType<typeof vi.fn>
-      signal: AbortSignal
-    }
-
-    beforeEach(() => {
-      // Clear all mocks before each lifecycle test
-      vi.clearAllMocks()
+  // Tests for Electric stream lifecycle management
+  describe(`Electric stream lifecycle management`, () => {
+    let mockUnsubscribe: ReturnType<typeof vi.fn>
+    let mockAbortController: {
+      abort: ReturnType<typeof vi.fn>
+      signal: AbortSignal
+    }
+
+    beforeEach(() => {
+      // Clear all mocks before each lifecycle test
+      vi.clearAllMocks()
+
+      // Reset mocks before each test
+      mockUnsubscribe = vi.fn()
+      mockAbortController = {
+        abort: vi.fn(),
+        signal: new AbortController().signal,
+      }
+
+      // Update the mock to return our mock unsubscribe function
+      mockSubscribe.mockImplementation((callback) => {
+        subscriber = callback
+        return mockUnsubscribe
+      })
+
+      // Mock AbortController
+      global.AbortController = vi
+        .fn()
+        .mockImplementation(() => mockAbortController)
+    })
+
+    it(`should call unsubscribe and abort when collection is cleaned up`, async () => {
+      const config = {
+        id: `cleanup-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Verify stream is set up
+      expect(mockSubscribe).toHaveBeenCalled()
+
+      // Cleanup the collection
+      await testCollection.cleanup()
+
+      // Verify that both unsubscribe and abort were called
+      expect(mockUnsubscribe).toHaveBeenCalledTimes(1)
+      expect(mockAbortController.abort).toHaveBeenCalledTimes(1)
+    })
+
+    it(`should properly cleanup Electric-specific resources`, async () => {
+      const config = {
+        id: `resource-cleanup-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Add some txids to track
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Test` },
+          headers: {
+            operation: `insert`,
+            txids: [100, 200],
+          },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // Verify txids are tracked
+      await expect(testCollection.utils.awaitTxId(100)).resolves.toBe(true)
+
+      // Cleanup collection
+      await testCollection.cleanup()
+
+      // Verify cleanup was called
+      expect(mockUnsubscribe).toHaveBeenCalled()
+      expect(mockAbortController.abort).toHaveBeenCalled()
+    })
+
+    it(`should handle multiple cleanup calls gracefully`, async () => {
+      const config = {
+        id: `multiple-cleanup-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Call cleanup multiple times
+      await testCollection.cleanup()
+      await testCollection.cleanup()
+      await testCollection.cleanup()
+
+      // Should only call unsubscribe once (from the first cleanup)
+      expect(mockUnsubscribe).toHaveBeenCalledTimes(1)
+      expect(mockAbortController.abort).toHaveBeenCalledTimes(1)
+    })
+
+    it(`should restart stream when collection is accessed after cleanup`, async () => {
+      const config = {
+        id: `restart-stream-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Initial stream setup
+      expect(mockSubscribe).toHaveBeenCalledTimes(1)
+
+      // Cleanup
+      await testCollection.cleanup()
+      expect(testCollection.status).toBe(`cleaned-up`)
+
+      // Access collection data to restart sync
+      const subscription = testCollection.subscribeChanges(() => {})
+
+      // Should have started a new stream
+      expect(mockSubscribe).toHaveBeenCalledTimes(2)
+      expect(testCollection.status).toBe(`loading`)
+
+      subscription.unsubscribe()
+    })
+
+    it(`should handle stream errors gracefully`, () => {
+      const config = {
+        id: `error-handling-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      // Mock stream to throw an error
+      mockSubscribe.mockImplementation(() => {
+        throw new Error(`Stream connection failed`)
+      })
+
+      expect(() => {
+        createCollection(electricCollectionOptions(config))
+      }).toThrow(`Stream connection failed`)
+    })
+
+    it(`should handle subscriber function errors without breaking`, () => {
+      const config = {
+        id: `subscriber-error-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Mock console.error to capture error logs
+      const consoleSpy = vi.spyOn(console, `error`).mockImplementation(() => {})
+
+      // Send messages with invalid data that might cause internal errors
+      // but shouldn't break the entire system
+      expect(() => {
+        subscriber([
+          {
+            key: `1`,
+            value: { id: 1, name: `Valid User` }, // Use valid data
+            headers: { operation: `insert` },
+          },
+        ])
+      }).not.toThrow()
+
+      // Should have processed the valid message without issues
+      expect(testCollection._state.syncedData.size).toBe(0) // Still pending until up-to-date
+
+      // Send up-to-date to commit
+      expect(() => {
+        subscriber([
+          {
+            headers: { control: `up-to-date` },
+          },
+        ])
+      }).not.toThrow()
+
+      // Now the data should be committed
+      expect(testCollection.has(1)).toBe(true)
+
+      consoleSpy.mockRestore()
+    })
+
+    it(`should properly handle concurrent stream operations`, async () => {
+      const config = {
+        id: `concurrent-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Simulate concurrent messages
+      const promises = [
+        new Promise<void>((resolve) => {
+          setTimeout(() => {
+            subscriber([
+              {
+                key: `1`,
+                value: { id: 1, name: `User 1` },
+                headers: { operation: `insert` },
+              },
+            ])
+            resolve()
+          }, 10)
+        }),
+        new Promise<void>((resolve) => {
+          setTimeout(() => {
+            subscriber([
+              {
+                key: `2`,
+                value: { id: 2, name: `User 2` },
+                headers: { operation: `insert` },
+              },
+            ])
+            resolve()
+          }, 20)
+        }),
+        new Promise<void>((resolve) => {
+          setTimeout(() => {
+            subscriber([
+              {
+                headers: { control: `up-to-date` },
+              },
+            ])
+            resolve()
+          }, 30)
+        }),
+      ]
+
+      await Promise.all(promises)
+
+      // Both items should be in the collection
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.has(2)).toBe(true)
+    })
+
+    it(`should handle schema information extraction from messages`, () => {
+      const config = {
+        id: `schema-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send message with schema information
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1` },
+          headers: {
+            operation: `insert`,
+            schema: `custom_schema`,
+          },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // Schema should be stored and used in sync metadata
+      // This is internal behavior, but we can verify it doesn't cause errors
+      expect(testCollection.has(1)).toBe(true)
+    })
+
+    it(`should handle invalid schema information gracefully`, () => {
+      const config = {
+        id: `invalid-schema-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send message with invalid schema information
+      expect(() => {
+        subscriber([
+          {
+            key: `1`,
+            value: { id: 1, name: `User 1` },
+            headers: {
+              operation: `insert`,
+              schema: 123 as any, // Invalid schema type
+            },
+          },
+          {
+            headers: { control: `up-to-date` },
+          },
+        ])
+      }).not.toThrow()
+
+      expect(testCollection.has(1)).toBe(true)
+    })
+
+    it(`should handle txids from control messages`, async () => {
+      const config = {
+        id: `control-txid-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send control message with txids (as numbers, per Electric API)
+      subscriber([
+        {
+          headers: {
+            control: `up-to-date`,
+            txids: [300, 400],
+          },
+        },
+      ])
+
+      // Txids should be tracked (converted to strings internally)
+      await expect(testCollection.utils.awaitTxId(300)).resolves.toBe(true)
+      await expect(testCollection.utils.awaitTxId(400)).resolves.toBe(true)
+    })
+
+    it(`should handle snapshot-end messages and match txids via snapshot metadata`, async () => {
+      const config = {
+        id: `snapshot-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send snapshot-end message with PostgresSnapshot metadata
+      // xmin=100, xmax=150, xip_list=[120, 130]
+      // Visible: txid < 100 (committed before snapshot) OR (100 <= txid < 150 AND txid NOT IN [120, 130])
+      // Not visible: txid >= 150 (not yet assigned) OR txid IN [120, 130] (in-progress)
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Test User` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: {
+            control: `snapshot-end`,
+            xmin: `100`,
+            xmax: `150`,
+            xip_list: [`120`, `130`],
+          },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // Txids that are visible in the snapshot should resolve
+      // Txids < xmin are committed and visible
+      await expect(testCollection.utils.awaitTxId(50)).resolves.toBe(true)
+      await expect(testCollection.utils.awaitTxId(99)).resolves.toBe(true)
+
+      // Txids in range [xmin, xmax) not in xip_list are visible
+      await expect(testCollection.utils.awaitTxId(100)).resolves.toBe(true)
+      await expect(testCollection.utils.awaitTxId(110)).resolves.toBe(true)
+      await expect(testCollection.utils.awaitTxId(121)).resolves.toBe(true)
+      await expect(testCollection.utils.awaitTxId(125)).resolves.toBe(true)
+      await expect(testCollection.utils.awaitTxId(131)).resolves.toBe(true)
+      await expect(testCollection.utils.awaitTxId(149)).resolves.toBe(true)
+
+      // Txids in xip_list (in-progress transactions) should NOT resolve
+      await expect(testCollection.utils.awaitTxId(120, 100)).rejects.toThrow(
+        `Timeout waiting for txId: 120`,
+      )
+      await expect(testCollection.utils.awaitTxId(130, 100)).rejects.toThrow(
+        `Timeout waiting for txId: 130`,
+      )
+
+      // Txids >= xmax should NOT resolve (not yet assigned)
+      await expect(testCollection.utils.awaitTxId(150, 100)).rejects.toThrow(
+        `Timeout waiting for txId: 150`,
+      )
+      await expect(testCollection.utils.awaitTxId(200, 100)).rejects.toThrow(
+        `Timeout waiting for txId: 200`,
+      )
+    })
+
+    it(`should await for txid that arrives later via snapshot-end`, async () => {
+      const config = {
+        id: `snapshot-await-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Start waiting for a txid before snapshot arrives
+      const txidToAwait = 105
+      const promise = testCollection.utils.awaitTxId(txidToAwait, 2000)
+
+      // Send snapshot-end message after a delay
+      setTimeout(() => {
+        subscriber([
+          {
+            headers: {
+              control: `snapshot-end`,
+              xmin: `100`,
+              xmax: `110`,
+              xip_list: [],
+            },
+          },
+          {
+            headers: { control: `up-to-date` },
+          },
+        ])
+      }, 50)
+
+      // The promise should resolve when the snapshot arrives
+      await expect(promise).resolves.toBe(true)
+    })
+
+    it(`should handle multiple snapshots and track all of them`, async () => {
+      const config = {
+        id: `multiple-snapshots-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send first snapshot: visible txids < 110
+      subscriber([
+        {
+          headers: {
+            control: `snapshot-end`,
+            xmin: `100`,
+            xmax: `110`,
+            xip_list: [],
+          },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // Send second snapshot: visible txids < 210
+      subscriber([
+        {
+          headers: {
+            control: `snapshot-end`,
+            xmin: `200`,
+            xmax: `210`,
+            xip_list: [],
+          },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // Txids visible in first snapshot
+      await expect(testCollection.utils.awaitTxId(105)).resolves.toBe(true)
+
+      // Txids visible in second snapshot
+      await expect(testCollection.utils.awaitTxId(205)).resolves.toBe(true)
+
+      // Txid 150 is visible in second snapshot (< xmin=200 means committed)
+      await expect(testCollection.utils.awaitTxId(150)).resolves.toBe(true)
+
+      // Txids >= second snapshot's xmax should timeout (not yet assigned)
+      await expect(testCollection.utils.awaitTxId(210, 100)).rejects.toThrow(
+        `Timeout waiting for txId: 210`,
+      )
+      await expect(testCollection.utils.awaitTxId(300, 100)).rejects.toThrow(
+        `Timeout waiting for txId: 300`,
+      )
+    })
+
+    it(`should prefer explicit txids over snapshot matching when both are available`, async () => {
+      const config = {
+        id: `explicit-txid-priority-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send message with explicit txid and snapshot
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Test User` },
+          headers: {
+            operation: `insert`,
+            txids: [500],
+          },
+        },
+        {
+          headers: {
+            control: `snapshot-end`,
+            xmin: `100`,
+            xmax: `110`,
+            xip_list: [],
+          },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // Explicit txid should resolve
+      await expect(testCollection.utils.awaitTxId(500)).resolves.toBe(true)
+
+      // Snapshot txid should also resolve
+      await expect(testCollection.utils.awaitTxId(105)).resolves.toBe(true)
+    })
+  })
+
+  // Tests for syncMode configuration
+  describe(`syncMode configuration`, () => {
+    it(`should not request snapshots during subscription in eager mode`, () => {
+      vi.clearAllMocks()
+
+      const config = {
+        id: `eager-no-snapshot-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        syncMode: `eager` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Subscribe and try to get more data
+      const subscription = testCollection.subscribeChanges(() => {})
+
+      // In eager mode, requestSnapshot should not be called
+      expect(mockRequestSnapshot).not.toHaveBeenCalled()
+
+      subscription.unsubscribe()
+    })
+
+    it(`should request incremental snapshots in on-demand mode when loadSubset is called`, async () => {
+      vi.clearAllMocks()
+
+      const config = {
+        id: `on-demand-snapshot-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        syncMode: `on-demand` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send up-to-date to mark collection as ready
+      subscriber([
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // In on-demand mode, calling loadSubset should request a snapshot
+      await testCollection._sync.loadSubset({ limit: 10 })
+
+      // Verify requestSnapshot was called
+      expect(mockRequestSnapshot).toHaveBeenCalledWith(
+        expect.objectContaining({
+          limit: 10,
+          params: {},
+        }),
+      )
+    })
+
+    it(`should fetch snapshots in progressive mode when loadSubset is called before sync completes`, async () => {
+      vi.clearAllMocks()
+
+      mockSubscribe.mockImplementation((_callback) => {
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      mockFetchSnapshot.mockResolvedValue({
+        metadata: {},
+        data: [
+          {
+            key: `2`,
+            value: { id: 2, name: `Snapshot User` },
+            headers: { operation: `insert` },
+          },
+        ],
+      })
+
+      const config = {
+        id: `progressive-snapshot-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        syncMode: `progressive` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      expect(testCollection.status).toBe(`loading`) // Not ready yet
+
+      // In progressive mode, calling loadSubset should fetch a snapshot BEFORE full sync completes
+      await testCollection._sync.loadSubset({ limit: 20 })
+
+      // Verify fetchSnapshot was called (not requestSnapshot)
+      expect(mockFetchSnapshot).toHaveBeenCalledWith(
+        expect.objectContaining({
+          limit: 20,
+          params: {},
+        }),
+      )
+      expect(mockRequestSnapshot).not.toHaveBeenCalled()
+
+      // Verify snapshot data was applied
+      expect(testCollection.has(2)).toBe(true)
+      expect(testCollection.get(2)).toEqual({ id: 2, name: `Snapshot User` })
+    })
+
+    it(`should not request snapshots when loadSubset is called in eager mode`, async () => {
+      vi.clearAllMocks()
+
+      const config = {
+        id: `eager-no-loadsubset-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        syncMode: `eager` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send up-to-date to mark collection as ready
+      subscriber([
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // In eager mode, loadSubset should do nothing
+      await testCollection._sync.loadSubset({ limit: 10 })
+
+      // Verify requestSnapshot was NOT called
+      expect(mockRequestSnapshot).not.toHaveBeenCalled()
+    })
+
+    it(`should handle progressive mode syncing in background`, async () => {
+      vi.clearAllMocks()
+
+      let testSubscriber!: (messages: Array<Message<Row>>) => void
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      mockFetchSnapshot.mockResolvedValue({
+        metadata: {},
+        data: [
+          {
+            key: `2`,
+            value: { id: 2, name: `Snapshot User` },
+            headers: { operation: `insert` },
+          },
+        ],
+      })
+
+      const config = {
+        id: `progressive-background-sync-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        syncMode: `progressive` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send stream data during snapshot phase (should be buffered)
+      testSubscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Initial User` },
+          headers: { operation: `insert` },
+        },
+      ])
+
+      // Collection should NOT have the buffered data yet
+      expect(testCollection.status).toBe(`loading`)
+      expect(testCollection.has(1)).toBe(false)
+
+      // Should be able to fetch snapshot data incrementally before full sync completes
+      await testCollection._sync.loadSubset({ limit: 10 })
+      expect(mockFetchSnapshot).toHaveBeenCalled()
+      expect(mockRequestSnapshot).not.toHaveBeenCalled()
+
+      // Snapshot data should be visible
+      expect(testCollection.has(2)).toBe(true)
+
+      // Now send up-to-date to complete the sync (triggers atomic swap)
+      testSubscriber([
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      expect(testCollection.status).toBe(`ready`)
+
+      // After atomic swap, buffered data should be visible, snapshot data cleared
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.has(2)).toBe(false) // Snapshot data truncated
+    })
+
+    it(`should stop fetching snapshots in progressive mode after first up-to-date and perform atomic swap`, async () => {
+      vi.clearAllMocks()
+
+      let testSubscriber!: (messages: Array<Message<Row>>) => void
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      mockFetchSnapshot.mockResolvedValue({
+        metadata: {},
+        data: [
+          {
+            key: `2`,
+            value: { id: 2, name: `Snapshot User` },
+            headers: { operation: `insert` },
+          },
+        ],
+      })
+
+      const config = {
+        id: `progressive-stop-after-sync-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        syncMode: `progressive` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      expect(testCollection.status).toBe(`loading`) // Not ready yet in progressive
+
+      // Should be able to fetch data before up-to-date (snapshot phase)
+      vi.clearAllMocks()
+      await testCollection._sync.loadSubset({ limit: 10 })
+      expect(mockFetchSnapshot).toHaveBeenCalledTimes(1)
+      expect(testCollection.has(2)).toBe(true) // Snapshot data applied
+
+      // Send change messages during snapshot phase (should be buffered)
+      testSubscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1` },
+          headers: { operation: `insert` },
+        },
+      ])
+
+      // Data should NOT be visible yet (buffered)
+      expect(testCollection.has(1)).toBe(false)
+
+      // Now send up-to-date to complete the full sync and trigger atomic swap
+      testSubscriber([
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      expect(testCollection.status).toBe(`ready`)
+
+      // After atomic swap, buffered data should be visible
+      expect(testCollection.has(1)).toBe(true)
+      // Snapshot data should be cleared by truncate, so id:2 should be gone
+      expect(testCollection.has(2)).toBe(false)
+
+      // Try to fetch more data - should NOT make a request since full sync is complete
+      vi.clearAllMocks()
+      await testCollection._sync.loadSubset({ limit: 10 })
+      expect(mockFetchSnapshot).not.toHaveBeenCalled()
+    })
+
+    it(`should allow snapshots in on-demand mode even after up-to-date`, async () => {
+      vi.clearAllMocks()
+
+      const config = {
+        id: `on-demand-after-sync-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        syncMode: `on-demand` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send initial data with up-to-date
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      expect(testCollection.status).toBe(`ready`)
+
+      // Should STILL be able to request more data in on-demand mode
+      vi.clearAllMocks()
+      await testCollection._sync.loadSubset({ limit: 10 })
+      expect(mockRequestSnapshot).toHaveBeenCalled()
+    })
+
+    it(`should ignore snapshot data when fetchSnapshot completes after up-to-date in progressive mode`, async () => {
+      vi.clearAllMocks()
+
+      let testSubscriber!: (messages: Array<Message<Row>>) => void
+      let resolveFetchSnapshot!: (value: any) => void
+      const fetchSnapshotPromise = new Promise((resolve) => {
+        resolveFetchSnapshot = resolve as any
+      })
+
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      // Mock fetchSnapshot to return a promise we control
+      mockFetchSnapshot.mockReturnValue(fetchSnapshotPromise)
+
+      const config = {
+        id: `progressive-snapshot-race-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        syncMode: `progressive` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      expect(testCollection.status).toBe(`loading`)
+
+      // Start a loadSubset request (should call fetchSnapshot)
+      const loadSubsetPromise = testCollection._sync.loadSubset({ limit: 10 })
+
+      // Verify fetchSnapshot was called
+      expect(mockFetchSnapshot).toHaveBeenCalled()
+
+      // Before the snapshot completes, send up-to-date to complete the sync
+      testSubscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Buffered User` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // Sync should be complete now
+      expect(testCollection.status).toBe(`ready`)
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.size).toBe(1)
+
+      // Now resolve the fetchSnapshot with data
+      resolveFetchSnapshot({
+        metadata: {},
+        data: [
+          {
+            key: `2`,
+            value: { id: 2, name: `Late Snapshot User` },
+            headers: { operation: `insert` },
+          },
+        ],
+      })
+
+      // Wait for loadSubset to complete
+      await loadSubsetPromise
+
+      // The snapshot data should be IGNORED because sync already completed
+      expect(testCollection.has(2)).toBe(false)
+      expect(testCollection.size).toBe(1) // Still only the buffered user
+      expect(testCollection.get(1)).toEqual({ id: 1, name: `Buffered User` })
+    })
+
+    it(`should default offset to 'now' in on-demand mode when no offset provided`, async () => {
+      vi.clearAllMocks()
+
+      // Import ShapeStream to check constructor calls
+      const { ShapeStream } = await import(`@electric-sql/client`)
+
+      const config = {
+        id: `on-demand-offset-now-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+          // No offset provided
+        },
+        syncMode: `on-demand` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      createCollection(electricCollectionOptions(config))
+
+      // Check that ShapeStream was called with offset: 'now'
+      expect(ShapeStream).toHaveBeenCalledWith(
+        expect.objectContaining({
+          offset: `now`,
+        }),
+      )
+    })
+
+    it(`should use undefined offset in eager mode when no offset provided`, async () => {
+      vi.clearAllMocks()
+
+      const { ShapeStream } = await import(`@electric-sql/client`)
+
+      const config = {
+        id: `eager-offset-undefined-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+          // No offset provided
+        },
+        syncMode: `eager` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      createCollection(electricCollectionOptions(config))
+
+      // Check that ShapeStream was called with offset: undefined
+      expect(ShapeStream).toHaveBeenCalledWith(
+        expect.objectContaining({
+          offset: undefined,
+        }),
+      )
+    })
+
+    it(`should use undefined offset in progressive mode when no offset provided`, async () => {
+      vi.clearAllMocks()
+
+      const { ShapeStream } = await import(`@electric-sql/client`)
+
+      const config = {
+        id: `progressive-offset-undefined-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+          // No offset provided
+        },
+        syncMode: `progressive` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      createCollection(electricCollectionOptions(config))
+
+      // Check that ShapeStream was called with offset: undefined
+      expect(ShapeStream).toHaveBeenCalledWith(
+        expect.objectContaining({
+          offset: undefined,
+        }),
+      )
+    })
+
+    it(`should use explicit offset when provided regardless of syncMode`, async () => {
+      vi.clearAllMocks()
+
+      const { ShapeStream } = await import(`@electric-sql/client`)
+
+      const config = {
+        id: `explicit-offset-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+          offset: -1 as any, // Explicit offset
+        },
+        syncMode: `on-demand` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      createCollection(electricCollectionOptions(config))
+
+      // Check that ShapeStream was called with the explicit offset
+      expect(ShapeStream).toHaveBeenCalledWith(
+        expect.objectContaining({
+          offset: -1,
+        }),
+      )
+    })
+  })
+
+  // Tests for overlapping subset queries with duplicate keys
+  describe(`Overlapping subset queries with duplicate keys`, () => {
+    it(`should convert duplicate inserts to updates when overlapping subset queries return the same row with different values`, () => {
+      // This test reproduces the issue where:
+      // 1. Multiple subset queries return the same row (e.g., different WHERE clauses that both match the same record)
+      // 2. The server sends `insert` operations for each response
+      // 3. If the row's data changed between requests (e.g., timestamp field updated), this caused a DuplicateKeySyncError
 
-      // Reset mocks before each test
-      mockUnsubscribe = vi.fn()
-      mockAbortController = {
-        abort: vi.fn(),
-        signal: new AbortController().signal,
+      const config = {
+        id: `duplicate-insert-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: {
+            table: `test_table`,
+          },
+        },
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
       }
 
-      // Update the mock to return our mock unsubscribe function
-      mockSubscribe.mockImplementation((callback) => {
-        subscriber = callback
-        return mockUnsubscribe
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // First subset query returns a row
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1`, updated_at: `2024-01-01T00:00:00Z` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // Verify initial data is present
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.get(1)).toEqual({
+        id: 1,
+        name: `User 1`,
+        updated_at: `2024-01-01T00:00:00Z`,
       })
 
-      // Mock AbortController
-      global.AbortController = vi
-        .fn()
-        .mockImplementation(() => mockAbortController)
+      // Second subset query returns the SAME row but with a different timestamp
+      // This would throw DuplicateKeySyncError without the fix because:
+      // 1. The key already exists in syncedData
+      // 2. The value is different (timestamp changed)
+      // 3. Without the Electric adapter converting insert->update, sync.ts throws
+      expect(() => {
+        subscriber([
+          {
+            key: `1`,
+            value: {
+              id: 1,
+              name: `User 1`,
+              updated_at: `2024-01-01T00:00:01Z`,
+            }, // Different timestamp!
+            headers: { operation: `insert` },
+          },
+          {
+            headers: { control: `up-to-date` },
+          },
+        ])
+      }).not.toThrow()
+
+      // The row should be updated with the new value
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.get(1)).toEqual({
+        id: 1,
+        name: `User 1`,
+        updated_at: `2024-01-01T00:00:01Z`,
+      })
     })
 
-    it(`should call unsubscribe and abort when collection is cleaned up`, async () => {
+    it(`should handle multiple duplicate inserts across several batches`, () => {
       const config = {
-        id: `cleanup-test`,
+        id: `multiple-duplicate-inserts-test`,
         shapeOptions: {
           url: `http://test-url`,
           params: {
@@ -1046,20 +2932,79 @@ describe(`Electric Integration`, () => {
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Verify stream is set up
-      expect(mockSubscribe).toHaveBeenCalled()
+      // First batch - initial inserts
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1`, version: 1 },
+          headers: { operation: `insert` },
+        },
+        {
+          key: `2`,
+          value: { id: 2, name: `User 2`, version: 1 },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
 
-      // Cleanup the collection
-      await testCollection.cleanup()
+      expect(testCollection.size).toBe(2)
+      expect(testCollection.get(1)).toEqual({
+        id: 1,
+        name: `User 1`,
+        version: 1,
+      })
+      expect(testCollection.get(2)).toEqual({
+        id: 2,
+        name: `User 2`,
+        version: 1,
+      })
 
-      // Verify that both unsubscribe and abort were called
-      expect(mockUnsubscribe).toHaveBeenCalledTimes(1)
-      expect(mockAbortController.abort).toHaveBeenCalledTimes(1)
+      // Second batch - overlapping subset query returns same rows with different values
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1`, version: 2 }, // version changed
+          headers: { operation: `insert` },
+        },
+        {
+          key: `2`,
+          value: { id: 2, name: `User 2`, version: 2 }, // version changed
+          headers: { operation: `insert` },
+        },
+        {
+          key: `3`,
+          value: { id: 3, name: `User 3`, version: 1 }, // new row
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // All rows should be present with updated values
+      expect(testCollection.size).toBe(3)
+      expect(testCollection.get(1)).toEqual({
+        id: 1,
+        name: `User 1`,
+        version: 2,
+      })
+      expect(testCollection.get(2)).toEqual({
+        id: 2,
+        name: `User 2`,
+        version: 2,
+      })
+      expect(testCollection.get(3)).toEqual({
+        id: 3,
+        name: `User 3`,
+        version: 1,
+      })
     })
 
-    it(`should properly cleanup Electric-specific resources`, async () => {
+    it(`should reset synced keys tracking on must-refetch`, () => {
       const config = {
-        id: `resource-cleanup-test`,
+        id: `must-refetch-reset-test`,
         shapeOptions: {
           url: `http://test-url`,
           params: {
@@ -1072,35 +3017,50 @@ describe(`Electric Integration`, () => {
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Add some txids to track
+      // Initial sync
       subscriber([
         {
           key: `1`,
-          value: { id: 1, name: `Test` },
-          headers: {
-            operation: `insert`,
-            txids: [100, 200],
-          },
+          value: { id: 1, name: `User 1` },
+          headers: { operation: `insert` },
         },
         {
           headers: { control: `up-to-date` },
         },
       ])
 
-      // Verify txids are tracked
-      await expect(testCollection.utils.awaitTxId(100)).resolves.toBe(true)
+      expect(testCollection.has(1)).toBe(true)
 
-      // Cleanup collection
-      await testCollection.cleanup()
+      // Trigger must-refetch (clears collection and syncedKeys tracking)
+      subscriber([
+        {
+          headers: { control: `must-refetch` },
+        },
+      ])
 
-      // Verify cleanup was called
-      expect(mockUnsubscribe).toHaveBeenCalled()
-      expect(mockAbortController.abort).toHaveBeenCalled()
+      // After must-refetch, sending the same key as insert should work
+      // because syncedKeys tracking was cleared
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1 After Refetch` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.get(1)).toEqual({
+        id: 1,
+        name: `User 1 After Refetch`,
+      })
     })
 
-    it(`should handle multiple cleanup calls gracefully`, async () => {
+    it(`should handle delete followed by insert of the same key`, () => {
       const config = {
-        id: `multiple-cleanup-test`,
+        id: `delete-then-insert-test`,
         shapeOptions: {
           url: `http://test-url`,
           params: {
@@ -1113,19 +3073,53 @@ describe(`Electric Integration`, () => {
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Call cleanup multiple times
-      await testCollection.cleanup()
-      await testCollection.cleanup()
-      await testCollection.cleanup()
+      // Initial insert
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
 
-      // Should only call unsubscribe once (from the first cleanup)
-      expect(mockUnsubscribe).toHaveBeenCalledTimes(1)
-      expect(mockAbortController.abort).toHaveBeenCalledTimes(1)
+      expect(testCollection.has(1)).toBe(true)
+
+      // Delete the row
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1 },
+          headers: { operation: `delete` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      expect(testCollection.has(1)).toBe(false)
+
+      // Re-insert the same key - should work because delete cleared the syncedKeys tracking
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1 Recreated` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.get(1)).toEqual({ id: 1, name: `User 1 Recreated` })
     })
 
-    it(`should restart stream when collection is accessed after cleanup`, async () => {
+    it(`should handle duplicate inserts within the same batch`, () => {
       const config = {
-        id: `restart-stream-test`,
+        id: `same-batch-duplicate-test`,
         shapeOptions: {
           url: `http://test-url`,
           params: {
@@ -1138,379 +3132,593 @@ describe(`Electric Integration`, () => {
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Initial stream setup
-      expect(mockSubscribe).toHaveBeenCalledTimes(1)
+      // Single batch with duplicate inserts for the same key
+      // This can happen when multiple subset responses are batched together
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1`, version: 1 },
+          headers: { operation: `insert` },
+        },
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1`, version: 2 }, // Same key, different value
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
 
-      // Cleanup
-      await testCollection.cleanup()
-      expect(testCollection.status).toBe(`cleaned-up`)
+      // Should have the latest value
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.get(1)).toEqual({
+        id: 1,
+        name: `User 1`,
+        version: 2,
+      })
+    })
+  })
 
-      // Access collection data to restart sync
-      const subscription = testCollection.subscribeChanges(() => {})
+  // Tests for commit and ready behavior with snapshot-end and up-to-date messages
+  describe(`Commit and ready behavior`, () => {
+    it(`should ignore snapshot-end before first up-to-date in progressive mode`, () => {
+      vi.clearAllMocks()
+
+      let testSubscriber!: (messages: Array<Message<Row>>) => void
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      mockFetchSnapshot.mockResolvedValue({ metadata: {}, data: [] })
+
+      const config = {
+        id: `progressive-ignore-snapshot-end-test`,
+        shapeOptions: {
+          url: `http://test-url`,
+          params: { table: `test_table` },
+        },
+        syncMode: `progressive` as const,
+        getKey: (item: Row) => item.id as number,
+        startSync: true,
+      }
+
+      const testCollection = createCollection(electricCollectionOptions(config))
+
+      // Send data followed by snapshot-end (but no up-to-date)
+      // In progressive mode, these messages should be BUFFERED, and snapshot-end
+      // should NOT trigger a commit because the snapshot-end in the log could be
+      // from a significant period before the stream is actually up to date
+      testSubscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Test User` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: {
+            control: `snapshot-end`,
+            xmin: `100`,
+            xmax: `110`,
+            xip_list: [],
+          },
+        },
+      ])
 
-      // Should have started a new stream
-      expect(mockSubscribe).toHaveBeenCalledTimes(2)
+      // Data should NOT be visible yet (snapshot-end should be ignored before up-to-date)
+      expect(testCollection.has(1)).toBe(false)
       expect(testCollection.status).toBe(`loading`)
 
-      subscription.unsubscribe()
+      // Now send up-to-date (triggers atomic swap)
+      testSubscriber([
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // Now data should be visible after atomic swap
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.get(1)).toEqual({ id: 1, name: `Test User` })
+      expect(testCollection.status).toBe(`ready`)
     })
 
-    it(`should handle stream errors gracefully`, () => {
+    it(`should commit on subset-end in eager mode`, () => {
       const config = {
-        id: `error-handling-test`,
+        id: `eager-subset-end-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `eager` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
-      // Mock stream to throw an error
-      mockSubscribe.mockImplementation(() => {
-        throw new Error(`Stream connection failed`)
-      })
+      const testCollection = createCollection(electricCollectionOptions(config))
 
-      expect(() => {
-        createCollection(electricCollectionOptions(config))
-      }).toThrow(`Stream connection failed`)
+      // Send data followed by subset-end (marks end of injected subset snapshot)
+      // subset-end should trigger a commit
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Test User` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `subset-end` },
+        },
+      ])
+
+      // Data should be committed and collection ready
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.get(1)).toEqual({ id: 1, name: `Test User` })
+      expect(testCollection.status).toBe(`ready`)
     })
 
-    it(`should handle subscriber function errors without breaking`, () => {
+    it(`should NOT commit on snapshot-end (only tracks metadata)`, () => {
       const config = {
-        id: `subscriber-error-test`,
+        id: `eager-snapshot-end-no-commit-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `eager` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Mock console.error to capture error logs
-      const consoleSpy = vi.spyOn(console, `error`).mockImplementation(() => {})
-
-      // Send messages with invalid data that might cause internal errors
-      // but shouldn't break the entire system
-      expect(() => {
-        subscriber([
-          {
-            key: `1`,
-            value: { id: 1, name: `Valid User` }, // Use valid data
-            headers: { operation: `insert` },
+      // Send data followed by snapshot-end
+      // snapshot-end should NOT trigger a commit - only up-to-date or subset-end do
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Test User` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: {
+            control: `snapshot-end`,
+            xmin: `100`,
+            xmax: `110`,
+            xip_list: [],
           },
-        ])
-      }).not.toThrow()
+        },
+      ])
 
-      // Should have processed the valid message without issues
-      expect(testCollection._state.syncedData.size).toBe(0) // Still pending until up-to-date
+      // Data should NOT be committed yet (snapshot-end doesn't trigger commit)
+      expect(testCollection.has(1)).toBe(false)
+      expect(testCollection.status).toBe(`loading`)
 
-      // Send up-to-date to commit
-      expect(() => {
-        subscriber([
-          {
-            headers: { control: `up-to-date` },
-          },
-        ])
-      }).not.toThrow()
+      // Now send up-to-date to commit
+      subscriber([
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
 
-      // Now the data should be committed
+      // Now data should be committed
       expect(testCollection.has(1)).toBe(true)
-
-      consoleSpy.mockRestore()
+      expect(testCollection.status).toBe(`ready`)
     })
 
-    it(`should properly handle concurrent stream operations`, async () => {
+    it(`should commit and mark ready on subset-end in on-demand mode`, () => {
       const config = {
-        id: `concurrent-test`,
+        id: `on-demand-subset-end-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `on-demand` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Simulate concurrent messages
-      const promises = [
-        new Promise<void>((resolve) => {
-          setTimeout(() => {
-            subscriber([
-              {
-                key: `1`,
-                value: { id: 1, name: `User 1` },
-                headers: { operation: `insert` },
-              },
-            ])
-            resolve()
-          }, 10)
-        }),
-        new Promise<void>((resolve) => {
-          setTimeout(() => {
-            subscriber([
-              {
-                key: `2`,
-                value: { id: 2, name: `User 2` },
-                headers: { operation: `insert` },
-              },
-            ])
-            resolve()
-          }, 20)
-        }),
-        new Promise<void>((resolve) => {
-          setTimeout(() => {
-            subscriber([
-              {
-                headers: { control: `up-to-date` },
-              },
-            ])
-            resolve()
-          }, 30)
-        }),
-      ]
-
-      await Promise.all(promises)
+      // Send data followed by subset-end (marks end of injected subset snapshot)
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `Test User` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `subset-end` },
+        },
+      ])
 
-      // Both items should be in the collection
+      // Data should be committed (available in state)
       expect(testCollection.has(1)).toBe(true)
-      expect(testCollection.has(2)).toBe(true)
+      expect(testCollection.get(1)).toEqual({ id: 1, name: `Test User` })
+
+      // Collection SHOULD be marked as ready in on-demand mode
+      expect(testCollection.status).toBe(`ready`)
     })
 
-    it(`should handle schema information extraction from messages`, () => {
+    it(`should buffer changes during snapshot phase in progressive mode until up-to-date`, () => {
+      vi.clearAllMocks()
+
+      let testSubscriber!: (messages: Array<Message<Row>>) => void
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      mockFetchSnapshot.mockResolvedValue({ metadata: {}, data: [] })
+
       const config = {
-        id: `schema-test`,
+        id: `progressive-snapshot-end-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `progressive` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Send message with schema information
-      subscriber([
+      // Send data followed by snapshot-end (but no up-to-date)
+      // In progressive mode, these messages should be BUFFERED, not committed
+      testSubscriber([
         {
           key: `1`,
-          value: { id: 1, name: `User 1` },
+          value: { id: 1, name: `Test User` },
+          headers: { operation: `insert` },
+        },
+        {
           headers: {
-            operation: `insert`,
-            schema: `custom_schema`,
+            control: `snapshot-end`,
+            xmin: `100`,
+            xmax: `110`,
+            xip_list: [],
           },
         },
+      ])
+
+      // Data should NOT be visible yet (it's buffered during snapshot phase)
+      expect(testCollection.has(1)).toBe(false)
+
+      // Collection should NOT be marked as ready yet in progressive mode
+      expect(testCollection.status).toBe(`loading`)
+
+      // Now send up-to-date (triggers atomic swap)
+      testSubscriber([
         {
           headers: { control: `up-to-date` },
         },
       ])
 
-      // Schema should be stored and used in sync metadata
-      // This is internal behavior, but we can verify it doesn't cause errors
+      // Now data should be visible after atomic swap
       expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.get(1)).toEqual({ id: 1, name: `Test User` })
+
+      // And it should be ready
+      expect(testCollection.status).toBe(`ready`)
     })
 
-    it(`should handle invalid schema information gracefully`, () => {
+    it(`should NOT commit multiple snapshot-end messages before up-to-date in eager mode`, () => {
       const config = {
-        id: `invalid-schema-test`,
+        id: `eager-multiple-snapshots-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `eager` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Send message with invalid schema information
-      expect(() => {
-        subscriber([
-          {
-            key: `1`,
-            value: { id: 1, name: `User 1` },
-            headers: {
-              operation: `insert`,
-              schema: 123 as any, // Invalid schema type
-            },
+      // First snapshot with data - snapshot-end should be ignored before up-to-date
+      subscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: {
+            control: `snapshot-end`,
+            xmin: `100`,
+            xmax: `110`,
+            xip_list: [],
           },
-          {
-            headers: { control: `up-to-date` },
+        },
+      ])
+
+      // First data should NOT be committed yet (snapshot-end ignored before up-to-date)
+      expect(testCollection.has(1)).toBe(false)
+      expect(testCollection.status).toBe(`loading`)
+
+      // Second snapshot with more data - still before up-to-date, so should be ignored
+      subscriber([
+        {
+          key: `2`,
+          value: { id: 2, name: `User 2` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: {
+            control: `snapshot-end`,
+            xmin: `110`,
+            xmax: `120`,
+            xip_list: [],
           },
-        ])
-      }).not.toThrow()
+        },
+      ])
+
+      // Second data should also NOT be committed yet
+      expect(testCollection.has(2)).toBe(false)
+      expect(testCollection.size).toBe(0)
+      expect(testCollection.status).toBe(`loading`)
+
+      // Finally send up-to-date - this commits all the pending data
+      subscriber([
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
 
+      // Now all data should be committed and collection ready
       expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.has(2)).toBe(true)
+      expect(testCollection.size).toBe(2)
+      expect(testCollection.status).toBe(`ready`)
     })
 
-    it(`should handle txids from control messages`, async () => {
+    it(`should handle up-to-date without snapshot-end (traditional behavior)`, () => {
       const config = {
-        id: `control-txid-test`,
+        id: `traditional-up-to-date-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `eager` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Send control message with txids (as numbers, per Electric API)
+      // Send data followed by up-to-date (no snapshot-end)
       subscriber([
         {
-          headers: {
-            control: `up-to-date`,
-            txids: [300, 400],
-          },
+          key: `1`,
+          value: { id: 1, name: `Test User` },
+          headers: { operation: `insert` },
+        },
+        {
+          headers: { control: `up-to-date` },
         },
       ])
 
-      // Txids should be tracked (converted to strings internally)
-      await expect(testCollection.utils.awaitTxId(300)).resolves.toBe(true)
-      await expect(testCollection.utils.awaitTxId(400)).resolves.toBe(true)
+      // Data should be committed and collection ready
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.status).toBe(`ready`)
     })
 
-    it(`should handle snapshot-end messages and match txids via snapshot metadata`, async () => {
+    it(`should handle must-refetch in progressive mode without orphan transactions`, () => {
+      vi.clearAllMocks()
+
+      let testSubscriber!: (messages: Array<Message<Row>>) => void
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      mockFetchSnapshot.mockResolvedValue({ metadata: {}, data: [] })
+
       const config = {
-        id: `snapshot-test`,
+        id: `progressive-must-refetch-orphan-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `progressive` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Send snapshot-end message with PostgresSnapshot metadata
-      // xmin=100, xmax=150, xip_list=[120, 130]
-      // Visible: txid < 100 (committed before snapshot) OR (100 <= txid < 150 AND txid NOT IN [120, 130])
-      // Not visible: txid >= 150 (not yet assigned) OR txid IN [120, 130] (in-progress)
-      subscriber([
+      // Phase 1: Complete the initial sync in progressive mode
+      testSubscriber([
         {
           key: `1`,
-          value: { id: 1, name: `Test User` },
+          value: { id: 1, name: `User 1` },
           headers: { operation: `insert` },
         },
         {
-          headers: {
-            control: `snapshot-end`,
-            xmin: `100`,
-            xmax: `150`,
-            xip_list: [`120`, `130`],
-          },
+          key: `2`,
+          value: { id: 2, name: `User 2` },
+          headers: { operation: `insert` },
         },
         {
           headers: { control: `up-to-date` },
         },
       ])
 
-      // Txids that are visible in the snapshot should resolve
-      // Txids < xmin are committed and visible
-      await expect(testCollection.utils.awaitTxId(50)).resolves.toBe(true)
-      await expect(testCollection.utils.awaitTxId(99)).resolves.toBe(true)
+      // After atomic swap, data should be visible
+      expect(testCollection.status).toBe(`ready`)
+      expect(testCollection.has(1)).toBe(true)
+      expect(testCollection.has(2)).toBe(true)
+      expect(testCollection.size).toBe(2)
 
-      // Txids in range [xmin, xmax) not in xip_list are visible
-      await expect(testCollection.utils.awaitTxId(100)).resolves.toBe(true)
-      await expect(testCollection.utils.awaitTxId(110)).resolves.toBe(true)
-      await expect(testCollection.utils.awaitTxId(121)).resolves.toBe(true)
-      await expect(testCollection.utils.awaitTxId(125)).resolves.toBe(true)
-      await expect(testCollection.utils.awaitTxId(131)).resolves.toBe(true)
-      await expect(testCollection.utils.awaitTxId(149)).resolves.toBe(true)
+      // No pending uncommitted synced transactions after initial sync
+      expect(testCollection._state.pendingSyncedTransactions.length).toBe(0)
 
-      // Txids in xip_list (in-progress transactions) should NOT resolve
-      await expect(testCollection.utils.awaitTxId(120, 100)).rejects.toThrow(
-        `Timeout waiting for txId: 120`
-      )
-      await expect(testCollection.utils.awaitTxId(130, 100)).rejects.toThrow(
-        `Timeout waiting for txId: 130`
-      )
+      // Phase 2: Receive must-refetch
+      // This resets hasReceivedUpToDate to false but starts a transaction
+      testSubscriber([
+        {
+          headers: { control: `must-refetch` },
+        },
+      ])
 
-      // Txids >= xmax should NOT resolve (not yet assigned)
-      await expect(testCollection.utils.awaitTxId(150, 100)).rejects.toThrow(
-        `Timeout waiting for txId: 150`
-      )
-      await expect(testCollection.utils.awaitTxId(200, 100)).rejects.toThrow(
-        `Timeout waiting for txId: 200`
-      )
+      // Old data should still be visible (transaction not committed yet)
+      expect(testCollection.status).toBe(`ready`)
+      expect(testCollection.size).toBe(2)
+
+      // There should be exactly 1 uncommitted pending transaction from must-refetch
+      expect(testCollection._state.pendingSyncedTransactions.length).toBe(1)
+      expect(
+        testCollection._state.pendingSyncedTransactions[0]?.committed,
+      ).toBe(false)
+
+      // Phase 3: Send new data after must-refetch (in separate batch)
+      // Without the fix, these would be buffered and cause orphan transaction
+      testSubscriber([
+        {
+          key: `3`,
+          value: { id: 3, name: `User 3` },
+          headers: { operation: `insert` },
+        },
+        {
+          key: `4`,
+          value: { id: 4, name: `User 4` },
+          headers: { operation: `insert` },
+        },
+      ])
+
+      // Data still not committed (no up-to-date yet)
+      expect(testCollection.size).toBe(2)
+
+      // Still 1 pending transaction (with the fix, data is written to it, not buffered)
+      expect(testCollection._state.pendingSyncedTransactions.length).toBe(1)
+
+      // Phase 4: Send up-to-date (in separate batch)
+      // Without the fix: atomic swap would try to start a new transaction,
+      // leaving the must-refetch transaction uncommitted (orphan)
+      // With the fix: normal commit happens on the existing transaction
+      testSubscriber([
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // After the fix: old data truncated, new data committed
+      expect(testCollection.status).toBe(`ready`)
+      expect(testCollection.has(1)).toBe(false) // Truncated by must-refetch
+      expect(testCollection.has(2)).toBe(false) // Truncated by must-refetch
+      expect(testCollection.has(3)).toBe(true) // New data after must-refetch
+      expect(testCollection.has(4)).toBe(true) // New data after must-refetch
+      expect(testCollection.size).toBe(2)
+
+      // CRITICAL: No orphan uncommitted transactions should remain
+      // Without the fix, there would be 1 uncommitted transaction from must-refetch
+      expect(testCollection._state.pendingSyncedTransactions.length).toBe(0)
+
+      // Verify data is correct (not undefined from orphan transaction)
+      expect(testCollection.get(3)).toEqual({ id: 3, name: `User 3` })
+      expect(testCollection.get(4)).toEqual({ id: 4, name: `User 4` })
     })
 
-    it(`should await for txid that arrives later via snapshot-end`, async () => {
+    it(`should handle must-refetch in progressive mode with txid tracking`, () => {
+      vi.clearAllMocks()
+
+      let testSubscriber!: (messages: Array<Message<Row>>) => void
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      mockFetchSnapshot.mockResolvedValue({ metadata: {}, data: [] })
+
       const config = {
-        id: `snapshot-await-test`,
+        id: `progressive-must-refetch-txid-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `progressive` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Start waiting for a txid before snapshot arrives
-      const txidToAwait = 105
-      const promise = testCollection.utils.awaitTxId(txidToAwait, 2000)
+      // Complete initial sync
+      testSubscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1` },
+          headers: { operation: `insert`, txids: [100] },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
 
-      // Send snapshot-end message after a delay
-      setTimeout(() => {
-        subscriber([
-          {
-            headers: {
-              control: `snapshot-end`,
-              xmin: `100`,
-              xmax: `110`,
-              xip_list: [],
-            },
-          },
-          {
-            headers: { control: `up-to-date` },
-          },
-        ])
-      }, 50)
+      expect(testCollection.status).toBe(`ready`)
 
-      // The promise should resolve when the snapshot arrives
-      await expect(promise).resolves.toBe(true)
+      // Must-refetch
+      testSubscriber([
+        {
+          headers: { control: `must-refetch` },
+        },
+      ])
+
+      // Send data with txids after must-refetch
+      // Without the fix, txids would not be tracked because isBufferingInitialSync() returns true
+      testSubscriber([
+        {
+          key: `2`,
+          value: { id: 2, name: `User 2` },
+          headers: { operation: `insert`, txids: [200] },
+        },
+        {
+          key: `3`,
+          value: { id: 3, name: `User 3` },
+          headers: { operation: `insert`, txids: [201] },
+        },
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      expect(testCollection.status).toBe(`ready`)
+      expect(testCollection.size).toBe(2)
+      expect(testCollection.has(2)).toBe(true)
+      expect(testCollection.has(3)).toBe(true)
     })
 
-    it(`should handle multiple snapshots and track all of them`, async () => {
+    it(`should handle must-refetch in progressive mode with snapshot-end metadata`, () => {
+      vi.clearAllMocks()
+
+      let testSubscriber!: (messages: Array<Message<Row>>) => void
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      mockFetchSnapshot.mockResolvedValue({ metadata: {}, data: [] })
+
       const config = {
-        id: `multiple-snapshots-test`,
+        id: `progressive-must-refetch-snapshot-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `progressive` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Send first snapshot: visible txids < 110
-      subscriber([
+      // Complete initial sync
+      testSubscriber([
+        {
+          key: `1`,
+          value: { id: 1, name: `User 1` },
+          headers: { operation: `insert` },
+        },
         {
           headers: {
             control: `snapshot-end`,
@@ -1524,8 +3732,23 @@ describe(`Electric Integration`, () => {
         },
       ])
 
-      // Send second snapshot: visible txids < 210
-      subscriber([
+      expect(testCollection.status).toBe(`ready`)
+
+      // Must-refetch
+      testSubscriber([
+        {
+          headers: { control: `must-refetch` },
+        },
+      ])
+
+      // Send data with snapshot-end after must-refetch
+      // Without the fix, snapshot-end metadata would not be tracked
+      testSubscriber([
+        {
+          key: `2`,
+          value: { id: 2, name: `User 2` },
+          headers: { operation: `insert` },
+        },
         {
           headers: {
             control: `snapshot-end`,
@@ -1539,69 +3762,105 @@ describe(`Electric Integration`, () => {
         },
       ])
 
-      // Txids visible in first snapshot
-      await expect(testCollection.utils.awaitTxId(105)).resolves.toBe(true)
-
-      // Txids visible in second snapshot
-      await expect(testCollection.utils.awaitTxId(205)).resolves.toBe(true)
+      expect(testCollection.status).toBe(`ready`)
+      expect(testCollection.size).toBe(1)
+      expect(testCollection.has(2)).toBe(true)
+      expect(testCollection.get(2)).toEqual({ id: 2, name: `User 2` })
+    })
 
-      // Txid 150 is visible in second snapshot (< xmin=200 means committed)
-      await expect(testCollection.utils.awaitTxId(150)).resolves.toBe(true)
+    it(`should handle multiple batches after must-refetch in progressive mode`, () => {
+      vi.clearAllMocks()
 
-      // Txids >= second snapshot's xmax should timeout (not yet assigned)
-      await expect(testCollection.utils.awaitTxId(210, 100)).rejects.toThrow(
-        `Timeout waiting for txId: 210`
-      )
-      await expect(testCollection.utils.awaitTxId(300, 100)).rejects.toThrow(
-        `Timeout waiting for txId: 300`
-      )
-    })
+      let testSubscriber!: (messages: Array<Message<Row>>) => void
+      mockSubscribe.mockImplementation((callback) => {
+        testSubscriber = callback
+        return () => {}
+      })
+      mockRequestSnapshot.mockResolvedValue(undefined)
+      mockFetchSnapshot.mockResolvedValue({ metadata: {}, data: [] })
 
-    it(`should prefer explicit txids over snapshot matching when both are available`, async () => {
       const config = {
-        id: `explicit-txid-priority-test`,
+        id: `progressive-must-refetch-batches-test`,
         shapeOptions: {
           url: `http://test-url`,
-          params: {
-            table: `test_table`,
-          },
+          params: { table: `test_table` },
         },
+        syncMode: `progressive` as const,
         getKey: (item: Row) => item.id as number,
         startSync: true,
       }
 
       const testCollection = createCollection(electricCollectionOptions(config))
 
-      // Send message with explicit txid and snapshot
-      subscriber([
+      // Complete initial sync
+      testSubscriber([
         {
           key: `1`,
-          value: { id: 1, name: `Test User` },
-          headers: {
-            operation: `insert`,
-            txids: [500],
-          },
+          value: { id: 1, name: `User 1` },
+          headers: { operation: `insert` },
         },
         {
-          headers: {
-            control: `snapshot-end`,
-            xmin: `100`,
-            xmax: `110`,
-            xip_list: [],
-          },
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      expect(testCollection.status).toBe(`ready`)
+
+      // Must-refetch
+      testSubscriber([
+        {
+          headers: { control: `must-refetch` },
         },
+      ])
+
+      // First batch of data after must-refetch
+      testSubscriber([
         {
-          headers: { control: `up-to-date` },
+          key: `2`,
+          value: { id: 2, name: `User 2` },
+          headers: { operation: `insert` },
         },
       ])
 
-      // Explicit txid should resolve
-      await expect(testCollection.utils.awaitTxId(500)).resolves.toBe(true)
+      // Second batch of data after must-refetch
+      testSubscriber([
+        {
+          key: `3`,
+          value: { id: 3, name: `User 3` },
+          headers: { operation: `insert` },
+        },
+      ])
 
-      // Snapshot txid should also resolve
-      await expect(testCollection.utils.awaitTxId(105)).resolves.toBe(true)
+      // Third batch of data after must-refetch
+      testSubscriber([
+        {
+          key: `4`,
+          value: { id: 4, name: `User 4` },
+          headers: { operation: `insert` },
+        },
+      ])
+
+      // Still waiting for up-to-date
+      expect(testCollection.size).toBe(1) // Only old data visible
+
+      // Final up-to-date
+      testSubscriber([
+        {
+          headers: { control: `up-to-date` },
+        },
+      ])
+
+      // All new data should be committed
+      expect(testCollection.status).toBe(`ready`)
+      expect(testCollection.has(1)).toBe(false) // Truncated
+      expect(testCollection.has(2)).toBe(true)
+      expect(testCollection.has(3)).toBe(true)
+      expect(testCollection.has(4)).toBe(true)
+      expect(testCollection.size).toBe(3)
     })
+  })
 
+  describe(`syncMode configuration - GC and resync`, () => {
     it(`should resync after garbage collection and new subscription`, () => {
       // Use fake timers for this test
       vi.useFakeTimers()
diff --git a/packages/electric-db-collection/tests/pg-serializer.property.test.ts b/packages/electric-db-collection/tests/pg-serializer.property.test.ts
new file mode 100644
index 000000000..45a9e79d0
--- /dev/null
+++ b/packages/electric-db-collection/tests/pg-serializer.property.test.ts
@@ -0,0 +1,229 @@
+import { describe, expect } from 'vitest'
+import { fc, test as fcTest } from '@fast-check/vitest'
+import { serialize } from '../src/pg-serializer'
+
+/**
+ * Property-based tests for pg-serializer
+ *
+ * Key properties:
+ * 1. Strings pass through unchanged
+ * 2. Numbers produce parseable numeric strings
+ * 3. Booleans serialize to 'true'/'false'
+ * 4. null and undefined both serialize to empty string
+ * 5. Dates produce valid ISO strings
+ * 6. Array escaping is consistent
+ */
+
+describe(`pg-serializer property-based tests`, () => {
+  describe(`string serialization`, () => {
+    fcTest.prop([fc.string()])(`strings pass through unchanged`, (str) => {
+      expect(serialize(str)).toBe(str)
+    })
+
+    fcTest.prop([fc.string()])(`strings are idempotent`, (str) => {
+      // serialize(serialize(str)) should equal serialize(str) for strings
+      const once = serialize(str)
+      const twice = serialize(once)
+      expect(twice).toBe(once)
+    })
+  })
+
+  describe(`number serialization`, () => {
+    fcTest.prop([fc.integer()])(
+      `integers round-trip through parseFloat`,
+      (n) => {
+        const serialized = serialize(n)
+        expect(parseFloat(serialized)).toBe(n)
+      },
+    )
+
+    fcTest.prop([
+      fc
+        .double({ noNaN: true, noDefaultInfinity: true })
+        .filter((n) => !Object.is(n, -0)),
+    ])(`finite doubles round-trip through parseFloat`, (n) => {
+      // Note: -0 is excluded because parseFloat("-0") returns 0
+      const serialized = serialize(n)
+      expect(parseFloat(serialized)).toBe(n)
+    })
+
+    fcTest.prop([fc.integer()])(`integers produce numeric strings`, (n) => {
+      const serialized = serialize(n)
+      expect(serialized).toMatch(/^-?\d+$/)
+    })
+  })
+
+  describe(`bigint serialization`, () => {
+    fcTest.prop([fc.bigInt()])(
+      `bigints round-trip through BigInt parsing`,
+      (n) => {
+        const serialized = serialize(n)
+        expect(BigInt(serialized)).toBe(n)
+      },
+    )
+
+    fcTest.prop([fc.bigInt()])(`bigints produce integer strings`, (n) => {
+      const serialized = serialize(n)
+      expect(serialized).toMatch(/^-?\d+$/)
+    })
+  })
+
+  describe(`boolean serialization`, () => {
+    fcTest.prop([fc.boolean()])(
+      `booleans serialize to 'true' or 'false'`,
+      (b) => {
+        const serialized = serialize(b)
+        expect(serialized).toBe(b ? `true` : `false`)
+      },
+    )
+
+    fcTest.prop([fc.boolean()])(
+      `booleans round-trip through string comparison`,
+      (b) => {
+        const serialized = serialize(b)
+        expect(serialized === `true`).toBe(b)
+      },
+    )
+  })
+
+  describe(`null/undefined serialization`, () => {
+    fcTest.prop([fc.constantFrom(null, undefined)])(
+      `null and undefined both serialize to empty string`,
+      (val) => {
+        expect(serialize(val)).toBe(``)
+      },
+    )
+  })
+
+  describe(`date serialization`, () => {
+    // Use bounded dates to avoid negative years which have different ISO format
+    const arbitraryBoundedDate = fc.date({
+      noInvalidDate: true,
+      min: new Date(`0000-01-01T00:00:00.000Z`),
+      max: new Date(`9999-12-31T23:59:59.999Z`),
+    })
+
+    fcTest.prop([arbitraryBoundedDate])(
+      `dates produce valid ISO strings`,
+      (date) => {
+        const serialized = serialize(date)
+        expect(serialized).toMatch(
+          /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
+        )
+      },
+    )
+
+    fcTest.prop([arbitraryBoundedDate])(
+      `dates round-trip through Date parsing`,
+      (date) => {
+        const serialized = serialize(date)
+        const parsed = new Date(serialized)
+        expect(parsed.getTime()).toBe(date.getTime())
+      },
+    )
+  })
+
+  describe(`array serialization`, () => {
+    fcTest.prop([fc.array(fc.integer(), { maxLength: 10 })])(
+      `integer arrays produce Postgres array format`,
+      (arr) => {
+        const serialized = serialize(arr)
+        expect(serialized).toMatch(/^\{.*\}$/)
+      },
+    )
+
+    fcTest.prop([fc.array(fc.integer(), { maxLength: 10 })])(
+      `integer arrays can be parsed back`,
+      (arr) => {
+        const serialized = serialize(arr)
+        // Remove braces and parse
+        const inner = serialized.slice(1, -1)
+        if (inner === ``) {
+          expect(arr).toEqual([])
+        } else {
+          const parsed = inner.split(`,`).map(Number)
+          expect(parsed).toEqual(arr)
+        }
+      },
+    )
+
+    fcTest.prop([fc.array(fc.boolean(), { maxLength: 10 })])(
+      `boolean arrays serialize correctly`,
+      (arr) => {
+        const serialized = serialize(arr)
+        expect(serialized).toMatch(/^\{.*\}$/)
+        // Each element should be 'true' or 'false'
+        const inner = serialized.slice(1, -1)
+        if (inner !== ``) {
+          const elements = inner.split(`,`)
+          elements.forEach((el) => {
+            expect([`true`, `false`]).toContain(el)
+          })
+        }
+      },
+    )
+
+    fcTest.prop([fc.array(fc.constantFrom(null, undefined), { maxLength: 5 })])(
+      `arrays with null/undefined serialize to NULL`,
+      (arr) => {
+        const serialized = serialize(arr)
+        const inner = serialized.slice(1, -1)
+        if (inner !== ``) {
+          const elements = inner.split(`,`)
+          elements.forEach((el) => {
+            expect(el).toBe(`NULL`)
+          })
+        }
+      },
+    )
+  })
+
+  describe(`string array escaping`, () => {
+    fcTest.prop([fc.array(fc.string(), { maxLength: 5 })])(
+      `string arrays are properly quoted`,
+      (arr) => {
+        const serialized = serialize(arr)
+        expect(serialized).toMatch(/^\{.*\}$/)
+        // Each string element should be quoted
+      },
+    )
+
+    fcTest.prop([
+      fc.string().filter((s) => s.includes(`"`) || s.includes(`\\`)),
+    ])(`strings with special chars are escaped`, (str) => {
+      const serialized = serialize([str])
+      // Should contain escaped quotes or backslashes
+      if (str.includes(`"`)) {
+        expect(serialized).toContain(`\\"`)
+      }
+      if (str.includes(`\\`)) {
+        expect(serialized).toContain(`\\\\`)
+      }
+    })
+  })
+
+  describe(`consistency properties`, () => {
+    fcTest.prop([
+      fc.oneof(
+        fc.string(),
+        fc.integer(),
+        fc.boolean(),
+        fc.constant(null),
+        fc.date({ noInvalidDate: true }),
+      ),
+    ])(`serialize is deterministic`, (val) => {
+      const first = serialize(val)
+      const second = serialize(val)
+      expect(first).toBe(second)
+    })
+
+    fcTest.prop([fc.array(fc.integer(), { maxLength: 10 })])(
+      `array serialization is deterministic`,
+      (arr) => {
+        const first = serialize(arr)
+        const second = serialize(arr)
+        expect(first).toBe(second)
+      },
+    )
+  })
+})
diff --git a/packages/electric-db-collection/tests/pg-serializer.test.ts b/packages/electric-db-collection/tests/pg-serializer.test.ts
new file mode 100644
index 000000000..266da1acf
--- /dev/null
+++ b/packages/electric-db-collection/tests/pg-serializer.test.ts
@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest'
+import { serialize } from '../src/pg-serializer'
+
+describe(`pg-serializer`, () => {
+  describe(`serialize`, () => {
+    it(`should serialize null as empty string`, () => {
+      expect(serialize(null)).toBe(``)
+    })
+
+    it(`should serialize undefined as empty string`, () => {
+      expect(serialize(undefined)).toBe(``)
+    })
+
+    it(`should serialize strings as-is`, () => {
+      expect(serialize(`hello`)).toBe(`hello`)
+      expect(serialize(``)).toBe(``)
+      expect(serialize(`with spaces`)).toBe(`with spaces`)
+    })
+
+    it(`should serialize numbers as strings`, () => {
+      expect(serialize(42)).toBe(`42`)
+      expect(serialize(0)).toBe(`0`)
+      expect(serialize(-123)).toBe(`-123`)
+      expect(serialize(3.14)).toBe(`3.14`)
+      expect(serialize(Infinity)).toBe(`Infinity`)
+      expect(serialize(-Infinity)).toBe(`-Infinity`)
+    })
+
+    it(`should serialize bigints as strings`, () => {
+      expect(serialize(BigInt(42))).toBe(`42`)
+      expect(serialize(BigInt(0))).toBe(`0`)
+      expect(serialize(BigInt(-123))).toBe(`-123`)
+      expect(serialize(BigInt(`9007199254740993`))).toBe(`9007199254740993`)
+      expect(serialize(BigInt(`-9007199254740993`))).toBe(`-9007199254740993`)
+    })
+
+    it(`should serialize booleans as lowercase strings`, () => {
+      expect(serialize(true)).toBe(`true`)
+      expect(serialize(false)).toBe(`false`)
+    })
+
+    it(`should serialize dates as ISO strings`, () => {
+      const date = new Date(`2024-01-15T10:30:45.000Z`)
+      expect(serialize(date)).toBe(`2024-01-15T10:30:45.000Z`)
+    })
+
+    describe(`arrays`, () => {
+      it(`should serialize empty arrays`, () => {
+        expect(serialize([])).toBe(`{}`)
+      })
+
+      it(`should serialize arrays of numbers`, () => {
+        expect(serialize([1, 2, 3])).toBe(`{1,2,3}`)
+      })
+
+      it(`should serialize arrays of bigints`, () => {
+        expect(serialize([BigInt(1), BigInt(2), BigInt(3)])).toBe(`{1,2,3}`)
+        expect(serialize([BigInt(`9007199254740993`)])).toBe(
+          `{9007199254740993}`,
+        )
+      })
+
+      it(`should serialize arrays of strings with proper escaping`, () => {
+        expect(serialize([`a`, `b`, `c`])).toBe(`{"a","b","c"}`)
+        expect(serialize([`hello world`])).toBe(`{"hello world"}`)
+      })
+
+      it(`should escape quotes and backslashes in string array elements`, () => {
+        expect(serialize([`with"quote`])).toBe(`{"with\\"quote"}`)
+        expect(serialize([`with\\backslash`])).toBe(`{"with\\\\backslash"}`)
+        expect(serialize([`both"and\\`])).toBe(`{"both\\"and\\\\"}`)
+      })
+
+      it(`should serialize arrays with null/undefined as NULL`, () => {
+        expect(serialize([1, null, 3])).toBe(`{1,NULL,3}`)
+        expect(serialize([`a`, undefined, `c`])).toBe(`{"a",NULL,"c"}`)
+      })
+
+      it(`should serialize arrays of booleans`, () => {
+        expect(serialize([true, false, true])).toBe(`{true,false,true}`)
+      })
+
+      it(`should serialize arrays of dates`, () => {
+        const date = new Date(`2024-01-15T10:30:45.000Z`)
+        expect(serialize([date])).toBe(`{2024-01-15T10:30:45.000Z}`)
+      })
+
+      it(`should serialize mixed type arrays`, () => {
+        expect(serialize([1, `two`, true, null])).toBe(`{1,"two",true,NULL}`)
+      })
+
+      it(`should serialize nested arrays`, () => {
+        expect(
+          serialize([
+            [1, 2],
+            [3, 4],
+          ]),
+        ).toBe(`{{1,2},{3,4}}`)
+      })
+    })
+
+    describe(`error handling`, () => {
+      it(`should throw for unsupported types`, () => {
+        expect(() => serialize({ key: `value` })).toThrow(
+          `Cannot serialize value:`,
+        )
+        expect(() => serialize(Symbol(`test`))).toThrow(
+          `Cannot serialize value:`,
+        )
+      })
+
+      it(`should handle error message for non-JSON-serializable values`, () => {
+        // This tests that the error message doesn't throw when trying to stringify
+        // values that JSON.stringify can't handle
+        const circularObj: any = {}
+        circularObj.self = circularObj
+
+        expect(() => serialize(circularObj)).toThrow(`Cannot serialize value:`)
+      })
+
+      it(`should throw for functions`, () => {
+        expect(() => serialize(() => {})).toThrow(`Cannot serialize value:`)
+      })
+    })
+  })
+})
diff --git a/packages/electric-db-collection/tests/sql-compiler.test.ts b/packages/electric-db-collection/tests/sql-compiler.test.ts
new file mode 100644
index 000000000..508449613
--- /dev/null
+++ b/packages/electric-db-collection/tests/sql-compiler.test.ts
@@ -0,0 +1,475 @@
+import { describe, expect, it } from 'vitest'
+import { compileSQL } from '../src/sql-compiler'
+import type { IR } from '@tanstack/db'
+
+// Helper to create a value expression
+function val<T>(value: T): IR.BasicExpression<T> {
+  return { type: `val`, value } as IR.BasicExpression<T>
+}
+
+// Helper to create a reference expression
+function ref(...path: Array<string>): IR.BasicExpression {
+  return { type: `ref`, path } as IR.BasicExpression
+}
+
+// Helper to create a function expression
+
+function func(name: string, args: Array<any>): IR.BasicExpression<boolean> {
+  return { type: `func`, name, args } as IR.BasicExpression<boolean>
+}
+
+describe(`sql-compiler`, () => {
+  describe(`compileSQL`, () => {
+    describe(`basic where clauses`, () => {
+      it(`should compile eq with string value`, () => {
+        const result = compileSQL({
+          where: func(`eq`, [ref(`name`), val(`John`)]),
+        })
+        expect(result.where).toBe(`"name" = $1`)
+        expect(result.params).toEqual({ '1': `John` })
+      })
+
+      it(`should compile eq with number value`, () => {
+        const result = compileSQL({
+          where: func(`eq`, [ref(`age`), val(25)]),
+        })
+        expect(result.where).toBe(`"age" = $1`)
+        expect(result.params).toEqual({ '1': `25` })
+      })
+
+      it(`should compile gt operator`, () => {
+        const result = compileSQL({
+          where: func(`gt`, [ref(`age`), val(18)]),
+        })
+        expect(result.where).toBe(`"age" > $1`)
+        expect(result.params).toEqual({ '1': `18` })
+      })
+
+      it(`should compile lt operator`, () => {
+        const result = compileSQL({
+          where: func(`lt`, [ref(`price`), val(100)]),
+        })
+        expect(result.where).toBe(`"price" < $1`)
+        expect(result.params).toEqual({ '1': `100` })
+      })
+
+      it(`should compile gte operator`, () => {
+        const result = compileSQL({
+          where: func(`gte`, [ref(`quantity`), val(10)]),
+        })
+        expect(result.where).toBe(`"quantity" >= $1`)
+        expect(result.params).toEqual({ '1': `10` })
+      })
+
+      it(`should compile lte operator`, () => {
+        const result = compileSQL({
+          where: func(`lte`, [ref(`rating`), val(5)]),
+        })
+        expect(result.where).toBe(`"rating" <= $1`)
+        expect(result.params).toEqual({ '1': `5` })
+      })
+
+      // Regression test for https://github.com/TanStack/db/issues/1147
+      it(`should compile eq with empty string value`, () => {
+        const result = compileSQL({
+          where: func(`eq`, [ref(`status`), val(``)]),
+        })
+        expect(result.where).toBe(`"status" = $1`)
+        expect(result.params).toEqual({ '1': `` })
+      })
+
+      it(`should compile eq with empty string in AND clause`, () => {
+        const result = compileSQL({
+          where: func(`and`, [
+            func(`eq`, [ref(`projectId`), val(`uuid-123`)]),
+            func(`eq`, [ref(`status`), val(``)]),
+          ]),
+        })
+        expect(result.where).toBe(`"projectId" = $1 AND "status" = $2`)
+        expect(result.params).toEqual({ '1': `uuid-123`, '2': `` })
+      })
+
+      it(`should handle multiple empty strings with correct param indices`, () => {
+        const result = compileSQL({
+          where: func(`and`, [
+            func(`eq`, [ref(`field1`), val(``)]),
+            func(`eq`, [ref(`field2`), val(``)]),
+          ]),
+        })
+        expect(result.where).toBe(`"field1" = $1 AND "field2" = $2`)
+        // Both empty strings should be present with correct indices
+        expect(result.params).toEqual({ '1': ``, '2': `` })
+      })
+
+      it(`should compile like with empty string pattern`, () => {
+        const result = compileSQL({
+          where: func(`like`, [ref(`description`), val(``)]),
+        })
+        expect(result.where).toBe(`"description" LIKE $1`)
+        expect(result.params).toEqual({ '1': `` })
+      })
+
+      it(`should compile ilike with empty string pattern`, () => {
+        const result = compileSQL({
+          where: func(`ilike`, [ref(`title`), val(``)]),
+        })
+        expect(result.where).toBe(`"title" ILIKE $1`)
+        expect(result.params).toEqual({ '1': `` })
+      })
+    })
+
+    describe(`compound where clauses`, () => {
+      it(`should compile AND with two conditions`, () => {
+        const result = compileSQL({
+          where: func(`and`, [
+            func(`eq`, [ref(`projectId`), val(`uuid-123`)]),
+            func(`gt`, [ref(`name`), val(`cursor-value`)]),
+          ]),
+        })
+        // Note: 2-arg AND doesn't add parentheses around the operands
+        expect(result.where).toBe(`"projectId" = $1 AND "name" > $2`)
+        expect(result.params).toEqual({ '1': `uuid-123`, '2': `cursor-value` })
+      })
+
+      it(`should compile AND with more than two conditions`, () => {
+        const result = compileSQL({
+          where: func(`and`, [
+            func(`eq`, [ref(`a`), val(`1`)]),
+            func(`eq`, [ref(`b`), val(`2`)]),
+            func(`eq`, [ref(`c`), val(`3`)]),
+          ]),
+        })
+        // >2 args adds parentheses
+        expect(result.where).toBe(`("a" = $1) AND ("b" = $2) AND ("c" = $3)`)
+        expect(result.params).toEqual({ '1': `1`, '2': `2`, '3': `3` })
+      })
+
+      it(`should compile OR with two conditions`, () => {
+        const result = compileSQL({
+          where: func(`or`, [
+            func(`eq`, [ref(`status`), val(`active`)]),
+            func(`eq`, [ref(`status`), val(`pending`)]),
+          ]),
+        })
+        expect(result.where).toBe(`"status" = $1 OR "status" = $2`)
+        expect(result.params).toEqual({ '1': `active`, '2': `pending` })
+      })
+    })
+
+    describe(`null/undefined value handling`, () => {
+      it(`should throw error for eq(col, null)`, () => {
+        // Users should use isNull() instead of eq(col, null)
+        expect(() =>
+          compileSQL({
+            where: func(`eq`, [ref(`deletedAt`), val(null)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'eq' operator`)
+      })
+
+      it(`should throw error for eq(col, undefined)`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`eq`, [ref(`deletedAt`), val(undefined)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'eq' operator`)
+      })
+
+      it(`should throw error for eq(null, col) (reversed order)`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`eq`, [val(null), ref(`name`)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'eq' operator`)
+      })
+
+      it(`should throw error for gt with null value`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`gt`, [ref(`age`), val(null)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'gt' operator`)
+      })
+
+      it(`should throw error for lt with undefined value`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`lt`, [ref(`age`), val(undefined)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'lt' operator`)
+      })
+
+      it(`should throw error for gte with null value`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`gte`, [ref(`price`), val(null)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'gte' operator`)
+      })
+
+      it(`should throw error for lte with null value`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`lte`, [ref(`rating`), val(null)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'lte' operator`)
+      })
+
+      it(`should throw error for like with null value`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`like`, [ref(`name`), val(null)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'like' operator`)
+      })
+
+      it(`should throw error for ilike with null value`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`ilike`, [ref(`name`), val(null)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'ilike' operator`)
+      })
+
+      it(`should throw error for eq(col, null) in AND clause`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`and`, [
+              func(`eq`, [ref(`projectId`), val(`uuid-123`)]),
+              func(`eq`, [ref(`deletedAt`), val(null)]),
+            ]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'eq' operator`)
+      })
+
+      it(`should throw error for eq(col, null) in mixed conditions`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`and`, [
+              func(`eq`, [ref(`status`), val(`active`)]),
+              func(`eq`, [ref(`archivedAt`), val(null)]),
+              func(`gt`, [ref(`createdAt`), val(`2024-01-01`)]),
+            ]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'eq' operator`)
+      })
+
+      it(`should not include params for null values in complex queries`, () => {
+        // This test simulates the bug scenario: a query with both valid params and null
+        // Before the fix, this would generate:
+        //   where: "projectId" = $1 AND "name" > $2
+        //   params: { "1": "uuid" } // missing $2!
+        // After the fix, gt(name, null) throws an error
+        expect(() =>
+          compileSQL({
+            where: func(`and`, [
+              func(`eq`, [ref(`projectId`), val(`uuid`)]),
+              func(`gt`, [ref(`name`), val(null)]),
+            ]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'gt' operator`)
+      })
+
+      it(`should throw error for eq(null, null)`, () => {
+        // Both args are null - this is nonsensical and would cause missing params
+        expect(() =>
+          compileSQL({
+            where: func(`eq`, [val(null), val(null)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'eq' operator`)
+      })
+
+      it(`should throw error for eq(null, literal)`, () => {
+        // Comparing null to a literal is nonsensical (always evaluates to UNKNOWN)
+        expect(() =>
+          compileSQL({
+            where: func(`eq`, [val(null), val(42)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'eq' operator`)
+      })
+
+      it(`should throw error for eq(col, null) - use isNull(col) instead`, () => {
+        // eq(col, null) should throw an error
+        // Users should use isNull(col) which works correctly
+        expect(() =>
+          compileSQL({
+            where: func(`eq`, [ref(`email`), val(null)]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'eq' operator`)
+
+        // isNull(col) should work correctly
+        const isNullResult = compileSQL({
+          where: func(`isNull`, [ref(`email`)]),
+        })
+        expect(isNullResult.where).toBe(`"email" IS NULL`)
+        expect(isNullResult.params).toEqual({})
+      })
+
+      it(`should throw error for eq(col, null) in OR clause`, () => {
+        expect(() =>
+          compileSQL({
+            where: func(`or`, [
+              func(`eq`, [ref(`deletedAt`), val(null)]),
+              func(`eq`, [ref(`status`), val(`active`)]),
+            ]),
+          }),
+        ).toThrow(`Cannot use null/undefined value with 'eq' operator`)
+      })
+    })
+
+    describe(`isNull/isUndefined operators`, () => {
+      it(`should compile isNull correctly`, () => {
+        const result = compileSQL({
+          where: func(`isNull`, [ref(`deletedAt`)]),
+        })
+        expect(result.where).toBe(`"deletedAt" IS NULL`)
+        expect(result.params).toEqual({})
+      })
+
+      it(`should compile isUndefined correctly`, () => {
+        const result = compileSQL({
+          where: func(`isUndefined`, [ref(`field`)]),
+        })
+        expect(result.where).toBe(`"field" IS NULL`)
+        expect(result.params).toEqual({})
+      })
+
+      it(`should compile NOT isNull correctly`, () => {
+        const result = compileSQL({
+          where: func(`not`, [func(`isNull`, [ref(`name`)])]),
+        })
+        expect(result.where).toBe(`"name" IS NOT NULL`)
+        expect(result.params).toEqual({})
+      })
+    })
+
+    describe(`empty where clause`, () => {
+      it(`should add true = true when no where clause`, () => {
+        const result = compileSQL({})
+        expect(result.where).toBe(`true = true`)
+        expect(result.params).toEqual({})
+      })
+    })
+
+    describe(`limit`, () => {
+      it(`should include limit in result`, () => {
+        const result = compileSQL({ limit: 10 })
+        expect(result.limit).toBe(10)
+      })
+    })
+
+    describe(`column name encoding (camelCase to snake_case)`, () => {
+      // Helper to simulate snakeCamelMapper's encode function
+      const camelToSnake = (str: string): string =>
+        str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+
+      it(`should encode column names in where clause when encoder is provided`, () => {
+        const result = compileSQL(
+          {
+            where: func(`eq`, [ref(`programTemplateId`), val(`uuid-123`)]),
+          },
+          { encodeColumnName: camelToSnake },
+        )
+        expect(result.where).toBe(`"program_template_id" = $1`)
+        expect(result.params).toEqual({ '1': `uuid-123` })
+      })
+
+      it(`should encode column names in compound where clauses`, () => {
+        const result = compileSQL(
+          {
+            where: func(`and`, [
+              func(`eq`, [ref(`programTemplateId`), val(`uuid-123`)]),
+              func(`gt`, [ref(`createdAt`), val(`2024-01-01`)]),
+            ]),
+          },
+          { encodeColumnName: camelToSnake },
+        )
+        expect(result.where).toBe(
+          `"program_template_id" = $1 AND "created_at" > $2`,
+        )
+        expect(result.params).toEqual({ '1': `uuid-123`, '2': `2024-01-01` })
+      })
+
+      it(`should encode column names in orderBy clause`, () => {
+        const result = compileSQL(
+          {
+            orderBy: [
+              {
+                expression: ref(`createdAt`),
+                compareOptions: { direction: `desc`, nulls: `last` },
+              },
+            ],
+          },
+          { encodeColumnName: camelToSnake },
+        )
+        expect(result.orderBy).toBe(`"created_at" DESC NULLS LAST`)
+      })
+
+      it(`should encode column names in isNull expressions`, () => {
+        const result = compileSQL(
+          {
+            where: func(`isNull`, [ref(`deletedAt`)]),
+          },
+          { encodeColumnName: camelToSnake },
+        )
+        expect(result.where).toBe(`"deleted_at" IS NULL`)
+      })
+
+      it(`should encode column names in NOT isNull expressions`, () => {
+        const result = compileSQL(
+          {
+            where: func(`not`, [func(`isNull`, [ref(`archivedAt`)])]),
+          },
+          { encodeColumnName: camelToSnake },
+        )
+        expect(result.where).toBe(`"archived_at" IS NOT NULL`)
+      })
+
+      it(`should not transform column names when no encoder is provided`, () => {
+        const result = compileSQL({
+          where: func(`eq`, [ref(`programTemplateId`), val(`uuid-123`)]),
+        })
+        // Without encoder, camelCase name is preserved
+        expect(result.where).toBe(`"programTemplateId" = $1`)
+      })
+
+      it(`should handle complex nested expressions with encoding`, () => {
+        const result = compileSQL(
+          {
+            where: func(`and`, [
+              func(`eq`, [ref(`userId`), val(`user-1`)]),
+              func(`or`, [
+                func(`eq`, [ref(`accountType`), val(`premium`)]),
+                func(`gte`, [ref(`totalSpend`), val(1000)]),
+              ]),
+            ]),
+          },
+          { encodeColumnName: camelToSnake },
+        )
+        expect(result.where).toBe(
+          `"user_id" = $1 AND "account_type" = $2 OR "total_spend" >= $3`,
+        )
+      })
+
+      it(`should encode column names in LIKE expressions`, () => {
+        const result = compileSQL(
+          {
+            where: func(`ilike`, [ref(`firstName`), val(`%john%`)]),
+          },
+          { encodeColumnName: camelToSnake },
+        )
+        expect(result.where).toBe(`"first_name" ILIKE $1`)
+      })
+
+      it(`should work with already snake_case names (identity transform)`, () => {
+        const result = compileSQL(
+          {
+            where: func(`eq`, [ref(`user_id`), val(`123`)]),
+          },
+          { encodeColumnName: camelToSnake },
+        )
+        // snake_case input remains snake_case
+        expect(result.where).toBe(`"user_id" = $1`)
+      })
+    })
+  })
+})
diff --git a/packages/electric-db-collection/tests/tags.test.ts b/packages/electric-db-collection/tests/tags.test.ts
new file mode 100644
index 000000000..01dfa2773
--- /dev/null
+++ b/packages/electric-db-collection/tests/tags.test.ts
@@ -0,0 +1,1241 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '@tanstack/db'
+import { electricCollectionOptions } from '../src/electric'
+import type { ElectricCollectionUtils } from '../src/electric'
+import type { Collection } from '@tanstack/db'
+import type { Message, Row } from '@electric-sql/client'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { MoveOutPattern } from '../src/tag-index'
+
+// Mock the ShapeStream module
+const mockSubscribe = vi.fn()
+const mockRequestSnapshot = vi.fn()
+const mockFetchSnapshot = vi.fn()
+const mockStream = {
+  subscribe: mockSubscribe,
+  requestSnapshot: mockRequestSnapshot,
+  fetchSnapshot: mockFetchSnapshot,
+}
+
+vi.mock(`@electric-sql/client`, async () => {
+  const actual = await vi.importActual(`@electric-sql/client`)
+  return {
+    ...actual,
+    ShapeStream: vi.fn(() => mockStream),
+  }
+})
+
+describe(`Electric Tag Tracking and GC`, () => {
+  let collection: Collection<
+    Row,
+    string | number,
+    ElectricCollectionUtils,
+    StandardSchemaV1<unknown, unknown>,
+    Row
+  >
+  let subscriber: (messages: Array<Message<Row>>) => void
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    // Reset mock subscriber
+    mockSubscribe.mockImplementation((callback) => {
+      subscriber = callback
+      return () => {}
+    })
+
+    // Reset mock requestSnapshot
+    mockRequestSnapshot.mockResolvedValue(undefined)
+
+    // Create collection with Electric configuration
+    const config = {
+      id: `test`,
+      shapeOptions: {
+        url: `http://test-url`,
+        params: {
+          table: `test_table`,
+        },
+      },
+      startSync: true,
+      getKey: (item: Row) => item.id as number,
+    }
+
+    // Get the options with utilities
+    const options = electricCollectionOptions(config)
+
+    // Create collection with Electric configuration
+    collection = createCollection(options) as unknown as Collection<
+      Row,
+      string | number,
+      ElectricCollectionUtils,
+      StandardSchemaV1<unknown, unknown>,
+      Row
+    >
+  })
+
+  it(`should track tags when rows are inserted with tags`, () => {
+    const tag1 = `hash1|hash2|hash3`
+    const tag2 = `hash4|hash5|hash6`
+
+    // Insert row with tags
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `insert`,
+          tags: [tag1, tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Test User` }]]),
+    )
+    expect(collection.status).toEqual(`ready`)
+
+    // Remove first tag - row should still exist
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `update`,
+          removed_tags: [tag1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Test User` }]]),
+    )
+
+    // Remove last tag - row should be garbage collected
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(new Map())
+  })
+
+  it(`should track tags when rows are updated with new tags`, () => {
+    const tag1 = `hash1|hash2|hash3`
+
+    // Insert row with tags
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `insert`,
+          tags: [tag1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Test User` }]]),
+    )
+
+    // Update with additional tags
+    const tag2 = `hash4|hash5|hash6`
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Updated User` },
+        headers: {
+          operation: `update`,
+          tags: [tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Updated User` }]]),
+    )
+
+    // Remove first tag - row should still exist
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Updated User` },
+        headers: {
+          operation: `update`,
+          removed_tags: [tag1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Updated User` }]]),
+    )
+
+    // Remove last tag - row should be garbage collected
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Updated User` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(new Map())
+  })
+
+  it(`should track tags that are structurally equal`, () => {
+    const tag1 = `hash1|hash2|hash3`
+    const tag1Copy = `hash1|hash2|hash3`
+
+    // Insert row with tags
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `insert`,
+          tags: [tag1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Test User` }]]),
+    )
+
+    // Remove first tag - row should be gone
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Updated User` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tag1Copy],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(new Map())
+  })
+
+  it(`should not interfere between rows with distinct tags`, () => {
+    const tag1 = `hash1|hash2|hash3`
+    const tag2 = `hash4|hash5|hash6`
+    const tag3 = `hash7|hash8|hash9`
+    const tag4 = `hash10|hash11|hash12`
+
+    // Insert multiple rows with some shared tags
+    // Row 1: tag1, tag2
+    // Row 2: tag2 (shared with row 1), tag3
+    // Row 3: tag3 (shared with row 2), tag4
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `insert`,
+          tags: [tag1, tag2],
+        },
+      },
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `insert`,
+          tags: [tag2, tag3],
+        },
+      },
+      {
+        key: `3`,
+        value: { id: 3, name: `User 3` },
+        headers: {
+          operation: `insert`,
+          tags: [tag3, tag4],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // All rows should exist
+    expect(collection.state.size).toBe(3)
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `User 1` })
+    expect(collection.state.get(2)).toEqual({ id: 2, name: `User 2` })
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Remove tag1 from row 1 - row 1 should still exist (has tag2), others unaffected
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `update`,
+          removed_tags: [tag1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row 1 should still exist (has tag2), rows 2 and 3 unaffected
+    expect(collection.state.size).toBe(3)
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `User 1` })
+    expect(collection.state.get(2)).toEqual({ id: 2, name: `User 2` })
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Remove tag2 from row 1 (shared tag) - row 1 should be deleted
+    // Row 2 should still exist because it has tag3 (tag2 removal only affects row 1)
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row 1 should be garbage collected, rows 2 and 3 should remain
+    // Row 2 still has tag2 and tag3, so removing tag2 from row 1 doesn't affect it
+    expect(collection.state.size).toBe(2)
+    expect(collection.state.has(1)).toBe(false)
+    expect(collection.state.get(2)).toEqual({ id: 2, name: `User 2` })
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Remove tag3 from row 2 - row 2 should still exist (has tag2)
+    // Row 3 should still exist because it has tag4 (tag3 removal only affects row 2)
+    subscriber([
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `update`,
+          removed_tags: [tag3],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row 2 should still exist (has tag3), row 3 unaffected
+    expect(collection.state.size).toBe(2)
+    expect(collection.state.has(1)).toBe(false)
+    expect(collection.state.get(2)).toEqual({ id: 2, name: `User 2` })
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Remove tag2 from row 2 (shared tag) - row 2 should be deleted
+    subscriber([
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row 2 should be garbage collected, row 3 should remain
+    // Row 3 still has tag3 and tag4
+    expect(collection.state.size).toBe(1)
+    expect(collection.state.has(1)).toBe(false)
+    expect(collection.state.has(2)).toBe(false)
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+  })
+
+  it(`should require exact match in removed_tags for tags with wildcards (underscore)`, () => {
+    const tagWithWildcard = `hash1|_|hash3`
+    const tagWithoutWildcard = `hash1|hash2|hash3`
+
+    // Insert row with wildcard tag
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `insert`,
+          tags: [tagWithWildcard],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `User 1` })
+
+    // Try to remove with non-matching tag (has specific value instead of wildcard)
+    // Should NOT remove because it doesn't match exactly
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `update`,
+          removed_tags: [tagWithoutWildcard],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should still exist because the tag didn't match exactly
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `User 1` })
+
+    // Remove with exact match (wildcard tag)
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tagWithWildcard],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should be garbage collected because exact match was removed
+    expect(collection.state.size).toBe(0)
+    expect(collection.state.has(1)).toBe(false)
+
+    // Insert row with specific value tag (no wildcard)
+    subscriber([
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `insert`,
+          tags: [tagWithoutWildcard],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state.get(2)).toEqual({ id: 2, name: `User 2` })
+
+    // Try to remove with wildcard tag - should NOT match
+    subscriber([
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `update`,
+          removed_tags: [tagWithWildcard],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should still exist because wildcard doesn't match specific value
+    expect(collection.state.get(2)).toEqual({ id: 2, name: `User 2` })
+
+    // Remove with exact match (specific value tag)
+    subscriber([
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tagWithoutWildcard],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should be garbage collected
+    expect(collection.state.size).toBe(0)
+    expect(collection.state.has(2)).toBe(false)
+
+    // Test with multiple tags including wildcards
+    const tagWildcard1 = `hash1|_|hash3`
+    const tagWildcard2 = `hash4|_|hash6`
+    const tagSpecific = `hash1|hash2|hash3`
+
+    subscriber([
+      {
+        key: `3`,
+        value: { id: 3, name: `User 3` },
+        headers: {
+          operation: `insert`,
+          tags: [tagWildcard1, tagWildcard2, tagSpecific],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Remove one wildcard tag with exact match
+    subscriber([
+      {
+        key: `3`,
+        value: { id: 3, name: `User 3` },
+        headers: {
+          operation: `update`,
+          removed_tags: [tagWildcard1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should still exist (has tagWildcard2 and tagSpecific)
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Try to remove wildcard tag with non-matching specific value
+    subscriber([
+      {
+        key: `3`,
+        value: { id: 3, name: `User 3` },
+        headers: {
+          operation: `update`,
+          removed_tags: [tagWithoutWildcard],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should still exist because tagWithoutWildcard doesn't match tagWildcard2
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Remove specific tag with exact match
+    subscriber([
+      {
+        key: `3`,
+        value: { id: 3, name: `User 3` },
+        headers: {
+          operation: `update`,
+          removed_tags: [tagSpecific],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should still exist (has tagWildcard2)
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Remove last wildcard tag with exact match
+    subscriber([
+      {
+        key: `3`,
+        value: { id: 3, name: `User 3` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tagWildcard2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should be garbage collected
+    expect(collection.state.size).toBe(0)
+    expect(collection.state.has(3)).toBe(false)
+  })
+
+  it(`should handle move-out events that remove matching tags`, () => {
+    const tag1 = `hash1|hash2|hash3`
+    const tag2 = `hash1|hash2|hash4`
+    const tag3 = `hash5|hash6|hash1`
+
+    // Insert rows with tags
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `insert`,
+          tags: [tag1],
+        },
+      },
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `insert`,
+          tags: [tag2],
+        },
+      },
+      {
+        key: `3`,
+        value: { id: 3, name: `User 3` },
+        headers: {
+          operation: `insert`,
+          tags: [tag3],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state.size).toBe(3)
+
+    // Send move-out event with pattern matching hash1 at position 0
+    const pattern: MoveOutPattern = {
+      pos: 0,
+      value: `hash1`,
+    }
+
+    subscriber([
+      {
+        headers: {
+          event: `move-out`,
+          patterns: [pattern],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Rows 1 and 2 should be deleted (they have hash1 at position 0)
+    // Row 3 should remain (has hash5 at position 0)
+    expect(collection.state.size).toBe(1)
+    expect(collection.state.has(3)).toBe(true)
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+  })
+
+  it(`should remove shared tags from all rows when move-out pattern matches`, () => {
+    // Create tags where some are shared between rows
+    const sharedTag1 = `hash1|hash2|hash3` // Shared by rows 1 and 2
+    const sharedTag2 = `hash4|hash5|hash6` // Shared by rows 2 and 3
+    const uniqueTag1 = `hash7|hash8|hash9` // Only in row 1
+    const uniqueTag2 = `hash10|hash11|hash12` // Only in row 3
+
+    // Insert rows with multiple tags, some shared
+    // Row 1: sharedTag1, uniqueTag1
+    // Row 2: sharedTag1, sharedTag2
+    // Row 3: sharedTag2, uniqueTag2
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `insert`,
+          tags: [sharedTag1, uniqueTag1],
+        },
+      },
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `insert`,
+          tags: [sharedTag1, sharedTag2],
+        },
+      },
+      {
+        key: `3`,
+        value: { id: 3, name: `User 3` },
+        headers: {
+          operation: `insert`,
+          tags: [sharedTag2, uniqueTag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state.size).toBe(3)
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `User 1` })
+    expect(collection.state.get(2)).toEqual({ id: 2, name: `User 2` })
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Send move-out event matching sharedTag1 (hash1 at position 0)
+    // This should remove sharedTag1 from both row 1 and row 2
+    const pattern: MoveOutPattern = {
+      pos: 0,
+      value: `hash1`,
+    }
+
+    subscriber([
+      {
+        headers: {
+          event: `move-out`,
+          patterns: [pattern],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row 1 should be deleted (only had sharedTag1 and uniqueTag1, sharedTag1 removed, but uniqueTag1 should remain... wait)
+    // Actually, if sharedTag1 matches the pattern, it should be removed from row 1
+    // Row 1 has [sharedTag1, uniqueTag1], so after removing sharedTag1, it still has uniqueTag1
+    // Row 2 has [sharedTag1, sharedTag2], so after removing sharedTag1, it still has sharedTag2
+    // So both rows should still exist
+    expect(collection.state.size).toBe(3)
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `User 1` })
+    expect(collection.state.get(2)).toEqual({ id: 2, name: `User 2` })
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Send move-out event matching sharedTag2 (hash4 at position 0)
+    // This should remove sharedTag2 from both row 2 and row 3
+    const pattern2: MoveOutPattern = {
+      pos: 0,
+      value: `hash4`,
+    }
+
+    subscriber([
+      {
+        headers: {
+          event: `move-out`,
+          patterns: [pattern2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row 2 should be deleted (had sharedTag1 and sharedTag2, both removed)
+    // Row 3 should still exist (has uniqueTag2)
+    // Row 1 should still exist (has uniqueTag1)
+    expect(collection.state.size).toBe(2)
+    expect(collection.state.has(2)).toBe(false)
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `User 1` })
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+
+    // Send move-out event matching uniqueTag1 (hash7 at position 0)
+    // This should remove uniqueTag1 from row 1
+    const pattern3: MoveOutPattern = {
+      pos: 0,
+      value: `hash7`,
+    }
+
+    subscriber([
+      {
+        headers: {
+          event: `move-out`,
+          patterns: [pattern3],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row 1 should be deleted (no tags left)
+    // Row 3 should still exist (has uniqueTag2)
+    expect(collection.state.size).toBe(1)
+    expect(collection.state.has(1)).toBe(false)
+    expect(collection.state.has(2)).toBe(false)
+    expect(collection.state.get(3)).toEqual({ id: 3, name: `User 3` })
+  })
+
+  it(`should not remove tags with underscores when pattern matches non-indexed position`, () => {
+    // Tag with underscore at position 1: a|_|c
+    // This tag is NOT indexed at position 1 (because of underscore)
+    const tagWithUnderscore = `a|_|c`
+
+    // Insert row with tag containing underscore
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `insert`,
+          tags: [tagWithUnderscore],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state.size).toBe(1)
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `User 1` })
+
+    // Send move-out event with pattern matching position 1 (where underscore is)
+    // Since the tag is not indexed at position 1, it won't be found in the index
+    // and the tag should remain
+    const patternNonIndexed: MoveOutPattern = {
+      pos: 1,
+      value: `b`,
+    }
+
+    subscriber([
+      {
+        headers: {
+          event: `move-out`,
+          patterns: [patternNonIndexed],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should still exist because the tag wasn't found in the index
+    expect(collection.state.size).toBe(1)
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `User 1` })
+
+    // Send move-out event with pattern matching position 2 (where 'c' is)
+    // Position 2 is indexed (has value 'c'), so it will be found in the index
+    // The pattern matching position 2 with value 'c' matches the tag a|_|c, so the tag is removed
+    const patternIndexed: MoveOutPattern = {
+      pos: 2,
+      value: `c`,
+    }
+
+    subscriber([
+      {
+        headers: {
+          event: `move-out`,
+          patterns: [patternIndexed],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should be garbage collected because the tag was removed
+    // (tagset becomes empty)
+    expect(collection.state.size).toBe(0)
+    expect(collection.state.has(1)).toBe(false)
+  })
+
+  it(`should handle move-out events with multiple patterns`, () => {
+    const tag1 = `hash1|hash2|hash3`
+    const tag2 = `hash4|hash5|hash6`
+    const tag3 = `hash7|hash8|hash9`
+
+    // Insert rows with tags
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `User 1` },
+        headers: {
+          operation: `insert`,
+          tags: [tag1],
+        },
+      },
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `insert`,
+          tags: [tag2],
+        },
+      },
+      {
+        key: `3`,
+        value: { id: 3, name: `User 3` },
+        headers: {
+          operation: `insert`,
+          tags: [tag3],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state.size).toBe(3)
+
+    // Send move-out event with multiple patterns
+    const pattern1: MoveOutPattern = {
+      pos: 0,
+      value: `hash1`,
+    }
+    const pattern2: MoveOutPattern = {
+      pos: 0,
+      value: `hash4`,
+    }
+
+    subscriber([
+      {
+        headers: {
+          event: `move-out`,
+          patterns: [pattern1, pattern2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Rows 1 and 2 should be deleted, row 3 should remain
+    expect(collection.state.size).toBe(1)
+    expect(collection.state.has(3)).toBe(true)
+  })
+
+  it(`should clear tag state on must-refetch`, () => {
+    const tag1 = `hash1|hash2|hash3`
+    const tag2 = `hash4|hash5|hash6`
+
+    // Insert row with tag
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `insert`,
+          tags: [tag1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Test User` }]]),
+    )
+
+    // Send must-refetch
+    subscriber([
+      {
+        headers: { control: `must-refetch` },
+      },
+    ])
+
+    // The collection should still have old data because truncate is in pending
+    // transaction. This is the intended behavior of the collection, you should have
+    // the old data until the next up-to-date message.
+    expect(collection.state.size).toBe(1)
+    expect(collection.state.has(1)).toBe(true)
+    expect(collection.state.get(1)).toEqual({ id: 1, name: `Test User` })
+
+    // Send new data after must-refetch
+    subscriber([
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: { operation: `insert` },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Collection should now have the new data
+    expect(collection.state).toEqual(new Map([[2, { id: 2, name: `User 2` }]]))
+
+    // Re-insert with new tag
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `insert`,
+          tags: [tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([
+        [1, { id: 1, name: `Test User` }],
+        [2, { id: 2, name: `User 2` }],
+      ]),
+    )
+
+    // Remove tag2 and check that the row is gone
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should be garbage collected
+    expect(collection.state.size).toBe(1)
+    expect(collection.state.has(1)).toBe(false)
+    expect(collection.state.has(2)).toBe(true)
+    expect(collection.state.get(2)).toEqual({ id: 2, name: `User 2` })
+  })
+
+  it(`should handle rows with no tags (not deleted)`, () => {
+    // Insert row without tags
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `insert`,
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should exist even without tags
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Test User` }]]),
+    )
+
+    // Update the row without tags
+    subscriber([
+      {
+        key: `1`,
+        old_value: { id: 1, name: `Test User` },
+        value: { id: 1, name: `Updated Test User` },
+        headers: {
+          operation: `update`,
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should still exist
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Updated Test User` }]]),
+    )
+
+    // Insert a row with tags
+    const tag = `hash1|hash2|hash3`
+    subscriber([
+      {
+        key: `2`,
+        value: { id: 2, name: `User 2` },
+        headers: {
+          operation: `insert`,
+          tags: [tag],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should exist
+    expect(collection.state).toEqual(
+      new Map([
+        [1, { id: 1, name: `Updated Test User` }],
+        [2, { id: 2, name: `User 2` }],
+      ]),
+    )
+
+    // Move out that matches the tag
+    const pattern: MoveOutPattern = {
+      pos: 1,
+      value: `hash2`,
+    }
+
+    subscriber([
+      {
+        headers: { event: `move-out`, patterns: [pattern] },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // User 2 should be gine but user 1 should still exist because it was never tagged
+    expect(collection.state.size).toBe(1)
+    expect(collection.state.has(1)).toBe(true)
+    expect(collection.state.has(2)).toBe(false)
+    expect(collection.state.get(1)).toEqual({
+      id: 1,
+      name: `Updated Test User`,
+    })
+  })
+
+  it(`should handle adding and removing tags in same update`, () => {
+    const tag1 = `hash1|hash2|hash3`
+    const tag2 = `hash4|hash5|hash6`
+
+    // Insert row with tag1
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `insert`,
+          tags: [tag1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Test User` }]]),
+    )
+
+    // Update: remove tag1, add tag2
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Updated User` },
+        headers: {
+          operation: `update`,
+          tags: [tag2],
+          removed_tags: [tag1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should still exist (has tag2)
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Updated User` }]]),
+    )
+  })
+
+  it(`should not recover old tags when row is deleted and re-inserted`, () => {
+    const tag1 = `hash1|hash2|hash3`
+    const tag2 = `hash4|hash5|hash6`
+
+    // Insert row with tag1
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `insert`,
+          tags: [tag1],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Test User` }]]),
+    )
+
+    // Delete the row (without tags)
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Test User` },
+        headers: {
+          operation: `delete`,
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should be deleted
+    expect(collection.state.size).toBe(0)
+    expect(collection.state.has(1)).toBe(false)
+
+    // Insert the row again with a new tag (tag2)
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Re-inserted User` },
+        headers: {
+          operation: `insert`,
+          tags: [tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should exist with new tag
+    expect(collection.state).toEqual(
+      new Map([[1, { id: 1, name: `Re-inserted User` }]]),
+    )
+
+    // Update the row with removed_tags including its new tag (tag2)
+    // The row should NOT have the old tag1, only tag2
+    subscriber([
+      {
+        key: `1`,
+        value: { id: 1, name: `Re-inserted User` },
+        headers: {
+          operation: `delete`,
+          removed_tags: [tag2],
+        },
+      },
+      {
+        headers: { control: `up-to-date` },
+      },
+    ])
+
+    // Row should be gone because tag2 was removed and it doesn't have old tag1
+    expect(collection.state.size).toBe(0)
+    expect(collection.state.has(1)).toBe(false)
+  })
+})
diff --git a/packages/electric-db-collection/tsconfig.json b/packages/electric-db-collection/tsconfig.json
index 7e586bab3..8b2e086d3 100644
--- a/packages/electric-db-collection/tsconfig.json
+++ b/packages/electric-db-collection/tsconfig.json
@@ -12,9 +12,12 @@
     "forceConsistentCasingInFileNames": true,
     "jsx": "react",
     "paths": {
-      "@tanstack/store": ["../store/src"]
+      "@tanstack/store": ["../store/src"],
+      "@tanstack/db-ivm": ["../db-ivm/src"],
+      "@tanstack/db": ["../db/src"],
+      "@tanstack/db-collection-e2e": ["../db-collection-e2e/src"]
     }
   },
-  "include": ["src", "tests", "vite.config.ts"],
+  "include": ["src", "tests", "e2e", "vite.config.ts", "vitest.e2e.config.ts"],
   "exclude": ["node_modules", "dist"]
 }
diff --git a/packages/electric-db-collection/vite.config.ts b/packages/electric-db-collection/vite.config.ts
index c7968f28a..b8c7930f0 100644
--- a/packages/electric-db-collection/vite.config.ts
+++ b/packages/electric-db-collection/vite.config.ts
@@ -1,14 +1,18 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import packageJson from './package.json'
 
 const config = defineConfig({
   test: {
     name: packageJson.name,
-    dir: `./tests`,
+    include: [`tests/**/*.test.ts`],
+    exclude: [`e2e/**/*`],
     environment: `jsdom`,
     coverage: { enabled: true, provider: `istanbul`, include: [`src/**/*`] },
-    typecheck: { enabled: true },
+    typecheck: {
+      enabled: true,
+      include: [`tests/**/*.test.ts`, `tests/**/*.test-d.ts`],
+    },
   },
 })
 
@@ -17,5 +21,5 @@ export default mergeConfig(
   tanstackViteConfig({
     entry: `./src/index.ts`,
     srcDir: `./src`,
-  })
+  }),
 )
diff --git a/packages/electric-db-collection/vitest.e2e.config.ts b/packages/electric-db-collection/vitest.e2e.config.ts
new file mode 100644
index 000000000..903f46de5
--- /dev/null
+++ b/packages/electric-db-collection/vitest.e2e.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: [`e2e/**/*.e2e.test.ts`],
+    globalSetup: `../db-collection-e2e/support/global-setup.ts`,
+    fileParallelism: false, // Critical for shared database
+    testTimeout: 30000,
+    environment: `jsdom`,
+  },
+})
diff --git a/packages/offline-transactions/CHANGELOG.md b/packages/offline-transactions/CHANGELOG.md
new file mode 100644
index 000000000..c75b2f360
--- /dev/null
+++ b/packages/offline-transactions/CHANGELOG.md
@@ -0,0 +1,227 @@
+# @tanstack/offline-transactions
+
+## 1.0.14
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 1.0.13
+
+### Patch Changes
+
+- Fix optimistic state not being restored to collections on page refresh while offline. Pending transactions are now automatically rehydrated from storage and their optimistic mutations applied to the UI immediately on startup, providing a seamless offline experience. ([#1169](https://github.com/TanStack/db/pull/1169))
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 1.0.12
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 1.0.11
+
+### Patch Changes
+
+- Fix date field corruption after app restart. String values matching ISO date format were incorrectly converted to Date objects during deserialization, corrupting user data. Now only explicit Date markers are converted, preserving string values intact. ([#1127](https://github.com/TanStack/db/pull/1127))
+
+- Fix mutation.changes field being lost during offline transaction serialization. Previously, the changes field was not included in serialized mutations, causing it to be empty ({}) after app restart. This led to sync functions receiving incomplete data when using mutation.changes for partial updates. ([#1124](https://github.com/TanStack/db/pull/1124))
+
+- Introduce specialized OnlineDetector for React Native ([#1137](https://github.com/TanStack/db/pull/1137))
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 1.0.10
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 1.0.9
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 1.0.8
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 1.0.7
+
+### Patch Changes
+
+- Fix race condition that caused double replay of offline transactions on page load. The issue occurred when WebLocksLeader's async lock acquisition triggered the leadership callback after requestLeadership() had already returned, causing loadAndReplayTransactions() to be called twice. ([#1046](https://github.com/TanStack/db/pull/1046))
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 1.0.6
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 1.0.5
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 1.0.4
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 1.0.3
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 1.0.2
+
+### Patch Changes
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 1.0.1
+
+### Patch Changes
+
+- Use regular dependency for @tanstack/db instead of peerDependency to match the standard pattern used by other TanStack DB packages and prevent duplicate installations ([#952](https://github.com/TanStack/db/pull/952))
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 1.0.0
+
+### Patch Changes
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.1.3
+
+### Patch Changes
+
+- Fix dependency bundling issues by moving @tanstack/db to peerDependencies ([#766](https://github.com/TanStack/db/pull/766))
+
+  **What Changed:**
+
+  Moved `@tanstack/db` from regular dependencies to peerDependencies in:
+  - `@tanstack/offline-transactions`
+  - `@tanstack/query-db-collection`
+
+  Removed `@opentelemetry/api` dependency from `@tanstack/offline-transactions`.
+
+  **Why:**
+
+  These extension packages incorrectly declared `@tanstack/db` as both a regular dependency AND a peerDependency simultaneously. This caused lock files to develop conflicting versions, resulting in multiple instances of `@tanstack/db` being installed in consuming applications.
+
+  The fix removes `@tanstack/db` from regular dependencies and keeps it only as a peerDependency. This ensures only one version of `@tanstack/db` is installed in the dependency tree, preventing version conflicts.
+
+  For local development, `@tanstack/db` remains in devDependencies so the packages can be built and tested independently.
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.1.2
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.1.1
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.1.0
+
+### Minor Changes
+
+- Add offline-transactions package with robust offline-first capabilities ([#559](https://github.com/TanStack/db/pull/559))
+
+  New package `@tanstack/offline-transactions` provides a comprehensive offline-first transaction system with:
+
+  **Core Features:**
+  - Persistent outbox pattern for reliable transaction processing
+  - Leader election for multi-tab coordination (Web Locks API with BroadcastChannel fallback)
+  - Automatic storage capability detection with graceful degradation
+  - Retry logic with exponential backoff and jitter
+  - Sequential transaction processing (FIFO ordering)
+
+  **Storage:**
+  - Automatic fallback chain: IndexedDB → localStorage → online-only
+  - Detects and handles private mode, SecurityError, QuotaExceededError
+  - Custom storage adapter support
+  - Diagnostic callbacks for storage failures
+
+  **Developer Experience:**
+  - TypeScript-first with full type safety
+  - Comprehensive test suite (25 tests covering leader failover, storage failures, e2e scenarios)
+  - Works in all modern browsers and server-side rendering environments
+
+  **@tanstack/db improvements:**
+  - Enhanced duplicate instance detection (dev-only, iframe-aware, with escape hatch)
+  - Better environment detection for SSR and worker contexts
+
+  Example usage:
+
+  ```typescript
+  import {
+    startOfflineExecutor,
+    IndexedDBAdapter,
+  } from '@tanstack/offline-transactions'
+
+  const executor = startOfflineExecutor({
+    collections: { todos: todoCollection },
+    storage: new IndexedDBAdapter(),
+    mutationFns: {
+      syncTodos: async ({ transaction, idempotencyKey }) => {
+        // Sync mutations to backend
+        await api.sync(transaction.mutations, idempotencyKey)
+      },
+    },
+    onStorageFailure: (diagnostic) => {
+      console.warn('Running in online-only mode:', diagnostic.message)
+    },
+  })
+
+  // Create offline transaction
+  const tx = executor.createOfflineTransaction({
+    mutationFnName: 'syncTodos',
+    autoCommit: false,
+  })
+
+  tx.mutate(() => {
+    todoCollection.insert({ id: '1', text: 'Buy milk', completed: false })
+  })
+
+  await tx.commit() // Persists to outbox and syncs when online
+  ```
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
diff --git a/packages/offline-transactions/README.md b/packages/offline-transactions/README.md
new file mode 100644
index 000000000..351480258
--- /dev/null
+++ b/packages/offline-transactions/README.md
@@ -0,0 +1,259 @@
+# @tanstack/offline-transactions
+
+Offline-first transaction capabilities for TanStack DB that provides durable persistence of mutations with automatic retry when connectivity is restored.
+
+## Features
+
+- **Outbox Pattern**: Persist mutations before dispatch for zero data loss
+- **Automatic Retry**: Exponential backoff with jitter for failed transactions
+- **Multi-tab Coordination**: Leader election ensures safe storage access
+- **FIFO Sequential Processing**: Transactions execute one at a time in creation order
+- **Flexible Storage**: IndexedDB with localStorage fallback
+- **Type Safe**: Full TypeScript support with TanStack DB integration
+
+## Installation
+
+### Web
+
+```bash
+npm install @tanstack/offline-transactions
+```
+
+### React Native / Expo
+
+```bash
+npm install @tanstack/offline-transactions @react-native-community/netinfo
+```
+
+The React Native implementation requires the `@react-native-community/netinfo` peer dependency for network connectivity detection.
+
+## Platform Support
+
+This package provides platform-specific implementations for web and React Native environments:
+
+- **Web**: Uses browser APIs (`window.online/offline` events, `document.visibilitychange`)
+- **React Native**: Uses React Native primitives (`@react-native-community/netinfo` for network status, `AppState` for foreground/background detection)
+
+## Quick Start
+
+Using offline transactions on web and React Native/Expo is identical except for the import. Choose the appropriate import based on your target platform:
+
+**Web:**
+
+```typescript
+import { startOfflineExecutor } from '@tanstack/offline-transactions'
+```
+
+**React Native / Expo:**
+
+```typescript
+import { startOfflineExecutor } from '@tanstack/offline-transactions/react-native'
+```
+
+**Usage (same for both platforms):**
+
+```typescript
+// Setup offline executor
+const offline = startOfflineExecutor({
+  collections: { todos: todoCollection },
+  mutationFns: {
+    syncTodos: async ({ transaction, idempotencyKey }) => {
+      await api.saveBatch(transaction.mutations, { idempotencyKey })
+    },
+  },
+  onLeadershipChange: (isLeader) => {
+    if (!isLeader) {
+      console.warn('Running in online-only mode (another tab is the leader)')
+    }
+  },
+})
+
+// Create offline transactions
+const offlineTx = offline.createOfflineTransaction({
+  mutationFnName: 'syncTodos',
+  autoCommit: false,
+})
+
+offlineTx.mutate(() => {
+  todoCollection.insert({
+    id: crypto.randomUUID(),
+    text: 'Buy milk',
+    completed: false,
+  })
+})
+
+// Execute with automatic offline support
+await offlineTx.commit()
+```
+
+## Core Concepts
+
+### Outbox-First Persistence
+
+Mutations are persisted to a durable outbox before being applied, ensuring zero data loss during offline periods:
+
+1. Mutation is persisted to IndexedDB/localStorage
+2. Optimistic update is applied locally
+3. When online, mutation is sent to server
+4. On success, mutation is removed from outbox
+
+### Multi-tab Coordination
+
+Only one tab acts as the "leader" to safely manage the outbox:
+
+- **Leader tab**: Full offline support with outbox persistence
+- **Non-leader tabs**: Online-only mode for safety
+- **Leadership transfer**: Automatic failover when leader tab closes
+
+### FIFO Sequential Processing
+
+Transactions are processed one at a time in the order they were created:
+
+- **Sequential execution**: All transactions execute in FIFO order
+- **Dependency safety**: Avoids conflicts between transactions that may reference each other
+- **Predictable behavior**: Transactions complete in the exact order they were created
+
+## API Reference
+
+### startOfflineExecutor(config)
+
+Creates and starts an offline executor instance.
+
+```typescript
+interface OfflineConfig {
+  collections: Record<string, Collection>
+  mutationFns: Record<string, MutationFn>
+  storage?: StorageAdapter
+  maxConcurrency?: number
+  jitter?: boolean
+  beforeRetry?: (transactions: OfflineTransaction[]) => OfflineTransaction[]
+  onUnknownMutationFn?: (name: string, tx: OfflineTransaction) => void
+  onLeadershipChange?: (isLeader: boolean) => void
+}
+```
+
+### OfflineExecutor
+
+#### Properties
+
+- `isOfflineEnabled: boolean` - Whether this tab can persist offline transactions
+
+#### Methods
+
+- `createOfflineTransaction(options)` - Create a manual offline transaction
+- `waitForTransactionCompletion(id)` - Wait for a specific transaction to complete
+- `removeFromOutbox(id)` - Manually remove transaction from outbox
+- `peekOutbox()` - View all pending transactions
+- `notifyOnline()` - Manually trigger retry execution
+- `dispose()` - Clean up resources
+
+### Error Handling
+
+Use `NonRetriableError` for permanent failures:
+
+```typescript
+import { NonRetriableError } from '@tanstack/offline-transactions'
+
+const mutationFn = async ({ transaction }) => {
+  try {
+    await api.save(transaction.mutations)
+  } catch (error) {
+    if (error.status === 422) {
+      throw new NonRetriableError('Invalid data - will not retry')
+    }
+    throw error // Will retry with backoff
+  }
+}
+```
+
+## Advanced Usage
+
+### Custom Storage Adapter
+
+```typescript
+import {
+  IndexedDBAdapter,
+  LocalStorageAdapter,
+} from '@tanstack/offline-transactions'
+
+const executor = startOfflineExecutor({
+  // Use custom storage
+  storage: new IndexedDBAdapter('my-app', 'transactions'),
+  // ... other config
+})
+```
+
+### Custom Retry Policy
+
+```typescript
+const executor = startOfflineExecutor({
+  maxConcurrency: 5,
+  jitter: true,
+  beforeRetry: (transactions) => {
+    // Filter out old transactions
+    const cutoff = Date.now() - 24 * 60 * 60 * 1000 // 24 hours
+    return transactions.filter((tx) => tx.createdAt.getTime() > cutoff)
+  },
+  // ... other config
+})
+```
+
+### Manual Transaction Control
+
+```typescript
+const tx = executor.createOfflineTransaction({
+  mutationFnName: 'syncData',
+  autoCommit: false,
+})
+
+tx.mutate(() => {
+  collection.insert({ id: '1', text: 'Item 1' })
+  collection.insert({ id: '2', text: 'Item 2' })
+})
+
+// Commit when ready
+await tx.commit()
+```
+
+## Migration from TanStack DB
+
+This package uses explicit offline transactions to provide offline capabilities:
+
+```typescript
+// Before: Standard TanStack DB (online only)
+todoCollection.insert({ id: '1', text: 'Buy milk' })
+
+// After: Explicit offline transactions
+const offline = startOfflineExecutor({
+  collections: { todos: todoCollection },
+  mutationFns: {
+    syncTodos: async ({ transaction }) => {
+      await api.sync(transaction.mutations)
+    },
+  },
+})
+
+const tx = offline.createOfflineTransaction({ mutationFnName: 'syncTodos' })
+tx.mutate(() => todoCollection.insert({ id: '1', text: 'Buy milk' }))
+await tx.commit() // Works offline!
+```
+
+## Platform Support
+
+### Web Browsers
+
+- **IndexedDB**: Modern browsers (primary storage)
+- **localStorage**: Fallback for limited environments
+- **Web Locks API**: Chrome 69+, Firefox 96+ (preferred leader election)
+- **BroadcastChannel**: All modern browsers (fallback leader election)
+
+### React Native
+
+- **React Native**: 0.60+ (tested with latest versions)
+- **Expo**: SDK 40+ (tested with latest versions)
+- **Required peer dependency**: `@react-native-community/netinfo` for network connectivity detection
+- **Storage**: Uses AsyncStorage or custom storage adapters
+
+## License
+
+MIT
diff --git a/packages/offline-transactions/package.json b/packages/offline-transactions/package.json
new file mode 100644
index 000000000..a1471dff7
--- /dev/null
+++ b/packages/offline-transactions/package.json
@@ -0,0 +1,83 @@
+{
+  "name": "@tanstack/offline-transactions",
+  "version": "1.0.14",
+  "description": "Offline-first transaction capabilities for TanStack DB",
+  "author": "TanStack",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/db.git",
+    "directory": "packages/offline-transactions"
+  },
+  "keywords": [
+    "tanstack",
+    "database",
+    "offline",
+    "transactions",
+    "persistence",
+    "sync"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src"
+  },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./react-native": {
+      "import": {
+        "types": "./dist/esm/react-native/index.d.ts",
+        "default": "./dist/esm/react-native/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/react-native/index.d.cts",
+        "default": "./dist/cjs/react-native/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@tanstack/db": "workspace:*"
+  },
+  "peerDependencies": {
+    "@react-native-community/netinfo": ">=11.0.0",
+    "react-native": ">=0.70.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-community/netinfo": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@react-native-community/netinfo": "11.4.1",
+    "@types/node": "^24.6.2",
+    "eslint": "^9.39.2",
+    "react-native": "0.79.6",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  }
+}
diff --git a/packages/offline-transactions/src/OfflineExecutor.ts b/packages/offline-transactions/src/OfflineExecutor.ts
new file mode 100644
index 000000000..ccfb08c66
--- /dev/null
+++ b/packages/offline-transactions/src/OfflineExecutor.ts
@@ -0,0 +1,596 @@
+// Storage adapters
+import { createOptimisticAction, createTransaction } from '@tanstack/db'
+import { IndexedDBAdapter } from './storage/IndexedDBAdapter'
+import { LocalStorageAdapter } from './storage/LocalStorageAdapter'
+
+// Core components
+import { OutboxManager } from './outbox/OutboxManager'
+import { KeyScheduler } from './executor/KeyScheduler'
+import { TransactionExecutor } from './executor/TransactionExecutor'
+
+// Coordination
+import { WebLocksLeader } from './coordination/WebLocksLeader'
+import { BroadcastChannelLeader } from './coordination/BroadcastChannelLeader'
+
+// Connectivity
+import { WebOnlineDetector } from './connectivity/OnlineDetector'
+
+// API
+import { OfflineTransaction as OfflineTransactionAPI } from './api/OfflineTransaction'
+import { createOfflineAction } from './api/OfflineAction'
+
+// TanStack DB primitives
+
+// Replay
+import { withNestedSpan, withSpan } from './telemetry/tracer'
+import type {
+  CreateOfflineActionOptions,
+  CreateOfflineTransactionOptions,
+  LeaderElection,
+  OfflineConfig,
+  OfflineMode,
+  OfflineTransaction,
+  OnlineDetector,
+  StorageAdapter,
+  StorageDiagnostic,
+} from './types'
+import type { Transaction } from '@tanstack/db'
+
+export class OfflineExecutor {
+  private config: OfflineConfig
+
+  // @ts-expect-error - Set during async initialization in initialize()
+  private storage: StorageAdapter | null
+  private outbox: OutboxManager | null
+  private scheduler: KeyScheduler
+  private executor: TransactionExecutor | null
+  private leaderElection: LeaderElection | null
+  private onlineDetector: OnlineDetector
+  private isLeaderState = false
+  private unsubscribeOnline: (() => void) | null = null
+  private unsubscribeLeadership: (() => void) | null = null
+
+  // Public diagnostic properties
+  public readonly mode: OfflineMode
+  public readonly storageDiagnostic: StorageDiagnostic
+
+  // Track initialization completion
+  private initPromise: Promise<void>
+  private initResolve!: () => void
+  private initReject!: (error: Error) => void
+
+  // Coordination mechanism for blocking transactions
+  private pendingTransactionPromises: Map<
+    string,
+    {
+      promise: Promise<any>
+      resolve: (result: any) => void
+      reject: (error: Error) => void
+    }
+  > = new Map()
+
+  // Track restoration transactions for cleanup when offline transactions complete
+  private restorationTransactions: Map<string, Transaction> = new Map()
+
+  constructor(config: OfflineConfig) {
+    this.config = config
+    this.scheduler = new KeyScheduler()
+    this.onlineDetector = config.onlineDetector ?? new WebOnlineDetector()
+
+    // Initialize as pending - will be set by async initialization
+    this.storage = null
+    this.outbox = null
+    this.executor = null
+    this.leaderElection = null
+
+    // Temporary diagnostic - will be updated by async initialization
+    this.mode = `offline`
+    this.storageDiagnostic = {
+      code: `STORAGE_AVAILABLE`,
+      mode: `offline`,
+      message: `Initializing storage...`,
+    }
+
+    // Create initialization promise
+    this.initPromise = new Promise((resolve, reject) => {
+      this.initResolve = resolve
+      this.initReject = reject
+    })
+
+    this.initialize()
+  }
+
+  /**
+   * Probe storage availability and create appropriate adapter.
+   * Returns null if no storage is available (online-only mode).
+   */
+  private async createStorage(): Promise<{
+    storage: StorageAdapter | null
+    diagnostic: StorageDiagnostic
+  }> {
+    // If user provided custom storage, use it without probing
+    if (this.config.storage) {
+      return {
+        storage: this.config.storage,
+        diagnostic: {
+          code: `STORAGE_AVAILABLE`,
+          mode: `offline`,
+          message: `Using custom storage adapter`,
+        },
+      }
+    }
+
+    // Probe IndexedDB first
+    const idbProbe = await IndexedDBAdapter.probe()
+    if (idbProbe.available) {
+      return {
+        storage: new IndexedDBAdapter(),
+        diagnostic: {
+          code: `STORAGE_AVAILABLE`,
+          mode: `offline`,
+          message: `Using IndexedDB for offline storage`,
+        },
+      }
+    }
+
+    // IndexedDB failed, try localStorage
+    const lsProbe = LocalStorageAdapter.probe()
+    if (lsProbe.available) {
+      return {
+        storage: new LocalStorageAdapter(),
+        diagnostic: {
+          code: `INDEXEDDB_UNAVAILABLE`,
+          mode: `offline`,
+          message: `IndexedDB unavailable, using localStorage fallback`,
+          error: idbProbe.error,
+        },
+      }
+    }
+
+    // Both failed - determine the diagnostic code
+    const isSecurityError =
+      idbProbe.error?.name === `SecurityError` ||
+      lsProbe.error?.name === `SecurityError`
+    const isQuotaError =
+      idbProbe.error?.name === `QuotaExceededError` ||
+      lsProbe.error?.name === `QuotaExceededError`
+
+    let code: StorageDiagnostic[`code`]
+    let message: string
+
+    if (isSecurityError) {
+      code = `STORAGE_BLOCKED`
+      message = `Storage blocked (private mode or security restrictions). Running in online-only mode.`
+    } else if (isQuotaError) {
+      code = `QUOTA_EXCEEDED`
+      message = `Storage quota exceeded. Running in online-only mode.`
+    } else {
+      code = `UNKNOWN_ERROR`
+      message = `Storage unavailable due to unknown error. Running in online-only mode.`
+    }
+
+    return {
+      storage: null,
+      diagnostic: {
+        code,
+        mode: `online-only`,
+        message,
+        error: idbProbe.error || lsProbe.error,
+      },
+    }
+  }
+
+  private createLeaderElection(): LeaderElection {
+    if (this.config.leaderElection) {
+      return this.config.leaderElection
+    }
+
+    if (WebLocksLeader.isSupported()) {
+      return new WebLocksLeader()
+    } else if (BroadcastChannelLeader.isSupported()) {
+      return new BroadcastChannelLeader()
+    } else {
+      // Fallback: always be leader in environments without multi-tab support
+      return {
+        requestLeadership: () => Promise.resolve(true),
+        releaseLeadership: () => {},
+        isLeader: () => true,
+        onLeadershipChange: () => () => {},
+      }
+    }
+  }
+
+  private setupEventListeners(): void {
+    // Only set up leader election listeners if we have storage
+    if (this.leaderElection) {
+      this.unsubscribeLeadership = this.leaderElection.onLeadershipChange(
+        (isLeader) => {
+          this.isLeaderState = isLeader
+
+          if (this.config.onLeadershipChange) {
+            this.config.onLeadershipChange(isLeader)
+          }
+
+          if (isLeader) {
+            this.loadAndReplayTransactions()
+          }
+        },
+      )
+    }
+
+    this.unsubscribeOnline = this.onlineDetector.subscribe(() => {
+      if (this.isOfflineEnabled && this.executor) {
+        // Reset retry delays so transactions can execute immediately when back online
+        this.executor.resetRetryDelays()
+        this.executor.executeAll().catch((error) => {
+          console.warn(
+            `Failed to execute transactions on connectivity change:`,
+            error,
+          )
+        })
+      }
+    })
+  }
+
+  private async initialize(): Promise<void> {
+    return withSpan(`executor.initialize`, {}, async (span) => {
+      try {
+        // Probe storage and create adapter
+        const { storage, diagnostic } = await this.createStorage()
+
+        // Cast to writable to set readonly properties
+        ;(this as any).storage = storage
+        ;(this as any).storageDiagnostic = diagnostic
+        ;(this as any).mode = diagnostic.mode
+
+        span.setAttribute(`storage.mode`, diagnostic.mode)
+        span.setAttribute(`storage.code`, diagnostic.code)
+
+        if (!storage) {
+          // Online-only mode - notify callback and skip offline setup
+          if (this.config.onStorageFailure) {
+            this.config.onStorageFailure(diagnostic)
+          }
+          span.setAttribute(`result`, `online-only`)
+          this.initResolve()
+          return
+        }
+
+        // Storage available - set up offline components
+        this.outbox = new OutboxManager(storage, this.config.collections)
+        this.executor = new TransactionExecutor(
+          this.scheduler,
+          this.outbox,
+          this.config,
+          this,
+        )
+        this.leaderElection = this.createLeaderElection()
+
+        // Request leadership first
+        const isLeader = await this.leaderElection.requestLeadership()
+        this.isLeaderState = isLeader
+        span.setAttribute(`isLeader`, isLeader)
+
+        // Set up event listeners after leadership is established
+        // This prevents the callback from being called multiple times
+        this.setupEventListeners()
+
+        // Notify initial leadership state
+        if (this.config.onLeadershipChange) {
+          this.config.onLeadershipChange(isLeader)
+        }
+
+        if (isLeader) {
+          await this.loadAndReplayTransactions()
+        }
+        span.setAttribute(`result`, `offline-enabled`)
+        this.initResolve()
+      } catch (error) {
+        console.warn(`Failed to initialize offline executor:`, error)
+        span.setAttribute(`result`, `failed`)
+        this.initReject(
+          error instanceof Error ? error : new Error(String(error)),
+        )
+      }
+    })
+  }
+
+  private async loadAndReplayTransactions(): Promise<void> {
+    if (!this.executor) {
+      return
+    }
+
+    try {
+      // Load pending transactions and restore optimistic state
+      await this.executor.loadPendingTransactions()
+
+      // Start execution in the background - don't await to avoid blocking initialization
+      // The transactions will execute and complete asynchronously
+      this.executor.executeAll().catch((error) => {
+        console.warn(`Failed to execute transactions:`, error)
+      })
+    } catch (error) {
+      console.warn(`Failed to load and replay transactions:`, error)
+    }
+  }
+
+  get isOfflineEnabled(): boolean {
+    return this.mode === `offline` && this.isLeaderState
+  }
+
+  /**
+   * Wait for the executor to fully initialize.
+   * This ensures that pending transactions are loaded and optimistic state is restored.
+   */
+  async waitForInit(): Promise<void> {
+    return this.initPromise
+  }
+
+  createOfflineTransaction(
+    options: CreateOfflineTransactionOptions,
+  ): Transaction | OfflineTransactionAPI {
+    const mutationFn = this.config.mutationFns[options.mutationFnName]
+
+    if (!mutationFn) {
+      throw new Error(`Unknown mutation function: ${options.mutationFnName}`)
+    }
+
+    // Check leadership immediately and use the appropriate primitive
+    if (!this.isOfflineEnabled) {
+      // Non-leader: use createTransaction directly with the resolved mutation function
+      // We need to wrap it to add the idempotency key
+      return createTransaction({
+        autoCommit: options.autoCommit ?? true,
+        mutationFn: (params) =>
+          mutationFn({
+            ...params,
+            idempotencyKey: options.idempotencyKey || crypto.randomUUID(),
+          }),
+        metadata: options.metadata,
+      })
+    }
+
+    // Leader: use OfflineTransaction wrapper for offline persistence
+    return new OfflineTransactionAPI(
+      options,
+      mutationFn,
+      this.persistTransaction.bind(this),
+      this,
+    )
+  }
+
+  createOfflineAction<T>(options: CreateOfflineActionOptions<T>) {
+    const mutationFn = this.config.mutationFns[options.mutationFnName]
+
+    if (!mutationFn) {
+      throw new Error(`Unknown mutation function: ${options.mutationFnName}`)
+    }
+
+    // Return a wrapper that checks leadership status at call time
+    return (variables: T) => {
+      // Check leadership when action is called, not when it's created
+      if (!this.isOfflineEnabled) {
+        // Non-leader: use createOptimisticAction directly
+        const action = createOptimisticAction({
+          mutationFn: (vars, params) =>
+            mutationFn({
+              ...vars,
+              ...params,
+              idempotencyKey: crypto.randomUUID(),
+            }),
+          onMutate: options.onMutate,
+        })
+        return action(variables)
+      }
+
+      // Leader: use the offline action wrapper
+      const action = createOfflineAction(
+        options,
+        mutationFn,
+        this.persistTransaction.bind(this),
+        this,
+      )
+      return action(variables)
+    }
+  }
+
+  private async persistTransaction(
+    transaction: OfflineTransaction,
+  ): Promise<void> {
+    // Wait for initialization to complete
+    await this.initPromise
+
+    return withNestedSpan(
+      `executor.persistTransaction`,
+      {
+        'transaction.id': transaction.id,
+        'transaction.mutationFnName': transaction.mutationFnName,
+      },
+      async (span) => {
+        if (!this.isOfflineEnabled || !this.outbox || !this.executor) {
+          span.setAttribute(`result`, `skipped_not_leader`)
+          this.resolveTransaction(transaction.id, undefined)
+          return
+        }
+
+        try {
+          await this.outbox.add(transaction)
+          await this.executor.execute(transaction)
+          span.setAttribute(`result`, `persisted`)
+        } catch (error) {
+          console.error(
+            `Failed to persist offline transaction ${transaction.id}:`,
+            error,
+          )
+          span.setAttribute(`result`, `failed`)
+          throw error
+        }
+      },
+    )
+  }
+
+  // Method for OfflineTransaction to wait for completion
+  async waitForTransactionCompletion(transactionId: string): Promise<any> {
+    const existing = this.pendingTransactionPromises.get(transactionId)
+    if (existing) {
+      return existing.promise
+    }
+
+    const deferred: {
+      promise: Promise<any>
+      resolve: (result: any) => void
+      reject: (error: Error) => void
+    } = {} as any
+
+    deferred.promise = new Promise((resolve, reject) => {
+      deferred.resolve = resolve
+      deferred.reject = reject
+    })
+
+    this.pendingTransactionPromises.set(transactionId, deferred)
+    return deferred.promise
+  }
+
+  // Method for TransactionExecutor to signal completion
+  resolveTransaction(transactionId: string, result: any): void {
+    const deferred = this.pendingTransactionPromises.get(transactionId)
+    if (deferred) {
+      deferred.resolve(result)
+      this.pendingTransactionPromises.delete(transactionId)
+    }
+
+    // Clean up the restoration transaction - the sync will provide authoritative data
+    this.cleanupRestorationTransaction(transactionId)
+  }
+
+  // Method for TransactionExecutor to signal failure
+  rejectTransaction(transactionId: string, error: Error): void {
+    const deferred = this.pendingTransactionPromises.get(transactionId)
+    if (deferred) {
+      deferred.reject(error)
+      this.pendingTransactionPromises.delete(transactionId)
+    }
+
+    // Clean up the restoration transaction and rollback optimistic state
+    this.cleanupRestorationTransaction(transactionId, true)
+  }
+
+  // Method for TransactionExecutor to register restoration transactions
+  registerRestorationTransaction(
+    offlineTransactionId: string,
+    restorationTransaction: Transaction,
+  ): void {
+    this.restorationTransactions.set(
+      offlineTransactionId,
+      restorationTransaction,
+    )
+  }
+
+  private cleanupRestorationTransaction(
+    transactionId: string,
+    shouldRollback = false,
+  ): void {
+    const restorationTx = this.restorationTransactions.get(transactionId)
+    if (!restorationTx) {
+      return
+    }
+
+    this.restorationTransactions.delete(transactionId)
+
+    if (shouldRollback) {
+      restorationTx.rollback()
+      return
+    }
+
+    // Mark as completed so recomputeOptimisticState removes it from consideration.
+    // The actual data will come from the sync.
+    restorationTx.setState(`completed`)
+
+    // Remove from each collection's transaction map and recompute
+    const touchedCollections = new Set<string>()
+    for (const mutation of restorationTx.mutations) {
+      // Defensive check for corrupted deserialized data
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (!mutation.collection) {
+        continue
+      }
+      const collectionId = mutation.collection.id
+      if (touchedCollections.has(collectionId)) {
+        continue
+      }
+      touchedCollections.add(collectionId)
+      mutation.collection._state.transactions.delete(restorationTx.id)
+      mutation.collection._state.recomputeOptimisticState(false)
+    }
+  }
+
+  async removeFromOutbox(id: string): Promise<void> {
+    if (!this.outbox) {
+      return
+    }
+    await this.outbox.remove(id)
+  }
+
+  async peekOutbox(): Promise<Array<OfflineTransaction>> {
+    if (!this.outbox) {
+      return []
+    }
+    return this.outbox.getAll()
+  }
+
+  async clearOutbox(): Promise<void> {
+    if (!this.outbox || !this.executor) {
+      return
+    }
+    await this.outbox.clear()
+    this.executor.clear()
+  }
+
+  notifyOnline(): void {
+    this.onlineDetector.notifyOnline()
+  }
+
+  getPendingCount(): number {
+    if (!this.executor) {
+      return 0
+    }
+    return this.executor.getPendingCount()
+  }
+
+  getRunningCount(): number {
+    if (!this.executor) {
+      return 0
+    }
+    return this.executor.getRunningCount()
+  }
+
+  getOnlineDetector(): OnlineDetector {
+    return this.onlineDetector
+  }
+
+  dispose(): void {
+    if (this.unsubscribeOnline) {
+      this.unsubscribeOnline()
+      this.unsubscribeOnline = null
+    }
+
+    if (this.unsubscribeLeadership) {
+      this.unsubscribeLeadership()
+      this.unsubscribeLeadership = null
+    }
+
+    if (this.leaderElection) {
+      this.leaderElection.releaseLeadership()
+
+      if (`dispose` in this.leaderElection) {
+        ;(this.leaderElection as any).dispose()
+      }
+    }
+
+    this.onlineDetector.dispose()
+  }
+}
+
+export function startOfflineExecutor(config: OfflineConfig): OfflineExecutor {
+  return new OfflineExecutor(config)
+}
diff --git a/packages/offline-transactions/src/api/OfflineAction.ts b/packages/offline-transactions/src/api/OfflineAction.ts
new file mode 100644
index 000000000..3a2558a02
--- /dev/null
+++ b/packages/offline-transactions/src/api/OfflineAction.ts
@@ -0,0 +1,65 @@
+import { OnMutateMustBeSynchronousError } from '@tanstack/db'
+import { OfflineTransaction } from './OfflineTransaction'
+import type { Transaction } from '@tanstack/db'
+import type {
+  CreateOfflineActionOptions,
+  OfflineMutationFn,
+  OfflineTransaction as OfflineTransactionType,
+} from '../types'
+
+function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+  return (
+    !!value &&
+    (typeof value === `object` || typeof value === `function`) &&
+    typeof (value as { then?: unknown }).then === `function`
+  )
+}
+
+export function createOfflineAction<T>(
+  options: CreateOfflineActionOptions<T>,
+  mutationFn: OfflineMutationFn,
+  persistTransaction: (tx: OfflineTransactionType) => Promise<void>,
+  executor: any,
+): (variables: T) => Transaction {
+  const { mutationFnName, onMutate } = options
+  console.log(`createOfflineAction 2`, options)
+
+  return (variables: T): Transaction => {
+    const offlineTransaction = new OfflineTransaction(
+      {
+        mutationFnName,
+        autoCommit: false,
+      },
+      mutationFn,
+      persistTransaction,
+      executor,
+    )
+
+    const transaction = offlineTransaction.mutate(() => {
+      console.log(`mutate`)
+      const maybePromise = onMutate(variables) as unknown
+
+      if (isPromiseLike(maybePromise)) {
+        throw new OnMutateMustBeSynchronousError()
+      }
+    })
+
+    // Immediately commit
+    const commitPromise = (async () => {
+      try {
+        await transaction.commit()
+        console.log(`offlineAction committed - success`)
+      } catch {
+        console.log(`offlineAction commit failed - error`)
+      }
+    })()
+
+    // Don't await - this is fire-and-forget for optimistic actions
+    // But catch to prevent unhandled rejection
+    commitPromise.catch(() => {
+      // Already handled in try/catch above
+    })
+
+    return transaction
+  }
+}
diff --git a/packages/offline-transactions/src/api/OfflineTransaction.ts b/packages/offline-transactions/src/api/OfflineTransaction.ts
new file mode 100644
index 000000000..32c96fd26
--- /dev/null
+++ b/packages/offline-transactions/src/api/OfflineTransaction.ts
@@ -0,0 +1,123 @@
+import { createTransaction } from '@tanstack/db'
+import { NonRetriableError } from '../types'
+import type { PendingMutation, Transaction } from '@tanstack/db'
+import type {
+  CreateOfflineTransactionOptions,
+  OfflineMutationFn,
+  OfflineTransaction as OfflineTransactionType,
+} from '../types'
+
+export class OfflineTransaction {
+  private offlineId: string
+  private mutationFnName: string
+  private autoCommit: boolean
+  private idempotencyKey: string
+  private metadata: Record<string, any>
+  private transaction: Transaction | null = null
+  private persistTransaction: (tx: OfflineTransactionType) => Promise<void>
+  private executor: any // Will be typed properly - reference to OfflineExecutor
+
+  constructor(
+    options: CreateOfflineTransactionOptions,
+    mutationFn: OfflineMutationFn,
+    persistTransaction: (tx: OfflineTransactionType) => Promise<void>,
+    executor: any,
+  ) {
+    this.offlineId = crypto.randomUUID()
+    this.mutationFnName = options.mutationFnName
+    this.autoCommit = options.autoCommit ?? true
+    this.idempotencyKey = options.idempotencyKey ?? crypto.randomUUID()
+    this.metadata = options.metadata ?? {}
+    this.persistTransaction = persistTransaction
+    this.executor = executor
+  }
+
+  mutate(callback: () => void): Transaction {
+    this.transaction = createTransaction({
+      id: this.offlineId,
+      autoCommit: false,
+      mutationFn: async () => {
+        // This is the blocking mutationFn that waits for the executor
+        // First persist the transaction to the outbox
+        const offlineTransaction: OfflineTransactionType = {
+          id: this.offlineId,
+          mutationFnName: this.mutationFnName,
+          mutations: this.transaction!.mutations,
+          keys: this.extractKeys(this.transaction!.mutations),
+          idempotencyKey: this.idempotencyKey,
+          createdAt: new Date(),
+          retryCount: 0,
+          nextAttemptAt: Date.now(),
+          metadata: this.metadata,
+          spanContext: undefined,
+          version: 1,
+        }
+
+        const completionPromise = this.executor.waitForTransactionCompletion(
+          this.offlineId,
+        )
+
+        try {
+          await this.persistTransaction(offlineTransaction)
+          // Now block and wait for the executor to complete the real mutation
+          await completionPromise
+        } catch (error) {
+          const normalizedError =
+            error instanceof Error ? error : new Error(String(error))
+          this.executor.rejectTransaction(this.offlineId, normalizedError)
+          throw error
+        }
+
+        return
+      },
+      metadata: this.metadata,
+    })
+
+    this.transaction.mutate(() => {
+      callback()
+    })
+
+    if (this.autoCommit) {
+      // Auto-commit for direct OfflineTransaction usage
+      this.commit().catch((error) => {
+        console.error(`Auto-commit failed:`, error)
+        throw error
+      })
+    }
+
+    return this.transaction
+  }
+
+  async commit(): Promise<Transaction> {
+    if (!this.transaction) {
+      throw new Error(`No mutations to commit. Call mutate() first.`)
+    }
+
+    try {
+      // Commit the TanStack DB transaction
+      // This will trigger the mutationFn which handles persistence and waiting
+      await this.transaction.commit()
+      return this.transaction
+    } catch (error) {
+      // Only rollback for NonRetriableError - other errors should allow retry
+      if (error instanceof NonRetriableError) {
+        this.transaction.rollback()
+      }
+      throw error
+    }
+  }
+
+  rollback(): void {
+    if (this.transaction) {
+      this.transaction.rollback()
+    }
+  }
+
+  private extractKeys(mutations: Array<PendingMutation>): Array<string> {
+    return mutations.map((mutation) => mutation.globalKey)
+  }
+
+  get id(): string {
+    return this.offlineId
+  }
+}
diff --git a/packages/offline-transactions/src/connectivity/OnlineDetector.ts b/packages/offline-transactions/src/connectivity/OnlineDetector.ts
new file mode 100644
index 000000000..5f7a1600c
--- /dev/null
+++ b/packages/offline-transactions/src/connectivity/OnlineDetector.ts
@@ -0,0 +1,98 @@
+import type { OnlineDetector } from '../types'
+
+/**
+ * Web-based online detector that uses browser APIs.
+ * Listens for:
+ * - `window.online` event for network connectivity changes
+ * - `document.visibilitychange` event for tab/window focus changes
+ */
+export class WebOnlineDetector implements OnlineDetector {
+  private listeners: Set<() => void> = new Set()
+  private isListening = false
+
+  constructor() {
+    this.startListening()
+  }
+
+  private startListening(): void {
+    if (this.isListening) {
+      return
+    }
+
+    this.isListening = true
+
+    if (typeof window !== `undefined`) {
+      window.addEventListener(`online`, this.handleOnline)
+      document.addEventListener(`visibilitychange`, this.handleVisibilityChange)
+    }
+  }
+
+  private stopListening(): void {
+    if (!this.isListening) {
+      return
+    }
+
+    this.isListening = false
+
+    if (typeof window !== `undefined`) {
+      window.removeEventListener(`online`, this.handleOnline)
+      document.removeEventListener(
+        `visibilitychange`,
+        this.handleVisibilityChange,
+      )
+    }
+  }
+
+  private handleOnline = (): void => {
+    this.notifyListeners()
+  }
+
+  private handleVisibilityChange = (): void => {
+    if (document.visibilityState === `visible`) {
+      this.notifyListeners()
+    }
+  }
+
+  private notifyListeners(): void {
+    for (const listener of this.listeners) {
+      try {
+        listener()
+      } catch (error) {
+        console.warn(`OnlineDetector listener error:`, error)
+      }
+    }
+  }
+
+  subscribe(callback: () => void): () => void {
+    this.listeners.add(callback)
+
+    return () => {
+      this.listeners.delete(callback)
+
+      if (this.listeners.size === 0) {
+        this.stopListening()
+      }
+    }
+  }
+
+  notifyOnline(): void {
+    this.notifyListeners()
+  }
+
+  isOnline(): boolean {
+    if (typeof navigator !== `undefined`) {
+      return navigator.onLine
+    }
+    return true
+  }
+
+  dispose(): void {
+    this.stopListening()
+    this.listeners.clear()
+  }
+}
+
+/**
+ * @deprecated Use `WebOnlineDetector` instead. This alias is kept for backwards compatibility.
+ */
+export const DefaultOnlineDetector = WebOnlineDetector
diff --git a/packages/offline-transactions/src/connectivity/ReactNativeOnlineDetector.ts b/packages/offline-transactions/src/connectivity/ReactNativeOnlineDetector.ts
new file mode 100644
index 000000000..e969732df
--- /dev/null
+++ b/packages/offline-transactions/src/connectivity/ReactNativeOnlineDetector.ts
@@ -0,0 +1,105 @@
+import NetInfo from '@react-native-community/netinfo'
+import { AppState } from 'react-native'
+import type { AppStateStatus, NativeEventSubscription } from 'react-native'
+import type { OnlineDetector } from '../types'
+
+/**
+ * React Native online detector that uses RN APIs.
+ * Listens for:
+ * - Network connectivity changes via `@react-native-community/netinfo`
+ * - App state changes (foreground/background) via `AppState`
+ */
+export class ReactNativeOnlineDetector implements OnlineDetector {
+  private listeners: Set<() => void> = new Set()
+  private netInfoUnsubscribe: (() => void) | null = null
+  private appStateSubscription: NativeEventSubscription | null = null
+  private isListening = false
+  private wasConnected = true
+
+  constructor() {
+    this.startListening()
+  }
+
+  private startListening(): void {
+    if (this.isListening) {
+      return
+    }
+
+    this.isListening = true
+
+    // Subscribe to network state changes
+    this.netInfoUnsubscribe = NetInfo.addEventListener((state) => {
+      const isConnected =
+        state.isConnected === true && state.isInternetReachable !== false
+
+      // Only notify when transitioning to online
+      if (isConnected && !this.wasConnected) {
+        this.notifyListeners()
+      }
+
+      this.wasConnected = isConnected
+    })
+
+    // Subscribe to app state changes (foreground/background)
+    this.appStateSubscription = AppState.addEventListener(
+      `change`,
+      this.handleAppStateChange,
+    )
+  }
+
+  private handleAppStateChange = (nextState: AppStateStatus): void => {
+    // Notify when app becomes active (foreground)
+    if (nextState === `active`) {
+      this.notifyListeners()
+    }
+  }
+
+  private stopListening(): void {
+    if (!this.isListening) {
+      return
+    }
+
+    this.isListening = false
+
+    if (this.netInfoUnsubscribe) {
+      this.netInfoUnsubscribe()
+      this.netInfoUnsubscribe = null
+    }
+
+    if (this.appStateSubscription) {
+      this.appStateSubscription.remove()
+      this.appStateSubscription = null
+    }
+  }
+
+  private notifyListeners(): void {
+    for (const listener of this.listeners) {
+      try {
+        listener()
+      } catch (error) {
+        console.warn(`ReactNativeOnlineDetector listener error:`, error)
+      }
+    }
+  }
+
+  subscribe(callback: () => void): () => void {
+    this.listeners.add(callback)
+
+    return () => {
+      this.listeners.delete(callback)
+
+      if (this.listeners.size === 0) {
+        this.stopListening()
+      }
+    }
+  }
+
+  notifyOnline(): void {
+    this.notifyListeners()
+  }
+
+  dispose(): void {
+    this.stopListening()
+    this.listeners.clear()
+  }
+}
diff --git a/packages/offline-transactions/src/coordination/BroadcastChannelLeader.ts b/packages/offline-transactions/src/coordination/BroadcastChannelLeader.ts
new file mode 100644
index 000000000..ce11a8abc
--- /dev/null
+++ b/packages/offline-transactions/src/coordination/BroadcastChannelLeader.ts
@@ -0,0 +1,181 @@
+import { BaseLeaderElection } from './LeaderElection'
+
+interface LeaderMessage {
+  type: `heartbeat` | `election` | `leadership-claim`
+  tabId: string
+  timestamp: number
+}
+
+export class BroadcastChannelLeader extends BaseLeaderElection {
+  private channelName: string
+  private tabId: string
+  private channel: BroadcastChannel | null = null
+  private heartbeatInterval: number | null = null
+  private electionTimeout: number | null = null
+  private lastLeaderHeartbeat = 0
+  private readonly heartbeatIntervalMs = 5000
+  private readonly electionTimeoutMs = 10000
+
+  constructor(channelName = `offline-executor-leader`) {
+    super()
+    this.channelName = channelName
+    this.tabId = crypto.randomUUID()
+    this.setupChannel()
+  }
+
+  private setupChannel(): void {
+    if (!this.isBroadcastChannelSupported()) {
+      return
+    }
+
+    this.channel = new BroadcastChannel(this.channelName)
+    this.channel.addEventListener(`message`, this.handleMessage)
+  }
+
+  private handleMessage = (event: MessageEvent<LeaderMessage>): void => {
+    const { type, tabId, timestamp } = event.data
+
+    if (tabId === this.tabId) {
+      return
+    }
+
+    switch (type) {
+      case `heartbeat`:
+        if (this.isLeaderState && tabId < this.tabId) {
+          this.releaseLeadership()
+        } else if (!this.isLeaderState) {
+          this.lastLeaderHeartbeat = timestamp
+          this.cancelElection()
+        }
+        break
+
+      case `election`:
+        if (this.isLeaderState) {
+          this.sendHeartbeat()
+        } else if (tabId > this.tabId) {
+          this.startElection()
+        }
+        break
+
+      case `leadership-claim`:
+        if (this.isLeaderState && tabId < this.tabId) {
+          this.releaseLeadership()
+        }
+        break
+    }
+  }
+
+  async requestLeadership(): Promise<boolean> {
+    if (!this.isBroadcastChannelSupported()) {
+      return false
+    }
+
+    if (this.isLeaderState) {
+      return true
+    }
+
+    this.startElection()
+
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(this.isLeaderState)
+      }, 1000)
+    })
+  }
+
+  private startElection(): void {
+    if (this.electionTimeout) {
+      return
+    }
+
+    this.sendMessage({
+      type: `election`,
+      tabId: this.tabId,
+      timestamp: Date.now(),
+    })
+
+    this.electionTimeout = window.setTimeout(() => {
+      const timeSinceLastHeartbeat = Date.now() - this.lastLeaderHeartbeat
+
+      if (timeSinceLastHeartbeat > this.electionTimeoutMs) {
+        this.claimLeadership()
+      }
+
+      this.electionTimeout = null
+    }, this.electionTimeoutMs)
+  }
+
+  private cancelElection(): void {
+    if (this.electionTimeout) {
+      clearTimeout(this.electionTimeout)
+      this.electionTimeout = null
+    }
+  }
+
+  private claimLeadership(): void {
+    this.notifyLeadershipChange(true)
+    this.sendMessage({
+      type: `leadership-claim`,
+      tabId: this.tabId,
+      timestamp: Date.now(),
+    })
+    this.startHeartbeat()
+  }
+
+  private startHeartbeat(): void {
+    if (this.heartbeatInterval) {
+      return
+    }
+
+    this.sendHeartbeat()
+
+    this.heartbeatInterval = window.setInterval(() => {
+      this.sendHeartbeat()
+    }, this.heartbeatIntervalMs)
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval)
+      this.heartbeatInterval = null
+    }
+  }
+
+  private sendHeartbeat(): void {
+    this.sendMessage({
+      type: `heartbeat`,
+      tabId: this.tabId,
+      timestamp: Date.now(),
+    })
+  }
+
+  private sendMessage(message: LeaderMessage): void {
+    if (this.channel) {
+      this.channel.postMessage(message)
+    }
+  }
+
+  releaseLeadership(): void {
+    this.stopHeartbeat()
+    this.cancelElection()
+    this.notifyLeadershipChange(false)
+  }
+
+  private isBroadcastChannelSupported(): boolean {
+    return typeof BroadcastChannel !== `undefined`
+  }
+
+  static isSupported(): boolean {
+    return typeof BroadcastChannel !== `undefined`
+  }
+
+  dispose(): void {
+    this.releaseLeadership()
+
+    if (this.channel) {
+      this.channel.removeEventListener(`message`, this.handleMessage)
+      this.channel.close()
+      this.channel = null
+    }
+  }
+}
diff --git a/packages/offline-transactions/src/coordination/LeaderElection.ts b/packages/offline-transactions/src/coordination/LeaderElection.ts
new file mode 100644
index 000000000..6223aef01
--- /dev/null
+++ b/packages/offline-transactions/src/coordination/LeaderElection.ts
@@ -0,0 +1,35 @@
+import type { LeaderElection } from '../types'
+
+export abstract class BaseLeaderElection implements LeaderElection {
+  protected isLeaderState = false
+  protected listeners: Set<(isLeader: boolean) => void> = new Set()
+
+  abstract requestLeadership(): Promise<boolean>
+  abstract releaseLeadership(): void
+
+  isLeader(): boolean {
+    return this.isLeaderState
+  }
+
+  onLeadershipChange(callback: (isLeader: boolean) => void): () => void {
+    this.listeners.add(callback)
+
+    return () => {
+      this.listeners.delete(callback)
+    }
+  }
+
+  protected notifyLeadershipChange(isLeader: boolean): void {
+    if (this.isLeaderState !== isLeader) {
+      this.isLeaderState = isLeader
+
+      for (const listener of this.listeners) {
+        try {
+          listener(isLeader)
+        } catch (error) {
+          console.warn(`Leadership change listener error:`, error)
+        }
+      }
+    }
+  }
+}
diff --git a/packages/offline-transactions/src/coordination/WebLocksLeader.ts b/packages/offline-transactions/src/coordination/WebLocksLeader.ts
new file mode 100644
index 000000000..644ad6437
--- /dev/null
+++ b/packages/offline-transactions/src/coordination/WebLocksLeader.ts
@@ -0,0 +1,88 @@
+import { BaseLeaderElection } from './LeaderElection'
+
+export class WebLocksLeader extends BaseLeaderElection {
+  private lockName: string
+  private releaseLock: (() => void) | null = null
+
+  constructor(lockName = `offline-executor-leader`) {
+    super()
+    this.lockName = lockName
+  }
+
+  async requestLeadership(): Promise<boolean> {
+    if (!this.isWebLocksSupported()) {
+      return false
+    }
+
+    if (this.isLeaderState) {
+      return true
+    }
+
+    try {
+      // First try to acquire the lock with ifAvailable
+      const available = await navigator.locks.request(
+        this.lockName,
+        {
+          mode: `exclusive`,
+          ifAvailable: true,
+        },
+        (lock) => {
+          return lock !== null
+        },
+      )
+
+      if (!available) {
+        return false
+      }
+
+      // Set state immediately to prevent duplicate notifications
+      // when the async lock acquisition calls notifyLeadershipChange(true).
+      // The guard in notifyLeadershipChange checks `isLeaderState !== isLeader`,
+      // so setting this to true here prevents the callback from firing again.
+      this.isLeaderState = true
+
+      // Lock is available, now acquire it for real and hold it
+      navigator.locks.request(
+        this.lockName,
+        {
+          mode: `exclusive`,
+        },
+        async (lock) => {
+          if (lock) {
+            this.notifyLeadershipChange(true)
+            // Hold the lock until released
+            return new Promise<void>((resolve) => {
+              this.releaseLock = () => {
+                this.notifyLeadershipChange(false)
+                resolve()
+              }
+            })
+          }
+        },
+      )
+
+      return true
+    } catch (error) {
+      if (error instanceof Error && error.name === `AbortError`) {
+        return false
+      }
+      console.warn(`Web Locks leadership request failed:`, error)
+      return false
+    }
+  }
+
+  releaseLeadership(): void {
+    if (this.releaseLock) {
+      this.releaseLock()
+      this.releaseLock = null
+    }
+  }
+
+  private isWebLocksSupported(): boolean {
+    return typeof navigator !== `undefined` && `locks` in navigator
+  }
+
+  static isSupported(): boolean {
+    return typeof navigator !== `undefined` && `locks` in navigator
+  }
+}
diff --git a/packages/offline-transactions/src/executor/KeyScheduler.ts b/packages/offline-transactions/src/executor/KeyScheduler.ts
new file mode 100644
index 000000000..1243db565
--- /dev/null
+++ b/packages/offline-transactions/src/executor/KeyScheduler.ts
@@ -0,0 +1,123 @@
+import { withSyncSpan } from '../telemetry/tracer'
+import type { OfflineTransaction } from '../types'
+
+export class KeyScheduler {
+  private pendingTransactions: Array<OfflineTransaction> = []
+  private isRunning = false
+
+  schedule(transaction: OfflineTransaction): void {
+    withSyncSpan(
+      `scheduler.schedule`,
+      {
+        'transaction.id': transaction.id,
+        queueLength: this.pendingTransactions.length,
+      },
+      () => {
+        this.pendingTransactions.push(transaction)
+        // Sort by creation time to maintain FIFO order
+        this.pendingTransactions.sort(
+          (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+        )
+      },
+    )
+  }
+
+  getNextBatch(_maxConcurrency: number): Array<OfflineTransaction> {
+    return withSyncSpan(
+      `scheduler.getNextBatch`,
+      { pendingCount: this.pendingTransactions.length },
+      (span) => {
+        // For sequential processing, we ignore maxConcurrency and only process one transaction at a time
+        if (this.isRunning || this.pendingTransactions.length === 0) {
+          span.setAttribute(`result`, `empty`)
+          return []
+        }
+
+        // Find the first transaction that's ready to run
+        const readyTransaction = this.pendingTransactions.find((tx) =>
+          this.isReadyToRun(tx),
+        )
+
+        if (readyTransaction) {
+          span.setAttribute(`result`, `found`)
+          span.setAttribute(`transaction.id`, readyTransaction.id)
+        } else {
+          span.setAttribute(`result`, `none_ready`)
+        }
+
+        return readyTransaction ? [readyTransaction] : []
+      },
+    )
+  }
+
+  private isReadyToRun(transaction: OfflineTransaction): boolean {
+    return Date.now() >= transaction.nextAttemptAt
+  }
+
+  markStarted(_transaction: OfflineTransaction): void {
+    this.isRunning = true
+  }
+
+  markCompleted(transaction: OfflineTransaction): void {
+    this.removeTransaction(transaction)
+    this.isRunning = false
+  }
+
+  markFailed(_transaction: OfflineTransaction): void {
+    this.isRunning = false
+  }
+
+  private removeTransaction(transaction: OfflineTransaction): void {
+    const index = this.pendingTransactions.findIndex(
+      (tx) => tx.id === transaction.id,
+    )
+    if (index >= 0) {
+      this.pendingTransactions.splice(index, 1)
+    }
+  }
+
+  updateTransaction(transaction: OfflineTransaction): void {
+    const index = this.pendingTransactions.findIndex(
+      (tx) => tx.id === transaction.id,
+    )
+    if (index >= 0) {
+      this.pendingTransactions[index] = transaction
+      // Re-sort to maintain FIFO order after update
+      this.pendingTransactions.sort(
+        (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+      )
+    }
+  }
+
+  getPendingCount(): number {
+    return this.pendingTransactions.length
+  }
+
+  getRunningCount(): number {
+    return this.isRunning ? 1 : 0
+  }
+
+  clear(): void {
+    this.pendingTransactions = []
+    this.isRunning = false
+  }
+
+  getAllPendingTransactions(): Array<OfflineTransaction> {
+    return [...this.pendingTransactions]
+  }
+
+  updateTransactions(updatedTransactions: Array<OfflineTransaction>): void {
+    for (const updatedTx of updatedTransactions) {
+      const index = this.pendingTransactions.findIndex(
+        (tx) => tx.id === updatedTx.id,
+      )
+      if (index >= 0) {
+        this.pendingTransactions[index] = updatedTx
+      }
+    }
+    // Re-sort to maintain FIFO order after updates
+    this.pendingTransactions.sort(
+      (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+    )
+  }
+}
diff --git a/packages/offline-transactions/src/executor/TransactionExecutor.ts b/packages/offline-transactions/src/executor/TransactionExecutor.ts
new file mode 100644
index 000000000..5853a243b
--- /dev/null
+++ b/packages/offline-transactions/src/executor/TransactionExecutor.ts
@@ -0,0 +1,374 @@
+import { createTransaction } from '@tanstack/db'
+import { DefaultRetryPolicy } from '../retry/RetryPolicy'
+import { NonRetriableError } from '../types'
+import { withNestedSpan } from '../telemetry/tracer'
+import type { KeyScheduler } from './KeyScheduler'
+import type { OutboxManager } from '../outbox/OutboxManager'
+import type { OfflineConfig, OfflineTransaction } from '../types'
+
+const HANDLED_EXECUTION_ERROR = Symbol(`HandledExecutionError`)
+
+export class TransactionExecutor {
+  private scheduler: KeyScheduler
+  private outbox: OutboxManager
+  private config: OfflineConfig
+  private retryPolicy: DefaultRetryPolicy
+  private isExecuting = false
+  private executionPromise: Promise<void> | null = null
+  private offlineExecutor: any // Reference to OfflineExecutor for signaling
+  private retryTimer: ReturnType<typeof setTimeout> | null = null
+
+  constructor(
+    scheduler: KeyScheduler,
+    outbox: OutboxManager,
+    config: OfflineConfig,
+    offlineExecutor: any,
+  ) {
+    this.scheduler = scheduler
+    this.outbox = outbox
+    this.config = config
+    this.retryPolicy = new DefaultRetryPolicy(10, config.jitter ?? true)
+    this.offlineExecutor = offlineExecutor
+  }
+
+  async execute(transaction: OfflineTransaction): Promise<void> {
+    this.scheduler.schedule(transaction)
+    await this.executeAll()
+  }
+
+  async executeAll(): Promise<void> {
+    if (this.isExecuting) {
+      return this.executionPromise!
+    }
+
+    this.isExecuting = true
+    this.executionPromise = this.runExecution()
+
+    try {
+      await this.executionPromise
+    } finally {
+      this.isExecuting = false
+      this.executionPromise = null
+    }
+  }
+
+  private async runExecution(): Promise<void> {
+    const maxConcurrency = this.config.maxConcurrency ?? 3
+
+    while (this.scheduler.getPendingCount() > 0) {
+      const batch = this.scheduler.getNextBatch(maxConcurrency)
+
+      if (batch.length === 0) {
+        break
+      }
+
+      const executions = batch.map((transaction) =>
+        this.executeTransaction(transaction),
+      )
+      await Promise.allSettled(executions)
+    }
+
+    // Schedule next retry after execution completes
+    this.scheduleNextRetry()
+  }
+
+  private async executeTransaction(
+    transaction: OfflineTransaction,
+  ): Promise<void> {
+    try {
+      await withNestedSpan(
+        `transaction.execute`,
+        {
+          'transaction.id': transaction.id,
+          'transaction.mutationFnName': transaction.mutationFnName,
+          'transaction.retryCount': transaction.retryCount,
+          'transaction.keyCount': transaction.keys.length,
+        },
+        async (span) => {
+          this.scheduler.markStarted(transaction)
+
+          if (transaction.retryCount > 0) {
+            span.setAttribute(`retry.attempt`, transaction.retryCount)
+          }
+
+          try {
+            const result = await this.runMutationFn(transaction)
+
+            this.scheduler.markCompleted(transaction)
+            await this.outbox.remove(transaction.id)
+
+            span.setAttribute(`result`, `success`)
+            this.offlineExecutor.resolveTransaction(transaction.id, result)
+          } catch (error) {
+            const err =
+              error instanceof Error ? error : new Error(String(error))
+
+            span.setAttribute(`result`, `error`)
+
+            await this.handleError(transaction, err)
+            ;(err as any)[HANDLED_EXECUTION_ERROR] = true
+            throw err
+          }
+        },
+      )
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        (error as any)[HANDLED_EXECUTION_ERROR] === true
+      ) {
+        return
+      }
+
+      throw error
+    }
+  }
+
+  private async runMutationFn(transaction: OfflineTransaction): Promise<void> {
+    const mutationFn = this.config.mutationFns[transaction.mutationFnName]
+
+    if (!mutationFn) {
+      const errorMessage = `Unknown mutation function: ${transaction.mutationFnName}`
+
+      if (this.config.onUnknownMutationFn) {
+        this.config.onUnknownMutationFn(transaction.mutationFnName, transaction)
+      }
+
+      throw new NonRetriableError(errorMessage)
+    }
+
+    // Mutations are already PendingMutation objects with collections attached
+    // from the deserializer, so we can use them directly
+    const transactionWithMutations = {
+      id: transaction.id,
+      mutations: transaction.mutations,
+      metadata: transaction.metadata ?? {},
+    }
+
+    await mutationFn({
+      transaction: transactionWithMutations as any,
+      idempotencyKey: transaction.idempotencyKey,
+    })
+  }
+
+  private async handleError(
+    transaction: OfflineTransaction,
+    error: Error,
+  ): Promise<void> {
+    return withNestedSpan(
+      `transaction.handleError`,
+      {
+        'transaction.id': transaction.id,
+        'error.name': error.name,
+        'error.message': error.message,
+      },
+      async (span) => {
+        const shouldRetry = this.retryPolicy.shouldRetry(
+          error,
+          transaction.retryCount,
+        )
+
+        span.setAttribute(`shouldRetry`, shouldRetry)
+
+        if (!shouldRetry) {
+          this.scheduler.markCompleted(transaction)
+          await this.outbox.remove(transaction.id)
+          console.warn(
+            `Transaction ${transaction.id} failed permanently:`,
+            error,
+          )
+
+          span.setAttribute(`result`, `permanent_failure`)
+          // Signal permanent failure to the waiting transaction
+          this.offlineExecutor.rejectTransaction(transaction.id, error)
+          return
+        }
+
+        const delay = this.retryPolicy.calculateDelay(transaction.retryCount)
+        const updatedTransaction: OfflineTransaction = {
+          ...transaction,
+          retryCount: transaction.retryCount + 1,
+          nextAttemptAt: Date.now() + delay,
+          lastError: {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+          },
+        }
+
+        span.setAttribute(`retryDelay`, delay)
+        span.setAttribute(`nextRetryCount`, updatedTransaction.retryCount)
+
+        this.scheduler.markFailed(transaction)
+        this.scheduler.updateTransaction(updatedTransaction)
+
+        try {
+          await this.outbox.update(transaction.id, updatedTransaction)
+          span.setAttribute(`result`, `scheduled_retry`)
+        } catch (persistError) {
+          span.recordException(persistError as Error)
+          span.setAttribute(`result`, `persist_failed`)
+          throw persistError
+        }
+
+        // Schedule retry timer
+        this.scheduleNextRetry()
+      },
+    )
+  }
+
+  async loadPendingTransactions(): Promise<void> {
+    const transactions = await this.outbox.getAll()
+    let filteredTransactions = transactions
+
+    if (this.config.beforeRetry) {
+      filteredTransactions = this.config.beforeRetry(transactions)
+    }
+
+    for (const transaction of filteredTransactions) {
+      this.scheduler.schedule(transaction)
+    }
+
+    // Restore optimistic state for loaded transactions
+    // This ensures the UI shows the optimistic data while transactions are pending
+    this.restoreOptimisticState(filteredTransactions)
+
+    // Reset retry delays for all loaded transactions so they can run immediately
+    this.resetRetryDelays()
+
+    // Schedule retry timer for loaded transactions
+    this.scheduleNextRetry()
+
+    const removedTransactions = transactions.filter(
+      (tx) => !filteredTransactions.some((filtered) => filtered.id === tx.id),
+    )
+
+    if (removedTransactions.length > 0) {
+      await this.outbox.removeMany(removedTransactions.map((tx) => tx.id))
+    }
+  }
+
+  /**
+   * Restore optimistic state from loaded transactions.
+   * Creates internal transactions to hold the mutations so the collection's
+   * state manager can show optimistic data while waiting for sync.
+   */
+  private restoreOptimisticState(
+    transactions: Array<OfflineTransaction>,
+  ): void {
+    for (const offlineTx of transactions) {
+      if (offlineTx.mutations.length === 0) {
+        continue
+      }
+
+      try {
+        // Create a restoration transaction that holds mutations for optimistic state display.
+        // It will never commit - the real mutation is handled by the offline executor.
+        const restorationTx = createTransaction({
+          id: offlineTx.id,
+          autoCommit: false,
+          mutationFn: async () => {},
+        })
+
+        // Prevent unhandled promise rejection when cleanup calls rollback()
+        // We don't care about this promise - it's just for holding mutations
+        restorationTx.isPersisted.promise.catch(() => {
+          // Intentionally ignored - restoration transactions are cleaned up
+          // via cleanupRestorationTransaction, not through normal commit flow
+        })
+
+        restorationTx.applyMutations(offlineTx.mutations)
+
+        // Register with each affected collection's state manager
+        const touchedCollections = new Set<string>()
+        for (const mutation of offlineTx.mutations) {
+          // Defensive check for corrupted deserialized data
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          if (!mutation.collection) {
+            continue
+          }
+          const collectionId = mutation.collection.id
+          if (touchedCollections.has(collectionId)) {
+            continue
+          }
+          touchedCollections.add(collectionId)
+
+          mutation.collection._state.transactions.set(
+            restorationTx.id,
+            restorationTx,
+          )
+          mutation.collection._state.recomputeOptimisticState(true)
+        }
+
+        this.offlineExecutor.registerRestorationTransaction(
+          offlineTx.id,
+          restorationTx,
+        )
+      } catch (error) {
+        console.warn(
+          `Failed to restore optimistic state for transaction ${offlineTx.id}:`,
+          error,
+        )
+      }
+    }
+  }
+
+  clear(): void {
+    this.scheduler.clear()
+    this.clearRetryTimer()
+  }
+
+  getPendingCount(): number {
+    return this.scheduler.getPendingCount()
+  }
+
+  private scheduleNextRetry(): void {
+    // Clear existing timer
+    this.clearRetryTimer()
+
+    // Find the earliest retry time among pending transactions
+    const earliestRetryTime = this.getEarliestRetryTime()
+
+    if (earliestRetryTime === null) {
+      return // No transactions pending retry
+    }
+
+    const delay = Math.max(0, earliestRetryTime - Date.now())
+
+    this.retryTimer = setTimeout(() => {
+      this.executeAll().catch((error) => {
+        console.warn(`Failed to execute retry batch:`, error)
+      })
+    }, delay)
+  }
+
+  private getEarliestRetryTime(): number | null {
+    const allTransactions = this.scheduler.getAllPendingTransactions()
+
+    if (allTransactions.length === 0) {
+      return null
+    }
+
+    return Math.min(...allTransactions.map((tx) => tx.nextAttemptAt))
+  }
+
+  private clearRetryTimer(): void {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer)
+      this.retryTimer = null
+    }
+  }
+
+  getRunningCount(): number {
+    return this.scheduler.getRunningCount()
+  }
+
+  resetRetryDelays(): void {
+    const allTransactions = this.scheduler.getAllPendingTransactions()
+    const updatedTransactions = allTransactions.map((transaction) => ({
+      ...transaction,
+      nextAttemptAt: Date.now(),
+    }))
+
+    this.scheduler.updateTransactions(updatedTransactions)
+  }
+}
diff --git a/packages/offline-transactions/src/index.ts b/packages/offline-transactions/src/index.ts
new file mode 100644
index 000000000..f43f4633a
--- /dev/null
+++ b/packages/offline-transactions/src/index.ts
@@ -0,0 +1,53 @@
+// Main API
+export { OfflineExecutor, startOfflineExecutor } from './OfflineExecutor'
+
+// Types
+export type {
+  OfflineTransaction,
+  OfflineConfig,
+  OfflineMode,
+  StorageAdapter,
+  StorageDiagnostic,
+  StorageDiagnosticCode,
+  RetryPolicy,
+  LeaderElection,
+  OnlineDetector,
+  CreateOfflineTransactionOptions,
+  CreateOfflineActionOptions,
+  SerializedError,
+  SerializedMutation,
+} from './types'
+
+export { NonRetriableError } from './types'
+
+// Storage adapters
+export { IndexedDBAdapter } from './storage/IndexedDBAdapter'
+export { LocalStorageAdapter } from './storage/LocalStorageAdapter'
+
+// Retry policies
+export { DefaultRetryPolicy } from './retry/RetryPolicy'
+export { BackoffCalculator } from './retry/BackoffCalculator'
+
+// Coordination
+export { WebLocksLeader } from './coordination/WebLocksLeader'
+export { BroadcastChannelLeader } from './coordination/BroadcastChannelLeader'
+
+// Connectivity
+export {
+  WebOnlineDetector,
+  DefaultOnlineDetector,
+} from './connectivity/OnlineDetector'
+
+// API components
+export { OfflineTransaction as OfflineTransactionAPI } from './api/OfflineTransaction'
+export { createOfflineAction } from './api/OfflineAction'
+
+// Outbox management
+export { OutboxManager } from './outbox/OutboxManager'
+export { TransactionSerializer } from './outbox/TransactionSerializer'
+
+// Execution engine
+export { KeyScheduler } from './executor/KeyScheduler'
+export { TransactionExecutor } from './executor/TransactionExecutor'
+
+// Replay
diff --git a/packages/offline-transactions/src/outbox/OutboxManager.ts b/packages/offline-transactions/src/outbox/OutboxManager.ts
new file mode 100644
index 000000000..bb2d8dda4
--- /dev/null
+++ b/packages/offline-transactions/src/outbox/OutboxManager.ts
@@ -0,0 +1,142 @@
+import { withSpan } from '../telemetry/tracer'
+import { TransactionSerializer } from './TransactionSerializer'
+import type { OfflineTransaction, StorageAdapter } from '../types'
+import type { Collection } from '@tanstack/db'
+
+export class OutboxManager {
+  private storage: StorageAdapter
+  private serializer: TransactionSerializer
+  private keyPrefix = `tx:`
+
+  constructor(
+    storage: StorageAdapter,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    collections: Record<string, Collection<any, any, any, any, any>>,
+  ) {
+    this.storage = storage
+    this.serializer = new TransactionSerializer(collections)
+  }
+
+  private getStorageKey(id: string): string {
+    return `${this.keyPrefix}${id}`
+  }
+
+  async add(transaction: OfflineTransaction): Promise<void> {
+    return withSpan(
+      `outbox.add`,
+      {
+        'transaction.id': transaction.id,
+        'transaction.mutationFnName': transaction.mutationFnName,
+        'transaction.keyCount': transaction.keys.length,
+      },
+      async () => {
+        const key = this.getStorageKey(transaction.id)
+        const serialized = this.serializer.serialize(transaction)
+        await this.storage.set(key, serialized)
+      },
+    )
+  }
+
+  async get(id: string): Promise<OfflineTransaction | null> {
+    return withSpan(`outbox.get`, { 'transaction.id': id }, async (span) => {
+      const key = this.getStorageKey(id)
+      const data = await this.storage.get(key)
+
+      if (!data) {
+        span.setAttribute(`result`, `not_found`)
+        return null
+      }
+
+      try {
+        const transaction = this.serializer.deserialize(data)
+        span.setAttribute(`result`, `found`)
+        return transaction
+      } catch (error) {
+        console.warn(`Failed to deserialize transaction ${id}:`, error)
+        span.setAttribute(`result`, `deserialize_error`)
+        return null
+      }
+    })
+  }
+
+  async getAll(): Promise<Array<OfflineTransaction>> {
+    return withSpan(`outbox.getAll`, {}, async (span) => {
+      const keys = await this.storage.keys()
+      const transactionKeys = keys.filter((key) =>
+        key.startsWith(this.keyPrefix),
+      )
+
+      span.setAttribute(`transactionCount`, transactionKeys.length)
+
+      const transactions: Array<OfflineTransaction> = []
+
+      for (const key of transactionKeys) {
+        const data = await this.storage.get(key)
+        if (data) {
+          try {
+            const transaction = this.serializer.deserialize(data)
+            transactions.push(transaction)
+          } catch (error) {
+            console.warn(
+              `Failed to deserialize transaction from key ${key}:`,
+              error,
+            )
+          }
+        }
+      }
+
+      return transactions.sort(
+        (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+      )
+    })
+  }
+
+  async getByKeys(keys: Array<string>): Promise<Array<OfflineTransaction>> {
+    const allTransactions = await this.getAll()
+    const keySet = new Set(keys)
+
+    return allTransactions.filter((transaction) =>
+      transaction.keys.some((key) => keySet.has(key)),
+    )
+  }
+
+  async update(
+    id: string,
+    updates: Partial<OfflineTransaction>,
+  ): Promise<void> {
+    return withSpan(`outbox.update`, { 'transaction.id': id }, async () => {
+      const existing = await this.get(id)
+      if (!existing) {
+        throw new Error(`Transaction ${id} not found`)
+      }
+
+      const updated = { ...existing, ...updates }
+      await this.add(updated)
+    })
+  }
+
+  async remove(id: string): Promise<void> {
+    return withSpan(`outbox.remove`, { 'transaction.id': id }, async () => {
+      const key = this.getStorageKey(id)
+      await this.storage.delete(key)
+    })
+  }
+
+  async removeMany(ids: Array<string>): Promise<void> {
+    return withSpan(`outbox.removeMany`, { count: ids.length }, async () => {
+      await Promise.all(ids.map((id) => this.remove(id)))
+    })
+  }
+
+  async clear(): Promise<void> {
+    const keys = await this.storage.keys()
+    const transactionKeys = keys.filter((key) => key.startsWith(this.keyPrefix))
+
+    await Promise.all(transactionKeys.map((key) => this.storage.delete(key)))
+  }
+
+  async count(): Promise<number> {
+    const keys = await this.storage.keys()
+    return keys.filter((key) => key.startsWith(this.keyPrefix)).length
+  }
+}
diff --git a/packages/offline-transactions/src/outbox/TransactionSerializer.ts b/packages/offline-transactions/src/outbox/TransactionSerializer.ts
new file mode 100644
index 000000000..cbbea8ece
--- /dev/null
+++ b/packages/offline-transactions/src/outbox/TransactionSerializer.ts
@@ -0,0 +1,173 @@
+import type {
+  OfflineTransaction,
+  SerializedError,
+  SerializedMutation,
+  SerializedOfflineTransaction,
+} from '../types'
+import type { Collection, PendingMutation } from '@tanstack/db'
+
+export class TransactionSerializer {
+  private collections: Record<string, Collection<any, any, any, any, any>>
+  private collectionIdToKey: Map<string, string>
+
+  constructor(
+    collections: Record<string, Collection<any, any, any, any, any>>,
+  ) {
+    this.collections = collections
+    // Create reverse lookup from collection.id to registry key
+    this.collectionIdToKey = new Map()
+    for (const [key, collection] of Object.entries(collections)) {
+      this.collectionIdToKey.set(collection.id, key)
+    }
+  }
+
+  serialize(transaction: OfflineTransaction): string {
+    const serialized: SerializedOfflineTransaction = {
+      ...transaction,
+      createdAt: transaction.createdAt.toISOString(),
+      mutations: transaction.mutations.map((mutation) =>
+        this.serializeMutation(mutation),
+      ),
+    }
+    return JSON.stringify(serialized)
+  }
+
+  deserialize(data: string): OfflineTransaction {
+    // Parse without a reviver - let deserializeValue handle dates in mutation data
+    // using the { __type: 'Date' } marker system
+    const parsed: SerializedOfflineTransaction = JSON.parse(data)
+
+    const createdAt = new Date(parsed.createdAt)
+    if (isNaN(createdAt.getTime())) {
+      throw new Error(
+        `Failed to deserialize transaction: invalid createdAt value "${parsed.createdAt}"`,
+      )
+    }
+
+    return {
+      ...parsed,
+      createdAt,
+      mutations: parsed.mutations.map((mutationData) =>
+        this.deserializeMutation(mutationData),
+      ),
+    }
+  }
+
+  private serializeMutation(mutation: PendingMutation): SerializedMutation {
+    const registryKey = this.collectionIdToKey.get(mutation.collection.id)
+    if (!registryKey) {
+      throw new Error(
+        `Collection with id ${mutation.collection.id} not found in registry`,
+      )
+    }
+
+    return {
+      globalKey: mutation.globalKey,
+      type: mutation.type,
+      modified: this.serializeValue(mutation.modified),
+      original: this.serializeValue(mutation.original),
+      changes: this.serializeValue(mutation.changes),
+      collectionId: registryKey, // Store registry key instead of collection.id
+    }
+  }
+
+  private deserializeMutation(data: SerializedMutation): PendingMutation {
+    const collection = this.collections[data.collectionId]
+    if (!collection) {
+      throw new Error(`Collection with id ${data.collectionId} not found`)
+    }
+
+    const modified = this.deserializeValue(data.modified)
+
+    // Extract the key from the modified data using the collection's getKey function
+    // This is needed for optimistic state restoration to work correctly
+    const key = modified ? collection.getKeyFromItem(modified) : null
+
+    // Create a partial PendingMutation - we can't fully reconstruct it but
+    // we provide what we can. The executor will need to handle the rest.
+    return {
+      globalKey: data.globalKey,
+      type: data.type as any,
+      modified,
+      original: this.deserializeValue(data.original),
+      changes: this.deserializeValue(data.changes) ?? {},
+      collection,
+      // These fields would need to be reconstructed by the executor
+      mutationId: ``, // Will be regenerated
+      key,
+      metadata: undefined,
+      syncMetadata: {},
+      optimistic: true,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    } as PendingMutation
+  }
+
+  private serializeValue(value: any): any {
+    if (value === null || value === undefined) {
+      return value
+    }
+
+    if (value instanceof Date) {
+      return { __type: `Date`, value: value.toISOString() }
+    }
+
+    if (typeof value === `object`) {
+      const result: any = Array.isArray(value) ? [] : {}
+      for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          result[key] = this.serializeValue(value[key])
+        }
+      }
+      return result
+    }
+
+    return value
+  }
+
+  private deserializeValue(value: any): any {
+    if (value === null || value === undefined) {
+      return value
+    }
+
+    if (typeof value === `object` && value.__type === `Date`) {
+      if (value.value === undefined || value.value === null) {
+        throw new Error(`Corrupted Date marker: missing value field`)
+      }
+      const date = new Date(value.value)
+      if (isNaN(date.getTime())) {
+        throw new Error(
+          `Failed to deserialize Date marker: invalid date value "${value.value}"`,
+        )
+      }
+      return date
+    }
+
+    if (typeof value === `object`) {
+      const result: any = Array.isArray(value) ? [] : {}
+      for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          result[key] = this.deserializeValue(value[key])
+        }
+      }
+      return result
+    }
+
+    return value
+  }
+
+  serializeError(error: Error): SerializedError {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    }
+  }
+
+  deserializeError(data: SerializedError): Error {
+    const error = new Error(data.message)
+    error.name = data.name
+    error.stack = data.stack
+    return error
+  }
+}
diff --git a/packages/offline-transactions/src/react-native/OfflineExecutor.ts b/packages/offline-transactions/src/react-native/OfflineExecutor.ts
new file mode 100644
index 000000000..7fc832164
--- /dev/null
+++ b/packages/offline-transactions/src/react-native/OfflineExecutor.ts
@@ -0,0 +1,24 @@
+import { OfflineExecutor as BaseOfflineExecutor } from '../OfflineExecutor'
+import { ReactNativeOnlineDetector } from '../connectivity/ReactNativeOnlineDetector'
+import type { OfflineConfig } from '../types'
+
+/**
+ * OfflineExecutor configured for React Native environments.
+ * Uses ReactNativeOnlineDetector by default instead of WebOnlineDetector.
+ */
+export class OfflineExecutor extends BaseOfflineExecutor {
+  constructor(config: OfflineConfig) {
+    super({
+      ...config,
+      onlineDetector: config.onlineDetector ?? new ReactNativeOnlineDetector(),
+    })
+  }
+}
+
+/**
+ * Start an offline executor configured for React Native environments.
+ * Uses ReactNativeOnlineDetector by default instead of WebOnlineDetector.
+ */
+export function startOfflineExecutor(config: OfflineConfig): OfflineExecutor {
+  return new OfflineExecutor(config)
+}
diff --git a/packages/offline-transactions/src/react-native/index.ts b/packages/offline-transactions/src/react-native/index.ts
new file mode 100644
index 000000000..977b1e93f
--- /dev/null
+++ b/packages/offline-transactions/src/react-native/index.ts
@@ -0,0 +1,45 @@
+// Re-export from main entry (types, utilities, etc.)
+export {
+  // Types
+  type OfflineTransaction,
+  type OfflineConfig,
+  type OfflineMode,
+  type StorageAdapter,
+  type StorageDiagnostic,
+  type StorageDiagnosticCode,
+  type RetryPolicy,
+  type LeaderElection,
+  type OnlineDetector,
+  type CreateOfflineTransactionOptions,
+  type CreateOfflineActionOptions,
+  type SerializedError,
+  type SerializedMutation,
+  NonRetriableError,
+  // Storage adapters
+  IndexedDBAdapter,
+  LocalStorageAdapter,
+  // Retry policies
+  DefaultRetryPolicy,
+  BackoffCalculator,
+  // Coordination
+  WebLocksLeader,
+  BroadcastChannelLeader,
+  // Connectivity - export web detector too for flexibility
+  WebOnlineDetector,
+  DefaultOnlineDetector,
+  // API components
+  OfflineTransactionAPI,
+  createOfflineAction,
+  // Outbox management
+  OutboxManager,
+  TransactionSerializer,
+  // Execution engine
+  KeyScheduler,
+  TransactionExecutor,
+} from '../index'
+
+// Export RN-specific detector
+export { ReactNativeOnlineDetector } from '../connectivity/ReactNativeOnlineDetector'
+
+// Export RN-configured executor
+export { OfflineExecutor, startOfflineExecutor } from './OfflineExecutor'
diff --git a/packages/offline-transactions/src/retry/BackoffCalculator.ts b/packages/offline-transactions/src/retry/BackoffCalculator.ts
new file mode 100644
index 000000000..be2236278
--- /dev/null
+++ b/packages/offline-transactions/src/retry/BackoffCalculator.ts
@@ -0,0 +1,13 @@
+export class BackoffCalculator {
+  private jitter: boolean
+
+  constructor(jitter = true) {
+    this.jitter = jitter
+  }
+
+  calculate(retryCount: number): number {
+    const baseDelay = Math.min(1000 * Math.pow(2, retryCount), 60000)
+    const jitterMultiplier = this.jitter ? Math.random() * 0.3 : 0
+    return Math.floor(baseDelay * (1 + jitterMultiplier))
+  }
+}
diff --git a/packages/offline-transactions/src/retry/NonRetriableError.ts b/packages/offline-transactions/src/retry/NonRetriableError.ts
new file mode 100644
index 000000000..6a2a38830
--- /dev/null
+++ b/packages/offline-transactions/src/retry/NonRetriableError.ts
@@ -0,0 +1 @@
+export { NonRetriableError } from '../types'
diff --git a/packages/offline-transactions/src/retry/RetryPolicy.ts b/packages/offline-transactions/src/retry/RetryPolicy.ts
new file mode 100644
index 000000000..9fb4f6bf5
--- /dev/null
+++ b/packages/offline-transactions/src/retry/RetryPolicy.ts
@@ -0,0 +1,41 @@
+import { NonRetriableError } from '../types'
+import { BackoffCalculator } from './BackoffCalculator'
+import type { RetryPolicy } from '../types'
+
+export class DefaultRetryPolicy implements RetryPolicy {
+  private backoffCalculator: BackoffCalculator
+  private maxRetries: number
+
+  constructor(maxRetries = 10, jitter = true) {
+    this.backoffCalculator = new BackoffCalculator(jitter)
+    this.maxRetries = maxRetries
+  }
+
+  calculateDelay(retryCount: number): number {
+    return this.backoffCalculator.calculate(retryCount)
+  }
+
+  shouldRetry(error: Error, retryCount: number): boolean {
+    if (retryCount >= this.maxRetries) {
+      return false
+    }
+
+    if (error instanceof NonRetriableError) {
+      return false
+    }
+
+    if (error.name === `AbortError`) {
+      return false
+    }
+
+    if (error.message.includes(`401`) || error.message.includes(`403`)) {
+      return false
+    }
+
+    if (error.message.includes(`422`) || error.message.includes(`400`)) {
+      return false
+    }
+
+    return true
+  }
+}
diff --git a/packages/offline-transactions/src/storage/IndexedDBAdapter.ts b/packages/offline-transactions/src/storage/IndexedDBAdapter.ts
new file mode 100644
index 000000000..c4ee78f31
--- /dev/null
+++ b/packages/offline-transactions/src/storage/IndexedDBAdapter.ts
@@ -0,0 +1,166 @@
+import { BaseStorageAdapter } from './StorageAdapter'
+
+export class IndexedDBAdapter extends BaseStorageAdapter {
+  private dbName: string
+  private storeName: string
+  private db: IDBDatabase | null = null
+
+  constructor(dbName = `offline-transactions`, storeName = `transactions`) {
+    super()
+    this.dbName = dbName
+    this.storeName = storeName
+  }
+
+  /**
+   * Probe IndexedDB availability by attempting to open a test database.
+   * This catches private mode and other restrictions that block IndexedDB.
+   */
+  static async probe(): Promise<{ available: boolean; error?: Error }> {
+    // Check if IndexedDB exists
+    if (typeof indexedDB === `undefined`) {
+      return {
+        available: false,
+        error: new Error(`IndexedDB is not available in this environment`),
+      }
+    }
+
+    // Try to actually open a test database to verify it works
+    try {
+      const testDbName = `__offline-tx-probe__`
+      const request = indexedDB.open(testDbName, 1)
+
+      return new Promise((resolve) => {
+        request.onerror = () => {
+          const error = request.error || new Error(`IndexedDB open failed`)
+          resolve({ available: false, error })
+        }
+
+        request.onsuccess = () => {
+          // Clean up test database
+          const db = request.result
+          db.close()
+          indexedDB.deleteDatabase(testDbName)
+          resolve({ available: true })
+        }
+
+        request.onblocked = () => {
+          resolve({
+            available: false,
+            error: new Error(`IndexedDB is blocked`),
+          })
+        }
+      })
+    } catch (error) {
+      return {
+        available: false,
+        error: error instanceof Error ? error : new Error(String(error)),
+      }
+    }
+  }
+
+  private async openDB(): Promise<IDBDatabase> {
+    if (this.db) {
+      return this.db
+    }
+
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1)
+
+      request.onerror = () => reject(request.error)
+      request.onsuccess = () => {
+        this.db = request.result
+        resolve(this.db)
+      }
+
+      request.onupgradeneeded = (event) => {
+        const db = (event.target as IDBOpenDBRequest).result
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName)
+        }
+      }
+    })
+  }
+
+  private async getStore(
+    mode: IDBTransactionMode = `readonly`,
+  ): Promise<IDBObjectStore> {
+    const db = await this.openDB()
+    const transaction = db.transaction([this.storeName], mode)
+    return transaction.objectStore(this.storeName)
+  }
+
+  async get(key: string): Promise<string | null> {
+    try {
+      const store = await this.getStore(`readonly`)
+      return new Promise((resolve, reject) => {
+        const request = store.get(key)
+        request.onerror = () => reject(request.error)
+        request.onsuccess = () => resolve(request.result ?? null)
+      })
+    } catch (error) {
+      console.warn(`IndexedDB get failed:`, error)
+      return null
+    }
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    try {
+      const store = await this.getStore(`readwrite`)
+      return new Promise((resolve, reject) => {
+        const request = store.put(value, key)
+        request.onerror = () => reject(request.error)
+        request.onsuccess = () => resolve()
+      })
+    } catch (error) {
+      if (
+        error instanceof DOMException &&
+        error.name === `QuotaExceededError`
+      ) {
+        throw new Error(
+          `Storage quota exceeded. Consider clearing old transactions.`,
+        )
+      }
+      throw error
+    }
+  }
+
+  async delete(key: string): Promise<void> {
+    try {
+      const store = await this.getStore(`readwrite`)
+      return new Promise((resolve, reject) => {
+        const request = store.delete(key)
+        request.onerror = () => reject(request.error)
+        request.onsuccess = () => resolve()
+      })
+    } catch (error) {
+      console.warn(`IndexedDB delete failed:`, error)
+    }
+  }
+
+  async keys(): Promise<Array<string>> {
+    try {
+      const store = await this.getStore(`readonly`)
+      return new Promise((resolve, reject) => {
+        const request = store.getAllKeys()
+        request.onerror = () => reject(request.error)
+        request.onsuccess = () => resolve(request.result as Array<string>)
+      })
+    } catch (error) {
+      console.warn(`IndexedDB keys failed:`, error)
+      return []
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      const store = await this.getStore(`readwrite`)
+      return new Promise((resolve, reject) => {
+        const request = store.clear()
+        request.onerror = () => reject(request.error)
+        request.onsuccess = () => resolve()
+      })
+    } catch (error) {
+      console.warn(`IndexedDB clear failed:`, error)
+    }
+  }
+}
diff --git a/packages/offline-transactions/src/storage/LocalStorageAdapter.ts b/packages/offline-transactions/src/storage/LocalStorageAdapter.ts
new file mode 100644
index 000000000..db3b85849
--- /dev/null
+++ b/packages/offline-transactions/src/storage/LocalStorageAdapter.ts
@@ -0,0 +1,117 @@
+import { BaseStorageAdapter } from './StorageAdapter'
+
+export class LocalStorageAdapter extends BaseStorageAdapter {
+  private prefix: string
+
+  constructor(prefix = `offline-tx:`) {
+    super()
+    this.prefix = prefix
+  }
+
+  /**
+   * Probe localStorage availability by attempting a test write.
+   * This catches private mode and other restrictions that block localStorage.
+   */
+  static probe(): { available: boolean; error?: Error } {
+    // Check if localStorage exists
+    if (typeof localStorage === `undefined`) {
+      return {
+        available: false,
+        error: new Error(`localStorage is not available in this environment`),
+      }
+    }
+
+    // Try to actually write/read/delete to verify it works
+    try {
+      const testKey = `__offline-tx-probe__`
+      const testValue = `test`
+
+      localStorage.setItem(testKey, testValue)
+      const retrieved = localStorage.getItem(testKey)
+      localStorage.removeItem(testKey)
+
+      if (retrieved !== testValue) {
+        return {
+          available: false,
+          error: new Error(`localStorage read/write verification failed`),
+        }
+      }
+
+      return { available: true }
+    } catch (error) {
+      return {
+        available: false,
+        error: error instanceof Error ? error : new Error(String(error)),
+      }
+    }
+  }
+
+  private getKey(key: string): string {
+    return `${this.prefix}${key}`
+  }
+
+  get(key: string): Promise<string | null> {
+    try {
+      return Promise.resolve(localStorage.getItem(this.getKey(key)))
+    } catch (error) {
+      console.warn(`localStorage get failed:`, error)
+      return Promise.resolve(null)
+    }
+  }
+
+  set(key: string, value: string): Promise<void> {
+    try {
+      localStorage.setItem(this.getKey(key), value)
+      return Promise.resolve()
+    } catch (error) {
+      if (
+        error instanceof DOMException &&
+        error.name === `QuotaExceededError`
+      ) {
+        return Promise.reject(
+          new Error(
+            `Storage quota exceeded. Consider clearing old transactions.`,
+          ),
+        )
+      }
+      return Promise.reject(error)
+    }
+  }
+
+  delete(key: string): Promise<void> {
+    try {
+      localStorage.removeItem(this.getKey(key))
+      return Promise.resolve()
+    } catch (error) {
+      console.warn(`localStorage delete failed:`, error)
+      return Promise.resolve()
+    }
+  }
+
+  keys(): Promise<Array<string>> {
+    try {
+      const keys: Array<string> = []
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i)
+        if (key && key.startsWith(this.prefix)) {
+          keys.push(key.slice(this.prefix.length))
+        }
+      }
+      return Promise.resolve(keys)
+    } catch (error) {
+      console.warn(`localStorage keys failed:`, error)
+      return Promise.resolve([])
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      const keys = await this.keys()
+      for (const key of keys) {
+        localStorage.removeItem(this.getKey(key))
+      }
+    } catch (error) {
+      console.warn(`localStorage clear failed:`, error)
+    }
+  }
+}
diff --git a/packages/offline-transactions/src/storage/StorageAdapter.ts b/packages/offline-transactions/src/storage/StorageAdapter.ts
new file mode 100644
index 000000000..3ebc129fe
--- /dev/null
+++ b/packages/offline-transactions/src/storage/StorageAdapter.ts
@@ -0,0 +1,11 @@
+import type { StorageAdapter } from '../types'
+
+export abstract class BaseStorageAdapter implements StorageAdapter {
+  abstract get(key: string): Promise<string | null>
+  abstract set(key: string, value: string): Promise<void>
+  abstract delete(key: string): Promise<void>
+  abstract keys(): Promise<Array<string>>
+  abstract clear(): Promise<void>
+}
+
+export { type StorageAdapter }
diff --git a/packages/offline-transactions/src/telemetry/tracer.ts b/packages/offline-transactions/src/telemetry/tracer.ts
new file mode 100644
index 000000000..c897a17fe
--- /dev/null
+++ b/packages/offline-transactions/src/telemetry/tracer.ts
@@ -0,0 +1,66 @@
+export interface SpanAttrs {
+  [key: string]: string | number | boolean | undefined
+}
+
+interface WithSpanOptions {
+  parentContext?: any
+}
+
+// No-op span implementation
+const noopSpan = {
+  setAttribute: () => {},
+  setAttributes: () => {},
+  setStatus: () => {},
+  recordException: () => {},
+  end: () => {},
+}
+
+/**
+ * Lightweight span wrapper with error handling.
+ * No-op implementation - telemetry has been removed.
+ *
+ * By default, creates spans at the current context level (siblings).
+ * Use withNestedSpan if you want parent-child relationships.
+ */
+export async function withSpan<T>(
+  name: string,
+  attrs: SpanAttrs,
+  fn: (span: any) => Promise<T>,
+  _options?: WithSpanOptions,
+): Promise<T> {
+  return await fn(noopSpan)
+}
+
+/**
+ * Like withSpan but propagates context so child spans nest properly.
+ * No-op implementation - telemetry has been removed.
+ */
+export async function withNestedSpan<T>(
+  name: string,
+  attrs: SpanAttrs,
+  fn: (span: any) => Promise<T>,
+  _options?: WithSpanOptions,
+): Promise<T> {
+  return await fn(noopSpan)
+}
+
+/**
+ * Creates a synchronous span for non-async operations
+ * No-op implementation - telemetry has been removed.
+ */
+export function withSyncSpan<T>(
+  name: string,
+  attrs: SpanAttrs,
+  fn: (span: any) => T,
+  _options?: WithSpanOptions,
+): T {
+  return fn(noopSpan)
+}
+
+/**
+ * Get the current tracer instance
+ * No-op implementation - telemetry has been removed.
+ */
+export function getTracer() {
+  return null
+}
diff --git a/packages/offline-transactions/src/types.ts b/packages/offline-transactions/src/types.ts
new file mode 100644
index 000000000..e0b1f6df7
--- /dev/null
+++ b/packages/offline-transactions/src/types.ts
@@ -0,0 +1,156 @@
+import type {
+  Collection,
+  MutationFnParams,
+  PendingMutation,
+} from '@tanstack/db'
+
+// Extended mutation function that includes idempotency key
+export type OfflineMutationFnParams<
+  T extends object = Record<string, unknown>,
+> = MutationFnParams<T> & {
+  idempotencyKey: string
+}
+
+export type OfflineMutationFn<T extends object = Record<string, unknown>> = (
+  params: OfflineMutationFnParams<T>,
+) => Promise<any>
+
+// Simplified mutation structure for serialization
+export interface SerializedMutation {
+  globalKey: string
+  type: string
+  modified: any
+  original: any
+  changes: any
+  collectionId: string
+}
+
+export interface SerializedError {
+  name: string
+  message: string
+  stack?: string
+}
+
+export interface SerializedSpanContext {
+  traceId: string
+  spanId: string
+  traceFlags: number
+  traceState?: string
+}
+
+// In-memory representation with full PendingMutation objects
+export interface OfflineTransaction {
+  id: string
+  mutationFnName: string
+  mutations: Array<PendingMutation>
+  keys: Array<string>
+  idempotencyKey: string
+  createdAt: Date
+  retryCount: number
+  nextAttemptAt: number
+  lastError?: SerializedError
+  metadata?: Record<string, any>
+  spanContext?: SerializedSpanContext
+  version: 1
+}
+
+// Serialized representation for storage
+export interface SerializedOfflineTransaction {
+  id: string
+  mutationFnName: string
+  mutations: Array<SerializedMutation>
+  keys: Array<string>
+  idempotencyKey: string
+  createdAt: string
+  retryCount: number
+  nextAttemptAt: number
+  lastError?: SerializedError
+  metadata?: Record<string, any>
+  spanContext?: SerializedSpanContext
+  version: 1
+}
+
+// Storage diagnostics and mode
+export type OfflineMode = `offline` | `online-only`
+
+export type StorageDiagnosticCode =
+  | `STORAGE_AVAILABLE`
+  | `INDEXEDDB_UNAVAILABLE`
+  | `LOCALSTORAGE_UNAVAILABLE`
+  | `STORAGE_BLOCKED`
+  | `QUOTA_EXCEEDED`
+  | `UNKNOWN_ERROR`
+
+export interface StorageDiagnostic {
+  code: StorageDiagnosticCode
+  mode: OfflineMode
+  message: string
+  error?: Error
+}
+
+export interface OfflineConfig {
+  collections: Record<string, Collection<any, any, any, any, any>>
+  mutationFns: Record<string, OfflineMutationFn>
+  storage?: StorageAdapter
+  maxConcurrency?: number
+  jitter?: boolean
+  beforeRetry?: (
+    transactions: Array<OfflineTransaction>,
+  ) => Array<OfflineTransaction>
+  onUnknownMutationFn?: (name: string, tx: OfflineTransaction) => void
+  onLeadershipChange?: (isLeader: boolean) => void
+  onStorageFailure?: (diagnostic: StorageDiagnostic) => void
+  leaderElection?: LeaderElection
+  /**
+   * Custom online detector implementation.
+   * Defaults to WebOnlineDetector for browser environments.
+   * Use ReactNativeOnlineDetector from '@tanstack/offline-transactions/react-native' for RN/Expo.
+   */
+  onlineDetector?: OnlineDetector
+}
+
+export interface StorageAdapter {
+  get: (key: string) => Promise<string | null>
+  set: (key: string, value: string) => Promise<void>
+  delete: (key: string) => Promise<void>
+  keys: () => Promise<Array<string>>
+  clear: () => Promise<void>
+}
+
+export interface RetryPolicy {
+  calculateDelay: (retryCount: number) => number
+  shouldRetry: (error: Error, retryCount: number) => boolean
+}
+
+export interface LeaderElection {
+  requestLeadership: () => Promise<boolean>
+  releaseLeadership: () => void
+  isLeader: () => boolean
+  onLeadershipChange: (callback: (isLeader: boolean) => void) => () => void
+}
+
+export interface OnlineDetector {
+  subscribe: (callback: () => void) => () => void
+  notifyOnline: () => void
+  dispose: () => void
+}
+
+export interface CreateOfflineTransactionOptions {
+  id?: string
+  mutationFnName: string
+  autoCommit?: boolean
+  idempotencyKey?: string
+  metadata?: Record<string, any>
+}
+
+export interface CreateOfflineActionOptions<T> {
+  mutationFnName: string
+  onMutate: (variables: T) => void
+}
+
+export class NonRetriableError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = `NonRetriableError`
+  }
+}
diff --git a/packages/offline-transactions/tests/OfflineExecutor.test.ts b/packages/offline-transactions/tests/OfflineExecutor.test.ts
new file mode 100644
index 000000000..19e48eb6c
--- /dev/null
+++ b/packages/offline-transactions/tests/OfflineExecutor.test.ts
@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { LocalStorageAdapter, startOfflineExecutor } from '../src/index'
+import type { OfflineConfig } from '../src/types'
+
+describe(`OfflineExecutor`, () => {
+  let mockCollection: any
+  let mockMutationFn: any
+  let config: OfflineConfig
+
+  beforeEach(() => {
+    mockCollection = {
+      id: `test-collection`,
+      insert: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+    }
+
+    mockMutationFn = vi.fn().mockResolvedValue(undefined)
+
+    config = {
+      collections: {
+        'test-collection': mockCollection,
+      },
+      mutationFns: {
+        syncData: mockMutationFn,
+      },
+      storage: new LocalStorageAdapter(),
+    }
+  })
+
+  it(`should create an offline executor`, () => {
+    const executor = startOfflineExecutor(config)
+
+    expect(executor).toBeDefined()
+    expect(executor.isOfflineEnabled).toBeDefined()
+  })
+
+  it(`should create offline transactions`, () => {
+    const executor = startOfflineExecutor(config)
+
+    const transaction = executor.createOfflineTransaction({
+      mutationFnName: `syncData`,
+    })
+
+    expect(transaction).toBeDefined()
+    expect(transaction.id).toBeDefined()
+  })
+
+  it(`should create offline actions`, () => {
+    const executor = startOfflineExecutor(config)
+
+    const action = executor.createOfflineAction({
+      mutationFnName: `syncData`,
+      onMutate: (data: any) => {
+        mockCollection.insert(data)
+      },
+    })
+
+    expect(action).toBeDefined()
+    expect(typeof action).toBe(`function`)
+  })
+
+  it(`should return empty outbox initially`, async () => {
+    const executor = startOfflineExecutor(config)
+
+    const transactions = await executor.peekOutbox()
+
+    expect(transactions).toEqual([])
+  })
+
+  it(`should dispose cleanly`, () => {
+    const executor = startOfflineExecutor(config)
+
+    expect(() => executor.dispose()).not.toThrow()
+  })
+})
diff --git a/packages/offline-transactions/tests/OnlineDetector.test.ts b/packages/offline-transactions/tests/OnlineDetector.test.ts
new file mode 100644
index 000000000..503aa38a3
--- /dev/null
+++ b/packages/offline-transactions/tests/OnlineDetector.test.ts
@@ -0,0 +1,194 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  DefaultOnlineDetector,
+  WebOnlineDetector,
+} from '../src/connectivity/OnlineDetector'
+
+describe(`WebOnlineDetector`, () => {
+  describe(`browser event handling`, () => {
+    let originalWindow: typeof globalThis.window
+    let originalDocument: typeof globalThis.document
+    let windowEventListeners: Map<string, Set<EventListener>>
+    let documentEventListeners: Map<string, Set<EventListener>>
+
+    beforeEach(() => {
+      // Store originals
+      originalWindow = globalThis.window
+      originalDocument = globalThis.document
+
+      // Create maps to track event listeners
+      windowEventListeners = new Map()
+      documentEventListeners = new Map()
+
+      // Mock window with event listener tracking
+      Object.defineProperty(globalThis, `window`, {
+        value: {
+          addEventListener: vi.fn((event: string, handler: EventListener) => {
+            if (!windowEventListeners.has(event)) {
+              windowEventListeners.set(event, new Set())
+            }
+            windowEventListeners.get(event)!.add(handler)
+          }),
+          removeEventListener: vi.fn(
+            (event: string, handler: EventListener) => {
+              windowEventListeners.get(event)?.delete(handler)
+            },
+          ),
+        },
+        writable: true,
+        configurable: true,
+      })
+
+      // Mock document with event listener tracking
+      Object.defineProperty(globalThis, `document`, {
+        value: {
+          visibilityState: `hidden`,
+          addEventListener: vi.fn((event: string, handler: EventListener) => {
+            if (!documentEventListeners.has(event)) {
+              documentEventListeners.set(event, new Set())
+            }
+            documentEventListeners.get(event)!.add(handler)
+          }),
+          removeEventListener: vi.fn(
+            (event: string, handler: EventListener) => {
+              documentEventListeners.get(event)?.delete(handler)
+            },
+          ),
+        },
+        writable: true,
+        configurable: true,
+      })
+    })
+
+    afterEach(() => {
+      // Restore originals
+      Object.defineProperty(globalThis, `window`, {
+        value: originalWindow,
+        writable: true,
+        configurable: true,
+      })
+      Object.defineProperty(globalThis, `document`, {
+        value: originalDocument,
+        writable: true,
+        configurable: true,
+      })
+    })
+
+    it(`should notify subscribers when online event fires`, () => {
+      const detector = new WebOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      // Simulate the online event
+      const onlineHandlers = windowEventListeners.get(`online`)
+      expect(onlineHandlers).toBeDefined()
+      expect(onlineHandlers!.size).toBe(1)
+
+      // Fire the online event
+      for (const handler of onlineHandlers!) {
+        handler(new Event(`online`))
+      }
+
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      detector.dispose()
+    })
+
+    it(`should notify subscribers when visibility changes to visible`, () => {
+      const detector = new WebOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      // Simulate visibility change to visible
+      ;(globalThis.document as any).visibilityState = `visible`
+
+      const visibilityHandlers = documentEventListeners.get(`visibilitychange`)
+      expect(visibilityHandlers).toBeDefined()
+      expect(visibilityHandlers!.size).toBe(1)
+
+      // Fire the visibilitychange event
+      for (const handler of visibilityHandlers!) {
+        handler(new Event(`visibilitychange`))
+      }
+
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      detector.dispose()
+    })
+
+    it(`should not notify when visibility changes to hidden`, () => {
+      const detector = new WebOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      // Keep visibility as hidden
+      ;(globalThis.document as any).visibilityState = `hidden`
+
+      const visibilityHandlers = documentEventListeners.get(`visibilitychange`)
+
+      // Fire the visibilitychange event
+      for (const handler of visibilityHandlers!) {
+        handler(new Event(`visibilitychange`))
+      }
+
+      expect(callback).not.toHaveBeenCalled()
+
+      detector.dispose()
+    })
+
+    it(`should unsubscribe from events on dispose`, () => {
+      const detector = new WebOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+      detector.dispose()
+
+      expect(window.removeEventListener).toHaveBeenCalledWith(
+        `online`,
+        expect.any(Function),
+      )
+      expect(document.removeEventListener).toHaveBeenCalledWith(
+        `visibilitychange`,
+        expect.any(Function),
+      )
+    })
+
+    it(`should support multiple subscribers`, () => {
+      const detector = new WebOnlineDetector()
+      const callback1 = vi.fn()
+      const callback2 = vi.fn()
+
+      detector.subscribe(callback1)
+      detector.subscribe(callback2)
+
+      detector.notifyOnline()
+
+      expect(callback1).toHaveBeenCalledTimes(1)
+      expect(callback2).toHaveBeenCalledTimes(1)
+
+      detector.dispose()
+    })
+
+    it(`should stop listening when all subscribers unsubscribe`, () => {
+      const detector = new WebOnlineDetector()
+      const callback = vi.fn()
+
+      const unsubscribe = detector.subscribe(callback)
+      unsubscribe()
+
+      expect(window.removeEventListener).toHaveBeenCalledWith(
+        `online`,
+        expect.any(Function),
+      )
+    })
+  })
+})
+
+describe(`DefaultOnlineDetector (backwards compatibility alias)`, () => {
+  it(`should be the same as WebOnlineDetector`, () => {
+    expect(DefaultOnlineDetector).toBe(WebOnlineDetector)
+  })
+})
diff --git a/packages/offline-transactions/tests/ReactNativeOnlineDetector.test.ts b/packages/offline-transactions/tests/ReactNativeOnlineDetector.test.ts
new file mode 100644
index 000000000..f1bd98218
--- /dev/null
+++ b/packages/offline-transactions/tests/ReactNativeOnlineDetector.test.ts
@@ -0,0 +1,324 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Import after mocks are set up
+import { AppState } from 'react-native'
+import NetInfo from '@react-native-community/netinfo'
+import { ReactNativeOnlineDetector } from '../src/connectivity/ReactNativeOnlineDetector'
+
+// Mock the react-native module
+vi.mock(`react-native`, () => {
+  const listeners: Array<(state: string) => void> = []
+  return {
+    AppState: {
+      addEventListener: vi.fn(
+        (event: string, callback: (state: string) => void) => {
+          if (event === `change`) {
+            listeners.push(callback)
+          }
+          return {
+            remove: vi.fn(() => {
+              const index = listeners.indexOf(callback)
+              if (index > -1) {
+                listeners.splice(index, 1)
+              }
+            }),
+          }
+        },
+      ),
+      // Expose for testing
+      __listeners: listeners,
+      __triggerChange: (state: string) => {
+        for (const listener of listeners) {
+          listener(state)
+        }
+      },
+    },
+  }
+})
+
+// Mock the @react-native-community/netinfo module
+vi.mock(`@react-native-community/netinfo`, () => {
+  const listeners: Array<
+    (state: {
+      isConnected: boolean
+      isInternetReachable: boolean | null
+    }) => void
+  > = []
+  return {
+    default: {
+      addEventListener: vi.fn(
+        (
+          callback: (state: {
+            isConnected: boolean
+            isInternetReachable: boolean | null
+          }) => void,
+        ) => {
+          listeners.push(callback)
+          return () => {
+            const index = listeners.indexOf(callback)
+            if (index > -1) {
+              listeners.splice(index, 1)
+            }
+          }
+        },
+      ),
+      // Expose for testing
+      __listeners: listeners,
+      __triggerState: (state: {
+        isConnected: boolean
+        isInternetReachable: boolean | null
+      }) => {
+        for (const listener of listeners) {
+          listener(state)
+        }
+      },
+    },
+  }
+})
+
+describe(`ReactNativeOnlineDetector`, () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    // Clear internal listener arrays
+    ;(AppState as any).__listeners.length = 0
+    ;(NetInfo as any).__listeners.length = 0
+  })
+
+  describe(`initialization`, () => {
+    it(`should subscribe to NetInfo on construction`, () => {
+      const detector = new ReactNativeOnlineDetector()
+
+      expect(NetInfo.addEventListener).toHaveBeenCalledTimes(1)
+      expect(NetInfo.addEventListener).toHaveBeenCalledWith(
+        expect.any(Function),
+      )
+
+      detector.dispose()
+    })
+
+    it(`should subscribe to AppState on construction`, () => {
+      const detector = new ReactNativeOnlineDetector()
+
+      expect(AppState.addEventListener).toHaveBeenCalledTimes(1)
+      expect(AppState.addEventListener).toHaveBeenCalledWith(
+        `change`,
+        expect.any(Function),
+      )
+
+      detector.dispose()
+    })
+  })
+
+  describe(`network connectivity changes`, () => {
+    it(`should notify subscribers when transitioning from offline to online`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      // First, simulate offline state
+      ;(NetInfo as any).__triggerState({
+        isConnected: false,
+        isInternetReachable: false,
+      })
+
+      expect(callback).not.toHaveBeenCalled()
+
+      // Now simulate coming online
+      ;(NetInfo as any).__triggerState({
+        isConnected: true,
+        isInternetReachable: true,
+      })
+
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      detector.dispose()
+    })
+
+    it(`should not notify when already online and staying online`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      // Simulate online state (detector starts assuming online)
+      ;(NetInfo as any).__triggerState({
+        isConnected: true,
+        isInternetReachable: true,
+      })
+
+      // Should not trigger since we were already considered online
+      expect(callback).not.toHaveBeenCalled()
+
+      detector.dispose()
+    })
+
+    it(`should treat isInternetReachable null as potentially reachable`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      // First go offline
+      ;(NetInfo as any).__triggerState({
+        isConnected: false,
+        isInternetReachable: false,
+      })
+
+      // Now come online with null isInternetReachable (unknown)
+      ;(NetInfo as any).__triggerState({
+        isConnected: true,
+        isInternetReachable: null,
+      })
+
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      detector.dispose()
+    })
+  })
+
+  describe(`app state changes`, () => {
+    it(`should notify subscribers when app becomes active`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      // Simulate app becoming active (foregrounded)
+      ;(AppState as any).__triggerChange(`active`)
+
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      detector.dispose()
+    })
+
+    it(`should not notify when app goes to background`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      // Simulate app going to background
+      ;(AppState as any).__triggerChange(`background`)
+
+      expect(callback).not.toHaveBeenCalled()
+
+      detector.dispose()
+    })
+
+    it(`should not notify when app becomes inactive`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      // Simulate app becoming inactive
+      ;(AppState as any).__triggerChange(`inactive`)
+
+      expect(callback).not.toHaveBeenCalled()
+
+      detector.dispose()
+    })
+  })
+
+  describe(`subscription management`, () => {
+    it(`should support multiple subscribers`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback1 = vi.fn()
+      const callback2 = vi.fn()
+
+      detector.subscribe(callback1)
+      detector.subscribe(callback2)
+
+      detector.notifyOnline()
+
+      expect(callback1).toHaveBeenCalledTimes(1)
+      expect(callback2).toHaveBeenCalledTimes(1)
+
+      detector.dispose()
+    })
+
+    it(`should allow unsubscribing`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      const unsubscribe = detector.subscribe(callback)
+      unsubscribe()
+
+      detector.notifyOnline()
+
+      expect(callback).not.toHaveBeenCalled()
+
+      detector.dispose()
+    })
+
+    it(`should handle notifyOnline() manual trigger`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+
+      detector.notifyOnline()
+      detector.notifyOnline()
+
+      expect(callback).toHaveBeenCalledTimes(2)
+
+      detector.dispose()
+    })
+  })
+
+  describe(`disposal`, () => {
+    it(`should unsubscribe from all native events on dispose`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+      detector.dispose()
+
+      // NetInfo and AppState listeners should be cleared
+      expect((NetInfo as any).__listeners.length).toBe(0)
+      expect((AppState as any).__listeners.length).toBe(0)
+    })
+
+    it(`should not notify after dispose`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const callback = vi.fn()
+
+      detector.subscribe(callback)
+      detector.dispose()
+
+      // Try to trigger events - should not notify
+      detector.notifyOnline()
+
+      expect(callback).not.toHaveBeenCalled()
+    })
+  })
+
+  describe(`error handling`, () => {
+    it(`should catch and warn on listener errors without stopping other listeners`, () => {
+      const detector = new ReactNativeOnlineDetector()
+      const consoleWarnSpy = vi
+        .spyOn(console, `warn`)
+        .mockImplementation(() => {})
+      const errorCallback = vi.fn(() => {
+        throw new Error(`Test error`)
+      })
+      const successCallback = vi.fn()
+
+      detector.subscribe(errorCallback)
+      detector.subscribe(successCallback)
+
+      detector.notifyOnline()
+
+      expect(errorCallback).toHaveBeenCalledTimes(1)
+      expect(successCallback).toHaveBeenCalledTimes(1)
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        `ReactNativeOnlineDetector listener error:`,
+        expect.any(Error),
+      )
+
+      consoleWarnSpy.mockRestore()
+      detector.dispose()
+    })
+  })
+})
diff --git a/packages/offline-transactions/tests/TransactionSerializer.test.ts b/packages/offline-transactions/tests/TransactionSerializer.test.ts
new file mode 100644
index 000000000..c1ce716fe
--- /dev/null
+++ b/packages/offline-transactions/tests/TransactionSerializer.test.ts
@@ -0,0 +1,238 @@
+import { describe, expect, it } from 'vitest'
+import { TransactionSerializer } from '../src/outbox/TransactionSerializer'
+import type { OfflineTransaction } from '../src/types'
+import type { PendingMutation } from '@tanstack/db'
+
+describe(`TransactionSerializer`, () => {
+  const mockCollection = {
+    id: `test-collection`,
+    getKeyFromItem: (item: any) => item.id,
+  }
+
+  const createSerializer = () => {
+    return new TransactionSerializer({
+      'test-collection': mockCollection as any,
+    })
+  }
+
+  describe(`date handling`, () => {
+    it(`should preserve plain ISO date strings without converting to Date objects`, () => {
+      const serializer = createSerializer()
+
+      // This is the bug: a plain string that looks like an ISO date
+      // should NOT be converted to a Date object after round-trip
+      const isoDateString = `2024-01-15T10:30:00.000Z`
+
+      const transaction: OfflineTransaction = {
+        id: `tx-1`,
+        createdAt: new Date(`2024-01-01T00:00:00.000Z`),
+        status: `pending`,
+        mutationFnName: `syncData`,
+        mutations: [
+          {
+            globalKey: `key-1`,
+            type: `insert`,
+            // This field intentionally stores an ISO date as a STRING
+            // (e.g., a DB value, or a user-provided string)
+            modified: {
+              id: `1`,
+              eventId: isoDateString, // Should remain a string!
+              description: `Some event`,
+            },
+            original: null,
+            collection: mockCollection,
+            mutationId: `mut-1`,
+            key: `1`,
+            changes: {},
+            metadata: undefined,
+            syncMetadata: {},
+            optimistic: true,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          } as PendingMutation,
+        ],
+      }
+
+      // Serialize and deserialize (simulating app restart)
+      const serialized = serializer.serialize(transaction)
+      const deserialized = serializer.deserialize(serialized)
+
+      // The eventId should still be a string, not a Date object
+      const eventId = deserialized.mutations[0]!.modified.eventId
+      expect(typeof eventId).toBe(`string`)
+      expect(eventId).toBe(isoDateString)
+    })
+
+    it(`should correctly restore actual Date objects using the marker system`, () => {
+      const serializer = createSerializer()
+
+      const actualDate = new Date(`2024-01-15T10:30:00.000Z`)
+
+      const transaction: OfflineTransaction = {
+        id: `tx-1`,
+        createdAt: new Date(`2024-01-01T00:00:00.000Z`),
+        status: `pending`,
+        mutationFnName: `syncData`,
+        mutations: [
+          {
+            globalKey: `key-1`,
+            type: `insert`,
+            modified: {
+              id: `1`,
+              createdAt: actualDate, // This is an actual Date object
+              name: `Test`,
+            },
+            original: null,
+            collection: mockCollection,
+            mutationId: `mut-1`,
+            key: `1`,
+            changes: {},
+            metadata: undefined,
+            syncMetadata: {},
+            optimistic: true,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          } as PendingMutation,
+        ],
+      }
+
+      const serialized = serializer.serialize(transaction)
+      const deserialized = serializer.deserialize(serialized)
+
+      // The createdAt should be restored as a Date object
+      const restoredDate = deserialized.mutations[0]!.modified.createdAt
+      expect(restoredDate).toBeInstanceOf(Date)
+      expect(restoredDate.toISOString()).toBe(actualDate.toISOString())
+    })
+
+    it(`should handle mixed Date objects and ISO string values correctly`, () => {
+      const serializer = createSerializer()
+
+      const actualDate = new Date(`2024-06-15T14:00:00.000Z`)
+      const isoStringValue = `2024-01-15T10:30:00.000Z` // Plain string, not a Date
+
+      const transaction: OfflineTransaction = {
+        id: `tx-1`,
+        createdAt: new Date(`2024-01-01T00:00:00.000Z`),
+        status: `pending`,
+        mutationFnName: `syncData`,
+        mutations: [
+          {
+            globalKey: `key-1`,
+            type: `insert`,
+            modified: {
+              id: `1`,
+              timestamp: actualDate, // Actual Date object
+              scheduledFor: isoStringValue, // Plain string that looks like ISO date
+              notes: `Meeting scheduled`,
+            },
+            original: null,
+            collection: mockCollection,
+            mutationId: `mut-1`,
+            key: `1`,
+            changes: {},
+            metadata: undefined,
+            syncMetadata: {},
+            optimistic: true,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          } as PendingMutation,
+        ],
+      }
+
+      const serialized = serializer.serialize(transaction)
+      const deserialized = serializer.deserialize(serialized)
+
+      const modified = deserialized.mutations[0]!.modified
+
+      // The actual Date should be restored as Date
+      expect(modified.timestamp).toBeInstanceOf(Date)
+      expect(modified.timestamp.toISOString()).toBe(actualDate.toISOString())
+
+      // The string should remain a string
+      expect(typeof modified.scheduledFor).toBe(`string`)
+      expect(modified.scheduledFor).toBe(isoStringValue)
+    })
+
+    it(`should not corrupt nested ISO string values`, () => {
+      const serializer = createSerializer()
+
+      const transaction: OfflineTransaction = {
+        id: `tx-1`,
+        createdAt: new Date(`2024-01-01T00:00:00.000Z`),
+        status: `pending`,
+        mutationFnName: `syncData`,
+        mutations: [
+          {
+            globalKey: `key-1`,
+            type: `insert`,
+            modified: {
+              id: `1`,
+              metadata: {
+                // Nested ISO strings should also be preserved
+                lastSync: `2024-03-20T08:00:00.000Z`,
+                importedFrom: `external-system`,
+              },
+            },
+            original: null,
+            collection: mockCollection,
+            mutationId: `mut-1`,
+            key: `1`,
+            changes: {},
+            metadata: undefined,
+            syncMetadata: {},
+            optimistic: true,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          } as PendingMutation,
+        ],
+      }
+
+      const serialized = serializer.serialize(transaction)
+      const deserialized = serializer.deserialize(serialized)
+
+      const lastSync = deserialized.mutations[0]!.modified.metadata.lastSync
+      expect(typeof lastSync).toBe(`string`)
+      expect(lastSync).toBe(`2024-03-20T08:00:00.000Z`)
+    })
+
+    it(`should correctly restore top-level createdAt as Date`, () => {
+      const serializer = createSerializer()
+
+      const transactionDate = new Date(`2024-05-15T12:30:00.000Z`)
+
+      const transaction: OfflineTransaction = {
+        id: `tx-1`,
+        createdAt: transactionDate,
+        status: `pending`,
+        mutationFnName: `syncData`,
+        mutations: [
+          {
+            globalKey: `key-1`,
+            type: `insert`,
+            modified: { id: `1` },
+            original: null,
+            collection: mockCollection,
+            mutationId: `mut-1`,
+            key: `1`,
+            changes: {},
+            metadata: undefined,
+            syncMetadata: {},
+            optimistic: true,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          } as PendingMutation,
+        ],
+      }
+
+      const serialized = serializer.serialize(transaction)
+      const deserialized = serializer.deserialize(serialized)
+
+      // Top-level createdAt should be a Date object
+      expect(deserialized.createdAt).toBeInstanceOf(Date)
+      expect(deserialized.createdAt.toISOString()).toBe(
+        transactionDate.toISOString(),
+      )
+    })
+  })
+})
diff --git a/packages/offline-transactions/tests/harness.ts b/packages/offline-transactions/tests/harness.ts
new file mode 100644
index 000000000..f12a026c6
--- /dev/null
+++ b/packages/offline-transactions/tests/harness.ts
@@ -0,0 +1,269 @@
+import { createCollection } from '@tanstack/db'
+import { startOfflineExecutor } from '../src/index'
+import type { ChangeMessage, Collection, PendingMutation } from '@tanstack/db'
+import type {
+  LeaderElection,
+  OfflineConfig,
+  OfflineMutationFnParams,
+  StorageAdapter,
+} from '../src/types'
+
+export class FakeStorageAdapter implements StorageAdapter {
+  private store = new Map<string, string>()
+
+  async get(key: string): Promise<string | null> {
+    return Promise.resolve(this.store.has(key) ? this.store.get(key)! : null)
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    this.store.set(key, value)
+    return Promise.resolve()
+  }
+
+  async delete(key: string): Promise<void> {
+    this.store.delete(key)
+    return Promise.resolve()
+  }
+
+  async keys(): Promise<Array<string>> {
+    return Promise.resolve(Array.from(this.store.keys()))
+  }
+
+  async clear(): Promise<void> {
+    this.store.clear()
+    return Promise.resolve()
+  }
+
+  snapshot(): Record<string, string> {
+    return Object.fromEntries(this.store.entries())
+  }
+}
+
+export interface TestItem {
+  id: string
+  value: string
+  completed: boolean
+  updatedAt: Date
+}
+
+interface SyncController {
+  begin: () => void
+  write: (message: Omit<ChangeMessage<TestItem>, `key`>) => void
+  commit: () => void
+  markReady: () => void
+}
+
+class FakeLeaderElection implements LeaderElection {
+  private listeners = new Set<(isLeader: boolean) => void>()
+  private leader = true
+
+  // eslint-disable-next-line
+  async requestLeadership(): Promise<boolean> {
+    this.notify(this.leader)
+    return this.leader
+  }
+
+  releaseLeadership(): void {
+    this.leader = false
+    this.notify(false)
+  }
+
+  isLeader(): boolean {
+    return this.leader
+  }
+
+  onLeadershipChange(callback: (isLeader: boolean) => void): () => void {
+    this.listeners.add(callback)
+    // Don't call callback immediately - matches real BaseLeaderElection behavior
+    return () => {
+      this.listeners.delete(callback)
+    }
+  }
+
+  setLeader(isLeader: boolean): void {
+    this.leader = isLeader
+    this.notify(isLeader)
+  }
+
+  private notify(isLeader: boolean): void {
+    for (const listener of this.listeners) {
+      listener(isLeader)
+    }
+  }
+}
+
+type TestMutationFn = (
+  params: OfflineMutationFnParams & { attempt: number },
+) => Promise<any>
+
+interface TestOfflineEnvironmentOptions {
+  mutationFnName?: string
+  mutationFn?: TestMutationFn
+  storage?: FakeStorageAdapter
+  config?: Partial<OfflineConfig>
+}
+
+function createDefaultCollection(): {
+  collection: Collection<TestItem, string, {}>
+  controller: SyncController
+} {
+  let controller!: SyncController
+
+  const collection = createCollection<TestItem, string, {}>({
+    id: `test-items`,
+    getKey: (item) => item.id,
+    startSync: true,
+    sync: {
+      sync: (params) => {
+        controller = {
+          begin: params.begin,
+          write: params.write,
+          commit: params.commit,
+          markReady: params.markReady,
+        }
+        params.markReady()
+      },
+    },
+  })
+
+  return { collection, controller }
+}
+
+export function createTestOfflineEnvironment(
+  options: TestOfflineEnvironmentOptions = {},
+): {
+  executor: ReturnType<typeof startOfflineExecutor>
+  storage: FakeStorageAdapter
+  collection: Collection<TestItem, string, {}>
+  mutationFnName: string
+  mutationCalls: Array<OfflineMutationFnParams & { attempt: number }>
+  waitForLeader: () => Promise<void>
+  leader: FakeLeaderElection
+  serverState: Map<string, TestItem>
+  applyMutations: (mutations: Array<PendingMutation<TestItem>>) => void
+} {
+  const mutationFnName = options.mutationFnName ?? `syncData`
+  const storage = options.storage ?? new FakeStorageAdapter()
+  const mutationCalls: Array<OfflineMutationFnParams & { attempt: number }> = []
+  const attemptCounter = new Map<string, number>()
+
+  const { collection, controller } = createDefaultCollection()
+  const serverState = new Map<string, TestItem>()
+
+  const applyMutations = (mutations: Array<PendingMutation<TestItem>>) => {
+    controller.begin()
+
+    for (const mutation of mutations) {
+      switch (mutation.type) {
+        case `insert`: {
+          const value = mutation.modified
+          serverState.set(value.id, value)
+          controller.write({ type: `insert`, value })
+          break
+        }
+        case `update`: {
+          const value = mutation.modified
+          serverState.set(value.id, value)
+          controller.write({ type: `update`, value })
+          break
+        }
+        case `delete`: {
+          const original = mutation.original as TestItem | undefined
+          const fallbackIdFromKey =
+            (typeof mutation.key === `string` ? mutation.key : undefined) ??
+            mutation.globalKey.split(`:`).pop()
+          const id = original?.id ?? fallbackIdFromKey
+
+          if (!id) {
+            throw new Error(
+              `Unable to determine id for delete mutation ${mutation.globalKey}`,
+            )
+          }
+
+          const previousValue = serverState.get(id)
+          serverState.delete(id)
+
+          const emittedValue: TestItem = previousValue ?? {
+            id,
+            value: original?.value ?? ``,
+            completed: original?.completed ?? false,
+            updatedAt: original?.updatedAt ?? new Date(),
+          }
+
+          controller.write({
+            type: `delete`,
+            value: emittedValue,
+          })
+          break
+        }
+      }
+    }
+
+    controller.commit()
+    controller.markReady()
+  }
+
+  const defaultMutation: TestMutationFn = (params) => {
+    const mutations = params.transaction.mutations as Array<
+      PendingMutation<TestItem>
+    >
+
+    applyMutations(mutations)
+
+    return { ok: true, mutations }
+  }
+
+  const mutationFn: TestMutationFn = options.mutationFn ?? defaultMutation
+
+  const leader = new FakeLeaderElection()
+
+  const wrappedMutation = async (
+    params: OfflineMutationFnParams,
+  ): Promise<any> => {
+    const currentAttempt = (attemptCounter.get(params.idempotencyKey) ?? 0) + 1
+    attemptCounter.set(params.idempotencyKey, currentAttempt)
+    const extendedParams = { ...params, attempt: currentAttempt }
+    mutationCalls.push(extendedParams)
+    return mutationFn(extendedParams)
+  }
+
+  const config: OfflineConfig = {
+    collections: {
+      ...(options.config?.collections ?? {}),
+      [collection.id]: collection,
+    },
+    mutationFns: {
+      ...(options.config?.mutationFns ?? {}),
+      [mutationFnName]: wrappedMutation,
+    },
+    storage,
+    maxConcurrency: options.config?.maxConcurrency,
+    jitter: options.config?.jitter,
+    beforeRetry: options.config?.beforeRetry,
+    onUnknownMutationFn: options.config?.onUnknownMutationFn,
+    onLeadershipChange: options.config?.onLeadershipChange,
+    leaderElection: options.config?.leaderElection ?? leader,
+  }
+
+  const executor = startOfflineExecutor(config)
+
+  const waitForLeader = async () => {
+    // Wait for full initialization including loading pending transactions
+    await executor.waitForInit()
+    if (!executor.isOfflineEnabled) {
+      throw new Error(`Executor did not become leader`)
+    }
+  }
+
+  return {
+    executor,
+    storage,
+    collection,
+    mutationFnName,
+    mutationCalls,
+    waitForLeader,
+    leader,
+    serverState,
+    applyMutations,
+  }
+}
diff --git a/packages/offline-transactions/tests/leader-failover.test.ts b/packages/offline-transactions/tests/leader-failover.test.ts
new file mode 100644
index 000000000..dd041f5fa
--- /dev/null
+++ b/packages/offline-transactions/tests/leader-failover.test.ts
@@ -0,0 +1,508 @@
+import { describe, expect, it } from 'vitest'
+import { FakeStorageAdapter, createTestOfflineEnvironment } from './harness'
+import type { TestItem } from './harness'
+import type { PendingMutation } from '@tanstack/db'
+import type { LeaderElection } from '../src/types'
+
+const flushMicrotasks = () => new Promise((resolve) => setTimeout(resolve, 0))
+
+const waitUntil = async (
+  predicate: () => boolean | Promise<boolean>,
+  timeoutMs = 5000,
+  intervalMs = 20,
+) => {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (await predicate()) {
+      return
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs))
+  }
+  throw new Error(`Timed out waiting for condition`)
+}
+
+describe(`leader failover`, () => {
+  it(`transfers pending transactions from old leader to new leader`, async () => {
+    const sharedStorage = new FakeStorageAdapter()
+
+    // Create executor A as leader
+    const envA = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      mutationFn: () => {
+        throw new Error(`offline`)
+      },
+    })
+
+    await envA.waitForLeader()
+    expect(envA.executor.isOfflineEnabled).toBe(true)
+
+    // Create a transaction that will fail and persist to outbox
+    const txA = envA.executor.createOfflineTransaction({
+      mutationFnName: envA.mutationFnName,
+      autoCommit: false,
+    })
+
+    txA.mutate(() => {
+      envA.collection.insert({
+        id: `failover-item`,
+        value: `transfer-me`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+
+    // Start commit - it will fail and persist to outbox
+    txA.commit()
+
+    // Wait for transaction to be in outbox
+    await waitUntil(async () => {
+      const outbox = await envA.executor.peekOutbox()
+      return outbox.length === 1
+    })
+
+    // Verify A has the transaction in outbox
+    const outboxA = await envA.executor.peekOutbox()
+    expect(outboxA).toHaveLength(1)
+    expect(outboxA[0].id).toBe(txA.id)
+
+    // Now create executor B with same storage, starts as non-leader
+    const envB = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      mutationFn: (params) => {
+        const mutations = params.transaction.mutations as Array<
+          PendingMutation<TestItem>
+        >
+        envB.applyMutations(mutations)
+        return { ok: true, mutations }
+      },
+      config: {
+        leaderElection: undefined, // Will use its own leader
+      },
+    })
+
+    // Initially B is non-leader
+    envB.leader.setLeader(false)
+    await flushMicrotasks()
+    expect(envB.executor.isOfflineEnabled).toBe(false)
+
+    // Switch leadership: A loses, B gains
+    envA.leader.setLeader(false)
+    envB.leader.setLeader(true)
+
+    await flushMicrotasks()
+
+    // Verify leadership states
+    expect(envA.executor.isOfflineEnabled).toBe(false)
+    expect(envB.executor.isOfflineEnabled).toBe(true)
+
+    // Wait for B to execute the transaction
+    await waitUntil(() => envB.mutationCalls.length >= 1)
+
+    // Verify B executed the transaction
+    expect(envB.mutationCalls).toHaveLength(1)
+    expect(envB.serverState.get(`failover-item`)?.value).toBe(`transfer-me`)
+
+    // Verify outbox is now empty (transaction completed)
+    await waitUntil(async () => {
+      const outbox = await envB.executor.peekOutbox()
+      return outbox.length === 0
+    })
+
+    envA.executor.dispose()
+    envB.executor.dispose()
+  })
+
+  it(`non-leader remains passive until it becomes leader`, async () => {
+    const sharedStorage = new FakeStorageAdapter()
+
+    // Create executor A as leader with a failing mutation
+    const envA = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      mutationFn: () => {
+        throw new Error(`offline`)
+      },
+    })
+
+    await envA.waitForLeader()
+
+    // Create executor B as non-leader with working mutation
+    const envB = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      mutationFn: (params) => {
+        const mutations = params.transaction.mutations as Array<
+          PendingMutation<TestItem>
+        >
+        envB.applyMutations(mutations)
+        return { ok: true, mutations }
+      },
+    })
+
+    envB.leader.setLeader(false)
+    await flushMicrotasks()
+
+    // A creates a transaction that goes to outbox
+    const txA = envA.executor.createOfflineTransaction({
+      mutationFnName: envA.mutationFnName,
+      autoCommit: false,
+    })
+
+    txA.mutate(() => {
+      envA.collection.insert({
+        id: `passive-test`,
+        value: `waiting`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+
+    txA.commit()
+
+    await waitUntil(async () => {
+      const outbox = await envA.executor.peekOutbox()
+      return outbox.length === 1
+    })
+
+    // B should not execute while non-leader
+    await flushMicrotasks()
+    await new Promise((resolve) => setTimeout(resolve, 100))
+    expect(envB.mutationCalls).toHaveLength(0)
+
+    // Now make B the leader
+    envA.leader.setLeader(false)
+    envB.leader.setLeader(true)
+    await flushMicrotasks()
+
+    // B should now execute the transaction
+    await waitUntil(() => envB.mutationCalls.length >= 1)
+    expect(envB.mutationCalls).toHaveLength(1)
+    expect(envB.serverState.get(`passive-test`)?.value).toBe(`waiting`)
+
+    envA.executor.dispose()
+    envB.executor.dispose()
+  })
+
+  it(`transaction survives multiple leadership transitions`, async () => {
+    const sharedStorage = new FakeStorageAdapter()
+
+    // Create executor A (will fail)
+    const envA = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      mutationFn: () => {
+        throw new Error(`A fails`)
+      },
+    })
+
+    await envA.waitForLeader()
+
+    // Create transaction from A
+    const txA = envA.executor.createOfflineTransaction({
+      mutationFnName: envA.mutationFnName,
+      autoCommit: false,
+    })
+
+    txA.mutate(() => {
+      envA.collection.insert({
+        id: `survivor`,
+        value: `resilient`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+
+    txA.commit()
+
+    await waitUntil(async () => {
+      const outbox = await envA.executor.peekOutbox()
+      return outbox.length === 1
+    })
+
+    // Create executor B (will also fail)
+    const envB = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      mutationFn: () => {
+        throw new Error(`B fails`)
+      },
+    })
+
+    envB.leader.setLeader(false)
+
+    // Create executor C (will succeed)
+    const envC = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      mutationFn: (params) => {
+        const mutations = params.transaction.mutations as Array<
+          PendingMutation<TestItem>
+        >
+        envC.applyMutations(mutations)
+        return { ok: true, mutations }
+      },
+    })
+
+    envC.leader.setLeader(false)
+
+    // Transfer to B
+    envA.leader.setLeader(false)
+    envB.leader.setLeader(true)
+    await flushMicrotasks()
+
+    // Wait for B to attempt and fail
+    await waitUntil(() => envB.mutationCalls.length >= 1)
+    expect(envB.mutationCalls).toHaveLength(1)
+
+    // Transaction should still be in outbox
+    const outboxB = await envB.executor.peekOutbox()
+    expect(outboxB).toHaveLength(1)
+
+    // Transfer to C
+    envB.leader.setLeader(false)
+    envC.leader.setLeader(true)
+    await flushMicrotasks()
+
+    // Wait for C to execute successfully
+    await waitUntil(() => envC.mutationCalls.length >= 1)
+    expect(envC.mutationCalls).toHaveLength(1)
+    expect(envC.serverState.get(`survivor`)?.value).toBe(`resilient`)
+
+    // Outbox should now be empty
+    await waitUntil(async () => {
+      const outbox = await envC.executor.peekOutbox()
+      return outbox.length === 0
+    })
+
+    envA.executor.dispose()
+    envB.executor.dispose()
+    envC.executor.dispose()
+  })
+
+  it(`new transactions from non-leader go online-only`, async () => {
+    const sharedStorage = new FakeStorageAdapter()
+
+    const envA = createTestOfflineEnvironment({
+      storage: sharedStorage,
+    })
+
+    await envA.waitForLeader()
+
+    const envB = createTestOfflineEnvironment({
+      storage: sharedStorage,
+    })
+
+    envB.leader.setLeader(false)
+    await flushMicrotasks()
+
+    // Create transaction from non-leader B
+    const txB = envB.executor.createOfflineTransaction({
+      mutationFnName: envB.mutationFnName,
+      autoCommit: false,
+    })
+
+    txB.mutate(() => {
+      envB.collection.insert({
+        id: `online-only`,
+        value: `no-outbox`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+
+    await txB.commit()
+
+    // Should have executed immediately without outbox
+    expect(envB.mutationCalls).toHaveLength(1)
+
+    // Should NOT be in outbox
+    const outbox = await envB.executor.peekOutbox()
+    expect(outbox).toHaveLength(0)
+
+    // Now create transaction from leader A
+    const txA = envA.executor.createOfflineTransaction({
+      mutationFnName: envA.mutationFnName,
+      autoCommit: false,
+    })
+
+    txA.mutate(() => {
+      envA.collection.insert({
+        id: `outbox-item`,
+        value: `in-outbox`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+
+    await txA.commit()
+
+    // A's transaction should have gone through outbox
+    expect(envA.mutationCalls.length).toBeGreaterThanOrEqual(1)
+
+    envA.executor.dispose()
+    envB.executor.dispose()
+  })
+
+  it(`calls onLeadershipChange callback on both gain and loss`, async () => {
+    const sharedStorage = new FakeStorageAdapter()
+    const callbackCalls: Array<{ executor: string; isLeader: boolean }> = []
+
+    const envA = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      config: {
+        onLeadershipChange: (isLeader) => {
+          callbackCalls.push({ executor: `A`, isLeader })
+        },
+      },
+    })
+
+    await envA.waitForLeader()
+
+    // A should have been called with true
+    expect(callbackCalls).toContainEqual({ executor: `A`, isLeader: true })
+
+    const envB = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      config: {
+        onLeadershipChange: (isLeader) => {
+          callbackCalls.push({ executor: `B`, isLeader })
+        },
+      },
+    })
+
+    envB.leader.setLeader(false)
+    await flushMicrotasks()
+
+    // B should have been called with false
+    expect(callbackCalls).toContainEqual({ executor: `B`, isLeader: false })
+
+    const beforeLength = callbackCalls.length
+
+    // Transfer leadership
+    envA.leader.setLeader(false)
+    await flushMicrotasks()
+    envB.leader.setLeader(true)
+    await flushMicrotasks()
+
+    // Both should have been called
+    const newCalls = callbackCalls.slice(beforeLength)
+    expect(newCalls).toContainEqual({ executor: `A`, isLeader: false })
+    expect(newCalls).toContainEqual({ executor: `B`, isLeader: true })
+
+    envA.executor.dispose()
+    envB.executor.dispose()
+  })
+
+  it(`calls onLeadershipChange exactly once during initialization`, async () => {
+    const callbackCalls: Array<boolean> = []
+
+    const env = createTestOfflineEnvironment({
+      config: {
+        onLeadershipChange: (isLeader) => {
+          callbackCalls.push(isLeader)
+        },
+      },
+    })
+
+    await env.waitForLeader()
+
+    // Should be called exactly once with true during initialization
+    expect(callbackCalls).toEqual([true])
+
+    // Wait a bit to ensure no duplicate calls
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    // Still should only have one call
+    expect(callbackCalls).toEqual([true])
+
+    env.executor.dispose()
+  })
+
+  it(`does not double-replay transactions when leadership callback fires after requestLeadership returns`, async () => {
+    // This test simulates the race condition in WebLocksLeader where:
+    // 1. requestLeadership() returns true immediately when lock is available
+    // 2. But notifyLeadershipChange(true) is called asynchronously when lock is actually acquired
+    // 3. This used to cause loadAndReplayTransactions() to be called twice
+    //
+    // The fix is to set isLeaderState = true synchronously in requestLeadership()
+    // so the async notifyLeadershipChange(true) doesn't trigger listeners again
+
+    const sharedStorage = new FakeStorageAdapter()
+
+    // Create a leader election that simulates the race condition:
+    // requestLeadership() returns true immediately but the callback fires later
+    class AsyncLeaderElection implements LeaderElection {
+      private listeners = new Set<(isLeader: boolean) => void>()
+      private leader = false
+
+      async requestLeadership(): Promise<boolean> {
+        // Simulate: lock is available, will return true immediately
+        // but the actual lock acquisition (and callback) happens async
+        setTimeout(() => {
+          // This simulates the fire-and-forget navigator.locks.request() completing
+          this.leader = true
+          for (const listener of this.listeners) {
+            listener(true)
+          }
+        }, 10)
+
+        return true // Returns immediately before callback fires
+      }
+
+      releaseLeadership(): void {
+        this.leader = false
+        for (const listener of this.listeners) {
+          listener(false)
+        }
+      }
+
+      isLeader(): boolean {
+        return this.leader
+      }
+
+      onLeadershipChange(callback: (isLeader: boolean) => void): () => void {
+        this.listeners.add(callback)
+        return () => {
+          this.listeners.delete(callback)
+        }
+      }
+    }
+
+    // Pre-populate storage with a pending transaction
+    const transactionId = `test-tx-${Date.now()}`
+    const transaction = {
+      id: transactionId,
+      mutationFnName: `syncData`,
+      idempotencyKey: `test-idempotency-key`,
+      payload: {},
+      createdAt: Date.now(),
+    }
+    await sharedStorage.set(
+      `offline-executor:transaction:${transactionId}`,
+      JSON.stringify(transaction),
+    )
+
+    let replayCount = 0
+    const env = createTestOfflineEnvironment({
+      storage: sharedStorage,
+      mutationFn: async (params) => {
+        replayCount++
+        const mutations = params.transaction.mutations as Array<
+          PendingMutation<TestItem>
+        >
+        env.applyMutations(mutations)
+        return { ok: true, mutations }
+      },
+      config: {
+        leaderElection: new AsyncLeaderElection(),
+      },
+    })
+
+    // Wait for potential double-replay to occur
+    // If the bug exists, the callback would fire ~10ms after initialization
+    // and cause a second replay
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    // The mutation should only be called once, not twice
+    // Note: In this specific test, the pre-populated transaction might not
+    // match the expected schema, so we check the replay count didn't double
+    expect(replayCount).toBeLessThanOrEqual(1)
+
+    env.executor.dispose()
+  })
+})
diff --git a/packages/offline-transactions/tests/offline-e2e.test.ts b/packages/offline-transactions/tests/offline-e2e.test.ts
new file mode 100644
index 000000000..290ef07ce
--- /dev/null
+++ b/packages/offline-transactions/tests/offline-e2e.test.ts
@@ -0,0 +1,666 @@
+import { describe, expect, it } from 'vitest'
+import { NonRetriableError } from '../src/types'
+import { FakeStorageAdapter, createTestOfflineEnvironment } from './harness'
+import type { TestItem } from './harness'
+import type { OfflineMutationFnParams } from '../src/types'
+import type { PendingMutation } from '@tanstack/db'
+
+const flushMicrotasks = () => new Promise((resolve) => setTimeout(resolve, 0))
+
+const waitUntil = async (
+  predicate: () => boolean | Promise<boolean>,
+  timeoutMs = 5000,
+  intervalMs = 20,
+) => {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (await predicate()) {
+      return
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs))
+  }
+  throw new Error(`Timed out waiting for condition`)
+}
+
+describe(`offline executor end-to-end`, () => {
+  it(`resolves waiting promises for successful transactions`, async () => {
+    const env = createTestOfflineEnvironment()
+
+    await env.waitForLeader()
+
+    const offlineTx = env.executor.createOfflineTransaction({
+      mutationFnName: env.mutationFnName,
+      autoCommit: false,
+    })
+
+    const waitPromise = env.executor.waitForTransactionCompletion(offlineTx.id)
+
+    const now = new Date()
+    offlineTx.mutate(() => {
+      env.collection.insert({
+        id: `item-1`,
+        value: `hello`,
+        completed: false,
+        updatedAt: now,
+      })
+    })
+
+    await offlineTx.commit()
+
+    await expect(waitPromise).resolves.toBeUndefined()
+
+    const outboxEntries = await env.executor.peekOutbox()
+    expect(outboxEntries).toEqual([])
+
+    expect(env.mutationCalls.length).toBeGreaterThanOrEqual(1)
+    const call = env.mutationCalls[env.mutationCalls.length - 1]!
+    expect(call.transaction.mutations).toHaveLength(1)
+    expect(call.transaction.mutations[0].key).toBe(`item-1`)
+    const stored = env.collection.get(`item-1`)
+    expect(stored?.value).toBe(`hello`)
+    expect(env.serverState.get(`item-1`)?.value).toBe(`hello`)
+
+    env.executor.dispose()
+  })
+
+  it(`retries queued transactions when backend resumes`, async () => {
+    let online = false
+    const env = createTestOfflineEnvironment({
+      mutationFn: (params) => {
+        const runtimeOnline = online
+        const mutations = params.transaction.mutations as Array<
+          PendingMutation<TestItem>
+        >
+        if (!runtimeOnline) {
+          throw new Error(`offline`)
+        }
+        env.applyMutations(mutations)
+        return { ok: true, mutations }
+      },
+    })
+
+    await env.waitForLeader()
+
+    const offlineTx = env.executor.createOfflineTransaction({
+      mutationFnName: env.mutationFnName,
+      autoCommit: false,
+    })
+
+    const now = new Date()
+    offlineTx.mutate(() => {
+      env.collection.insert({
+        id: `queued-item`,
+        value: `queued`,
+        completed: false,
+        updatedAt: now,
+      })
+    })
+
+    // Commit should not throw for retriable errors - it persists to outbox
+    const commitPromise = offlineTx.commit()
+
+    // Wait a bit for the transaction to be processed
+    await flushMicrotasks()
+
+    // Check that the transaction was attempted once
+    expect(env.mutationCalls.length).toBe(1)
+
+    // Check that the transaction is in the outbox (persisted for retry)
+    let outboxEntries = await env.executor.peekOutbox()
+    expect(outboxEntries.length).toBe(1)
+    expect(outboxEntries[0].id).toBe(offlineTx.id)
+
+    // Now bring the system back online
+    online = true
+    env.executor.notifyOnline()
+
+    // Wait for the retry to succeed
+    await waitUntil(() => env.mutationCalls.length >= 2)
+
+    // The original commit promise should now resolve
+    await expect(commitPromise).resolves.toBeDefined()
+
+    // Check that the transaction completed successfully
+    outboxEntries = await env.executor.peekOutbox()
+    expect(outboxEntries).toEqual([])
+
+    outboxEntries = await env.executor.peekOutbox()
+    expect(outboxEntries).toEqual([])
+    expect(env.mutationCalls.length).toBeGreaterThanOrEqual(2)
+    expect(env.serverState.get(`queued-item`)?.value).toBe(`queued`)
+
+    env.executor.dispose()
+  })
+
+  it(`rejects waiting promises for permanent failures and rolls back optimistic state`, async () => {
+    const error = new NonRetriableError(`permanent`)
+    const env = createTestOfflineEnvironment({
+      mutationFn: () => {
+        throw error
+      },
+    })
+
+    await env.waitForLeader()
+
+    const offlineTx = env.executor.createOfflineTransaction({
+      mutationFnName: env.mutationFnName,
+      autoCommit: false,
+    })
+
+    const waitPromise = env.executor.waitForTransactionCompletion(offlineTx.id)
+
+    offlineTx.mutate(() => {
+      env.collection.insert({
+        id: `perm-item`,
+        value: `nope`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+
+    await expect(offlineTx.commit()).rejects.toThrow(`permanent`)
+    await expect(waitPromise).rejects.toThrow(`permanent`)
+
+    const outboxEntries = await env.executor.peekOutbox()
+    expect(outboxEntries).toEqual([])
+    expect(env.collection.get(`perm-item`)).toBeUndefined()
+    expect(env.serverState.get(`perm-item`)).toBeUndefined()
+
+    env.executor.dispose()
+  })
+
+  it(`replays persisted transactions on startup`, async () => {
+    const storage = new FakeStorageAdapter()
+
+    const offlineErrorEnv = createTestOfflineEnvironment({
+      storage,
+      mutationFn: () => {
+        throw new Error(`offline`)
+      },
+    })
+
+    await offlineErrorEnv.waitForLeader()
+
+    const offlineTx = offlineErrorEnv.executor.createOfflineTransaction({
+      mutationFnName: offlineErrorEnv.mutationFnName,
+      autoCommit: false,
+    })
+
+    offlineTx.mutate(() => {
+      offlineErrorEnv.collection.insert({
+        id: `persisted`,
+        value: `from-outbox`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+
+    // Start the commit - it will persist to outbox and keep retrying
+    // We don't await it because it will never complete (mutation always fails)
+    offlineTx.commit()
+
+    // Wait for the transaction to be persisted to outbox
+    await waitUntil(async () => {
+      const pendingEntries = await offlineErrorEnv.executor.peekOutbox()
+      return pendingEntries.length === 1
+    }, 5000)
+
+    // Verify it's in the outbox
+    const outboxEntries = await offlineErrorEnv.executor.peekOutbox()
+    expect(outboxEntries.length).toBe(1)
+    expect(outboxEntries[0].id).toBe(offlineTx.id)
+
+    offlineErrorEnv.executor.dispose()
+
+    const replayEnv = createTestOfflineEnvironment({
+      storage,
+      mutationFn: (params: OfflineMutationFnParams & { attempt: number }) => {
+        const mutations = params.transaction.mutations as Array<
+          PendingMutation<TestItem>
+        >
+        replayEnv.applyMutations(mutations)
+        return { ok: true, mutations }
+      },
+    })
+
+    await replayEnv.waitForLeader()
+    await waitUntil(async () => {
+      const entries = await replayEnv.executor.peekOutbox()
+      return entries.length === 0
+    })
+    expect(replayEnv.serverState.get(`persisted`)?.value).toBe(`from-outbox`)
+
+    replayEnv.executor.dispose()
+  })
+
+  // TODO: Fix this test - hanging at await commitFirst after resolving mutation
+  it.skip(`serializes transactions targeting the same key`, async () => {
+    console.log(`[TEST] Starting serializes transactions test`)
+    const pendingResolvers: Array<() => void> = []
+    const env = createTestOfflineEnvironment({
+      mutationFn: async (params) => {
+        const mutations = params.transaction.mutations as Array<
+          PendingMutation<TestItem>
+        >
+
+        await new Promise<void>((resolve) => {
+          pendingResolvers.push(() => {
+            env.applyMutations(mutations)
+            resolve()
+          })
+        })
+
+        return { ok: true, mutations }
+      },
+    })
+
+    console.log(`[TEST] Waiting for leader...`)
+    await env.waitForLeader()
+    console.log(`[TEST] Leader ready`)
+
+    const firstTx = env.executor.createOfflineTransaction({
+      mutationFnName: env.mutationFnName,
+      autoCommit: false,
+    })
+    console.log(`[TEST] Created first transaction:`, firstTx.id)
+    const waitFirst = env.executor.waitForTransactionCompletion(firstTx.id)
+    firstTx.mutate(() => {
+      env.collection.insert({
+        id: `shared`,
+        value: `v1`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+    console.log(`[TEST] Committing first transaction`)
+    const commitFirst = firstTx.commit()
+
+    await flushMicrotasks()
+    console.log(
+      `[TEST] After flush, mutationCalls:`,
+      env.mutationCalls.length,
+      `resolvers:`,
+      pendingResolvers.length,
+    )
+    expect(env.mutationCalls.length).toBe(1)
+    expect(pendingResolvers.length).toBe(1)
+
+    console.log(`[TEST] Creating second transaction`)
+    const secondTx = env.executor.createOfflineTransaction({
+      mutationFnName: env.mutationFnName,
+      autoCommit: false,
+    })
+    console.log(`[TEST] Created second transaction:`, secondTx.id)
+    const waitSecond = env.executor.waitForTransactionCompletion(secondTx.id)
+    secondTx.mutate(() => {
+      env.collection.update(`shared`, (draft) => {
+        draft.value = `v2`
+        draft.updatedAt = new Date()
+      })
+    })
+    console.log(`[TEST] Committing second transaction`)
+    const commitSecond = secondTx.commit()
+
+    await flushMicrotasks()
+    console.log(
+      `[TEST] After second flush, mutationCalls:`,
+      env.mutationCalls.length,
+      `resolvers:`,
+      pendingResolvers.length,
+    )
+    expect(env.mutationCalls.length).toBe(1)
+    expect(pendingResolvers.length).toBe(1)
+
+    console.log(`[TEST] Resolving first transaction`)
+    pendingResolvers.shift()?.()
+    console.log(`[TEST] Awaiting commitFirst`)
+    await commitFirst
+    console.log(`[TEST] Awaiting waitFirst`)
+    await waitFirst
+    console.log(`[TEST] Waiting for second mutation call...`)
+    await waitUntil(() => env.mutationCalls.length >= 2)
+    console.log(`[TEST] Second mutation called!`)
+    expect(pendingResolvers.length).toBe(1)
+
+    pendingResolvers.shift()?.()
+    await commitSecond
+    await waitSecond
+    await waitUntil(() => env.serverState.get(`shared`)?.value === `v2`)
+
+    env.executor.dispose()
+  })
+
+  it(`processes mutations sequentially regardless of keys`, async () => {
+    const pendingResolvers: Array<() => void> = []
+    // eslint-disable-next-line prefer-const
+    let env: ReturnType<typeof createTestOfflineEnvironment> | undefined
+
+    const deferredMutation = async (
+      params: OfflineMutationFnParams & { attempt: number },
+    ) => {
+      const runtimeEnv = env
+      if (!runtimeEnv) {
+        throw new Error(`env not initialized`)
+      }
+
+      const mutations = params.transaction.mutations as Array<
+        PendingMutation<TestItem>
+      >
+
+      await new Promise<void>((resolve) => {
+        pendingResolvers.push(() => {
+          runtimeEnv.applyMutations(mutations)
+          resolve()
+        })
+      })
+
+      return { ok: true, mutations }
+    }
+
+    env = createTestOfflineEnvironment({
+      mutationFn: deferredMutation,
+    })
+
+    const runtimeEnv = env
+
+    await runtimeEnv.waitForLeader()
+
+    const firstTx = runtimeEnv.executor.createOfflineTransaction({
+      mutationFnName: runtimeEnv.mutationFnName,
+      autoCommit: false,
+    })
+    const waitFirst = runtimeEnv.executor.waitForTransactionCompletion(
+      firstTx.id,
+    )
+    firstTx.mutate(() => {
+      runtimeEnv.collection.insert({
+        id: `first`,
+        value: `1`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+    const commitFirst = firstTx.commit()
+
+    const secondTx = runtimeEnv.executor.createOfflineTransaction({
+      mutationFnName: runtimeEnv.mutationFnName,
+      autoCommit: false,
+    })
+    const waitSecond = runtimeEnv.executor.waitForTransactionCompletion(
+      secondTx.id,
+    )
+    secondTx.mutate(() => {
+      runtimeEnv.collection.insert({
+        id: `second`,
+        value: `2`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+    const commitSecond = secondTx.commit()
+
+    await flushMicrotasks()
+    // With sequential processing, only one transaction executes at a time
+    expect(runtimeEnv.mutationCalls.length).toBe(1)
+    expect(pendingResolvers.length).toBe(1)
+
+    // Resolve the first transaction
+    pendingResolvers.shift()?.()
+    // Wait for the second transaction to start
+    await waitUntil(() => runtimeEnv.mutationCalls.length >= 2)
+    expect(pendingResolvers.length).toBe(1)
+
+    // Resolve the second transaction
+    pendingResolvers.shift()?.()
+    await Promise.all([commitFirst, commitSecond, waitFirst, waitSecond])
+
+    expect(runtimeEnv.serverState.get(`first`)?.value).toBe(`1`)
+    expect(runtimeEnv.serverState.get(`second`)?.value).toBe(`2`)
+
+    runtimeEnv.executor.dispose()
+  })
+
+  it(`executes transactions online-only when not leader`, async () => {
+    const env = createTestOfflineEnvironment()
+
+    // Set this tab to not be leader
+    env.leader.setLeader(false)
+
+    // Give the executor a moment to react to leadership change
+    await flushMicrotasks()
+
+    // Should not be offline enabled when not leader
+    expect(env.executor.isOfflineEnabled).toBe(false)
+
+    const offlineTx = env.executor.createOfflineTransaction({
+      mutationFnName: env.mutationFnName,
+      autoCommit: false,
+    })
+
+    const now = new Date()
+    offlineTx.mutate(() => {
+      env.collection.insert({
+        id: `non-leader-item`,
+        value: `online-only`,
+        completed: false,
+        updatedAt: now,
+      })
+    })
+
+    // Should execute immediately online without persisting to outbox
+    await offlineTx.commit()
+
+    // Should have called the mutation function
+    expect(env.mutationCalls.length).toBe(1)
+    const call = env.mutationCalls[0]!
+    expect(call.transaction.mutations).toHaveLength(1)
+    expect(call.transaction.mutations[0].key).toBe(`non-leader-item`)
+
+    // Should have applied to both local and server state
+    expect(env.collection.get(`non-leader-item`)?.value).toBe(`online-only`)
+    expect(env.serverState.get(`non-leader-item`)?.value).toBe(`online-only`)
+
+    // Should NOT have persisted to outbox
+    const outboxEntries = await env.executor.peekOutbox()
+    expect(outboxEntries).toEqual([])
+
+    env.executor.dispose()
+  })
+
+  it(`should restore optimistic state to collection on startup`, async () => {
+    // This test verifies that optimistic state IS restored to the collection
+    // when the page is refreshed while offline (e.g., with pending transactions).
+    //
+    // After page refresh, the collection should still show the optimistic data
+    // from pending transactions, providing a seamless offline UX.
+
+    const storage = new FakeStorageAdapter()
+
+    // Create a promise that never resolves - simulates offline/stuck mutation
+    const mutationPromise = () => new Promise<void>(() => {})
+
+    // First environment: Create a transaction that gets stuck (simulating offline)
+    const firstEnv = createTestOfflineEnvironment({
+      storage,
+      mutationFn: async () => {
+        // This mutation will hang forever, simulating offline state
+        await mutationPromise()
+        throw new Error(`Should not reach here in first env`)
+      },
+    })
+
+    await firstEnv.waitForLeader()
+
+    const offlineTx = firstEnv.executor.createOfflineTransaction({
+      mutationFnName: firstEnv.mutationFnName,
+      autoCommit: false,
+    })
+
+    // Apply optimistic update
+    offlineTx.mutate(() => {
+      firstEnv.collection.insert({
+        id: `optimistic-item`,
+        value: `should-persist`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+
+    // Verify the optimistic update is visible in the collection
+    expect(firstEnv.collection.get(`optimistic-item`)?.value).toBe(
+      `should-persist`,
+    )
+
+    // Start commit - it will persist to outbox and start (but not complete) execution
+    offlineTx.commit()
+
+    // Wait for the transaction to be persisted to outbox
+    await waitUntil(async () => {
+      const pendingEntries = await firstEnv.executor.peekOutbox()
+      return pendingEntries.length === 1
+    }, 5000)
+
+    // Verify it's in the outbox
+    const outboxEntries = await firstEnv.executor.peekOutbox()
+    expect(outboxEntries.length).toBe(1)
+    expect(outboxEntries[0].id).toBe(offlineTx.id)
+
+    // Verify the mutation data is properly serialized
+    expect(outboxEntries[0].mutations.length).toBe(1)
+    expect(outboxEntries[0].mutations[0].type).toBe(`insert`)
+
+    // Dispose first environment (simulating page refresh)
+    firstEnv.executor.dispose()
+
+    // Create a new environment with a deferred mutation to control timing
+    let secondEnvResolveMutation: (() => void) | null = null
+    const secondEnvMutationPromise = () =>
+      new Promise<void>((resolve) => {
+        secondEnvResolveMutation = resolve
+      })
+
+    const secondEnv = createTestOfflineEnvironment({
+      storage,
+      mutationFn: async (params) => {
+        // Wait for explicit resolution
+        await secondEnvMutationPromise()
+        const mutations = params.transaction.mutations as Array<
+          PendingMutation<TestItem>
+        >
+        secondEnv.applyMutations(mutations)
+        return { ok: true, mutations }
+      },
+    })
+
+    await secondEnv.waitForLeader()
+
+    // At this point, the optimistic state should be restored to the collection
+    // The transaction is loaded from storage, and the optimistic mutations
+    // are applied to the collection immediately
+    const restoredItem = secondEnv.collection.get(`optimistic-item`)
+
+    // The optimistic state should be restored from persisted transactions
+    expect(restoredItem?.value).toBe(`should-persist`)
+
+    // Verify the transaction IS still in the outbox (data was persisted correctly)
+    const secondEnvOutbox = await secondEnv.executor.peekOutbox()
+    expect(secondEnvOutbox.length).toBe(1)
+    expect(secondEnvOutbox[0].mutations[0].type).toBe(`insert`)
+
+    // Now complete the mutation to verify the data eventually syncs
+    secondEnvResolveMutation!()
+
+    await waitUntil(async () => {
+      const entries = await secondEnv.executor.peekOutbox()
+      return entries.length === 0
+    })
+
+    // After sync completes, the item appears (but this is too late for offline UX)
+    expect(secondEnv.serverState.get(`optimistic-item`)?.value).toBe(
+      `should-persist`,
+    )
+
+    secondEnv.executor.dispose()
+  })
+
+  it(`should rollback restored optimistic state on permanent failure after page refresh`, async () => {
+    // This test verifies that optimistic state restored from persisted transactions
+    // is properly rolled back when the transaction fails permanently (NonRetriableError).
+    //
+    // Scenario: User creates transaction offline, refreshes page, transaction fails permanently
+    // Expected: Optimistic state should be visible initially, then removed after failure
+
+    const storage = new FakeStorageAdapter()
+
+    // First environment: Create a transaction that gets stuck (simulating offline)
+    const mutationPromise = () => new Promise<void>(() => {})
+
+    const firstEnv = createTestOfflineEnvironment({
+      storage,
+      mutationFn: async () => {
+        await mutationPromise()
+        throw new Error(`Should not reach here in first env`)
+      },
+    })
+
+    await firstEnv.waitForLeader()
+
+    const offlineTx = firstEnv.executor.createOfflineTransaction({
+      mutationFnName: firstEnv.mutationFnName,
+      autoCommit: false,
+    })
+
+    // Apply optimistic update
+    offlineTx.mutate(() => {
+      firstEnv.collection.insert({
+        id: `ghost-item`,
+        value: `will-fail`,
+        completed: false,
+        updatedAt: new Date(),
+      })
+    })
+
+    // Verify the optimistic update is visible
+    expect(firstEnv.collection.get(`ghost-item`)?.value).toBe(`will-fail`)
+
+    // Start commit - it will persist to outbox
+    offlineTx.commit()
+
+    // Wait for the transaction to be persisted
+    await waitUntil(async () => {
+      const pendingEntries = await firstEnv.executor.peekOutbox()
+      return pendingEntries.length === 1
+    }, 5000)
+
+    // Dispose first environment (simulating page refresh)
+    firstEnv.executor.dispose()
+
+    // Create a new environment where the mutation fails permanently
+    const secondEnv = createTestOfflineEnvironment({
+      storage,
+      mutationFn: () => {
+        throw new NonRetriableError(`Server rejected mutation permanently`)
+      },
+    })
+
+    await secondEnv.waitForLeader()
+
+    // Optimistic state should be restored immediately after initialization
+    expect(secondEnv.collection.get(`ghost-item`)?.value).toBe(`will-fail`)
+
+    // Wait for the transaction to fail and be removed from outbox
+    await waitUntil(async () => {
+      const entries = await secondEnv.executor.peekOutbox()
+      return entries.length === 0
+    }, 5000)
+
+    // After permanent failure, the optimistic state should be rolled back
+    // The item should no longer exist in the collection
+    expect(secondEnv.collection.get(`ghost-item`)).toBeUndefined()
+
+    // And it should not exist on the server either
+    expect(secondEnv.serverState.get(`ghost-item`)).toBeUndefined()
+
+    secondEnv.executor.dispose()
+  })
+})
diff --git a/packages/offline-transactions/tests/setup.ts b/packages/offline-transactions/tests/setup.ts
new file mode 100644
index 000000000..3a7c60e50
--- /dev/null
+++ b/packages/offline-transactions/tests/setup.ts
@@ -0,0 +1,67 @@
+import { vi } from 'vitest'
+
+// Mock browser APIs that might not be available in test environment
+Object.defineProperty(global, `crypto`, {
+  value: {
+    randomUUID: () => Math.random().toString(36).substring(2, 15),
+  },
+})
+
+Object.defineProperty(global, `navigator`, {
+  value: {
+    onLine: true,
+    locks: {
+      request: vi.fn().mockResolvedValue(false),
+    },
+  },
+})
+
+Object.defineProperty(global, `BroadcastChannel`, {
+  value: vi.fn().mockImplementation(() => ({
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    postMessage: vi.fn(),
+    close: vi.fn(),
+  })),
+})
+
+Object.defineProperty(global, `indexedDB`, {
+  value: {
+    open: vi.fn().mockReturnValue({
+      onerror: null,
+      onsuccess: null,
+      onupgradeneeded: null,
+      result: null,
+      error: new Error(`IndexedDB not available in test environment`),
+    }),
+  },
+})
+
+Object.defineProperty(global, `localStorage`, {
+  value: {
+    getItem: vi.fn(),
+    setItem: vi.fn(),
+    removeItem: vi.fn(),
+    key: vi.fn(),
+    length: 0,
+  },
+})
+
+Object.defineProperty(global, `document`, {
+  value: {
+    visibilityState: `visible`,
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+  },
+})
+
+Object.defineProperty(global, `window`, {
+  value: {
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    setTimeout: global.setTimeout,
+    clearTimeout: global.clearTimeout,
+    setInterval: global.setInterval,
+    clearInterval: global.clearInterval,
+  },
+})
diff --git a/packages/offline-transactions/tests/storage-failure.test.ts b/packages/offline-transactions/tests/storage-failure.test.ts
new file mode 100644
index 000000000..dfac008a9
--- /dev/null
+++ b/packages/offline-transactions/tests/storage-failure.test.ts
@@ -0,0 +1,387 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createCollection } from '@tanstack/db'
+import {
+  IndexedDBAdapter,
+  LocalStorageAdapter,
+  startOfflineExecutor,
+} from '../src/index'
+import type { OfflineConfig, StorageDiagnostic } from '../src/types'
+
+const waitUntil = async (
+  predicate: () => boolean | Promise<boolean>,
+  timeoutMs = 5000,
+  intervalMs = 20,
+) => {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (await predicate()) {
+      return
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs))
+  }
+  throw new Error(`Timed out waiting for condition`)
+}
+
+describe(`storage failure handling`, () => {
+  let mockCollection: any
+  let mockMutationFn: any
+  let baseConfig: OfflineConfig
+
+  beforeEach(() => {
+    mockCollection = createCollection({
+      id: `test-collection`,
+      getKey: (item: any) => item.id,
+      sync: {
+        sync: () => {},
+      },
+    })
+
+    mockMutationFn = vi.fn().mockResolvedValue(undefined)
+
+    baseConfig = {
+      collections: {
+        'test-collection': mockCollection,
+      },
+      mutationFns: {
+        syncData: mockMutationFn,
+      },
+    }
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it(`falls back to localStorage when IndexedDB fails with SecurityError`, async () => {
+    // Mock IndexedDB to fail with SecurityError
+    const securityError = new Error(`IndexedDB blocked`)
+    securityError.name = `SecurityError`
+
+    vi.spyOn(IndexedDBAdapter, `probe`).mockResolvedValue({
+      available: false,
+      error: securityError,
+    })
+
+    // Mock localStorage to succeed
+    vi.spyOn(LocalStorageAdapter, `probe`).mockReturnValue({
+      available: true,
+    })
+
+    const executor = startOfflineExecutor(baseConfig)
+
+    // Wait for initialization to complete
+    await waitUntil(
+      () => executor.storageDiagnostic.message !== `Initializing storage...`,
+    )
+
+    // Should be in offline mode using localStorage
+    expect(executor.mode).toBe(`offline`)
+    expect(executor.storageDiagnostic.code).toBe(`INDEXEDDB_UNAVAILABLE`)
+    expect(executor.storageDiagnostic.message).toContain(
+      `localStorage fallback`,
+    )
+    expect(executor.storageDiagnostic.error).toBe(securityError)
+
+    executor.dispose()
+  })
+
+  it(`goes online-only when both storage types fail with SecurityError`, async () => {
+    const idbSecurityError = new Error(`IndexedDB blocked`)
+    idbSecurityError.name = `SecurityError`
+
+    const lsSecurityError = new Error(`localStorage blocked`)
+    lsSecurityError.name = `SecurityError`
+
+    vi.spyOn(IndexedDBAdapter, `probe`).mockResolvedValue({
+      available: false,
+      error: idbSecurityError,
+    })
+
+    vi.spyOn(LocalStorageAdapter, `probe`).mockReturnValue({
+      available: false,
+      error: lsSecurityError,
+    })
+
+    let capturedDiagnostic: StorageDiagnostic | undefined
+
+    const config: OfflineConfig = {
+      ...baseConfig,
+      onStorageFailure: (diagnostic) => {
+        capturedDiagnostic = diagnostic
+      },
+    }
+
+    const executor = startOfflineExecutor(config)
+
+    await waitUntil(
+      () => executor.storageDiagnostic.message !== `Initializing storage...`,
+    )
+
+    // Should be in online-only mode
+    expect(executor.mode).toBe(`online-only`)
+    expect(executor.storageDiagnostic.code).toBe(`STORAGE_BLOCKED`)
+    expect(executor.storageDiagnostic.message).toContain(`private mode`)
+    expect(executor.isOfflineEnabled).toBe(false)
+
+    // onStorageFailure callback should have been called
+    expect(capturedDiagnostic).toBeDefined()
+    expect(capturedDiagnostic?.code).toBe(`STORAGE_BLOCKED`)
+
+    executor.dispose()
+  })
+
+  it(`goes online-only when storage quota is exceeded`, async () => {
+    const idbQuotaError = new Error(`Quota exceeded`)
+    idbQuotaError.name = `QuotaExceededError`
+
+    const lsQuotaError = new Error(`Quota exceeded`)
+    lsQuotaError.name = `QuotaExceededError`
+
+    vi.spyOn(IndexedDBAdapter, `probe`).mockResolvedValue({
+      available: false,
+      error: idbQuotaError,
+    })
+
+    vi.spyOn(LocalStorageAdapter, `probe`).mockReturnValue({
+      available: false,
+      error: lsQuotaError,
+    })
+
+    let capturedDiagnostic: StorageDiagnostic | undefined
+
+    const config: OfflineConfig = {
+      ...baseConfig,
+      onStorageFailure: (diagnostic) => {
+        capturedDiagnostic = diagnostic
+      },
+    }
+
+    const executor = startOfflineExecutor(config)
+
+    await waitUntil(
+      () => executor.storageDiagnostic.message !== `Initializing storage...`,
+    )
+
+    // Should be in online-only mode with QUOTA_EXCEEDED
+    expect(executor.mode).toBe(`online-only`)
+    expect(executor.storageDiagnostic.code).toBe(`QUOTA_EXCEEDED`)
+    expect(executor.storageDiagnostic.message).toContain(`quota exceeded`)
+
+    // onStorageFailure callback should have been called
+    expect(capturedDiagnostic).toBeDefined()
+    expect(capturedDiagnostic?.code).toBe(`QUOTA_EXCEEDED`)
+
+    executor.dispose()
+  })
+
+  it(`goes online-only with unknown error for other storage failures`, async () => {
+    const idbUnknownError = new Error(`Something went wrong`)
+    idbUnknownError.name = `InvalidStateError`
+
+    const lsUnknownError = new Error(`Something else went wrong`)
+
+    vi.spyOn(IndexedDBAdapter, `probe`).mockResolvedValue({
+      available: false,
+      error: idbUnknownError,
+    })
+
+    vi.spyOn(LocalStorageAdapter, `probe`).mockReturnValue({
+      available: false,
+      error: lsUnknownError,
+    })
+
+    const executor = startOfflineExecutor(baseConfig)
+
+    await waitUntil(
+      () => executor.storageDiagnostic.message !== `Initializing storage...`,
+    )
+
+    // Should be in online-only mode with UNKNOWN_ERROR
+    expect(executor.mode).toBe(`online-only`)
+    expect(executor.storageDiagnostic.code).toBe(`UNKNOWN_ERROR`)
+    expect(executor.storageDiagnostic.message).toContain(`unknown error`)
+
+    executor.dispose()
+  })
+
+  it(`bypasses probe when custom storage adapter is provided`, async () => {
+    const probeSpy = vi.spyOn(IndexedDBAdapter, `probe`)
+    const lsProbeSpy = vi.spyOn(LocalStorageAdapter, `probe`)
+
+    // Create a custom storage adapter
+    const customStorage = {
+      get: vi.fn().mockResolvedValue(null),
+      set: vi.fn().mockResolvedValue(undefined),
+      delete: vi.fn().mockResolvedValue(undefined),
+      keys: vi.fn().mockResolvedValue([]),
+      clear: vi.fn().mockResolvedValue(undefined),
+    }
+
+    const config: OfflineConfig = {
+      ...baseConfig,
+      storage: customStorage,
+    }
+
+    const executor = startOfflineExecutor(config)
+
+    await waitUntil(
+      () => executor.storageDiagnostic.message !== `Initializing storage...`,
+    )
+
+    // Should be in offline mode
+    expect(executor.mode).toBe(`offline`)
+    expect(executor.storageDiagnostic.code).toBe(`STORAGE_AVAILABLE`)
+    expect(executor.storageDiagnostic.message).toContain(`custom storage`)
+
+    // Probe methods should NOT have been called
+    expect(probeSpy).not.toHaveBeenCalled()
+    expect(lsProbeSpy).not.toHaveBeenCalled()
+
+    executor.dispose()
+  })
+
+  it(`executes transactions online-only when storage fails`, async () => {
+    // Force both storage types to fail
+    const error = new Error(`Storage blocked`)
+    error.name = `SecurityError`
+
+    vi.spyOn(IndexedDBAdapter, `probe`).mockResolvedValue({
+      available: false,
+      error,
+    })
+
+    vi.spyOn(LocalStorageAdapter, `probe`).mockReturnValue({
+      available: false,
+      error,
+    })
+
+    let mutationCalled = false
+    const mutationFn = vi.fn().mockImplementation(() => {
+      mutationCalled = true
+      return Promise.resolve({ ok: true })
+    })
+
+    const config: OfflineConfig = {
+      ...baseConfig,
+      mutationFns: {
+        syncData: mutationFn,
+      },
+    }
+
+    const executor = startOfflineExecutor(config)
+
+    await waitUntil(() => executor.mode === `online-only`)
+
+    // Create and execute a transaction
+    const tx = executor.createOfflineTransaction({
+      mutationFnName: `syncData`,
+      autoCommit: false,
+    })
+
+    tx.mutate(() => {
+      mockCollection.insert({ id: `test-1`, value: `test` })
+    })
+
+    await tx.commit()
+
+    // Transaction should have executed immediately
+    expect(mutationCalled).toBe(true)
+    expect(mutationFn).toHaveBeenCalledOnce()
+
+    // Should NOT be in outbox (no storage available)
+    const outbox = await executor.peekOutbox()
+    expect(outbox).toEqual([])
+
+    executor.dispose()
+  })
+
+  it(`allows transactions to succeed even without outbox persistence`, async () => {
+    // Simulate storage failure
+    const error = new Error(`Storage unavailable`)
+    error.name = `SecurityError`
+
+    vi.spyOn(IndexedDBAdapter, `probe`).mockResolvedValue({
+      available: false,
+      error,
+    })
+
+    vi.spyOn(LocalStorageAdapter, `probe`).mockReturnValue({
+      available: false,
+      error,
+    })
+
+    const results: Array<string> = []
+
+    const mutationFn = vi.fn().mockImplementation(() => {
+      results.push(`mutation-executed`)
+      return Promise.resolve({ ok: true })
+    })
+
+    const config: OfflineConfig = {
+      ...baseConfig,
+      mutationFns: {
+        syncData: mutationFn,
+      },
+    }
+
+    const executor = startOfflineExecutor(config)
+
+    await waitUntil(() => executor.mode === `online-only`)
+
+    // Create multiple transactions
+    const tx1 = executor.createOfflineTransaction({
+      mutationFnName: `syncData`,
+      autoCommit: false,
+    })
+    tx1.mutate(() => {
+      mockCollection.insert({ id: `test-1`, value: `first` })
+    })
+
+    const tx2 = executor.createOfflineTransaction({
+      mutationFnName: `syncData`,
+      autoCommit: false,
+    })
+    tx2.mutate(() => {
+      mockCollection.insert({ id: `test-2`, value: `second` })
+    })
+
+    // Both should execute and complete
+    await tx1.commit()
+    await tx2.commit()
+
+    expect(results).toHaveLength(2)
+    expect(mutationFn).toHaveBeenCalledTimes(2)
+
+    executor.dispose()
+  })
+
+  it(`handles mixed failure scenarios - IndexedDB generic error, localStorage SecurityError`, async () => {
+    const idbError = new Error(`Database corrupted`)
+    idbError.name = `DatabaseError`
+
+    const lsError = new Error(`localStorage blocked`)
+    lsError.name = `SecurityError`
+
+    vi.spyOn(IndexedDBAdapter, `probe`).mockResolvedValue({
+      available: false,
+      error: idbError,
+    })
+
+    vi.spyOn(LocalStorageAdapter, `probe`).mockReturnValue({
+      available: false,
+      error: lsError,
+    })
+
+    const executor = startOfflineExecutor(baseConfig)
+
+    await waitUntil(
+      () => executor.storageDiagnostic.message !== `Initializing storage...`,
+    )
+
+    // Should detect SecurityError and use STORAGE_BLOCKED
+    expect(executor.mode).toBe(`online-only`)
+    expect(executor.storageDiagnostic.code).toBe(`STORAGE_BLOCKED`)
+
+    executor.dispose()
+  })
+})
diff --git a/packages/offline-transactions/tsconfig.json b/packages/offline-transactions/tsconfig.json
new file mode 100644
index 000000000..648131b1e
--- /dev/null
+++ b/packages/offline-transactions/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "."
+  },
+  "include": ["src/**/*", "tests/**/*", "*.ts"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/packages/offline-transactions/vite.config.ts b/packages/offline-transactions/vite.config.ts
new file mode 100644
index 000000000..87883e4ce
--- /dev/null
+++ b/packages/offline-transactions/vite.config.ts
@@ -0,0 +1,22 @@
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import packageJson from './package.json'
+
+const config = defineConfig({
+  test: {
+    name: packageJson.name,
+    dir: `./tests`,
+    environment: `jsdom`,
+    coverage: { enabled: true, provider: `istanbul`, include: [`src/**/*`] },
+    typecheck: { enabled: true },
+  },
+})
+
+export default mergeConfig(
+  config,
+  tanstackViteConfig({
+    entry: [`./src/index.ts`, `./src/react-native/index.ts`],
+    srcDir: `./src`,
+    externalDeps: [`react-native`, `@react-native-community/netinfo`],
+  }),
+)
diff --git a/packages/offline-transactions/vitest.config.ts b/packages/offline-transactions/vitest.config.ts
new file mode 100644
index 000000000..4ade54490
--- /dev/null
+++ b/packages/offline-transactions/vitest.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: `jsdom`,
+    setupFiles: [`./tests/setup.ts`],
+  },
+})
diff --git a/packages/powersync-db-collection/CHANGELOG.md b/packages/powersync-db-collection/CHANGELOG.md
new file mode 100644
index 000000000..369da445e
--- /dev/null
+++ b/packages/powersync-db-collection/CHANGELOG.md
@@ -0,0 +1,243 @@
+# @tanstack/powersync-db-collection
+
+## 0.1.28
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 0.1.27
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 0.1.26
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 0.1.25
+
+### Patch Changes
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 0.1.24
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 0.1.23
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 0.1.22
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 0.1.21
+
+### Patch Changes
+
+- Added support for tracking collection operation metadata in PowerSync CrudEntry operations. ([#999](https://github.com/TanStack/db/pull/999))
+
+  ```typescript
+  // Schema config
+  const APP_SCHEMA = new Schema({
+    documents: new Table(
+      {
+        name: column.text,
+
+        created_at: column.text,
+      },
+      {
+        // Metadata tracking must be enabled on the PowerSync table
+        trackMetadata: true,
+      },
+    ),
+  })
+
+  // ... Other config
+
+  // Collection operations which specify metadata
+  await collection.insert(
+    {
+      id,
+      name: `document`,
+    },
+    // The string version of this will be present in PowerSync `CrudEntry`s during uploads
+    {
+      metadata: {
+        extraInfo: 'Info',
+      },
+    },
+  )
+  ```
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 0.1.20
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 0.1.19
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 0.1.18
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 0.1.17
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 0.1.16
+
+### Patch Changes
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 0.1.15
+
+### Patch Changes
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 0.1.14
+
+### Patch Changes
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/db@0.5.10
+
+## 0.1.13
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+
+## 0.1.12
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+
+## 0.1.11
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+
+## 0.1.10
+
+### Patch Changes
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 0.1.9
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 0.1.8
+
+### Patch Changes
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 0.1.7
+
+### Patch Changes
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 0.1.6
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+
+## 0.1.5
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 0.1.4
+
+### Patch Changes
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.1.3
+
+### Patch Changes
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.1.2
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.1.1
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.1.0
+
+### Minor Changes
+
+- Initial Release ([#747](https://github.com/TanStack/db/pull/747))
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
diff --git a/packages/powersync-db-collection/package.json b/packages/powersync-db-collection/package.json
new file mode 100644
index 000000000..587b3298c
--- /dev/null
+++ b/packages/powersync-db-collection/package.json
@@ -0,0 +1,70 @@
+{
+  "name": "@tanstack/powersync-db-collection",
+  "version": "0.1.28",
+  "description": "PowerSync collection for TanStack DB",
+  "author": "POWERSYNC",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/db.git",
+    "directory": "packages/powersync-db-collection"
+  },
+  "homepage": "https://tanstack.com/db",
+  "keywords": [
+    "powersync",
+    "realtime",
+    "local-first",
+    "sync-engine",
+    "sync",
+    "replication",
+    "opfs",
+    "indexeddb",
+    "localstorage",
+    "optimistic",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "lint": "eslint . --fix",
+    "test": "vitest --run"
+  },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "@tanstack/db": "workspace:*",
+    "@tanstack/store": "^0.8.0",
+    "debug": "^4.4.3",
+    "p-defer": "^4.0.1"
+  },
+  "peerDependencies": {
+    "@powersync/common": "^1.41.0"
+  },
+  "devDependencies": {
+    "@powersync/common": "^1.44.0",
+    "@powersync/node": "^0.15.1",
+    "@types/debug": "^4.1.12",
+    "@vitest/coverage-istanbul": "^3.2.4"
+  }
+}
diff --git a/packages/powersync-db-collection/src/PendingOperationStore.ts b/packages/powersync-db-collection/src/PendingOperationStore.ts
new file mode 100644
index 000000000..96798b07f
--- /dev/null
+++ b/packages/powersync-db-collection/src/PendingOperationStore.ts
@@ -0,0 +1,54 @@
+import pDefer from 'p-defer'
+import type { DiffTriggerOperation } from '@powersync/common'
+import type { DeferredPromise } from 'p-defer'
+
+export type PendingOperation = {
+  tableName: string
+  operation: DiffTriggerOperation
+  id: string
+  timestamp: string
+}
+
+/**
+ * Optimistic mutations have their optimistic state discarded once transactions have
+ * been applied.
+ * We need to ensure that an applied transaction has been observed by the sync diff trigger
+ * before resolving the transaction application call.
+ * This store allows registering a wait for a pending operation to have been observed.
+ */
+export class PendingOperationStore {
+  private pendingOperations = new Map<PendingOperation, DeferredPromise<void>>()
+
+  /**
+   * Globally accessible PendingOperationStore
+   */
+  static GLOBAL = new PendingOperationStore()
+
+  /**
+   * @returns A promise which will resolve once the specified operation has been seen.
+   */
+  waitFor(operation: PendingOperation): Promise<void> {
+    const managedPromise = pDefer<void>()
+    this.pendingOperations.set(operation, managedPromise)
+    return managedPromise.promise
+  }
+
+  /**
+   * Marks a set of operations as seen. This will resolve any pending promises.
+   */
+  resolvePendingFor(operations: Array<PendingOperation>) {
+    for (const operation of operations) {
+      for (const [pendingOp, deferred] of this.pendingOperations.entries()) {
+        if (
+          pendingOp.tableName == operation.tableName &&
+          pendingOp.operation == operation.operation &&
+          pendingOp.id == operation.id &&
+          pendingOp.timestamp == operation.timestamp
+        ) {
+          deferred.resolve()
+          this.pendingOperations.delete(pendingOp)
+        }
+      }
+    }
+  }
+}
diff --git a/packages/powersync-db-collection/src/PowerSyncTransactor.ts b/packages/powersync-db-collection/src/PowerSyncTransactor.ts
new file mode 100644
index 000000000..a45a4c751
--- /dev/null
+++ b/packages/powersync-db-collection/src/PowerSyncTransactor.ts
@@ -0,0 +1,335 @@
+import { sanitizeSQL } from '@powersync/common'
+import DebugModule from 'debug'
+import { PendingOperationStore } from './PendingOperationStore'
+import { asPowerSyncRecord, mapOperationToPowerSync } from './helpers'
+import type { AbstractPowerSyncDatabase, LockContext } from '@powersync/common'
+import type { PendingMutation, Transaction } from '@tanstack/db'
+import type { PendingOperation } from './PendingOperationStore'
+import type {
+  EnhancedPowerSyncCollectionConfig,
+  PowerSyncCollectionMeta,
+} from './definitions'
+
+const debug = DebugModule.debug(`ts/db:powersync`)
+
+export type TransactorOptions = {
+  database: AbstractPowerSyncDatabase
+}
+
+/**
+ * Applies mutations to the PowerSync database. This method is called automatically by the collection's
+ * insert, update, and delete operations. You typically don't need to call this directly unless you
+ * have special transaction requirements.
+ *
+ * @example
+ * ```typescript
+ * // Create a collection
+ * const collection = createCollection(
+ *   powerSyncCollectionOptions<Document>({
+ *     database: db,
+ *     table: APP_SCHEMA.props.documents,
+ *   })
+ * )
+ *
+ * const addTx = createTransaction({
+ *   autoCommit: false,
+ *   mutationFn: async ({ transaction }) => {
+ *     await new PowerSyncTransactor({ database: db }).applyTransaction(transaction)
+ *   },
+ * })
+ *
+ * addTx.mutate(() => {
+ *   for (let i = 0; i < 5; i++) {
+ *     collection.insert({ id: randomUUID(), name: `tx-${i}` })
+ *   }
+ * })
+ *
+ * await addTx.commit()
+ * await addTx.isPersisted.promise
+ * ```
+ *
+ * @param transaction - The transaction containing mutations to apply
+ * @returns A promise that resolves when the mutations have been persisted to PowerSync
+ */
+export class PowerSyncTransactor {
+  database: AbstractPowerSyncDatabase
+  pendingOperationStore: PendingOperationStore
+
+  constructor(options: TransactorOptions) {
+    this.database = options.database
+    this.pendingOperationStore = PendingOperationStore.GLOBAL
+  }
+
+  /**
+   * Persists a {@link Transaction} to the PowerSync SQLite database.
+   */
+  async applyTransaction(transaction: Transaction<any>) {
+    const { mutations } = transaction
+
+    if (mutations.length == 0) {
+      return
+    }
+    /**
+     * The transaction might contain operations for different collections.
+     * We can do some optimizations for single-collection transactions.
+     */
+    const mutationsCollectionIds = mutations.map(
+      (mutation) => mutation.collection.id,
+    )
+    const collectionIds = Array.from(new Set(mutationsCollectionIds))
+    const lastCollectionMutationIndexes = new Map<string, number>()
+    const allCollections = collectionIds
+      .map((id) => mutations.find((mutation) => mutation.collection.id == id)!)
+      .map((mutation) => mutation.collection)
+    for (const collectionId of collectionIds) {
+      lastCollectionMutationIndexes.set(
+        collectionId,
+        mutationsCollectionIds.lastIndexOf(collectionId),
+      )
+    }
+
+    // Check all the observers are ready before taking a lock
+    await Promise.all(
+      allCollections.map(async (collection) => {
+        if (collection.isReady()) {
+          return
+        }
+        await new Promise<void>((resolve) => collection.onFirstReady(resolve))
+      }),
+    )
+
+    // Persist to PowerSync
+    const { whenComplete } = await this.database.writeTransaction(
+      async (tx) => {
+        const pendingOperations: Array<PendingOperation | null> = []
+
+        for (const [index, mutation] of mutations.entries()) {
+          /**
+           * Each collection processes events independently. We need to make sure the
+           * last operation for each collection has been observed.
+           */
+          const shouldWait =
+            index == lastCollectionMutationIndexes.get(mutation.collection.id)
+          switch (mutation.type) {
+            case `insert`:
+              pendingOperations.push(
+                await this.handleInsert(mutation, tx, shouldWait),
+              )
+              break
+            case `update`:
+              pendingOperations.push(
+                await this.handleUpdate(mutation, tx, shouldWait),
+              )
+              break
+            case `delete`:
+              pendingOperations.push(
+                await this.handleDelete(mutation, tx, shouldWait),
+              )
+              break
+          }
+        }
+
+        /**
+         * Return a promise from the writeTransaction, without awaiting it.
+         * This promise will resolve once the entire transaction has been
+         * observed via the diff triggers.
+         * We return without awaiting in order to free the write lock.
+         */
+        return {
+          whenComplete: Promise.all(
+            pendingOperations
+              .filter((op) => !!op)
+              .map((op) => this.pendingOperationStore.waitFor(op)),
+          ),
+        }
+      },
+    )
+
+    // Wait for the change to be observed via the diff trigger
+    await whenComplete
+  }
+
+  protected async handleInsert(
+    mutation: PendingMutation<any>,
+    context: LockContext,
+    waitForCompletion: boolean = false,
+  ): Promise<PendingOperation | null> {
+    debug(`insert`, mutation)
+
+    return this.handleOperationWithCompletion(
+      mutation,
+      context,
+      waitForCompletion,
+      async (tableName, mutation, serializeValue) => {
+        const values = serializeValue(mutation.modified)
+        const keys = Object.keys(values).map((key) => sanitizeSQL`${key}`)
+        const queryParameters = Object.values(values)
+
+        const metadataValue = this.processMutationMetadata(mutation)
+        if (metadataValue != null) {
+          keys.push(`_metadata`)
+          queryParameters.push(metadataValue)
+        }
+
+        await context.execute(
+          `
+        INSERT into ${tableName} 
+            (${keys.join(`, `)}) 
+        VALUES 
+            (${keys.map((_) => `?`).join(`, `)})
+        `,
+          queryParameters,
+        )
+      },
+    )
+  }
+
+  protected async handleUpdate(
+    mutation: PendingMutation<any>,
+    context: LockContext,
+    waitForCompletion: boolean = false,
+  ): Promise<PendingOperation | null> {
+    debug(`update`, mutation)
+
+    return this.handleOperationWithCompletion(
+      mutation,
+      context,
+      waitForCompletion,
+      async (tableName, mutation, serializeValue) => {
+        const values = serializeValue(mutation.modified)
+        const keys = Object.keys(values).map((key) => sanitizeSQL`${key}`)
+        const queryParameters = Object.values(values)
+
+        const metadataValue = this.processMutationMetadata(mutation)
+        if (metadataValue != null) {
+          keys.push(`_metadata`)
+          queryParameters.push(metadataValue)
+        }
+
+        await context.execute(
+          `
+        UPDATE ${tableName} 
+        SET ${keys.map((key) => `${key} = ?`).join(`, `)}
+        WHERE id = ?
+        `,
+          [...queryParameters, asPowerSyncRecord(mutation.modified).id],
+        )
+      },
+    )
+  }
+
+  protected async handleDelete(
+    mutation: PendingMutation<any>,
+    context: LockContext,
+    waitForCompletion: boolean = false,
+  ): Promise<PendingOperation | null> {
+    debug(`update`, mutation)
+
+    return this.handleOperationWithCompletion(
+      mutation,
+      context,
+      waitForCompletion,
+      async (tableName, mutation) => {
+        const metadataValue = this.processMutationMetadata(mutation)
+        if (metadataValue != null) {
+          /**
+           * Delete operations with metadata require a different approach to handle metadata.
+           * This will delete the record.
+           */
+          await context.execute(
+            `
+            UPDATE ${tableName} SET _deleted = TRUE, _metadata = ? WHERE id = ?
+            `,
+            [metadataValue, asPowerSyncRecord(mutation.original).id],
+          )
+        } else {
+          await context.execute(
+            `
+            DELETE FROM ${tableName} WHERE id = ?
+            `,
+            [asPowerSyncRecord(mutation.original).id],
+          )
+        }
+      },
+    )
+  }
+
+  /**
+   * Helper function which wraps a persistence operation by:
+   * - Fetching the mutation's collection's SQLite table details
+   * - Executing the mutation
+   * - Returning the last pending diff operation if required
+   */
+  protected async handleOperationWithCompletion(
+    mutation: PendingMutation<any>,
+    context: LockContext,
+    waitForCompletion: boolean,
+    handler: (
+      tableName: string,
+      mutation: PendingMutation<any>,
+      serializeValue: (value: any) => Record<string, unknown>,
+    ) => Promise<void>,
+  ): Promise<PendingOperation | null> {
+    const { tableName, trackedTableName, serializeValue } =
+      this.getMutationCollectionMeta(mutation)
+
+    await handler(sanitizeSQL`${tableName}`, mutation, serializeValue)
+
+    if (!waitForCompletion) {
+      return null
+    }
+
+    // Need to get the operation in order to wait for it
+    const diffOperation = await context.get<{ id: string; timestamp: string }>(
+      sanitizeSQL`SELECT id, timestamp FROM ${trackedTableName} ORDER BY timestamp DESC LIMIT 1`,
+    )
+    return {
+      tableName,
+      id: diffOperation.id,
+      operation: mapOperationToPowerSync(mutation.type),
+      timestamp: diffOperation.timestamp,
+    }
+  }
+
+  protected getMutationCollectionMeta(
+    mutation: PendingMutation<any>,
+  ): PowerSyncCollectionMeta<any> {
+    if (
+      typeof (mutation.collection.config as any).utils?.getMeta != `function`
+    ) {
+      throw new Error(`Collection is not a PowerSync collection.`)
+    }
+    return (
+      mutation.collection
+        .config as unknown as EnhancedPowerSyncCollectionConfig<any>
+    ).utils.getMeta()
+  }
+
+  /**
+   * Processes collection mutation metadata for persistence to the database.
+   * We only support storing string metadata.
+   * @returns null if no metadata should be stored.
+   */
+  protected processMutationMetadata(
+    mutation: PendingMutation<any>,
+  ): string | null {
+    const { metadataIsTracked } = this.getMutationCollectionMeta(mutation)
+    if (!metadataIsTracked) {
+      // If it's not supported, we don't store metadata.
+      if (typeof mutation.metadata != `undefined`) {
+        // Log a warning if metadata is provided but not tracked.
+        this.database.logger.warn(
+          `Metadata provided for collection ${mutation.collection.id} but the PowerSync table does not track metadata. The PowerSync table should be configured with trackMetadata: true.`,
+          mutation.metadata,
+        )
+      }
+      return null
+    } else if (typeof mutation.metadata == `undefined`) {
+      return null
+    } else if (typeof mutation.metadata == `string`) {
+      return mutation.metadata
+    } else {
+      return JSON.stringify(mutation.metadata)
+    }
+  }
+}
diff --git a/packages/powersync-db-collection/src/definitions.ts b/packages/powersync-db-collection/src/definitions.ts
new file mode 100644
index 000000000..c65fa850e
--- /dev/null
+++ b/packages/powersync-db-collection/src/definitions.ts
@@ -0,0 +1,279 @@
+import type { AbstractPowerSyncDatabase, Table } from '@powersync/common'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type {
+  BaseCollectionConfig,
+  CollectionConfig,
+  InferSchemaOutput,
+} from '@tanstack/db'
+import type {
+  AnyTableColumnType,
+  ExtractedTable,
+  OptionalExtractedTable,
+  PowerSyncRecord,
+} from './helpers'
+
+/**
+ * Small helper which determines the output type if:
+ * - Standard SQLite types are to be used OR
+ * - If the provided schema should be used.
+ */
+export type InferPowerSyncOutputType<
+  TTable extends Table = Table,
+  TSchema extends StandardSchemaV1<PowerSyncRecord> = never,
+> = TSchema extends never ? ExtractedTable<TTable> : InferSchemaOutput<TSchema>
+
+/**
+ * A mapping type for custom serialization of object properties to SQLite-compatible values.
+ *
+ * This type allows you to override, for keys in the input object (`TOutput`), a function that transforms
+ * the value to the corresponding SQLite type (`TSQLite`). Keys not specified will use the default SQLite serialization.
+ *
+ * ## Generics
+ * - `TOutput`: The input object type, representing the row data to be serialized.
+ * - `TSQLite`: The target SQLite-compatible type for each property, typically inferred from the table schema.
+ *
+ * ## Usage
+ * Use this type to define a map of serialization functions for specific keys when you need custom handling
+ * (e.g., converting complex objects, formatting dates, or handling enums).
+ *
+ * Example:
+ * ```ts
+ * const serializer: CustomSQLiteSerializer<MyRowType, MySQLiteType> = {
+ *   createdAt: (date) => date.toISOString(),
+ *   status: (status) => status ? 1 : 0,
+ *   meta: (meta) => JSON.stringify(meta),
+ * };
+ * ```
+ *
+ * ## Behavior
+ * - Each key maps to a function that receives the value and returns the SQLite-compatible value.
+ * - Used by `serializeForSQLite` to override default serialization for specific columns.
+ */
+export type CustomSQLiteSerializer<
+  TOutput extends Record<string, unknown>,
+  TSQLite extends Record<string, unknown>,
+> = Partial<{
+  [Key in keyof TOutput]: (
+    value: TOutput[Key],
+  ) => Key extends keyof TSQLite ? TSQLite[Key] : never
+}>
+
+export type SerializerConfig<
+  TOutput extends Record<string, unknown>,
+  TSQLite extends Record<string, unknown>,
+> = {
+  /**
+   * Optional partial serializer object for customizing how individual columns are serialized for SQLite.
+   *
+   * This should be a partial map of column keys to serialization functions, following the
+   * {@link CustomSQLiteSerializer} type. Each function receives the column value and returns a value
+   * compatible with SQLite storage.
+   *
+   * If not provided for a column, the default behavior is used:
+   *   - `TEXT`: Strings are stored as-is; Dates are converted to ISO strings; other types are JSON-stringified.
+   *   - `INTEGER`/`REAL`: Numbers are stored as-is; booleans are mapped to 1/0.
+   *
+   * Use this option to override serialization for specific columns, such as formatting dates, handling enums,
+   * or serializing complex objects.
+   *
+   * Example:
+   * ```typescript
+   * serializer: {
+   *   createdAt: (date) => date.getTime(), // Store as timestamp
+   *   meta: (meta) => JSON.stringify(meta), // Custom object serialization
+   * }
+   * ```
+   */
+  serializer?: CustomSQLiteSerializer<TOutput, TSQLite>
+
+  /**
+   * Application logic should ensure that incoming synced data is always valid.
+   * Failing to deserialize and apply incoming changes results in data inconsistency - which is a fatal error.
+   * Use this callback to react to deserialization errors.
+   */
+  onDeserializationError: (error: StandardSchemaV1.FailureResult) => void
+}
+
+/**
+ * Config for when TInput and TOutput are both the SQLite types.
+ */
+export type ConfigWithSQLiteTypes = {}
+
+/**
+ * Config where TInput is the SQLite types while TOutput can be defined by TSchema.
+ * We can use the same schema to validate TInput and incoming SQLite changes.
+ */
+export type ConfigWithSQLiteInputType<
+  TTable extends Table,
+  TSchema extends StandardSchemaV1<
+    // TInput is the SQLite types.
+    OptionalExtractedTable<TTable>,
+    AnyTableColumnType<TTable>
+  >,
+> = SerializerConfig<
+  StandardSchemaV1.InferOutput<TSchema>,
+  ExtractedTable<TTable>
+> & {
+  schema: TSchema
+}
+
+/**
+ * Config where TInput and TOutput have arbitrarily typed values.
+ * The keys of the types need to equal the SQLite types.
+ * Since TInput is not the SQLite types, we require a schema in order to deserialize incoming SQLite updates. The schema should validate from SQLite to TOutput.
+ */
+export type ConfigWithArbitraryCollectionTypes<
+  TTable extends Table,
+  TSchema extends StandardSchemaV1<
+    // The input and output must have the same keys, the value types can be arbitrary
+    AnyTableColumnType<TTable>,
+    AnyTableColumnType<TTable>
+  >,
+> = SerializerConfig<
+  StandardSchemaV1.InferOutput<TSchema>,
+  ExtractedTable<TTable>
+> & {
+  schema: TSchema
+  /**
+   * Schema for deserializing and validating input data from the sync stream.
+   *
+   * This schema defines how to transform and validate data coming from SQLite types (as stored in the database)
+   * into the desired output types (`TOutput`) expected by your application or validation logic.
+   *
+   * The generic parameters allow for arbitrary input and output types, so you can specify custom conversion rules
+   * for each column. This is especially useful when your application expects richer types (e.g., Date, enums, objects)
+   * than what SQLite natively supports.
+   *
+   * Use this to ensure that incoming data from the sync stream is properly converted and validated before use.
+   *
+   * Example:
+   * ```typescript
+   * deserializationSchema: z.object({
+   *   createdAt: z.preprocess((val) => new Date(val as string), z.date()),
+   *   meta: z.preprocess((val) => JSON.parse(val as string), z.object({ ... })),
+   * })
+   * ```
+   *
+   * This enables robust type safety and validation for incoming data, bridging the gap between SQLite storage
+   * and your application's expected types.
+   */
+  deserializationSchema: StandardSchemaV1<
+    ExtractedTable<TTable>,
+    StandardSchemaV1.InferOutput<TSchema>
+  >
+}
+export type BasePowerSyncCollectionConfig<
+  TTable extends Table = Table,
+  TSchema extends StandardSchemaV1 = never,
+> = Omit<
+  BaseCollectionConfig<ExtractedTable<TTable>, string, TSchema>,
+  `onInsert` | `onUpdate` | `onDelete` | `getKey`
+> & {
+  /** The PowerSync schema Table definition */
+  table: TTable
+  /** The PowerSync database instance */
+  database: AbstractPowerSyncDatabase
+  /**
+   * The maximum number of documents to read from the SQLite table
+   * in a single batch during the initial sync between PowerSync and the
+   * in-memory TanStack DB collection.
+   *
+   * @remarks
+   * - Defaults to {@link DEFAULT_BATCH_SIZE} if not specified.
+   * - Larger values reduce the number of round trips to the storage
+   *   engine but increase memory usage per batch.
+   * - Smaller values may lower memory usage and allow earlier
+   *   streaming of initial results, at the cost of more query calls.
+   */
+  syncBatchSize?: number
+}
+
+/**
+ * Configuration interface for PowerSync collection options.
+ * @template TTable - The PowerSync table schema definition
+ * @template TSchema - The validation schema type
+ */
+/**
+ * Configuration options for creating a PowerSync collection.
+ *
+ * @example
+ * ```typescript
+ * const APP_SCHEMA = new Schema({
+ *   documents: new Table({
+ *     name: column.text,
+ *   }),
+ * })
+ *
+ * const db = new PowerSyncDatabase({
+ *   database: {
+ *     dbFilename: "test.sqlite",
+ *   },
+ *   schema: APP_SCHEMA,
+ * })
+ *
+ * const collection = createCollection(
+ *   powerSyncCollectionOptions({
+ *     database: db,
+ *     table: APP_SCHEMA.props.documents
+ *   })
+ * )
+ * ```
+ */
+export type PowerSyncCollectionConfig<
+  TTable extends Table = Table,
+  TSchema extends StandardSchemaV1<any> = never,
+> = BasePowerSyncCollectionConfig<TTable, TSchema> &
+  (
+    | ConfigWithSQLiteTypes
+    | ConfigWithSQLiteInputType<TTable, TSchema>
+    | ConfigWithArbitraryCollectionTypes<TTable, TSchema>
+  )
+
+/**
+ * Metadata for the PowerSync Collection.
+ */
+export type PowerSyncCollectionMeta<TTable extends Table = Table> = {
+  /**
+   * The SQLite table representing the collection.
+   */
+  tableName: string
+  /**
+   * The internal table used to track diffs for the collection.
+   */
+  trackedTableName: string
+
+  /**
+   * Serializes a collection value to the SQLite type
+   */
+  serializeValue: (value: any) => ExtractedTable<TTable>
+
+  /**
+   * Whether the PowerSync table tracks metadata.
+   */
+  metadataIsTracked: boolean
+}
+
+/**
+ * A CollectionConfig which includes utilities for PowerSync.
+ */
+export type EnhancedPowerSyncCollectionConfig<
+  TTable extends Table,
+  OutputType extends Record<string, unknown> = Record<string, unknown>,
+  TSchema extends StandardSchemaV1 = never,
+> = CollectionConfig<OutputType, string, TSchema> & {
+  id?: string
+  utils: PowerSyncCollectionUtils<TTable>
+  schema?: TSchema
+}
+
+/**
+ * Collection-level utilities for PowerSync.
+ */
+export type PowerSyncCollectionUtils<TTable extends Table = Table> = {
+  getMeta: () => PowerSyncCollectionMeta<TTable>
+}
+
+/**
+ * Default value for {@link PowerSyncCollectionConfig#syncBatchSize}.
+ */
+export const DEFAULT_BATCH_SIZE = 1000
diff --git a/packages/powersync-db-collection/src/helpers.ts b/packages/powersync-db-collection/src/helpers.ts
new file mode 100644
index 000000000..af33d259a
--- /dev/null
+++ b/packages/powersync-db-collection/src/helpers.ts
@@ -0,0 +1,112 @@
+import { DiffTriggerOperation } from '@powersync/common'
+import type {
+  BaseColumnType,
+  ExtractColumnValueType,
+  Table,
+} from '@powersync/common'
+
+/**
+ * All PowerSync table records include a UUID `id` column.
+ */
+export type PowerSyncRecord = {
+  id: string
+  [key: string]: unknown
+}
+
+/**
+ * Utility type: If T includes null, also allow undefined (to support optional fields in insert/update operations).
+ * PowerSync records are typically typed as `string | null`, where insert
+ * and update operations may also allow not specifying a value at all (optional).
+ */
+type WithUndefinedIfNull<T> = null extends T ? T | undefined : T
+type OptionalIfUndefined<T> = {
+  [K in keyof T as undefined extends T[K] ? K : never]?: T[K]
+} & {
+  [K in keyof T as undefined extends T[K] ? never : K]: T[K]
+}
+
+/**
+ * Provides the base column types for a table. This excludes the `id` column.
+ */
+export type ExtractedTableColumns<TTable extends Table> = {
+  [K in keyof TTable[`columnMap`]]: ExtractColumnValueType<
+    TTable[`columnMap`][K]
+  >
+}
+/**
+ * Utility type that extracts the typed structure of a table based on its column definitions.
+ * Maps each column to its corresponding TypeScript type using ExtractColumnValueType.
+ *
+ * @template TTable - The PowerSync table definition
+ * @example
+ * ```typescript
+ * const table = new Table({
+ *   name: column.text,
+ *   age: column.integer
+ * })
+ * type TableType = ExtractedTable<typeof table>
+ * // Results in: { id: string, name: string | null, age: number | null }
+ * ```
+ */
+export type ExtractedTable<TTable extends Table> =
+  ExtractedTableColumns<TTable> & {
+    id: string
+  }
+
+export type OptionalExtractedTable<TTable extends Table> = OptionalIfUndefined<{
+  [K in keyof TTable[`columnMap`]]: WithUndefinedIfNull<
+    ExtractColumnValueType<TTable[`columnMap`][K]>
+  >
+}> & {
+  id: string
+}
+
+/**
+ * Maps the schema of TTable to a type which
+ * requires the keys be equal, but the values can have any value type.
+ */
+export type AnyTableColumnType<TTable extends Table> = {
+  [K in keyof TTable[`columnMap`]]: any
+} & { id: string }
+
+export function asPowerSyncRecord(record: any): PowerSyncRecord {
+  if (typeof record.id !== `string`) {
+    throw new Error(`Record must have a string id field`)
+  }
+  return record as PowerSyncRecord
+}
+
+//  Helper type to ensure the keys of TOutput match the Table columns
+export type MapBaseColumnType<TOutput> = {
+  [Key in keyof TOutput]: BaseColumnType<any>
+}
+
+/**
+ * Maps {@link DiffTriggerOperation} to TanstackDB operations
+ */
+export function mapOperation(operation: DiffTriggerOperation) {
+  switch (operation) {
+    case DiffTriggerOperation.INSERT:
+      return `insert`
+    case DiffTriggerOperation.UPDATE:
+      return `update`
+    case DiffTriggerOperation.DELETE:
+      return `delete`
+  }
+}
+
+/**
+ * Maps TanstackDB operations to  {@link DiffTriggerOperation}
+ */
+export function mapOperationToPowerSync(operation: string) {
+  switch (operation) {
+    case `insert`:
+      return DiffTriggerOperation.INSERT
+    case `update`:
+      return DiffTriggerOperation.UPDATE
+    case `delete`:
+      return DiffTriggerOperation.DELETE
+    default:
+      throw new Error(`Unknown operation ${operation} received`)
+  }
+}
diff --git a/packages/powersync-db-collection/src/index.ts b/packages/powersync-db-collection/src/index.ts
new file mode 100644
index 000000000..6879d7a22
--- /dev/null
+++ b/packages/powersync-db-collection/src/index.ts
@@ -0,0 +1,3 @@
+export * from './definitions'
+export * from './powersync'
+export * from './PowerSyncTransactor'
diff --git a/packages/powersync-db-collection/src/powersync.ts b/packages/powersync-db-collection/src/powersync.ts
new file mode 100644
index 000000000..bc2e85bc2
--- /dev/null
+++ b/packages/powersync-db-collection/src/powersync.ts
@@ -0,0 +1,480 @@
+import { DiffTriggerOperation, sanitizeSQL } from '@powersync/common'
+import { PendingOperationStore } from './PendingOperationStore'
+import { PowerSyncTransactor } from './PowerSyncTransactor'
+import { DEFAULT_BATCH_SIZE } from './definitions'
+import { asPowerSyncRecord, mapOperation } from './helpers'
+import { convertTableToSchema } from './schema'
+import { serializeForSQLite } from './serialization'
+import type {
+  AnyTableColumnType,
+  ExtractedTable,
+  ExtractedTableColumns,
+  MapBaseColumnType,
+  OptionalExtractedTable,
+} from './helpers'
+import type {
+  BasePowerSyncCollectionConfig,
+  ConfigWithArbitraryCollectionTypes,
+  ConfigWithSQLiteInputType,
+  ConfigWithSQLiteTypes,
+  CustomSQLiteSerializer,
+  EnhancedPowerSyncCollectionConfig,
+  InferPowerSyncOutputType,
+  PowerSyncCollectionConfig,
+  PowerSyncCollectionUtils,
+} from './definitions'
+import type { PendingOperation } from './PendingOperationStore'
+import type { SyncConfig } from '@tanstack/db'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { Table, TriggerDiffRecord } from '@powersync/common'
+
+/**
+ * Creates PowerSync collection options for use with a standard Collection.
+ *
+ * @template TTable - The SQLite-based typing
+ * @template TSchema - The validation schema type (optionally supports a custom input type)
+ * @param config - Configuration options for the PowerSync collection
+ * @returns Collection options with utilities
+ */
+
+// Overload 1: No schema is provided
+
+/**
+ * Creates a PowerSync collection configuration with basic default validation.
+ * Input and Output types are the SQLite column types.
+ *
+ * @example
+ * ```typescript
+ * const APP_SCHEMA = new Schema({
+ *   documents: new Table({
+ *     name: column.text,
+ *   }),
+ * })
+ *
+ * type Document = (typeof APP_SCHEMA)["types"]["documents"]
+ *
+ * const db = new PowerSyncDatabase({
+ *   database: {
+ *     dbFilename: "test.sqlite",
+ *   },
+ *   schema: APP_SCHEMA,
+ * })
+ *
+ * const collection = createCollection(
+ *   powerSyncCollectionOptions({
+ *     database: db,
+ *     table: APP_SCHEMA.props.documents
+ *   })
+ * )
+ * ```
+ */
+export function powerSyncCollectionOptions<TTable extends Table = Table>(
+  config: BasePowerSyncCollectionConfig<TTable, never> & ConfigWithSQLiteTypes,
+): EnhancedPowerSyncCollectionConfig<
+  TTable,
+  OptionalExtractedTable<TTable>,
+  never
+>
+
+// Overload 2: Schema is provided and the TInput matches SQLite types.
+
+/**
+ * Creates a PowerSync collection configuration with schema validation.
+ *
+ * The input types satisfy the SQLite column types.
+ *
+ * The output types are defined by the provided schema. This schema can enforce additional
+ * validation or type transforms.
+ * Arbitrary output typed mutations are encoded to SQLite for persistence. We provide a basic standard
+ * serialization implementation to serialize column values. Custom or advanced types require providing additional
+ * serializer specifications. Partial column overrides can be supplied to `serializer`.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod"
+ *
+ * // The PowerSync SQLite schema
+ * const APP_SCHEMA = new Schema({
+ *   documents: new Table({
+ *     name: column.text,
+ *     // Dates are stored as ISO date strings in SQLite
+ *     created_at: column.text
+ *   }),
+ * })
+ *
+ * // Advanced Zod validations. The output type of this schema
+ * // is constrained to the SQLite schema of APP_SCHEMA
+ * const schema = z.object({
+ *   id: z.string(),
+ *   // Notice that `name` is not nullable (is required) here and it has additional validation
+ *   name: z.string().min(3, { message: "Should be at least 3 characters" }).nullable(),
+ *   // The input type is still the SQLite string type. While collections will output smart Date instances.
+ *   created_at: z.string().transform(val => new Date(val))
+ * })
+ *
+ * const collection = createCollection(
+ *   powerSyncCollectionOptions({
+ *     database: db,
+ *     table: APP_SCHEMA.props.documents,
+ *     schema,
+ *     serializer: {
+ *        // The default is toISOString, this is just to demonstrate custom overrides
+ *        created_at: (outputValue) => outputValue.toISOString(),
+ *     },
+ *   })
+ * )
+ * ```
+ */
+export function powerSyncCollectionOptions<
+  TTable extends Table,
+  TSchema extends StandardSchemaV1<
+    // TInput is the SQLite types. We can use the supplied schema to validate sync input
+    OptionalExtractedTable<TTable>,
+    AnyTableColumnType<TTable>
+  >,
+>(
+  config: BasePowerSyncCollectionConfig<TTable, TSchema> &
+    ConfigWithSQLiteInputType<TTable, TSchema>,
+): EnhancedPowerSyncCollectionConfig<
+  TTable,
+  InferPowerSyncOutputType<TTable, TSchema>,
+  TSchema
+> & {
+  schema: TSchema
+}
+
+// Overload 3: Schema is provided with arbitrary TInput and TOutput
+/**
+ * Creates a PowerSync collection configuration with schema validation.
+ *
+ * The input types are not linked to the internal SQLite table types. This can
+ * give greater flexibility, e.g. by accepting rich types as input for `insert` or `update` operations.
+ * An additional `deserializationSchema` is required in order to process incoming SQLite updates to the output type.
+ *
+ * The output types are defined by the provided schema. This schema can enforce additional
+ * validation or type transforms.
+ * Arbitrary output typed mutations are encoded to SQLite for persistence. We provide a basic standard
+ * serialization implementation to serialize column values. Custom or advanced types require providing additional
+ * serializer specifications. Partial column overrides can be supplied to `serializer`.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod"
+ *
+ * // The PowerSync SQLite schema
+ * const APP_SCHEMA = new Schema({
+ *   documents: new Table({
+ *     name: column.text,
+ *     // Booleans are represented as integers in SQLite
+ *     is_active: column.integer
+ *   }),
+ * })
+ *
+ * // Advanced Zod validations.
+ * // We accept boolean values as input for operations and expose Booleans in query results
+ * const schema = z.object({
+ *   id: z.string(),
+ *   isActive: z.boolean(), // TInput and TOutput are boolean
+ * })
+ *
+ * // The deserializationSchema converts the SQLite synced INTEGER (0/1) values to booleans.
+ * const deserializationSchema = z.object({
+ *   id: z.string(),
+ *   isActive: z.number().nullable().transform((val) => val == null ? true : val > 0),
+ * })
+ *
+ * const collection = createCollection(
+ *   powerSyncCollectionOptions({
+ *     database: db,
+ *     table: APP_SCHEMA.props.documents,
+ *     schema,
+ *     deserializationSchema,
+ *   })
+ * )
+ * ```
+ */
+export function powerSyncCollectionOptions<
+  TTable extends Table,
+  TSchema extends StandardSchemaV1<
+    // The input and output must have the same keys, the value types can be arbitrary
+    AnyTableColumnType<TTable>,
+    AnyTableColumnType<TTable>
+  >,
+>(
+  config: BasePowerSyncCollectionConfig<TTable, TSchema> &
+    ConfigWithArbitraryCollectionTypes<TTable, TSchema>,
+): EnhancedPowerSyncCollectionConfig<
+  TTable,
+  InferPowerSyncOutputType<TTable, TSchema>,
+  TSchema
+> & {
+  utils: PowerSyncCollectionUtils<TTable>
+  schema: TSchema
+}
+
+/**
+ * Implementation of powerSyncCollectionOptions that handles both schema and non-schema configurations.
+ */
+
+export function powerSyncCollectionOptions<
+  TTable extends Table,
+  TSchema extends StandardSchemaV1<any> = never,
+>(config: PowerSyncCollectionConfig<TTable, TSchema>) {
+  const {
+    database,
+    table,
+    schema: inputSchema,
+    syncBatchSize = DEFAULT_BATCH_SIZE,
+    ...restConfig
+  } = config
+
+  const deserializationSchema =
+    `deserializationSchema` in config ? config.deserializationSchema : null
+  const serializer = `serializer` in config ? config.serializer : undefined
+  const onDeserializationError =
+    `onDeserializationError` in config
+      ? config.onDeserializationError
+      : undefined
+
+  // The SQLite table type
+  type TableType = ExtractedTable<TTable>
+
+  // The collection output type
+  type OutputType = InferPowerSyncOutputType<TTable, TSchema>
+
+  const { viewName, trackMetadata: metadataIsTracked } = table
+
+  /**
+   * Deserializes data from the incoming sync stream
+   */
+  const deserializeSyncRow = (value: TableType): OutputType => {
+    const validationSchema = deserializationSchema || schema
+    const validation = validationSchema[`~standard`].validate(value)
+    if (`value` in validation) {
+      return validation.value
+    } else if (`issues` in validation) {
+      const issueMessage = `Failed to validate incoming data for ${viewName}. Issues: ${validation.issues.map((issue) => `${issue.path} - ${issue.message}`)}`
+      database.logger.error(issueMessage)
+      onDeserializationError!(validation)
+      throw new Error(issueMessage)
+    } else {
+      const unknownErrorMessage = `Unknown deserialization error for ${viewName}`
+      database.logger.error(unknownErrorMessage)
+      onDeserializationError!({ issues: [{ message: unknownErrorMessage }] })
+      throw new Error(unknownErrorMessage)
+    }
+  }
+
+  // We can do basic runtime validations for columns if not explicit schema has been provided
+  const schema = inputSchema ?? (convertTableToSchema(table) as TSchema)
+  /**
+   * The onInsert, onUpdate, and onDelete handlers should only return
+   * after we have written the changes to TanStack DB.
+   * We currently only write to TanStack DB from a diff trigger.
+   * We wait for the diff trigger to observe the change,
+   * and only then return from the on[X] handlers.
+   * This ensures that when the transaction is reported as
+   * complete to the caller, the in-memory state is already
+   * consistent with the database.
+   */
+  const pendingOperationStore = PendingOperationStore.GLOBAL
+  // Keep the tracked table unique in case of multiple tabs.
+  const trackedTableName = `__${viewName}_tracking_${Math.floor(
+    Math.random() * 0xffffffff,
+  )
+    .toString(16)
+    .padStart(8, `0`)}`
+
+  const transactor = new PowerSyncTransactor({
+    database,
+  })
+
+  /**
+   * "sync"
+   * Notice that this describes the Sync between the local SQLite table
+   * and the in-memory tanstack-db collection.
+   */
+  const sync: SyncConfig<OutputType, string> = {
+    sync: (params) => {
+      const { begin, write, commit, markReady } = params
+      const abortController = new AbortController()
+
+      // The sync function needs to be synchronous
+      async function start() {
+        database.logger.info(
+          `Sync is starting for ${viewName} into ${trackedTableName}`,
+        )
+        database.onChangeWithCallback(
+          {
+            onChange: async () => {
+              await database
+                .writeTransaction(async (context) => {
+                  begin()
+                  const operations = await context.getAll<TriggerDiffRecord>(
+                    `SELECT * FROM ${trackedTableName} ORDER BY timestamp ASC`,
+                  )
+                  const pendingOperations: Array<PendingOperation> = []
+
+                  for (const op of operations) {
+                    const { id, operation, timestamp, value } = op
+                    const parsedValue = deserializeSyncRow({
+                      id,
+                      ...JSON.parse(value),
+                    })
+                    const parsedPreviousValue =
+                      op.operation == DiffTriggerOperation.UPDATE
+                        ? deserializeSyncRow({
+                            id,
+                            ...JSON.parse(op.previous_value),
+                          })
+                        : undefined
+                    write({
+                      type: mapOperation(operation),
+                      value: parsedValue,
+                      previousValue: parsedPreviousValue,
+                    })
+                    pendingOperations.push({
+                      id,
+                      operation,
+                      timestamp,
+                      tableName: viewName,
+                    })
+                  }
+
+                  // clear the current operations
+                  await context.execute(`DELETE FROM ${trackedTableName}`)
+
+                  commit()
+                  pendingOperationStore.resolvePendingFor(pendingOperations)
+                })
+                .catch((error) => {
+                  database.logger.error(
+                    `An error has been detected in the sync handler`,
+                    error,
+                  )
+                })
+            },
+          },
+          {
+            signal: abortController.signal,
+            triggerImmediate: false,
+            tables: [trackedTableName],
+          },
+        )
+
+        const disposeTracking = await database.triggers.createDiffTrigger({
+          source: viewName,
+          destination: trackedTableName,
+          when: {
+            [DiffTriggerOperation.INSERT]: `TRUE`,
+            [DiffTriggerOperation.UPDATE]: `TRUE`,
+            [DiffTriggerOperation.DELETE]: `TRUE`,
+          },
+          hooks: {
+            beforeCreate: async (context) => {
+              let currentBatchCount = syncBatchSize
+              let cursor = 0
+              while (currentBatchCount == syncBatchSize) {
+                begin()
+                const batchItems = await context.getAll<TableType>(
+                  sanitizeSQL`SELECT * FROM ${viewName} LIMIT ? OFFSET ?`,
+                  [syncBatchSize, cursor],
+                )
+                currentBatchCount = batchItems.length
+                cursor += currentBatchCount
+                for (const row of batchItems) {
+                  write({
+                    type: `insert`,
+                    value: deserializeSyncRow(row),
+                  })
+                }
+                commit()
+              }
+              markReady()
+              database.logger.info(
+                `Sync is ready for ${viewName} into ${trackedTableName}`,
+              )
+            },
+          },
+        })
+
+        // If the abort controller was aborted while processing the request above
+        if (abortController.signal.aborted) {
+          await disposeTracking()
+        } else {
+          abortController.signal.addEventListener(
+            `abort`,
+            () => {
+              disposeTracking()
+            },
+            { once: true },
+          )
+        }
+      }
+
+      start().catch((error) =>
+        database.logger.error(
+          `Could not start syncing process for ${viewName} into ${trackedTableName}`,
+          error,
+        ),
+      )
+
+      return () => {
+        database.logger.info(
+          `Sync has been stopped for ${viewName} into ${trackedTableName}`,
+        )
+        abortController.abort()
+      }
+    },
+    // Expose the getSyncMetadata function
+    getSyncMetadata: undefined,
+  }
+
+  const getKey = (record: OutputType) => asPowerSyncRecord(record).id
+
+  const outputConfig: EnhancedPowerSyncCollectionConfig<
+    TTable,
+    OutputType,
+    TSchema
+  > = {
+    ...restConfig,
+    schema,
+    getKey,
+    // Syncing should start immediately since we need to monitor the changes for mutations
+    startSync: true,
+    sync,
+    onInsert: async (params) => {
+      // The transaction here should only ever contain a single insert mutation
+      return await transactor.applyTransaction(params.transaction)
+    },
+    onUpdate: async (params) => {
+      // The transaction here should only ever contain a single update mutation
+      return await transactor.applyTransaction(params.transaction)
+    },
+    onDelete: async (params) => {
+      // The transaction here should only ever contain a single delete mutation
+      return await transactor.applyTransaction(params.transaction)
+    },
+    utils: {
+      getMeta: () => ({
+        tableName: viewName,
+        trackedTableName,
+        metadataIsTracked,
+        serializeValue: (value) =>
+          serializeForSQLite(
+            value,
+            // This is required by the input generic
+            table as Table<
+              MapBaseColumnType<InferPowerSyncOutputType<TTable, TSchema>>
+            >,
+            // Coerce serializer to the shape that corresponds to the Table constructed from OutputType
+            serializer as CustomSQLiteSerializer<
+              OutputType,
+              ExtractedTableColumns<Table<MapBaseColumnType<OutputType>>>
+            >,
+          ),
+      }),
+    },
+  }
+  return outputConfig
+}
diff --git a/packages/powersync-db-collection/src/schema.ts b/packages/powersync-db-collection/src/schema.ts
new file mode 100644
index 000000000..706795590
--- /dev/null
+++ b/packages/powersync-db-collection/src/schema.ts
@@ -0,0 +1,100 @@
+import { ColumnType } from '@powersync/common'
+import type { Table } from '@powersync/common'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { ExtractedTable } from './helpers'
+
+/**
+ * Converts a PowerSync Table instance to a StandardSchemaV1 schema.
+ * Creates a schema that validates the structure and types of table records
+ * according to the PowerSync table definition.
+ *
+ * @template TTable - The PowerSync schema-typed Table definition
+ * @param table - The PowerSync Table instance to convert
+ * @returns A StandardSchemaV1-compatible schema with proper type validation
+ *
+ * @example
+ * ```typescript
+ * const usersTable = new Table({
+ *   name: column.text,
+ *   age: column.integer
+ * })
+ * ```
+ */
+export function convertTableToSchema<TTable extends Table>(
+  table: TTable,
+): StandardSchemaV1<ExtractedTable<TTable>> {
+  type TExtracted = ExtractedTable<TTable>
+  // Create validate function that checks types according to column definitions
+  const validate = (
+    value: unknown,
+  ):
+    | StandardSchemaV1.SuccessResult<TExtracted>
+    | StandardSchemaV1.FailureResult => {
+    if (typeof value != `object` || value == null) {
+      return {
+        issues: [
+          {
+            message: `Value must be an object`,
+          },
+        ],
+      }
+    }
+
+    const issues: Array<StandardSchemaV1.Issue> = []
+
+    // Check id field
+    if (!(`id` in value) || typeof (value as any).id != `string`) {
+      issues.push({
+        message: `id field must be a string`,
+        path: [`id`],
+      })
+    }
+
+    // Check each column
+    for (const column of table.columns) {
+      const val = (value as TExtracted)[column.name as keyof TExtracted]
+
+      if (val == null) {
+        continue
+      }
+
+      switch (column.type) {
+        case ColumnType.TEXT:
+          if (typeof val != `string`) {
+            issues.push({
+              message: `${column.name} must be a string or null`,
+              path: [column.name],
+            })
+          }
+          break
+        case ColumnType.INTEGER:
+        case ColumnType.REAL:
+          if (typeof val != `number`) {
+            issues.push({
+              message: `${column.name} must be a number or null`,
+              path: [column.name],
+            })
+          }
+          break
+      }
+    }
+
+    if (issues.length > 0) {
+      return { issues }
+    }
+
+    return { value: { ...value } as TExtracted }
+  }
+
+  return {
+    '~standard': {
+      version: 1,
+      vendor: `powersync`,
+      validate,
+      types: {
+        input: {} as TExtracted,
+        output: {} as TExtracted,
+      },
+    },
+  }
+}
diff --git a/packages/powersync-db-collection/src/serialization.ts b/packages/powersync-db-collection/src/serialization.ts
new file mode 100644
index 000000000..a3719c5f8
--- /dev/null
+++ b/packages/powersync-db-collection/src/serialization.ts
@@ -0,0 +1,101 @@
+import { ColumnType } from '@powersync/common'
+import type { Table } from '@powersync/common'
+import type { CustomSQLiteSerializer } from './definitions'
+import type {
+  ExtractedTable,
+  ExtractedTableColumns,
+  MapBaseColumnType,
+} from './helpers'
+
+/**
+ * Serializes an object for persistence to a SQLite table, mapping its values to appropriate SQLite types.
+ *
+ * This function takes an object representing a row, a table schema, and an optional custom serializer map.
+ * It returns a new object with values transformed to be compatible with SQLite column types.
+ *
+ * ## Generics
+ * - `TOutput`: The shape of the input object, typically matching the row data.
+ * - `TTable`: The table schema, which must match the keys of `TOutput`.
+ *
+ * ## Parameters
+ * - `value`: The object to serialize (row data).
+ * - `tableSchema`: The schema describing the SQLite table columns and types.
+ * - `customSerializer`: An optional map of custom serialization functions for specific keys.
+ *
+ * ## Behavior
+ * - For each key in `value`, finds the corresponding column in `tableSchema`.
+ * - If a custom serializer is provided for a key, it is used to transform the value.
+ * - Otherwise, values are mapped according to the column type:
+ *   - `TEXT`: Strings are passed through; Dates are converted to ISO strings; other types are JSON-stringified.
+ *   - `INTEGER`/`REAL`: Numbers are passed through; booleans are mapped to 1/0; other types are coerced to numbers.
+ * - Throws if a column type is unknown or a value cannot be converted.
+ *
+ * ## Returns
+ * - An object with the same keys as `value`, with values transformed for SQLite compatibility.
+ *
+ * ## Errors
+ * - Throws if a key in `value` does not exist in the schema.
+ * - Throws if a value cannot be converted to the required SQLite type.
+ */
+export function serializeForSQLite<
+  TOutput extends Record<string, unknown>,
+  // The keys should match
+  TTable extends Table<MapBaseColumnType<TOutput>> = Table<
+    MapBaseColumnType<TOutput>
+  >,
+>(
+  value: TOutput,
+  tableSchema: TTable,
+  customSerializer: Partial<
+    CustomSQLiteSerializer<TOutput, ExtractedTableColumns<TTable>>
+  > = {},
+): ExtractedTable<TTable> {
+  return Object.fromEntries(
+    Object.entries(value).map(([key, value]) => {
+      // First get the output schema type
+      const outputType =
+        key == `id`
+          ? ColumnType.TEXT
+          : tableSchema.columns.find((column) => column.name == key)?.type
+      if (!outputType) {
+        throw new Error(`Could not find schema for ${key} column.`)
+      }
+
+      if (value == null) {
+        return [key, value]
+      }
+
+      const customTransform = customSerializer[key]
+      if (customTransform) {
+        return [key, customTransform(value as TOutput[string])]
+      }
+
+      // Map to the output
+      switch (outputType) {
+        case ColumnType.TEXT:
+          if (typeof value == `string`) {
+            return [key, value]
+          } else if (value instanceof Date) {
+            return [key, value.toISOString()]
+          } else {
+            return [key, JSON.stringify(value)]
+          }
+        case ColumnType.INTEGER:
+        case ColumnType.REAL:
+          if (typeof value == `number`) {
+            return [key, value]
+          } else if (typeof value == `boolean`) {
+            return [key, value ? 1 : 0]
+          } else {
+            const numberValue = Number(value)
+            if (isNaN(numberValue)) {
+              throw new Error(
+                `Could not convert ${key}=${value} to a number for SQLite`,
+              )
+            }
+            return [key, numberValue]
+          }
+      }
+    }),
+  )
+}
diff --git a/packages/powersync-db-collection/tests/collection-schema.test.ts b/packages/powersync-db-collection/tests/collection-schema.test.ts
new file mode 100644
index 000000000..84a7b1297
--- /dev/null
+++ b/packages/powersync-db-collection/tests/collection-schema.test.ts
@@ -0,0 +1,362 @@
+import { randomUUID } from 'node:crypto'
+import { tmpdir } from 'node:os'
+import { PowerSyncDatabase, Schema, Table, column } from '@powersync/node'
+import { SchemaValidationError, createCollection } from '@tanstack/db'
+import { describe, expect, it, onTestFinished, vi } from 'vitest'
+import { z } from 'zod'
+import { powerSyncCollectionOptions } from '../src'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+
+const APP_SCHEMA = new Schema({
+  documents: new Table({
+    name: column.text,
+    author: column.text,
+    created_at: column.text, // Will be mapped to Date
+    archived: column.integer, // Will be mapped to Boolean
+  }),
+})
+
+describe(`PowerSync Schema Integration`, () => {
+  async function createDatabase() {
+    const db = new PowerSyncDatabase({
+      database: {
+        dbFilename: `test.sqlite`,
+        dbLocation: tmpdir(),
+        implementation: { type: `node:sqlite` },
+      },
+      schema: APP_SCHEMA,
+    })
+    onTestFinished(async () => {
+      await db.disconnectAndClear()
+      await db.close()
+    })
+    // Initial clear in case a test might have failed
+    await db.disconnectAndClear()
+    return db
+  }
+
+  function createDocumentsCollection(db: PowerSyncDatabase) {
+    const collection = createCollection(
+      powerSyncCollectionOptions({
+        database: db,
+        // We get typing and a default validator from this
+        table: APP_SCHEMA.props.documents,
+      }),
+    )
+    onTestFinished(() => collection.cleanup())
+    return collection
+  }
+
+  describe(`schema`, () => {
+    /**
+     * When using the SQLite types for TInput and TOutput, we provide a basic schema validator.
+     */
+    it(`should use basic runtime validations from automatic SQLite schema`, async () => {
+      const db = await createDatabase()
+
+      // the collection should infer types and validate with the schema
+      const collection = createDocumentsCollection(db)
+      await collection.stateWhenReady()
+
+      collection.insert({
+        id: randomUUID(),
+        name: `aname`,
+      })
+
+      collection.insert({
+        id: randomUUID(),
+        name: null,
+      })
+
+      expect(collection.size).eq(2)
+
+      // should validate inputs
+      try {
+        collection.insert({} as any)
+      } catch (ex) {
+        expect(ex instanceof SchemaValidationError).true
+        if (ex instanceof SchemaValidationError) {
+          expect(ex.message).contains(`id field must be a string`)
+        }
+      }
+    })
+
+    /**
+     * The TInput value can enforce additional validations.
+     * This example uses the SQLite types as TInput and TOutput.
+     */
+    it(`should allow for advanced input validations`, async () => {
+      const db = await createDatabase()
+
+      const errorMessage = `Name must be at least 3 characters`
+      /**
+       * This has additional validations on TInput.
+       * These validations will be applied for mutations: e.g. `insert`, `update`/
+       * Validations include:
+       *  - `name`, `author` and `created_at` are required
+       *  - `name` must be at least 3 characters long
+       */
+      const schema = z.object({
+        id: z.string(),
+        name: z.string().min(3, { message: errorMessage }),
+        archived: z.number(),
+        author: z.string(),
+        created_at: z.string(),
+      })
+
+      const collection = createCollection(
+        powerSyncCollectionOptions({
+          database: db,
+          table: APP_SCHEMA.props.documents,
+          schema,
+          onDeserializationError: () => {},
+        }),
+      )
+      onTestFinished(() => collection.cleanup())
+
+      try {
+        collection.insert({
+          id: randomUUID(),
+          name: `2`,
+          author: `name`,
+          created_at: new Date().toISOString(),
+          archived: 0,
+        })
+        expect.fail(`Should throw a validation error`)
+      } catch (ex) {
+        expect(ex instanceof SchemaValidationError).true
+        if (ex instanceof SchemaValidationError) {
+          expect(ex.message).contains(errorMessage)
+        }
+      }
+
+      expect(collection.size).eq(0)
+
+      // should validate inputs
+      try {
+        collection.insert({} as any)
+      } catch (ex) {
+        expect(ex instanceof SchemaValidationError).true
+        if (ex instanceof SchemaValidationError) {
+          expect(ex.message).contains(`Required - path: id`)
+        }
+      }
+    })
+
+    /**
+     * In this example the TInput and TOutput types are different.
+     * In this example we use the SQLite types as the input. We don't need an additional deserialization schema.
+     */
+    it(`should allow custom/transformed input types - Input is SQLite`, async () => {
+      const db = await createDatabase()
+
+      /**
+       * The input for `created_at` is string, while it's presented as a `Date` in TOutput
+       */
+      const schema = z.object({
+        id: z.string(),
+        name: z.string().nullable(),
+        archived: z.number().nullable(),
+        author: z.string().nullable(),
+        created_at: z
+          .string()
+          .nullable()
+          .transform((val) => val && new Date(val)),
+      })
+
+      const collection = createCollection(
+        powerSyncCollectionOptions({
+          database: db,
+          table: APP_SCHEMA.props.documents,
+          schema,
+          onDeserializationError: () => {},
+        }),
+      )
+      onTestFinished(() => collection.cleanup())
+
+      const testDate = new Date()
+      const id = randomUUID()
+      collection.insert({
+        id,
+        name: `document`,
+        author: `nanme`,
+        created_at: testDate.toISOString(),
+        archived: 0,
+      })
+
+      const item = collection.get(id)
+
+      expect(item?.created_at instanceof Date).true
+      expect(item?.created_at?.toLocaleString()).eq(testDate.toLocaleString())
+    })
+
+    /**
+     * In this example the TInput and TOutput types are different.
+     * In this example we use custom types for TInput. This requires an additional schema for validating
+     * incoming items from the sync stream (which is typed as SQLite)
+     */
+    it(`should allow custom/transformed input types - Input is different from SQLite`, async () => {
+      const db = await createDatabase()
+
+      /**
+       * The input for `created_at` is unix epoch, while it's presented as a `Date` in TOutput
+       */
+      const schema = z.object({
+        id: z.string(),
+        name: z.string().nullable(),
+        // We want to use booleans as the input here
+        archived: z.boolean().nullable(),
+        author: z.string().nullable(),
+        created_at: z.date().nullable(),
+      })
+
+      const collection = createCollection(
+        powerSyncCollectionOptions({
+          database: db,
+          table: APP_SCHEMA.props.documents,
+          schema,
+          /**
+           * This needs to convert the SQLite types (which are different from TInput in this case)
+           * to TOutput
+           */
+          deserializationSchema: z.object({
+            id: z.string(),
+            name: z.string().nullable(),
+            archived: z
+              .number()
+              .nullable()
+              .transform((val) => (val ? val != 0 : null)),
+            author: z.string().nullable(),
+            // In this case val is an ISO date string from SQLite
+            created_at: z
+              .string()
+              .nullable()
+              .transform((val) => (val ? new Date(val) : null)),
+          }),
+          onDeserializationError: () => {},
+        }),
+      )
+      onTestFinished(() => collection.cleanup())
+
+      const testDate = new Date()
+      const id = randomUUID()
+      collection.insert({
+        id,
+        name: `document`,
+        author: `nanme`,
+        created_at: new Date(),
+        archived: false,
+      })
+
+      const item = collection.get(id)
+
+      expect(item?.created_at instanceof Date).true
+      expect(item?.created_at?.toLocaleString()).eq(testDate.toLocaleString())
+    })
+
+    /**
+     * In this example we contain a TOutput field type which requires custom serialization for SQLite
+     */
+    it(`should allow for custom serializers`, async () => {
+      const db = await createDatabase()
+
+      class MyDataClass {
+        constructor(public options: { value: string }) {}
+      }
+
+      /**
+       * Here name is stored as a Buffer. We can't serialize this to SQLite automatically.
+       * We need to provide a serializer.
+       */
+      const schema = z.object({
+        id: z.string(),
+        name: z
+          .string()
+          .nullable()
+          .transform((value) => (value ? new MyDataClass({ value }) : null)),
+        archived: z.number().nullable(),
+        author: z.string().nullable(),
+        created_at: z.string().nullable(),
+      })
+
+      const collection = createCollection(
+        powerSyncCollectionOptions({
+          database: db,
+          table: APP_SCHEMA.props.documents,
+          schema,
+          // This is used to serialize to SQLite
+          serializer: {
+            name: (holder) => holder?.options.value || null,
+          },
+          deserializationSchema: schema,
+          onDeserializationError: () => {},
+        }),
+      )
+      onTestFinished(() => collection.cleanup())
+
+      const id = randomUUID()
+
+      const result = collection.insert({
+        id,
+        name: `document`,
+        author: `name`,
+        created_at: new Date().toISOString(),
+        archived: 0,
+      })
+
+      const item = collection.get(id)
+      await result.isPersisted.promise
+      expect(item?.name instanceof MyDataClass).true
+      expect(item?.name?.options.value).eq(`document`)
+    })
+
+    /**
+     * We sync data which cannot be validated by the schema. This is a fatal error.
+     */
+    it(`should catch deserialization errors`, async () => {
+      const db = await createDatabase()
+
+      /**
+       * Here name is stored as a Buffer. We can't serialize this to SQLite automatically.
+       * We need to provide a serializer.
+       */
+      const schema = z.object({
+        id: z.string(),
+        name: z.string(),
+        archived: z.number(),
+        author: z.string(),
+        created_at: z.string(),
+      })
+
+      const onError = vi.fn((() => {}) as (
+        error: StandardSchemaV1.FailureResult,
+      ) => void)
+
+      const collection = createCollection(
+        powerSyncCollectionOptions({
+          database: db,
+          table: APP_SCHEMA.props.documents,
+          schema,
+          onDeserializationError: onError,
+        }),
+      )
+      onTestFinished(() => collection.cleanup())
+
+      await collection.stateWhenReady()
+
+      // The columns are not nullable in the schema
+      // Write invalid data to SQLite, this simulates a sync
+      await db.execute(`INSERT INTO documents(id) VALUES(uuid())`)
+
+      await vi.waitFor(
+        () => {
+          const issues = onError.mock.lastCall?.[0]?.issues
+          expect(issues).toBeDefined()
+          // Each column which should have been defined
+          expect(issues?.length).eq(4)
+        },
+        { timeout: 1000 },
+      )
+    })
+  })
+})
diff --git a/packages/powersync-db-collection/tests/powersync.test.ts b/packages/powersync-db-collection/tests/powersync.test.ts
new file mode 100644
index 000000000..4a4a5a544
--- /dev/null
+++ b/packages/powersync-db-collection/tests/powersync.test.ts
@@ -0,0 +1,553 @@
+import { randomUUID } from 'node:crypto'
+import { tmpdir } from 'node:os'
+import {
+  CrudEntry,
+  PowerSyncDatabase,
+  Schema,
+  Table,
+  column,
+} from '@powersync/node'
+import {
+  createCollection,
+  createTransaction,
+  eq,
+  liveQueryCollectionOptions,
+} from '@tanstack/db'
+import { describe, expect, it, onTestFinished, vi } from 'vitest'
+import { powerSyncCollectionOptions } from '../src'
+import { PowerSyncTransactor } from '../src/PowerSyncTransactor'
+import type { AbstractPowerSyncDatabase } from '@powersync/node'
+
+const APP_SCHEMA = new Schema({
+  users: new Table({
+    name: column.text,
+    active: column.integer, // Will be mapped to Boolean
+  }),
+  documents: new Table(
+    {
+      name: column.text,
+      author: column.text,
+      created_at: column.text, // Will be mapped to Date
+    },
+    {
+      trackMetadata: true,
+    },
+  ),
+})
+
+describe(`PowerSync Integration`, () => {
+  async function createDatabase() {
+    const db = new PowerSyncDatabase({
+      database: {
+        dbFilename: `test-${randomUUID()}.sqlite`,
+        dbLocation: tmpdir(),
+        implementation: { type: `node:sqlite` },
+      },
+      schema: APP_SCHEMA,
+    })
+    onTestFinished(async () => {
+      await db.disconnectAndClear()
+      await db.close()
+    })
+    // Initial clear in case a test might have failed
+    await db.disconnectAndClear()
+    return db
+  }
+
+  function createDocumentsCollection(db: PowerSyncDatabase) {
+    const collection = createCollection(
+      powerSyncCollectionOptions({
+        database: db,
+        // We get typing and a default validator from this
+        table: APP_SCHEMA.props.documents,
+      }),
+    )
+    onTestFinished(() => collection.cleanup())
+    return collection
+  }
+
+  async function createTestData(db: AbstractPowerSyncDatabase) {
+    await db.execute(`
+        INSERT into documents (id, name)
+        VALUES 
+            (uuid(), 'one'),
+            (uuid(), 'two'),
+            (uuid(), 'three')
+        `)
+  }
+
+  describe(`sync`, () => {
+    it(`should initialize and fetch initial data`, async () => {
+      const db = await createDatabase()
+      await createTestData(db)
+      const collection = createDocumentsCollection(db)
+
+      await collection.stateWhenReady()
+
+      // Verify the collection state contains our items
+      expect(collection.size).toBe(3)
+      // Sort by name since keys are random UUIDs
+      expect(collection.toArray.map((entry) => entry.name).sort()).deep.equals([
+        `one`,
+        `three`,
+        `two`,
+      ])
+    })
+
+    it(`should update when data syncs`, async () => {
+      const db = await createDatabase()
+      await createTestData(db)
+
+      const collection = createDocumentsCollection(db)
+
+      await collection.stateWhenReady()
+
+      // Verify the collection state contains our items
+      expect(collection.size).toBe(3)
+
+      // Make an update, simulates a sync from another client
+      await db.execute(`
+        INSERT into documents (id, name)
+        VALUES 
+            (uuid(), 'four')
+        `)
+
+      // The collection should update
+      await vi.waitFor(
+        () => {
+          expect(collection.size).toBe(4)
+          // Sort by name since keys are random UUIDs
+          expect(
+            collection.toArray.map((entry) => entry.name).sort(),
+          ).deep.equals([`four`, `one`, `three`, `two`])
+        },
+        { timeout: 1000 },
+      )
+
+      await db.execute(`
+        DELETE from documents
+        WHERE name = 'two'
+        `)
+
+      // The collection should update
+      await vi.waitFor(
+        () => {
+          expect(collection.size).toBe(3)
+          // Sort by name since keys are random UUIDs
+          expect(
+            collection.toArray.map((entry) => entry.name).sort(),
+          ).deep.equals([`four`, `one`, `three`])
+        },
+        { timeout: 1000 },
+      )
+
+      await db.execute(`
+        UPDATE documents
+        SET name = 'updated'
+        WHERE name = 'one'
+        `)
+
+      // The collection should update
+      await vi.waitFor(
+        () => {
+          expect(collection.size).toBe(3)
+          // Sort by name since keys are random UUIDs
+          expect(
+            collection.toArray.map((entry) => entry.name).sort(),
+          ).deep.equals([`four`, `three`, `updated`])
+        },
+        { timeout: 1000 },
+      )
+    })
+
+    it(`should propagate collection mutations to PowerSync`, async () => {
+      const db = await createDatabase()
+      await createTestData(db)
+
+      const collection = createDocumentsCollection(db)
+      await collection.stateWhenReady()
+
+      // Verify the collection state contains our items
+      expect(collection.size).toBe(3)
+
+      const id = randomUUID()
+      const tx = collection.insert({
+        id,
+        name: `new`,
+        author: `somebody`,
+      })
+
+      // The insert should optimistically update the collection
+      const newDoc = collection.get(id)
+      expect(newDoc).toBeDefined()
+      expect(newDoc!.name).toBe(`new`)
+      expect(newDoc!.author).toBe(`somebody`)
+
+      await tx.isPersisted.promise
+      // The item should now be present in PowerSync
+      // We should also have patched it back in to Tanstack DB (removing the optimistic state)
+
+      // Now do an update
+      await collection.update(id, (d) => (d.name = `updatedNew`)).isPersisted
+        .promise
+
+      const updatedDoc = collection.get(id)
+      expect(updatedDoc).toBeDefined()
+      expect(updatedDoc!.name).toBe(`updatedNew`)
+      // Only the updated field should be updated
+      expect(updatedDoc!.author).toBe(`somebody`)
+
+      await collection.delete(id).isPersisted.promise
+
+      // There should be a crud entries for this
+      const _crudEntries = await db.getAll(`
+        SELECT * FROM ps_crud ORDER BY id`)
+
+      const crudEntries = _crudEntries.map((r) => CrudEntry.fromRow(r))
+
+      expect(crudEntries.length).toBe(6)
+      // We can only group transactions for similar operations
+      expect(crudEntries.map((e) => e.op)).toEqual([
+        `PUT`,
+        `PUT`,
+        `PUT`,
+        `PUT`,
+        `PATCH`,
+        `DELETE`,
+      ])
+    })
+
+    it(`should handle transactions`, async () => {
+      const db = await createDatabase()
+      await createTestData(db)
+
+      const collection = createDocumentsCollection(db)
+      await collection.stateWhenReady()
+
+      expect(collection.size).toBe(3)
+
+      const addTx = createTransaction({
+        autoCommit: false,
+        mutationFn: async ({ transaction }) => {
+          await new PowerSyncTransactor({ database: db }).applyTransaction(
+            transaction,
+          )
+        },
+      })
+
+      addTx.mutate(() => {
+        for (let i = 0; i < 5; i++) {
+          collection.insert({ id: randomUUID(), name: `tx-${i}` })
+        }
+      })
+
+      await addTx.commit()
+      await addTx.isPersisted.promise
+
+      expect(collection.size).toBe(8)
+
+      // fetch the ps_crud items
+      // There should be a crud entries for this
+      const _crudEntries = await db.getAll(`
+        SELECT * FROM ps_crud ORDER BY id`)
+      const crudEntries = _crudEntries.map((r) => CrudEntry.fromRow(r))
+
+      const lastTransactionId =
+        crudEntries[crudEntries.length - 1]?.transactionId
+      /**
+       * The last items, created in the same transaction, should be in the same
+       * PowerSync transaction.
+       */
+      expect(
+        crudEntries
+          .reverse()
+          .slice(0, 5)
+          .every((crudEntry) => crudEntry.transactionId == lastTransactionId),
+      ).true
+    })
+
+    it(`should handle transactions with multiple collections`, async () => {
+      const db = await createDatabase()
+      await createTestData(db)
+
+      const documentsCollection = createDocumentsCollection(db)
+
+      const usersCollection = createCollection(
+        powerSyncCollectionOptions({
+          database: db,
+          table: APP_SCHEMA.props.users,
+        }),
+      )
+      onTestFinished(() => usersCollection.cleanup())
+
+      await documentsCollection.stateWhenReady()
+      await usersCollection.stateWhenReady()
+
+      expect(documentsCollection.size).toBe(3)
+      expect(usersCollection.size).toBe(0)
+
+      const addTx = createTransaction({
+        autoCommit: false,
+        mutationFn: async ({ transaction }) => {
+          await new PowerSyncTransactor({ database: db }).applyTransaction(
+            transaction,
+          )
+        },
+      })
+
+      addTx.mutate(() => {
+        for (let i = 0; i < 5; i++) {
+          documentsCollection.insert({ id: randomUUID(), name: `tx-${i}` })
+          usersCollection.insert({ id: randomUUID(), name: `user` })
+        }
+      })
+
+      await addTx.commit()
+      await addTx.isPersisted.promise
+
+      expect(documentsCollection.size).toBe(8)
+      expect(usersCollection.size).toBe(5)
+
+      // fetch the ps_crud items
+      // There should be a crud entries for this
+      const _crudEntries = await db.getAll(`
+        SELECT * FROM ps_crud ORDER BY id`)
+      const crudEntries = _crudEntries.map((r) => CrudEntry.fromRow(r))
+
+      const lastTransactionId =
+        crudEntries[crudEntries.length - 1]?.transactionId
+      /**
+       * The last items, created in the same transaction, should be in the same
+       * PowerSync transaction.
+       */
+      expect(
+        crudEntries
+          .reverse()
+          .slice(0, 10)
+          .every((crudEntry) => crudEntry.transactionId == lastTransactionId),
+      ).true
+    })
+
+    /**
+     * Metadata provided by the collection operation should be persisted to the database if supported by the SQLite table.
+     */
+    it(`should persist collection operation metadata`, async () => {
+      const db = await createDatabase()
+
+      const collection = createDocumentsCollection(db)
+      await collection.stateWhenReady()
+
+      const metadata = {
+        text: `some text`,
+        number: 123,
+        boolean: true,
+      }
+      const id = randomUUID()
+      await collection.insert(
+        {
+          id,
+          name: `new`,
+          author: `somebody`,
+        },
+        {
+          metadata,
+        },
+      ).isPersisted.promise
+
+      // Now do an update
+      await collection.update(
+        id,
+        { metadata: metadata },
+        (d) => (d.name = `updatedNew`),
+      ).isPersisted.promise
+
+      await collection.delete(id, { metadata }).isPersisted.promise
+
+      // There should be a crud entries for this
+      const crudBatch = await db.getCrudBatch(100)
+      expect(crudBatch).toBeDefined()
+      const crudEntries = crudBatch!.crud
+
+      // The metadata should be available in the CRUD entries for upload
+      const stringifiedMetadata = JSON.stringify(metadata)
+      expect(crudEntries.length).toBe(3)
+      expect(crudEntries[0]!.metadata).toEqual(stringifiedMetadata)
+      expect(crudEntries[1]!.metadata).toEqual(stringifiedMetadata)
+      expect(crudEntries[2]!.metadata).toEqual(stringifiedMetadata)
+
+      // Verify the item is deleted from SQLite
+      const documents = await db.getAll(`
+        SELECT * FROM documents`)
+      expect(documents.length).toBe(0)
+    })
+  })
+
+  describe(`General use`, () => {
+    it(`should rollback transactions on error`, async () => {
+      const db = await createDatabase()
+
+      const options = powerSyncCollectionOptions({
+        database: db,
+        table: APP_SCHEMA.props.documents,
+      })
+
+      // This will cause the transactor to fail when writing to SQLite
+      vi.spyOn(options.utils, `getMeta`).mockImplementation(() => ({
+        tableName: `fakeTable`,
+        trackedTableName: `error`,
+        metadataIsTracked: true,
+        serializeValue: () => ({}) as any,
+      }))
+      // Create two collections for the same table
+      const collection = createCollection(options)
+
+      onTestFinished(() => collection.cleanup())
+      const addTx = createTransaction({
+        autoCommit: false,
+        mutationFn: async ({ transaction }) => {
+          await new PowerSyncTransactor({ database: db }).applyTransaction(
+            transaction,
+          )
+        },
+      })
+
+      expect(collection.size).eq(0)
+      await collection.stateWhenReady()
+
+      const id = randomUUID()
+      addTx.mutate(() => {
+        collection.insert({
+          id,
+          name: `aname`,
+        })
+      })
+
+      // This should be present in the optimistic state, but should be reverted when attempting to persist
+      expect(collection.size).eq(1)
+
+      try {
+        await addTx.commit()
+        await addTx.isPersisted.promise
+        expect.fail(`Should have thrown an error`)
+      } catch (error) {
+        expect(error).toBeDefined()
+        // The collection should be in a clean state
+        expect(collection.size).toBe(0)
+      }
+    })
+
+    it(`should work with live queries`, async () => {
+      const db = await createDatabase()
+
+      // Create two collections for the same table
+      const collection = createDocumentsCollection(db)
+
+      await collection.stateWhenReady()
+
+      const liveDocuments = createCollection(
+        liveQueryCollectionOptions({
+          query: (q) =>
+            q
+              .from({ document: collection })
+              .where(({ document }) => eq(document.name, `book`))
+              .select(({ document }) => ({
+                id: document.id,
+                name: document.name,
+              })),
+        }),
+      )
+
+      expect(liveDocuments.size).eq(0)
+
+      const bookNames = new Set<string>()
+
+      liveDocuments.subscribeChanges((changes) => {
+        changes
+          .map((change) => change.value.name)
+          .forEach((change) => bookNames.add(change))
+      })
+
+      await collection.insert({
+        id: randomUUID(),
+        name: `notabook`,
+      }).isPersisted.promise
+      await collection.insert({
+        id: randomUUID(),
+        name: `book`,
+      }).isPersisted.promise
+
+      expect(collection.size).eq(2)
+      await vi.waitFor(
+        () => {
+          expect(Array.from(bookNames)).deep.equals([`book`])
+        },
+        { timeout: 1000 },
+      )
+    })
+  })
+
+  describe(`Multiple Clients`, () => {
+    it(`should sync updates between multiple clients`, async () => {
+      const db = await createDatabase()
+
+      // Create two collections for the same table
+      const collectionA = createDocumentsCollection(db)
+      await collectionA.stateWhenReady()
+
+      const collectionB = createDocumentsCollection(db)
+      await collectionB.stateWhenReady()
+
+      await createTestData(db)
+
+      // Both collections should have the data present after insertion
+      await vi.waitFor(
+        () => {
+          expect(collectionA.size).eq(3)
+          expect(collectionB.size).eq(3)
+        },
+        { timeout: 1000 },
+      )
+    })
+  })
+
+  describe(`Lifecycle`, () => {
+    it(`should cleanup resources`, async () => {
+      const db = await createDatabase()
+      const collectionOptions = powerSyncCollectionOptions({
+        database: db,
+        table: APP_SCHEMA.props.documents,
+      })
+
+      const meta = collectionOptions.utils.getMeta()
+
+      const tableExists = async (): Promise<boolean> => {
+        const result = await db.writeLock(async (tx) => {
+          return tx.get<{ count: number }>(
+            `
+              SELECT COUNT(*) as count 
+              FROM sqlite_temp_master 
+              WHERE type='table' AND name = ?
+            `,
+            [meta.trackedTableName],
+          )
+        })
+        return result.count > 0
+      }
+
+      const collection = createCollection(collectionOptions)
+      await collection.stateWhenReady()
+      expect(await tableExists()).true
+
+      await collection.cleanup()
+
+      // It seems that even though `cleanup` is async, the sync disposer cannot be async
+      // We wait for the table to be deleted
+      await vi.waitFor(
+        async () => {
+          expect(await tableExists()).false
+        },
+        { timeout: 1000 },
+      )
+    })
+  })
+})
diff --git a/packages/powersync-db-collection/tests/schema.test.ts b/packages/powersync-db-collection/tests/schema.test.ts
new file mode 100644
index 000000000..7405284d5
--- /dev/null
+++ b/packages/powersync-db-collection/tests/schema.test.ts
@@ -0,0 +1,164 @@
+import { Schema, Table, column } from '@powersync/common'
+import { describe, expect, it } from 'vitest'
+import { convertTableToSchema } from '../src/schema'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+
+describe(`Schema Conversion`, () => {
+  describe(`convertTableToSchema`, () => {
+    it(`should convert a simple table with text and integer columns`, () => {
+      const table = new Table({
+        name: column.text,
+        age: column.integer,
+      })
+
+      const schema = convertTableToSchema(table)
+
+      // Test schema structure
+      expect(schema).toHaveProperty(`~standard`)
+      expect(schema[`~standard`].version).toBe(1)
+      expect(schema[`~standard`].vendor).toBe(`powersync`)
+      expect(schema[`~standard`].validate).toBeTypeOf(`function`)
+
+      // Test validation with valid data
+      const validResult = schema[`~standard`].validate({
+        id: `123`,
+        name: `John`,
+        age: 25,
+      }) as StandardSchemaV1.SuccessResult<any>
+
+      expect(validResult.issues).toBeUndefined()
+      expect(validResult.value).toEqual({
+        id: `123`,
+        name: `John`,
+        age: 25,
+      })
+
+      // Test validation with invalid data
+      const invalidResult = schema[`~standard`].validate({
+        id: `123`,
+        name: 123, // wrong type
+        age: `25`, // wrong type
+      }) as StandardSchemaV1.FailureResult
+
+      expect(invalidResult.issues).toHaveLength(2)
+      expect(invalidResult.issues[0]?.message).toContain(`must be a string`)
+      expect(invalidResult.issues[1]?.message).toContain(`must be a number`)
+    })
+
+    it(`should handle null values correctly`, () => {
+      const table = new Table({
+        name: column.text,
+        age: column.integer,
+      })
+
+      const schema = convertTableToSchema(table)
+
+      // Test validation with null values
+      const result = schema[`~standard`].validate({
+        id: `123`,
+        name: null,
+        age: null,
+      }) as StandardSchemaV1.SuccessResult<any>
+
+      expect(result.issues).toBeUndefined()
+      expect(result.value).toEqual({
+        id: `123`,
+        name: null,
+        age: null,
+      })
+    })
+
+    it(`should handle optional values correctly`, () => {
+      const table = new Table({
+        name: column.text,
+        age: column.integer,
+      })
+
+      const schema = convertTableToSchema(table)
+
+      // Test validation with null values
+      const result = schema[`~standard`].validate({
+        id: `123`,
+        name: null,
+        // Don't specify age
+      }) as StandardSchemaV1.SuccessResult<any>
+
+      expect(result.issues).toBeUndefined()
+      expect(result.value).toEqual({
+        id: `123`,
+        name: null,
+      })
+      expect(result.value.age).undefined
+    })
+
+    it(`should require id field`, () => {
+      const table = new Table({
+        name: column.text,
+      })
+
+      const schema = convertTableToSchema(table)
+
+      // Test validation without id
+      const result = schema[`~standard`].validate({
+        name: `John`,
+      }) as StandardSchemaV1.FailureResult
+
+      expect(result.issues).toHaveLength(1)
+      expect(result.issues[0]?.message).toContain(`id field must be a string`)
+    })
+
+    it(`should handle all column types`, () => {
+      const table = new Table({
+        text_col: column.text,
+        int_col: column.integer,
+        real_col: column.real,
+      })
+
+      const schema = convertTableToSchema(table)
+
+      // Test validation with all types
+      const result = schema[`~standard`].validate({
+        id: `123`,
+        text_col: `text`,
+        int_col: 42,
+        real_col: 3.14,
+      }) as StandardSchemaV1.SuccessResult<any>
+
+      expect(result.issues).toBeUndefined()
+      expect(result.value).toEqual({
+        id: `123`,
+        text_col: `text`,
+        int_col: 42,
+        real_col: 3.14,
+      })
+    })
+
+    it(`should validate each table independently`, () => {
+      const schema = new Schema({
+        users: new Table({
+          name: column.text,
+        }),
+        posts: new Table({
+          views: column.integer,
+        }),
+      })
+
+      const usersSchema = convertTableToSchema(schema.props.users)
+      const postsSchema = convertTableToSchema(schema.props.posts)
+
+      // Test that invalid data in one table doesn't affect the other
+      const userInvalidResult = usersSchema[`~standard`].validate({
+        id: `123`,
+        name: 42, // wrong type
+      }) as StandardSchemaV1.FailureResult
+
+      const postValidResult = postsSchema[`~standard`].validate({
+        id: `456`,
+        views: 100,
+      }) as StandardSchemaV1.SuccessResult<any>
+
+      expect(userInvalidResult.issues).toHaveLength(1)
+      expect(postValidResult.issues).toBeUndefined()
+    })
+  })
+})
diff --git a/packages/powersync-db-collection/tsconfig.docs.json b/packages/powersync-db-collection/tsconfig.docs.json
new file mode 100644
index 000000000..5a73feb02
--- /dev/null
+++ b/packages/powersync-db-collection/tsconfig.docs.json
@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "paths": {
+      "@tanstack/db": ["../db/src"]
+    }
+  },
+  "include": ["src"]
+}
diff --git a/packages/powersync-db-collection/tsconfig.json b/packages/powersync-db-collection/tsconfig.json
new file mode 100644
index 000000000..7e586bab3
--- /dev/null
+++ b/packages/powersync-db-collection/tsconfig.json
@@ -0,0 +1,20 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "jsx": "react",
+    "paths": {
+      "@tanstack/store": ["../store/src"]
+    }
+  },
+  "include": ["src", "tests", "vite.config.ts"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/packages/powersync-db-collection/vite.config.ts b/packages/powersync-db-collection/vite.config.ts
new file mode 100644
index 000000000..8f43b798f
--- /dev/null
+++ b/packages/powersync-db-collection/vite.config.ts
@@ -0,0 +1,21 @@
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import { defineConfig, mergeConfig } from 'vitest/config'
+import packageJson from './package.json'
+
+const config = defineConfig({
+  test: {
+    name: packageJson.name,
+    dir: `./tests`,
+    environment: `node`,
+    coverage: { enabled: true, provider: `istanbul`, include: [`src/**/*`] },
+    typecheck: { enabled: true },
+  },
+})
+
+export default mergeConfig(
+  config,
+  tanstackViteConfig({
+    entry: `./src/index.ts`,
+    srcDir: `./src`,
+  }),
+)
diff --git a/packages/query-db-collection/CHANGELOG.md b/packages/query-db-collection/CHANGELOG.md
index 48106f1d9..bf767ea49 100644
--- a/packages/query-db-collection/CHANGELOG.md
+++ b/packages/query-db-collection/CHANGELOG.md
@@ -1,5 +1,492 @@
 # @tanstack/query-db-collection
 
+## 1.0.21
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 1.0.20
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 1.0.19
+
+### Patch Changes
+
+- Fix updating all active query caches on directWrite for on-demand collections.Previously directWrite operations (e.g. writeUpdate/writeInsert) only updated the cache at the base query key for on-demand collections, leading to stale data when components remounted. This change ensures all active query cache keys are updated so data persists correctly. ([#1155](https://github.com/TanStack/db/pull/1155))
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 1.0.18
+
+### Patch Changes
+
+- Fix syncedData not updating when manual write operations (writeUpsert, writeInsert, etc.) are called after async operations in mutation handlers. Previously, the sync transaction would be blocked by the persisting user transaction, leaving syncedData stale until the next sync cycle. ([#1130](https://github.com/TanStack/db/pull/1130))
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 1.0.17
+
+### Patch Changes
+
+- Fix refetch such that it returns the query observer results instead of undefined. ([#1132](https://github.com/TanStack/db/pull/1132))
+
+## 1.0.16
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 1.0.15
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 1.0.14
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 1.0.13
+
+### Patch Changes
+
+- Fix on-demand sync behavior so the full TanStack Query lifecycle is respected. ([#1007](https://github.com/TanStack/db/pull/1007))
+
+  This patch resolves an issue where using on-demand synchronization could break the query lifecycle, including the error reported in https://github.com/TanStack/db/issues/998.
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 1.0.12
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 1.0.11
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 1.0.10
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 1.0.9
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 1.0.8
+
+### Patch Changes
+
+- Fix writeInsert/writeUpsert throwing error when collection uses select option ([#1023](https://github.com/TanStack/db/pull/1023))
+
+  When a Query Collection was configured with a `select` option to extract items from a wrapped API response (e.g., `{ data: [...], meta: {...} }`), calling `writeInsert()` or `writeUpsert()` would corrupt the query cache and trigger the error: "select() must return an array of objects".
+
+  The fix routes cache updates through a new `updateCacheData` function that preserves the wrapper structure by using the `select` function to identify which property contains the items array (via reference equality), then updates only that property while keeping metadata intact.
+
+## 1.0.7
+
+### Patch Changes
+
+- Enhanced LoadSubsetOptions with separate cursor expressions and offset for flexible pagination. ([#960](https://github.com/TanStack/db/pull/960))
+
+  **⚠️ Breaking Change for Custom Sync Layers / Query Collections:**
+
+  `LoadSubsetOptions.where` no longer includes cursor expressions for pagination. If you have a custom sync layer or query collection that implements `loadSubset`, you must now handle pagination separately:
+  - **Cursor-based pagination:** Use the new `cursor` property (`cursor.whereFrom` and `cursor.whereCurrent`) and combine them with `where` yourself
+  - **Offset-based pagination:** Use the new `offset` property
+
+  Previously, cursor expressions were baked into the `where` clause. Now they are passed separately so sync layers can choose their preferred pagination strategy.
+
+  **Changes:**
+  - Added `CursorExpressions` type with `whereFrom`, `whereCurrent`, and optional `lastKey` properties
+  - Added `cursor` to `LoadSubsetOptions` for cursor-based pagination (separate from `where`)
+  - Added `offset` to `LoadSubsetOptions` for offset-based pagination support
+  - Electric sync layer now makes two parallel `requestSnapshot` calls when cursor is present:
+    - One for `whereCurrent` (all ties at boundary, no limit)
+    - One for `whereFrom` (rows after cursor, with limit)
+  - Query collection serialization now includes `offset` for query key generation
+  - Added `truncate` event to collections, emitted when synced data is truncated (e.g., after `must-refetch`)
+  - Fixed `setWindow` pagination: cursor expressions are now correctly built when paging through results
+  - Fixed offset tracking: `loadNextItems` now passes the correct window offset to prevent incorrect deduplication
+  - `CollectionSubscriber` now listens for `truncate` events to reset cursor tracking state
+
+  **Benefits:**
+  - Sync layers can choose between cursor-based or offset-based pagination strategies
+  - Electric can efficiently handle tie-breaking with two targeted requests
+  - Better separation of concerns between filtering (`where`) and pagination (`cursor`/`offset`)
+  - `setWindow` correctly triggers backend loading for subsequent pages in multi-column orderBy queries
+  - Cursor state is properly reset after truncation, preventing stale cursor data from being used
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 1.0.6
+
+### Patch Changes
+
+- fix(query-db-collection): use deep equality for object field comparison in query observer ([#967](https://github.com/TanStack/db/pull/967))
+
+  Fixed an issue where updating object fields (non-primitives) with `refetch: false` in `onUpdate` handlers would cause the value to rollback to the previous state every other update. The query observer was using shallow equality (`===`) to compare items, which compares object properties by reference rather than by value. This caused the observer to incorrectly detect differences and write stale data back to syncedData. Now uses `deepEquals` for proper value comparison.
+
+- Use regular dependency for @tanstack/db instead of peerDependency to match the standard pattern used by other TanStack DB packages and prevent duplicate installations ([#952](https://github.com/TanStack/db/pull/952))
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 1.0.5
+
+### Patch Changes
+
+- fix: ensure ctx.meta.loadSubsetOptions type-safety works automatically ([#869](https://github.com/TanStack/db/pull/869))
+
+  The module augmentation for ctx.meta.loadSubsetOptions is now guaranteed to load automatically when importing from @tanstack/query-db-collection. Previously, users needed to explicitly import QueryCollectionMeta or use @ts-ignore to pass ctx.meta?.loadSubsetOptions to parseLoadSubsetOptions.
+
+  Additionally, QueryCollectionMeta is now an interface (instead of a type alias), enabling users to safely extend meta with custom properties via declaration merging:
+
+  ```typescript
+  declare module '@tanstack/query-db-collection' {
+    interface QueryCollectionMeta {
+      myCustomProperty: string
+    }
+  }
+  ```
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 1.0.4
+
+### Patch Changes
+
+- Fix data loss on component remount by implementing reference counting for QueryObserver lifecycle ([#870](https://github.com/TanStack/db/pull/870))
+
+  **What changed vs main:**
+
+  Previously, when live query subscriptions unsubscribed, there was no tracking of which rows were still needed by other active queries. This caused data loss during remounts.
+
+  This PR adds reference counting infrastructure to properly manage QueryObserver lifecycle:
+  1. Pass same predicates to `unloadSubset` that were passed to `loadSubset`
+  2. Use them to compute the queryKey (via `generateQueryKeyFromOptions`)
+  3. Use existing machinery (`queryToRows` map) to find rows that query loaded
+  4. Decrement the ref count
+  5. GC rows where count reaches 0 (no longer referenced by any active query)
+
+  **Impact:**
+  - Navigation back to previously loaded pages shows cached data immediately
+  - No unnecessary refetches during quick remounts (< gcTime)
+  - Multiple live queries with identical predicates correctly share QueryObservers
+  - Proper row-level cleanup when last subscriber leaves
+  - TanStack Query's cache lifecycle (gcTime) is fully respected
+  - No data leakage from in-flight requests when unsubscribing
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 1.0.3
+
+### Patch Changes
+
+- Improved the type of the queryFn's ctx.meta property of the Query Collection to include the loadSubsetOptions ([#857](https://github.com/TanStack/db/pull/857))
+
+- Fixed bug where optimistic state leaked into syncedData when using writeInsert inside onInsert handlers. Previously, when syncing server-generated fields (like IDs or timestamps) using writeInsert within an onInsert handler, the QueryClient cache was updated with combined visible state (including optimistic changes), which triggered the query observer to write optimistic values back to syncedData. Now the cache is correctly updated with only server-confirmed state, ensuring syncedData maintains separation from optimistic state. ([#879](https://github.com/TanStack/db/pull/879))
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 1.0.2
+
+### Patch Changes
+
+- Automatically append predicates to static queryKey in on-demand mode. ([#800](https://github.com/TanStack/db/pull/800))
+
+  When using a static `queryKey` with `syncMode: 'on-demand'`, the system now automatically appends serialized LoadSubsetOptions to create unique cache keys for different predicate combinations. This fixes an issue where all live queries with different predicates would share the same TanStack Query cache entry, causing data to be overwritten.
+
+  **Before:**
+
+  ```typescript
+  // This would cause conflicts between different queries
+  queryCollectionOptions({
+    queryKey: ['products'], // Static key
+    syncMode: 'on-demand',
+    queryFn: async (ctx) => {
+      const { where, limit } = ctx.meta.loadSubsetOptions
+      return fetch(`/api/products?...`).then((r) => r.json())
+    },
+  })
+  ```
+
+  With different live queries filtering by `category='A'` and `category='B'`, both would share the same cache key `['products']`, causing the last query to overwrite the first.
+
+  **After:**
+  Static queryKeys now work correctly in on-demand mode! The system automatically creates unique cache keys:
+  - Query with `category='A'` → `['products', '{"where":{...A...}}']`
+  - Query with `category='B'` → `['products', '{"where":{...B...}}']`
+
+  **Key behaviors:**
+  - ✅ Static queryKeys now work correctly with on-demand mode (automatic serialization)
+  - ✅ Function-based queryKeys continue to work as before (no change)
+  - ✅ Eager mode with static queryKeys unchanged (no automatic serialization)
+  - ✅ Identical predicates correctly reuse the same cache entry
+
+  This makes the documentation example work correctly without requiring users to manually implement function-based queryKeys for predicate push-down.
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 1.0.1
+
+### Patch Changes
+
+- Temporarily remove `loadSubset` call deduplication in query collection. We need to revisit our approach to deduplication to ensure correctness. See https://github.com/TanStack/db/issues/836 for discussion on the proper implementation strategy. ([#840](https://github.com/TanStack/db/pull/840))
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 1.0.0
+
+### Patch Changes
+
+- Add expression helper utilities for parsing LoadSubsetOptions in queryFn. ([#763](https://github.com/TanStack/db/pull/763))
+
+  When using `syncMode: 'on-demand'`, TanStack DB now provides helper functions to easily parse where clauses, orderBy, and limit predicates into your API's format:
+  - `parseWhereExpression`: Parse where clauses with custom handlers for each operator
+  - `parseOrderByExpression`: Parse order by into simple array format
+  - `extractSimpleComparisons`: Extract simple AND-ed filters
+  - `parseLoadSubsetOptions`: Convenience function to parse all options at once
+  - `walkExpression`, `extractFieldPath`, `extractValue`: Lower-level helpers
+
+  **Example:**
+
+  ```typescript
+  import { parseLoadSubsetOptions } from '@tanstack/db'
+  // or from "@tanstack/query-db-collection" (re-exported for convenience)
+
+  queryFn: async (ctx) => {
+    const { where, orderBy, limit } = ctx.meta.loadSubsetOptions
+
+    const parsed = parseLoadSubsetOptions({ where, orderBy, limit })
+
+    // Build API request from parsed filters
+    const params = new URLSearchParams()
+    parsed.filters.forEach(({ field, operator, value }) => {
+      if (operator === 'eq') {
+        params.set(field.join('.'), String(value))
+      }
+    })
+
+    return fetch(`/api/products?${params}`).then((r) => r.json())
+  }
+  ```
+
+  This eliminates the need to manually traverse expression AST trees when implementing predicate push-down.
+
+- Handle pushed-down predicates ([#763](https://github.com/TanStack/db/pull/763))
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.3.0
+
+### Minor Changes
+
+- Add QueryObserver state utilities and convert error utils to getters ([#742](https://github.com/TanStack/db/pull/742))
+
+  Exposes TanStack Query's QueryObserver state through QueryCollectionUtils, providing visibility into sync status beyond just error states. Also converts existing error state utilities from methods to getters for consistency with TanStack DB/Query patterns.
+
+  **Breaking Changes:**
+  - `lastError()`, `isError()`, and `errorCount()` are now getters instead of methods
+    - Before: `collection.utils.lastError()`
+    - After: `collection.utils.lastError`
+
+  **New Utilities:**
+  - `isFetching` - Check if query is currently fetching (initial or background)
+  - `isRefetching` - Check if query is refetching in background
+  - `isLoading` - Check if query is loading for first time
+  - `dataUpdatedAt` - Get timestamp of last successful data update
+  - `fetchStatus` - Get current fetch status ('fetching' | 'paused' | 'idle')
+
+  **Use Cases:**
+  - Show loading indicators during background refetches
+  - Implement "Last updated X minutes ago" UI patterns
+  - Better understanding of query sync behavior
+
+  **Example Usage:**
+
+  ```ts
+  const collection = queryCollectionOptions({
+    // ... config
+  })
+
+  // Check sync status
+  if (collection.utils.isFetching) {
+    console.log('Syncing with server...')
+  }
+
+  if (collection.utils.isRefetching) {
+    console.log('Background refresh in progress')
+  }
+
+  // Show last update time
+  const lastUpdate = new Date(collection.utils.dataUpdatedAt)
+  console.log(`Last synced: ${lastUpdate.toLocaleTimeString()}`)
+
+  // Check error state (now using getters)
+  if (collection.utils.isError) {
+    console.error('Sync failed:', collection.utils.lastError)
+    console.log(`Failed ${collection.utils.errorCount} times`)
+  }
+  ```
+
+### Patch Changes
+
+- Fix dependency bundling issues by moving @tanstack/db to peerDependencies ([#766](https://github.com/TanStack/db/pull/766))
+
+  **What Changed:**
+
+  Moved `@tanstack/db` from regular dependencies to peerDependencies in:
+  - `@tanstack/offline-transactions`
+  - `@tanstack/query-db-collection`
+
+  Removed `@opentelemetry/api` dependency from `@tanstack/offline-transactions`.
+
+  **Why:**
+
+  These extension packages incorrectly declared `@tanstack/db` as both a regular dependency AND a peerDependency simultaneously. This caused lock files to develop conflicting versions, resulting in multiple instances of `@tanstack/db` being installed in consuming applications.
+
+  The fix removes `@tanstack/db` from regular dependencies and keeps it only as a peerDependency. This ensures only one version of `@tanstack/db` is installed in the dependency tree, preventing version conflicts.
+
+  For local development, `@tanstack/db` remains in devDependencies so the packages can be built and tested independently.
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.2.42
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.2.41
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.2.40
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+
+## 0.2.39
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+
+## 0.2.38
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+
+## 0.2.37
+
+### Patch Changes
+
+- **Behavior change**: `utils.refetch()` now uses exact query key targeting (previously used prefix matching). This prevents unintended cascading refetches of related queries. For example, refetching `['todos', 'project-1']` will no longer trigger refetches of `['todos']` or `['todos', 'project-2']`. ([#552](https://github.com/TanStack/db/pull/552))
+
+  Additionally, `utils.refetch()` now bypasses `enabled: false` to support manual/imperative refetch patterns (matching TanStack Query hook behavior) and returns `QueryObserverResult` instead of `void` for better DX.
+
+## 0.2.36
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+
+## 0.2.35
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+
+## 0.2.34
+
+### Patch Changes
+
+- Fix queryCollectionOptions to respect QueryClient defaultOptions when not overridden ([#707](https://github.com/TanStack/db/pull/707))
+
+  Previously, when creating a QueryClient with defaultOptions (e.g., staleTime, retry, refetchOnWindowFocus), these options were ignored by queryCollectionOptions unless explicitly specified again in the collection config. This required duplicating configuration and prevented users from setting global defaults.
+
+  Now, queryCollectionOptions properly respects the QueryClient's defaultOptions as fallbacks. Options explicitly provided in queryCollectionOptions will still override the defaults.
+
+  Example - this now works as expected:
+
+  ```typescript
+  const dbQueryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        refetchOnWindowFocus: false,
+        staleTime: Infinity,
+      },
+    },
+  })
+
+  queryCollectionOptions({
+    id: 'wallet-accounts',
+    queryKey: ['wallet-accounts'],
+    queryClient: dbQueryClient,
+    // staleTime: Infinity is now inherited from defaultOptions
+  })
+  ```
+
+- Fix writeDelete/writeUpdate validation to check synced store only ([#708](https://github.com/TanStack/db/pull/708))
+
+  Fixed issue where calling `writeDelete()` or `writeUpdate()` inside mutation handlers (like `onDelete`) would throw errors when optimistic updates were active. These write operations now correctly validate against the synced store only, not the combined view (synced + optimistic).
+
+  This allows patterns like calling `writeDelete()` inside an `onDelete` handler to work correctly, enabling users to write directly to the synced store while the mutation is being persisted to the backend.
+
+  Fixes #706
+
+## 0.2.33
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+
 ## 0.2.32
 
 ### Patch Changes
@@ -372,7 +859,7 @@
   try {
     collection.insert(data)
   } catch (error) {
-    if (error.message.includes("already exists")) {
+    if (error.message.includes('already exists')) {
       // Handle duplicate key error
     }
   }
@@ -381,7 +868,7 @@
   **After:**
 
   ```ts
-  import { DuplicateKeyError } from "@tanstack/db"
+  import { DuplicateKeyError } from '@tanstack/db'
 
   try {
     collection.insert(data)
@@ -398,14 +885,14 @@
 
   ```ts
   // Electric collection errors were imported from @tanstack/db
-  import { ElectricInsertHandlerMustReturnTxIdError } from "@tanstack/db"
+  import { ElectricInsertHandlerMustReturnTxIdError } from '@tanstack/db'
   ```
 
   **After:**
 
   ```ts
   // Now import from the specific adapter package
-  import { ElectricInsertHandlerMustReturnTxIdError } from "@tanstack/electric-db-collection"
+  import { ElectricInsertHandlerMustReturnTxIdError } from '@tanstack/electric-db-collection'
   ```
 
   ### Unified Error Handling
@@ -413,14 +900,14 @@
   **New:**
 
   ```ts
-  import { TanStackDBError } from "@tanstack/db"
+  import { TanStackDBError } from '@tanstack/db'
 
   try {
     // Any TanStack DB operation
   } catch (error) {
     if (error instanceof TanStackDBError) {
       // Handle all TanStack DB errors uniformly
-      console.log("TanStack DB error:", error.message)
+      console.log('TanStack DB error:', error.message)
     }
   }
   ```
diff --git a/packages/query-db-collection/e2e/query-filter.ts b/packages/query-db-collection/e2e/query-filter.ts
new file mode 100644
index 000000000..43f4d0e87
--- /dev/null
+++ b/packages/query-db-collection/e2e/query-filter.ts
@@ -0,0 +1,639 @@
+/**
+ * Query-driven sync implementation for Query collection E2E tests
+ * Uses expression helpers to implement proper predicate push-down
+ */
+
+import { parseLoadSubsetOptions } from '@tanstack/db'
+import type {
+  IR,
+  LoadSubsetOptions,
+  ParsedOrderBy,
+  SimpleComparison,
+} from '@tanstack/db'
+
+const DEBUG_VERBOSE = process.env.DEBUG_QUERY_PUSH === `1`
+const DEBUG_SUMMARY =
+  DEBUG_VERBOSE || process.env.DEBUG_QUERY_PUSH_SUMMARY === `1`
+const SIMPLE_OPERATORS = new Set([
+  `eq`,
+  `gt`,
+  `gte`,
+  `lt`,
+  `lte`,
+  `in`,
+  `isNull`,
+  `isUndefined`,
+  // NOT-wrapped operators (flattened by extractSimpleComparisons)
+  `not_eq`,
+  `not_gt`,
+  `not_gte`,
+  `not_lt`,
+  `not_lte`,
+  `not_in`,
+  `not_isNull`,
+  `not_isUndefined`,
+])
+
+/**
+ * Build a stable TanStack Query key for load subset options
+ */
+export function buildQueryKey(
+  namespace: string,
+  options: LoadSubsetOptions | undefined,
+) {
+  return [`e2e`, namespace, serializeLoadSubsetOptions(options)]
+}
+
+export function serializeLoadSubsetOptions(
+  options: LoadSubsetOptions | undefined,
+): unknown {
+  if (!options) {
+    return null
+  }
+
+  const result: Record<string, unknown> = {}
+
+  if (options.where) {
+    result.where = serializeExpression(options.where)
+  }
+
+  if (options.orderBy?.length) {
+    result.orderBy = options.orderBy.map((clause) => ({
+      expression: serializeExpression(clause.expression),
+      direction: clause.compareOptions.direction,
+      nulls: clause.compareOptions.nulls,
+    }))
+  }
+
+  if (options.limit !== undefined) {
+    result.limit = options.limit
+  }
+
+  // Include offset for pagination support - different offsets need different query keys
+  if (options.offset !== undefined) {
+    result.offset = options.offset
+  }
+
+  return JSON.stringify(Object.keys(result).length === 0 ? null : result)
+}
+
+function serializeExpression(expr: IR.BasicExpression | undefined): unknown {
+  if (!expr) {
+    return null
+  }
+
+  switch (expr.type) {
+    case `val`:
+      return {
+        type: `val`,
+        value: serializeValue(expr.value),
+      }
+    case `ref`:
+      return {
+        type: `ref`,
+        path: [...expr.path],
+      }
+    case `func`:
+      return {
+        type: `func`,
+        name: expr.name,
+        args: expr.args.map((arg) => serializeExpression(arg)),
+      }
+    default:
+      return null
+  }
+}
+
+function serializeValue(value: unknown): unknown {
+  if (value === undefined) {
+    return { __type: `undefined` }
+  }
+
+  if (typeof value === `number`) {
+    if (Number.isNaN(value)) {
+      return { __type: `nan` }
+    }
+    if (value === Number.POSITIVE_INFINITY) {
+      return { __type: `infinity`, sign: 1 }
+    }
+    if (value === Number.NEGATIVE_INFINITY) {
+      return { __type: `infinity`, sign: -1 }
+    }
+  }
+
+  if (typeof value === `bigint`) {
+    return { __type: `bigint`, value: value.toString() }
+  }
+
+  if (
+    value === null ||
+    typeof value === `string` ||
+    typeof value === `number` ||
+    typeof value === `boolean`
+  ) {
+    return value
+  }
+
+  if (value instanceof Date) {
+    return { __type: `date`, value: value.toJSON() }
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeValue(item))
+  }
+
+  if (typeof value === `object`) {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).map(([key, val]) => [
+        key,
+        serializeValue(val),
+      ]),
+    )
+  }
+
+  return value
+}
+
+type Predicate<T> = (item: T) => boolean
+
+function isBasicExpression(
+  expr: IR.BasicExpression | null | undefined,
+): expr is IR.BasicExpression {
+  return expr != null
+}
+
+/**
+ * Apply LoadSubsetOptions to data (filter, sort, limit, offset)
+ */
+export function applyPredicates<T>(
+  data: Array<T>,
+  options: LoadSubsetOptions | undefined,
+): Array<T> {
+  if (!options) return data
+
+  // Parse options: try simple comparisons first (faster path), fall back to expression evaluation if needed
+  // extractSimpleComparisons (called by parseLoadSubsetOptions) intentionally throws for unsupported operators
+  // like 'like', 'ilike', 'or', etc. When that happens, we use buildExpressionPredicate instead.
+  let filters: Array<SimpleComparison> = []
+  let sorts: Array<ParsedOrderBy> = []
+  let limit: number | undefined = undefined
+  const offset = options.offset ?? 0
+
+  // Check if where clause is simple before trying to parse
+  const hasComplexWhere = options.where && !isSimpleExpression(options.where)
+
+  if (!hasComplexWhere) {
+    // Simple expression - parse everything at once
+    try {
+      const parsed = parseLoadSubsetOptions(options)
+      filters = parsed.filters
+      sorts = parsed.sorts
+      limit = parsed.limit
+    } catch (error) {
+      // This shouldn't happen for simple expressions, but handle it gracefully
+      if (DEBUG_SUMMARY) {
+        console.log(
+          `[query-filter] parseLoadSubsetOptions failed unexpectedly`,
+          error,
+        )
+      }
+      limit = options.limit
+    }
+  } else {
+    // Complex expression (like/ilike/or/etc.) - cannot use simple comparisons
+    // We'll filter using buildExpressionPredicate which evaluates the full expression tree
+    // filters stays empty - this signals buildFilterPredicate to use buildExpressionPredicate instead of buildSimplePredicate
+    // Note: Filtering still happens! Just via a different path (expression evaluation vs simple comparisons)
+
+    limit = options.limit
+
+    if (options.orderBy) {
+      try {
+        const orderByParsed = parseLoadSubsetOptions({
+          orderBy: options.orderBy,
+        })
+        sorts = orderByParsed.sorts
+      } catch {
+        // OrderBy parsing failed, will skip sorting
+        if (DEBUG_SUMMARY) {
+          console.log(`[query-filter] orderBy parsing failed, skipping sort`)
+        }
+      }
+    }
+
+    if (DEBUG_SUMMARY) {
+      console.log(
+        `[query-filter] complex where clause detected, will filter using buildExpressionPredicate`,
+      )
+    }
+  }
+
+  if (DEBUG_SUMMARY) {
+    const { limit: rawLimit, where, orderBy } = options
+    const analysis = analyzeExpression(where)
+    console.log(`[query-filter] loadSubsetOptions`, {
+      hasWhere: Boolean(where),
+      whereType: where?.type,
+      whereName: where?.type === `func` ? (where as IR.Func).name : undefined,
+      expressionSummary: analysis,
+      hasOrderBy: Boolean(orderBy),
+      limit: rawLimit,
+      offset,
+      filtersCount: filters.length,
+      sortsCount: sorts.length,
+      initialSize: data.length,
+    })
+  }
+
+  let result = [...data]
+
+  // Apply WHERE filtering
+  const predicate = buildFilterPredicate<T>(options.where, filters)
+  if (predicate) {
+    result = result.filter(predicate)
+    if (DEBUG_SUMMARY) {
+      console.log(`[query-filter] after where`, {
+        size: result.length,
+      })
+    }
+  }
+
+  // Apply ORDER BY
+  if (sorts.length > 0) {
+    result.sort((a, b) => compareBySorts(a, b, sorts))
+    if (DEBUG_SUMMARY) {
+      console.log(`[query-filter] after orderBy`, {
+        size: result.length,
+      })
+    }
+  }
+
+  // Apply OFFSET and LIMIT
+  // For pagination: offset skips rows, limit caps the result
+  if (offset > 0 || limit !== undefined) {
+    const start = offset
+    const end = limit !== undefined ? offset + limit : undefined
+    result = result.slice(start, end)
+    if (DEBUG_SUMMARY) {
+      console.log(`[query-filter] after offset/limit`, {
+        size: result.length,
+        offset,
+        limit,
+      })
+    }
+  }
+
+  return result
+}
+
+/**
+ * Build a predicate function from expression tree
+ *
+ * Two paths:
+ * 1. Simple expressions (eq, gt, etc.) with parsed filters -> buildSimplePredicate (faster)
+ * 2. Complex expressions (like, ilike, or, etc.) or empty filters -> buildExpressionPredicate (full expression evaluation)
+ */
+function buildFilterPredicate<T>(
+  where: IR.BasicExpression<boolean> | undefined,
+  filters: Array<SimpleComparison>,
+): Predicate<T> | undefined {
+  if (!where) {
+    return undefined
+  }
+
+  // Use simple predicate if we have parsed filters (fast path for eq, gt, etc.)
+  if (filters.length > 0 && isSimpleExpression(where)) {
+    return buildSimplePredicate<T>(filters)
+  }
+
+  // Otherwise, use expression predicate (handles like, ilike, or, etc.)
+  // This still filters! It just evaluates the expression tree directly instead of using parsed comparisons
+  try {
+    return buildExpressionPredicate<T>(where)
+  } catch (error) {
+    if (DEBUG_SUMMARY) {
+      console.warn(`[query-filter] failed to build expression predicate`, error)
+    }
+    return undefined
+  }
+}
+
+function buildSimplePredicate<T>(
+  filters: Array<SimpleComparison>,
+): Predicate<T> {
+  return (item: T) =>
+    filters.every((comparison) => evaluateSimpleComparison(comparison, item))
+}
+
+function evaluateSimpleComparison<T>(
+  comparison: SimpleComparison,
+  item: T,
+): boolean {
+  const actualValue = getFieldValue(item, comparison.field)
+  const expectedValue = comparison.value
+
+  switch (comparison.operator) {
+    case `eq`:
+      return actualValue === expectedValue
+    case `gt`:
+      return actualValue > expectedValue
+    case `gte`:
+      return actualValue >= expectedValue
+    case `lt`:
+      return actualValue < expectedValue
+    case `lte`:
+      return actualValue <= expectedValue
+    case `in`:
+      return Array.isArray(expectedValue)
+        ? expectedValue.includes(actualValue)
+        : false
+    case `isNull`:
+      return actualValue === null
+    case `isUndefined`:
+      return actualValue === undefined
+    // NOT-wrapped operators (flattened)
+    case `not_eq`:
+      return actualValue !== expectedValue
+    case `not_gt`:
+      return !(actualValue > expectedValue)
+    case `not_gte`:
+      return !(actualValue >= expectedValue)
+    case `not_lt`:
+      return !(actualValue < expectedValue)
+    case `not_lte`:
+      return !(actualValue <= expectedValue)
+    case `not_in`:
+      return Array.isArray(expectedValue)
+        ? !expectedValue.includes(actualValue)
+        : true
+    case `not_isNull`:
+      return actualValue !== null
+    case `not_isUndefined`:
+      return actualValue !== undefined
+    default:
+      throw new Error(
+        `Unsupported simple comparison operator: ${comparison.operator}`,
+      )
+  }
+}
+
+function isSimpleExpression(expr: IR.BasicExpression): boolean {
+  if (expr.type !== `func`) {
+    return false
+  }
+
+  if (expr.name === `and`) {
+    return expr.args.every(
+      (arg): arg is IR.BasicExpression =>
+        Boolean(arg) && arg.type === `func` && isSimpleExpression(arg),
+    )
+  }
+
+  // Handle NOT wrapping simple expressions
+  if (expr.name === `not`) {
+    const [arg] = expr.args
+    if (!arg || arg.type !== `func`) {
+      return false
+    }
+    // NOT can wrap comparison operators or null checks
+    return isSimpleExpression(arg)
+  }
+
+  if (!SIMPLE_OPERATORS.has(expr.name)) {
+    return false
+  }
+
+  // Null/undefined checks take a single ref argument
+  if (expr.name === `isNull` || expr.name === `isUndefined`) {
+    const [fieldArg] = expr.args
+    return fieldArg?.type === `ref`
+  }
+
+  // Comparison operators take ref and val arguments
+  const [leftArg, rightArg] = expr.args
+  return leftArg?.type === `ref` && rightArg?.type === `val`
+}
+
+function buildExpressionPredicate<T>(
+  expr: IR.BasicExpression<boolean>,
+): Predicate<T> {
+  return (item: T) => Boolean(evaluateExpression(expr, item))
+}
+
+function analyzeExpression(expr: IR.BasicExpression | undefined):
+  | {
+      hasIsNull: boolean
+      hasIsUndefined: boolean
+      hasEqNull: boolean
+      rootName?: string
+    }
+  | undefined {
+  if (!expr) return undefined
+
+  const summary = {
+    hasIsNull: false,
+    hasIsUndefined: false,
+    hasEqNull: false,
+    rootName: expr.type === `func` ? expr.name : undefined,
+  }
+
+  function walk(node: IR.BasicExpression): void {
+    if (node.type === `func`) {
+      if (node.name === `isNull`) summary.hasIsNull = true
+      if (node.name === `isUndefined`) summary.hasIsUndefined = true
+
+      if (node.name === `eq`) {
+        const right = node.args[1]
+        if (right?.type === `val` && right.value === null) {
+          summary.hasEqNull = true
+        }
+      }
+
+      node.args.filter(isBasicExpression).forEach((child) => walk(child))
+    }
+  }
+
+  walk(expr)
+  return summary
+}
+
+function evaluateExpression<T>(expr: IR.BasicExpression, item: T): any {
+  switch (expr.type) {
+    case `val`:
+      return expr.value
+    case `ref`:
+      return getFieldValue(item, expr.path)
+    case `func`: {
+      const args = expr.args.map((arg) => evaluateExpression(arg, item))
+      return evaluateFunction(expr.name, args)
+    }
+    default:
+      return undefined
+  }
+}
+
+function evaluateFunction(name: string, args: Array<any>): any {
+  if (DEBUG_VERBOSE) {
+    console.log(`[query-filter] operator=${name}`, args)
+  }
+  switch (name) {
+    case `eq`:
+      return args[0] === args[1]
+    case `neq`:
+    case `ne`:
+    case `notEq`:
+      return args[0] !== args[1]
+    case `gt`:
+      return args[0] > args[1]
+    case `gte`:
+      return args[0] >= args[1]
+    case `lt`:
+      return args[0] < args[1]
+    case `lte`:
+      return args[0] <= args[1]
+    case `and`:
+      return args.every(Boolean)
+    case `or`:
+      return args.some(Boolean)
+    case `not`:
+      return !args[0]
+    case `in`:
+    case `inArray`:
+      return Array.isArray(args[1]) ? args[1].includes(args[0]) : false
+    case `isNull`:
+      return args[0] === null
+    case `isNotNull`:
+      return args[0] !== null
+    case `isUndefined`:
+      return args[0] === undefined
+    case `isNotUndefined`:
+      return args[0] !== undefined
+    case `like`:
+      return evaluateLike(args[0], args[1], false)
+    case `ilike`:
+      return evaluateLike(args[0], args[1], true)
+    case `lower`:
+      return typeof args[0] === `string` ? args[0].toLowerCase() : args[0]
+    case `upper`:
+      return typeof args[0] === `string` ? args[0].toUpperCase() : args[0]
+    default:
+      throw new Error(`Unsupported predicate operator: ${name}`)
+  }
+}
+
+/**
+ * Evaluates LIKE/ILIKE patterns
+ * Converts SQL LIKE pattern to regex for JavaScript matching
+ * Returns null for 3-valued logic (UNKNOWN) when value or pattern is null/undefined
+ */
+function evaluateLike(
+  value: any,
+  pattern: any,
+  caseInsensitive: boolean,
+): boolean | null {
+  // In 3-valued logic, if value or pattern is null/undefined, return UNKNOWN (null)
+  if (
+    value === null ||
+    value === undefined ||
+    pattern === null ||
+    pattern === undefined
+  ) {
+    return null
+  }
+
+  if (typeof value !== `string` || typeof pattern !== `string`) {
+    return false
+  }
+
+  const searchValue = caseInsensitive ? value.toLowerCase() : value
+  const searchPattern = caseInsensitive ? pattern.toLowerCase() : pattern
+
+  // Convert SQL LIKE pattern to regex
+  // First escape all regex special chars except % and _
+  let regexPattern = searchPattern.replace(/[.*+?^${}()|[\]\\]/g, `\\$&`)
+
+  // Then convert SQL wildcards to regex
+  regexPattern = regexPattern.replace(/%/g, `.*`) // % matches any sequence
+  regexPattern = regexPattern.replace(/_/g, `.`) // _ matches any single char
+
+  const regex = new RegExp(`^${regexPattern}$`)
+  return regex.test(searchValue)
+}
+
+function compareBySorts<T>(a: T, b: T, sorts: Array<ParsedOrderBy>): number {
+  for (const sort of sorts) {
+    const aVal = getFieldValue(a, sort.field)
+    const bVal = getFieldValue(b, sort.field)
+
+    const result = compareValues(aVal, bVal, sort.direction, sort.nulls)
+    if (result !== 0) {
+      return result
+    }
+  }
+
+  return 0
+}
+
+function compareValues(
+  a: any,
+  b: any,
+  direction: `asc` | `desc`,
+  nulls?: `first` | `last`,
+): number {
+  const aNull = a === null || a === undefined
+  const bNull = b === null || b === undefined
+
+  if (aNull || bNull) {
+    if (aNull && bNull) return 0
+    if (nulls === `first`) {
+      return aNull ? -1 : 1
+    }
+    if (nulls === `last`) {
+      return aNull ? 1 : -1
+    }
+    // Default SQL behavior: treat nulls as lowest for ASC, highest for DESC
+    if (direction === `asc`) {
+      return aNull ? -1 : 1
+    }
+    return aNull ? 1 : -1
+  }
+
+  if (a < b) return direction === `asc` ? -1 : 1
+  if (a > b) return direction === `asc` ? 1 : -1
+  return 0
+}
+
+/**
+ * Get nested field value from object
+ */
+function getFieldValue(obj: any, fieldPath: Array<string | number>): any {
+  if (fieldPath.length === 0) {
+    return undefined
+  }
+
+  let path = fieldPath
+
+  if (
+    path.length > 0 &&
+    obj &&
+    typeof path[0] === `string` &&
+    !(path[0] in obj)
+  ) {
+    path = path.slice(1)
+  }
+
+  if (path.length === 0) {
+    if (DEBUG_VERBOSE) {
+      console.log(`[query-filter] getFieldValue alias`, fieldPath, `->`, obj)
+    }
+    return obj
+  }
+
+  const value = path.reduce((current, key) => current?.[key], obj)
+
+  if (DEBUG_VERBOSE) {
+    console.log(`[query-filter] getFieldValue`, fieldPath, `->`, value)
+  }
+
+  return value
+}
diff --git a/packages/query-db-collection/e2e/query.e2e.test.ts b/packages/query-db-collection/e2e/query.e2e.test.ts
new file mode 100644
index 000000000..1bda6ce26
--- /dev/null
+++ b/packages/query-db-collection/e2e/query.e2e.test.ts
@@ -0,0 +1,251 @@
+/**
+ * Query Collection E2E Tests
+ *
+ * Tests using Query collections with mock backend
+ */
+
+import { afterAll, afterEach, beforeAll, describe } from 'vitest'
+import { createCollection } from '@tanstack/db'
+import { QueryClient } from '@tanstack/query-core'
+import { queryCollectionOptions } from '../src/query'
+import {
+  createCollationTestSuite,
+  createDeduplicationTestSuite,
+  createJoinsTestSuite,
+  createLiveUpdatesTestSuite,
+  createMutationsTestSuite,
+  createPaginationTestSuite,
+  createPredicatesTestSuite,
+  generateSeedData,
+} from '../../db-collection-e2e/src/index'
+import { applyPredicates, buildQueryKey } from './query-filter'
+import type {
+  Comment as E2EComment,
+  Post as E2EPost,
+  E2ETestConfig,
+  User as E2EUser,
+} from '../../db-collection-e2e/src/types'
+
+describe(`Query Collection E2E Tests`, () => {
+  let config: E2ETestConfig
+  let queryClient: QueryClient
+
+  beforeAll(async () => {
+    // Make seed data mutable so mutations can modify it
+    const seedData = generateSeedData()
+
+    queryClient = new QueryClient({
+      defaultOptions: {
+        queries: {
+          staleTime: 0,
+          retry: false,
+        },
+      },
+    })
+
+    // Create REAL Query collections with mock backend queryFn
+    const eagerUsers = createCollection(
+      queryCollectionOptions({
+        id: `query-e2e-users-eager`,
+        queryClient,
+        queryKey: [`e2e`, `users`, `eager`],
+        queryFn: () => {
+          // Mock query function that returns seed data
+          return Promise.resolve(seedData.users)
+        },
+        getKey: (item: E2EUser) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const eagerPosts = createCollection(
+      queryCollectionOptions({
+        id: `query-e2e-posts-eager`,
+        queryClient,
+        queryKey: [`e2e`, `posts`, `eager`],
+        queryFn: () => {
+          return Promise.resolve(seedData.posts)
+        },
+        getKey: (item: E2EPost) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const eagerComments = createCollection(
+      queryCollectionOptions({
+        id: `query-e2e-comments-eager`,
+        queryClient,
+        queryKey: [`e2e`, `comments`, `eager`],
+        queryFn: () => {
+          return Promise.resolve(seedData.comments)
+        },
+        getKey: (item: E2EComment) => item.id,
+        startSync: true,
+      }),
+    )
+
+    const onDemandUsers = createCollection(
+      queryCollectionOptions({
+        id: `query-e2e-users-ondemand`,
+        queryClient,
+        // Function-based queryKey that derives a serializable key from predicate options
+        // This ensures different predicates create separate TanStack Query observers
+        queryKey: (opts) => buildQueryKey(`users`, opts),
+        syncMode: `on-demand`,
+        queryFn: (ctx) => {
+          const options = ctx.meta?.loadSubsetOptions
+          const filtered = applyPredicates(seedData.users, options)
+          return Promise.resolve(filtered)
+        },
+        getKey: (item: E2EUser) => item.id,
+        startSync: false,
+      }),
+    )
+
+    const onDemandPosts = createCollection(
+      queryCollectionOptions({
+        id: `query-e2e-posts-ondemand`,
+        queryClient,
+        queryKey: (opts) => buildQueryKey(`posts`, opts),
+        syncMode: `on-demand`,
+        queryFn: (ctx) => {
+          const options = ctx.meta?.loadSubsetOptions
+          const filtered = applyPredicates(seedData.posts, options)
+          return Promise.resolve(filtered)
+        },
+        getKey: (item: E2EPost) => item.id,
+        startSync: false,
+      }),
+    )
+
+    const onDemandComments = createCollection(
+      queryCollectionOptions({
+        id: `query-e2e-comments-ondemand`,
+        queryClient,
+        queryKey: (opts) => buildQueryKey(`comments`, opts),
+        syncMode: `on-demand`,
+        queryFn: (ctx) => {
+          const options = ctx.meta?.loadSubsetOptions
+          const filtered = applyPredicates(seedData.comments, options)
+          return Promise.resolve(filtered)
+        },
+        getKey: (item: E2EComment) => item.id,
+        startSync: false,
+      }),
+    )
+
+    // Wait for eager collections to load
+    await eagerUsers.preload()
+    await eagerPosts.preload()
+    await eagerComments.preload()
+
+    // On-demand collections don't start automatically
+    await onDemandUsers.preload()
+    await onDemandPosts.preload()
+    await onDemandComments.preload()
+
+    config = {
+      collections: {
+        eager: {
+          users: eagerUsers as any,
+          posts: eagerPosts as any,
+          comments: eagerComments as any,
+        },
+        onDemand: {
+          users: onDemandUsers as any,
+          posts: onDemandPosts as any,
+          comments: onDemandComments as any,
+        },
+      },
+      // Mutations for Query collections - modify seed data and invalidate queries
+      mutations: {
+        insertUser: async (user) => {
+          console.log(`[mutation] insertUser called, id=${user.id}`)
+          seedData.users.push(user)
+          console.log(`[mutation] calling invalidateQueries`)
+          await queryClient.invalidateQueries({ queryKey: [`e2e`, `users`] })
+          console.log(`[mutation] invalidateQueries completed`)
+        },
+        updateUser: async (id, updates) => {
+          console.log(`[mutation] updateUser called, id=${id}`)
+          const userIndex = seedData.users.findIndex((u) => u.id === id)
+          if (userIndex !== -1) {
+            seedData.users[userIndex] = {
+              ...seedData.users[userIndex]!,
+              ...updates,
+            }
+            console.log(`[mutation] calling invalidateQueries`)
+            await queryClient.invalidateQueries({ queryKey: [`e2e`, `users`] })
+            console.log(`[mutation] invalidateQueries completed`)
+          }
+        },
+        deleteUser: async (id) => {
+          console.log(`[mutation] deleteUser called, id=${id}`)
+          const userIndex = seedData.users.findIndex((u) => u.id === id)
+          if (userIndex !== -1) {
+            seedData.users.splice(userIndex, 1)
+            console.log(`[mutation] calling invalidateQueries`)
+            await queryClient.invalidateQueries({ queryKey: [`e2e`, `users`] })
+            console.log(`[mutation] invalidateQueries completed`)
+          }
+        },
+        insertPost: async (post) => {
+          seedData.posts.push(post)
+          await queryClient.invalidateQueries({ queryKey: [`e2e`, `posts`] })
+        },
+      },
+      setup: async () => {},
+      afterEach: async () => {
+        // Clean up and restart on-demand collections
+        // This validates cleanup() works and each test starts fresh
+        await onDemandUsers.cleanup()
+        await onDemandPosts.cleanup()
+        await onDemandComments.cleanup()
+
+        // Restart sync after cleanup
+        onDemandUsers.startSyncImmediate()
+        onDemandPosts.startSyncImmediate()
+        onDemandComments.startSyncImmediate()
+
+        // Wait for collections to be ready
+        await onDemandUsers.preload()
+        await onDemandPosts.preload()
+        await onDemandComments.preload()
+      },
+      teardown: async () => {
+        await Promise.all([
+          eagerUsers.cleanup(),
+          eagerPosts.cleanup(),
+          eagerComments.cleanup(),
+          onDemandUsers.cleanup(),
+          onDemandPosts.cleanup(),
+          onDemandComments.cleanup(),
+        ])
+        queryClient.clear()
+      },
+    }
+  })
+
+  afterEach(async () => {
+    if (config.afterEach) {
+      await config.afterEach()
+    }
+  })
+
+  afterAll(async () => {
+    await config.teardown()
+  })
+
+  function getConfig() {
+    return Promise.resolve(config)
+  }
+
+  // Run all test suites
+  createPredicatesTestSuite(getConfig)
+  createPaginationTestSuite(getConfig)
+  createJoinsTestSuite(getConfig)
+  createDeduplicationTestSuite(getConfig)
+  createCollationTestSuite(getConfig)
+  createMutationsTestSuite(getConfig)
+  createLiveUpdatesTestSuite(getConfig)
+})
diff --git a/packages/query-db-collection/package.json b/packages/query-db-collection/package.json
index 35f161069..2906f4525 100644
--- a/packages/query-db-collection/package.json
+++ b/packages/query-db-collection/package.json
@@ -1,15 +1,32 @@
 {
   "name": "@tanstack/query-db-collection",
+  "version": "1.0.21",
   "description": "TanStack Query collection for TanStack DB",
-  "version": "0.2.32",
-  "dependencies": {
-    "@standard-schema/spec": "^1.0.0",
-    "@tanstack/db": "workspace:*"
+  "author": "Kyle Mathews",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/db.git",
+    "directory": "packages/query-db-collection"
   },
-  "devDependencies": {
-    "@tanstack/query-core": "^5.90.5",
-    "@vitest/coverage-istanbul": "^3.2.4"
+  "homepage": "https://tanstack.com/db",
+  "keywords": [
+    "query",
+    "tanstack",
+    "optimistic",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "lint": "eslint . --fix",
+    "test": "vitest run",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts"
   },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -23,38 +40,21 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
-  "packageManager": "pnpm@10.18.3",
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "@tanstack/db": "workspace:*"
+  },
   "peerDependencies": {
     "@tanstack/query-core": "^5.0.0",
     "typescript": ">=4.7"
   },
-  "author": "Kyle Mathews",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/TanStack/db.git",
-    "directory": "packages/query-db-collection"
-  },
-  "homepage": "https://tanstack.com/db",
-  "keywords": [
-    "query",
-    "tanstack",
-    "optimistic",
-    "typescript"
-  ],
-  "scripts": {
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "lint": "eslint . --fix",
-    "test": "npx vitest --run"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "devDependencies": {
+    "@tanstack/query-core": "^5.90.16",
+    "@vitest/coverage-istanbul": "^3.2.4"
+  }
 }
diff --git a/packages/query-db-collection/src/errors.ts b/packages/query-db-collection/src/errors.ts
index d14e69ff0..722474525 100644
--- a/packages/query-db-collection/src/errors.ts
+++ b/packages/query-db-collection/src/errors.ts
@@ -1,4 +1,4 @@
-import { TanStackDBError } from "@tanstack/db"
+import { TanStackDBError } from '@tanstack/db'
 
 // Query Collection Errors
 export class QueryCollectionError extends TanStackDBError {
@@ -39,7 +39,7 @@ export class GetKeyRequiredError extends QueryCollectionError {
 export class SyncNotInitializedError extends QueryCollectionError {
   constructor() {
     super(
-      `Collection must be in 'ready' state for manual sync operations. Sync not initialized yet.`
+      `Collection must be in 'ready' state for manual sync operations. Sync not initialized yet.`,
     )
     this.name = `SyncNotInitializedError`
   }
diff --git a/packages/query-db-collection/src/global.ts b/packages/query-db-collection/src/global.ts
new file mode 100644
index 000000000..281ed99b4
--- /dev/null
+++ b/packages/query-db-collection/src/global.ts
@@ -0,0 +1,40 @@
+/**
+ * Global type augmentation for @tanstack/query-core
+ *
+ * This file ensures the module augmentation is always loaded when the package is imported.
+ * The index.ts file re-exports QueryCollectionMeta from this file, which guarantees
+ * TypeScript processes this file (and its module augmentation) whenever anyone imports
+ * from @tanstack/query-db-collection.
+ *
+ * This makes ctx.meta?.loadSubsetOptions automatically type-safe without requiring
+ * users to manually import QueryCollectionMeta.
+ */
+
+import type { LoadSubsetOptions } from '@tanstack/db'
+
+/**
+ * Base interface for Query Collection meta properties.
+ * Users can extend this interface to add their own custom properties while
+ * preserving loadSubsetOptions.
+ *
+ * @example
+ * ```typescript
+ * declare module "@tanstack/query-db-collection" {
+ *   interface QueryCollectionMeta {
+ *     myCustomProperty: string
+ *     userId?: number
+ *   }
+ * }
+ * ```
+ */
+export interface QueryCollectionMeta extends Record<string, unknown> {
+  loadSubsetOptions: LoadSubsetOptions
+}
+
+// Module augmentation to extend TanStack Query's Register interface
+// This ensures that ctx.meta always includes loadSubsetOptions
+declare module '@tanstack/query-core' {
+  interface Register {
+    queryMeta: QueryCollectionMeta
+  }
+}
diff --git a/packages/query-db-collection/src/index.ts b/packages/query-db-collection/src/index.ts
index 42b47e419..14a5fe702 100644
--- a/packages/query-db-collection/src/index.ts
+++ b/packages/query-db-collection/src/index.ts
@@ -1,8 +1,27 @@
+// Export QueryCollectionMeta from global.ts
+// This ensures the module augmentation in global.ts is processed by TypeScript
+export type { QueryCollectionMeta } from './global'
+
 export {
   queryCollectionOptions,
   type QueryCollectionConfig,
   type QueryCollectionUtils,
   type SyncOperation,
-} from "./query"
+} from './query'
+
+export * from './errors'
 
-export * from "./errors"
+// Re-export expression helpers from @tanstack/db
+export {
+  parseWhereExpression,
+  parseOrderByExpression,
+  extractSimpleComparisons,
+  parseLoadSubsetOptions,
+  extractFieldPath,
+  extractValue,
+  walkExpression,
+  type FieldPath,
+  type SimpleComparison,
+  type ParseWhereOptions,
+  type ParsedOrderBy,
+} from '@tanstack/db'
diff --git a/packages/query-db-collection/src/manual-sync.ts b/packages/query-db-collection/src/manual-sync.ts
index f783eb119..addf6808b 100644
--- a/packages/query-db-collection/src/manual-sync.ts
+++ b/packages/query-db-collection/src/manual-sync.ts
@@ -3,9 +3,9 @@ import {
   DuplicateKeyInBatchError,
   SyncNotInitializedError,
   UpdateOperationItemNotFoundError,
-} from "./errors"
-import type { QueryClient } from "@tanstack/query-core"
-import type { ChangeMessage, Collection } from "@tanstack/db"
+} from './errors'
+import type { QueryClient } from '@tanstack/query-core'
+import type { ChangeMessage, Collection } from '@tanstack/db'
 
 // Track active batch operations per context to prevent cross-collection contamination
 const activeBatchContexts = new WeakMap<
@@ -35,9 +35,20 @@ export interface SyncContext<
   queryClient: QueryClient
   queryKey: Array<unknown>
   getKey: (item: TRow) => TKey
-  begin: () => void
+  /**
+   * Begin a new sync transaction.
+   * @param options.immediate - When true, the transaction will be processed immediately
+   *   even if there are persisting user transactions. Used by manual write operations.
+   */
+  begin: (options?: { immediate?: boolean }) => void
   write: (message: Omit<ChangeMessage<TRow>, `key`>) => void
   commit: () => void
+  /**
+   * Optional function to update the query cache with the latest synced data.
+   * Handles both direct array caches and wrapped response formats (when `select` is used).
+   * If not provided, falls back to directly setting the cache with the raw array.
+   */
+  updateCacheData?: (items: Array<TRow>) => void
 }
 
 interface NormalizedOperation<
@@ -58,7 +69,7 @@ function normalizeOperations<
   ops:
     | SyncOperation<TRow, TKey, TInsertInput>
     | Array<SyncOperation<TRow, TKey, TInsertInput>>,
-  ctx: SyncContext<TRow, TKey>
+  ctx: SyncContext<TRow, TKey>,
 ): Array<NormalizedOperation<TRow, TKey>> {
   const operations = Array.isArray(ops) ? ops : [ops]
   const normalized: Array<NormalizedOperation<TRow, TKey>> = []
@@ -80,7 +91,7 @@ function normalizeOperations<
           // For insert/upsert, validate and resolve the full item first
           const resolved = ctx.collection.validateData(
             item,
-            op.type === `upsert` ? `insert` : op.type
+            op.type === `upsert` ? `insert` : op.type,
           )
           key = ctx.getKey(resolved)
         }
@@ -98,7 +109,7 @@ function validateOperations<
   TKey extends string | number = string | number,
 >(
   operations: Array<NormalizedOperation<TRow, TKey>>,
-  ctx: SyncContext<TRow, TKey>
+  ctx: SyncContext<TRow, TKey>,
 ): void {
   const seenKeys = new Set<TKey>()
 
@@ -110,12 +121,14 @@ function validateOperations<
     seenKeys.add(op.key)
 
     // Validate operation-specific requirements
+    // NOTE: These validations check the synced store only, not the combined view (synced + optimistic)
+    // This allows write operations to work correctly even when items are optimistically modified
     if (op.type === `update`) {
-      if (!ctx.collection.has(op.key)) {
+      if (!ctx.collection._state.syncedData.has(op.key)) {
         throw new UpdateOperationItemNotFoundError(op.key)
       }
     } else if (op.type === `delete`) {
-      if (!ctx.collection.has(op.key)) {
+      if (!ctx.collection._state.syncedData.has(op.key)) {
         throw new DeleteOperationItemNotFoundError(op.key)
       }
     }
@@ -131,12 +144,14 @@ export function performWriteOperations<
   operations:
     | SyncOperation<TRow, TKey, TInsertInput>
     | Array<SyncOperation<TRow, TKey, TInsertInput>>,
-  ctx: SyncContext<TRow, TKey>
+  ctx: SyncContext<TRow, TKey>,
 ): void {
   const normalized = normalizeOperations(operations, ctx)
   validateOperations(normalized, ctx)
 
-  ctx.begin()
+  // Use immediate: true to ensure syncedData is updated synchronously,
+  // even when called from within a mutationFn with an active persisting transaction
+  ctx.begin({ immediate: true })
 
   for (const op of normalized) {
     switch (op.type) {
@@ -149,7 +164,8 @@ export function performWriteOperations<
         break
       }
       case `update`: {
-        const currentItem = ctx.collection.get(op.key)!
+        // Get from synced store only, not the combined view
+        const currentItem = ctx.collection._state.syncedData.get(op.key)!
         const updatedItem = {
           ...currentItem,
           ...op.data,
@@ -157,7 +173,7 @@ export function performWriteOperations<
         const resolved = ctx.collection.validateData(
           updatedItem,
           `update`,
-          op.key
+          op.key,
         )
         ctx.write({
           type: `update`,
@@ -166,7 +182,8 @@ export function performWriteOperations<
         break
       }
       case `delete`: {
-        const currentItem = ctx.collection.get(op.key)!
+        // Get from synced store only, not the combined view
+        const currentItem = ctx.collection._state.syncedData.get(op.key)!
         ctx.write({
           type: `delete`,
           value: currentItem,
@@ -174,12 +191,14 @@ export function performWriteOperations<
         break
       }
       case `upsert`: {
+        // Check synced store only, not the combined view
+        const existsInSyncedStore = ctx.collection._state.syncedData.has(op.key)
         const resolved = ctx.collection.validateData(
           op.data,
-          ctx.collection.has(op.key) ? `update` : `insert`,
-          op.key
+          existsInSyncedStore ? `update` : `insert`,
+          op.key,
         )
-        if (ctx.collection.has(op.key)) {
+        if (existsInSyncedStore) {
           ctx.write({
             type: `update`,
             value: resolved,
@@ -198,8 +217,13 @@ export function performWriteOperations<
   ctx.commit()
 
   // Update query cache after successful commit
-  const updatedData = ctx.collection.toArray
-  ctx.queryClient.setQueryData(ctx.queryKey, updatedData)
+  const updatedData = Array.from(ctx.collection._state.syncedData.values())
+  if (ctx.updateCacheData) {
+    ctx.updateCacheData(updatedData)
+  } else {
+    // Fallback: directly set the cache with raw array (for non-Query Collection consumers)
+    ctx.queryClient.setQueryData(ctx.queryKey, updatedData)
+  }
 }
 
 // Factory function to create write utils
@@ -294,7 +318,7 @@ export function createWriteUtils<
       const existingBatch = activeBatchContexts.get(ctx)
       if (existingBatch?.isActive) {
         throw new Error(
-          `Cannot nest writeBatch calls. Complete the current batch before starting a new one.`
+          `Cannot nest writeBatch calls. Complete the current batch before starting a new one.`,
         )
       }
 
@@ -320,7 +344,7 @@ export function createWriteUtils<
           typeof result.then === `function`
         ) {
           throw new Error(
-            `writeBatch does not support async callbacks. The callback must be synchronous.`
+            `writeBatch does not support async callbacks. The callback must be synchronous.`,
           )
         }
 
diff --git a/packages/query-db-collection/src/query.ts b/packages/query-db-collection/src/query.ts
index 2d53105cc..6b3f83a90 100644
--- a/packages/query-db-collection/src/query.ts
+++ b/packages/query-db-collection/src/query.ts
@@ -1,31 +1,36 @@
-import { QueryObserver } from "@tanstack/query-core"
+import { QueryObserver, hashKey } from '@tanstack/query-core'
+import { deepEquals } from '@tanstack/db'
 import {
   GetKeyRequiredError,
   QueryClientRequiredError,
   QueryFnRequiredError,
   QueryKeyRequiredError,
-} from "./errors"
-import { createWriteUtils } from "./manual-sync"
-import type {
-  QueryClient,
-  QueryFunctionContext,
-  QueryKey,
-  QueryObserverOptions,
-} from "@tanstack/query-core"
+} from './errors'
+import { createWriteUtils } from './manual-sync'
+import { serializeLoadSubsetOptions } from './serialization'
 import type {
   BaseCollectionConfig,
   ChangeMessage,
   CollectionConfig,
   DeleteMutationFnParams,
   InsertMutationFnParams,
+  LoadSubsetOptions,
   SyncConfig,
   UpdateMutationFnParams,
   UtilsRecord,
-} from "@tanstack/db"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+} from '@tanstack/db'
+import type {
+  FetchStatus,
+  QueryClient,
+  QueryFunctionContext,
+  QueryKey,
+  QueryObserverOptions,
+  QueryObserverResult,
+} from '@tanstack/query-core'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 // Re-export for external use
-export type { SyncOperation } from "./manual-sync"
+export type { SyncOperation } from './manual-sync'
 
 // Schema output type inference helper (matches electric.ts pattern)
 type InferSchemaOutput<T> = T extends StandardSchemaV1
@@ -41,6 +46,8 @@ type InferSchemaInput<T> = T extends StandardSchemaV1
     : Record<string, unknown>
   : Record<string, unknown>
 
+type TQueryKeyBuilder<TQueryKey> = (opts: LoadSubsetOptions) => TQueryKey
+
 /**
  * Configuration options for creating a Query Collection
  * @template T - The explicit type of items stored in the collection
@@ -53,7 +60,7 @@ type InferSchemaInput<T> = T extends StandardSchemaV1
 export interface QueryCollectionConfig<
   T extends object = object,
   TQueryFn extends (context: QueryFunctionContext<any>) => Promise<any> = (
-    context: QueryFunctionContext<any>
+    context: QueryFunctionContext<any>,
   ) => Promise<any>,
   TError = unknown,
   TQueryKey extends QueryKey = QueryKey,
@@ -62,10 +69,10 @@ export interface QueryCollectionConfig<
   TQueryData = Awaited<ReturnType<TQueryFn>>,
 > extends BaseCollectionConfig<T, TKey, TSchema> {
   /** The query key used by TanStack Query to identify this query */
-  queryKey: TQueryKey
+  queryKey: TQueryKey | TQueryKeyBuilder<TQueryKey>
   /** Function that fetches data from the server. Must return the complete collection state */
   queryFn: TQueryFn extends (
-    context: QueryFunctionContext<TQueryKey>
+    context: QueryFunctionContext<TQueryKey>,
   ) => Promise<Array<any>>
     ? (context: QueryFunctionContext<TQueryKey>) => Promise<Array<T>>
     : TQueryFn
@@ -131,8 +138,11 @@ export interface QueryCollectionConfig<
 
 /**
  * Type for the refetch utility function
+ * Returns the QueryObserverResult from TanStack Query
  */
-export type RefetchFn = (opts?: { throwOnError?: boolean }) => Promise<void>
+export type RefetchFn = (opts?: {
+  throwOnError?: boolean
+}) => Promise<Array<QueryObserverResult<any, any> | void>>
 
 /**
  * Utility methods available on Query Collections for direct writes and manual operations.
@@ -160,15 +170,28 @@ export interface QueryCollectionUtils<
   writeUpsert: (data: Partial<TItem> | Array<Partial<TItem>>) => void
   /** Execute multiple write operations as a single atomic batch to the synced data store */
   writeBatch: (callback: () => void) => void
+
+  // Query Observer State (getters)
   /** Get the last error encountered by the query (if any); reset on success */
-  lastError: () => TError | undefined
+  lastError: TError | undefined
   /** Check if the collection is in an error state */
-  isError: () => boolean
+  isError: boolean
   /**
    * Get the number of consecutive sync failures.
    * Incremented only when query fails completely (not per retry attempt); reset on success.
    */
-  errorCount: () => number
+  errorCount: number
+  /** Check if query is currently fetching (initial or background) */
+  isFetching: boolean
+  /** Check if query is refetching in background (not initial fetch) */
+  isRefetching: boolean
+  /** Check if query is loading for the first time (no data yet) */
+  isLoading: boolean
+  /** Get timestamp of last successful data update (in milliseconds) */
+  dataUpdatedAt: number
+  /** Get current fetch status */
+  fetchStatus: `fetching` | `paused` | `idle`
+
   /**
    * Clear the error state and trigger a refetch of the query
    * @returns Promise that resolves when the refetch completes successfully
@@ -177,6 +200,111 @@ export interface QueryCollectionUtils<
   clearError: () => Promise<void>
 }
 
+/**
+ * Internal state object for tracking query observer and errors
+ */
+interface QueryCollectionState {
+  lastError: any
+  errorCount: number
+  lastErrorUpdatedAt: number
+  observers: Map<
+    string,
+    QueryObserver<Array<any>, any, Array<any>, Array<any>, any>
+  >
+}
+
+/**
+ * Implementation class for QueryCollectionUtils with explicit dependency injection
+ * for better testability and architectural clarity
+ */
+class QueryCollectionUtilsImpl {
+  private state: QueryCollectionState
+  private refetchFn: RefetchFn
+
+  // Write methods
+  public refetch: RefetchFn
+  public writeInsert: any
+  public writeUpdate: any
+  public writeDelete: any
+  public writeUpsert: any
+  public writeBatch: any
+
+  constructor(
+    state: QueryCollectionState,
+    refetch: RefetchFn,
+    writeUtils: ReturnType<typeof createWriteUtils>,
+  ) {
+    this.state = state
+    this.refetchFn = refetch
+
+    // Initialize methods to use passed dependencies
+    this.refetch = refetch
+    this.writeInsert = writeUtils.writeInsert
+    this.writeUpdate = writeUtils.writeUpdate
+    this.writeDelete = writeUtils.writeDelete
+    this.writeUpsert = writeUtils.writeUpsert
+    this.writeBatch = writeUtils.writeBatch
+  }
+
+  public async clearError() {
+    this.state.lastError = undefined
+    this.state.errorCount = 0
+    this.state.lastErrorUpdatedAt = 0
+    await this.refetchFn({ throwOnError: true })
+  }
+
+  // Getters for error state
+  public get lastError() {
+    return this.state.lastError
+  }
+
+  public get isError() {
+    return !!this.state.lastError
+  }
+
+  public get errorCount() {
+    return this.state.errorCount
+  }
+
+  // Getters for QueryObserver state
+  public get isFetching() {
+    // check if any observer is fetching
+    return Array.from(this.state.observers.values()).some(
+      (observer) => observer.getCurrentResult().isFetching,
+    )
+  }
+
+  public get isRefetching() {
+    // check if any observer is refetching
+    return Array.from(this.state.observers.values()).some(
+      (observer) => observer.getCurrentResult().isRefetching,
+    )
+  }
+
+  public get isLoading() {
+    // check if any observer is loading
+    return Array.from(this.state.observers.values()).some(
+      (observer) => observer.getCurrentResult().isLoading,
+    )
+  }
+
+  public get dataUpdatedAt() {
+    // compute the max dataUpdatedAt of all observers
+    return Math.max(
+      0,
+      ...Array.from(this.state.observers.values()).map(
+        (observer) => observer.getCurrentResult().dataUpdatedAt,
+      ),
+    )
+  }
+
+  public get fetchStatus(): Array<FetchStatus> {
+    return Array.from(this.state.observers.values()).map(
+      (observer) => observer.getCurrentResult().fetchStatus,
+    )
+  }
+}
+
 /**
  * Creates query collection options for use with a standard Collection.
  * This integrates TanStack Query with TanStack DB for automatic synchronization.
@@ -281,8 +409,13 @@ export function queryCollectionOptions<
   > & {
     schema: T
     select: (data: TQueryData) => Array<InferSchemaInput<T>>
-  }
-): CollectionConfig<InferSchemaOutput<T>, TKey, T> & {
+  },
+): CollectionConfig<
+  InferSchemaOutput<T>,
+  TKey,
+  T,
+  QueryCollectionUtils<InferSchemaOutput<T>, TKey, InferSchemaInput<T>, TError>
+> & {
   schema: T
   utils: QueryCollectionUtils<
     InferSchemaOutput<T>,
@@ -296,7 +429,7 @@ export function queryCollectionOptions<
 export function queryCollectionOptions<
   T extends object,
   TQueryFn extends (context: QueryFunctionContext<any>) => Promise<any> = (
-    context: QueryFunctionContext<any>
+    context: QueryFunctionContext<any>,
   ) => Promise<any>,
   TError = unknown,
   TQueryKey extends QueryKey = QueryKey,
@@ -314,8 +447,13 @@ export function queryCollectionOptions<
   > & {
     schema?: never // prohibit schema
     select: (data: TQueryData) => Array<T>
-  }
-): CollectionConfig<T, TKey> & {
+  },
+): CollectionConfig<
+  T,
+  TKey,
+  never,
+  QueryCollectionUtils<T, TKey, T, TError>
+> & {
   schema?: never // no schema in the result
   utils: QueryCollectionUtils<T, TKey, T, TError>
 }
@@ -330,7 +468,7 @@ export function queryCollectionOptions<
   config: QueryCollectionConfig<
     InferSchemaOutput<T>,
     (
-      context: QueryFunctionContext<any>
+      context: QueryFunctionContext<any>,
     ) => Promise<Array<InferSchemaOutput<T>>>,
     TError,
     TQueryKey,
@@ -338,8 +476,13 @@ export function queryCollectionOptions<
     T
   > & {
     schema: T
-  }
-): CollectionConfig<InferSchemaOutput<T>, TKey, T> & {
+  },
+): CollectionConfig<
+  InferSchemaOutput<T>,
+  TKey,
+  T,
+  QueryCollectionUtils<InferSchemaOutput<T>, TKey, InferSchemaInput<T>, TError>
+> & {
   schema: T
   utils: QueryCollectionUtils<
     InferSchemaOutput<T>,
@@ -364,15 +507,25 @@ export function queryCollectionOptions<
     TKey
   > & {
     schema?: never // prohibit schema
-  }
-): CollectionConfig<T, TKey> & {
+  },
+): CollectionConfig<
+  T,
+  TKey,
+  never,
+  QueryCollectionUtils<T, TKey, T, TError>
+> & {
   schema?: never // no schema in the result
   utils: QueryCollectionUtils<T, TKey, T, TError>
 }
 
 export function queryCollectionOptions(
-  config: QueryCollectionConfig<Record<string, unknown>>
-): CollectionConfig & {
+  config: QueryCollectionConfig<Record<string, unknown>>,
+): CollectionConfig<
+  Record<string, unknown>,
+  string | number,
+  never,
+  QueryCollectionUtils
+> & {
   utils: QueryCollectionUtils
 } {
   const {
@@ -393,6 +546,9 @@ export function queryCollectionOptions(
     ...baseCollectionConfig
   } = config
 
+  // Default to eager sync mode if not provided
+  const syncMode = baseCollectionConfig.syncMode ?? `eager`
+
   // Validate required parameters
 
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -414,197 +570,656 @@ export function queryCollectionOptions(
     throw new GetKeyRequiredError()
   }
 
-  /** The last error encountered by the query */
-  let lastError: any
-  /** The number of consecutive sync failures */
-  let errorCount = 0
-  /** The timestamp for when the query most recently returned the status as "error" */
-  let lastErrorUpdatedAt = 0
+  /** State object to hold error tracking and observer reference */
+  const state: QueryCollectionState = {
+    lastError: undefined as any,
+    errorCount: 0,
+    lastErrorUpdatedAt: 0,
+    observers: new Map<
+      string,
+      QueryObserver<Array<any>, any, Array<any>, Array<any>, any>
+    >(),
+  }
+
+  // hashedQueryKey → queryKey
+  const hashToQueryKey = new Map<string, QueryKey>()
+
+  // queryKey → Set<RowKey>
+  const queryToRows = new Map<string, Set<string | number>>()
+
+  // RowKey → Set<queryKey>
+  const rowToQueries = new Map<string | number, Set<string>>()
+
+  // queryKey → QueryObserver's unsubscribe function
+  const unsubscribes = new Map<string, () => void>()
+
+  // queryKey → reference count (how many loadSubset calls are active)
+  // Reference counting for QueryObserver lifecycle management
+  // =========================================================
+  // Tracks how many live query subscriptions are using each QueryObserver.
+  // Multiple live queries with identical predicates share the same QueryObserver for efficiency.
+  //
+  // Lifecycle:
+  // - Increment: when createQueryFromOpts creates or reuses an observer
+  // - Decrement: when subscription.unsubscribe() passes predicates to collection._sync.unloadSubset()
+  // - Reset: when cleanupQuery() is triggered by TanStack Query's cache GC
+  //
+  // When refcount reaches 0, unloadSubset():
+  // 1. Computes the same queryKey from the predicates
+  // 2. Uses existing machinery (queryToRows map) to find rows that query loaded
+  // 3. Decrements refcount and GCs rows where count reaches 0
+  const queryRefCounts = new Map<string, number>()
+
+  // Helper function to add a row to the internal state
+  const addRow = (rowKey: string | number, hashedQueryKey: string) => {
+    const rowToQueriesSet = rowToQueries.get(rowKey) || new Set()
+    rowToQueriesSet.add(hashedQueryKey)
+    rowToQueries.set(rowKey, rowToQueriesSet)
+
+    const queryToRowsSet = queryToRows.get(hashedQueryKey) || new Set()
+    queryToRowsSet.add(rowKey)
+    queryToRows.set(hashedQueryKey, queryToRowsSet)
+  }
+
+  // Helper function to remove a row from the internal state
+  const removeRow = (rowKey: string | number, hashedQuerKey: string) => {
+    const rowToQueriesSet = rowToQueries.get(rowKey) || new Set()
+    rowToQueriesSet.delete(hashedQuerKey)
+    rowToQueries.set(rowKey, rowToQueriesSet)
+
+    const queryToRowsSet = queryToRows.get(hashedQuerKey) || new Set()
+    queryToRowsSet.delete(rowKey)
+    queryToRows.set(hashedQuerKey, queryToRowsSet)
+
+    return rowToQueriesSet.size === 0
+  }
 
   const internalSync: SyncConfig<any>[`sync`] = (params) => {
     const { begin, write, commit, markReady, collection } = params
 
-    const observerOptions: QueryObserverOptions<
-      Array<any>,
-      any,
-      Array<any>,
-      Array<any>,
-      any
-    > = {
-      queryKey: queryKey,
-      queryFn: queryFn,
-      meta: meta,
-      enabled: enabled,
-      refetchInterval: refetchInterval,
-      retry: retry,
-      retryDelay: retryDelay,
-      staleTime: staleTime,
-      structuralSharing: true,
-      notifyOnChangeProps: `all`,
+    // Track whether sync has been started
+    let syncStarted = false
+
+    /**
+     * Generate a consistent query key from LoadSubsetOptions.
+     * CRITICAL: Must use identical logic in both createQueryFromOpts and unloadSubset
+     * so that refcount increment/decrement operations target the same hashedQueryKey.
+     * Inconsistent keys would cause refcount leaks and prevent proper cleanup.
+     */
+    const generateQueryKeyFromOptions = (opts: LoadSubsetOptions): QueryKey => {
+      if (typeof queryKey === `function`) {
+        // Function-based queryKey: use it to build the key from opts
+        return queryKey(opts)
+      } else if (syncMode === `on-demand`) {
+        // Static queryKey in on-demand mode: automatically append serialized predicates
+        // to create separate cache entries for different predicate combinations
+        const serialized = serializeLoadSubsetOptions(opts)
+        return serialized !== undefined ? [...queryKey, serialized] : queryKey
+      } else {
+        // Static queryKey in eager mode: use as-is
+        return queryKey
+      }
     }
 
-    const localObserver = new QueryObserver<
-      Array<any>,
-      any,
-      Array<any>,
-      Array<any>,
-      any
-    >(queryClient, observerOptions)
-
-    let isSubscribed = false
-    let actualUnsubscribeFn: (() => void) | null = null
-
-    type UpdateHandler = Parameters<typeof localObserver.subscribe>[0]
-    const handleQueryResult: UpdateHandler = (result) => {
-      if (result.isSuccess) {
-        // Clear error state
-        lastError = undefined
-        errorCount = 0
-
-        const rawData = result.data
-        const newItemsArray = select ? select(rawData) : rawData
-
-        if (
-          !Array.isArray(newItemsArray) ||
-          newItemsArray.some((item) => typeof item !== `object`)
-        ) {
-          const errorMessage = select
-            ? `@tanstack/query-db-collection: select() must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey)}`
-            : `@tanstack/query-db-collection: queryFn must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey)}`
-
-          console.error(errorMessage)
-          return
-        }
+    const createQueryFromOpts = (
+      opts: LoadSubsetOptions = {},
+      queryFunction: typeof queryFn = queryFn,
+    ): true | Promise<void> => {
+      // Generate key using common function
+      const key = generateQueryKeyFromOptions(opts)
+      const hashedQueryKey = hashKey(key)
+      const extendedMeta = { ...meta, loadSubsetOptions: opts }
 
-        const currentSyncedItems: Map<string | number, any> = new Map(
-          collection._state.syncedData.entries()
+      if (state.observers.has(hashedQueryKey)) {
+        // We already have a query for this queryKey
+        // Increment reference count since another consumer is using this observer
+        queryRefCounts.set(
+          hashedQueryKey,
+          (queryRefCounts.get(hashedQueryKey) || 0) + 1,
         )
-        const newItemsMap = new Map<string | number, any>()
-        newItemsArray.forEach((item) => {
-          const key = getKey(item)
-          newItemsMap.set(key, item)
-        })
 
-        begin()
+        // Get the current result and return based on its state
+        const observer = state.observers.get(hashedQueryKey)!
+        const currentResult = observer.getCurrentResult()
 
-        // Helper function for shallow equality check of objects
-        const shallowEqual = (
-          obj1: Record<string, any>,
-          obj2: Record<string, any>
-        ): boolean => {
-          // Get all keys from both objects
-          const keys1 = Object.keys(obj1)
-          const keys2 = Object.keys(obj2)
-
-          // If number of keys is different, objects are not equal
-          if (keys1.length !== keys2.length) return false
-
-          // Check if all keys in obj1 have the same values in obj2
-          return keys1.every((key) => {
-            // Skip comparing functions and complex objects deeply
-            if (typeof obj1[key] === `function`) return true
-            return obj1[key] === obj2[key]
+        if (currentResult.isSuccess) {
+          // Data is already available, return true synchronously
+          return true
+        } else if (currentResult.isError) {
+          // Error already occurred, reject immediately
+          return Promise.reject(currentResult.error)
+        } else {
+          // Query is still loading, wait for the first result
+          return new Promise<void>((resolve, reject) => {
+            const unsubscribe = observer.subscribe((result) => {
+              // Use a microtask in case `subscribe` is called synchronously, before `unsubscribe` is initialized
+              queueMicrotask(() => {
+                if (result.isSuccess) {
+                  unsubscribe()
+                  resolve()
+                } else if (result.isError) {
+                  unsubscribe()
+                  reject(result.error)
+                }
+              })
+            })
           })
         }
+      }
+
+      const observerOptions: QueryObserverOptions<
+        Array<any>,
+        any,
+        Array<any>,
+        Array<any>,
+        any
+      > = {
+        queryKey: key,
+        queryFn: queryFunction,
+        meta: extendedMeta,
+        structuralSharing: true,
+        notifyOnChangeProps: `all`,
+
+        // Only include options that are explicitly defined to allow QueryClient defaultOptions to be used
+        ...(enabled !== undefined && { enabled }),
+        ...(refetchInterval !== undefined && { refetchInterval }),
+        ...(retry !== undefined && { retry }),
+        ...(retryDelay !== undefined && { retryDelay }),
+        ...(staleTime !== undefined && { staleTime }),
+      }
 
-        currentSyncedItems.forEach((oldItem, key) => {
-          const newItem = newItemsMap.get(key)
-          if (!newItem) {
-            write({ type: `delete`, value: oldItem })
-          } else if (
-            !shallowEqual(
-              oldItem as Record<string, any>,
-              newItem as Record<string, any>
-            )
+      const localObserver = new QueryObserver<
+        Array<any>,
+        any,
+        Array<any>,
+        Array<any>,
+        any
+      >(queryClient, observerOptions)
+
+      hashToQueryKey.set(hashedQueryKey, key)
+      state.observers.set(hashedQueryKey, localObserver)
+
+      // Increment reference count for this query
+      queryRefCounts.set(
+        hashedQueryKey,
+        (queryRefCounts.get(hashedQueryKey) || 0) + 1,
+      )
+
+      // Create a promise that resolves when the query result is first available
+      const readyPromise = new Promise<void>((resolve, reject) => {
+        const unsubscribe = localObserver.subscribe((result) => {
+          // Use a microtask in case `subscribe` is called synchronously, before `unsubscribe` is initialized
+          queueMicrotask(() => {
+            if (result.isSuccess) {
+              unsubscribe()
+              resolve()
+            } else if (result.isError) {
+              unsubscribe()
+              reject(result.error)
+            }
+          })
+        })
+      })
+
+      // If sync has started or there are subscribers to the collection, subscribe to the query straight away
+      // This creates the main subscription that handles data updates
+      if (syncStarted || collection.subscriberCount > 0) {
+        subscribeToQuery(localObserver, hashedQueryKey)
+      }
+
+      return readyPromise
+    }
+
+    type UpdateHandler = Parameters<QueryObserver[`subscribe`]>[0]
+
+    const makeQueryResultHandler = (queryKey: QueryKey) => {
+      const hashedQueryKey = hashKey(queryKey)
+      const handleQueryResult: UpdateHandler = (result) => {
+        if (result.isSuccess) {
+          // Clear error state
+          state.lastError = undefined
+          state.errorCount = 0
+
+          const rawData = result.data
+          const newItemsArray = select ? select(rawData) : rawData
+
+          if (
+            !Array.isArray(newItemsArray) ||
+            newItemsArray.some((item) => typeof item !== `object`)
           ) {
-            // Only update if there are actual differences in the properties
-            write({ type: `update`, value: newItem })
+            const errorMessage = select
+              ? `@tanstack/query-db-collection: select() must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey)}`
+              : `@tanstack/query-db-collection: queryFn must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey)}`
+
+            console.error(errorMessage)
+            return
           }
-        })
 
-        newItemsMap.forEach((newItem, key) => {
-          if (!currentSyncedItems.has(key)) {
-            write({ type: `insert`, value: newItem })
+          const currentSyncedItems: Map<string | number, any> = new Map(
+            collection._state.syncedData.entries(),
+          )
+          const newItemsMap = new Map<string | number, any>()
+          newItemsArray.forEach((item) => {
+            const key = getKey(item)
+            newItemsMap.set(key, item)
+          })
+
+          begin()
+
+          currentSyncedItems.forEach((oldItem, key) => {
+            const newItem = newItemsMap.get(key)
+            if (!newItem) {
+              const needToRemove = removeRow(key, hashedQueryKey) // returns true if the row is no longer referenced by any queries
+              if (needToRemove) {
+                write({ type: `delete`, value: oldItem })
+              }
+            } else if (!deepEquals(oldItem, newItem)) {
+              // Only update if there are actual differences in the properties
+              write({ type: `update`, value: newItem })
+            }
+          })
+
+          newItemsMap.forEach((newItem, key) => {
+            addRow(key, hashedQueryKey)
+            if (!currentSyncedItems.has(key)) {
+              write({ type: `insert`, value: newItem })
+            }
+          })
+
+          commit()
+
+          // Mark collection as ready after first successful query result
+          markReady()
+        } else if (result.isError) {
+          if (result.errorUpdatedAt !== state.lastErrorUpdatedAt) {
+            state.lastError = result.error
+            state.errorCount++
+            state.lastErrorUpdatedAt = result.errorUpdatedAt
           }
-        })
 
-        commit()
+          console.error(
+            `[QueryCollection] Error observing query ${String(queryKey)}:`,
+            result.error,
+          )
 
-        // Mark collection as ready after first successful query result
-        markReady()
-      } else if (result.isError) {
-        if (result.errorUpdatedAt !== lastErrorUpdatedAt) {
-          lastError = result.error
-          errorCount++
-          lastErrorUpdatedAt = result.errorUpdatedAt
+          // Mark collection as ready even on error to avoid blocking apps
+          markReady()
         }
+      }
+      return handleQueryResult
+    }
 
-        console.error(
-          `[QueryCollection] Error observing query ${String(queryKey)}:`,
-          result.error
-        )
+    const isSubscribed = (hashedQueryKey: string) => {
+      return unsubscribes.has(hashedQueryKey)
+    }
 
-        // Mark collection as ready even on error to avoid blocking apps
-        markReady()
+    const subscribeToQuery = (
+      observer: QueryObserver<Array<any>, any, Array<any>, Array<any>, any>,
+      hashedQueryKey: string,
+    ) => {
+      if (!isSubscribed(hashedQueryKey)) {
+        const cachedQueryKey = hashToQueryKey.get(hashedQueryKey)!
+        const handleQueryResult = makeQueryResultHandler(cachedQueryKey)
+        const unsubscribeFn = observer.subscribe(handleQueryResult)
+        unsubscribes.set(hashedQueryKey, unsubscribeFn)
+
+        // Process the current result immediately if available
+        // This ensures data is synced when resubscribing to a query with cached data
+        const currentResult = observer.getCurrentResult()
+        if (currentResult.isSuccess || currentResult.isError) {
+          handleQueryResult(currentResult)
+        }
       }
     }
 
-    const subscribeToQuery = () => {
-      if (!isSubscribed) {
-        actualUnsubscribeFn = localObserver.subscribe(handleQueryResult)
-        isSubscribed = true
-      }
+    const subscribeToQueries = () => {
+      state.observers.forEach(subscribeToQuery)
     }
 
-    const unsubscribeFromQuery = () => {
-      if (isSubscribed && actualUnsubscribeFn) {
-        actualUnsubscribeFn()
-        actualUnsubscribeFn = null
-        isSubscribed = false
-      }
+    const unsubscribeFromQueries = () => {
+      unsubscribes.forEach((unsubscribeFn) => {
+        unsubscribeFn()
+      })
+      unsubscribes.clear()
     }
 
-    // Always subscribe when sync starts (this could be from preload(), startSync config, or first subscriber)
-    // We'll dynamically unsubscribe/resubscribe based on subscriber count to maintain staleTime behavior
-    subscribeToQuery()
+    // Mark that sync has started
+    syncStarted = true
 
     // Set up event listener for subscriber changes
     const unsubscribeFromCollectionEvents = collection.on(
       `subscribers:change`,
       ({ subscriberCount }) => {
         if (subscriberCount > 0) {
-          subscribeToQuery()
+          subscribeToQueries()
         } else if (subscriberCount === 0) {
-          unsubscribeFromQuery()
+          unsubscribeFromQueries()
         }
-      }
+      },
     )
 
-    // Ensure we process any existing query data (QueryObserver doesn't invoke its callback automatically with initial
-    // state)
-    handleQueryResult(localObserver.getCurrentResult())
+    // If syncMode is eager, create the initial query without any predicates
+    if (syncMode === `eager`) {
+      // Catch any errors to prevent unhandled rejections
+      const initialResult = createQueryFromOpts({})
+      if (initialResult instanceof Promise) {
+        initialResult.catch(() => {
+          // Errors are already handled by the query result handler
+        })
+      }
+    } else {
+      // In on-demand mode, mark ready immediately since there's no initial query
+      markReady()
+    }
+
+    // Always subscribe when sync starts (this could be from preload(), startSync config, or first subscriber)
+    // We'll dynamically unsubscribe/resubscribe based on subscriber count to maintain staleTime behavior
+    subscribeToQueries()
+
+    // Ensure we process any existing query data (QueryObserver doesn't invoke its callback automatically with initial state)
+    state.observers.forEach((observer, hashedQueryKey) => {
+      const cachedQueryKey = hashToQueryKey.get(hashedQueryKey)!
+      const handleQueryResult = makeQueryResultHandler(cachedQueryKey)
+      handleQueryResult(observer.getCurrentResult())
+    })
+
+    /**
+     * Perform row-level cleanup and remove all tracking for a query.
+     * Callers are responsible for ensuring the query is safe to cleanup.
+     */
+    const cleanupQueryInternal = (hashedQueryKey: string) => {
+      unsubscribes.get(hashedQueryKey)?.()
+      unsubscribes.delete(hashedQueryKey)
+
+      const rowKeys = queryToRows.get(hashedQueryKey) ?? new Set()
+      const rowsToDelete: Array<any> = []
+
+      rowKeys.forEach((rowKey) => {
+        const queries = rowToQueries.get(rowKey)
+
+        if (!queries) {
+          return
+        }
+
+        queries.delete(hashedQueryKey)
+
+        if (queries.size === 0) {
+          rowToQueries.delete(rowKey)
+
+          if (collection.has(rowKey)) {
+            rowsToDelete.push(collection.get(rowKey))
+          }
+        }
+      })
+
+      if (rowsToDelete.length > 0) {
+        begin()
+        rowsToDelete.forEach((row) => {
+          write({ type: `delete`, value: row })
+        })
+        commit()
+      }
+
+      state.observers.delete(hashedQueryKey)
+      queryToRows.delete(hashedQueryKey)
+      hashToQueryKey.delete(hashedQueryKey)
+      queryRefCounts.delete(hashedQueryKey)
+    }
+
+    /**
+     * Attempt to cleanup a query when it appears unused.
+     * Respects refcounts and invalidateQueries cycles via hasListeners().
+     */
+    const cleanupQueryIfIdle = (hashedQueryKey: string) => {
+      const refcount = queryRefCounts.get(hashedQueryKey) || 0
+      const observer = state.observers.get(hashedQueryKey)
+
+      if (refcount <= 0) {
+        // Drop our subscription so hasListeners reflects only active consumers
+        unsubscribes.get(hashedQueryKey)?.()
+        unsubscribes.delete(hashedQueryKey)
+      }
+
+      const hasListeners = observer?.hasListeners() ?? false
+
+      if (hasListeners) {
+        // During invalidateQueries, TanStack Query keeps internal listeners alive.
+        // Leave refcount at 0 but keep observer so it can resubscribe.
+        queryRefCounts.set(hashedQueryKey, 0)
+        return
+      }
+
+      // No listeners means the query is truly idle.
+      // Even if refcount > 0, we treat hasListeners as authoritative to prevent leaks.
+      // This can happen if subscriptions are GC'd without calling unloadSubset.
+      if (refcount > 0) {
+        console.warn(
+          `[cleanupQueryIfIdle] Invariant violation: refcount=${refcount} but no listeners. Cleaning up to prevent leak.`,
+          { hashedQueryKey },
+        )
+      }
+
+      cleanupQueryInternal(hashedQueryKey)
+    }
+
+    /**
+     * Force cleanup used by explicit collection cleanup.
+     * Ignores refcounts/hasListeners and removes everything.
+     */
+    const forceCleanupQuery = (hashedQueryKey: string) => {
+      cleanupQueryInternal(hashedQueryKey)
+    }
+
+    // Subscribe to the query client's cache to handle queries that are GCed by tanstack query
+    const unsubscribeQueryCache = queryClient
+      .getQueryCache()
+      .subscribe((event) => {
+        const hashedKey = event.query.queryHash
+        if (event.type === `removed`) {
+          // Only cleanup if this is OUR query (we track it)
+          if (hashToQueryKey.has(hashedKey)) {
+            // TanStack Query GC'd this query after gcTime expired.
+            // Use the guarded cleanup path to avoid deleting rows for active queries.
+            cleanupQueryIfIdle(hashedKey)
+          }
+        }
+      })
 
-    return async () => {
+    const cleanup = async () => {
       unsubscribeFromCollectionEvents()
-      unsubscribeFromQuery()
-      await queryClient.cancelQueries({ queryKey })
-      queryClient.removeQueries({ queryKey })
+      unsubscribeFromQueries()
+
+      const allQueryKeys = [...hashToQueryKey.values()]
+      const allHashedKeys = [...state.observers.keys()]
+
+      // Force cleanup all queries (explicit cleanup path)
+      // This ignores hasListeners and always cleans up
+      for (const hashedKey of allHashedKeys) {
+        forceCleanupQuery(hashedKey)
+      }
+
+      // Unsubscribe from cache events (cleanup already happened above)
+      unsubscribeQueryCache()
+
+      // Remove queries from TanStack Query cache
+      await Promise.all(
+        allQueryKeys.map(async (qKey) => {
+          await queryClient.cancelQueries({ queryKey: qKey, exact: true })
+          queryClient.removeQueries({ queryKey: qKey, exact: true })
+        }),
+      )
+    }
+
+    /**
+     * Unload a query subset - the subscription-based cleanup path (on-demand mode).
+     *
+     * Called when a live query subscription unsubscribes (via collection._sync.unloadSubset()).
+     *
+     * Flow:
+     * 1. Receives the same predicates that were passed to loadSubset
+     * 2. Computes the queryKey using generateQueryKeyFromOptions (same logic as loadSubset)
+     * 3. Decrements refcount
+     * 4. If refcount reaches 0:
+     *    - Checks hasListeners() to detect invalidateQueries cycles
+     *    - If hasListeners is true: resets refcount (TanStack Query keeping observer alive)
+     *    - If hasListeners is false: calls forceCleanupQuery() to perform row-level GC
+     *
+     * The hasListeners() check prevents premature cleanup during invalidateQueries:
+     * - invalidateQueries causes temporary unsubscribe/resubscribe
+     * - During unsubscribe, our refcount drops to 0
+     * - But observer.hasListeners() is still true (TanStack Query's internal listeners)
+     * - We skip cleanup and reset refcount, allowing resubscribe to succeed
+     *
+     * We don't cancel in-flight requests. Unsubscribing from the observer is sufficient
+     * to prevent late-arriving data from being processed. The request completes and is cached
+     * by TanStack Query, allowing quick remounts to restore data without refetching.
+     */
+    const unloadSubset = (options: LoadSubsetOptions) => {
+      // 1. Same predicates → 2. Same queryKey
+      const key = generateQueryKeyFromOptions(options)
+      const hashedQueryKey = hashKey(key)
+
+      // 3. Decrement refcount
+      const currentCount = queryRefCounts.get(hashedQueryKey) || 0
+      const newCount = currentCount - 1
+
+      // Update refcount
+      if (newCount <= 0) {
+        queryRefCounts.set(hashedQueryKey, 0)
+        cleanupQueryIfIdle(hashedQueryKey)
+      } else {
+        // Still have other references, just decrement
+        queryRefCounts.set(hashedQueryKey, newCount)
+      }
+    }
+
+    // Create deduplicated loadSubset wrapper for non-eager modes
+    // This prevents redundant snapshot requests when multiple concurrent
+    // live queries request overlapping or subset predicates
+    const loadSubsetDedupe =
+      syncMode === `eager` ? undefined : createQueryFromOpts
+
+    return {
+      loadSubset: loadSubsetDedupe,
+      unloadSubset: syncMode === `eager` ? undefined : unloadSubset,
+      cleanup,
     }
   }
 
   /**
    * Refetch the query data
-   * @returns Promise that resolves when the refetch is complete
+   *
+   * Uses queryObserver.refetch() because:
+   * - Bypasses `enabled: false` to support manual/imperative refetch patterns (e.g., button-triggered fetch)
+   * - Ensures clearError() works even when enabled: false
+   * - Always refetches THIS specific collection (exact targeting via observer)
+   * - Respects retry, retryDelay, and other observer options
+   *
+   * This matches TanStack Query's hook behavior where refetch() bypasses enabled: false.
+   * See: https://tanstack.com/query/latest/docs/framework/react/guides/disabling-queries
+   *
+   * Used by both:
+   * - utils.refetch() - for explicit user-triggered refetches
+   * - Internal handlers (onInsert/onUpdate/onDelete) - after mutations to get fresh data
+   *
+   * @returns Promise that resolves when the refetch is complete, with QueryObserverResult
    */
-  const refetch: RefetchFn = (opts) => {
-    return queryClient.refetchQueries(
-      {
-        queryKey: queryKey,
-      },
-      {
+  const refetch: RefetchFn = async (opts) => {
+    const allQueryKeys = [...hashToQueryKey.values()]
+    const refetchPromises = allQueryKeys.map((qKey) => {
+      const queryObserver = state.observers.get(hashKey(qKey))!
+      return queryObserver.refetch({
         throwOnError: opts?.throwOnError,
+      })
+    })
+
+    return Promise.all(refetchPromises)
+  }
+
+  /**
+   * Updates a single query key in the cache with new items, handling both direct arrays
+   * and wrapped response formats (when `select` is used).
+   */
+  const updateCacheDataForKey = (key: QueryKey, items: Array<any>): void => {
+    if (select) {
+      // When `select` is used, the cache contains a wrapped response (e.g., { data: [...], meta: {...} })
+      // We need to update the cache while preserving the wrapper structure
+      queryClient.setQueryData(key, (oldData: any) => {
+        if (!oldData || typeof oldData !== `object`) {
+          // No existing cache or not an object - don't corrupt the cache
+          return oldData
+        }
+
+        if (Array.isArray(oldData)) {
+          // Cache is already a raw array (shouldn't happen with select, but handle it)
+          return items
+        }
+
+        // Use the select function to identify which property contains the items array.
+        // This is more robust than guessing based on property order.
+        const selectedArray = select(oldData)
+
+        if (Array.isArray(selectedArray)) {
+          // Find the property that matches the selected array by reference equality
+          for (const propKey of Object.keys(oldData)) {
+            if (oldData[propKey] === selectedArray) {
+              // Found the exact property - create a shallow copy with updated items
+              return { ...oldData, [propKey]: items }
+            }
+          }
+        }
+
+        // Fallback: check common property names used for data arrays
+        if (Array.isArray(oldData.data)) {
+          return { ...oldData, data: items }
+        }
+        if (Array.isArray(oldData.items)) {
+          return { ...oldData, items: items }
+        }
+        if (Array.isArray(oldData.results)) {
+          return { ...oldData, results: items }
+        }
+
+        // Last resort: find first array property
+        for (const propKey of Object.keys(oldData)) {
+          if (Array.isArray(oldData[propKey])) {
+            return { ...oldData, [propKey]: items }
+          }
+        }
+
+        // Couldn't safely identify the array property - don't corrupt the cache
+        // Return oldData unchanged to avoid breaking select
+        return oldData
+      })
+    } else {
+      // No select - cache contains raw array, just set it directly
+      queryClient.setQueryData(key, items)
+    }
+  }
+
+  /**
+   * Updates the query cache with new items for ALL active query keys.
+   * This is critical for on-demand mode where multiple query keys may exist
+   * (each with different predicates).
+   */
+  const updateCacheData = (items: Array<any>): void => {
+    // Get all active query keys from the hashToQueryKey map
+    const activeQueryKeys = Array.from(hashToQueryKey.values())
+
+    if (activeQueryKeys.length > 0) {
+      // Update all active query keys in the cache
+      for (const key of activeQueryKeys) {
+        updateCacheDataForKey(key, items)
       }
-    )
+    } else {
+      // Fallback: no active queries yet, use the base query key
+      // This handles the case where updateCacheData is called before any queries are created
+      const baseKey =
+        typeof queryKey === `function`
+          ? queryKey({})
+          : (queryKey as unknown as QueryKey)
+      updateCacheDataForKey(baseKey, items)
+    }
   }
 
   // Create write context for manual write operations
@@ -616,21 +1231,29 @@ export function queryCollectionOptions(
     begin: () => void
     write: (message: Omit<ChangeMessage<any>, `key`>) => void
     commit: () => void
+    updateCacheData?: (items: Array<any>) => void
   } | null = null
 
   // Enhanced internalSync that captures write functions for manual use
   const enhancedInternalSync: SyncConfig<any>[`sync`] = (params) => {
     const { begin, write, commit, collection } = params
 
+    // Get the base query key for the context (handle both static and function-based keys)
+    const contextQueryKey =
+      typeof queryKey === `function`
+        ? (queryKey({}) as unknown as Array<unknown>)
+        : (queryKey as unknown as Array<unknown>)
+
     // Store references for manual write operations
     writeContext = {
       collection,
       queryClient,
-      queryKey: queryKey as unknown as Array<unknown>,
+      queryKey: contextQueryKey,
       getKey: getKey as (item: any) => string | number,
       begin,
       write,
       commit,
+      updateCacheData,
     }
 
     // Call the original internalSync logic
@@ -639,7 +1262,7 @@ export function queryCollectionOptions(
 
   // Create write utils using the manual-sync module
   const writeUtils = createWriteUtils<any, string | number, any>(
-    () => writeContext
+    () => writeContext,
   )
 
   // Create wrapper handlers for direct persistence operations that handle refetching
@@ -685,25 +1308,17 @@ export function queryCollectionOptions(
       }
     : undefined
 
+  // Create utils instance with state and dependencies passed explicitly
+  const utils: any = new QueryCollectionUtilsImpl(state, refetch, writeUtils)
+
   return {
     ...baseCollectionConfig,
     getKey,
+    syncMode,
     sync: { sync: enhancedInternalSync },
     onInsert: wrappedOnInsert,
     onUpdate: wrappedOnUpdate,
     onDelete: wrappedOnDelete,
-    utils: {
-      refetch,
-      ...writeUtils,
-      lastError: () => lastError,
-      isError: () => !!lastError,
-      errorCount: () => errorCount,
-      clearError: () => {
-        lastError = undefined
-        errorCount = 0
-        lastErrorUpdatedAt = 0
-        return refetch({ throwOnError: true })
-      },
-    },
+    utils,
   }
 }
diff --git a/packages/query-db-collection/src/serialization.ts b/packages/query-db-collection/src/serialization.ts
new file mode 100644
index 000000000..9849c4bd3
--- /dev/null
+++ b/packages/query-db-collection/src/serialization.ts
@@ -0,0 +1,135 @@
+import type { IR, LoadSubsetOptions } from '@tanstack/db'
+
+/**
+ * Serializes LoadSubsetOptions into a stable, hashable format for query keys.
+ * Includes where, orderBy, limit, and offset for pagination support.
+ * Note: cursor expressions are not serialized as they are backend-specific.
+ * @internal
+ */
+export function serializeLoadSubsetOptions(
+  options: LoadSubsetOptions | undefined,
+): string | undefined {
+  if (!options) {
+    return undefined
+  }
+
+  const result: Record<string, unknown> = {}
+
+  if (options.where) {
+    result.where = serializeExpression(options.where)
+  }
+
+  if (options.orderBy?.length) {
+    result.orderBy = options.orderBy.map((clause) => {
+      const baseOrderBy = {
+        expression: serializeExpression(clause.expression),
+        direction: clause.compareOptions.direction,
+        nulls: clause.compareOptions.nulls,
+        stringSort: clause.compareOptions.stringSort,
+      }
+
+      // Handle locale-specific options when stringSort is 'locale'
+      if (clause.compareOptions.stringSort === `locale`) {
+        return {
+          ...baseOrderBy,
+          locale: clause.compareOptions.locale,
+          localeOptions: clause.compareOptions.localeOptions,
+        }
+      }
+
+      return baseOrderBy
+    })
+  }
+
+  if (options.limit !== undefined) {
+    result.limit = options.limit
+  }
+
+  // Include offset for pagination support
+  if (options.offset !== undefined) {
+    result.offset = options.offset
+  }
+
+  return Object.keys(result).length === 0 ? undefined : JSON.stringify(result)
+}
+
+/**
+ * Recursively serializes an IR expression for stable hashing
+ * @internal
+ */
+function serializeExpression(expr: IR.BasicExpression | undefined): unknown {
+  if (!expr) {
+    return null
+  }
+
+  switch (expr.type) {
+    case `val`:
+      return {
+        type: `val`,
+        value: serializeValue(expr.value),
+      }
+    case `ref`:
+      return {
+        type: `ref`,
+        path: [...expr.path],
+      }
+    case `func`:
+      return {
+        type: `func`,
+        name: expr.name,
+        args: expr.args.map((arg) => serializeExpression(arg)),
+      }
+    default:
+      return null
+  }
+}
+
+/**
+ * Serializes special JavaScript values (undefined, NaN, Infinity, Date)
+ * @internal
+ */
+function serializeValue(value: unknown): unknown {
+  if (value === undefined) {
+    return { __type: `undefined` }
+  }
+
+  if (typeof value === `number`) {
+    if (Number.isNaN(value)) {
+      return { __type: `nan` }
+    }
+    if (value === Number.POSITIVE_INFINITY) {
+      return { __type: `infinity`, sign: 1 }
+    }
+    if (value === Number.NEGATIVE_INFINITY) {
+      return { __type: `infinity`, sign: -1 }
+    }
+  }
+
+  if (
+    value === null ||
+    typeof value === `string` ||
+    typeof value === `number` ||
+    typeof value === `boolean`
+  ) {
+    return value
+  }
+
+  if (value instanceof Date) {
+    return { __type: `date`, value: value.toJSON() }
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeValue(item))
+  }
+
+  if (typeof value === `object`) {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).map(([key, val]) => [
+        key,
+        serializeValue(val),
+      ]),
+    )
+  }
+
+  return value
+}
diff --git a/packages/query-db-collection/tests/query.test-d.ts b/packages/query-db-collection/tests/query.test-d.ts
index c8df9298e..8481021eb 100644
--- a/packages/query-db-collection/tests/query.test-d.ts
+++ b/packages/query-db-collection/tests/query.test-d.ts
@@ -1,19 +1,22 @@
-import { describe, expectTypeOf, it } from "vitest"
+import { describe, expectTypeOf, it } from 'vitest'
 import {
   and,
   createCollection,
   createLiveQueryCollection,
   eq,
   gt,
-} from "@tanstack/db"
-import { QueryClient } from "@tanstack/query-core"
-import { z } from "zod"
-import { queryCollectionOptions } from "../src/query"
+  parseLoadSubsetOptions,
+} from '@tanstack/db'
+import { QueryClient } from '@tanstack/query-core'
+import { z } from 'zod'
+import { queryCollectionOptions } from '../src/query'
+import type { QueryCollectionConfig, QueryCollectionUtils } from '../src/query'
 import type {
   DeleteMutationFnParams,
   InsertMutationFnParams,
+  LoadSubsetOptions,
   UpdateMutationFnParams,
-} from "@tanstack/db"
+} from '@tanstack/db'
 
 describe(`Query collection type resolution tests`, () => {
   // Define test types
@@ -45,21 +48,21 @@ describe(`Query collection type resolution tests`, () => {
       onInsert: (params) => {
         // Verify that the mutation value has the correct type
         expectTypeOf(
-          params.transaction.mutations[0].modified
+          params.transaction.mutations[0].modified,
         ).toEqualTypeOf<ExplicitType>()
         return Promise.resolve()
       },
       onUpdate: (params) => {
         // Verify that the mutation value has the correct type
         expectTypeOf(
-          params.transaction.mutations[0].modified
+          params.transaction.mutations[0].modified,
         ).toEqualTypeOf<ExplicitType>()
         return Promise.resolve()
       },
       onDelete: (params) => {
         // Verify that the mutation value has the correct type
         expectTypeOf(
-          params.transaction.mutations[0].original
+          params.transaction.mutations[0].original,
         ).toEqualTypeOf<ExplicitType>()
         return Promise.resolve()
       },
@@ -67,15 +70,33 @@ describe(`Query collection type resolution tests`, () => {
 
     // Verify that the handlers are properly typed
     expectTypeOf(options.onInsert).parameters.toEqualTypeOf<
-      [InsertMutationFnParams<ExplicitType>]
+      [
+        InsertMutationFnParams<
+          ExplicitType,
+          string | number,
+          QueryCollectionUtils<ExplicitType>
+        >,
+      ]
     >()
 
     expectTypeOf(options.onUpdate).parameters.toEqualTypeOf<
-      [UpdateMutationFnParams<ExplicitType>]
+      [
+        UpdateMutationFnParams<
+          ExplicitType,
+          string | number,
+          QueryCollectionUtils<ExplicitType>
+        >,
+      ]
     >()
 
     expectTypeOf(options.onDelete).parameters.toEqualTypeOf<
-      [DeleteMutationFnParams<ExplicitType>]
+      [
+        DeleteMutationFnParams<
+          ExplicitType,
+          string | number,
+          QueryCollectionUtils<ExplicitType>
+        >,
+      ]
     >()
   })
 
@@ -403,4 +424,140 @@ describe(`Query collection type resolution tests`, () => {
       expectTypeOf(selectUserData).parameters.toEqualTypeOf<[ResponseType]>()
     })
   })
+
+  describe(`loadSubsetOptions type inference`, () => {
+    interface TestItem {
+      id: string
+      name: string
+    }
+
+    it(`should type loadSubsetOptions as LoadSubsetOptions in queryFn`, () => {
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `loadSubsetTest`,
+        queryClient,
+        queryKey: [`loadSubsetTest`],
+        queryFn: (ctx) => {
+          // Verify that loadSubsetOptions is assignable to LoadSubsetOptions
+          // This ensures it can be used where LoadSubsetOptions is expected
+          expectTypeOf(
+            ctx.meta!.loadSubsetOptions,
+          ).toExtend<LoadSubsetOptions>()
+          // so that parseLoadSubsetOptions can be called without type errors
+          parseLoadSubsetOptions(ctx.meta?.loadSubsetOptions)
+          // The fact that this call compiles without errors verifies that
+          // ctx.meta.loadSubsetOptions is typed correctly as LoadSubsetOptions
+          return Promise.resolve([])
+        },
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      createCollection(options)
+    })
+
+    it(`should allow meta to contain additional properties beyond loadSubsetOptions`, () => {
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `loadSubsetTest`,
+        queryClient,
+        queryKey: [`loadSubsetTest`],
+        queryFn: (ctx) => {
+          // Verify that an object with loadSubsetOptions plus other properties
+          // can be assigned to ctx.meta's type. This ensures the type is not too restrictive.
+          const metaWithExtra = {
+            loadSubsetOptions: ctx.meta!.loadSubsetOptions,
+            customProperty: `test`,
+            anotherProperty: 123,
+          }
+
+          // Test that this object can be assigned to ctx.meta's type
+          // This verifies that ctx.meta allows additional properties beyond loadSubsetOptions
+          const typedMeta: typeof ctx.meta = metaWithExtra
+
+          // Verify the assignment worked (this will fail at compile time if types don't match)
+          expectTypeOf(
+            typedMeta.loadSubsetOptions,
+          ).toExtend<LoadSubsetOptions>()
+
+          return Promise.resolve([])
+        },
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      createCollection(options)
+    })
+
+    it(`should have loadSubsetOptions typed automatically without explicit QueryCollectionMeta import`, () => {
+      // This test validates that the module augmentation works automatically
+      // Note: We are NOT importing QueryCollectionMeta, yet ctx.meta.loadSubsetOptions
+      // should still be properly typed as LoadSubsetOptions
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `autoTypeTest`,
+        queryClient,
+        queryKey: [`autoTypeTest`],
+        queryFn: (ctx) => {
+          // This should compile without errors because the module augmentation
+          // in global.d.ts is automatically loaded via the triple-slash reference
+          // in index.ts
+          const options = ctx.meta?.loadSubsetOptions
+
+          // Verify the type is correct
+          expectTypeOf(options).toMatchTypeOf<LoadSubsetOptions | undefined>()
+
+          // Verify it can be passed to parseLoadSubsetOptions without type errors
+          const parsed = parseLoadSubsetOptions(options)
+          expectTypeOf(parsed).toMatchTypeOf<{
+            filters: Array<any>
+            sorts: Array<any>
+            limit?: number
+          }>()
+
+          return Promise.resolve([])
+        },
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      createCollection(options)
+    })
+
+    it(`should allow users to extend QueryCollectionMeta via module augmentation`, () => {
+      // This test validates that users can extend QueryCollectionMeta to add custom properties
+      // by augmenting the @tanstack/query-db-collection module
+
+      // In reality, users would do:
+      // declare module "@tanstack/query-db-collection" {
+      //   interface QueryCollectionMeta {
+      //     customUserId: number
+      //     customContext?: string
+      //   }
+      // }
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `extendMetaTest`,
+        queryClient,
+        queryKey: [`extendMetaTest`],
+        queryFn: (ctx) => {
+          // ctx.meta still has loadSubsetOptions
+          expectTypeOf(ctx.meta?.loadSubsetOptions).toMatchTypeOf<
+            LoadSubsetOptions | undefined
+          >()
+
+          // This test documents the extension pattern even though we can't
+          // actually augment QueryCollectionMeta in a test file (it would
+          // affect all other tests in the same compilation unit)
+
+          return Promise.resolve([])
+        },
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      createCollection(options)
+    })
+  })
 })
diff --git a/packages/query-db-collection/tests/query.test.ts b/packages/query-db-collection/tests/query.test.ts
index b87caf67c..0a623de61 100644
--- a/packages/query-db-collection/tests/query.test.ts
+++ b/packages/query-db-collection/tests/query.test.ts
@@ -1,16 +1,22 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { QueryClient } from "@tanstack/query-core"
-import { createCollection } from "@tanstack/db"
-import { queryCollectionOptions } from "../src/query"
-import type { QueryFunctionContext } from "@tanstack/query-core"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { QueryClient } from '@tanstack/query-core'
+import {
+  createCollection,
+  createLiveQueryCollection,
+  eq,
+  ilike,
+  or,
+} from '@tanstack/db'
+import { queryCollectionOptions } from '../src/query'
+import type { QueryFunctionContext } from '@tanstack/query-core'
 import type {
-  CollectionImpl,
+  Collection,
   DeleteMutationFnParams,
   InsertMutationFnParams,
   TransactionWithMutations,
   UpdateMutationFnParams,
-} from "@tanstack/db"
-import type { QueryCollectionConfig } from "../src/query"
+} from '@tanstack/db'
+import type { QueryCollectionConfig, QueryCollectionUtils } from '../src/query'
 
 interface TestItem {
   id: string
@@ -18,6 +24,12 @@ interface TestItem {
   value?: number
 }
 
+interface CategorisedItem {
+  id: string
+  name: string
+  category: string
+}
+
 const getKey = (item: TestItem) => item.id
 
 // Helper to advance timers and allow microtasks to flush
@@ -30,9 +42,10 @@ describe(`QueryCollection`, () => {
     queryClient = new QueryClient({
       defaultOptions: {
         queries: {
-          // Setting a low staleTime and cacheTime to ensure queries can be refetched easily in tests
+          // Setting a low staleTime and gcTime to ensure queries can be refetched easily in tests
           // and GC'd quickly if not observed.
           staleTime: 0,
+          gcTime: 0, // Immediate GC for tests
           retry: false, // Disable retries for tests to avoid delays
         },
       },
@@ -74,7 +87,7 @@ describe(`QueryCollection`, () => {
       {
         timeout: 1000, // Give it a reasonable timeout
         interval: 50, // Check frequently
-      }
+      },
     )
 
     // Additional wait for internal processing if necessary
@@ -179,7 +192,7 @@ describe(`QueryCollection`, () => {
       .mockImplementation(() => {})
 
     const queryFn: (
-      context: QueryFunctionContext<any>
+      context: QueryFunctionContext<any>,
     ) => Promise<Array<TestItem>> = vi
       .fn()
       .mockResolvedValueOnce([initialItem])
@@ -212,7 +225,7 @@ describe(`QueryCollection`, () => {
 
     // Verify the error was logged correctly
     const errorCallArgs = consoleErrorSpy.mock.calls.find((call) =>
-      call[0].includes(`[QueryCollection] Error observing query`)
+      call[0].includes(`[QueryCollection] Error observing query`),
     )
     expect(errorCallArgs).toBeDefined()
     expect(errorCallArgs?.[1]).toBe(testError)
@@ -233,7 +246,7 @@ describe(`QueryCollection`, () => {
 
     // Mock queryFn to return invalid data (not an array of objects)
     const queryFn: (
-      context: QueryFunctionContext<any>
+      context: QueryFunctionContext<any>,
     ) => Promise<Array<TestItem>> = vi
       .fn()
       .mockResolvedValue(`not an array` as any)
@@ -257,8 +270,8 @@ describe(`QueryCollection`, () => {
     await vi.waitFor(() => {
       const errorCallArgs = consoleErrorSpy.mock.calls.find((call) =>
         call[0].includes(
-          `@tanstack/query-db-collection: queryFn must return an array of objects`
-        )
+          `@tanstack/query-db-collection: queryFn must return an array of objects`,
+        ),
       )
       expect(errorCallArgs).toBeDefined()
     })
@@ -278,7 +291,7 @@ describe(`QueryCollection`, () => {
     // Second query returns a new object with the same properties (different reference)
     // Third query returns an object with an actual change
     const queryFn: (
-      context: QueryFunctionContext<any>
+      context: QueryFunctionContext<any>,
     ) => Promise<Array<TestItem>> = vi
       .fn()
       .mockResolvedValueOnce([initialItem])
@@ -431,7 +444,131 @@ describe(`QueryCollection`, () => {
     })
 
     // Verify queryFn was called with the correct context, including the meta object
-    expect(queryFn).toHaveBeenCalledWith(expect.objectContaining({ meta }))
+    expect(queryFn).toHaveBeenCalledWith(
+      expect.objectContaining({ meta: { ...meta, loadSubsetOptions: {} } }),
+    )
+  })
+
+  describe(`loadSubsetOptions passed to queryFn`, () => {
+    it(`should pass eq where clause to queryFn via loadSubsetOptions`, async () => {
+      const queryKey = [`loadSubsetTest`]
+      const queryFn = vi
+        .fn()
+        .mockImplementation((ctx: QueryFunctionContext<any>) => {
+          const loadSubsetOptions = ctx.meta?.loadSubsetOptions
+          // Verify where clause is present
+          expect(loadSubsetOptions?.where).toBeDefined()
+          expect(loadSubsetOptions?.where).not.toBeNull()
+          if (loadSubsetOptions?.where?.type === `func`) {
+            expect(loadSubsetOptions.where.name).toBe(`eq`)
+          }
+          return Promise.resolve([])
+        })
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `loadSubsetTest`,
+        queryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        syncMode: `on-demand`,
+        // startSync: true,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create a live query with an eq where clause
+      const liveQuery = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.id, `1`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      await liveQuery.preload()
+
+      // Wait for queryFn to be called
+      await vi.waitFor(() => {
+        expect(queryFn).toHaveBeenCalled()
+      })
+
+      // Verify queryFn was called with loadSubsetOptions containing the where clause
+      expect(queryFn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta: expect.objectContaining({
+            loadSubsetOptions: expect.objectContaining({
+              where: expect.objectContaining({
+                type: `func`,
+                name: `eq`,
+              }),
+            }),
+          }),
+        }),
+      )
+    })
+
+    it(`should pass ilike where clause to queryFn via loadSubsetOptions`, async () => {
+      const queryFn = vi
+        .fn()
+        .mockImplementation((ctx: QueryFunctionContext<any>) => {
+          const loadSubsetOptions = ctx.meta?.loadSubsetOptions
+          // Verify where clause is present (this was the bug - it was undefined/null before the fix)
+          expect(loadSubsetOptions?.where).toBeDefined()
+          expect(loadSubsetOptions?.where).not.toBeNull()
+          if (loadSubsetOptions?.where?.type === `func`) {
+            expect(loadSubsetOptions.where.name).toBe(`ilike`)
+          }
+          return Promise.resolve([])
+        })
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `loadSubsetIlikeTest`,
+        queryClient,
+        queryKey: [`loadSubsetIlikeTest`],
+        queryFn,
+        getKey,
+        syncMode: `on-demand`,
+        // startSync: true,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create a live query with an ilike where clause
+      const liveQuery = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => ilike(item.name, `%test%`))
+            .orderBy(({ item }) => item.name)
+            .limit(10),
+      })
+
+      await liveQuery.preload()
+
+      // Wait for queryFn to be called
+      await vi.waitFor(() => {
+        expect(queryFn).toHaveBeenCalled()
+      })
+
+      // Verify queryFn was called with loadSubsetOptions containing the ilike where clause
+      // Without the fix: where would be undefined/null
+      // With the fix: where should be defined with the ilike expression
+      expect(queryFn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta: expect.objectContaining({
+            loadSubsetOptions: expect.objectContaining({
+              where: expect.objectContaining({
+                type: `func`,
+                name: `ilike`,
+              }),
+            }),
+          }),
+        }),
+      )
+    })
   })
 
   describe(`Select method testing`, () => {
@@ -514,8 +651,8 @@ describe(`QueryCollection`, () => {
       await vi.waitFor(() => {
         const errorCallArgs = consoleErrorSpy.mock.calls.find((call) =>
           call[0].includes(
-            `@tanstack/query-db-collection: select() must return an array of objects`
-          )
+            `@tanstack/query-db-collection: select() must return an array of objects`,
+          ),
         )
         expect(errorCallArgs).toBeDefined()
       })
@@ -551,10 +688,183 @@ describe(`QueryCollection`, () => {
 
       // Verify that the query cache state exists along with its metadata
       const initialCache = queryClient.getQueryData(
-        queryKey
+        queryKey,
       ) as MetaDataType<TestItem>
       expect(initialCache).toEqual(initialMetaData)
     })
+
+    it(`should not throw error when using writeInsert with select option`, async () => {
+      const queryKey = [`select-writeInsert-test`]
+      const consoleErrorSpy = vi
+        .spyOn(console, `error`)
+        .mockImplementation(() => {})
+
+      const queryFn = vi.fn().mockResolvedValue(initialMetaData)
+      const select = vi.fn((data: MetaDataType<TestItem>) => data.data)
+
+      const options = queryCollectionOptions({
+        id: `select-writeInsert-test`,
+        queryClient,
+        queryKey,
+        queryFn,
+        select,
+        getKey,
+        startSync: true,
+      })
+      const collection = createCollection(options)
+
+      // Wait for collection to be ready
+      await vi.waitFor(() => {
+        expect(collection.status).toBe(`ready`)
+        expect(collection.size).toBe(2)
+      })
+
+      // This should NOT cause an error - but with the bug it does
+      const newItem: TestItem = { id: `3`, name: `New Item` }
+      collection.utils.writeInsert(newItem)
+
+      // Verify the item was inserted
+      expect(collection.size).toBe(3)
+      expect(collection.get(`3`)).toEqual(newItem)
+
+      // Wait a tick to allow any async error handlers to run
+      await flushPromises()
+
+      // Verify no error was logged about select returning non-array
+      const errorCallArgs = consoleErrorSpy.mock.calls.find((call) =>
+        call[0]?.includes?.(
+          `@tanstack/query-db-collection: select() must return an array of objects`,
+        ),
+      )
+      expect(errorCallArgs).toBeUndefined()
+
+      consoleErrorSpy.mockRestore()
+    })
+
+    it(`should not throw error when using writeUpsert with select option`, async () => {
+      const queryKey = [`select-writeUpsert-test`]
+      const consoleErrorSpy = vi
+        .spyOn(console, `error`)
+        .mockImplementation(() => {})
+
+      const queryFn = vi.fn().mockResolvedValue(initialMetaData)
+      const select = vi.fn((data: MetaDataType<TestItem>) => data.data)
+
+      const options = queryCollectionOptions({
+        id: `select-writeUpsert-test`,
+        queryClient,
+        queryKey,
+        queryFn,
+        select,
+        getKey,
+        startSync: true,
+      })
+      const collection = createCollection(options)
+
+      // Wait for collection to be ready
+      await vi.waitFor(() => {
+        expect(collection.status).toBe(`ready`)
+        expect(collection.size).toBe(2)
+      })
+
+      // This should NOT cause an error - but with the bug it does
+      // Test upsert for new item
+      const newItem: TestItem = { id: `3`, name: `Upserted New Item` }
+      collection.utils.writeUpsert(newItem)
+
+      // Verify the item was inserted
+      expect(collection.size).toBe(3)
+      expect(collection.get(`3`)).toEqual(newItem)
+
+      // Test upsert for existing item
+      collection.utils.writeUpsert({ id: `1`, name: `Updated First Item` })
+
+      // Verify the item was updated
+      expect(collection.get(`1`)?.name).toBe(`Updated First Item`)
+
+      // Wait a tick to allow any async error handlers to run
+      await flushPromises()
+
+      // Verify no error was logged about select returning non-array
+      const errorCallArgs = consoleErrorSpy.mock.calls.find((call) =>
+        call[0]?.includes?.(
+          `@tanstack/query-db-collection: select() must return an array of objects`,
+        ),
+      )
+      expect(errorCallArgs).toBeUndefined()
+
+      consoleErrorSpy.mockRestore()
+    })
+
+    it(`should update query cache with wrapped format preserved when using writeInsert with select option`, async () => {
+      const queryKey = [`select-cache-update-test`]
+
+      const queryFn = vi.fn().mockResolvedValue(initialMetaData)
+      const select = vi.fn((data: MetaDataType<TestItem>) => data.data)
+
+      const options = queryCollectionOptions({
+        id: `select-cache-update-test`,
+        queryClient,
+        queryKey,
+        queryFn,
+        select,
+        getKey,
+        startSync: true,
+      })
+      const collection = createCollection(options)
+
+      // Wait for collection to be ready
+      await vi.waitFor(() => {
+        expect(collection.status).toBe(`ready`)
+        expect(collection.size).toBe(2)
+      })
+
+      // Verify initial cache has wrapped format
+      const initialCache = queryClient.getQueryData(
+        queryKey,
+      ) as MetaDataType<TestItem>
+      expect(initialCache.metaDataOne).toBe(`example metadata`)
+      expect(initialCache.metaDataTwo).toBe(`example metadata`)
+      expect(initialCache.data).toHaveLength(2)
+
+      // Insert a new item
+      const newItem: TestItem = { id: `3`, name: `New Item` }
+      collection.utils.writeInsert(newItem)
+
+      // Verify the cache still has wrapped format with metadata preserved
+      const cacheAfterInsert = queryClient.getQueryData(
+        queryKey,
+      ) as MetaDataType<TestItem>
+      expect(cacheAfterInsert.metaDataOne).toBe(`example metadata`)
+      expect(cacheAfterInsert.metaDataTwo).toBe(`example metadata`)
+      expect(cacheAfterInsert.data).toHaveLength(3)
+      expect(cacheAfterInsert.data).toContainEqual(newItem)
+
+      // Update an existing item
+      collection.utils.writeUpdate({ id: `1`, name: `Updated First Item` })
+
+      // Verify the cache still has wrapped format
+      const cacheAfterUpdate = queryClient.getQueryData(
+        queryKey,
+      ) as MetaDataType<TestItem>
+      expect(cacheAfterUpdate.metaDataOne).toBe(`example metadata`)
+      expect(cacheAfterUpdate.data).toHaveLength(3)
+      const updatedItem = cacheAfterUpdate.data.find((item) => item.id === `1`)
+      expect(updatedItem?.name).toBe(`Updated First Item`)
+
+      // Delete an item
+      collection.utils.writeDelete(`2`)
+
+      // Verify the cache still has wrapped format
+      const cacheAfterDelete = queryClient.getQueryData(
+        queryKey,
+      ) as MetaDataType<TestItem>
+      expect(cacheAfterDelete.metaDataOne).toBe(`example metadata`)
+      expect(cacheAfterDelete.data).toHaveLength(2)
+      expect(cacheAfterDelete.data).not.toContainEqual(
+        expect.objectContaining({ id: `2` }),
+      )
+    })
   })
   describe(`Direct persistence handlers`, () => {
     it(`should pass through direct persistence handlers to collection options`, () => {
@@ -607,21 +917,45 @@ describe(`QueryCollection`, () => {
         mutations: [] as any,
       } as TransactionWithMutations<TestItem, `delete`>
 
-      const insertMockParams: InsertMutationFnParams<TestItem> = {
+      const mockCollection = {
+        utils: {} as QueryCollectionUtils<
+          TestItem,
+          string | number,
+          TestItem,
+          unknown
+        >,
+      } as unknown as Collection<
+        TestItem,
+        string | number,
+        QueryCollectionUtils<TestItem, string | number, TestItem, unknown>,
+        never,
+        TestItem
+      >
+
+      const insertMockParams = {
         transaction: insertTransaction,
-        // @ts-ignore not testing this
-        collection: {} as CollectionImpl,
-      }
-      const updateMockParams: UpdateMutationFnParams<TestItem> = {
+        collection: mockCollection,
+      } as InsertMutationFnParams<
+        TestItem,
+        string | number,
+        QueryCollectionUtils<TestItem, string | number, TestItem, unknown>
+      >
+      const updateMockParams = {
         transaction: updateTransaction,
-        // @ts-ignore not testing this
-        collection: {} as CollectionImpl,
-      }
-      const deleteMockParams: DeleteMutationFnParams<TestItem> = {
+        collection: mockCollection,
+      } as UpdateMutationFnParams<
+        TestItem,
+        string | number,
+        QueryCollectionUtils<TestItem, string | number, TestItem, unknown>
+      >
+      const deleteMockParams = {
         transaction: deleteTransaction,
-        // @ts-ignore not testing this
-        collection: {} as CollectionImpl,
-      }
+        collection: mockCollection,
+      } as DeleteMutationFnParams<
+        TestItem,
+        string | number,
+        QueryCollectionUtils<TestItem, string | number, TestItem, unknown>
+      >
 
       // Create handlers
       const onInsert = vi.fn().mockResolvedValue(undefined)
@@ -659,62 +993,100 @@ describe(`QueryCollection`, () => {
         mutations: [] as any,
       } as TransactionWithMutations<TestItem, `insert`>
 
-      const insertMockParams: InsertMutationFnParams<TestItem> = {
-        transaction: insertTransaction,
-        // @ts-ignore not testing this
-        collection: {} as CollectionImpl,
-      }
-
       // Create handlers with different return values
       const onInsertDefault = vi.fn().mockResolvedValue(undefined) // Default behavior should refetch
       const onInsertFalse = vi.fn().mockResolvedValue({ refetch: false }) // No refetch
 
-      // Create a spy on the refetch function itself
-      const refetchSpy = vi.fn().mockResolvedValue(undefined)
-
       // Create configs with the handlers
+      const queryFnDefault = vi
+        .fn()
+        .mockResolvedValue([{ id: `1`, name: `Item 1` }])
+      const queryFnFalse = vi
+        .fn()
+        .mockResolvedValue([{ id: `1`, name: `Item 1` }])
+
       const configDefault: QueryCollectionConfig<TestItem> = {
         id: `test-default`,
         queryClient,
         queryKey: [`refetchTest`, `default`],
-        queryFn: vi.fn().mockResolvedValue([{ id: `1`, name: `Item 1` }]),
+        queryFn: queryFnDefault,
         getKey,
         onInsert: onInsertDefault,
+        startSync: true,
       }
 
       const configFalse: QueryCollectionConfig<TestItem> = {
         id: `test-false`,
         queryClient,
         queryKey: [`refetchTest`, `false`],
-        queryFn: vi.fn().mockResolvedValue([{ id: `1`, name: `Item 1` }]),
+        queryFn: queryFnFalse,
         getKey,
         onInsert: onInsertFalse,
+        startSync: true,
       }
 
-      // Mock the queryClient.refetchQueries method which is called by collection.utils.refetch()
-      vi.spyOn(queryClient, `refetchQueries`).mockImplementation(refetchSpy)
-
       // Test case 1: Default behavior (undefined return) should trigger refetch
       const optionsDefault = queryCollectionOptions(configDefault)
-      await optionsDefault.onInsert!(insertMockParams)
+      const collectionDefault = createCollection(optionsDefault)
+
+      // Wait for initial sync
+      await vi.waitFor(() => {
+        expect(collectionDefault.status).toBe(`ready`)
+      })
+
+      // Clear initial call
+      queryFnDefault.mockClear()
+
+      const insertParamsDefault = {
+        transaction: insertTransaction,
+        collection: collectionDefault,
+      } satisfies InsertMutationFnParams<
+        TestItem,
+        string | number,
+        QueryCollectionUtils<TestItem, string | number, TestItem, unknown>
+      >
 
-      // Verify handler was called and refetch was triggered
-      expect(onInsertDefault).toHaveBeenCalledWith(insertMockParams)
-      expect(refetchSpy).toHaveBeenCalledTimes(1)
+      await optionsDefault.onInsert!(insertParamsDefault)
 
-      // Reset mocks
-      refetchSpy.mockClear()
+      // Verify handler was called and refetch was triggered (queryFn called again)
+      expect(onInsertDefault).toHaveBeenCalledWith(insertParamsDefault)
+      await vi.waitFor(() => {
+        expect(queryFnDefault).toHaveBeenCalledTimes(1)
+      })
 
       // Test case 2: Explicit { refetch: false } should not trigger refetch
       const optionsFalse = queryCollectionOptions(configFalse)
-      await optionsFalse.onInsert!(insertMockParams)
+      const collectionFalse = createCollection(optionsFalse)
+
+      // Wait for initial sync
+      await vi.waitFor(() => {
+        expect(collectionFalse.status).toBe(`ready`)
+      })
+
+      // Clear initial call
+      queryFnFalse.mockClear()
+
+      const insertParamsFalse = {
+        transaction: insertTransaction,
+        collection: collectionFalse,
+      } satisfies InsertMutationFnParams<
+        TestItem,
+        string | number,
+        QueryCollectionUtils<TestItem, string | number, TestItem, unknown>
+      >
 
-      // Verify handler was called but refetch was NOT triggered
-      expect(onInsertFalse).toHaveBeenCalledWith(insertMockParams)
-      expect(refetchSpy).not.toHaveBeenCalled()
+      await optionsFalse.onInsert!(insertParamsFalse)
 
-      // Restore original function
-      vi.restoreAllMocks()
+      // Verify handler was called but refetch was NOT triggered (queryFn not called)
+      expect(onInsertFalse).toHaveBeenCalledWith(insertParamsFalse)
+      // Wait a bit to ensure no refetch happens
+      await new Promise((resolve) => setTimeout(resolve, 50))
+      expect(queryFnFalse).not.toHaveBeenCalled()
+
+      await Promise.all([
+        collectionDefault.cleanup(),
+        collectionFalse.cleanup(),
+      ])
     })
   })
 
@@ -802,8 +1174,11 @@ describe(`QueryCollection`, () => {
       expect(collection.status).toBe(`cleaned-up`)
 
       // Verify that cleanup methods are called regardless of subscriber state
-      expect(cancelQueriesSpy).toHaveBeenCalledWith({ queryKey })
-      expect(removeQueriesSpy).toHaveBeenCalledWith({ queryKey })
+      expect(cancelQueriesSpy).toHaveBeenCalledWith({
+        queryKey,
+        exact: true,
+      })
+      expect(removeQueriesSpy).toHaveBeenCalledWith({ queryKey, exact: true })
 
       // Verify subscribers can be safely cleaned up after collection cleanup
       subscription1.unsubscribe()
@@ -945,8 +1320,11 @@ describe(`QueryCollection`, () => {
       expect(collection.status).toBe(`cleaned-up`)
 
       // Verify cleanup methods were called
-      expect(cancelQueriesSpy).toHaveBeenCalledWith({ queryKey })
-      expect(removeQueriesSpy).toHaveBeenCalledWith({ queryKey })
+      expect(cancelQueriesSpy).toHaveBeenCalledWith({
+        queryKey,
+        exact: true,
+      })
+      expect(removeQueriesSpy).toHaveBeenCalledWith({ queryKey, exact: true })
 
       // Clear the spies to track new calls
       cancelQueriesSpy.mockClear()
@@ -964,8 +1342,11 @@ describe(`QueryCollection`, () => {
       await flushPromises()
 
       // Verify cleanup methods were called again for the restarted sync
-      expect(cancelQueriesSpy).toHaveBeenCalledWith({ queryKey })
-      expect(removeQueriesSpy).toHaveBeenCalledWith({ queryKey })
+      expect(cancelQueriesSpy).toHaveBeenCalledWith({
+        queryKey,
+        exact: true,
+      })
+      expect(removeQueriesSpy).toHaveBeenCalledWith({ queryKey, exact: true })
 
       // Restore spies
       cancelQueriesSpy.mockRestore()
@@ -1529,7 +1910,7 @@ describe(`QueryCollection`, () => {
       collection.utils.writeInsert(newItem)
 
       const cacheAfterInsert = queryClient.getQueryData(
-        queryKey
+        queryKey,
       ) as Array<TestItem>
       expect(cacheAfterInsert).toHaveLength(3)
       expect(cacheAfterInsert).toContainEqual(newItem)
@@ -1538,7 +1919,7 @@ describe(`QueryCollection`, () => {
       collection.utils.writeUpdate({ id: `1`, name: `Updated Item 1` })
 
       const cacheAfterUpdate = queryClient.getQueryData(
-        queryKey
+        queryKey,
       ) as Array<TestItem>
       expect(cacheAfterUpdate).toHaveLength(3)
       const updatedItem = cacheAfterUpdate.find((item) => item.id === `1`)
@@ -1548,7 +1929,7 @@ describe(`QueryCollection`, () => {
       collection.utils.writeDelete(`2`)
 
       const cacheAfterDelete = queryClient.getQueryData(
-        queryKey
+        queryKey,
       ) as Array<TestItem>
       expect(cacheAfterDelete).toHaveLength(2)
       expect(cacheAfterDelete).not.toContainEqual({
@@ -1561,7 +1942,7 @@ describe(`QueryCollection`, () => {
       collection.utils.writeUpsert({ id: `4`, name: `Item 4`, value: 40 })
 
       const cacheAfterUpsert = queryClient.getQueryData(
-        queryKey
+        queryKey,
       ) as Array<TestItem>
       expect(cacheAfterUpsert).toHaveLength(3)
       expect(cacheAfterUpsert).toContainEqual({
@@ -1587,13 +1968,13 @@ describe(`QueryCollection`, () => {
       })
 
       const cacheAfterBatch = queryClient.getQueryData(
-        queryKey
+        queryKey,
       ) as Array<TestItem>
       expect(cacheAfterBatch).toHaveLength(4) // 3 - 1 (delete) + 1 (insert) + 1 (upsert) = 4
 
       // Verify specific changes from batch
       expect(cacheAfterBatch).not.toContainEqual(
-        expect.objectContaining({ id: `1` })
+        expect.objectContaining({ id: `1` }),
       )
       expect(cacheAfterBatch).toContainEqual({
         id: `5`,
@@ -1652,7 +2033,7 @@ describe(`QueryCollection`, () => {
 
       // Verify cache wasn't modified
       const cacheAfterError = queryClient.getQueryData(
-        queryKey
+        queryKey,
       ) as Array<TestItem>
       expect(cacheAfterError).toEqual(initialCache)
       expect(cacheAfterError).toHaveLength(2)
@@ -1667,7 +2048,7 @@ describe(`QueryCollection`, () => {
 
       // Verify cache wasn't modified
       const cacheAfterBatchError = queryClient.getQueryData(
-        queryKey
+        queryKey,
       ) as Array<TestItem>
       expect(cacheAfterBatchError).toEqual(initialCache)
       expect(cacheAfterBatchError).toHaveLength(2)
@@ -1815,51 +2196,325 @@ describe(`QueryCollection`, () => {
       expect(collection2.has(`a`)).toBe(true)
       expect(collection2.has(`b`)).toBe(true)
     })
-  })
 
-  it(`should call markReady when queryFn returns an empty array`, async () => {
-    const queryKey = [`emptyArrayTest`]
-    const queryFn = vi.fn().mockResolvedValue([])
+    it(`should replace optimistic state with server state when writeInsert is called in onInsert handler`, async () => {
+      // Reproduces bug where optimistic client data overwrites server data in syncedData
+      // When writeInsert is called inside onInsert handler to sync server-generated fields
+      const queryKey = [`todos-writeinsert-bug`]
+      const queryFn = vi.fn().mockResolvedValue([])
+
+      type Todo = {
+        id: number
+        slug: string
+        title: string
+        checked: boolean
+        createdAt: string
+      }
 
-    const config: QueryCollectionConfig<TestItem> = {
-      id: `test`,
-      queryClient,
-      queryKey,
-      queryFn,
-      getKey,
-      startSync: true,
-    }
+      let nextServerId = 1
+      const serverTodos: Array<Todo> = []
 
-    const options = queryCollectionOptions(config)
-    const collection = createCollection(options)
+      async function sleep(timeMs: number) {
+        return new Promise((resolve) => setTimeout(resolve, timeMs))
+      }
 
-    // Wait for the query to complete
-    await vi.waitFor(
-      () => {
-        expect(queryFn).toHaveBeenCalledTimes(1)
-        // The collection should be marked as ready even with empty array
-        expect(collection.status).toBe(`ready`)
-      },
-      {
-        timeout: 1000,
-        interval: 50,
+      async function createTodos(newTodos: Array<Todo>) {
+        await sleep(50)
+        const savedTodos = newTodos.map((todo) => ({
+          ...todo,
+          id: nextServerId++,
+          createdAt: new Date().toISOString(),
+        }))
+        serverTodos.push(...savedTodos)
+        return savedTodos
       }
-    )
 
-    // Verify the collection is empty but ready
-    expect(collection.size).toBe(0)
-    expect(collection.status).toBe(`ready`)
-  })
+      const todosCollection = createCollection(
+        queryCollectionOptions<Todo>({
+          id: `writeinsert-bug-test`,
+          queryKey,
+          queryFn,
+          queryClient,
+          getKey: (item: Todo) => item.slug,
+          startSync: true,
+          onInsert: async ({ transaction }) => {
+            const newItems = transaction.mutations.map((m) => m.modified)
+            const serverItems = await createTodos(newItems)
+
+            // Write server data with server-generated IDs to synced store
+            todosCollection.utils.writeBatch(() => {
+              serverItems.forEach((serverItem) => {
+                todosCollection.utils.writeInsert(serverItem)
+              })
+            })
+
+            return { refetch: false }
+          },
+        }),
+      )
 
-  it(`should read the state of a query that is already ready`, async () => {
-    // Populate the query cache, so the query will immediately be loaded
-    const queryKey = [`raceConditionTest`]
-    const initialItems: Array<TestItem> = [
-      { id: `1`, name: `Cached Item 1` },
-      { id: `2`, name: `Cached Item 2` },
-    ]
+      await vi.waitFor(() => {
+        expect(todosCollection.status).toBe(`ready`)
+      })
+
+      // Insert with client-side negative ID
+      const clientId = -999
+      const slug = `test-slug-${Date.now()}`
+
+      todosCollection.insert({
+        id: clientId,
+        title: `Task`,
+        slug,
+        checked: false,
+        createdAt: new Date().toISOString(),
+      })
+
+      // Wait for mutation to complete
+      await flushPromises()
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      // Verify syncedData has server ID, not client ID
+      const syncedTodo = todosCollection._state.syncedData.get(slug)
+      expect(syncedTodo).toBeDefined()
+      expect(syncedTodo?.id).toBe(1) // Server-generated ID
+      expect(syncedTodo?.id).not.toBe(clientId) // Not client optimistic ID
+
+      // Verify visible state also shows server ID
+      const todo = todosCollection.get(slug)
+      expect(todo).toBeDefined()
+      expect(todo?.id).toBe(1)
+      expect(todo?.id).not.toBe(clientId)
+    })
+
+    it(`should update syncedData immediately when writeUpsert is called after async API in onUpdate handler`, async () => {
+      // Reproduces bug where syncedData shows stale values when writeUpsert is called
+      // AFTER an async API call in a mutation handler. The async await causes the
+      // transaction to be added to state.transactions before writeUpsert runs,
+      // which means commitPendingTransactions() sees hasPersistingTransaction=true
+      // and would skip processing the sync transaction without the immediate flag.
+      const queryKey = [`writeUpsert-after-api-test`]
+
+      type Brand = {
+        id: string
+        brandName: string
+      }
+
+      const serverBrands: Array<Brand> = [{ id: `123`, brandName: `A` }]
+
+      const queryFn = vi.fn().mockImplementation(async () => {
+        return [...serverBrands]
+      })
+
+      // Track syncedData state immediately after writeUpsert
+      let syncedDataAfterWriteUpsert: Brand | undefined
+      let hasPersistingTransactionDuringWrite = false
+
+      const collection = createCollection(
+        queryCollectionOptions<Brand>({
+          id: `writeUpsert-after-api-test`,
+          queryKey,
+          queryFn,
+          queryClient,
+          getKey: (item: Brand) => item.id,
+          startSync: true,
+          onUpdate: async ({ transaction }) => {
+            const updates = transaction.mutations.map((m) => m.modified)
+
+            // Simulate async API call - THIS IS KEY!
+            // After this await, the transaction will be in state.transactions
+            await new Promise((resolve) => setTimeout(resolve, 10))
+
+            // Check if there's now a persisting transaction
+            hasPersistingTransactionDuringWrite = Array.from(
+              collection._state.transactions.values(),
+            ).some((tx) => tx.state === `persisting`)
+
+            // Update server state
+            for (const update of updates) {
+              const idx = serverBrands.findIndex((b) => b.id === update.id)
+              if (idx !== -1) {
+                serverBrands[idx] = { ...serverBrands[idx], ...update }
+              }
+            }
+
+            // Write the server response back to syncedData
+            // Without the immediate flag, this would be blocked by the persisting transaction
+            collection.utils.writeBatch(() => {
+              for (const update of updates) {
+                collection.utils.writeUpsert(update)
+              }
+            })
+
+            // Check syncedData IMMEDIATELY after writeUpsert
+            syncedDataAfterWriteUpsert = collection._state.syncedData.get(`123`)
+
+            return { refetch: false }
+          },
+        }),
+      )
+
+      await vi.waitFor(() => {
+        expect(collection.status).toBe(`ready`)
+      })
+
+      // Verify initial state
+      expect(collection._state.syncedData.get(`123`)?.brandName).toBe(`A`)
+
+      // Update brandName from A to B
+      collection.update(`123`, (draft) => {
+        draft.brandName = `B`
+      })
+
+      // Wait for mutation to complete
+      await flushPromises()
+      await new Promise((resolve) => setTimeout(resolve, 50))
+
+      // Verify we had a persisting transaction during the write
+      expect(hasPersistingTransactionDuringWrite).toBe(true)
+
+      // The CRITICAL assertion: syncedData should have been updated IMMEDIATELY after writeUpsert
+      // Without the fix, this would fail because commitPendingTransactions() would skip
+      // processing due to hasPersistingTransaction being true
+      expect(syncedDataAfterWriteUpsert).toBeDefined()
+      expect(syncedDataAfterWriteUpsert?.brandName).toBe(`B`)
+    })
+
+    it(`should not rollback object field updates after server response with refetch: false`, async () => {
+      const queryKey = [`object-field-update-test`]
+
+      type Todo = {
+        id: string
+        metadata: { createdBy: string }
+      }
+
+      const serverTodos: Array<Todo> = [
+        { id: `1`, metadata: { createdBy: `user1` } },
+      ]
+
+      const queryFn = vi
+        .fn()
+        .mockImplementation(() => Promise.resolve([...serverTodos]))
+
+      async function updateTodo(id: string, changes: Partial<Todo>) {
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        const todo = serverTodos.find((t) => t.id === id)
+        if (todo) {
+          Object.assign(todo, changes)
+        }
+        return todo
+      }
+
+      const todosCollection = createCollection(
+        queryCollectionOptions<Todo>({
+          id: `object-field-update-test`,
+          queryKey,
+          queryFn,
+          queryClient,
+          getKey: (item: Todo) => item.id,
+          startSync: true,
+          onUpdate: async ({ transaction }) => {
+            const updates = transaction.mutations.map((m) => ({
+              id: m.key as string,
+              changes: m.changes,
+            }))
+
+            const serverItems = await Promise.all(
+              updates.map((update) => updateTodo(update.id, update.changes)),
+            )
+
+            todosCollection.utils.writeBatch(() => {
+              serverItems.forEach((serverItem) => {
+                if (serverItem) {
+                  todosCollection.utils.writeUpdate(serverItem)
+                }
+              })
+            })
+
+            return { refetch: false }
+          },
+        }),
+      )
+
+      await vi.waitFor(() => {
+        expect(todosCollection.status).toBe(`ready`)
+      })
+
+      // Verify initial state
+      expect(todosCollection.get(`1`)?.metadata.createdBy).toBe(`user1`)
+
+      // Update 1: change metadata from user1 to user456
+      todosCollection.update(`1`, (draft) => {
+        draft.metadata = { createdBy: `user456` }
+      })
+
+      // Wait for mutation to complete
+      await new Promise((resolve) => setTimeout(resolve, 50))
+
+      // Verify Update 1 worked
+      expect(todosCollection.get(`1`)?.metadata.createdBy).toBe(`user456`)
+      expect(
+        todosCollection._state.syncedData.get(`1`)?.metadata.createdBy,
+      ).toBe(`user456`)
+
+      // Update 2: change metadata from user456 to user789
+      todosCollection.update(`1`, (draft) => {
+        draft.metadata = { createdBy: `user789` }
+      })
+
+      // Wait for mutation to complete
+      await new Promise((resolve) => setTimeout(resolve, 50))
+
+      // Verify Update 2 persisted correctly
+      expect(
+        todosCollection._state.syncedData.get(`1`)?.metadata.createdBy,
+      ).toBe(`user789`)
+      expect(todosCollection.get(`1`)?.metadata.createdBy).toBe(`user789`)
+    })
+  })
+
+  it(`should call markReady when queryFn returns an empty array`, async () => {
+    const queryKey = [`emptyArrayTest`]
+    const queryFn = vi.fn().mockResolvedValue([])
+
+    const config: QueryCollectionConfig<TestItem> = {
+      id: `test`,
+      queryClient,
+      queryKey,
+      queryFn,
+      getKey,
+      startSync: true,
+    }
+
+    const options = queryCollectionOptions(config)
+    const collection = createCollection(options)
+
+    // Wait for the query to complete
+    await vi.waitFor(
+      () => {
+        expect(queryFn).toHaveBeenCalledTimes(1)
+        // The collection should be marked as ready even with empty array
+        expect(collection.status).toBe(`ready`)
+      },
+      {
+        timeout: 1000,
+        interval: 50,
+      },
+    )
+
+    // Verify the collection is empty but ready
+    expect(collection.size).toBe(0)
+    expect(collection.status).toBe(`ready`)
+  })
+
+  it(`should read the state of a query that is already ready`, async () => {
+    // Populate the query cache, so the query will immediately be loaded
+    const queryKey = [`raceConditionTest`]
+    const initialItems: Array<TestItem> = [
+      { id: `1`, name: `Cached Item 1` },
+      { id: `2`, name: `Cached Item 2` },
+    ]
     const queryFn: (
-      context: QueryFunctionContext<any>
+      context: QueryFunctionContext<any>,
     ) => Promise<Array<TestItem>> = vi.fn().mockReturnValue(initialItems)
     await queryClient.prefetchQuery({ queryKey, queryFn })
 
@@ -1873,12 +2528,12 @@ describe(`QueryCollection`, () => {
         getKey,
         startSync: true,
         staleTime: 60000, // uses the prefetched value without a refetch
-      })
+      }),
     )
     expect(collection.status).toBe(`ready`)
     expect(collection.size).toBe(2)
     expect(Array.from(collection.values())).toEqual(
-      expect.arrayContaining(initialItems)
+      expect.arrayContaining(initialItems),
     )
   })
 
@@ -1958,11 +2613,289 @@ describe(`QueryCollection`, () => {
     })
   })
 
+  it(`should use exact targeting when refetching to avoid unintended cascading of related queries`, async () => {
+    // Create multiple collections with related but distinct query keys
+    const queryKey = [`todos`]
+    const queryKey1 = [`todos`, `project-1`]
+    const queryKey2 = [`todos`, `project-2`]
+
+    const mockItems = [{ id: `1`, name: `Item 1` }]
+    const queryFn = vi.fn().mockResolvedValue(mockItems)
+    const queryFn1 = vi.fn().mockResolvedValue(mockItems)
+    const queryFn2 = vi.fn().mockResolvedValue(mockItems)
+
+    const config: QueryCollectionConfig<TestItem> = {
+      id: `all-todos`,
+      queryClient,
+      queryKey: queryKey,
+      queryFn: queryFn,
+      getKey,
+      startSync: true,
+    }
+    const config1: QueryCollectionConfig<TestItem> = {
+      id: `project-1-todos`,
+      queryClient,
+      queryKey: queryKey1,
+      queryFn: queryFn1,
+      getKey,
+      startSync: true,
+    }
+    const config2: QueryCollectionConfig<TestItem> = {
+      id: `project-2-todos`,
+      queryClient,
+      queryKey: queryKey2,
+      queryFn: queryFn2,
+      getKey,
+      startSync: true,
+    }
+
+    const options = queryCollectionOptions(config)
+    const options1 = queryCollectionOptions(config1)
+    const options2 = queryCollectionOptions(config2)
+
+    const collection = createCollection(options)
+    const collection1 = createCollection(options1)
+    const collection2 = createCollection(options2)
+
+    // Wait for initial queries to complete
+    await vi.waitFor(() => {
+      expect(queryFn).toHaveBeenCalledTimes(1)
+      expect(queryFn1).toHaveBeenCalledTimes(1)
+      expect(queryFn2).toHaveBeenCalledTimes(1)
+      expect(collection.status).toBe(`ready`)
+    })
+
+    // Reset call counts to test refetch behavior
+    queryFn.mockClear()
+    queryFn1.mockClear()
+    queryFn2.mockClear()
+
+    // Refetch the target collection with key ['todos', 'project-1']
+    await collection1.utils.refetch()
+
+    // Verify that only the target query was refetched
+    await vi.waitFor(() => {
+      expect(queryFn1).toHaveBeenCalledTimes(1)
+      expect(queryFn).not.toHaveBeenCalled()
+      expect(queryFn2).not.toHaveBeenCalled()
+    })
+
+    // Cleanup
+    await Promise.all([
+      collection.cleanup(),
+      collection1.cleanup(),
+      collection2.cleanup(),
+    ])
+  })
+
+  it(`should use exact targeting when clearError() refetches to avoid unintended cascading`, async () => {
+    const queryKey1 = [`todos`, `project-1`]
+    const queryKey2 = [`todos`, `project-2`]
+
+    const testError = new Error(`Test error`)
+    const mockItems = [{ id: `1`, name: `Item 1` }]
+    const queryFn1 = vi
+      .fn()
+      .mockRejectedValueOnce(testError)
+      .mockResolvedValue(mockItems)
+    const queryFn2 = vi.fn().mockResolvedValue(mockItems)
+
+    const config1: QueryCollectionConfig<TestItem> = {
+      id: `project-1-todos-clear-error`,
+      queryClient,
+      queryKey: queryKey1,
+      queryFn: queryFn1,
+      getKey,
+      startSync: true,
+      retry: false,
+    }
+    const config2: QueryCollectionConfig<TestItem> = {
+      id: `project-2-todos-clear-error`,
+      queryClient,
+      queryKey: queryKey2,
+      queryFn: queryFn2,
+      getKey,
+      startSync: true,
+      retry: false,
+    }
+
+    const options1 = queryCollectionOptions(config1)
+    const options2 = queryCollectionOptions(config2)
+
+    const collection1 = createCollection(options1)
+    const collection2 = createCollection(options2)
+
+    await vi.waitFor(() => {
+      expect(collection1.utils.isError).toBe(true)
+      expect(collection2.status).toBe(`ready`)
+    })
+
+    queryFn1.mockClear()
+    queryFn2.mockClear()
+
+    await collection1.utils.clearError()
+
+    await vi.waitFor(() => {
+      expect(queryFn1).toHaveBeenCalledTimes(1)
+      expect(queryFn2).not.toHaveBeenCalled()
+    })
+
+    await Promise.all([collection1.cleanup(), collection2.cleanup()])
+  })
+
+  it(`should propagate errors when throwOnError is true in refetch`, async () => {
+    const testError = new Error(`Refetch error`)
+    const queryKey = [`throw-on-error-test`]
+    const queryFn = vi.fn().mockRejectedValue(testError)
+
+    await queryClient.prefetchQuery({ queryKey, queryFn })
+
+    const collection = createCollection(
+      queryCollectionOptions({
+        id: `throw-on-error-test`,
+        queryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        retry: false,
+        startSync: true,
+      }),
+    )
+
+    await vi.waitFor(() => {
+      expect(collection.utils.isError).toBe(true)
+    })
+
+    await expect(
+      collection.utils.refetch({ throwOnError: true }),
+    ).rejects.toThrow(testError)
+
+    // Should not throw when throwOnError is false
+    await collection.utils.refetch({ throwOnError: false })
+
+    await collection.cleanup()
+  })
+
+  describe(`refetch() behavior`, () => {
+    it(`should refetch when collection is syncing (startSync: true)`, async () => {
+      const queryKey = [`refetch-test-syncing`]
+      const queryFn = vi.fn().mockResolvedValue([{ id: `1`, name: `A` }])
+
+      const collection = createCollection(
+        queryCollectionOptions({
+          id: `refetch-test-syncing`,
+          queryClient,
+          queryKey,
+          queryFn,
+          getKey,
+          startSync: true,
+        }),
+      )
+
+      await vi.waitFor(() => {
+        expect(collection.status).toBe(`ready`)
+      })
+
+      queryFn.mockClear()
+
+      await collection.utils.refetch()
+      expect(queryFn).toHaveBeenCalledTimes(1)
+
+      await collection.cleanup()
+    })
+
+    it(`should refetch even when enabled: false (imperative refetch pattern)`, async () => {
+      const mockItems: Array<TestItem> = [{ id: `1`, name: `Item 1` }]
+      const queryKey = [`manual-fetch-test`]
+      const queryFn = vi.fn().mockResolvedValue(mockItems)
+
+      const collection = createCollection(
+        queryCollectionOptions({
+          id: `manual-fetch-test`,
+          queryClient,
+          queryKey,
+          queryFn,
+          getKey,
+          enabled: false,
+          startSync: true,
+        }),
+      )
+
+      // Query should not auto-fetch due to enabled: false
+      expect(queryFn).not.toHaveBeenCalled()
+
+      // But manual refetch should work
+      await collection.utils.refetch()
+      expect(queryFn).toHaveBeenCalledTimes(1)
+
+      await collection.cleanup()
+    })
+
+    it(`should be no-op when sync has not started (no observer created)`, async () => {
+      const queryKey = [`refetch-test-no-sync`]
+      const queryFn = vi.fn().mockResolvedValue([{ id: `1`, name: `A` }])
+
+      const collection = createCollection(
+        queryCollectionOptions({
+          id: `refetch-test-no-sync`,
+          queryClient,
+          queryKey,
+          queryFn,
+          getKey,
+          startSync: false,
+        }),
+      )
+
+      // Refetch should be no-op because observer doesn't exist yet
+      await collection.utils.refetch()
+      expect(queryFn).not.toHaveBeenCalled()
+
+      await collection.cleanup()
+    })
+
+    it(`should return array of QueryObserverResult`, async () => {
+      const queryKey = [`refetch-return-value-test`]
+      const mockData = [{ id: `1`, val: Math.random() * 100 }]
+      const queryFn = vi.fn().mockResolvedValue(mockData)
+
+      const collection = createCollection(
+        queryCollectionOptions({
+          id: `refetch-return-value-test`,
+          queryClient,
+          queryKey,
+          queryFn,
+          getKey,
+          startSync: true,
+        }),
+      )
+
+      await vi.waitFor(() => {
+        expect(collection.status).toBe(`ready`)
+      })
+
+      queryFn.mockClear()
+
+      const result = await collection.utils.refetch()
+
+      expect(queryFn).toHaveBeenCalledTimes(1)
+
+      expect(result).not.toBeUndefined()
+      expect(Array.isArray(result)).toBe(true)
+      expect(result.length).toBeGreaterThan(0)
+      for (const r of result) {
+        expect(r).toHaveProperty(`status`)
+        expect(r).toHaveProperty(`data`)
+      }
+
+      await collection.cleanup()
+    })
+  })
+
   describe(`Error Handling`, () => {
     // Helper to create test collection with common configuration
     const createErrorHandlingTestCollection = (
       testId: string,
-      queryFn: ReturnType<typeof vi.fn>
+      queryFn: ReturnType<typeof vi.fn>,
     ) => {
       const config: QueryCollectionConfig<TestItem> = {
         id: testId,
@@ -1991,39 +2924,39 @@ describe(`QueryCollection`, () => {
 
       const collection = createErrorHandlingTestCollection(
         `error-tracking-test`,
-        queryFn
+        queryFn,
       )
 
       // Wait for initial success - no errors
       await vi.waitFor(() => {
         expect(collection.status).toBe(`ready`)
-        expect(collection.utils.lastError()).toBeUndefined()
-        expect(collection.utils.isError()).toBe(false)
-        expect(collection.utils.errorCount()).toBe(0)
+        expect(collection.utils.lastError).toBeUndefined()
+        expect(collection.utils.isError).toBe(false)
+        expect(collection.utils.errorCount).toBe(0)
       })
 
       // First error - count increments
       await collection.utils.refetch()
       await vi.waitFor(() => {
-        expect(collection.utils.lastError()).toBe(errors[0])
-        expect(collection.utils.errorCount()).toBe(1)
-        expect(collection.utils.isError()).toBe(true)
+        expect(collection.utils.lastError).toBe(errors[0])
+        expect(collection.utils.errorCount).toBe(1)
+        expect(collection.utils.isError).toBe(true)
       })
 
       // Second error - count increments again
       await collection.utils.refetch()
       await vi.waitFor(() => {
-        expect(collection.utils.lastError()).toBe(errors[1])
-        expect(collection.utils.errorCount()).toBe(2)
-        expect(collection.utils.isError()).toBe(true)
+        expect(collection.utils.lastError).toBe(errors[1])
+        expect(collection.utils.errorCount).toBe(2)
+        expect(collection.utils.isError).toBe(true)
       })
 
       // Successful refetch resets error state
       await collection.utils.refetch()
       await vi.waitFor(() => {
-        expect(collection.utils.lastError()).toBeUndefined()
-        expect(collection.utils.isError()).toBe(false)
-        expect(collection.utils.errorCount()).toBe(0)
+        expect(collection.utils.lastError).toBeUndefined()
+        expect(collection.utils.isError).toBe(false)
+        expect(collection.utils.errorCount).toBe(0)
         expect(collection.get(`1`)).toEqual(updatedData[0])
       })
     })
@@ -2040,21 +2973,21 @@ describe(`QueryCollection`, () => {
 
       const collection = createErrorHandlingTestCollection(
         `clear-error-test`,
-        queryFn
+        queryFn,
       )
 
       // Wait for initial error
       await vi.waitFor(() => {
-        expect(collection.utils.isError()).toBe(true)
-        expect(collection.utils.errorCount()).toBe(1)
+        expect(collection.utils.isError).toBe(true)
+        expect(collection.utils.errorCount).toBe(1)
       })
 
       // Manual error clearing triggers refetch
       await collection.utils.clearError()
 
-      expect(collection.utils.lastError()).toBeUndefined()
-      expect(collection.utils.isError()).toBe(false)
-      expect(collection.utils.errorCount()).toBe(0)
+      expect(collection.utils.lastError).toBeUndefined()
+      expect(collection.utils.isError).toBe(false)
+      expect(collection.utils.errorCount).toBe(0)
 
       await vi.waitFor(() => {
         expect(collection.get(`1`)).toEqual(recoveryData[0])
@@ -2062,9 +2995,9 @@ describe(`QueryCollection`, () => {
 
       // Refetch on rejection should throw an error
       await expect(collection.utils.clearError()).rejects.toThrow(testError)
-      expect(collection.utils.lastError()).toBe(testError)
-      expect(collection.utils.isError()).toBe(true)
-      expect(collection.utils.errorCount()).toBe(1)
+      expect(collection.utils.lastError).toBe(testError)
+      expect(collection.utils.isError).toBe(true)
+      expect(collection.utils.errorCount).toBe(1)
     })
 
     it(`should maintain collection functionality despite errors and persist error state`, async () => {
@@ -2081,7 +3014,7 @@ describe(`QueryCollection`, () => {
 
       const collection = createErrorHandlingTestCollection(
         `functionality-with-errors-test`,
-        queryFn
+        queryFn,
       )
 
       await vi.waitFor(() => {
@@ -2092,8 +3025,8 @@ describe(`QueryCollection`, () => {
       // Cause error
       await collection.utils.refetch()
       await vi.waitFor(() => {
-        expect(collection.utils.errorCount()).toBe(1)
-        expect(collection.utils.isError()).toBe(true)
+        expect(collection.utils.errorCount).toBe(1)
+        expect(collection.utils.isError).toBe(true)
       })
 
       // Collection operations still work with cached data
@@ -2110,25 +3043,25 @@ describe(`QueryCollection`, () => {
       await flushPromises()
 
       // Manual writes clear error state
-      expect(collection.utils.lastError()).toBeUndefined()
-      expect(collection.utils.isError()).toBe(false)
-      expect(collection.utils.errorCount()).toBe(0)
+      expect(collection.utils.lastError).toBeUndefined()
+      expect(collection.utils.isError).toBe(false)
+      expect(collection.utils.errorCount).toBe(0)
 
       // Create error state again for persistence test
       await collection.utils.refetch()
-      await vi.waitFor(() => expect(collection.utils.isError()).toBe(true))
+      await vi.waitFor(() => expect(collection.utils.isError).toBe(true))
 
-      const originalError = collection.utils.lastError()
-      const originalErrorCount = collection.utils.errorCount()
+      const originalError = collection.utils.lastError
+      const originalErrorCount = collection.utils.errorCount
 
       // Read-only operations don't affect error state
       expect(collection.has(`1`)).toBe(true)
       const changeHandler = vi.fn()
       const subscription = collection.subscribeChanges(changeHandler)
 
-      expect(collection.utils.lastError()).toBe(originalError)
-      expect(collection.utils.isError()).toBe(true)
-      expect(collection.utils.errorCount()).toBe(originalErrorCount)
+      expect(collection.utils.lastError).toBe(originalError)
+      expect(collection.utils.isError).toBe(true)
+      expect(collection.utils.errorCount).toBe(originalErrorCount)
 
       subscription.unsubscribe()
     })
@@ -2168,16 +3101,16 @@ describe(`QueryCollection`, () => {
       // Wait for collection to be ready (even with error)
       await vi.waitFor(() => {
         expect(collection.status).toBe(`ready`)
-        expect(collection.utils.isError()).toBe(true)
+        expect(collection.utils.isError).toBe(true)
       })
 
       // Verify custom error is accessible with all its properties
-      const lastError = collection.utils.lastError()
+      const lastError = collection.utils.lastError
       expect(lastError).toBe(customError)
       expect(lastError?.code).toBe(`NETWORK_ERROR`)
       expect(lastError?.message).toBe(`Failed to fetch data`)
       expect(lastError?.details?.retryAfter).toBe(5000)
-      expect(collection.utils.errorCount()).toBe(1)
+      expect(collection.utils.errorCount).toBe(1)
     })
 
     it(`should persist error state after collection cleanup`, async () => {
@@ -2188,27 +3121,27 @@ describe(`QueryCollection`, () => {
 
       const collection = createErrorHandlingTestCollection(
         `error-persistence-cleanup-test`,
-        queryFn
+        queryFn,
       )
 
       // Wait for collection to be ready (even with error)
       await vi.waitFor(() => {
         expect(collection.status).toBe(`ready`)
-        expect(collection.utils.isError()).toBe(true)
+        expect(collection.utils.isError).toBe(true)
       })
 
       // Verify error state before cleanup
-      expect(collection.utils.lastError()).toBe(testError)
-      expect(collection.utils.errorCount()).toBe(1)
+      expect(collection.utils.lastError).toBe(testError)
+      expect(collection.utils.errorCount).toBe(1)
 
       // Cleanup collection
       await collection.cleanup()
       expect(collection.status).toBe(`cleaned-up`)
 
       // Error state should persist after cleanup
-      expect(collection.utils.isError()).toBe(true)
-      expect(collection.utils.lastError()).toBe(testError)
-      expect(collection.utils.errorCount()).toBe(1)
+      expect(collection.utils.isError).toBe(true)
+      expect(collection.utils.lastError).toBe(testError)
+      expect(collection.utils.errorCount).toBe(1)
     })
 
     it(`should increment errorCount only after final failure when using Query retries`, async () => {
@@ -2239,16 +3172,16 @@ describe(`QueryCollection`, () => {
         () => {
           expect(collection.status).toBe(`ready`) // Should be ready even with error
           expect(queryFn).toHaveBeenCalledTimes(totalAttempts)
-          expect(collection.utils.isError()).toBe(true)
+          expect(collection.utils.isError).toBe(true)
         },
-        { timeout: 2000 }
+        { timeout: 2000 },
       )
 
       // Error count should only increment once after all retries are exhausted
       // This ensures we track "consecutive post-retry failures," not per-attempt failures
-      expect(collection.utils.errorCount()).toBe(1)
-      expect(collection.utils.lastError()).toBe(testError)
-      expect(collection.utils.isError()).toBe(true)
+      expect(collection.utils.errorCount).toBe(1)
+      expect(collection.utils.lastError).toBe(testError)
+      expect(collection.utils.isError).toBe(true)
 
       // Reset attempt counter for second test
       queryFn.mockClear()
@@ -2261,13 +3194,13 @@ describe(`QueryCollection`, () => {
         () => {
           expect(queryFn).toHaveBeenCalledTimes(totalAttempts)
         },
-        { timeout: 2000 }
+        { timeout: 2000 },
       )
 
       // Error count should now be 2 (two post-retry failures)
-      expect(collection.utils.errorCount()).toBe(2)
-      expect(collection.utils.lastError()).toBe(testError)
-      expect(collection.utils.isError()).toBe(true)
+      expect(collection.utils.errorCount).toBe(2)
+      expect(collection.utils.lastError).toBe(testError)
+      expect(collection.utils.isError).toBe(true)
     })
   })
 
@@ -2339,5 +3272,1919 @@ describe(`QueryCollection`, () => {
       expect(collection.status).toBe(`ready`)
       expect(collection.size).toBe(items.length)
     })
+    it(`should allow writeDelete in onDelete handler to write to synced store`, async () => {
+      const queryKey = [`writeDelete-in-onDelete-test`]
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const onDelete = vi.fn(async ({ transaction, collection }) => {
+        const deletedItem = transaction.mutations[0]?.original
+        // Call writeDelete inside onDelete handler - this should work without throwing
+        collection.utils.writeDelete(deletedItem.id)
+        return { refetch: false }
+      })
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `writeDelete-in-onDelete-test`,
+        queryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+        onDelete,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      await vi.waitFor(() => {
+        expect(collection.status).toBe(`ready`)
+        expect(collection.size).toBe(2)
+      })
+
+      const transaction = collection.delete(`1`)
+      await transaction.isPersisted.promise
+
+      // Verify the fix: writeDelete should work, transaction completes, item is deleted
+      expect(transaction.state).toBe(`completed`)
+      expect(onDelete).toHaveBeenCalledTimes(1)
+      expect(collection.has(`1`)).toBe(false)
+      expect(collection.size).toBe(1)
+    })
+
+    it(`should transition to ready immediately in on-demand mode without loading data`, async () => {
+      const queryKey = [`preload-on-demand-test`]
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `preload-on-demand-test`,
+        queryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        syncMode: `on-demand`, // No initial query in on-demand mode
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Collection should be idle initially
+      expect(collection.status).toBe(`idle`)
+      expect(queryFn).not.toHaveBeenCalled()
+      expect(collection.size).toBe(0)
+
+      // Preload should resolve immediately without calling queryFn
+      // since there's no initial query in on-demand mode
+      await collection.preload()
+
+      // After preload, collection should be ready
+      // but queryFn should NOT have been called and collection should still be empty
+      expect(collection.status).toBe(`ready`)
+      expect(queryFn).not.toHaveBeenCalled()
+      expect(collection.size).toBe(0)
+
+      // Now if we call loadSubset, it should actually load data
+      await collection._sync.loadSubset({})
+
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(items.length)
+      })
+
+      expect(queryFn).toHaveBeenCalledTimes(1)
+      expect(collection.get(`1`)).toEqual(items[0])
+      expect(collection.get(`2`)).toEqual(items[1])
+    })
+  })
+
+  describe(`QueryClient defaultOptions`, () => {
+    it(`should respect defaultOptions from QueryClient when not overridden`, async () => {
+      // Create a QueryClient with custom defaultOptions
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            staleTime: 10000, // 10 seconds
+            retry: 2,
+            refetchOnWindowFocus: false,
+          },
+        },
+      })
+
+      const queryKey = [`defaultOptionsTest`]
+      const items: Array<TestItem> = [{ id: `1`, name: `Item 1` }]
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      // Create a collection without specifying staleTime or retry
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `defaultOptionsTest`,
+        queryClient: customQueryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      await vi.waitFor(() => {
+        expect(collection.status).toBe(`ready`)
+      })
+
+      // Verify queryFn was called once
+      expect(queryFn).toHaveBeenCalledTimes(1)
+
+      // Verify the query has the correct staleTime from defaultOptions
+      const query = customQueryClient.getQueryCache().find({ queryKey })
+      expect((query?.options as any).staleTime).toBe(10000)
+
+      // Clean up
+      customQueryClient.clear()
+    })
+
+    it(`should override defaultOptions when explicitly provided in queryCollectionOptions`, async () => {
+      // Create a QueryClient with custom defaultOptions
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            staleTime: 10000, // 10 seconds default
+            retry: 2,
+          },
+        },
+      })
+
+      const queryKey = [`overrideOptionsTest`]
+      const items: Array<TestItem> = [{ id: `1`, name: `Item 1` }]
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      // Create a collection WITH explicit staleTime override
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `overrideOptionsTest`,
+        queryClient: customQueryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+        staleTime: 100, // Override to 100ms
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      await vi.waitFor(() => {
+        expect(collection.status).toBe(`ready`)
+      })
+
+      // Verify the query uses the overridden staleTime (100ms), not the default (10000ms)
+      const query = customQueryClient.getQueryCache().find({ queryKey })
+      expect((query?.options as any).staleTime).toBe(100)
+
+      // Clean up
+      customQueryClient.clear()
+    })
+
+    it(`should use retry from QueryClient defaultOptions when not overridden`, async () => {
+      let callCount = 0
+      // Create a QueryClient with custom retry defaultOption
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            retry: 2, // Retry 2 times
+            retryDelay: 1, // 1ms delay for fast test
+          },
+        },
+      })
+
+      const queryKey = [`retryDefaultOptionsTest`]
+      const queryFn = vi.fn().mockImplementation(() => {
+        callCount++
+        // Fail on first 2 attempts, succeed on 3rd
+        if (callCount <= 2) {
+          return Promise.reject(new Error(`Attempt ${callCount} failed`))
+        }
+        return Promise.resolve([{ id: `1`, name: `Item 1` }])
+      })
+
+      // Create a collection without specifying retry
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `retryDefaultOptionsTest`,
+        queryClient: customQueryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Wait for the query to eventually succeed (after retries)
+      await vi.waitFor(
+        () => {
+          expect(collection.status).toBe(`ready`)
+        },
+        { timeout: 2000 },
+      )
+
+      // Should have called queryFn 3 times (initial + 2 retries)
+      expect(callCount).toBe(3)
+
+      // Clean up
+      customQueryClient.clear()
+    })
+  })
+
+  describe(`Query Garbage Collection`, () => {
+    const isCategory = (category: `A` | `B` | `C`, where: any) => {
+      return (
+        where &&
+        where.type === `func` &&
+        where.name === `eq` &&
+        where.args[0].path[0] === `category` &&
+        where.args[1].value === category
+      )
+    }
+
+    it(`should delete all rows when a single query is garbage collected`, async () => {
+      const queryKey = [`single-query-gc-test`]
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+        { id: `3`, name: `Item 3` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `single-query-gc-test`,
+        queryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Wait for initial data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3)
+        expect(collection.get(`1`)).toEqual(items[0])
+        expect(collection.get(`2`)).toEqual(items[1])
+        expect(collection.get(`3`)).toEqual(items[2])
+      })
+
+      // Verify all items are in the collection
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+      expect(collection.has(`3`)).toBe(true)
+
+      // Simulate query garbage collection by removing the query from the cache
+      await collection.cleanup()
+
+      // Verify all items are removed
+      expect(collection.has(`1`)).toBe(false)
+      expect(collection.has(`2`)).toBe(false)
+      expect(collection.has(`3`)).toBe(false)
+    })
+
+    it(`should only delete non-shared rows when one of multiple overlapping queries is GCed`, async () => {
+      const baseQueryKey = [`overlapping-query-test`]
+
+      // Mock queryFn to return different data based on predicates
+      const queryFn = vi.fn().mockImplementation((context) => {
+        const { meta } = context
+        const loadSubsetOptions = meta?.loadSubsetOptions ?? {}
+        const { where } = loadSubsetOptions
+
+        // Query 1: items 1, 2, 3 (where: { category: 'A' })
+        if (isCategory(`A`, where)) {
+          console.log(`Is category A`)
+          return Promise.resolve([
+            { id: `1`, name: `Item 1` },
+            { id: `2`, name: `Item 2` },
+            { id: `3`, name: `Item 3` },
+          ])
+        }
+
+        // Query 2: items 2, 3, 4 (where: { category: 'B' })
+        if (isCategory(`B`, where)) {
+          return Promise.resolve([
+            { id: `2`, name: `Item 2` },
+            { id: `3`, name: `Item 3` },
+            { id: `4`, name: `Item 4` },
+          ])
+        }
+
+        // Query 3: items 3, 4, 5 (where: { category: 'C' })
+        if (isCategory(`C`, where)) {
+          return Promise.resolve([
+            { id: `3`, name: `Item 3` },
+            { id: `4`, name: `Item 4` },
+            { id: `5`, name: `Item 5` },
+          ])
+        }
+        return Promise.resolve([])
+      })
+
+      const queryKey = (ctx: any) => {
+        if (ctx.where) {
+          return [...baseQueryKey, ctx.where]
+        }
+        return baseQueryKey
+      }
+
+      const config: QueryCollectionConfig<
+        TestItem & { category: `A` | `B` | `C` }
+      > = {
+        id: `overlapping-test`,
+        queryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Collection should start empty with on-demand sync mode
+      expect(collection.size).toBe(0)
+
+      // Load query 1 with no predicates (items 1, 2, 3)
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query1.preload()
+
+      // Wait for query 1 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3)
+      })
+
+      // Add query 2 with different predicates (items 2, 3, 4)
+      // We abuse the `where` clause being typed as `any` to pass a category
+      // but in real usage this would be some Intermediate Representation of the where clause
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `B`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query2.preload()
+
+      // Wait for query 2 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(4) // Should have items 1, 2, 3, 4
+      })
+
+      // Add query 3 with different predicates
+      const query3 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `C`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query3.preload()
+
+      // Wait for query 3 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(5) // Should have items 1, 2, 3, 4, 5
+      })
+
+      // Verify all items are present
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+      expect(collection.has(`3`)).toBe(true)
+      expect(collection.has(`4`)).toBe(true)
+      expect(collection.has(`5`)).toBe(true)
+
+      // GC query 1 (no predicates) - should only remove item 1 (unique to query 1)
+      // Items 2 and 3 should remain because they're shared with other queries
+      await query1.cleanup()
+
+      // Wait for async GC to complete (gcTime: 0 still schedules async removal)
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(4) // Should have items 2, 3, 4, 5
+      })
+
+      // Verify item 1 is removed (it was only in query 1)
+      expect(collection.has(`1`)).toBe(false)
+
+      // Verify shared items are still present
+      expect(collection.has(`2`)).toBe(true)
+      expect(collection.has(`3`)).toBe(true)
+      expect(collection.has(`4`)).toBe(true)
+      expect(collection.has(`5`)).toBe(true)
+
+      // GC query 2 (where: { category: 'B' }) - should remove item 2
+      // Items 3 and 4 should remain because they are shared with query 3
+      await query2.cleanup()
+
+      // Wait for async GC to complete
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3) // Should have items 3, 4, 5
+      })
+
+      // Verify item 2 is removed (it was only in query 2)
+      expect(collection.has(`2`)).toBe(false)
+
+      // Verify items 3 and 4 are still present (shared with query 3)
+      expect(collection.has(`3`)).toBe(true)
+      expect(collection.has(`4`)).toBe(true)
+      expect(collection.has(`5`)).toBe(true)
+
+      // GC query 3 (where: { category: 'C' }) - should remove all remaining items
+      await query3.cleanup()
+
+      // Wait for async GC to complete
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(0)
+      })
+
+      // Verify all items are now removed
+      expect(collection.has(`3`)).toBe(false)
+      expect(collection.has(`4`)).toBe(false)
+      expect(collection.has(`5`)).toBe(false)
+    })
+
+    it(`should handle GC of queries with identical data`, async () => {
+      const baseQueryKey = [`identical-query-test`]
+
+      // Mock queryFn to return the same data for all queries
+      const queryFn = vi.fn().mockImplementation(() => {
+        // All queries return the same data regardless of predicates
+        return Promise.resolve([
+          { id: `1`, name: `Item 1`, category: `A` },
+          { id: `2`, name: `Item 2`, category: `A` },
+          { id: `3`, name: `Item 3`, category: `A` },
+        ])
+      })
+
+      const config: QueryCollectionConfig<CategorisedItem> = {
+        id: `identical-test`,
+        queryClient,
+        queryKey: (ctx) => {
+          if (ctx.where) {
+            return [...baseQueryKey, ctx.where]
+          }
+          return baseQueryKey
+        },
+        queryFn,
+        getKey,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Collection should start empty with on-demand sync mode
+      expect(collection.size).toBe(0)
+
+      // Load query 1 with no predicates (items 1, 2, 3)
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query1.preload()
+
+      // Wait for query 1 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3)
+      })
+
+      // Add query 2 with different predicates (but returns same data)
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query2.preload()
+
+      // Wait for query 2 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3) // Same data, no new items
+      })
+
+      // Add query 3 with different predicates (but returns same data)
+      const query3 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) =>
+              or(eq(item.category, `A`), eq(item.category, `B`)),
+            )
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query3.preload()
+
+      // Wait for query 3 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3) // Same data, no new items
+      })
+
+      // GC query 1 - should not remove any items (all items are shared with other queries)
+      await query1.cleanup()
+
+      expect(collection.size).toBe(3) // Items still present due to other queries
+
+      // All items should still be present
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+      expect(collection.has(`3`)).toBe(true)
+
+      // GC query 2 - should still not remove any items (all items are shared with query 3)
+      await query2.cleanup()
+
+      expect(collection.size).toBe(3) // Items still present due to query 3
+
+      // All items should still be present
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+      expect(collection.has(`3`)).toBe(true)
+
+      // GC query 3 - should remove all items (no more queries reference them)
+      await query3.cleanup()
+
+      // Wait for async GC to complete
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(0)
+      })
+
+      // All items should now be removed
+      expect(collection.has(`1`)).toBe(false)
+      expect(collection.has(`2`)).toBe(false)
+      expect(collection.has(`3`)).toBe(false)
+    })
+
+    it(`should handle GC of empty queries gracefully`, async () => {
+      const baseQueryKey = [`empty-query-test`]
+
+      // Mock queryFn to return different data based on predicates
+      const queryFn = vi.fn().mockImplementation((context) => {
+        const { meta } = context
+        const loadSubsetOptions = meta?.loadSubsetOptions || {}
+        const { where } = loadSubsetOptions
+
+        // Query 2: some items (where: { category: 'B' })
+        if (isCategory(`B`, where)) {
+          return Promise.resolve([
+            { id: `1`, name: `Item 1`, category: `B` },
+            { id: `2`, name: `Item 2`, category: `B` },
+          ])
+        }
+
+        return Promise.resolve([])
+      })
+
+      const config: QueryCollectionConfig<TestItem & { category: `A` | `B` }> =
+        {
+          id: `empty-test`,
+          queryClient,
+          queryKey: (ctx) => {
+            if (ctx.where) {
+              return [...baseQueryKey, ctx.where]
+            }
+            return baseQueryKey
+          },
+          queryFn,
+          getKey,
+          startSync: true,
+          syncMode: `on-demand`,
+        }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Collection should start empty with on-demand sync mode
+      expect(collection.size).toBe(0)
+
+      // Load query 1 (returns empty array)
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      await query1.preload()
+
+      // Wait for query 1 data to load (still empty)
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(0) // Empty query
+      })
+
+      // Add query 2 with different predicates (items 1, 2)
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `B`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query2.preload()
+
+      // Wait for query 2 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2) // Should have items 1, 2
+      })
+
+      // Verify items are present
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+
+      // GC empty query 1 - should not affect the collection
+      await query1.cleanup()
+
+      // Collection should still have items from query 2
+      expect(collection.size).toBe(2)
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+
+      // GC non-empty query 2 - should remove its items
+      await query2.cleanup()
+
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(0)
+      })
+
+      expect(collection.has(`1`)).toBe(false)
+      expect(collection.has(`2`)).toBe(false)
+    })
+
+    it(`should handle concurrent GC of multiple queries`, async () => {
+      const baseQueryKey = [`concurrent-query-test`]
+
+      // Mock queryFn to return different data based on predicates
+      const queryFn = vi.fn().mockImplementation((context) => {
+        const { meta } = context
+        const loadSubsetOptions = meta?.loadSubsetOptions || {}
+        const { where } = loadSubsetOptions
+
+        // Query 1: items 1, 2 (no predicates)
+        if (isCategory(`C`, where)) {
+          return Promise.resolve([
+            { id: `1`, name: `Item 1`, category: `C` },
+            { id: `2`, name: `Item 2`, category: `C` },
+          ])
+        }
+
+        // Query 2: items 2, 3 (where: { type: 'A' })
+        if (isCategory(`A`, where)) {
+          return Promise.resolve([
+            { id: `2`, name: `Item 2`, category: `A` },
+            { id: `3`, name: `Item 3`, category: `A` },
+          ])
+        }
+
+        // Query 3: items 3, 4 (where: { type: 'B' })
+        if (isCategory(`B`, where)) {
+          return Promise.resolve([
+            { id: `3`, name: `Item 3`, category: `B` },
+            { id: `4`, name: `Item 4`, category: `B` },
+          ])
+        }
+
+        return Promise.resolve([])
+      })
+
+      const config: QueryCollectionConfig<
+        TestItem & { category: `A` | `B` | `C` }
+      > = {
+        id: `concurrent-test`,
+        queryClient,
+        queryKey: (ctx) => {
+          if (ctx.where) {
+            return [...baseQueryKey, ctx.where]
+          }
+          return baseQueryKey
+        },
+        queryFn,
+        getKey,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Collection should start empty with on-demand sync mode
+      expect(collection.size).toBe(0)
+
+      // Load query 1 with no predicates (items 1, 2)
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `C`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query1.preload()
+
+      // Wait for query 1 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+
+      // Add query 2 with different predicates (items 2, 3)
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query2.preload()
+
+      // Wait for query 2 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3) // Should have items 1, 2, 3
+      })
+
+      // Add query 3 with different predicates
+      const query3 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `B`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query3.preload()
+
+      // Wait for query 3 data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(4) // Should have items 1, 2, 3, 4
+      })
+
+      // GC all queries concurrently
+      const queries = [query1, query2, query3]
+      const proms = queries.map((query) => query.cleanup())
+      await Promise.all(proms)
+
+      // Wait for async GC to complete
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(0)
+      })
+
+      // Verify all items are removed
+      expect(collection.has(`1`)).toBe(false)
+      expect(collection.has(`2`)).toBe(false)
+      expect(collection.has(`3`)).toBe(false)
+      expect(collection.has(`4`)).toBe(false)
+    })
+
+    it(`should handle GC correctly when queries are ordered and have a LIMIT`, async () => {
+      const baseQueryKey = [`deduplication-gc-test`]
+
+      // Mock queryFn to return different data based on predicates
+      const queryFn = vi.fn().mockImplementation((context) => {
+        const { meta } = context
+        const loadSubsetOptions = meta?.loadSubsetOptions ?? {}
+        const { where, limit } = loadSubsetOptions
+
+        // Query 1: all items with category A (no limit)
+        if (isCategory(`A`, where)) {
+          const items = [
+            { id: `1`, name: `Item 1`, category: `A` },
+            { id: `2`, name: `Item 2`, category: `A` },
+            { id: `3`, name: `Item 3`, category: `A` },
+          ]
+          // Slice to limit if provided
+          return Promise.resolve(limit ? items.slice(0, limit) : items)
+        }
+
+        return Promise.resolve([])
+      })
+
+      const config: QueryCollectionConfig<CategorisedItem> = {
+        id: `deduplication-test`,
+        queryClient,
+        queryKey: (ctx) => {
+          const key = [...baseQueryKey]
+          if (ctx.where) {
+            key.push(`where`, JSON.stringify(ctx.where))
+          }
+          if (ctx.limit) {
+            key.push(`limit`, ctx.limit.toString())
+          }
+          if (ctx.orderBy) {
+            key.push(`orderBy`, JSON.stringify(ctx.orderBy))
+          }
+          return key
+        },
+        queryFn,
+        getKey,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Collection should start empty with on-demand sync mode
+      expect(collection.size).toBe(0)
+
+      // Execute first query: load all rows that belong to category A (returns 3 rows)
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query1.preload()
+
+      // Wait for first query data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3)
+        expect(queryFn).toHaveBeenCalledTimes(1)
+      })
+
+      // Verify all 3 items are present
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+      expect(collection.has(`3`)).toBe(true)
+
+      // Execute second query: load rows with category A, limit 2, ordered by ID
+      // This should be deduplicated since we already have all category A data
+      // So it will load the data from the local collection
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .orderBy(({ item }) => item.id, `asc`)
+            .limit(2)
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+      await query2.preload()
+
+      await flushPromises()
+
+      // queryFn should have been called twice
+      // because we do not dedupe the 2nd query
+      expect(queryFn).toHaveBeenCalledTimes(2)
+
+      // Collection should still have all 3 items (deduplication doesn't remove data)
+      expect(collection.size).toBe(3)
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+      expect(collection.has(`3`)).toBe(true)
+
+      // GC the first query (all category A without limit)
+      await query1.cleanup()
+
+      // Wait for async GC to complete
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2) // Should only have items 1 and 2 because they are still referenced by query 2
+      })
+
+      // Verify that only row 3 is removed (it was only referenced by query 1)
+      expect(collection.has(`1`)).toBe(true) // Still present (referenced by query 2)
+      expect(collection.has(`2`)).toBe(true) // Still present (referenced by query 2)
+      expect(collection.has(`3`)).toBe(false) // Removed (only referenced by query 1)
+
+      // GC the second query (category A with limit 2)
+      await query2.cleanup()
+
+      // Wait for final GC to process
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(0)
+      })
+    })
+
+    it(`should handle duplicate subset loads correctly (refcount bug)`, async () => {
+      // This test catches Bug 1: missing refcount increment when reusing existing observer
+      // When two subscriptions load the same subset, unloading one should NOT destroy
+      // the observer since another subscription still needs it
+
+      const baseQueryKey = [`refcount-bug-test`]
+      const items: Array<CategorisedItem> = [
+        { id: `1`, name: `Item 1`, category: `A` },
+        { id: `2`, name: `Item 2`, category: `A` },
+        { id: `3`, name: `Item 3`, category: `A` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const config: QueryCollectionConfig<CategorisedItem> = {
+        id: `refcount-test`,
+        queryClient,
+        queryKey: baseQueryKey,
+        queryFn,
+        getKey: (item) => item.id,
+        startSync: true,
+        syncMode: `on-demand`,
+        onInsert: async () => ({ refetch: false }),
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create two live queries that request the SAME subset
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      // Load both queries
+      await query1.preload()
+      await query2.preload()
+
+      // Wait for data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3)
+      })
+      expect(queryFn).toHaveBeenCalledTimes(1) // Deduplicated
+
+      // Cleanup query1
+      await query1.cleanup()
+      await flushPromises()
+
+      // BUG: Without refcount increment on reuse, the observer is destroyed
+      // and query2 stops receiving updates. Collection data is also removed.
+      // EXPECTED: query2 should still work since it's using the same observer
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3) // Should still have data for query2
+      })
+
+      // Verify query2 still works by mutating data
+      await collection.insert({ id: `4`, name: `Item 4`, category: `A` })
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(4)
+        expect(collection.has(`4`)).toBe(true)
+      })
+
+      // Now cleanup query2
+      await query2.cleanup()
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(0) // NOW it should be cleaned up
+      })
+    })
+
+    it(`should reset refcount after query GC and reload (stale refcount bug)`, async () => {
+      // This test catches Bug 2: stale refcounts after GC/remove
+      // When TanStack Query GCs a query, the refcount should be cleaned up
+      // Otherwise, reloading the same subset will start with a stale count
+
+      const baseQueryKey = [`stale-refcount-test`]
+      const items: Array<CategorisedItem> = [
+        { id: `1`, name: `Item 1`, category: `A` },
+        { id: `2`, name: `Item 2`, category: `A` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const config: QueryCollectionConfig<CategorisedItem> = {
+        id: `stale-refcount-test`,
+        queryClient,
+        queryKey: baseQueryKey,
+        queryFn,
+        getKey: (item) => item.id,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create and load a query
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      await query1.preload()
+
+      // Wait for data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+
+      // Force GC by calling removeQueries (simulates gcTime expiry)
+      queryClient.removeQueries({ queryKey: baseQueryKey })
+      await flushPromises()
+
+      // BUG: queryRefCounts still has stale count, wasn't cleaned up by cleanupQuery
+      // When we load again, the refcount will be wrong (starts at 1 instead of 0, or accumulates)
+
+      // Reload the same query
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      await query2.preload()
+
+      // Wait for data to reload
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+
+      // Cleanup - this should properly decrement from 1 to 0 and clean up
+      await query2.cleanup()
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(0) // Should be cleaned up
+      })
+
+      // BUG SYMPTOM: If refcount was stale (e.g. was 2, decremented to 1),
+      // the observer won't be destroyed and data won't be cleaned up
+    })
+
+    it(`should handle mount/unmount/remount without breaking cache (destroyed observer bug)`, async () => {
+      // This test catches Bug 3: destroyed observer reuse
+      // When subscriberCount hits 0, unsubscribeFromQueries() destroys observers
+      // but leaves them in state.observers. On remount, subscribeToQueries()
+      // tries to reuse destroyed observers, which breaks cache processing
+
+      const baseQueryKey = [`destroyed-observer-test`]
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      // Use a longer gcTime to ensure cache persists across unmount/remount
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            gcTime: 5 * 60 * 1000, // 5 minutes
+            staleTime: Infinity, // set an Infinity staleTime to prevent a refetch
+            retry: false,
+          },
+        },
+      })
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `destroyed-observer-test`,
+        queryClient: customQueryClient,
+        queryKey: baseQueryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Mount: create and subscribe to a query
+      const query1 = createLiveQueryCollection({
+        query: (q) => q.from({ item: collection }).select(({ item }) => item),
+      })
+
+      await query1.preload()
+
+      // Wait for initial data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+      expect(queryFn).toHaveBeenCalledTimes(1)
+
+      // Unmount: cleanup the query, triggering subscriberCount -> 0
+      // This calls unsubscribeFromQueries() which destroys observers
+      await query1.cleanup()
+      await flushPromises()
+
+      // At this point, observer.destroy() was called but observer is still in state.observers
+
+      // Remount quickly (before gcTime expires): cache should still be valid
+      const query2 = createLiveQueryCollection({
+        query: (q) => q.from({ item: collection }).select(({ item }) => item),
+      })
+
+      // BUG: subscribeToQueries() tries to subscribe to the destroyed observer
+      // QueryObserver.destroy() is terminal - reactivation isn't guaranteed
+      // This breaks cache processing on remount
+
+      await query2.preload()
+
+      // EXPECTED: Should process cached data immediately without refetch
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+      expect(queryFn).toHaveBeenCalledTimes(1) // No refetch!
+
+      // BUG SYMPTOM: If destroyed observer doesn't process cached results,
+      // collection will be empty or queryFn will be called again
+    })
+
+    it(`should not leak data when unsubscribing while load is in flight`, async () => {
+      // Test the edge case where the last subscriber unsubscribes before queryFn resolves.
+      // We need to ensure that:
+      // 1. No late-arriving data is written after unsubscribe
+      // 2. No rows leak back into the collection
+
+      const baseQueryKey = [`in-flight-unsubscribe-test`]
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+      ]
+
+      // Create a delayed queryFn that we can control
+      let resolveQuery: ((value: Array<TestItem>) => void) | undefined
+      const queryFnPromise = new Promise<Array<TestItem>>((resolve) => {
+        resolveQuery = resolve
+      })
+      const queryFn = vi.fn().mockReturnValue(queryFnPromise)
+
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            gcTime: 5 * 60 * 1000,
+            staleTime: 0,
+            retry: false,
+          },
+        },
+      })
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `in-flight-unsubscribe-test`,
+        queryClient: customQueryClient,
+        queryKey: baseQueryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create a live query and start loading
+      const query1 = createLiveQueryCollection({
+        query: (q) => q.from({ item: collection }).select(({ item }) => item),
+      })
+
+      // Start preload but don't await - this triggers the queryFn
+      const preloadPromise = query1.preload()
+
+      // Wait a bit to ensure queryFn has been called
+      await flushPromises()
+      expect(queryFn).toHaveBeenCalledTimes(1)
+      expect(collection.size).toBe(0) // No data yet
+
+      // Unsubscribe while the query is still in flight (before queryFn resolves)
+      await query1.cleanup()
+      await flushPromises()
+
+      // Collection should be empty after cleanup
+      expect(collection.size).toBe(0)
+
+      // Now resolve the query - this is the "late-arriving data"
+      resolveQuery!(items)
+      await flushPromises()
+
+      // CRITICAL: After the late-arriving data is processed, the collection
+      // should still be empty. No rows should leak back in.
+      expect(collection.size).toBe(0)
+
+      // Clean up
+      try {
+        await preloadPromise
+      } catch {
+        // Query was cancelled, this is expected
+      }
+    })
+  })
+
+  describe(`Cache Persistence on Remount`, () => {
+    it(`should process cached results immediately when QueryObserver resubscribes`, async () => {
+      const queryKey = [`remount-cache-test`]
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+        { id: `3`, name: `Item 3` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      // Use a longer gcTime to simulate cache persistence
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            gcTime: 5 * 60 * 1000, // 5 minutes
+            staleTime: 0,
+            retry: false,
+          },
+        },
+      })
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `remount-cache-test`,
+        queryClient: customQueryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create first live query and load data
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      await query1.preload()
+
+      // Wait for data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(3)
+        expect(queryFn).toHaveBeenCalledTimes(1)
+      })
+
+      // Verify all items are present before creating second query
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+      expect(collection.has(`3`)).toBe(true)
+
+      // Create second live query while first is still active
+      // This simulates multiple components using the same collection
+      // (e.g., list view and detail view both querying the same collection)
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      // Preload - this should use cached data and process it immediately
+      await query2.preload()
+      await flushPromises()
+
+      // queryFn should still only have been called once (using cache)
+      // This verifies the fix: QueryObserver processes cached results immediately
+      expect(queryFn).toHaveBeenCalledTimes(1)
+
+      // Data should be present in both queries
+      expect(collection.size).toBe(3)
+      expect(collection.has(`1`)).toBe(true)
+      expect(collection.has(`2`)).toBe(true)
+      expect(collection.has(`3`)).toBe(true)
+
+      // Cleanup
+      await query1.cleanup()
+      await query2.cleanup()
+      customQueryClient.clear()
+    })
+
+    it(`should preserve cache and avoid refetch during quick remount`, async () => {
+      const queryKey = [`preserve-cache-remount`]
+      const items: Array<TestItem> = [{ id: `1`, name: `Item 1` }]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `preserve-cache-remount`,
+        queryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create and load first query
+      const query1 = createLiveQueryCollection({
+        query: (q) => q.from({ item: collection }),
+      })
+
+      await query1.preload()
+
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(1)
+        expect(queryFn).toHaveBeenCalledTimes(1)
+      })
+
+      // Create second query while first is still active (simulating remount)
+      // In real-world React, the first component unmounts but cleanup is deferred
+      const query2 = createLiveQueryCollection({
+        query: (q) => q.from({ item: collection }),
+      })
+
+      await query2.preload()
+      await flushPromises()
+
+      // Cache should still be present in the collection
+      expect(collection.size).toBe(1)
+
+      // We should NOT have refetched (used TanStack Query cache)
+      expect(queryFn).toHaveBeenCalledTimes(1)
+
+      // Cleanup both
+      await query1.cleanup()
+      await query2.cleanup()
+    })
+
+    it(`should allow TanStack Query to manage cache lifecycle via gcTime`, async () => {
+      const queryKey = [`gctime-respect-test`]
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      // Use a longer gcTime to verify cache isn't prematurely removed
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            gcTime: 5 * 60 * 1000, // 5 minutes
+            staleTime: 0,
+            retry: false,
+          },
+        },
+      })
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `gctime-respect-test`,
+        queryClient: customQueryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        startSync: true,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // First mount
+      const query1 = createLiveQueryCollection({
+        query: (q) => q.from({ item: collection }),
+      })
+
+      await query1.preload()
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+        expect(queryFn).toHaveBeenCalledTimes(1)
+      })
+
+      // Create second query while first is active (simulating overlapping mount)
+      const query2 = createLiveQueryCollection({
+        query: (q) => q.from({ item: collection }),
+      })
+
+      await query2.preload()
+      await flushPromises()
+
+      // Should still use cache - no refetch
+      expect(queryFn).toHaveBeenCalledTimes(1)
+      expect(collection.size).toBe(2)
+
+      // Cleanup both
+      await query1.cleanup()
+      await query2.cleanup()
+      customQueryClient.clear()
+    })
+
+    it(`should not immediately remove query data from cache when live query is GCed (respects gcTime)`, async () => {
+      // Create a QueryClient with a longer cacheTime to test that data should persist
+      const testQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            staleTime: Infinity, // set an Infinity staleTime to prevent a refetch
+            gcTime: 300,
+            retry: false,
+          },
+        },
+      })
+
+      const queryKey = [`premature-gc-test`]
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      // Use on-demand mode so the query is only created when the live query needs it
+      // This ensures the subscription is passed when the query is created
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `premature-gc-test`,
+        queryClient: testQueryClient,
+        queryKey,
+        queryFn,
+        getKey,
+        syncMode: `on-demand`, // Use on-demand mode so query is created with subscription
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create a live query that uses the collection
+      // This creates a subscription that will trigger the unsubscribed event when cleaned up
+      const liveQuery = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      // Preload the live query - this will create the query with the subscription
+      await liveQuery.preload()
+
+      // Wait for data to load
+      await vi.waitFor(() => {
+        expect(queryFn).toHaveBeenCalledTimes(1)
+        expect(collection.size).toBe(2)
+      })
+
+      // Verify query data is in the cache
+      const cachedData = testQueryClient.getQueryData(
+        queryKey,
+      ) as Array<TestItem>
+      expect(cachedData).toBeDefined()
+      expect(cachedData).toEqual(items)
+
+      // Cleanup the live query - this triggers the unsubscribed event
+      await liveQuery.cleanup()
+
+      // Wait 100ms, the gcTime is set to 300ms, so data should remain in the cache
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      // Data should remain in cache until gcTime elapses
+      const cachedDataAfterCleanup = testQueryClient.getQueryData(queryKey)
+      expect(cachedDataAfterCleanup).toBeDefined()
+      expect(cachedDataAfterCleanup).toEqual(items)
+
+      // Wait an additional 250ms to be sure the gcTime elapsed
+      await new Promise((resolve) => setTimeout(resolve, 250))
+
+      // Data should be removed from cache after gcTime elapses
+      const cachedDataAfterCacheTime = testQueryClient.getQueryData(queryKey)
+      expect(cachedDataAfterCacheTime).toBeUndefined()
+
+      // Cleanup
+      testQueryClient.clear()
+    })
+  })
+
+  describe(`Static queryKey with on-demand mode`, () => {
+    it(`should automatically append serialized predicates to static queryKey in on-demand mode`, async () => {
+      const items: Array<CategorisedItem> = [
+        { id: `1`, name: `Item 1`, category: `A` },
+        { id: `2`, name: `Item 2`, category: `A` },
+        { id: `3`, name: `Item 3`, category: `B` },
+        { id: `4`, name: `Item 4`, category: `B` },
+      ]
+
+      const queryFn = vi.fn((ctx: QueryFunctionContext) => {
+        const loadSubsetOptions = ctx.meta?.loadSubsetOptions
+        // Filter items based on the where clause if present
+        if (loadSubsetOptions?.where) {
+          // Simple mock filtering - in real use, you'd use parseLoadSubsetOptions
+          return Promise.resolve(items)
+        }
+        return Promise.resolve(items)
+      })
+
+      const staticQueryKey = [`static-on-demand-test`]
+
+      const config: QueryCollectionConfig<CategorisedItem> = {
+        id: `static-on-demand-test`,
+        queryClient,
+        queryKey: staticQueryKey, // Static queryKey (not a function)
+        queryFn,
+        getKey: (item: CategorisedItem) => item.id,
+        syncMode: `on-demand`,
+        startSync: true,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Collection should start empty with on-demand sync mode
+      expect(collection.size).toBe(0)
+
+      // Create first live query with category A filter
+      const queryA = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => item),
+      })
+
+      await queryA.preload()
+
+      // Wait for first query to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBeGreaterThan(0)
+      })
+
+      // Verify queryFn was called
+      expect(queryFn).toHaveBeenCalledTimes(1)
+      const firstCall = queryFn.mock.calls[0]?.[0]
+      expect(firstCall?.meta?.loadSubsetOptions).toBeDefined()
+
+      // Create second live query with category B filter
+      const queryB = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `B`))
+            .select(({ item }) => item),
+      })
+
+      await queryB.preload()
+
+      // Wait for second query to trigger another queryFn call
+      await vi.waitFor(() => {
+        expect(queryFn).toHaveBeenCalledTimes(2)
+      })
+
+      // Verify the second call has different loadSubsetOptions
+      const secondCall = queryFn.mock.calls[1]?.[0]
+      expect(secondCall?.meta?.loadSubsetOptions).toBeDefined()
+
+      // The two queries should have triggered separate cache entries
+      // because the static queryKey was automatically extended with serialized predicates
+      expect(queryFn).toHaveBeenCalledTimes(2)
+
+      // Cleanup
+      await queryA.cleanup()
+      await queryB.cleanup()
+    })
+
+    it(`should create same cache key for identical predicates with static queryKey`, async () => {
+      const items: Array<CategorisedItem> = [
+        { id: `1`, name: `Item 1`, category: `A` },
+        { id: `2`, name: `Item 2`, category: `A` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const config: QueryCollectionConfig<CategorisedItem> = {
+        id: `static-identical-predicates-test`,
+        queryClient,
+        queryKey: [`identical-test`],
+        queryFn,
+        getKey: (item: CategorisedItem) => item.id,
+        syncMode: `on-demand`,
+        startSync: true,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create two live queries with identical predicates
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => item),
+      })
+
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => item),
+      })
+
+      await query1.preload()
+      await query2.preload()
+
+      await vi.waitFor(() => {
+        expect(collection.size).toBeGreaterThan(0)
+      })
+
+      // Should only call queryFn once because identical predicates
+      // should produce the same serialized cache key
+      expect(queryFn).toHaveBeenCalledTimes(1)
+
+      // Cleanup
+      await query1.cleanup()
+      await query2.cleanup()
+    })
+
+    it(`should work correctly in eager mode with static queryKey (no automatic serialization)`, async () => {
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `static-eager-test`,
+        queryClient,
+        queryKey: [`eager-test`],
+        queryFn,
+        getKey,
+        syncMode: `eager`, // Eager mode should NOT append predicates
+        startSync: true,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Wait for initial load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(items.length)
+      })
+
+      // Should call queryFn once with empty predicates
+      expect(queryFn).toHaveBeenCalledTimes(1)
+      const call = queryFn.mock.calls[0]?.[0]
+      expect(call?.meta?.loadSubsetOptions).toEqual({})
+    })
+  })
+
+  describe(`On-demand collection directWrite cache update`, () => {
+    it(`should update query cache for all active query keys when using writeUpdate with computed queryKey`, async () => {
+      // Ensures writeUpdate on on-demand collections with computed query keys
+      // updates all active cache keys to prevent data loss on remount
+
+      const items: Array<CategorisedItem> = [
+        { id: `1`, name: `Item 1`, category: `A` },
+        { id: `2`, name: `Item 2`, category: `A` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      // Use a custom queryClient with longer gcTime to prevent cache from being removed
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            gcTime: 5 * 60 * 1000, // 5 minutes
+            staleTime: Infinity, // Prevent refetch
+            retry: false,
+          },
+        },
+      })
+
+      // Function-based queryKey (computed) - the bug scenario
+      const config: QueryCollectionConfig<CategorisedItem> = {
+        id: `directwrite-computed-key-test`,
+        queryClient: customQueryClient,
+        queryKey: (opts) => {
+          // Computed key includes predicate info
+          if (opts.where) {
+            return [`directwrite-test`, JSON.stringify(opts.where)]
+          }
+          return [`directwrite-test`]
+        },
+        queryFn,
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create a live query that will load data with a specific where clause
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      await query1.preload()
+
+      // Wait for data to load
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+
+      // Perform a direct write update
+      collection.utils.writeUpdate({ id: `1`, name: `Updated Item 1` })
+
+      // Verify the collection reflects the update
+      expect(collection.get(`1`)?.name).toBe(`Updated Item 1`)
+
+      // IMPORTANT: Simulate remount by cleaning up and recreating the live query
+      // This is where the bug manifests - the updated data should persist
+      await query1.cleanup()
+      await flushPromises()
+
+      // Recreate the same live query (simulating component remount)
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      await query2.preload()
+
+      // Wait for data to be available
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+
+      // BUG ASSERTION: After remount, the updated data should persist
+      // With the bug, this will fail because writeUpdate updated the wrong cache key
+      // and on remount, the stale cached data is loaded instead
+      expect(collection.get(`1`)?.name).toBe(`Updated Item 1`)
+
+      // Cleanup
+      await query2.cleanup()
+      customQueryClient.clear()
+    })
+
+    it(`should update query cache for static queryKey with where clause in on-demand mode`, async () => {
+      // Scenario: static queryKey + on-demand mode + where clause
+      // The where clause causes a computed query key to be generated
+
+      const items: Array<CategorisedItem> = [
+        { id: `1`, name: `Item 1`, category: `A` },
+        { id: `2`, name: `Item 2`, category: `A` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            gcTime: 5 * 60 * 1000,
+            staleTime: Infinity,
+            retry: false,
+          },
+        },
+      })
+
+      // Static queryKey but with on-demand mode, the where clause will append serialized predicates
+      const config: QueryCollectionConfig<CategorisedItem> = {
+        id: `directwrite-static-key-where-test`,
+        queryClient: customQueryClient,
+        queryKey: [`static-directwrite-test`],
+        queryFn,
+        getKey: (item) => item.id,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      // Create a live query with a where clause
+      const query1 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      await query1.preload()
+
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+
+      // Perform a direct write update
+      collection.utils.writeUpdate({ id: `1`, name: `Updated Item 1` })
+
+      expect(collection.get(`1`)?.name).toBe(`Updated Item 1`)
+
+      // Simulate remount
+      await query1.cleanup()
+      await flushPromises()
+
+      const query2 = createLiveQueryCollection({
+        query: (q) =>
+          q
+            .from({ item: collection })
+            .where(({ item }) => eq(item.category, `A`))
+            .select(({ item }) => ({ id: item.id, name: item.name })),
+      })
+
+      await query2.preload()
+
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+
+      // After remount, the updated data should persist
+      expect(collection.get(`1`)?.name).toBe(`Updated Item 1`)
+
+      await query2.cleanup()
+      customQueryClient.clear()
+    })
+
+    it(`should update query cache for function queryKey that returns constant value in on-demand mode`, async () => {
+      // Scenario: function queryKey that returns same value
+      // This creates an undefined entry in the cache
+
+      const items: Array<TestItem> = [
+        { id: `1`, name: `Item 1` },
+        { id: `2`, name: `Item 2` },
+      ]
+
+      const queryFn = vi.fn().mockResolvedValue(items)
+
+      const customQueryClient = new QueryClient({
+        defaultOptions: {
+          queries: {
+            gcTime: 5 * 60 * 1000,
+            staleTime: Infinity,
+            retry: false,
+          },
+        },
+      })
+
+      // Function queryKey that always returns the same value
+      const config: QueryCollectionConfig<TestItem> = {
+        id: `directwrite-constant-fn-key-test`,
+        queryClient: customQueryClient,
+        queryKey: () => [`constant-fn-key-test`],
+        queryFn,
+        getKey,
+        syncMode: `on-demand`,
+      }
+
+      const options = queryCollectionOptions(config)
+      const collection = createCollection(options)
+
+      const query1 = createLiveQueryCollection({
+        query: (q) => q.from({ item: collection }).select(({ item }) => item),
+      })
+
+      await query1.preload()
+
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+
+      // Perform a direct write update
+      collection.utils.writeUpdate({ id: `1`, name: `Updated Item 1` })
+
+      expect(collection.get(`1`)?.name).toBe(`Updated Item 1`)
+
+      // Simulate remount
+      await query1.cleanup()
+      await flushPromises()
+
+      const query2 = createLiveQueryCollection({
+        query: (q) => q.from({ item: collection }).select(({ item }) => item),
+      })
+
+      await query2.preload()
+
+      await vi.waitFor(() => {
+        expect(collection.size).toBe(2)
+      })
+
+      // After remount, the updated data should persist
+      expect(collection.get(`1`)?.name).toBe(`Updated Item 1`)
+
+      await query2.cleanup()
+      customQueryClient.clear()
+    })
   })
 })
diff --git a/packages/query-db-collection/tsconfig.json b/packages/query-db-collection/tsconfig.json
index 623d4bd91..3d3c48bdd 100644
--- a/packages/query-db-collection/tsconfig.json
+++ b/packages/query-db-collection/tsconfig.json
@@ -14,9 +14,10 @@
     "paths": {
       "@tanstack/store": ["../store/src"],
       "@tanstack/db": ["../db/src"],
-      "@tanstack/db-ivm": ["../db-ivm/src"]
+      "@tanstack/db-ivm": ["../db-ivm/src"],
+      "@tanstack/db-collection-e2e": ["../db-collection-e2e/src"]
     }
   },
-  "include": ["src", "tests", "vite.config.ts"],
+  "include": ["src", "tests", "e2e", "vite.config.ts", "vitest.e2e.config.ts"],
   "exclude": ["node_modules", "dist"]
 }
diff --git a/packages/query-db-collection/vite.config.ts b/packages/query-db-collection/vite.config.ts
index c7968f28a..b8c7930f0 100644
--- a/packages/query-db-collection/vite.config.ts
+++ b/packages/query-db-collection/vite.config.ts
@@ -1,14 +1,18 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import packageJson from './package.json'
 
 const config = defineConfig({
   test: {
     name: packageJson.name,
-    dir: `./tests`,
+    include: [`tests/**/*.test.ts`],
+    exclude: [`e2e/**/*`],
     environment: `jsdom`,
     coverage: { enabled: true, provider: `istanbul`, include: [`src/**/*`] },
-    typecheck: { enabled: true },
+    typecheck: {
+      enabled: true,
+      include: [`tests/**/*.test.ts`, `tests/**/*.test-d.ts`],
+    },
   },
 })
 
@@ -17,5 +21,5 @@ export default mergeConfig(
   tanstackViteConfig({
     entry: `./src/index.ts`,
     srcDir: `./src`,
-  })
+  }),
 )
diff --git a/packages/query-db-collection/vitest.e2e.config.ts b/packages/query-db-collection/vitest.e2e.config.ts
new file mode 100644
index 000000000..5b0918452
--- /dev/null
+++ b/packages/query-db-collection/vitest.e2e.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: [`e2e/**/*.e2e.test.ts`],
+    fileParallelism: false,
+    testTimeout: 30000,
+    environment: `jsdom`,
+  },
+})
diff --git a/packages/react-db/CHANGELOG.md b/packages/react-db/CHANGELOG.md
index 7760660ca..5e5e15bf4 100644
--- a/packages/react-db/CHANGELOG.md
+++ b/packages/react-db/CHANGELOG.md
@@ -1,5 +1,407 @@
 # @tanstack/react-db
 
+## 0.1.68
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 0.1.67
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 0.1.66
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 0.1.65
+
+### Patch Changes
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 0.1.64
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 0.1.63
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 0.1.62
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 0.1.61
+
+### Patch Changes
+
+- Improve runtime error message and documentation when `useLiveSuspenseQuery` receives `undefined` from query callback. ([#860](https://github.com/TanStack/db/pull/860))
+
+  Following TanStack Query's `useSuspenseQuery` design, `useLiveSuspenseQuery` intentionally does not support disabled queries (when callback returns `undefined` or `null`). This maintains the type guarantee that `data` is always `T` (not `T | undefined`), which is a core benefit of using Suspense.
+
+  **What changed:**
+  1. **Improved runtime error message** with clear guidance:
+
+  ```
+  useLiveSuspenseQuery does not support disabled queries (callback returned undefined/null).
+  The Suspense pattern requires data to always be defined (T, not T | undefined).
+  Solutions:
+  1) Use conditional rendering - don't render the component until the condition is met.
+  2) Use useLiveQuery instead, which supports disabled queries with the 'isEnabled' flag.
+  ```
+
+  2. **Enhanced JSDoc documentation** with detailed `@remarks` section explaining the design decision, showing both incorrect (❌) and correct (✅) patterns
+
+  **Why this matters:**
+
+  ```typescript
+  // ❌ This pattern doesn't work with Suspense queries:
+  const { data } = useLiveSuspenseQuery(
+    (q) => userId
+      ? q.from({ users }).where(({ users }) => eq(users.id, userId)).findOne()
+      : undefined,
+    [userId]
+  )
+
+  // ✅ Instead, use conditional rendering:
+  function UserProfile({ userId }: { userId: string }) {
+    const { data } = useLiveSuspenseQuery(
+      (q) => q.from({ users }).where(({ users }) => eq(users.id, userId)).findOne(),
+      [userId]
+    )
+    return <div>{data.name}</div> // data is guaranteed non-undefined
+  }
+
+  function App({ userId }: { userId?: string }) {
+    if (!userId) return <div>No user selected</div>
+    return <UserProfile userId={userId} />
+  }
+
+  // ✅ Or use useLiveQuery for conditional queries:
+  const { data, isEnabled } = useLiveQuery(
+    (q) => userId
+      ? q.from({ users }).where(({ users }) => eq(users.id, userId)).findOne()
+      : undefined,
+    [userId]
+  )
+  ```
+
+  This aligns with TanStack Query's philosophy where Suspense queries prioritize type safety and proper component composition over flexibility.
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 0.1.60
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 0.1.59
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 0.1.58
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 0.1.57
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 0.1.56
+
+### Patch Changes
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 0.1.55
+
+### Patch Changes
+
+- Fixed `isReady` to return `true` for disabled queries in `useLiveQuery`/`injectLiveQuery` across all framework packages. When a query function returns `null` or `undefined` (disabling the query), there's no async operation to wait for, so the hook should be considered "ready" immediately. ([#886](https://github.com/TanStack/db/pull/886))
+
+  Additionally, all frameworks now have proper TypeScript overloads that explicitly support returning `undefined | null` from query functions, making the disabled query pattern type-safe.
+
+  This fixes the common pattern where users conditionally enable queries and don't want to show loading states when the query is disabled.
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 0.1.54
+
+### Patch Changes
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/db@0.5.10
+
+## 0.1.53
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+
+## 0.1.52
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+
+## 0.1.51
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+
+## 0.1.50
+
+### Patch Changes
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 0.1.49
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 0.1.48
+
+### Patch Changes
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 0.1.47
+
+### Patch Changes
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 0.1.46
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+
+## 0.1.45
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 0.1.44
+
+### Patch Changes
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.1.43
+
+### Patch Changes
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.1.42
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.1.41
+
+### Patch Changes
+
+- Add `useLiveSuspenseQuery` hook for React Suspense support ([#697](https://github.com/TanStack/db/pull/697))
+
+  Introduces a new `useLiveSuspenseQuery` hook that integrates with React Suspense and Error Boundaries, following TanStack Query's `useSuspenseQuery` pattern.
+
+  **Key features:**
+  - React 18+ compatible using the throw promise pattern
+  - Type-safe API with guaranteed data (never undefined)
+  - Automatic error handling via Error Boundaries
+  - Reactive updates after initial load via useSyncExternalStore
+  - Support for dependency-based re-suspension
+  - Works with query functions, config objects, and pre-created collections
+
+  **Example usage:**
+
+  ```tsx
+  import { Suspense } from 'react'
+  import { useLiveSuspenseQuery } from '@tanstack/react-db'
+
+  function TodoList() {
+    // Data is guaranteed to be defined - no isLoading needed
+    const { data } = useLiveSuspenseQuery((q) =>
+      q
+        .from({ todos: todosCollection })
+        .where(({ todos }) => eq(todos.completed, false)),
+    )
+
+    return (
+      <ul>
+        {data.map((todo) => (
+          <li key={todo.id}>{todo.text}</li>
+        ))}
+      </ul>
+    )
+  }
+
+  function App() {
+    return (
+      <Suspense fallback={<div>Loading...</div>}>
+        <TodoList />
+      </Suspense>
+    )
+  }
+  ```
+
+  **Implementation details:**
+  - Throws promises when collection is loading (caught by Suspense)
+  - Throws errors when collection fails (caught by Error Boundary)
+  - Reuses promise across re-renders to prevent infinite loops
+  - Detects dependency changes and creates new collection/promise
+  - Same TypeScript overloads as useLiveQuery for consistency
+
+  **Documentation:**
+  - Comprehensive guide in live-queries.md covering usage patterns and when to use each hook
+  - Comparison with useLiveQuery showing different approaches to loading/error states
+  - Router loader pattern recommendation for React Router/TanStack Router users
+  - Error handling examples with Suspense and Error Boundaries
+
+  Resolves #692
+
+## 0.1.40
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.1.39
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+
+## 0.1.38
+
+### Patch Changes
+
+- Add paced mutations with pluggable timing strategies ([#704](https://github.com/TanStack/db/pull/704))
+
+  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
+  ```
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+
+## 0.1.37
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+
+## 0.1.36
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+
+## 0.1.35
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+
+## 0.1.34
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+
 ## 0.1.33
 
 ### Patch Changes
@@ -26,7 +428,7 @@
   **Example usage:**
 
   ```tsx
-  import { useLiveInfiniteQuery } from "@tanstack/react-db"
+  import { useLiveInfiniteQuery } from '@tanstack/react-db'
 
   function PostList() {
     const { data, pages, fetchNextPage, hasNextPage, isLoading } =
@@ -34,12 +436,12 @@
         (q) =>
           q
             .from({ posts: postsCollection })
-            .orderBy(({ posts }) => posts.createdAt, "desc"),
+            .orderBy(({ posts }) => posts.createdAt, 'desc'),
         {
           pageSize: 20,
           getNextPageParam: (lastPage, allPages) =>
             lastPage.length === 20 ? allPages.length : undefined,
-        }
+        },
       )
 
     if (isLoading) return <div>Loading...</div>
diff --git a/packages/react-db/package.json b/packages/react-db/package.json
index c12c7916d..3feaf8965 100644
--- a/packages/react-db/package.json
+++ b/packages/react-db/package.json
@@ -1,12 +1,12 @@
 {
   "name": "@tanstack/react-db",
+  "version": "0.1.68",
   "description": "React integration for @tanstack/db",
-  "version": "0.1.33",
   "author": "Kyle Mathews",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/TanStack/db.git",
+    "url": "git+https://github.com/TanStack/db.git",
     "directory": "packages/react-db"
   },
   "homepage": "https://tanstack.com/db",
@@ -15,21 +15,17 @@
     "react",
     "typescript"
   ],
-  "packageManager": "pnpm@10.18.3",
-  "dependencies": {
-    "@tanstack/db": "workspace:*",
-    "use-sync-external-store": "^1.6.0"
-  },
-  "devDependencies": {
-    "@electric-sql/client": "1.0.14",
-    "@testing-library/react": "^16.3.0",
-    "@types/react": "^19.2.2",
-    "@types/react-dom": "^19.2.2",
-    "@types/use-sync-external-store": "^1.5.0",
-    "@vitest/coverage-istanbul": "^3.2.4",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0"
+  "scripts": {
+    "build": "vite build",
+    "build:minified": "vite build --minify",
+    "dev": "vite build --watch",
+    "test": "vitest --run",
+    "lint": "eslint . --fix"
   },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -43,22 +39,26 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
+  "dependencies": {
+    "@tanstack/db": "workspace:*",
+    "use-sync-external-store": "^1.6.0"
+  },
   "peerDependencies": {
     "react": ">=16.8.0"
   },
-  "scripts": {
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "test": "npx vitest --run",
-    "lint": "eslint . --fix"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "devDependencies": {
+    "@electric-sql/client": "^1.3.1",
+    "@testing-library/react": "^16.3.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@types/use-sync-external-store": "^1.5.0",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3"
+  }
 }
diff --git a/packages/react-db/src/index.ts b/packages/react-db/src/index.ts
index bb3cd3ad5..b352a0ba0 100644
--- a/packages/react-db/src/index.ts
+++ b/packages/react-db/src/index.ts
@@ -1,10 +1,12 @@
 // Re-export all public APIs
-export * from "./useLiveQuery"
-export * from "./useLiveInfiniteQuery"
+export * from './useLiveQuery'
+export * from './useLiveSuspenseQuery'
+export * from './usePacedMutations'
+export * from './useLiveInfiniteQuery'
 
 // Re-export everything from @tanstack/db
-export * from "@tanstack/db"
+export * from '@tanstack/db'
 
 // Re-export some stuff explicitly to ensure the type & value is exported
-export type { Collection } from "@tanstack/db"
-export { createTransaction } from "@tanstack/db"
+export type { Collection } from '@tanstack/db'
+export { createTransaction } from '@tanstack/db'
diff --git a/packages/react-db/src/useLiveInfiniteQuery.ts b/packages/react-db/src/useLiveInfiniteQuery.ts
index 650bbe22c..405ecb583 100644
--- a/packages/react-db/src/useLiveInfiniteQuery.ts
+++ b/packages/react-db/src/useLiveInfiniteQuery.ts
@@ -1,6 +1,6 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react"
-import { CollectionImpl } from "@tanstack/db"
-import { useLiveQuery } from "./useLiveQuery"
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { CollectionImpl } from '@tanstack/db'
+import { useLiveQuery } from './useLiveQuery'
 import type {
   Collection,
   Context,
@@ -9,13 +9,13 @@ import type {
   LiveQueryCollectionUtils,
   NonSingleResult,
   QueryBuilder,
-} from "@tanstack/db"
+} from '@tanstack/db'
 
 /**
  * Type guard to check if utils object has setWindow method (LiveQueryCollectionUtils)
  */
 function isLiveQueryCollectionUtils(
-  utils: unknown
+  utils: unknown,
 ): utils is LiveQueryCollectionUtils {
   return typeof (utils as any).setWindow === `function`
 }
@@ -27,7 +27,7 @@ export type UseLiveInfiniteQueryConfig<TContext extends Context> = {
     lastPage: Array<InferResultType<TContext>[number]>,
     allPages: Array<Array<InferResultType<TContext>[number]>>,
     lastPageParam: number,
-    allPageParams: Array<number>
+    allPageParams: Array<number>,
   ) => number | undefined
 }
 
@@ -116,21 +116,21 @@ export function useLiveInfiniteQuery<
   TUtils extends Record<string, any>,
 >(
   liveQueryCollection: Collection<TResult, TKey, TUtils> & NonSingleResult,
-  config: UseLiveInfiniteQueryConfig<any>
+  config: UseLiveInfiniteQueryConfig<any>,
 ): UseLiveInfiniteQueryReturn<any>
 
 // Overload for query function
 export function useLiveInfiniteQuery<TContext extends Context>(
   queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,
   config: UseLiveInfiniteQueryConfig<TContext>,
-  deps?: Array<unknown>
+  deps?: Array<unknown>,
 ): UseLiveInfiniteQueryReturn<TContext>
 
 // Implementation
 export function useLiveInfiniteQuery<TContext extends Context>(
   queryFnOrCollection: any,
   config: UseLiveInfiniteQueryConfig<TContext>,
-  deps: Array<unknown> = []
+  deps: Array<unknown> = [],
 ): UseLiveInfiniteQueryReturn<TContext> {
   const pageSize = config.pageSize || 20
   const initialPageParam = config.initialPageParam ?? 0
@@ -142,7 +142,7 @@ export function useLiveInfiniteQuery<TContext extends Context>(
   if (!isCollection && typeof queryFnOrCollection !== `function`) {
     throw new Error(
       `useLiveInfiniteQuery: First argument must be either a pre-created live query collection (CollectionImpl) ` +
-        `or a query function. Received: ${typeof queryFnOrCollection}`
+        `or a query function. Received: ${typeof queryFnOrCollection}`,
     )
   }
 
@@ -188,7 +188,7 @@ export function useLiveInfiniteQuery<TContext extends Context>(
     ? useLiveQuery(queryFnOrCollection)
     : useLiveQuery(
         (q) => queryFnOrCollection(q).limit(pageSize).offset(0),
-        deps
+        deps,
       )
 
   // Adjust window when pagination changes
@@ -203,7 +203,7 @@ export function useLiveInfiniteQuery<TContext extends Context>(
       if (isCollection) {
         throw new Error(
           `useLiveInfiniteQuery: Pre-created live query collection must have an orderBy clause for infinite pagination to work. ` +
-            `Please add .orderBy() to your createLiveQueryCollection query.`
+            `Please add .orderBy() to your createLiveQueryCollection query.`,
         )
       }
       return
@@ -219,7 +219,7 @@ export function useLiveInfiniteQuery<TContext extends Context>(
       ) {
         console.warn(
           `useLiveInfiniteQuery: Pre-created collection has window {offset: ${currentWindow.offset}, limit: ${currentWindow.limit}} ` +
-            `but hook expects {offset: ${expectedOffset}, limit: ${expectedLimit}}. Adjusting window now.`
+            `but hook expects {offset: ${expectedOffset}, limit: ${expectedLimit}}. Adjusting window now.`,
         )
       }
       hasValidatedCollectionRef.current = true
@@ -273,7 +273,7 @@ export function useLiveInfiniteQuery<TContext extends Context>(
     // Flatten the pages for the data return (without peek ahead item)
     const flatDataResult = dataArray.slice(
       0,
-      totalItemsRequested
+      totalItemsRequested,
     ) as InferResultType<TContext>
 
     return {
diff --git a/packages/react-db/src/useLiveQuery.ts b/packages/react-db/src/useLiveQuery.ts
index 90145d25d..331ff3a27 100644
--- a/packages/react-db/src/useLiveQuery.ts
+++ b/packages/react-db/src/useLiveQuery.ts
@@ -1,9 +1,9 @@
-import { useRef, useSyncExternalStore } from "react"
+import { useRef, useSyncExternalStore } from 'react'
 import {
   BaseQueryBuilder,
   CollectionImpl,
   createLiveQueryCollection,
-} from "@tanstack/db"
+} from '@tanstack/db'
 import type {
   Collection,
   CollectionConfigSingleRowOption,
@@ -16,7 +16,7 @@ import type {
   NonSingleResult,
   QueryBuilder,
   SingleResult,
-} from "@tanstack/db"
+} from '@tanstack/db'
 
 const DEFAULT_GC_TIME_MS = 1 // Live queries created by useLiveQuery are cleaned up immediately (0 disables GC)
 
@@ -83,7 +83,7 @@ export type UseLiveQueryStatus = CollectionStatus | `disabled`
 // Overload 1: Accept query function that always returns QueryBuilder
 export function useLiveQuery<TContext extends Context>(
   queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,
-  deps?: Array<unknown>
+  deps?: Array<unknown>,
 ): {
   state: Map<string | number, GetResult<TContext>>
   data: InferResultType<TContext>
@@ -100,9 +100,9 @@ export function useLiveQuery<TContext extends Context>(
 // Overload 2: Accept query function that can return undefined/null
 export function useLiveQuery<TContext extends Context>(
   queryFn: (
-    q: InitialQueryBuilder
+    q: InitialQueryBuilder,
   ) => QueryBuilder<TContext> | undefined | null,
-  deps?: Array<unknown>
+  deps?: Array<unknown>,
 ): {
   state: Map<string | number, GetResult<TContext>> | undefined
   data: InferResultType<TContext> | undefined
@@ -119,9 +119,9 @@ export function useLiveQuery<TContext extends Context>(
 // Overload 3: Accept query function that can return LiveQueryCollectionConfig
 export function useLiveQuery<TContext extends Context>(
   queryFn: (
-    q: InitialQueryBuilder
+    q: InitialQueryBuilder,
   ) => LiveQueryCollectionConfig<TContext> | undefined | null,
-  deps?: Array<unknown>
+  deps?: Array<unknown>,
 ): {
   state: Map<string | number, GetResult<TContext>> | undefined
   data: InferResultType<TContext> | undefined
@@ -142,9 +142,9 @@ export function useLiveQuery<
   TUtils extends Record<string, any>,
 >(
   queryFn: (
-    q: InitialQueryBuilder
+    q: InitialQueryBuilder,
   ) => Collection<TResult, TKey, TUtils> | undefined | null,
-  deps?: Array<unknown>
+  deps?: Array<unknown>,
 ): {
   state: Map<TKey, TResult> | undefined
   data: Array<TResult> | undefined
@@ -166,14 +166,14 @@ export function useLiveQuery<
   TUtils extends Record<string, any>,
 >(
   queryFn: (
-    q: InitialQueryBuilder
+    q: InitialQueryBuilder,
   ) =>
     | QueryBuilder<TContext>
     | LiveQueryCollectionConfig<TContext>
     | Collection<TResult, TKey, TUtils>
     | undefined
     | null,
-  deps?: Array<unknown>
+  deps?: Array<unknown>,
 ): {
   state:
     | Map<string | number, GetResult<TContext>>
@@ -229,7 +229,7 @@ export function useLiveQuery<
 // Overload 6: Accept config object
 export function useLiveQuery<TContext extends Context>(
   config: LiveQueryCollectionConfig<TContext>,
-  deps?: Array<unknown>
+  deps?: Array<unknown>,
 ): {
   state: Map<string | number, GetResult<TContext>>
   data: InferResultType<TContext>
@@ -278,7 +278,7 @@ export function useLiveQuery<
   TKey extends string | number,
   TUtils extends Record<string, any>,
 >(
-  liveQueryCollection: Collection<TResult, TKey, TUtils> & NonSingleResult
+  liveQueryCollection: Collection<TResult, TKey, TUtils> & NonSingleResult,
 ): {
   state: Map<TKey, TResult>
   data: Array<TResult>
@@ -298,7 +298,7 @@ export function useLiveQuery<
   TKey extends string | number,
   TUtils extends Record<string, any>,
 >(
-  liveQueryCollection: Collection<TResult, TKey, TUtils> & SingleResult
+  liveQueryCollection: Collection<TResult, TKey, TUtils> & SingleResult,
 ): {
   state: Map<TKey, TResult>
   data: TResult | undefined
@@ -315,7 +315,7 @@ export function useLiveQuery<
 // Implementation - use function overloads to infer the actual collection type
 export function useLiveQuery(
   configOrQueryOrCollection: any,
-  deps: Array<unknown> = []
+  deps: Array<unknown> = [],
 ) {
   // Check if it's already a collection by checking for specific collection methods
   const isCollection =
@@ -327,7 +327,7 @@ export function useLiveQuery(
 
   // Use refs to cache collection and track dependencies
   const collectionRef = useRef<Collection<object, string | number, {}> | null>(
-    null
+    null,
   )
   const depsRef = useRef<Array<unknown> | null>(null)
   const configRef = useRef<unknown>(null)
@@ -350,6 +350,21 @@ export function useLiveQuery(
 
   if (needsNewCollection) {
     if (isCollection) {
+      // Warn when passing a collection directly with on-demand sync mode
+      // In on-demand mode, data is only loaded when queries with predicates request it
+      // Passing the collection directly doesn't provide any predicates, so no data loads
+      const syncMode = (
+        configOrQueryOrCollection as { config?: { syncMode?: string } }
+      ).config?.syncMode
+      if (syncMode === `on-demand`) {
+        console.warn(
+          `[useLiveQuery] Warning: Passing a collection with syncMode "on-demand" directly to useLiveQuery ` +
+            `will not load any data. In on-demand mode, data is only loaded when queries with predicates request it.\n\n` +
+            `Instead, use a query builder function:\n` +
+            `  const { data } = useLiveQuery((q) => q.from({ c: myCollection }).select(({ c }) => c))\n\n` +
+            `Or switch to syncMode "eager" if you want all data to sync automatically.`,
+        )
+      }
       // It's already a collection, ensure sync is started for React hooks
       configOrQueryOrCollection.startSyncImmediate()
       collectionRef.current = configOrQueryOrCollection
@@ -386,7 +401,7 @@ export function useLiveQuery(
         } else {
           // Unexpected return type
           throw new Error(
-            `useLiveQuery callback must return a QueryBuilder, LiveQueryCollectionConfig, Collection, undefined, or null. Got: ${typeof result}`
+            `useLiveQuery callback must return a QueryBuilder, LiveQueryCollectionConfig, Collection, undefined, or null. Got: ${typeof result}`,
           )
         }
         depsRef.current = [...deps]
@@ -467,7 +482,7 @@ export function useLiveQuery(
   // Use useSyncExternalStore to subscribe to collection changes
   const snapshot = useSyncExternalStore(
     subscribeRef.current,
-    getSnapshotRef.current
+    getSnapshotRef.current,
   )
 
   // Track last snapshot (from useSyncExternalStore) and the returned value separately
@@ -492,7 +507,7 @@ export function useLiveQuery(
         collection: undefined,
         status: `disabled`,
         isLoading: false,
-        isReady: false,
+        isReady: true,
         isIdle: false,
         isError: false,
         isCleanedUp: false,
diff --git a/packages/react-db/src/useLiveSuspenseQuery.ts b/packages/react-db/src/useLiveSuspenseQuery.ts
new file mode 100644
index 000000000..c35e7e11a
--- /dev/null
+++ b/packages/react-db/src/useLiveSuspenseQuery.ts
@@ -0,0 +1,219 @@
+import { useRef } from 'react'
+import { useLiveQuery } from './useLiveQuery'
+import type {
+  Collection,
+  Context,
+  GetResult,
+  InferResultType,
+  InitialQueryBuilder,
+  LiveQueryCollectionConfig,
+  NonSingleResult,
+  QueryBuilder,
+  SingleResult,
+} from '@tanstack/db'
+
+/**
+ * Create a live query with React Suspense support
+ * @param queryFn - Query function that defines what data to fetch
+ * @param deps - Array of dependencies that trigger query re-execution when changed
+ * @returns Object with reactive data and state - data is guaranteed to be defined
+ * @throws Promise when data is loading (caught by Suspense boundary)
+ * @throws Error when collection fails (caught by Error boundary)
+ * @example
+ * // Basic usage with Suspense
+ * function TodoList() {
+ *   const { data } = useLiveSuspenseQuery((q) =>
+ *     q.from({ todos: todosCollection })
+ *      .where(({ todos }) => eq(todos.completed, false))
+ *      .select(({ todos }) => ({ id: todos.id, text: todos.text }))
+ *   )
+ *
+ *   return (
+ *     <ul>
+ *       {data.map(todo => <li key={todo.id}>{todo.text}</li>)}
+ *     </ul>
+ *   )
+ * }
+ *
+ * function App() {
+ *   return (
+ *     <Suspense fallback={<div>Loading...</div>}>
+ *       <TodoList />
+ *     </Suspense>
+ *   )
+ * }
+ *
+ * @example
+ * // Single result query
+ * const { data } = useLiveSuspenseQuery(
+ *   (q) => q.from({ todos: todosCollection })
+ *          .where(({ todos }) => eq(todos.id, 1))
+ *          .findOne()
+ * )
+ * // data is guaranteed to be the single item (or undefined if not found)
+ *
+ * @example
+ * // With dependencies that trigger re-suspension
+ * const { data } = useLiveSuspenseQuery(
+ *   (q) => q.from({ todos: todosCollection })
+ *          .where(({ todos }) => gt(todos.priority, minPriority)),
+ *   [minPriority] // Re-suspends when minPriority changes
+ * )
+ *
+ * @example
+ * // With Error boundary
+ * function App() {
+ *   return (
+ *     <ErrorBoundary fallback={<div>Error loading data</div>}>
+ *       <Suspense fallback={<div>Loading...</div>}>
+ *         <TodoList />
+ *       </Suspense>
+ *     </ErrorBoundary>
+ *   )
+ * }
+ *
+ * @remarks
+ * **Important:** This hook does NOT support disabled queries (returning undefined/null).
+ * Following TanStack Query's useSuspenseQuery design, the query callback must always
+ * return a valid query, collection, or config object.
+ *
+ * ❌ **This will cause a type error:**
+ * ```ts
+ * useLiveSuspenseQuery(
+ *   (q) => userId ? q.from({ users }) : undefined  // ❌ Error!
+ * )
+ * ```
+ *
+ * ✅ **Use conditional rendering instead:**
+ * ```ts
+ * function Profile({ userId }: { userId: string }) {
+ *   const { data } = useLiveSuspenseQuery(
+ *     (q) => q.from({ users }).where(({ users }) => eq(users.id, userId))
+ *   )
+ *   return <div>{data.name}</div>
+ * }
+ *
+ * // In parent component:
+ * {userId ? <Profile userId={userId} /> : <div>No user</div>}
+ * ```
+ *
+ * ✅ **Or use useLiveQuery for conditional queries:**
+ * ```ts
+ * const { data, isEnabled } = useLiveQuery(
+ *   (q) => userId ? q.from({ users }) : undefined,  // ✅ Supported!
+ *   [userId]
+ * )
+ * ```
+ */
+// Overload 1: Accept query function that always returns QueryBuilder
+export function useLiveSuspenseQuery<TContext extends Context>(
+  queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,
+  deps?: Array<unknown>,
+): {
+  state: Map<string | number, GetResult<TContext>>
+  data: InferResultType<TContext>
+  collection: Collection<GetResult<TContext>, string | number, {}>
+}
+
+// Overload 2: Accept config object
+export function useLiveSuspenseQuery<TContext extends Context>(
+  config: LiveQueryCollectionConfig<TContext>,
+  deps?: Array<unknown>,
+): {
+  state: Map<string | number, GetResult<TContext>>
+  data: InferResultType<TContext>
+  collection: Collection<GetResult<TContext>, string | number, {}>
+}
+
+// Overload 3: Accept pre-created live query collection
+export function useLiveSuspenseQuery<
+  TResult extends object,
+  TKey extends string | number,
+  TUtils extends Record<string, any>,
+>(
+  liveQueryCollection: Collection<TResult, TKey, TUtils> & NonSingleResult,
+): {
+  state: Map<TKey, TResult>
+  data: Array<TResult>
+  collection: Collection<TResult, TKey, TUtils>
+}
+
+// Overload 4: Accept pre-created live query collection with singleResult: true
+export function useLiveSuspenseQuery<
+  TResult extends object,
+  TKey extends string | number,
+  TUtils extends Record<string, any>,
+>(
+  liveQueryCollection: Collection<TResult, TKey, TUtils> & SingleResult,
+): {
+  state: Map<TKey, TResult>
+  data: TResult | undefined
+  collection: Collection<TResult, TKey, TUtils> & SingleResult
+}
+
+// Implementation - uses useLiveQuery internally and adds Suspense logic
+export function useLiveSuspenseQuery(
+  configOrQueryOrCollection: any,
+  deps: Array<unknown> = [],
+) {
+  const promiseRef = useRef<Promise<void> | null>(null)
+  const collectionRef = useRef<Collection<any, any, any> | null>(null)
+  const hasBeenReadyRef = useRef(false)
+
+  // Use useLiveQuery to handle collection management and reactivity
+  const result = useLiveQuery(configOrQueryOrCollection, deps)
+
+  // Reset promise and ready state when collection changes (deps changed)
+  if (collectionRef.current !== result.collection) {
+    promiseRef.current = null
+    collectionRef.current = result.collection
+    hasBeenReadyRef.current = false
+  }
+
+  // Track when we reach ready state
+  if (result.status === `ready`) {
+    hasBeenReadyRef.current = true
+    promiseRef.current = null
+  }
+
+  // SUSPENSE LOGIC: Throw promise or error based on collection status
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (!result.isEnabled) {
+    // Suspense queries cannot be disabled - this matches TanStack Query's useSuspenseQuery behavior
+    throw new Error(
+      `useLiveSuspenseQuery does not support disabled queries (callback returned undefined/null). ` +
+        `The Suspense pattern requires data to always be defined (T, not T | undefined). ` +
+        `Solutions: ` +
+        `1) Use conditional rendering - don't render the component until the condition is met. ` +
+        `2) Use useLiveQuery instead, which supports disabled queries with the 'isEnabled' flag.`,
+    )
+  }
+
+  // Only throw errors during initial load (before first ready)
+  // After success, errors surface as stale data (matches TanStack Query behavior)
+  if (result.status === `error` && !hasBeenReadyRef.current) {
+    promiseRef.current = null
+    // TODO: Once collections hold a reference to their last error object (#671),
+    // we should rethrow that actual error instead of creating a generic message
+    throw new Error(`Collection "${result.collection.id}" failed to load`)
+  }
+
+  if (result.status === `loading` || result.status === `idle`) {
+    // Create or reuse promise for current collection
+    if (!promiseRef.current) {
+      promiseRef.current = result.collection.preload()
+    }
+    // THROW PROMISE - React Suspense catches this (React 18+ required)
+    // Note: We don't check React version here. In React <18, this will be caught
+    // by an Error Boundary, which provides a reasonable failure mode.
+    throw promiseRef.current
+  }
+
+  // Return data without status/loading flags (handled by Suspense/ErrorBoundary)
+  // If error after success, return last known good state (stale data)
+  return {
+    state: result.state,
+    data: result.data,
+    collection: result.collection,
+  }
+}
diff --git a/packages/react-db/src/usePacedMutations.ts b/packages/react-db/src/usePacedMutations.ts
new file mode 100644
index 000000000..7fc001e4a
--- /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/test-setup.ts b/packages/react-db/tests/test-setup.ts
index b686eeaaf..2d717649d 100644
--- a/packages/react-db/tests/test-setup.ts
+++ b/packages/react-db/tests/test-setup.ts
@@ -1,6 +1,6 @@
-import "@testing-library/jest-dom/vitest"
-import { cleanup } from "@testing-library/react"
-import { afterEach } from "vitest"
+import '@testing-library/jest-dom/vitest'
+import { cleanup } from '@testing-library/react'
+import { afterEach } from 'vitest'
 
 declare global {
   var IS_REACT_ACT_ENVIRONMENT: boolean
diff --git a/packages/react-db/tests/useLiveInfiniteQuery.test.tsx b/packages/react-db/tests/useLiveInfiniteQuery.test.tsx
index 1496a27f1..9672205c3 100644
--- a/packages/react-db/tests/useLiveInfiniteQuery.test.tsx
+++ b/packages/react-db/tests/useLiveInfiniteQuery.test.tsx
@@ -1,8 +1,10 @@
-import { describe, expect, it } from "vitest"
-import { act, renderHook, waitFor } from "@testing-library/react"
-import { createCollection, createLiveQueryCollection, eq } from "@tanstack/db"
-import { useLiveInfiniteQuery } from "../src/useLiveInfiniteQuery"
-import { mockSyncCollectionOptions } from "../../db/tests/utils"
+import { describe, expect, it } from 'vitest'
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { createCollection, createLiveQueryCollection, eq } from '@tanstack/db'
+import { useLiveInfiniteQuery } from '../src/useLiveInfiniteQuery'
+import { mockSyncCollectionOptions } from '../../db/tests/utils'
+import { createFilterFunctionFromExpression } from '../../db/src/collection/change-events'
+import type { LoadSubsetOptions } from '@tanstack/db'
 
 type Post = {
   id: string
@@ -34,7 +36,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `initial-page-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -52,7 +54,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -84,7 +86,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `multiple-pages-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -97,7 +99,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -143,7 +145,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `no-more-pages-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -156,7 +158,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -202,7 +204,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `empty-results-test`,
         getKey: (post: Post) => post.id,
         initialData: [],
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -215,7 +217,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -237,7 +239,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `live-updates-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -250,7 +252,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -308,7 +310,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `deletions-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -321,7 +323,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -366,6 +368,137 @@ describe(`useLiveInfiniteQuery`, () => {
     expect(result.current.pages[1]).toHaveLength(10)
   })
 
+  it(`should handle deletion from partial page with descending order`, async () => {
+    // Create only 5 items - fewer than the pageSize of 20
+    const posts = createMockPosts(5)
+    const collection = createCollection(
+      mockSyncCollectionOptions<Post>({
+        id: `partial-page-deletion-desc-test`,
+        getKey: (post: Post) => post.id,
+        initialData: posts,
+      }),
+    )
+
+    const { result } = renderHook(() => {
+      return useLiveInfiniteQuery(
+        (q) =>
+          q
+            .from({ posts: collection })
+            .orderBy(({ posts: p }) => p.createdAt, `desc`),
+        {
+          pageSize: 20,
+          getNextPageParam: (lastPage) =>
+            lastPage.length === 20 ? lastPage.length : undefined,
+        },
+      )
+    })
+
+    await waitFor(() => {
+      expect(result.current.isReady).toBe(true)
+    })
+
+    // Should have all 5 items on one page (partial page)
+    expect(result.current.pages).toHaveLength(1)
+    expect(result.current.data).toHaveLength(5)
+    expect(result.current.hasNextPage).toBe(false)
+
+    // Verify the first item (most recent by createdAt descending)
+    const firstItemId = result.current.data[0]!.id
+    expect(firstItemId).toBe(`1`) // Post 1 has the highest createdAt
+
+    // Delete the first item (the one that appears first in descending order)
+    act(() => {
+      collection.utils.begin()
+      collection.utils.write({
+        type: `delete`,
+        value: posts[0]!, // Post 1
+      })
+      collection.utils.commit()
+    })
+
+    // The deleted item should disappear from the result
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(4)
+    })
+
+    // Verify the deleted item is no longer in the data
+    expect(
+      result.current.data.find((p) => p.id === firstItemId),
+    ).toBeUndefined()
+
+    // Verify the new first item is Post 2
+    expect(result.current.data[0]!.id).toBe(`2`)
+
+    // Still should have 1 page with 4 items
+    expect(result.current.pages).toHaveLength(1)
+    expect(result.current.pages[0]).toHaveLength(4)
+    expect(result.current.hasNextPage).toBe(false)
+  })
+
+  it(`should handle deletion from partial page with ascending order`, async () => {
+    // Create only 5 items - fewer than the pageSize of 20
+    const posts = createMockPosts(5)
+    const collection = createCollection(
+      mockSyncCollectionOptions<Post>({
+        id: `partial-page-deletion-asc-test`,
+        getKey: (post: Post) => post.id,
+        initialData: posts,
+      }),
+    )
+
+    const { result } = renderHook(() => {
+      return useLiveInfiniteQuery(
+        (q) =>
+          q
+            .from({ posts: collection })
+            .orderBy(({ posts: p }) => p.createdAt, `asc`), // ascending order
+        {
+          pageSize: 20,
+          getNextPageParam: (lastPage) =>
+            lastPage.length === 20 ? lastPage.length : undefined,
+        },
+      )
+    })
+
+    await waitFor(() => {
+      expect(result.current.isReady).toBe(true)
+    })
+
+    // Should have all 5 items on one page (partial page)
+    expect(result.current.pages).toHaveLength(1)
+    expect(result.current.data).toHaveLength(5)
+    expect(result.current.hasNextPage).toBe(false)
+
+    // In ascending order, Post 5 has the lowest createdAt and appears first
+    const firstItemId = result.current.data[0]!.id
+    expect(firstItemId).toBe(`5`) // Post 5 has the lowest createdAt
+
+    // Delete the first item (the one that appears first in ascending order)
+    act(() => {
+      collection.utils.begin()
+      collection.utils.write({
+        type: `delete`,
+        value: posts[4]!, // Post 5 (index 4 in array)
+      })
+      collection.utils.commit()
+    })
+
+    // The deleted item should disappear from the result
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(4)
+    })
+
+    // Verify the deleted item is no longer in the data
+    expect(
+      result.current.data.find((p) => p.id === firstItemId),
+    ).toBeUndefined()
+
+    // Still should have 1 page with 4 items
+    expect(result.current.pages).toHaveLength(1)
+    expect(result.current.pages[0]).toHaveLength(4)
+    expect(result.current.hasNextPage).toBe(false)
+  })
+
   it(`should work with where clauses`, async () => {
     const posts = createMockPosts(50)
     const collection = createCollection(
@@ -373,7 +506,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `where-clause-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -387,7 +520,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 5,
           getNextPageParam: (lastPage) =>
             lastPage.length === 5 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -426,7 +559,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `deps-change-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result, rerender } = renderHook(
@@ -442,10 +575,10 @@ describe(`useLiveInfiniteQuery`, () => {
             getNextPageParam: (lastPage) =>
               lastPage.length === 5 ? lastPage.length : undefined,
           },
-          [category]
+          [category],
         )
       },
-      { initialProps: { category: `tech` } }
+      { initialProps: { category: `tech` } },
     )
 
     await waitFor(() => {
@@ -484,7 +617,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `page-params-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -498,7 +631,7 @@ describe(`useLiveInfiniteQuery`, () => {
           initialPageParam: 0,
           getNextPageParam: (lastPage, allPages, lastPageParam) =>
             lastPage.length === 10 ? lastPageParam + 1 : undefined,
-        }
+        },
       )
     })
 
@@ -534,7 +667,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `exact-boundary-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -555,7 +688,7 @@ describe(`useLiveInfiniteQuery`, () => {
             // If we have less than a full page left, no more pages
             return totalLoaded
           },
-        }
+        },
       )
     })
 
@@ -590,7 +723,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `concurrent-fetch-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -603,7 +736,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -651,7 +784,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `no-fetch-when-done-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -664,7 +797,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -693,7 +826,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `initial-param-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -707,7 +840,7 @@ describe(`useLiveInfiniteQuery`, () => {
           initialPageParam: 100,
           getNextPageParam: (lastPage, allPages, lastPageParam) =>
             lastPage.length === 10 ? lastPageParam + 1 : undefined,
-        }
+        },
       )
     })
 
@@ -734,7 +867,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `sync-detection-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -747,7 +880,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -819,7 +952,7 @@ describe(`useLiveInfiniteQuery`, () => {
         id: `immediate-data-test`,
         getKey: (post: Post) => post.id,
         initialData: posts,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -832,7 +965,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -855,7 +988,8 @@ describe(`useLiveInfiniteQuery`, () => {
   })
 
   it(`should track isFetchingNextPage when async loading is triggered`, async () => {
-    let loadSubsetCallCount = 0
+    // Define all data upfront
+    const allPosts = createMockPosts(30)
 
     const collection = createCollection<Post>({
       id: `async-loading-test`,
@@ -864,49 +998,91 @@ describe(`useLiveInfiniteQuery`, () => {
       startSync: true,
       sync: {
         sync: ({ markReady, begin, write, commit }) => {
-          // Provide initial data
+          // Provide initial data by slicing the first 15 elements
           begin()
-          for (let i = 1; i <= 15; i++) {
+          const initialPosts = allPosts.slice(0, 15)
+          for (const post of initialPosts) {
             write({
               type: `insert`,
-              value: {
-                id: `${i}`,
-                title: `Post ${i}`,
-                content: `Content ${i}`,
-                createdAt: 1000000 - i * 1000,
-                category: i % 2 === 0 ? `tech` : `life`,
-              },
+              value: post,
             })
           }
           commit()
           markReady()
 
           return {
-            loadSubset: () => {
-              loadSubsetCallCount++
+            loadSubset: (opts: LoadSubsetOptions) => {
+              // Filter the data array based on opts
+              let filtered = allPosts
+
+              // Apply where clause if provided
+              if (opts.where) {
+                const filterFn = createFilterFunctionFromExpression(opts.where)
+                filtered = filtered.filter(filterFn)
+              }
 
-              // First few calls return true (initial load + window setup)
-              if (loadSubsetCallCount <= 2) {
-                return true
+              // Sort by createdAt descending if orderBy is provided
+              if (opts.orderBy && opts.orderBy.length > 0) {
+                filtered = filtered.sort((a, b) => {
+                  // We know ordering is always by createdAt descending
+                  return b.createdAt - a.createdAt
+                })
+              }
+
+              // Apply cursor expressions if present (new cursor-based pagination)
+              if (opts.cursor) {
+                const { whereFrom, whereCurrent } = opts.cursor
+                try {
+                  const whereFromFn =
+                    createFilterFunctionFromExpression(whereFrom)
+                  const fromData = filtered.filter(whereFromFn)
+
+                  const whereCurrentFn =
+                    createFilterFunctionFromExpression(whereCurrent)
+                  const currentData = filtered.filter(whereCurrentFn)
+
+                  // Combine current (ties) with from (next page), deduplicate
+                  const seenIds = new Set<string>()
+                  filtered = []
+                  for (const item of currentData) {
+                    if (!seenIds.has(item.id)) {
+                      seenIds.add(item.id)
+                      filtered.push(item)
+                    }
+                  }
+                  // Apply limit only to fromData
+                  const limitedFromData = opts.limit
+                    ? fromData.slice(0, opts.limit)
+                    : fromData
+                  for (const item of limitedFromData) {
+                    if (!seenIds.has(item.id)) {
+                      seenIds.add(item.id)
+                      filtered.push(item)
+                    }
+                  }
+                  // Re-sort after combining
+                  filtered.sort((a, b) => b.createdAt - a.createdAt)
+                } catch {
+                  // Fallback to original filtered if cursor parsing fails
+                }
+              } else if (opts.limit !== undefined) {
+                // Apply limit only if no cursor (cursor handles limit internally)
+                filtered = filtered.slice(0, opts.limit)
               }
 
               // Subsequent calls simulate async loading with a real timeout
               const loadPromise = new Promise<void>((resolve) => {
                 setTimeout(() => {
                   begin()
-                  // Load more data
-                  for (let i = 16; i <= 30; i++) {
+
+                  // Insert the requested posts
+                  for (const post of filtered) {
                     write({
                       type: `insert`,
-                      value: {
-                        id: `${i}`,
-                        title: `Post ${i}`,
-                        content: `Content ${i}`,
-                        createdAt: 1000000 - i * 1000,
-                        category: i % 2 === 0 ? `tech` : `life`,
-                      },
+                      value: post,
                     })
                   }
+
                   commit()
                   resolve()
                 }, 50)
@@ -929,7 +1105,7 @@ describe(`useLiveInfiniteQuery`, () => {
           pageSize: 10,
           getNextPageParam: (lastPage) =>
             lastPage.length === 10 ? lastPage.length : undefined,
-        }
+        },
       )
     })
 
@@ -957,7 +1133,7 @@ describe(`useLiveInfiniteQuery`, () => {
       () => {
         expect(result.current.isFetchingNextPage).toBe(false)
       },
-      { timeout: 200 }
+      { timeout: 200 },
     )
 
     // Should have 2 pages now
@@ -973,7 +1149,7 @@ describe(`useLiveInfiniteQuery`, () => {
           id: `pre-created-test`,
           getKey: (post: Post) => post.id,
           initialData: posts,
-        })
+        }),
       )
 
       const liveQueryCollection = createLiveQueryCollection({
@@ -1018,7 +1194,7 @@ describe(`useLiveInfiniteQuery`, () => {
           id: `pre-created-multi-page-test`,
           getKey: (post: Post) => post.id,
           initialData: posts,
-        })
+        }),
       )
 
       const liveQueryCollection = createLiveQueryCollection({
@@ -1069,7 +1245,7 @@ describe(`useLiveInfiniteQuery`, () => {
           id: `pre-created-reset-1`,
           getKey: (post: Post) => post.id,
           initialData: posts1,
-        })
+        }),
       )
 
       const liveQueryCollection1 = createLiveQueryCollection({
@@ -1089,7 +1265,7 @@ describe(`useLiveInfiniteQuery`, () => {
           id: `pre-created-reset-2`,
           getKey: (post: Post) => post.id,
           initialData: posts2,
-        })
+        }),
       )
 
       const liveQueryCollection2 = createLiveQueryCollection({
@@ -1111,7 +1287,7 @@ describe(`useLiveInfiniteQuery`, () => {
               lastPage.length === 10 ? lastPage.length : undefined,
           })
         },
-        { initialProps: { coll: liveQueryCollection1 } }
+        { initialProps: { coll: liveQueryCollection1 } },
       )
 
       await waitFor(() => {
@@ -1149,7 +1325,7 @@ describe(`useLiveInfiniteQuery`, () => {
           id: `no-orderby-test`,
           getKey: (post: Post) => post.id,
           initialData: posts,
-        })
+        }),
       )
 
       // Create collection WITHOUT orderBy
@@ -1211,7 +1387,7 @@ describe(`useLiveInfiniteQuery`, () => {
           id: `mismatched-window-test`,
           getKey: (post: Post) => post.id,
           initialData: posts,
-        })
+        }),
       )
 
       const liveQueryCollection = createLiveQueryCollection({
@@ -1252,7 +1428,7 @@ describe(`useLiveInfiniteQuery`, () => {
           id: `pre-created-live-updates-test`,
           getKey: (post: Post) => post.id,
           initialData: posts,
-        })
+        }),
       )
 
       const liveQueryCollection = createLiveQueryCollection({
@@ -1325,7 +1501,7 @@ describe(`useLiveInfiniteQuery`, () => {
           id: `router-loader-test`,
           getKey: (post: Post) => post.id,
           initialData: posts,
-        })
+        }),
       )
 
       // Simulate router loader: create and preload collection
diff --git a/packages/react-db/tests/useLiveQuery.test-d.tsx b/packages/react-db/tests/useLiveQuery.test-d.tsx
index df012a021..41162698c 100644
--- a/packages/react-db/tests/useLiveQuery.test-d.tsx
+++ b/packages/react-db/tests/useLiveQuery.test-d.tsx
@@ -1,14 +1,14 @@
-import { describe, expectTypeOf, it } from "vitest"
-import { renderHook } from "@testing-library/react"
-import { createCollection } from "../../db/src/collection/index"
-import { mockSyncCollectionOptions } from "../../db/tests/utils"
+import { describe, expectTypeOf, it } from 'vitest'
+import { renderHook } from '@testing-library/react'
+import { createCollection } from '../../db/src/collection/index'
+import { mockSyncCollectionOptions } from '../../db/tests/utils'
 import {
   createLiveQueryCollection,
   eq,
   liveQueryCollectionOptions,
-} from "../../db/src/query/index"
-import { useLiveQuery } from "../src/useLiveQuery"
-import type { SingleResult } from "../../db/src/types"
+} from '../../db/src/query/index'
+import { useLiveQuery } from '../src/useLiveQuery'
+import type { SingleResult } from '../../db/src/types'
 
 type Person = {
   id: string
@@ -26,7 +26,7 @@ describe(`useLiveQuery type assertions`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: [],
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -34,7 +34,7 @@ describe(`useLiveQuery type assertions`, () => {
         q
           .from({ collection })
           .where(({ collection: c }) => eq(c.id, `3`))
-          .findOne()
+          .findOne(),
       )
     })
 
@@ -47,7 +47,7 @@ describe(`useLiveQuery type assertions`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: [],
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -69,7 +69,7 @@ describe(`useLiveQuery type assertions`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: [],
-      })
+      }),
     )
 
     const options = liveQueryCollectionOptions({
@@ -97,7 +97,7 @@ describe(`useLiveQuery type assertions`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: [],
-      })
+      }),
     )
 
     const liveQueryCollection = createLiveQueryCollection({
diff --git a/packages/react-db/tests/useLiveQuery.test.tsx b/packages/react-db/tests/useLiveQuery.test.tsx
index 214e9238d..cbaf7fe97 100644
--- a/packages/react-db/tests/useLiveQuery.test.tsx
+++ b/packages/react-db/tests/useLiveQuery.test.tsx
@@ -1,5 +1,5 @@
-import { describe, expect, it } from "vitest"
-import { act, renderHook, waitFor } from "@testing-library/react"
+import { describe, expect, it } from 'vitest'
+import { act, renderHook, waitFor } from '@testing-library/react'
 import {
   Query,
   count,
@@ -9,10 +9,10 @@ import {
   eq,
   gt,
   lte,
-} from "@tanstack/db"
-import { useEffect } from "react"
-import { useLiveQuery } from "../src/useLiveQuery"
-import { mockSyncCollectionOptions } from "../../db/tests/utils"
+} from '@tanstack/db'
+import { useEffect } from 'react'
+import { useLiveQuery } from '../src/useLiveQuery'
+import { mockSyncCollectionOptions } from '../../db/tests/utils'
 
 type Person = {
   id: string
@@ -85,7 +85,7 @@ describe(`Query Collections`, () => {
         id: `test-persons`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -97,7 +97,7 @@ describe(`Query Collections`, () => {
             id: persons.id,
             name: persons.name,
             age: persons.age,
-          }))
+          })),
       )
     })
 
@@ -121,7 +121,7 @@ describe(`Query Collections`, () => {
         id: `test-persons`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { result, rerender } = renderHook(() => {
@@ -133,7 +133,7 @@ describe(`Query Collections`, () => {
             id: persons.id,
             name: persons.name,
             age: persons.age,
-          }))
+          })),
       )
     })
 
@@ -163,7 +163,7 @@ describe(`Query Collections`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -171,7 +171,7 @@ describe(`Query Collections`, () => {
         q
           .from({ collection })
           .where(({ collection: c }) => eq(c.id, `3`))
-          .findOne()
+          .findOne(),
       )
     })
 
@@ -197,7 +197,7 @@ describe(`Query Collections`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -232,7 +232,7 @@ describe(`Query Collections`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const liveQueryCollection = createLiveQueryCollection({
@@ -269,7 +269,7 @@ describe(`Query Collections`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -281,7 +281,7 @@ describe(`Query Collections`, () => {
             id: c.id,
             name: c.name,
           }))
-          .orderBy(({ collection: c }) => c.id, `asc`)
+          .orderBy(({ collection: c }) => c.id, `asc`),
       )
     })
 
@@ -340,7 +340,7 @@ describe(`Query Collections`, () => {
           id: `4`,
           name: `Kyle Doe`,
         }),
-      ])
+      ]),
     )
 
     // Update the person
@@ -379,7 +379,7 @@ describe(`Query Collections`, () => {
           id: `4`,
           name: `Kyle Doe 2`,
         }),
-      ])
+      ]),
     )
 
     // Delete the person
@@ -418,7 +418,7 @@ describe(`Query Collections`, () => {
         id: `person-collection-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create issue collection
@@ -427,7 +427,7 @@ describe(`Query Collections`, () => {
         id: `issue-collection-test`,
         getKey: (issue: Issue) => issue.id,
         initialData: initialIssues,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -435,13 +435,13 @@ describe(`Query Collections`, () => {
         q
           .from({ issues: issueCollection })
           .join({ persons: personCollection }, ({ issues, persons }) =>
-            eq(issues.userId, persons.id)
+            eq(issues.userId, persons.id),
           )
           .select(({ issues, persons }) => ({
             id: issues.id,
             title: issues.title,
             name: persons?.name,
-          }))
+          })),
       )
     })
 
@@ -546,7 +546,7 @@ describe(`Query Collections`, () => {
         id: `params-change-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { result, rerender } = renderHook(
@@ -561,10 +561,10 @@ describe(`Query Collections`, () => {
                 name: c.name,
                 age: c.age,
               })),
-          [minAge]
+          [minAge],
         )
       },
-      { initialProps: { minAge: 30 } }
+      { initialProps: { minAge: 30 } },
     )
 
     // Wait for collection to sync
@@ -620,7 +620,7 @@ describe(`Query Collections`, () => {
         id: `stop-query-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { result, rerender } = renderHook(
@@ -634,10 +634,10 @@ describe(`Query Collections`, () => {
                 id: c.id,
                 name: c.name,
               })),
-          [minAge]
+          [minAge],
         )
       },
-      { initialProps: { minAge: 30 } }
+      { initialProps: { minAge: 30 } },
     )
 
     // Wait for collection to sync
@@ -685,7 +685,7 @@ describe(`Query Collections`, () => {
         id: `optimistic-changes-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Initial query
@@ -699,7 +699,7 @@ describe(`Query Collections`, () => {
             name: c.name,
             team: c.team,
           }))
-          .orderBy(({ collection: c }) => c.id, `asc`)
+          .orderBy(({ collection: c }) => c.id, `asc`),
       )
     })
 
@@ -715,7 +715,7 @@ describe(`Query Collections`, () => {
           .select(({ queryResult }) => ({
             team: queryResult.team,
             count: count(queryResult.id),
-          }))
+          })),
       )
     })
 
@@ -792,7 +792,7 @@ describe(`Query Collections`, () => {
         id: `person-collection-test-bug`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create issue collection
@@ -801,7 +801,7 @@ describe(`Query Collections`, () => {
         id: `issue-collection-test-bug`,
         getKey: (issue: Issue) => issue.id,
         initialData: initialIssues,
-      })
+      }),
     )
 
     // Render the hook with a query that joins persons and issues
@@ -810,13 +810,13 @@ describe(`Query Collections`, () => {
         q
           .from({ issues: issueCollection })
           .join({ persons: personCollection }, ({ issues, persons }) =>
-            eq(issues.userId, persons.id)
+            eq(issues.userId, persons.id),
           )
           .select(({ issues, persons }) => ({
             id: issues.id,
             title: issues.title,
             name: persons?.name,
-          }))
+          })),
       )
 
       // Track each render state
@@ -903,13 +903,13 @@ describe(`Query Collections`, () => {
     await waitFor(() => {
       // Verify optimistic state is immediately reflected
       expect(result.current.state.size).toBe(4)
+      expect(result.current.state.get(`[temp-key,1]`)).toMatchObject({
+        id: `temp-key`,
+        name: `John Doe`,
+        title: `New Issue`,
+      })
+      expect(result.current.state.get(`[4,1]`)).toBeUndefined()
     })
-    expect(result.current.state.get(`[temp-key,1]`)).toMatchObject({
-      id: `temp-key`,
-      name: `John Doe`,
-      title: `New Issue`,
-    })
-    expect(result.current.state.get(`[4,1]`)).toBeUndefined()
 
     // Wait for the transaction to be committed
     await transaction.isPersisted.promise
@@ -921,7 +921,8 @@ describe(`Query Collections`, () => {
 
     // Check if we had any render where the temp key was removed but the permanent key wasn't added yet
     const hadFlicker = renderStates.some(
-      (state) => !state.hasTempKey && !state.hasPermKey && state.stateSize === 3
+      (state) =>
+        !state.hasTempKey && !state.hasPermKey && state.stateSize === 3,
     )
 
     expect(hadFlicker).toBe(false)
@@ -942,7 +943,7 @@ describe(`Query Collections`, () => {
         id: `pre-created-collection-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create a live query collection beforehand
@@ -986,7 +987,7 @@ describe(`Query Collections`, () => {
         id: `collection-1`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const collection2 = createCollection(
@@ -1011,7 +1012,7 @@ describe(`Query Collections`, () => {
             team: `team3`,
           },
         ],
-      })
+      }),
     )
 
     // Create two different live query collections
@@ -1043,7 +1044,7 @@ describe(`Query Collections`, () => {
       ({ collection }: { collection: any }) => {
         return useLiveQuery(collection)
       },
-      { initialProps: { collection: liveQueryCollection1 } }
+      { initialProps: { collection: liveQueryCollection1 } },
     )
 
     // Wait for first collection to sync
@@ -1085,7 +1086,7 @@ describe(`Query Collections`, () => {
         id: `test-persons-config-querybuilder`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create a QueryBuilder instance beforehand
@@ -1149,7 +1150,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
@@ -1195,7 +1196,7 @@ describe(`Query Collections`, () => {
           id: `pre-created-has-loaded-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       // Create a live query collection that's already syncing
@@ -1253,7 +1254,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
@@ -1302,7 +1303,7 @@ describe(`Query Collections`, () => {
           id: `live-updates-has-loaded-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const { result } = renderHook(() => {
@@ -1313,7 +1314,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
@@ -1398,13 +1399,13 @@ describe(`Query Collections`, () => {
           q
             .from({ issues: issueCollection })
             .join({ persons: personCollection }, ({ issues, persons }) =>
-              eq(issues.userId, persons.id)
+              eq(issues.userId, persons.id),
             )
             .select(({ issues, persons }) => ({
               id: issues.id,
               title: issues.title,
               name: persons?.name,
-            }))
+            })),
         )
       })
 
@@ -1491,10 +1492,10 @@ describe(`Query Collections`, () => {
                   id: c.id,
                   name: c.name,
                 })),
-            [minAge]
+            [minAge],
           )
         },
-        { initialProps: { minAge: 30 } }
+        { initialProps: { minAge: 30 } },
       )
 
       // Initially should be false
@@ -1585,7 +1586,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
@@ -1702,7 +1703,7 @@ describe(`Query Collections`, () => {
               id: persons.id,
               name: persons.name,
               team: persons.team,
-            }))
+            })),
         )
       })
 
@@ -1824,13 +1825,13 @@ describe(`Query Collections`, () => {
           q
             .from({ issues: issueCollection })
             .join({ persons: personCollection }, ({ issues, persons }) =>
-              eq(issues.userId, persons.id)
+              eq(issues.userId, persons.id),
             )
             .select(({ issues, persons }) => ({
               id: issues.id,
               title: issues.title,
               userName: persons?.name,
-            }))
+            })),
         )
       })
 
@@ -1932,7 +1933,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
@@ -1976,7 +1977,7 @@ describe(`Query Collections`, () => {
           id: `undefined-callback-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const { result, rerender } = renderHook(
@@ -1993,10 +1994,10 @@ describe(`Query Collections`, () => {
                   age: persons.age,
                 }))
             },
-            [enabled]
+            [enabled],
           )
         },
-        { initialProps: { enabled: false } }
+        { initialProps: { enabled: false } },
       )
 
       // When callback returns undefined, should return the specified state
@@ -2005,7 +2006,7 @@ describe(`Query Collections`, () => {
       expect(result.current.collection).toBeUndefined()
       expect(result.current.status).toBe(`disabled`)
       expect(result.current.isLoading).toBe(false)
-      expect(result.current.isReady).toBe(false)
+      expect(result.current.isReady).toBe(true)
       expect(result.current.isIdle).toBe(false)
       expect(result.current.isError).toBe(false)
       expect(result.current.isCleanedUp).toBe(false)
@@ -2044,7 +2045,7 @@ describe(`Query Collections`, () => {
       expect(result.current.collection).toBeUndefined()
       expect(result.current.status).toBe(`disabled`)
       expect(result.current.isLoading).toBe(false)
-      expect(result.current.isReady).toBe(false)
+      expect(result.current.isReady).toBe(true)
       expect(result.current.isIdle).toBe(false)
       expect(result.current.isError).toBe(false)
       expect(result.current.isCleanedUp).toBe(false)
@@ -2056,7 +2057,7 @@ describe(`Query Collections`, () => {
           id: `null-callback-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const { result, rerender } = renderHook(
@@ -2073,10 +2074,10 @@ describe(`Query Collections`, () => {
                   age: persons.age,
                 }))
             },
-            [enabled]
+            [enabled],
           )
         },
-        { initialProps: { enabled: false } }
+        { initialProps: { enabled: false } },
       )
 
       // When callback returns null, should return the specified state
@@ -2085,7 +2086,7 @@ describe(`Query Collections`, () => {
       expect(result.current.collection).toBeUndefined()
       expect(result.current.status).toBe(`disabled`)
       expect(result.current.isLoading).toBe(false)
-      expect(result.current.isReady).toBe(false)
+      expect(result.current.isReady).toBe(true)
       expect(result.current.isIdle).toBe(false)
       expect(result.current.isError).toBe(false)
       expect(result.current.isCleanedUp).toBe(false)
@@ -2113,7 +2114,7 @@ describe(`Query Collections`, () => {
           id: `config-callback-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const { result, rerender } = renderHook(
@@ -2144,10 +2145,10 @@ describe(`Query Collections`, () => {
                 }))
                 .orderBy(({ persons }) => persons.age)
             },
-            [useConfig]
+            [useConfig],
           )
         },
-        { initialProps: { useConfig: false } }
+        { initialProps: { useConfig: false } },
       )
 
       // Wait for collection to sync and state to update
@@ -2199,7 +2200,7 @@ describe(`Query Collections`, () => {
           id: `collection-callback-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       // Create a live query collection beforehand
@@ -2232,10 +2233,10 @@ describe(`Query Collections`, () => {
                   age: persons.age,
                 }))
             },
-            [useCollection]
+            [useCollection],
           )
         },
-        { initialProps: { useCollection: false } }
+        { initialProps: { useCollection: false } },
       )
 
       // Wait for collection to sync and state to update
@@ -2246,17 +2247,18 @@ describe(`Query Collections`, () => {
       expect(result.current.collection).toBeDefined()
       expect(result.current.status).toBeDefined()
 
+      // Results are in deterministic key order (id: 1 before id: 2)
       expect(result.current.data).toMatchObject([
-        {
-          id: `2`,
-          name: `Jane Doe`,
-          age: 25,
-        },
         {
           id: `1`,
           name: `John Doe`,
           age: 30,
         },
+        {
+          id: `2`,
+          name: `Jane Doe`,
+          age: 25,
+        },
       ])
 
       // Switch to using pre-created collection
@@ -2288,7 +2290,7 @@ describe(`Query Collections`, () => {
           id: `conditional-deps-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const { result, rerender } = renderHook(
@@ -2305,10 +2307,10 @@ describe(`Query Collections`, () => {
                   age: persons.age,
                 }))
             },
-            [minAge, enabled]
+            [minAge, enabled],
           )
         },
-        { initialProps: { minAge: 30, enabled: false } }
+        { initialProps: { minAge: 30, enabled: false } },
       )
 
       // Initially disabled
diff --git a/packages/react-db/tests/useLiveSuspenseQuery.test.tsx b/packages/react-db/tests/useLiveSuspenseQuery.test.tsx
new file mode 100644
index 000000000..fc78b0796
--- /dev/null
+++ b/packages/react-db/tests/useLiveSuspenseQuery.test.tsx
@@ -0,0 +1,685 @@
+import { describe, expect, it } from 'vitest'
+import { renderHook, waitFor } from '@testing-library/react'
+import {
+  createCollection,
+  createLiveQueryCollection,
+  eq,
+  gt,
+} from '@tanstack/db'
+import { StrictMode, Suspense } from 'react'
+import { useLiveSuspenseQuery } from '../src/useLiveSuspenseQuery'
+import { mockSyncCollectionOptions } from '../../db/tests/utils'
+import type { ReactNode } from 'react'
+
+type Person = {
+  id: string
+  name: string
+  age: number
+  email: string
+  isActive: boolean
+  team: string
+}
+
+const initialPersons: Array<Person> = [
+  {
+    id: `1`,
+    name: `John Doe`,
+    age: 30,
+    email: `john.doe@example.com`,
+    isActive: true,
+    team: `team1`,
+  },
+  {
+    id: `2`,
+    name: `Jane Doe`,
+    age: 25,
+    email: `jane.doe@example.com`,
+    isActive: true,
+    team: `team2`,
+  },
+  {
+    id: `3`,
+    name: `John Smith`,
+    age: 35,
+    email: `john.smith@example.com`,
+    isActive: true,
+    team: `team1`,
+  },
+]
+
+// Wrapper component with Suspense
+function SuspenseWrapper({ children }: { children: ReactNode }) {
+  return <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
+}
+
+describe(`useLiveSuspenseQuery`, () => {
+  it(`should suspend while loading and return data when ready`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-1`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result } = renderHook(
+      () => {
+        return useLiveSuspenseQuery((q) =>
+          q
+            .from({ persons: collection })
+            .where(({ persons }) => gt(persons.age, 30))
+            .select(({ persons }) => ({
+              id: persons.id,
+              name: persons.name,
+              age: persons.age,
+            })),
+        )
+      },
+      {
+        wrapper: SuspenseWrapper,
+      },
+    )
+
+    // Wait for data to load
+    await waitFor(() => {
+      expect(result.current.state.size).toBe(1)
+    })
+
+    expect(result.current.data).toHaveLength(1)
+    const johnSmith = result.current.data[0]
+    expect(johnSmith).toMatchObject({
+      id: `3`,
+      name: `John Smith`,
+      age: 35,
+    })
+  })
+
+  it(`should return data that is always defined (type-safe)`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-2`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result } = renderHook(
+      () => {
+        return useLiveSuspenseQuery((q) => q.from({ persons: collection }))
+      },
+      {
+        wrapper: SuspenseWrapper,
+      },
+    )
+
+    await waitFor(() => {
+      expect(result.current.data).toBeDefined()
+    })
+
+    // Data is always defined - no optional chaining needed
+    expect(result.current.data.length).toBe(3)
+    // TypeScript will guarantee data is Array<Person>, not Array<Person> | undefined
+  })
+
+  it(`should work with single result queries`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-3`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result } = renderHook(
+      () => {
+        return useLiveSuspenseQuery((q) =>
+          q
+            .from({ collection })
+            .where(({ collection: c }) => eq(c.id, `3`))
+            .findOne(),
+        )
+      },
+      {
+        wrapper: SuspenseWrapper,
+      },
+    )
+
+    await waitFor(() => {
+      expect(result.current.state.size).toBe(1)
+    })
+
+    expect(result.current.data).toMatchObject({
+      id: `3`,
+      name: `John Smith`,
+      age: 35,
+    })
+  })
+
+  it(`should work with pre-created live query collection`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-4`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const liveQuery = createLiveQueryCollection((q) =>
+      q
+        .from({ persons: collection })
+        .where(({ persons }) => gt(persons.age, 30)),
+    )
+
+    const { result } = renderHook(() => useLiveSuspenseQuery(liveQuery), {
+      wrapper: SuspenseWrapper,
+    })
+
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(1)
+    })
+
+    expect(result.current.data[0]).toMatchObject({
+      id: `3`,
+      name: `John Smith`,
+      age: 35,
+    })
+  })
+
+  it(`should re-suspend when deps change`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-5`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result, rerender } = renderHook(
+      ({ minAge }) => {
+        return useLiveSuspenseQuery(
+          (q) =>
+            q
+              .from({ persons: collection })
+              .where(({ persons }) => gt(persons.age, minAge)),
+          [minAge],
+        )
+      },
+      {
+        wrapper: SuspenseWrapper,
+        initialProps: { minAge: 30 },
+      },
+    )
+
+    // Initial load - age > 30
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(1)
+    })
+    expect(result.current.data[0]?.age).toBe(35)
+
+    // Change deps - age > 20
+    rerender({ minAge: 20 })
+
+    // Should re-suspend and load new data
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(3)
+    })
+  })
+
+  it(`should reactively update data after initial load`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-6`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result } = renderHook(
+      () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
+      {
+        wrapper: SuspenseWrapper,
+      },
+    )
+
+    // Wait for initial data
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(3)
+    })
+
+    // Insert new person
+    collection.insert({
+      id: `4`,
+      name: `New Person`,
+      age: 40,
+      email: `new@example.com`,
+      isActive: true,
+      team: `team1`,
+    })
+
+    // Should reactively update
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(4)
+    })
+  })
+
+  it(`should throw error when query function returns undefined`, () => {
+    expect(() => {
+      renderHook(
+        () => {
+          return useLiveSuspenseQuery(() => undefined as any)
+        },
+        {
+          wrapper: SuspenseWrapper,
+        },
+      )
+    }).toThrow(/does not support disabled queries/)
+  })
+
+  it(`should work with config object`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-7`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result } = renderHook(
+      () => {
+        return useLiveSuspenseQuery({
+          query: (q) => q.from({ persons: collection }),
+        })
+      },
+      {
+        wrapper: SuspenseWrapper,
+      },
+    )
+
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(3)
+    })
+  })
+
+  it(`should keep stable data references when data hasn't changed`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-8`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result, rerender } = renderHook(
+      () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
+      {
+        wrapper: SuspenseWrapper,
+      },
+    )
+
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(3)
+    })
+
+    const data1 = result.current.data
+
+    rerender()
+
+    const data2 = result.current.data
+
+    // Data objects should be stable
+    expect(data1[0]).toBe(data2[0])
+    expect(data1[1]).toBe(data2[1])
+    expect(data1[2]).toBe(data2[2])
+  })
+
+  it(`should handle multiple queries in same component (serial execution)`, async () => {
+    const personsCollection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-9`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result } = renderHook(
+      () => {
+        const persons = useLiveSuspenseQuery((q) =>
+          q.from({ persons: personsCollection }),
+        )
+        const johnDoe = useLiveSuspenseQuery((q) =>
+          q
+            .from({ persons: personsCollection })
+            .where(({ persons: p }) => eq(p.id, `1`))
+            .findOne(),
+        )
+        return { persons, johnDoe }
+      },
+      {
+        wrapper: SuspenseWrapper,
+      },
+    )
+
+    await waitFor(() => {
+      expect(result.current.persons.data).toHaveLength(3)
+      expect(result.current.johnDoe.data).toBeDefined()
+    })
+
+    expect(result.current.johnDoe.data).toMatchObject({
+      id: `1`,
+      name: `John Doe`,
+    })
+  })
+
+  it(`should cleanup collection when unmounted`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-10`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result, unmount } = renderHook(
+      () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
+      {
+        wrapper: SuspenseWrapper,
+      },
+    )
+
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(3)
+    })
+
+    const liveQueryCollection = result.current.collection
+    expect(liveQueryCollection.subscriberCount).toBeGreaterThan(0)
+
+    unmount()
+
+    // Collection should eventually be cleaned up (gcTime is 1ms)
+    await waitFor(
+      () => {
+        expect(liveQueryCollection.status).toBe(`cleaned-up`)
+      },
+      { timeout: 1000 },
+    )
+  })
+
+  it(`should NOT re-suspend on live updates after initial load`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-11`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    let suspenseCount = 0
+    const SuspenseCounter = ({ children }: { children: ReactNode }) => {
+      return (
+        <Suspense
+          fallback={
+            <div>
+              {(() => {
+                suspenseCount++
+                return `Loading...`
+              })()}
+            </div>
+          }
+        >
+          {children}
+        </Suspense>
+      )
+    }
+
+    const { result } = renderHook(
+      () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
+      {
+        wrapper: SuspenseCounter,
+      },
+    )
+
+    // Wait for initial load
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(3)
+    })
+
+    const initialSuspenseCount = suspenseCount
+
+    // Make multiple live updates
+    collection.insert({
+      id: `4`,
+      name: `New Person 1`,
+      age: 40,
+      email: `new1@example.com`,
+      isActive: true,
+      team: `team1`,
+    })
+
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(4)
+    })
+
+    collection.insert({
+      id: `5`,
+      name: `New Person 2`,
+      age: 45,
+      email: `new2@example.com`,
+      isActive: true,
+      team: `team2`,
+    })
+
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(5)
+    })
+
+    collection.delete(`4`)
+
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(4)
+    })
+
+    // Verify suspense count hasn't increased (no re-suspension)
+    expect(suspenseCount).toBe(initialSuspenseCount)
+  })
+
+  it(`should only suspend on deps change, not on every re-render`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-12`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const { result, rerender } = renderHook(
+      ({ minAge }) =>
+        useLiveSuspenseQuery(
+          (q) =>
+            q
+              .from({ persons: collection })
+              .where(({ persons }) => gt(persons.age, minAge)),
+          [minAge],
+        ),
+      {
+        wrapper: SuspenseWrapper,
+        initialProps: { minAge: 20 },
+      },
+    )
+
+    // Wait for initial load
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(3)
+    })
+
+    const dataAfterInitial = result.current.data
+
+    // Re-render with SAME deps - should NOT suspend (data stays available)
+    rerender({ minAge: 20 })
+    expect(result.current.data).toHaveLength(3)
+    expect(result.current.data).toBe(dataAfterInitial)
+
+    rerender({ minAge: 20 })
+    expect(result.current.data).toHaveLength(3)
+
+    rerender({ minAge: 20 })
+    expect(result.current.data).toHaveLength(3)
+
+    // Change deps - SHOULD suspend and get new data
+    rerender({ minAge: 30 })
+
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(1)
+    })
+
+    expect(result.current.data[0]?.age).toBe(35)
+  })
+
+  it(`should work with pre-created SingleResult collection`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-single`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    // Pre-create a SingleResult live query collection
+    const singlePersonQuery = createLiveQueryCollection((q) =>
+      q
+        .from({ persons: collection })
+        .where(({ persons }) => eq(persons.id, `1`))
+        .findOne(),
+    )
+
+    const { result } = renderHook(
+      () => useLiveSuspenseQuery(singlePersonQuery),
+      {
+        wrapper: SuspenseWrapper,
+      },
+    )
+
+    await waitFor(() => {
+      expect(result.current.data).toBeDefined()
+    })
+
+    expect(result.current.data).toMatchObject({
+      id: `1`,
+      name: `John Doe`,
+      age: 30,
+    })
+  })
+
+  it(`should handle StrictMode double-invocation correctly`, async () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-strict`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    const StrictModeWrapper = ({ children }: { children: ReactNode }) => (
+      <StrictMode>
+        <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
+      </StrictMode>
+    )
+
+    const { result } = renderHook(
+      () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
+      {
+        wrapper: StrictModeWrapper,
+      },
+    )
+
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(3)
+    })
+
+    // Verify data is correct despite double-invocation
+    expect(result.current.data).toHaveLength(3)
+    expect(result.current.data[0]).toMatchObject({
+      id: `1`,
+      name: `John Doe`,
+    })
+  })
+
+  it(`should not re-suspend after hasBeenReady when isLoadingSubset changes`, async () => {
+    // This test verifies that after the initial ready state is reached,
+    // subsequent isLoadingSubset changes don't cause re-suspension
+    // (stale-while-revalidate behavior, matching TanStack Query)
+
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-suspense-on-demand`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    let suspenseCount = 0
+
+    const SuspenseTracker = ({ children }: { children: ReactNode }) => {
+      return (
+        <Suspense
+          fallback={
+            <div>
+              {(() => {
+                suspenseCount++
+                return `Loading...`
+              })()}
+            </div>
+          }
+        >
+          {children}
+        </Suspense>
+      )
+    }
+
+    const { result } = renderHook(
+      () => {
+        return useLiveSuspenseQuery((q) => q.from({ persons: collection }))
+      },
+      {
+        wrapper: SuspenseTracker,
+      },
+    )
+
+    // Wait for initial load
+    await waitFor(() => {
+      expect(result.current.data).toHaveLength(3)
+    })
+
+    const initialSuspenseCount = suspenseCount
+
+    // Now simulate on-demand loading by tracking a load promise on the live query collection
+    // This mimics what happens when a new subset query is made in on-demand mode
+    let resolveLoadPromise: () => void
+    const loadPromise = new Promise<void>((resolve) => {
+      resolveLoadPromise = resolve
+    })
+
+    // Track the load promise on the LIVE QUERY collection - this sets isLoadingSubset = true
+    result.current.collection._sync.trackLoadPromise(loadPromise)
+
+    // Verify isLoadingSubset is now true on the live query collection
+    expect(result.current.collection.isLoadingSubset).toBe(true)
+
+    // The collection is still ready, but isLoadingSubset is true
+    expect(result.current.collection.status).toBe(`ready`)
+
+    // Resolve the load promise to simulate data loading complete
+    resolveLoadPromise!()
+
+    // Wait for the loadingSubset:change event to propagate
+    await waitFor(() => {
+      expect(result.current.collection.isLoadingSubset).toBe(false)
+    })
+
+    // After hasBeenReadyRef is set, subsequent isLoadingSubset changes
+    // should NOT cause re-suspension (stale-while-revalidate behavior)
+    expect(suspenseCount).toBe(initialSuspenseCount)
+
+    // Data should still be available
+    expect(result.current.data).toHaveLength(3)
+  })
+})
diff --git a/packages/react-db/tests/usePacedMutations.test.tsx b/packages/react-db/tests/usePacedMutations.test.tsx
new file mode 100644
index 000000000..cbd058c18
--- /dev/null
+++ b/packages/react-db/tests/usePacedMutations.test.tsx
@@ -0,0 +1,251 @@
+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 React hook`, () => {
+  it(`should work with debounce strategy (smoke test)`, 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: debounceStrategy({ wait: 50 }),
+      }),
+    )
+
+    let tx
+    act(() => {
+      tx = result.current({ id: 1, value: 1 })
+    })
+
+    expect(mutationFn).not.toHaveBeenCalled()
+
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    expect(mutationFn).toHaveBeenCalledTimes(1)
+    expect(tx!.state).toBe(`completed`)
+  })
+
+  it(`should work with throttle strategy (smoke test)`, 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: true }),
+      }),
+    )
+
+    let tx
+    act(() => {
+      tx = result.current({ id: 1, value: 1 })
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 10))
+    expect(mutationFn).toHaveBeenCalledTimes(1)
+    expect(tx!.state).toBe(`completed`)
+  })
+
+  it(`should work with queue strategy (smoke test)`, async () => {
+    const mutationFn = vi.fn(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 5))
+    })
+
+    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: queueStrategy({ wait: 10 }),
+      }),
+    )
+
+    let tx
+    act(() => {
+      tx = result.current({ id: 1, value: 1 })
+    })
+
+    await tx!.isPersisted.promise
+    expect(mutationFn).toHaveBeenCalledTimes(1)
+    expect(tx!.state).toBe(`completed`)
+  })
+
+  describe(`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/packages/react-db/vite.config.ts b/packages/react-db/vite.config.ts
index a394bec32..1e193ca2f 100644
--- a/packages/react-db/vite.config.ts
+++ b/packages/react-db/vite.config.ts
@@ -1,7 +1,7 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import react from "@vitejs/plugin-react"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import react from '@vitejs/plugin-react'
+import packageJson from './package.json'
 
 export default defineConfig(async () => {
   const tanstack = await tanstackViteConfig({
diff --git a/packages/rxdb-db-collection/CHANGELOG.md b/packages/rxdb-db-collection/CHANGELOG.md
index a9de728fb..8ce1ae755 100644
--- a/packages/rxdb-db-collection/CHANGELOG.md
+++ b/packages/rxdb-db-collection/CHANGELOG.md
@@ -1,5 +1,243 @@
 # @tanstack/rxdb-db-collection
 
+## 0.1.56
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 0.1.55
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 0.1.54
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 0.1.53
+
+### Patch Changes
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 0.1.52
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 0.1.51
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 0.1.50
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 0.1.49
+
+### Patch Changes
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 0.1.48
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 0.1.47
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 0.1.46
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 0.1.45
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 0.1.44
+
+### Patch Changes
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 0.1.43
+
+### Patch Changes
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 0.1.42
+
+### Patch Changes
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/db@0.5.10
+
+## 0.1.41
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+
+## 0.1.40
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+
+## 0.1.39
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+
+## 0.1.38
+
+### Patch Changes
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 0.1.37
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 0.1.36
+
+### Patch Changes
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 0.1.35
+
+### Patch Changes
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 0.1.34
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+
+## 0.1.33
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 0.1.32
+
+### Patch Changes
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.1.31
+
+### Patch Changes
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.1.30
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.1.29
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.1.28
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+
+## 0.1.27
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+
+## 0.1.26
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+
+## 0.1.25
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+
+## 0.1.24
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+
+## 0.1.23
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+
 ## 0.1.22
 
 ### Patch Changes
diff --git a/packages/rxdb-db-collection/package.json b/packages/rxdb-db-collection/package.json
index 9a7f241a3..4fa8b3838 100644
--- a/packages/rxdb-db-collection/package.json
+++ b/packages/rxdb-db-collection/package.json
@@ -1,48 +1,12 @@
 {
   "name": "@tanstack/rxdb-db-collection",
+  "version": "0.1.56",
   "description": "RxDB collection for TanStack DB",
-  "version": "0.1.22",
-  "dependencies": {
-    "rxdb": "16.19.1",
-    "@standard-schema/spec": "^1.0.0",
-    "@tanstack/db": "workspace:*",
-    "@tanstack/store": "^0.8.0",
-    "debug": "^4.4.3"
-  },
-  "devDependencies": {
-    "@types/debug": "^4.1.12",
-    "@vitest/coverage-istanbul": "^3.2.4"
-  },
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
-      }
-    },
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
-  "packageManager": "pnpm@10.18.3",
-  "peerDependencies": {
-    "rxdb": ">=16.17.2",
-    "rxjs": ">=7.8.2",
-    "typescript": ">=4.7"
-  },
   "author": "Kyle Mathews",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/TanStack/db.git",
+    "url": "git+https://github.com/TanStack/db.git",
     "directory": "packages/rxdb-db-collection"
   },
   "homepage": "https://tanstack.com/db",
@@ -64,9 +28,44 @@
     "build": "vite build",
     "dev": "vite build --watch",
     "lint": "eslint . --fix",
-    "test": "npx vitest --run"
+    "test": "vitest --run"
   },
-  "sideEffects": false,
   "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "@tanstack/db": "workspace:*",
+    "@tanstack/store": "^0.8.0",
+    "debug": "^4.4.3",
+    "rxdb": "16.21.1"
+  },
+  "peerDependencies": {
+    "rxdb": ">=16.17.2",
+    "rxjs": ">=7.8.2",
+    "typescript": ">=4.7"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@vitest/coverage-istanbul": "^3.2.4"
+  }
 }
diff --git a/packages/rxdb-db-collection/src/index.ts b/packages/rxdb-db-collection/src/index.ts
index 4d3f5981c..2beb5af06 100644
--- a/packages/rxdb-db-collection/src/index.ts
+++ b/packages/rxdb-db-collection/src/index.ts
@@ -1,2 +1,2 @@
-export * from "./rxdb"
-export * from "./helper"
+export * from './rxdb'
+export * from './helper'
diff --git a/packages/rxdb-db-collection/src/rxdb.ts b/packages/rxdb-db-collection/src/rxdb.ts
index dfb1f9011..6ec59cfb6 100644
--- a/packages/rxdb-db-collection/src/rxdb.ts
+++ b/packages/rxdb-db-collection/src/rxdb.ts
@@ -5,23 +5,23 @@ import {
   lastOfArray,
   prepareQuery,
   rxStorageWriteErrorToRxError,
-} from "rxdb/plugins/core"
-import DebugModule from "debug"
-import { stripRxdbFields } from "./helper"
+} from 'rxdb/plugins/core'
+import DebugModule from 'debug'
+import { stripRxdbFields } from './helper'
 import type {
   FilledMangoQuery,
   RxCollection,
   RxDocumentData,
-} from "rxdb/plugins/core"
-import type { Subscription } from "rxjs"
+} from 'rxdb/plugins/core'
+import type { Subscription } from 'rxjs'
 
 import type {
   BaseCollectionConfig,
   CollectionConfig,
   InferSchemaOutput,
   SyncConfig,
-} from "@tanstack/db"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
+} from '@tanstack/db'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 const debug = DebugModule.debug(`ts/db:rxdb`)
 
@@ -87,7 +87,7 @@ export type RxDBCollectionConfig<
 
 // Overload for when schema is provided
 export function rxdbCollectionOptions<T extends StandardSchemaV1>(
-  config: RxDBCollectionConfig<InferSchemaOutput<T>, T>
+  config: RxDBCollectionConfig<InferSchemaOutput<T>, T>,
 ): CollectionConfig<InferSchemaOutput<T>, string, T> & {
   schema: T
 }
@@ -96,7 +96,7 @@ export function rxdbCollectionOptions<T extends StandardSchemaV1>(
 export function rxdbCollectionOptions<T extends object>(
   config: RxDBCollectionConfig<T> & {
     schema?: never // prohibit schema
-  }
+  },
 ): CollectionConfig<T, string> & {
   schema?: never // no schema in the result
 }
@@ -143,9 +143,9 @@ export function rxdbCollectionOptions(config: RxDBCollectionConfig<any, any>) {
             query = {
               selector: {
                 $or: [
-                  { "_meta.lwt": { $gt: cursor._meta.lwt } },
+                  { '_meta.lwt': { $gt: cursor._meta.lwt } },
                   {
-                    "_meta.lwt": cursor._meta.lwt,
+                    '_meta.lwt': cursor._meta.lwt,
                     [primaryPath]: {
                       $gt: getKey(cursor),
                     },
@@ -153,14 +153,14 @@ export function rxdbCollectionOptions(config: RxDBCollectionConfig<any, any>) {
                 ],
                 _deleted: false,
               },
-              sort: [{ "_meta.lwt": `asc` }, { [primaryPath]: `asc` }],
+              sort: [{ '_meta.lwt': `asc` }, { [primaryPath]: `asc` }],
               limit: syncBatchSize,
               skip: 0,
             }
           } else {
             query = {
               selector: { _deleted: false },
-              sort: [{ "_meta.lwt": `asc` }, { [primaryPath]: `asc` }],
+              sort: [{ '_meta.lwt': `asc` }, { [primaryPath]: `asc` }],
               limit: syncBatchSize,
               skip: 0,
             }
@@ -174,7 +174,7 @@ export function rxdbCollectionOptions(config: RxDBCollectionConfig<any, any>) {
            */
           const preparedQuery = prepareQuery<Row>(
             rxCollection.storageInstance.schema,
-            query
+            query,
           )
           const result = await rxCollection.storageInstance.query(preparedQuery)
           const docs = result.documents
@@ -228,7 +228,7 @@ export function rxdbCollectionOptions(config: RxDBCollectionConfig<any, any>) {
         const subs = getFromMapOrCreate(
           OPEN_RXDB_SUBSCRIPTIONS,
           rxCollection,
-          () => new Set()
+          () => new Set(),
         )
         subs.add(sub)
       }
@@ -253,7 +253,7 @@ export function rxdbCollectionOptions(config: RxDBCollectionConfig<any, any>) {
         const subs = getFromMapOrCreate(
           OPEN_RXDB_SUBSCRIPTIONS,
           rxCollection,
-          () => new Set()
+          () => new Set(),
         )
         subs.delete(sub)
         sub.unsubscribe()
@@ -280,7 +280,8 @@ export function rxdbCollectionOptions(config: RxDBCollectionConfig<any, any>) {
     onUpdate: async (params) => {
       debug(`update`, params)
       const mutations = params.transaction.mutations.filter(
-        (m) => m.type === `update`
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        (m) => m.type === `update`,
       )
 
       for (const mutation of mutations) {
@@ -296,7 +297,8 @@ export function rxdbCollectionOptions(config: RxDBCollectionConfig<any, any>) {
     onDelete: async (params) => {
       debug(`delete`, params)
       const mutations = params.transaction.mutations.filter(
-        (m) => m.type === `delete`
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        (m) => m.type === `delete`,
       )
       const ids = mutations.map((mutation) => getKey(mutation.original))
       return rxCollection.bulkRemove(ids).then((result) => {
diff --git a/packages/rxdb-db-collection/tests/rxdb.test.ts b/packages/rxdb-db-collection/tests/rxdb.test.ts
index 87c1b9dff..03f470d88 100644
--- a/packages/rxdb-db-collection/tests/rxdb.test.ts
+++ b/packages/rxdb-db-collection/tests/rxdb.test.ts
@@ -1,16 +1,16 @@
-import { describe, expect, it } from "vitest"
-import { createCollection } from "@tanstack/db"
+import { describe, expect, it } from 'vitest'
+import { createCollection } from '@tanstack/db'
 import {
   addRxPlugin,
   createRxDatabase,
   getFromMapOrCreate,
-} from "rxdb/plugins/core"
-import { RxDBDevModePlugin } from "rxdb/plugins/dev-mode"
-import { getRxStorageMemory } from "rxdb/plugins/storage-memory"
-import { wrappedValidateAjvStorage } from "rxdb/plugins/validate-ajv"
-import { OPEN_RXDB_SUBSCRIPTIONS, rxdbCollectionOptions } from "../src/rxdb"
-import type { RxCollection } from "rxdb/plugins/core"
-import type { RxDBCollectionConfig } from "../src/rxdb"
+} from 'rxdb/plugins/core'
+import { RxDBDevModePlugin } from 'rxdb/plugins/dev-mode'
+import { getRxStorageMemory } from 'rxdb/plugins/storage-memory'
+import { wrappedValidateAjvStorage } from 'rxdb/plugins/validate-ajv'
+import { OPEN_RXDB_SUBSCRIPTIONS, rxdbCollectionOptions } from '../src/rxdb'
+import type { RxCollection } from 'rxdb/plugins/core'
+import type { RxDBCollectionConfig } from '../src/rxdb'
 
 type TestDocType = {
   id: string
@@ -36,7 +36,7 @@ describe(`RxDB Integration`, () => {
 
   async function getDatababase(
     initialDocs: Array<TestDocType> = [],
-    dbId = dbNameId++
+    dbId = dbNameId++,
   ) {
     const db = await createRxDatabase<RxCollections, unknown, unknown, unknown>(
       {
@@ -45,7 +45,7 @@ describe(`RxDB Integration`, () => {
         storage: wrappedValidateAjvStorage({
           storage: getRxStorageMemory(),
         }),
-      }
+      },
     )
     const collections = await db.addCollections<RxCollections>({
       test: {
@@ -76,7 +76,7 @@ describe(`RxDB Integration`, () => {
 
   async function createTestState(
     initialDocs: Array<TestDocType> = [],
-    config: Partial<RxDBCollectionConfig<TestDocType, any>> = {}
+    config: Partial<RxDBCollectionConfig<TestDocType, any>> = {},
   ) {
     const db = await getDatababase(initialDocs, dbNameId++)
     const rxCollection: RxCollection<TestDocType> = db.test
@@ -205,7 +205,7 @@ describe(`RxDB Integration`, () => {
       const subs = getFromMapOrCreate(
         OPEN_RXDB_SUBSCRIPTIONS,
         rxCollection,
-        () => new Set()
+        () => new Set(),
       )
       expect(subs.size).toEqual(0)
 
@@ -249,13 +249,13 @@ describe(`RxDB Integration`, () => {
         rxdbCollectionOptions({
           rxCollection: db1.test,
           startSync: true,
-        })
+        }),
       )
       const col2 = createCollection(
         rxdbCollectionOptions({
           rxCollection: db2.test,
           startSync: true,
-        })
+        }),
       )
       await col1.stateWhenReady()
       await col2.stateWhenReady()
diff --git a/packages/rxdb-db-collection/vite.config.ts b/packages/rxdb-db-collection/vite.config.ts
index c7968f28a..aa589f666 100644
--- a/packages/rxdb-db-collection/vite.config.ts
+++ b/packages/rxdb-db-collection/vite.config.ts
@@ -1,6 +1,6 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import packageJson from './package.json'
 
 const config = defineConfig({
   test: {
@@ -17,5 +17,5 @@ export default mergeConfig(
   tanstackViteConfig({
     entry: `./src/index.ts`,
     srcDir: `./src`,
-  })
+  }),
 )
diff --git a/packages/solid-db/CHANGELOG.md b/packages/solid-db/CHANGELOG.md
index d19fb4024..cb79b2dbe 100644
--- a/packages/solid-db/CHANGELOG.md
+++ b/packages/solid-db/CHANGELOG.md
@@ -1,5 +1,297 @@
 # @tanstack/react-db
 
+## 0.2.4
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 0.2.3
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 0.2.2
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 0.2.1
+
+### Patch Changes
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 0.2.0
+
+### Minor Changes
+
+- Update solid-db to enable suspense support. ([#826](https://github.com/TanStack/db/pull/826))
+  You can now run do
+
+  ```tsx
+  // Use Suspense boundaries
+  const todosQuery = useLiveQuery((q) => q.from({ todos: todoCollection }))
+
+  return (
+    <>
+      {/* Status and other getters don't trigger Suspense */}
+      <div>Status {todosQuery.status}</div>
+      <div>Loading {todosQuery.isLoading ? 'yes' : 'no'}</div>
+
+      <Suspense fallback={<div>Loading...</div>}>
+        <For each={todosQuery()}>
+          {(todo) => <li key={todo.id}>{todo.text}</li>}
+        </For>
+      </Suspense>
+    </>
+  )
+  ```
+
+  All values returned from useLiveQuery are now getters, so no longer need to be called as functions. This is a breaking change. This is to match how createResource works, and everything still stays reactive.
+
+  ```tsx
+  const todos = useLiveQuery(() => existingCollection)
+
+  const handleToggle = (id) => {
+    // Can now access collection directly
+    todos.collection.update(id, (draft) => {
+      draft.completed = !draft.completed
+    })
+  }
+
+  return (
+    <>
+      {/* Status and other getters don't trigger Suspense */}
+      <div>Status {todos.status}</div>
+      <div>Loading {todos.isLoading ? 'yes' : 'no'}</div>
+      <div>Ready {todos.isReady ? 'yes' : 'no'}</div>
+      <div>Idle {todos.isIdle ? 'yes' : 'no'}</div>
+      <div>Error {todos.isError ? 'yes' : 'no'}</div>
+    </>
+  )
+  ```
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 0.1.62
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 0.1.61
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 0.1.60
+
+### Patch Changes
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 0.1.59
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 0.1.58
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 0.1.57
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 0.1.56
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 0.1.55
+
+### Patch Changes
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 0.1.54
+
+### Patch Changes
+
+- Fixed `isReady` to return `true` for disabled queries in `useLiveQuery`/`injectLiveQuery` across all framework packages. When a query function returns `null` or `undefined` (disabling the query), there's no async operation to wait for, so the hook should be considered "ready" immediately. ([#886](https://github.com/TanStack/db/pull/886))
+
+  Additionally, all frameworks now have proper TypeScript overloads that explicitly support returning `undefined | null` from query functions, making the disabled query pattern type-safe.
+
+  This fixes the common pattern where users conditionally enable queries and don't want to show loading states when the query is disabled.
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 0.1.53
+
+### Patch Changes
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/db@0.5.10
+
+## 0.1.52
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+
+## 0.1.51
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+
+## 0.1.50
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+
+## 0.1.49
+
+### Patch Changes
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 0.1.48
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 0.1.47
+
+### Patch Changes
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 0.1.46
+
+### Patch Changes
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 0.1.45
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+
+## 0.1.44
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 0.1.43
+
+### Patch Changes
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.1.42
+
+### Patch Changes
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.1.41
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.1.40
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.1.39
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+
+## 0.1.38
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+
+## 0.1.37
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+
+## 0.1.36
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+
+## 0.1.35
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+
+## 0.1.34
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+
 ## 0.1.33
 
 ### Patch Changes
diff --git a/packages/solid-db/package.json b/packages/solid-db/package.json
index 0aab6539b..acecd5f66 100644
--- a/packages/solid-db/package.json
+++ b/packages/solid-db/package.json
@@ -1,12 +1,12 @@
 {
   "name": "@tanstack/solid-db",
+  "version": "0.2.4",
   "description": "Solid integration for @tanstack/db",
-  "version": "0.1.33",
   "author": "Kyle Mathews",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/TanStack/db.git",
+    "url": "git+https://github.com/TanStack/db.git",
     "directory": "packages/solid-db"
   },
   "homepage": "https://tanstack.com/db",
@@ -15,20 +15,16 @@
     "solid",
     "typescript"
   ],
-  "packageManager": "pnpm@10.18.3",
-  "dependencies": {
-    "@solid-primitives/map": "^0.7.2",
-    "@tanstack/db": "workspace:*"
-  },
-  "devDependencies": {
-    "@electric-sql/client": "1.0.14",
-    "@solidjs/testing-library": "^0.8.10",
-    "@vitest/coverage-istanbul": "^3.2.4",
-    "jsdom": "^27.0.1",
-    "solid-js": "^1.9.9",
-    "vite-plugin-solid": "^2.11.9",
-    "vitest": "^3.2.4"
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "vitest --run",
+    "lint": "eslint . --fix"
   },
+  "type": "module",
+  "main": "dist/esm/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -38,22 +34,25 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
+  "dependencies": {
+    "@solid-primitives/map": "^0.7.2",
+    "@tanstack/db": "workspace:*"
+  },
   "peerDependencies": {
     "solid-js": ">=1.9.0"
   },
-  "scripts": {
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "test": "vitest --run",
-    "lint": "eslint . --fix"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "devDependencies": {
+    "@electric-sql/client": "^1.3.1",
+    "@solidjs/testing-library": "^0.8.10",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "jsdom": "^27.4.0",
+    "solid-js": "^1.9.10",
+    "vite-plugin-solid": "^2.11.10",
+    "vitest": "^3.2.4"
+  }
 }
diff --git a/packages/solid-db/src/index.ts b/packages/solid-db/src/index.ts
index bd98349f0..681078b9c 100644
--- a/packages/solid-db/src/index.ts
+++ b/packages/solid-db/src/index.ts
@@ -1,9 +1,9 @@
 // Re-export all public APIs
-export * from "./useLiveQuery"
+export * from './useLiveQuery'
 
 // Re-export everything from @tanstack/db
-export * from "@tanstack/db"
+export * from '@tanstack/db'
 
 // Re-export some stuff explicitly to ensure the type & value is exported
-export type { Collection } from "@tanstack/db"
-export { createTransaction } from "@tanstack/db"
+export type { Collection } from '@tanstack/db'
+export { createTransaction } from '@tanstack/db'
diff --git a/packages/solid-db/src/useLiveQuery.ts b/packages/solid-db/src/useLiveQuery.ts
index d3e645871..7a5ba9595 100644
--- a/packages/solid-db/src/useLiveQuery.ts
+++ b/packages/solid-db/src/useLiveQuery.ts
@@ -1,15 +1,19 @@
 import {
   batch,
-  createComputed,
+  createEffect,
   createMemo,
   createResource,
   createSignal,
   onCleanup,
-} from "solid-js"
-import { ReactiveMap } from "@solid-primitives/map"
-import { CollectionImpl, createLiveQueryCollection } from "@tanstack/db"
-import { createStore, reconcile } from "solid-js/store"
-import type { Accessor } from "solid-js"
+} from 'solid-js'
+import { ReactiveMap } from '@solid-primitives/map'
+import {
+  BaseQueryBuilder,
+  CollectionImpl,
+  createLiveQueryCollection,
+} from '@tanstack/db'
+import { createStore, reconcile } from 'solid-js/store'
+import type { Accessor } from 'solid-js'
 import type {
   ChangeMessage,
   Collection,
@@ -19,12 +23,12 @@ import type {
   InitialQueryBuilder,
   LiveQueryCollectionConfig,
   QueryBuilder,
-} from "@tanstack/db"
+} from '@tanstack/db'
 
 /**
  * Create a live query using a query function
  * @param queryFn - Query function that defines what data to fetch
- * @returns Object with reactive data, state, and status information
+ * @returns Accessor that returns data with Suspense support, with state and status information as properties
  * @example
  * // Basic query with object syntax
  * const todosQuery = useLiveQuery((q) =>
@@ -62,39 +66,78 @@ import type {
  *
  * return (
  *   <Switch>
- *     <Match when={todosQuery.isLoading()}>
+ *     <Match when={todosQuery.isLoading}>
  *       <div>Loading...</div>
  *     </Match>
- *     <Match when={todosQuery.isError()}>
- *       <div>Error: {todosQuery.status()}</div>
+ *     <Match when={todosQuery.isError}>
+ *       <div>Error: {todosQuery.status}</div>
  *     </Match>
- *     <Match when={todosQuery.isReady()}>
- *       <For each={todosQuery.data()}>
+ *     <Match when={todosQuery.isReady}>
+ *       <For each={todosQuery()}>
  *         {(todo) => <li key={todo.id}>{todo.text}</li>}
  *       </For>
  *     </Match>
  *   </Switch>
  * )
+ *
+ * @example
+ * // Use Suspense boundaries
+ * const todosQuery = useLiveQuery((q) =>
+ *   q.from({ todos: todoCollection })
+ * )
+ *
+ * return (
+ *   <Suspense fallback={<div>Loading...</div>}>
+ *     <For each={todosQuery()}>
+ *       {(todo) => <li key={todo.id}>{todo.text}</li>}
+ *     </For>
+ *   </Suspense>
+ * )
  */
-// Overload 1: Accept just the query function
+// Overload 1: Accept query function that always returns QueryBuilder
 export function useLiveQuery<TContext extends Context>(
-  queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>
-): {
+  queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,
+): Accessor<Array<GetResult<TContext>>> & {
+  /**
+   * @deprecated use function result instead
+   * query.data -> query()
+   */
+  data: Array<GetResult<TContext>>
   state: ReactiveMap<string | number, GetResult<TContext>>
+  collection: Collection<GetResult<TContext>, string | number, {}>
+  status: CollectionStatus
+  isLoading: boolean
+  isReady: boolean
+  isIdle: boolean
+  isError: boolean
+  isCleanedUp: boolean
+}
+
+// Overload 1b: Accept query function that can return undefined/null
+export function useLiveQuery<TContext extends Context>(
+  queryFn: (
+    q: InitialQueryBuilder,
+  ) => QueryBuilder<TContext> | undefined | null,
+): Accessor<Array<GetResult<TContext>>> & {
+  /**
+   * @deprecated use function result instead
+   * query.data -> query()
+   */
   data: Array<GetResult<TContext>>
-  collection: Accessor<Collection<GetResult<TContext>, string | number, {}>>
-  status: Accessor<CollectionStatus>
-  isLoading: Accessor<boolean>
-  isReady: Accessor<boolean>
-  isIdle: Accessor<boolean>
-  isError: Accessor<boolean>
-  isCleanedUp: Accessor<boolean>
+  state: ReactiveMap<string | number, GetResult<TContext>>
+  collection: Collection<GetResult<TContext>, string | number, {}> | null
+  status: CollectionStatus | `disabled`
+  isLoading: boolean
+  isReady: boolean
+  isIdle: boolean
+  isError: boolean
+  isCleanedUp: boolean
 }
 
 /**
  * Create a live query using configuration object
  * @param config - Configuration object with query and options
- * @returns Object with reactive data, state, and status information
+ * @returns Accessor that returns data with Suspense support, with state and status information as properties
  * @example
  * // Basic config object usage
  * const todosQuery = useLiveQuery(() => ({
@@ -118,14 +161,14 @@ export function useLiveQuery<TContext extends Context>(
  * }))
  *
  * return (
- *   <Switch fallback={<div>{itemsQuery.data.length} items loaded</div>}>
- *     <Match when={itemsQuery.isLoading()}>
+ *   <Switch fallback={<div>{itemsQuery().length} items loaded</div>}>
+ *     <Match when={itemsQuery.isLoading}>
  *       <div>Loading...</div>
  *     </Match>
- *     <Match when={itemsQuery.isError()}>
+ *     <Match when={itemsQuery.isError}>
  *       <div>Something went wrong</div>
  *     </Match>
- *     <Match when={!itemsQuery.isReady()}>
+ *     <Match when={!itemsQuery.isReady}>
  *       <div>Preparing...</div>
  *     </Match>
  *   </Switch>
@@ -133,23 +176,27 @@ export function useLiveQuery<TContext extends Context>(
  */
 // Overload 2: Accept config object
 export function useLiveQuery<TContext extends Context>(
-  config: Accessor<LiveQueryCollectionConfig<TContext>>
-): {
-  state: ReactiveMap<string | number, GetResult<TContext>>
+  config: Accessor<LiveQueryCollectionConfig<TContext>>,
+): Accessor<Array<GetResult<TContext>>> & {
+  /**
+   * @deprecated use function result instead
+   * query.data -> query()
+   */
   data: Array<GetResult<TContext>>
-  collection: Accessor<Collection<GetResult<TContext>, string | number, {}>>
-  status: Accessor<CollectionStatus>
-  isLoading: Accessor<boolean>
-  isReady: Accessor<boolean>
-  isIdle: Accessor<boolean>
-  isError: Accessor<boolean>
-  isCleanedUp: Accessor<boolean>
+  state: ReactiveMap<string | number, GetResult<TContext>>
+  collection: Collection<GetResult<TContext>, string | number, {}>
+  status: CollectionStatus
+  isLoading: boolean
+  isReady: boolean
+  isIdle: boolean
+  isError: boolean
+  isCleanedUp: boolean
 }
 
 /**
  * Subscribe to an existing live query collection
  * @param liveQueryCollection - Pre-created live query collection to subscribe to
- * @returns Object with reactive data, state, and status information
+ * @returns Accessor that returns data with Suspense support, with state and status information as properties
  * @example
  * // Using pre-created live query collection
  * const myLiveQuery = createLiveQueryCollection((q) =>
@@ -163,7 +210,7 @@ export function useLiveQuery<TContext extends Context>(
  *
  * // Use collection for mutations
  * const handleToggle = (id) => {
- *   existingQuery.collection().update(id, draft => { draft.completed = !draft.completed })
+ *   existingQuery.collection.update(id, draft => { draft.completed = !draft.completed })
  * }
  *
  * @example
@@ -171,11 +218,11 @@ export function useLiveQuery<TContext extends Context>(
  * const sharedQuery = useLiveQuery(() => sharedCollection)
  *
  * return (
- *  <Switch fallback={<div><For each={sharedQuery.data()}>{(item) => <Item key={item.id} {...item} />}</For></div>}>
- *    <Match when={sharedQuery.isLoading()}>
+ *  <Switch fallback={<div><For each={sharedQuery()}>{(item) => <Item key={item.id} {...item} />}</For></div>}>
+ *    <Match when={sharedQuery.isLoading}>
  *      <div>Loading...</div>
  *    </Match>
- *    <Match when={sharedQuery.isError()}>
+ *    <Match when={sharedQuery.isError}>
  *      <div>Error loading data</div>
  *    </Match>
  *  </Switch>
@@ -187,26 +234,39 @@ export function useLiveQuery<
   TKey extends string | number,
   TUtils extends Record<string, any>,
 >(
-  liveQueryCollection: Accessor<Collection<TResult, TKey, TUtils>>
-): {
-  state: ReactiveMap<TKey, TResult>
+  liveQueryCollection: Accessor<Collection<TResult, TKey, TUtils>>,
+): Accessor<Array<TResult>> & {
+  /**
+   * @deprecated use function result instead
+   * query.data -> query()
+   */
   data: Array<TResult>
-  collection: Accessor<Collection<TResult, TKey, TUtils>>
-  status: Accessor<CollectionStatus>
-  isLoading: Accessor<boolean>
-  isReady: Accessor<boolean>
-  isIdle: Accessor<boolean>
-  isError: Accessor<boolean>
-  isCleanedUp: Accessor<boolean>
+  state: ReactiveMap<TKey, TResult>
+  collection: Collection<TResult, TKey, TUtils>
+  status: CollectionStatus
+  isLoading: boolean
+  isReady: boolean
+  isIdle: boolean
+  isError: boolean
+  isCleanedUp: boolean
 }
 
 // Implementation - use function overloads to infer the actual collection type
 export function useLiveQuery(
-  configOrQueryOrCollection: (queryFn?: any) => any
+  configOrQueryOrCollection: (queryFn?: any) => any,
 ) {
   const collection = createMemo(
     () => {
       if (configOrQueryOrCollection.length === 1) {
+        // This is a query function - check if it returns null/undefined
+        const queryBuilder = new BaseQueryBuilder() as InitialQueryBuilder
+        const result = configOrQueryOrCollection(queryBuilder)
+
+        if (result === undefined || result === null) {
+          // Disabled query - return null
+          return null
+        }
+
         return createLiveQueryCollection({
           query: configOrQueryOrCollection,
           startSync: true,
@@ -214,6 +274,12 @@ export function useLiveQuery(
       }
 
       const innerCollection = configOrQueryOrCollection()
+
+      if (innerCollection === undefined || innerCollection === null) {
+        // Disabled query - return null
+        return null
+      }
+
       if (innerCollection instanceof CollectionImpl) {
         innerCollection.startSyncImmediate()
         return innerCollection as Collection
@@ -225,7 +291,7 @@ export function useLiveQuery(
       })
     },
     undefined,
-    { name: `TanstackDBCollectionMemo` }
+    { name: `TanstackDBCollectionMemo` },
   )
 
   // Reactive state that gets updated granularly through change events
@@ -237,92 +303,145 @@ export function useLiveQuery(
   })
 
   // Track collection status reactively
-  const [status, setStatus] = createSignal(collection().status, {
-    name: `TanstackDBStatus`,
-  })
+  const [status, setStatus] = createSignal(
+    collection() ? collection()!.status : (`disabled` as const),
+    {
+      name: `TanstackDBStatus`,
+    },
+  )
 
   // Helper to sync data array from collection in correct order
   const syncDataFromCollection = (
-    currentCollection: Collection<any, any, any>
+    currentCollection: Collection<any, any, any>,
   ) => {
     setData((prev) =>
-      reconcile(Array.from(currentCollection.values()))(prev).filter(Boolean)
+      reconcile(Array.from(currentCollection.values()))(prev).filter(Boolean),
     )
   }
 
-  // Track current unsubscribe function
-  let currentUnsubscribe: (() => void) | null = null
-
-  createComputed(
-    () => {
-      const currentCollection = collection()
-
-      // Update status ref whenever the effect runs
+  const [getDataResource] = createResource(
+    () => ({ currentCollection: collection() }),
+    async ({ currentCollection }) => {
+      if (!currentCollection) {
+        return []
+      }
       setStatus(currentCollection.status)
-
-      // Initialize state with current collection data
-      state.clear()
-      for (const [key, value] of currentCollection.entries()) {
-        state.set(key, value)
+      try {
+        await currentCollection.toArrayWhenReady()
+      } catch (error) {
+        setStatus(`error`)
+        throw error
       }
+      // Initialize state with current collection data
+      batch(() => {
+        state.clear()
+        for (const [key, value] of currentCollection.entries()) {
+          state.set(key, value)
+        }
+        syncDataFromCollection(currentCollection)
+        setStatus(currentCollection.status)
+      })
+      return data
+    },
+    {
+      name: `TanstackDBData`,
+      deferStream: false,
+      initialValue: data,
+    },
+  )
 
-      // Subscribe to collection changes with granular updates
-      const subscription = currentCollection.subscribeChanges(
-        (changes: Array<ChangeMessage<any>>) => {
-          // Apply each change individually to the reactive state
-          batch(() => {
-            for (const change of changes) {
-              switch (change.type) {
-                case `insert`:
-                case `update`:
-                  state.set(change.key, change.value)
-                  break
-                case `delete`:
-                  state.delete(change.key)
-                  break
-              }
+  createEffect(() => {
+    const currentCollection = collection()
+    if (!currentCollection) {
+      setStatus(`disabled` as const)
+      state.clear()
+      setData([])
+      return
+    }
+    const subscription = currentCollection.subscribeChanges(
+      (changes: Array<ChangeMessage<any>>) => {
+        // Apply each change individually to the reactive state
+        batch(() => {
+          for (const change of changes) {
+            switch (change.type) {
+              case `insert`:
+              case `update`:
+                state.set(change.key, change.value)
+                break
+              case `delete`:
+                state.delete(change.key)
+                break
             }
-          })
+          }
 
-          // Update the data array to maintain sorted order
           syncDataFromCollection(currentCollection)
 
           // Update status ref on every change
           setStatus(currentCollection.status)
-        },
-        {
-          includeInitialState: true,
-        }
-      )
+        })
+      },
+      {
+        // Include initial state to ensure immediate population for pre-created collections
+        includeInitialState: true,
+      },
+    )
 
-      currentUnsubscribe = subscription.unsubscribe.bind(subscription)
+    onCleanup(() => {
+      subscription.unsubscribe()
+    })
+  })
 
-      // Preload collection data if not already started
-      if (currentCollection.status === `idle`) {
-        createResource(() => currentCollection.preload())
-      }
+  // We have to remove getters from the resource function so we wrap it
+  function getData() {
+    return getDataResource()
+  }
 
-      // Cleanup when computed is invalidated
-      onCleanup(() => {
-        if (currentUnsubscribe) {
-          currentUnsubscribe()
-          currentUnsubscribe = null
-        }
-      })
+  Object.defineProperties(getData, {
+    data: {
+      get() {
+        return getData()
+      },
     },
-    undefined,
-    { name: `TanstackDBSyncComputed` }
-  )
-
-  return {
-    state,
-    data,
-    collection,
-    status,
-    isLoading: () => status() === `loading`,
-    isReady: () => status() === `ready`,
-    isIdle: () => status() === `idle`,
-    isError: () => status() === `error`,
-    isCleanedUp: () => status() === `cleaned-up`,
-  }
+    status: {
+      get() {
+        return status()
+      },
+    },
+    collection: {
+      get() {
+        return collection()
+      },
+    },
+    state: {
+      get() {
+        return state
+      },
+    },
+    isLoading: {
+      get() {
+        return status() === `loading`
+      },
+    },
+    isReady: {
+      get() {
+        return status() === `ready` || status() === `disabled`
+      },
+    },
+    isIdle: {
+      get() {
+        return status() === `idle`
+      },
+    },
+    isError: {
+      get() {
+        return status() === `error`
+      },
+    },
+    isCleanedUp: {
+      get() {
+        return status() === `cleaned-up`
+      },
+    },
+  })
+  return getData
 }
diff --git a/packages/solid-db/tests/test-setup.ts b/packages/solid-db/tests/test-setup.ts
index 9b279c469..6c99e8bb9 100644
--- a/packages/solid-db/tests/test-setup.ts
+++ b/packages/solid-db/tests/test-setup.ts
@@ -1,6 +1,6 @@
-import "@testing-library/jest-dom/vitest"
-import { cleanup } from "@solidjs/testing-library"
-import { afterEach } from "vitest"
+import '@testing-library/jest-dom/vitest'
+import { cleanup } from '@solidjs/testing-library'
+import { afterEach } from 'vitest'
 
 // https://testing-library.com/docs/solid-testing-library/api/#cleanup
 afterEach(() => cleanup())
diff --git a/packages/solid-db/tests/useLiveQuery.test.tsx b/packages/solid-db/tests/useLiveQuery.test.tsx
index 459a10bd1..8f9ef6ee2 100644
--- a/packages/solid-db/tests/useLiveQuery.test.tsx
+++ b/packages/solid-db/tests/useLiveQuery.test.tsx
@@ -1,5 +1,5 @@
-import { describe, expect, it } from "vitest"
-import { renderHook, waitFor } from "@solidjs/testing-library"
+import { describe, expect, it } from 'vitest'
+import { render, renderHook, waitFor } from '@solidjs/testing-library'
 import {
   Query,
   count,
@@ -8,11 +8,17 @@ import {
   createOptimisticAction,
   eq,
   gt,
-} from "@tanstack/db"
-import { createComputed, createRoot, createSignal } from "solid-js"
-import { useLiveQuery } from "../src/useLiveQuery"
-import { mockSyncCollectionOptions } from "../../db/tests/utils"
-import type { Accessor } from "solid-js"
+} from '@tanstack/db'
+import {
+  For,
+  Suspense,
+  createComputed,
+  createRoot,
+  createSignal,
+} from 'solid-js'
+import { useLiveQuery } from '../src/useLiveQuery'
+import { mockSyncCollectionOptions } from '../../db/tests/utils'
+import type { Accessor } from 'solid-js'
 
 type Person = {
   id: string
@@ -85,7 +91,7 @@ describe(`Query Collections`, () => {
         id: `test-persons`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const rendered = renderHook(() => {
@@ -97,7 +103,7 @@ describe(`Query Collections`, () => {
             id: persons.id,
             name: persons.name,
             age: persons.age,
-          }))
+          })),
       )
     })
 
@@ -105,9 +111,9 @@ describe(`Query Collections`, () => {
     await waitFor(() => {
       expect(rendered.result.state.size).toBe(1) // Only John Smith (age 35)
     })
-    expect(rendered.result.data).toHaveLength(1)
+    expect(rendered.result()).toHaveLength(1)
 
-    const johnSmith = rendered.result.data[0]
+    const johnSmith = rendered.result()[0]
     expect(johnSmith).toMatchObject({
       id: `3`,
       name: `John Smith`,
@@ -121,7 +127,7 @@ describe(`Query Collections`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const rendered = renderHook(() => {
@@ -133,7 +139,7 @@ describe(`Query Collections`, () => {
             id: c.id,
             name: c.name,
           }))
-          .orderBy(({ collection: c }) => c.id, `asc`)
+          .orderBy(({ collection: c }) => c.id, `asc`),
       )
     })
 
@@ -146,8 +152,8 @@ describe(`Query Collections`, () => {
       name: `John Smith`,
     })
 
-    expect(rendered.result.data.length).toBe(1)
-    expect(rendered.result.data[0]).toMatchObject({
+    expect(rendered.result().length).toBe(1)
+    expect(rendered.result()[0]).toMatchObject({
       id: `3`,
       name: `John Smith`,
     })
@@ -179,8 +185,8 @@ describe(`Query Collections`, () => {
       name: `Kyle Doe`,
     })
 
-    expect(rendered.result.data.length).toBe(2)
-    expect(rendered.result.data).toEqual(
+    expect(rendered.result().length).toBe(2)
+    expect(rendered.result()).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
           id: `3`,
@@ -190,7 +196,7 @@ describe(`Query Collections`, () => {
           id: `4`,
           name: `Kyle Doe`,
         }),
-      ])
+      ]),
     )
 
     // Update the person
@@ -216,8 +222,8 @@ describe(`Query Collections`, () => {
       name: `Kyle Doe 2`,
     })
 
-    expect(rendered.result.data.length).toBe(2)
-    expect(rendered.result.data).toEqual(
+    expect(rendered.result().length).toBe(2)
+    expect(rendered.result()).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
           id: `3`,
@@ -227,7 +233,7 @@ describe(`Query Collections`, () => {
           id: `4`,
           name: `Kyle Doe 2`,
         }),
-      ])
+      ]),
     )
 
     // Delete the person
@@ -250,8 +256,8 @@ describe(`Query Collections`, () => {
     })
     expect(rendered.result.state.get(`4`)).toBeUndefined()
 
-    expect(rendered.result.data.length).toBe(1)
-    expect(rendered.result.data[0]).toMatchObject({
+    expect(rendered.result().length).toBe(1)
+    expect(rendered.result()[0]).toMatchObject({
       id: `3`,
       name: `John Smith`,
     })
@@ -264,7 +270,7 @@ describe(`Query Collections`, () => {
         id: `person-collection-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create issue collection
@@ -273,7 +279,7 @@ describe(`Query Collections`, () => {
         id: `issue-collection-test`,
         getKey: (issue: Issue) => issue.id,
         initialData: initialIssues,
-      })
+      }),
     )
 
     const { result } = renderHook(() => {
@@ -281,13 +287,13 @@ describe(`Query Collections`, () => {
         q
           .from({ issues: issueCollection })
           .join({ persons: personCollection }, ({ issues, persons }) =>
-            eq(issues.userId, persons.id)
+            eq(issues.userId, persons.id),
           )
           .select(({ issues, persons }) => ({
             id: issues.id,
             title: issues.title,
-            name: persons.name,
-          }))
+            name: persons?.name,
+          })),
       )
     })
 
@@ -373,11 +379,11 @@ describe(`Query Collections`, () => {
     })
     issueCollection.utils.commit()
 
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    // After deletion, issue 3 should no longer have a joined result
-    expect(result.state.get(`[3,1]`)).toBeUndefined()
-    expect(result.state.size).toBe(3)
+    await waitFor(() => {
+      // After deletion, issue 3 should no longer have a joined result
+      expect(result.state.get(`[3,1]`)).toBeUndefined()
+      expect(result.state.size).toBe(3)
+    })
   })
 
   it(`should recompile query when parameters change and change results`, async () => {
@@ -387,7 +393,7 @@ describe(`Query Collections`, () => {
           id: `params-change-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const [minAge, setMinAge] = createSignal(30)
@@ -401,10 +407,10 @@ describe(`Query Collections`, () => {
                 id: c.id,
                 name: c.name,
                 age: c.age,
-              }))
+              })),
           )
         },
-        { initialProps: [{ minAge: minAge }] }
+        { initialProps: [{ minAge: minAge }] },
       )
 
       // Wait for collection to sync
@@ -460,7 +466,7 @@ describe(`Query Collections`, () => {
           id: `stop-query-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const [minAge, setMinAge] = createSignal(30)
@@ -473,10 +479,10 @@ describe(`Query Collections`, () => {
               .select(({ collection: c }) => ({
                 id: c.id,
                 name: c.name,
-              }))
+              })),
           )
         },
-        { initialProps: [{ minAge }] }
+        { initialProps: [{ minAge }] },
       )
 
       // Wait for collection to sync
@@ -523,7 +529,7 @@ describe(`Query Collections`, () => {
         id: `optimistic-changes-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Initial query
@@ -537,7 +543,7 @@ describe(`Query Collections`, () => {
             name: c.name,
             team: c.team,
           }))
-          .orderBy(({ collection: c }) => c.id, `asc`)
+          .orderBy(({ collection: c }) => c.id, `asc`),
       )
     })
 
@@ -548,12 +554,12 @@ describe(`Query Collections`, () => {
     const groupedLiveQuery = renderHook(() => {
       return useLiveQuery((q) =>
         q
-          .from({ queryResult: rendered.result.collection() })
+          .from({ queryResult: rendered.result.collection })
           .groupBy(({ queryResult }) => queryResult.team)
           .select(({ queryResult }) => ({
             team: queryResult.team,
             count: count(queryResult.id),
-          }))
+          })),
       )
     })
 
@@ -628,7 +634,7 @@ describe(`Query Collections`, () => {
         id: `person-collection-test-bug`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create issue collection
@@ -637,7 +643,7 @@ describe(`Query Collections`, () => {
         id: `issue-collection-test-bug`,
         getKey: (issue: Issue) => issue.id,
         initialData: initialIssues,
-      })
+      }),
     )
 
     // Render the hook with a query that joins persons and issues
@@ -646,13 +652,13 @@ describe(`Query Collections`, () => {
         q
           .from({ issues: issueCollection })
           .join({ persons: personCollection }, ({ issues, persons }) =>
-            eq(issues.userId, persons.id)
+            eq(issues.userId, persons.id),
           )
           .select(({ issues, persons }) => ({
             id: issues.id,
             title: issues.title,
-            name: persons.name,
-          }))
+            name: persons?.name,
+          })),
       )
 
       // Track each render state
@@ -751,7 +757,8 @@ describe(`Query Collections`, () => {
 
     // Check if we had any render where the temp key was removed but the permanent key wasn't added yet
     const hadFlicker = renderStates.some(
-      (state) => !state.hasTempKey && !state.hasPermKey && state.stateSize === 3
+      (state) =>
+        !state.hasTempKey && !state.hasPermKey && state.stateSize === 3,
     )
 
     expect(hadFlicker).toBe(false)
@@ -772,7 +779,7 @@ describe(`Query Collections`, () => {
         id: `pre-created-collection-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create a live query collection beforehand
@@ -797,9 +804,9 @@ describe(`Query Collections`, () => {
     await waitFor(() => {
       expect(result.state.size).toBe(1) // Only John Smith (age 35)
     })
-    expect(result.data).toHaveLength(1)
+    expect(result()).toHaveLength(1)
 
-    const johnSmith = result.data[0]
+    const johnSmith = result()[0]
     expect(johnSmith).toMatchObject({
       id: `3`,
       name: `John Smith`,
@@ -807,7 +814,7 @@ describe(`Query Collections`, () => {
     })
 
     // Verify that the returned collection is the same instance
-    expect(result.collection()).toBe(liveQueryCollection)
+    expect(result.collection).toBe(liveQueryCollection)
   })
 
   it(`should switch to a different pre-created live query collection when changed`, async () => {
@@ -817,7 +824,7 @@ describe(`Query Collections`, () => {
           id: `collection-1`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const collection2 = createCollection(
@@ -842,7 +849,7 @@ describe(`Query Collections`, () => {
               team: `team3`,
             },
           ],
-        })
+        }),
       )
 
       // Create two different live query collections
@@ -875,7 +882,7 @@ describe(`Query Collections`, () => {
         (props: { collection: Accessor<any> }) => {
           return useLiveQuery(props.collection)
         },
-        { initialProps: [{ collection: collection }] }
+        { initialProps: [{ collection: collection }] },
       )
 
       // Wait for first collection to sync
@@ -886,7 +893,7 @@ describe(`Query Collections`, () => {
         id: `3`,
         name: `John Smith`,
       })
-      expect(rendered.result.collection()).toBe(liveQueryCollection1)
+      expect(rendered.result.collection).toBe(liveQueryCollection1)
 
       // Switch to the second collection
       setCollection(liveQueryCollection2)
@@ -903,7 +910,7 @@ describe(`Query Collections`, () => {
         id: `5`,
         name: `Bob Dylan`,
       })
-      expect(rendered.result.collection()).toBe(liveQueryCollection2)
+      expect(rendered.result.collection).toBe(liveQueryCollection2)
 
       // Verify we no longer have data from the first collection
       expect(rendered.result.state.get(`3`)).toBeUndefined()
@@ -918,7 +925,7 @@ describe(`Query Collections`, () => {
         id: `test-persons-config-querybuilder`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create a QueryBuilder instance beforehand
@@ -939,9 +946,9 @@ describe(`Query Collections`, () => {
     await waitFor(() => {
       expect(result.state.size).toBe(1) // Only John Smith (age 35)
     })
-    expect(result.data).toHaveLength(1)
+    expect(result()).toHaveLength(1)
 
-    const johnSmith = result.data[0]
+    const johnSmith = result()[0]
     expect(johnSmith).toMatchObject({
       id: `3`,
       name: `John Smith`,
@@ -982,12 +989,12 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
       // Initially isLoading should be true
-      expect(rendered.result.isLoading()).toBe(true)
+      expect(rendered.result.isLoading).toBe(true)
 
       // Start sync manually
       collection.preload()
@@ -1010,7 +1017,7 @@ describe(`Query Collections`, () => {
 
       // Wait for collection to become ready
       await waitFor(() => {
-        expect(rendered.result.isLoading()).toBe(false)
+        expect(rendered.result.isLoading).toBe(false)
       })
       // Note: Data may not appear immediately due to live query evaluation timing
       // The main test is that isLoading transitions from true to false
@@ -1022,7 +1029,7 @@ describe(`Query Collections`, () => {
           id: `pre-created-has-loaded-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       // Create a live query collection that's already syncing
@@ -1046,7 +1053,7 @@ describe(`Query Collections`, () => {
       })
 
       // For pre-created collections that are already syncing, isLoading should be true
-      expect(rendered.result.isLoading()).toBe(false)
+      expect(rendered.result.isLoading).toBe(false)
       expect(rendered.result.state.size).toBe(1)
     })
 
@@ -1080,12 +1087,12 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
       // Initially should be true
-      expect(rendered.result.isLoading()).toBe(true)
+      expect(rendered.result.isLoading).toBe(true)
 
       // Start sync manually
       collection.preload()
@@ -1109,14 +1116,14 @@ describe(`Query Collections`, () => {
 
       await new Promise((resolve) => setTimeout(resolve, 100))
 
-      expect(rendered.result.isLoading()).toBe(false)
-      expect(rendered.result.isReady()).toBe(true)
+      expect(rendered.result.isLoading).toBe(false)
+      expect(rendered.result.isReady).toBe(true)
 
       // Wait for collection to become ready
       await waitFor(() => {
-        expect(rendered.result.isLoading()).toBe(false)
+        expect(rendered.result.isLoading).toBe(false)
       })
-      expect(rendered.result.status()).toBe(`ready`)
+      expect(rendered.result.status).toBe(`ready`)
     })
 
     it(`should maintain isReady state during live updates`, async () => {
@@ -1125,7 +1132,7 @@ describe(`Query Collections`, () => {
           id: `live-updates-has-loaded-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const { result } = renderHook(() => {
@@ -1136,16 +1143,16 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
       // Wait for initial load
       await waitFor(() => {
-        expect(result.isLoading()).toBe(false)
+        expect(result.isLoading).toBe(false)
       })
 
-      const initialIsReady = result.isReady()
+      const initialIsReady = result.isReady
 
       // Perform live updates
       collection.utils.begin()
@@ -1168,8 +1175,8 @@ describe(`Query Collections`, () => {
       })
 
       // isReady should remain true during live updates
-      expect(result.isReady()).toBe(true)
-      expect(result.isReady()).toBe(initialIsReady)
+      expect(result.isReady).toBe(true)
+      expect(result.isReady).toBe(initialIsReady)
     })
 
     it(`should handle isLoading with complex queries including joins`, async () => {
@@ -1219,18 +1226,18 @@ describe(`Query Collections`, () => {
           q
             .from({ issues: issueCollection })
             .join({ persons: personCollection }, ({ issues, persons }) =>
-              eq(issues.userId, persons.id)
+              eq(issues.userId, persons.id),
             )
             .select(({ issues, persons }) => ({
               id: issues.id,
               title: issues.title,
-              name: persons.name,
-            }))
+              name: persons?.name,
+            })),
         )
       })
 
       // Initially should be true
-      expect(result.isLoading()).toBe(true)
+      expect(result.isLoading).toBe(true)
 
       // Start sync for both collections
       personCollection.preload()
@@ -1266,7 +1273,7 @@ describe(`Query Collections`, () => {
 
       // Wait for both collections to sync
       await waitFor(() => {
-        expect(result.isReady()).toBe(true)
+        expect(result.isReady).toBe(true)
       })
       // Note: Joined data may not appear immediately due to live query evaluation timing
       // The main test is that isLoading transitions from false to true
@@ -1306,14 +1313,14 @@ describe(`Query Collections`, () => {
                 .select(({ collection: c }) => ({
                   id: c.id,
                   name: c.name,
-                }))
+                })),
             )
           },
-          { initialProps: [{ minAge: minAge }] }
+          { initialProps: [{ minAge: minAge }] },
         )
 
         // Initially should be false
-        expect(result.isLoading()).toBe(true)
+        expect(result.isLoading).toBe(true)
 
         // Start sync manually
         collection.preload()
@@ -1344,7 +1351,7 @@ describe(`Query Collections`, () => {
 
         // Wait for initial load
         await waitFor(() => {
-          expect(result.isLoading()).toBe(false)
+          expect(result.isLoading).toBe(false)
         })
 
         // Change parameters
@@ -1352,7 +1359,7 @@ describe(`Query Collections`, () => {
 
         // isReady should remain true even when parameters change
         await waitFor(() => {
-          expect(result.isReady()).toBe(true)
+          expect(result.isReady).toBe(true)
         })
         // Note: Data size may not change immediately due to live query evaluation timing
         // The main test is that isReady remains true when parameters change
@@ -1394,14 +1401,14 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
       // Initially isLoading should be true
-      expect(result.isLoading()).toBe(true)
+      expect(result.isLoading).toBe(true)
       expect(result.state.size).toBe(0)
-      expect(result.data).toEqual([])
+      expect(result()).toEqual([])
 
       // Start sync manually
       collection.preload()
@@ -1409,7 +1416,7 @@ describe(`Query Collections`, () => {
       await new Promise((resolve) => setTimeout(resolve, 10))
 
       // Still loading
-      expect(result.isLoading()).toBe(true)
+      expect(result.isLoading).toBe(true)
 
       // Add first batch of data (but don't mark ready yet)
       syncBegin!()
@@ -1430,9 +1437,9 @@ describe(`Query Collections`, () => {
       await waitFor(() => {
         expect(result.state.size).toBe(1)
       })
-      expect(result.isLoading()).toBe(true) // Still loading
-      expect(result.data).toHaveLength(1)
-      expect(result.data[0]).toMatchObject({
+      expect(result.isLoading).toBe(true) // Still loading
+      expect(result()).toHaveLength(1)
+      expect(result()[0]).toMatchObject({
         id: `1`,
         name: `John Smith`,
       })
@@ -1456,18 +1463,18 @@ describe(`Query Collections`, () => {
       await waitFor(() => {
         expect(result.state.size).toBe(2)
       })
-      expect(result.isLoading()).toBe(true) // Still loading
-      expect(result.data).toHaveLength(2)
+      expect(result.isLoading).toBe(true) // Still loading
+      expect(result()).toHaveLength(2)
 
       // Now mark as ready
       syncMarkReady!()
 
       // Should now be ready
       await waitFor(() => {
-        expect(result.isLoading()).toBe(false)
+        expect(result.isLoading).toBe(false)
       })
       expect(result.state.size).toBe(2)
-      expect(result.data).toHaveLength(2)
+      expect(result()).toHaveLength(2)
     })
 
     it(`should show filtered results during sync with isLoading true`, async () => {
@@ -1502,7 +1509,7 @@ describe(`Query Collections`, () => {
               id: persons.id,
               name: persons.name,
               team: persons.team,
-            }))
+            })),
         )
       })
 
@@ -1511,7 +1518,7 @@ describe(`Query Collections`, () => {
 
       await new Promise((resolve) => setTimeout(resolve, 10))
 
-      expect(result.isLoading()).toBe(true)
+      expect(result.isLoading).toBe(true)
 
       // Add items from different teams
       syncBegin!()
@@ -1554,15 +1561,15 @@ describe(`Query Collections`, () => {
       await waitFor(() => {
         expect(result.state.size).toBe(2)
       })
-      expect(result.isLoading()).toBe(true)
-      expect(result.data).toHaveLength(2)
-      expect(result.data.every((p) => p.team === `team1`)).toBe(true)
+      expect(result.isLoading).toBe(true)
+      expect(result()).toHaveLength(2)
+      expect(result().every((p) => p.team === `team1`)).toBe(true)
 
       // Mark ready
       syncMarkReady!()
 
       await waitFor(() => {
-        expect(result.isLoading()).toBe(false)
+        expect(result.isLoading).toBe(false)
       })
       expect(result.state.size).toBe(2)
     })
@@ -1617,13 +1624,13 @@ describe(`Query Collections`, () => {
           q
             .from({ issues: issueCollection })
             .join({ persons: personCollection }, ({ issues, persons }) =>
-              eq(issues.userId, persons.id)
+              eq(issues.userId, persons.id),
             )
             .select(({ issues, persons }) => ({
               id: issues.id,
               title: issues.title,
-              userName: persons.name,
-            }))
+              userName: persons?.name,
+            })),
         )
       })
 
@@ -1633,7 +1640,7 @@ describe(`Query Collections`, () => {
 
       await new Promise((resolve) => setTimeout(resolve, 10))
 
-      expect(result.isLoading()).toBe(true)
+      expect(result.isLoading).toBe(true)
 
       // Add a person first
       userSyncBegin!()
@@ -1652,7 +1659,7 @@ describe(`Query Collections`, () => {
 
       await new Promise((resolve) => setTimeout(resolve, 10))
 
-      expect(result.isLoading()).toBe(true)
+      expect(result.isLoading).toBe(true)
       expect(result.state.size).toBe(0) // No joins yet
 
       // Add an issue for that person
@@ -1672,9 +1679,9 @@ describe(`Query Collections`, () => {
       await waitFor(() => {
         expect(result.state.size).toBe(1)
       })
-      expect(result.isLoading()).toBe(true)
-      expect(result.data).toHaveLength(1)
-      expect(result.data[0]).toMatchObject({
+      expect(result.isLoading).toBe(true)
+      expect(result()).toHaveLength(1)
+      expect(result()[0]).toMatchObject({
         id: `1`,
         title: `First Issue`,
         userName: `John Doe`,
@@ -1685,7 +1692,7 @@ describe(`Query Collections`, () => {
       issueSyncMarkReady!()
 
       await waitFor(() => {
-        expect(result.isLoading()).toBe(false)
+        expect(result.isLoading).toBe(false)
       })
       expect(result.state.size).toBe(1)
     })
@@ -1716,15 +1723,15 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
       })
 
       // Initially isLoading should be true
-      expect(result.isLoading()).toBe(true)
-      expect(result.isReady()).toBe(false)
+      expect(result.isLoading).toBe(true)
+      expect(result.isReady).toBe(false)
       expect(result.state.size).toBe(0)
-      expect(result.data).toEqual([])
+      expect(result()).toEqual([])
 
       // Start sync manually
       collection.preload()
@@ -1732,20 +1739,222 @@ describe(`Query Collections`, () => {
       await new Promise((resolve) => setTimeout(resolve, 10))
 
       // Still loading
-      expect(result.isLoading()).toBe(true)
-      expect(result.isReady()).toBe(false)
+      expect(result.isLoading).toBe(true)
+      expect(result.isReady).toBe(false)
 
       // Mark ready without any data commits
       syncMarkReady!()
 
       // Should now be ready, even with no data
       await waitFor(() => {
-        expect(result.isReady()).toBe(true)
+        expect(result.isReady).toBe(true)
       })
-      expect(result.isLoading()).toBe(false)
+      expect(result.isLoading).toBe(false)
       expect(result.state.size).toBe(0) // Still no data
-      expect(result.data).toEqual([]) // Empty array
-      expect(result.status()).toBe(`ready`)
+      expect(result()).toEqual([]) // Empty array
+      expect(result.status).toBe(`ready`)
+    })
+  })
+
+  describe(`Disabled queries`, () => {
+    it(`should handle callback returning undefined with proper state`, async () => {
+      return createRoot(async (dispose) => {
+        const collection = createCollection(
+          mockSyncCollectionOptions<Person>({
+            id: `disabled-undefined-test`,
+            getKey: (person: Person) => person.id,
+            initialData: initialPersons,
+          }),
+        )
+
+        const [enabled, setEnabled] = createSignal(false)
+        const rendered = renderHook(
+          (props: { enabled: Accessor<boolean> }) => {
+            return useLiveQuery((q) => {
+              if (!props.enabled()) return undefined
+              return q
+                .from({ collection })
+                .where(({ collection: c }) => gt(c.age, 30))
+                .select(({ collection: c }) => ({
+                  id: c.id,
+                  name: c.name,
+                  age: c.age,
+                }))
+            })
+          },
+          { initialProps: [{ enabled }] },
+        )
+
+        // When callback returns undefined, should return disabled state
+        expect(rendered.result.state.size).toBe(0)
+        expect(rendered.result.data).toEqual([])
+        expect(rendered.result.collection).toBeNull()
+        expect(rendered.result.status).toBe(`disabled`)
+        expect(rendered.result.isLoading).toBe(false)
+        expect(rendered.result.isReady).toBe(true)
+
+        // Enable the query
+        setEnabled(true)
+        await new Promise((resolve) => setTimeout(resolve, 10))
+
+        await waitFor(() => {
+          expect(rendered.result.state.size).toBe(1) // Only John Smith (age 35)
+        })
+        expect(rendered.result.data).toHaveLength(1)
+        expect(rendered.result.isReady).toBe(true)
+
+        // Disable the query again
+        setEnabled(false)
+        await new Promise((resolve) => setTimeout(resolve, 10))
+
+        expect(rendered.result.status).toBe(`disabled`)
+        expect(rendered.result.isReady).toBe(true)
+
+        dispose()
+      })
+    })
+
+    it(`should handle callback returning null with proper state`, async () => {
+      return createRoot(async (dispose) => {
+        const collection = createCollection(
+          mockSyncCollectionOptions<Person>({
+            id: `disabled-null-test`,
+            getKey: (person: Person) => person.id,
+            initialData: initialPersons,
+          }),
+        )
+
+        const [enabled, setEnabled] = createSignal(false)
+        const rendered = renderHook(
+          (props: { enabled: Accessor<boolean> }) => {
+            return useLiveQuery((q) => {
+              if (!props.enabled()) return null
+              return q
+                .from({ collection })
+                .where(({ collection: c }) => gt(c.age, 30))
+                .select(({ collection: c }) => ({
+                  id: c.id,
+                  name: c.name,
+                  age: c.age,
+                }))
+            })
+          },
+          { initialProps: [{ enabled }] },
+        )
+
+        // When callback returns null, should return disabled state
+        expect(rendered.result.state.size).toBe(0)
+        expect(rendered.result.data).toEqual([])
+        expect(rendered.result.collection).toBeNull()
+        expect(rendered.result.status).toBe(`disabled`)
+        expect(rendered.result.isLoading).toBe(false)
+        expect(rendered.result.isReady).toBe(true)
+
+        // Enable the query
+        setEnabled(true)
+        await new Promise((resolve) => setTimeout(resolve, 10))
+
+        await waitFor(() => {
+          expect(rendered.result.state.size).toBe(1)
+        })
+        expect(rendered.result.data).toHaveLength(1)
+        expect(rendered.result.isReady).toBe(true)
+
+        dispose()
+      })
+    })
+  })
+
+  describe(`Suspense Integration`, () => {
+    it(`should work with Suspense boundaries`, async () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `test-persons-suspense`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      function TestComponent() {
+        const query = useLiveQuery((q) =>
+          q.from({ persons: collection }).select(({ persons }) => ({
+            id: persons.id,
+            name: persons.name,
+          })),
+        )
+
+        return (
+          <ul data-testid="list">
+            <For each={query()}>
+              {(person) => (
+                <li data-testid={`person-${person.id}`}>{person.name}</li>
+              )}
+            </For>
+          </ul>
+        )
+      }
+
+      const { findByTestId } = render(() => (
+        <Suspense fallback={<div data-testid="loading">Loading...</div>}>
+          <TestComponent />
+        </Suspense>
+      ))
+
+      // Should eventually show the list with data
+      await waitFor(async () => {
+        const list = await findByTestId(`list`)
+        expect(list).toBeTruthy()
+      })
+
+      // Verify data is rendered
+      const person1 = await findByTestId(`person-1`)
+      expect(person1.textContent).toBe(`John Doe`)
+
+      const person2 = await findByTestId(`person-2`)
+      expect(person2.textContent).toBe(`Jane Doe`)
+
+      const person3 = await findByTestId(`person-3`)
+      expect(person3.textContent).toBe(`John Smith`)
+    })
+
+    it(`should show fallback during loading and data after ready`, async () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `test-persons-suspense-fallback`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      function TestComponent() {
+        const query = useLiveQuery((q) =>
+          q.from({ persons: collection }).select(({ persons }) => ({
+            id: persons.id,
+            name: persons.name,
+          })),
+        )
+
+        return (
+          <div data-testid="content">
+            <span data-testid="count">{query().length}</span>
+          </div>
+        )
+      }
+
+      const { findByTestId } = render(() => (
+        <Suspense fallback={<div data-testid="loading">Loading...</div>}>
+          <TestComponent />
+        </Suspense>
+      ))
+
+      // Should eventually resolve and show data
+      await waitFor(async () => {
+        const content = await findByTestId(`content`)
+        expect(content).toBeTruthy()
+      })
+
+      const count = await findByTestId(`count`)
+      expect(count.textContent).toBe(`3`)
     })
   })
 })
diff --git a/packages/solid-db/vite.config.ts b/packages/solid-db/vite.config.ts
index 043716caa..aa8d1d9f3 100644
--- a/packages/solid-db/vite.config.ts
+++ b/packages/solid-db/vite.config.ts
@@ -1,7 +1,7 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import solidPlugin from "vite-plugin-solid"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import solidPlugin from 'vite-plugin-solid'
+import packageJson from './package.json'
 
 const config = defineConfig({
   plugins: [solidPlugin()],
@@ -21,5 +21,5 @@ export default mergeConfig(
     entry: `./src/index.ts`,
     srcDir: `./src`,
     cjs: false,
-  })
+  }),
 )
diff --git a/packages/svelte-db/CHANGELOG.md b/packages/svelte-db/CHANGELOG.md
index 34b1c1211..2034f6bf5 100644
--- a/packages/svelte-db/CHANGELOG.md
+++ b/packages/svelte-db/CHANGELOG.md
@@ -1,5 +1,307 @@
 # @tanstack/svelte-db
 
+## 0.1.67
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 0.1.66
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 0.1.65
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 0.1.64
+
+### Patch Changes
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 0.1.63
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 0.1.62
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 0.1.61
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 0.1.60
+
+### Patch Changes
+
+- Add `findOne()` / `SingleResult` support to `useLiveQuery` hook. ([#1001](https://github.com/TanStack/db/pull/1001))
+
+  When using `.findOne()` in a query, the `data` property is now correctly typed as `T | undefined` instead of `Array<T>`, matching the React implementation.
+
+  **Example:**
+
+  ```ts
+  const query = useLiveQuery((q) =>
+    q
+      .from({ users: usersCollection })
+      .where(({ users }) => eq(users.id, userId))
+      .findOne(),
+  )
+
+  // query.data is now typed as User | undefined (not User[])
+  ```
+
+  This works with all query patterns:
+  - Query functions: `useLiveQuery((q) => q.from(...).findOne())`
+  - Config objects: `useLiveQuery({ query: (q) => q.from(...).findOne() })`
+  - Pre-created collections with `SingleResult`
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 0.1.59
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 0.1.58
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 0.1.57
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 0.1.56
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 0.1.55
+
+### Patch Changes
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 0.1.54
+
+### Patch Changes
+
+- Fixed `isReady` to return `true` for disabled queries in `useLiveQuery`/`injectLiveQuery` across all framework packages. When a query function returns `null` or `undefined` (disabling the query), there's no async operation to wait for, so the hook should be considered "ready" immediately. ([#886](https://github.com/TanStack/db/pull/886))
+
+  Additionally, all frameworks now have proper TypeScript overloads that explicitly support returning `undefined | null` from query functions, making the disabled query pattern type-safe.
+
+  This fixes the common pattern where users conditionally enable queries and don't want to show loading states when the query is disabled.
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 0.1.53
+
+### Patch Changes
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/db@0.5.10
+
+## 0.1.52
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+
+## 0.1.51
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+
+## 0.1.50
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+
+## 0.1.49
+
+### Patch Changes
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 0.1.48
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 0.1.47
+
+### Patch Changes
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 0.1.46
+
+### Patch Changes
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 0.1.45
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+
+## 0.1.44
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 0.1.43
+
+### Patch Changes
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.1.42
+
+### Patch Changes
+
+- Fix flushSync error in Svelte 5 async compiler mode ([#745](https://github.com/TanStack/db/pull/745))
+
+  Previously, `useLiveQuery` threw an error when Svelte 5's async compiler mode was enabled:
+
+  ```
+  Uncaught Svelte error: flush_sync_in_effect
+  Cannot use flushSync inside an effect
+  ```
+
+  This occurred because `flushSync()` was called inside the `onFirstReady` callback, which executes within a `$effect` block. Svelte 5's async compiler enforces a strict rule that `flushSync()` cannot be called inside effects, as documented at svelte.dev/e/flush_sync_in_effect.
+
+  **The Fix:**
+
+  Removed the unnecessary `flushSync()` call from the `onFirstReady` callback. Svelte 5's reactivity system automatically propagates state changes without needing synchronous flushing. This matches the pattern already used in Vue's implementation.
+
+  **Compatibility:**
+  - ✅ For users WITHOUT async mode (current default): Works as before
+  - ✅ For users WITH async mode: Now works instead of throwing error
+  - ✅ Future-proof: async mode will be default in Svelte 6
+  - ✅ All 23 existing tests pass, confirming no regression
+
+  **How to enable async mode:**
+
+  ```javascript
+  // svelte.config.js
+  export default {
+    compilerOptions: {
+      experimental: {
+        async: true,
+      },
+    },
+  }
+  ```
+
+  Fixes #744
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.1.41
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.1.40
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.1.39
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+
+## 0.1.38
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+
+## 0.1.37
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+
+## 0.1.36
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+
+## 0.1.35
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+
+## 0.1.34
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+
 ## 0.1.33
 
 ### Patch Changes
diff --git a/packages/svelte-db/package.json b/packages/svelte-db/package.json
index 09fc9d7ca..26951cb2c 100644
--- a/packages/svelte-db/package.json
+++ b/packages/svelte-db/package.json
@@ -1,52 +1,55 @@
 {
   "name": "@tanstack/svelte-db",
+  "version": "0.1.67",
   "description": "Svelte integration for @tanstack/db",
-  "version": "0.1.33",
-  "dependencies": {
-    "@tanstack/db": "workspace:*"
+  "author": "Kyle Mathews",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/db.git",
+    "directory": "packages/svelte-db"
   },
-  "devDependencies": {
-    "@sveltejs/package": "^2.5.4",
-    "@sveltejs/vite-plugin-svelte": "^6.2.1",
-    "@vitest/coverage-istanbul": "^3.2.4",
-    "publint": "^0.3.14",
-    "svelte": "^5.41.0",
-    "svelte-check": "^4.3.3"
+  "homepage": "https://tanstack.com/db",
+  "keywords": [
+    "optimistic",
+    "svelte",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "svelte-package --input ./src --output ./dist --tsconfig ./tsconfig.build.json",
+    "lint": "eslint . --fix",
+    "test": "vitest --run",
+    "test:types": "svelte-check --tsconfig ./tsconfig.json"
   },
+  "type": "module",
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "svelte": "./dist/index.js"
     }
   },
+  "sideEffects": [
+    "**/*.css"
+  ],
   "files": [
     "dist",
     "!dist/**/*.test.*",
     "!dist/**/*.spec.*"
   ],
-  "keywords": [
-    "optimistic",
-    "svelte",
-    "typescript"
-  ],
+  "dependencies": {
+    "@tanstack/db": "workspace:*"
+  },
   "peerDependencies": {
     "svelte": "^5.0.0"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/TanStack/db.git",
-    "directory": "packages/svelte-db"
-  },
-  "scripts": {
-    "build": "svelte-package --input ./src --output ./dist --tsconfig ./tsconfig.build.json",
-    "lint": "eslint . --fix",
-    "test": "npx vitest --run",
-    "test:types": "svelte-check --tsconfig ./tsconfig.json"
-  },
-  "sideEffects": [
-    "**/*.css"
-  ],
-  "svelte": "./dist/index.js",
-  "type": "module",
-  "types": "./dist/index.d.ts"
+  "devDependencies": {
+    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "publint": "^0.3.16",
+    "svelte": "^5.46.1",
+    "svelte-check": "^4.3.5"
+  }
 }
diff --git a/packages/svelte-db/src/index.ts b/packages/svelte-db/src/index.ts
index 0e460625d..a07f98a64 100644
--- a/packages/svelte-db/src/index.ts
+++ b/packages/svelte-db/src/index.ts
@@ -1,9 +1,9 @@
 // Re-export all public APIs
-export * from "./useLiveQuery.svelte.js"
+export * from './useLiveQuery.svelte.js'
 
 // Re-export everything from @tanstack/db
-export * from "@tanstack/db"
+export * from '@tanstack/db'
 
 // Re-export some stuff explicitly to ensure the type & value is exported
-export type { Collection } from "@tanstack/db"
-export { createTransaction } from "@tanstack/db"
+export type { Collection } from '@tanstack/db'
+export { createTransaction } from '@tanstack/db'
diff --git a/packages/svelte-db/src/useLiveQuery.svelte.ts b/packages/svelte-db/src/useLiveQuery.svelte.ts
index 4c3625fdc..76dedd3c7 100644
--- a/packages/svelte-db/src/useLiveQuery.svelte.ts
+++ b/packages/svelte-db/src/useLiveQuery.svelte.ts
@@ -1,23 +1,27 @@
 // eslint-disable-next-line import/no-duplicates -- See https://github.com/un-ts/eslint-plugin-import-x/issues/308
-import { flushSync, untrack } from "svelte"
+import { untrack } from 'svelte'
 // eslint-disable-next-line import/no-duplicates -- See https://github.com/un-ts/eslint-plugin-import-x/issues/308
-import { SvelteMap } from "svelte/reactivity"
-import { createLiveQueryCollection } from "@tanstack/db"
+import { SvelteMap } from 'svelte/reactivity'
+import { BaseQueryBuilder, createLiveQueryCollection } from '@tanstack/db'
 import type {
   ChangeMessage,
   Collection,
+  CollectionConfigSingleRowOption,
   CollectionStatus,
   Context,
   GetResult,
+  InferResultType,
   InitialQueryBuilder,
   LiveQueryCollectionConfig,
+  NonSingleResult,
   QueryBuilder,
-} from "@tanstack/db"
+  SingleResult,
+} from '@tanstack/db'
 
 /**
  * Return type for useLiveQuery hook
  * @property state - Reactive Map of query results (key → item)
- * @property data - Reactive array of query results in order
+ * @property data - Reactive array of query results in order, or single item when using findOne()
  * @property collection - The underlying query collection instance
  * @property status - Current query status
  * @property isLoading - True while initial query data is loading
@@ -26,9 +30,9 @@ import type {
  * @property isError - True when query encountered an error
  * @property isCleanedUp - True when query has been cleaned up
  */
-export interface UseLiveQueryReturn<T extends object> {
+export interface UseLiveQueryReturn<T extends object, TData = Array<T>> {
   state: Map<string | number, T>
-  data: Array<T>
+  data: TData
   collection: Collection<T, string | number, {}>
   status: CollectionStatus
   isLoading: boolean
@@ -42,9 +46,10 @@ export interface UseLiveQueryReturnWithCollection<
   T extends object,
   TKey extends string | number,
   TUtils extends Record<string, any>,
+  TData = Array<T>,
 > {
   state: Map<TKey, T>
-  data: Array<T>
+  data: TData
   collection: Collection<T, TKey, TUtils>
   status: CollectionStatus
   isLoading: boolean
@@ -68,13 +73,38 @@ function toValue<T>(value: MaybeGetter<T>): T {
  * @param queryFn - Query function that defines what data to fetch
  * @param deps - Array of reactive dependencies that trigger query re-execution when changed
  * @returns Reactive object with query data, state, and status information
+ *
+ * @remarks
+ * **IMPORTANT - Destructuring in Svelte 5:**
+ * Direct destructuring breaks reactivity. To destructure, wrap with `$derived`:
+ *
+ * ❌ **Incorrect** - Loses reactivity:
+ * ```ts
+ * const { data, isLoading } = useLiveQuery(...)
+ * ```
+ *
+ * ✅ **Correct** - Maintains reactivity:
+ * ```ts
+ * // Option 1: Use dot notation (recommended)
+ * const query = useLiveQuery(...)
+ * // Access: query.data, query.isLoading
+ *
+ * // Option 2: Wrap with $derived for destructuring
+ * const query = useLiveQuery(...)
+ * const { data, isLoading } = $derived(query)
+ * ```
+ *
+ * This is a fundamental Svelte 5 limitation, not a library bug. See:
+ * https://github.com/sveltejs/svelte/issues/11002
+ *
  * @example
- * // Basic query with object syntax
+ * // Basic query with object syntax (recommended pattern)
  * const todosQuery = useLiveQuery((q) =>
  *   q.from({ todos: todosCollection })
  *    .where(({ todos }) => eq(todos.completed, false))
  *    .select(({ todos }) => ({ id: todos.id, text: todos.text }))
  * )
+ * // Access via: todosQuery.data, todosQuery.isLoading, etc.
  *
  * @example
  * // With reactive dependencies
@@ -86,6 +116,14 @@ function toValue<T>(value: MaybeGetter<T>): T {
  * )
  *
  * @example
+ * // Destructuring with $derived (if needed)
+ * const query = useLiveQuery((q) =>
+ *   q.from({ todos: todosCollection })
+ * )
+ * const { data, isLoading, isError } = $derived(query)
+ * // Now data, isLoading, and isError maintain reactivity
+ *
+ * @example
  * // Join pattern
  * const issuesQuery = useLiveQuery((q) =>
  *   q.from({ issues: issueCollection })
@@ -118,11 +156,22 @@ function toValue<T>(value: MaybeGetter<T>): T {
  * //   </ul>
  * // {/if}
  */
-// Overload 1: Accept just the query function
+// Overload 1: Accept query function that always returns QueryBuilder
 export function useLiveQuery<TContext extends Context>(
   queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,
-  deps?: Array<() => unknown>
-): UseLiveQueryReturn<GetResult<TContext>>
+  deps?: Array<() => unknown>,
+): UseLiveQueryReturn<GetResult<TContext>, InferResultType<TContext>>
+
+// Overload 1b: Accept query function that can return undefined/null
+export function useLiveQuery<TContext extends Context>(
+  queryFn: (
+    q: InitialQueryBuilder,
+  ) => QueryBuilder<TContext> | undefined | null,
+  deps?: Array<() => unknown>,
+): UseLiveQueryReturn<
+  GetResult<TContext>,
+  InferResultType<TContext> | undefined
+>
 
 /**
  * Create a live query using configuration object
@@ -164,8 +213,8 @@ export function useLiveQuery<TContext extends Context>(
 // Overload 2: Accept config object
 export function useLiveQuery<TContext extends Context>(
   config: LiveQueryCollectionConfig<TContext>,
-  deps?: Array<() => unknown>
-): UseLiveQueryReturn<GetResult<TContext>>
+  deps?: Array<() => unknown>,
+): UseLiveQueryReturn<GetResult<TContext>, InferResultType<TContext>>
 
 /**
  * Subscribe to an existing query collection (can be reactive)
@@ -210,19 +259,32 @@ export function useLiveQuery<TContext extends Context>(
  * //   {/each}
  * // {/if}
  */
-// Overload 3: Accept pre-created live query collection (can be reactive)
+// Overload 3: Accept pre-created live query collection WITHOUT SingleResult (returns array)
+export function useLiveQuery<
+  TResult extends object,
+  TKey extends string | number,
+  TUtils extends Record<string, any>,
+>(
+  liveQueryCollection: MaybeGetter<
+    Collection<TResult, TKey, TUtils> & NonSingleResult
+  >,
+): UseLiveQueryReturnWithCollection<TResult, TKey, TUtils, Array<TResult>>
+
+// Overload 4: Accept pre-created live query collection WITH SingleResult (returns single item)
 export function useLiveQuery<
   TResult extends object,
   TKey extends string | number,
   TUtils extends Record<string, any>,
 >(
-  liveQueryCollection: MaybeGetter<Collection<TResult, TKey, TUtils>>
-): UseLiveQueryReturnWithCollection<TResult, TKey, TUtils>
+  liveQueryCollection: MaybeGetter<
+    Collection<TResult, TKey, TUtils> & SingleResult
+  >,
+): UseLiveQueryReturnWithCollection<TResult, TKey, TUtils, TResult | undefined>
 
 // Implementation
 export function useLiveQuery(
   configOrQueryOrCollection: any,
-  deps: Array<() => unknown> = []
+  deps: Array<() => unknown> = [],
 ): UseLiveQueryReturn<any> | UseLiveQueryReturnWithCollection<any, any, any> {
   const collection = $derived.by(() => {
     // First check if the original parameter might be a getter
@@ -247,6 +309,20 @@ export function useLiveQuery(
       typeof unwrappedParam.id === `string`
 
     if (isCollection) {
+      // Warn when passing a collection directly with on-demand sync mode
+      // In on-demand mode, data is only loaded when queries with predicates request it
+      // Passing the collection directly doesn't provide any predicates, so no data loads
+      const syncMode = (unwrappedParam as { config?: { syncMode?: string } })
+        .config?.syncMode
+      if (syncMode === `on-demand`) {
+        console.warn(
+          `[useLiveQuery] Warning: Passing a collection with syncMode "on-demand" directly to useLiveQuery ` +
+            `will not load any data. In on-demand mode, data is only loaded when queries with predicates request it.\n\n` +
+            `Instead, use a query builder function:\n` +
+            `  const { data } = useLiveQuery((q) => q.from({ c: myCollection }).select(({ c }) => c))\n\n` +
+            `Or switch to syncMode "eager" if you want all data to sync automatically.`,
+        )
+      }
       // It's already a collection, ensure sync is started for Svelte helpers
       // Only start sync if the collection is in idle state
       if (unwrappedParam.status === `idle`) {
@@ -260,6 +336,15 @@ export function useLiveQuery(
 
     // Ensure we always start sync for Svelte helpers
     if (typeof unwrappedParam === `function`) {
+      // Check if query function returns null/undefined (disabled query)
+      const queryBuilder = new BaseQueryBuilder() as InitialQueryBuilder
+      const result = unwrappedParam(queryBuilder)
+
+      if (result === undefined || result === null) {
+        // Disabled query - return null
+        return null
+      }
+
       return createLiveQueryCollection({
         query: unwrappedParam,
         startSync: true,
@@ -279,11 +364,11 @@ export function useLiveQuery(
   let internalData = $state<Array<any>>([])
 
   // Track collection status reactively
-  let status = $state(collection.status)
+  let status = $state(collection ? collection.status : (`disabled` as const))
 
   // Helper to sync data array from collection in correct order
   const syncDataFromCollection = (
-    currentCollection: Collection<any, any, any>
+    currentCollection: Collection<any, any, any>,
   ) => {
     untrack(() => {
       internalData = []
@@ -298,6 +383,20 @@ export function useLiveQuery(
   $effect(() => {
     const currentCollection = collection
 
+    // Handle null collection (disabled query)
+    if (!currentCollection) {
+      status = `disabled` as const
+      untrack(() => {
+        state.clear()
+        internalData = []
+      })
+      if (currentUnsubscribe) {
+        currentUnsubscribe()
+        currentUnsubscribe = null
+      }
+      return
+    }
+
     // Update status state whenever the effect runs
     status = currentCollection.status
 
@@ -320,10 +419,9 @@ export function useLiveQuery(
     // Listen for the first ready event to catch status transitions
     // that might not trigger change events (fixes async status transition bug)
     currentCollection.onFirstReady(() => {
-      // Use flushSync to ensure Svelte reactivity updates properly
-      flushSync(() => {
-        status = currentCollection.status
-      })
+      // Update status directly - Svelte's reactivity system handles the update automatically
+      // Note: We cannot use flushSync here as it's disallowed inside effects in async mode
+      status = currentCollection.status
     })
 
     // Subscribe to collection changes with granular updates
@@ -351,7 +449,7 @@ export function useLiveQuery(
       },
       {
         includeInitialState: true,
-      }
+      },
     )
 
     currentUnsubscribe = subscription.unsubscribe.bind(subscription)
@@ -375,6 +473,18 @@ export function useLiveQuery(
       return state
     },
     get data() {
+      const currentCollection = collection
+      if (currentCollection) {
+        const config =
+          currentCollection.config as CollectionConfigSingleRowOption<
+            any,
+            any,
+            any
+          >
+        if (config.singleResult) {
+          return internalData[0]
+        }
+      }
       return internalData
     },
     get collection() {
@@ -387,7 +497,7 @@ export function useLiveQuery(
       return status === `loading`
     },
     get isReady() {
-      return status === `ready`
+      return status === `ready` || status === `disabled`
     },
     get isIdle() {
       return status === `idle`
diff --git a/packages/svelte-db/svelte.config.js b/packages/svelte-db/svelte.config.js
index af7d74ea4..94ca454ac 100644
--- a/packages/svelte-db/svelte.config.js
+++ b/packages/svelte-db/svelte.config.js
@@ -1,4 +1,4 @@
-import { vitePreprocess } from "@sveltejs/vite-plugin-svelte"
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'
 
 const config = {
   preprocess: vitePreprocess(),
diff --git a/packages/svelte-db/tests/useLiveQuery.svelte.test.ts b/packages/svelte-db/tests/useLiveQuery.svelte.test.ts
index 5916c9da0..cb16e8579 100644
--- a/packages/svelte-db/tests/useLiveQuery.svelte.test.ts
+++ b/packages/svelte-db/tests/useLiveQuery.svelte.test.ts
@@ -1,14 +1,14 @@
-import { afterEach, describe, expect, it } from "vitest"
+import { afterEach, describe, expect, it } from 'vitest'
 import {
   count,
   createCollection,
   createLiveQueryCollection,
   eq,
   gt,
-} from "@tanstack/db"
-import { flushSync } from "svelte"
-import { useLiveQuery } from "../src/useLiveQuery.svelte.js"
-import { mockSyncCollectionOptions } from "../../db/tests/utils"
+} from '@tanstack/db'
+import { flushSync } from 'svelte'
+import { useLiveQuery } from '../src/useLiveQuery.svelte.js'
+import { mockSyncCollectionOptions } from '../../db/tests/utils'
 
 type Person = {
   id: string
@@ -87,7 +87,7 @@ describe(`Query Collections`, () => {
         id: `test-persons`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     cleanup = $effect.root(() => {
@@ -99,7 +99,7 @@ describe(`Query Collections`, () => {
             id: persons.id,
             name: persons.name,
             age: persons.age,
-          }))
+          })),
       )
 
       flushSync()
@@ -116,13 +116,103 @@ describe(`Query Collections`, () => {
     })
   })
 
+  it(`should maintain reactivity when destructuring return values with $derived`, () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-destructure`,
+        getKey: (person: Person) => person.id,
+        initialData: initialPersons,
+      }),
+    )
+
+    cleanup = $effect.root(() => {
+      // IMPORTANT: In Svelte 5, destructuring breaks reactivity unless wrapped in $derived
+      // This is the correct pattern for destructuring (Issue #414)
+      const query = useLiveQuery((q) =>
+        q
+          .from({ persons: collection })
+          .where(({ persons }) => gt(persons.age, 30))
+          .select(({ persons }) => ({
+            id: persons.id,
+            name: persons.name,
+            age: persons.age,
+          })),
+      )
+
+      // Destructure using $derived to maintain reactivity
+      const { data, state, isReady, isLoading } = $derived(query)
+
+      flushSync()
+
+      // Initial state checks
+      expect(isReady).toBe(true)
+      expect(isLoading).toBe(false)
+      expect(state.size).toBe(1)
+      expect(data).toHaveLength(1)
+      expect(data[0]).toMatchObject({
+        id: `3`,
+        name: `John Smith`,
+        age: 35,
+      })
+
+      // Add a new person that matches the filter
+      collection.utils.begin()
+      collection.utils.write({
+        type: `insert`,
+        value: {
+          id: `4`,
+          name: `Alice Johnson`,
+          age: 40,
+          email: `alice.johnson@example.com`,
+          isActive: true,
+          team: `team1`,
+        },
+      })
+      collection.utils.commit()
+
+      flushSync()
+
+      // Verify destructured values are still reactive after collection change
+      expect(state.size).toBe(2)
+      expect(data).toHaveLength(2)
+      expect(data.some((p) => p.id === `4`)).toBe(true)
+      expect(data.some((p) => p.id === `3`)).toBe(true)
+
+      // Remove a person
+      collection.utils.begin()
+      collection.utils.write({
+        type: `delete`,
+        value: {
+          id: `3`,
+          name: `John Smith`,
+          age: 35,
+          email: `john.smith@example.com`,
+          isActive: true,
+          team: `team1`,
+        },
+      })
+      collection.utils.commit()
+
+      flushSync()
+
+      // Verify destructured values still track changes
+      expect(state.size).toBe(1)
+      expect(data).toHaveLength(1)
+      expect(data[0]).toMatchObject({
+        id: `4`,
+        name: `Alice Johnson`,
+        age: 40,
+      })
+    })
+  })
+
   it(`should be able to query a collection with live updates`, () => {
     const collection = createCollection(
       mockSyncCollectionOptions<Person>({
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     cleanup = $effect.root(() => {
@@ -134,7 +224,7 @@ describe(`Query Collections`, () => {
             id: c.id,
             name: c.name,
           }))
-          .orderBy(({ collection: c }) => c.id, `asc`)
+          .orderBy(({ collection: c }) => c.id, `asc`),
       )
 
       // Wait for collection to sync
@@ -190,7 +280,7 @@ describe(`Query Collections`, () => {
             id: `4`,
             name: `Kyle Doe`,
           }),
-        ])
+        ]),
       )
 
       // Update the person
@@ -227,7 +317,7 @@ describe(`Query Collections`, () => {
             id: `4`,
             name: `Kyle Doe 2`,
           }),
-        ])
+        ]),
       )
 
       // Delete the person
@@ -265,7 +355,7 @@ describe(`Query Collections`, () => {
         id: `person-collection-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     cleanup = $effect.root(() => {
@@ -275,20 +365,20 @@ describe(`Query Collections`, () => {
           id: `issue-collection-test`,
           getKey: (issue: Issue) => issue.id,
           initialData: initialIssues,
-        })
+        }),
       )
 
       const query = useLiveQuery((q) =>
         q
           .from({ issues: issueCollection })
           .join({ persons: personCollection }, ({ issues, persons }) =>
-            eq(issues.userId, persons.id)
+            eq(issues.userId, persons.id),
           )
           .select(({ issues, persons }) => ({
             id: issues.id,
             title: issues.title,
             name: persons.name,
-          }))
+          })),
       )
 
       // Wait for collections to sync
@@ -386,7 +476,7 @@ describe(`Query Collections`, () => {
         id: `params-change-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     cleanup = $effect.root(() => {
@@ -402,7 +492,7 @@ describe(`Query Collections`, () => {
               name: c.name,
               age: c.age,
             })),
-        [() => minAge]
+        [() => minAge],
       )
 
       // Wait for collection to sync
@@ -455,7 +545,7 @@ describe(`Query Collections`, () => {
         id: `optimistic-changes-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     cleanup = $effect.root(() => {
@@ -469,7 +559,7 @@ describe(`Query Collections`, () => {
             name: c.name,
             team: c.team,
           }))
-          .orderBy(({ collection: c }) => c.id, `asc`)
+          .orderBy(({ collection: c }) => c.id, `asc`),
       )
 
       // Wait for collection to sync
@@ -483,7 +573,7 @@ describe(`Query Collections`, () => {
           .select(({ queryResult }) => ({
             team: queryResult.team,
             count: count(queryResult.id),
-          }))
+          })),
       )
 
       // Wait for grouped query to sync
@@ -550,7 +640,7 @@ describe(`Query Collections`, () => {
         id: `person-collection-test-bug`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create issue collection
@@ -559,7 +649,7 @@ describe(`Query Collections`, () => {
         id: `issue-collection-test-bug`,
         getKey: (issue: Issue) => issue.id,
         initialData: initialIssues,
-      })
+      }),
     )
 
     cleanup = $effect.root(() => {
@@ -568,13 +658,13 @@ describe(`Query Collections`, () => {
         q
           .from({ issues: issueCollection })
           .join({ persons: personCollection }, ({ issues, persons }) =>
-            eq(issues.userId, persons.id)
+            eq(issues.userId, persons.id),
           )
           .select(({ issues, persons }) => ({
             id: issues.id,
             title: issues.title,
             name: persons.name,
-          }))
+          })),
       )
 
       // Wait for collections to sync and verify initial state
@@ -613,7 +703,7 @@ describe(`Query Collections`, () => {
         id: `pre-created-collection-test-vue`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     cleanup = $effect.root(() => {
@@ -657,7 +747,7 @@ describe(`Query Collections`, () => {
         id: `collection-1-vue`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const collection2 = createCollection(
@@ -682,7 +772,7 @@ describe(`Query Collections`, () => {
             team: `team3`,
           },
         ],
-      })
+      }),
     )
 
     cleanup = $effect.root(() => {
@@ -779,7 +869,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
 
         // Initially isReady should be false (collection is in idle state)
@@ -817,7 +907,7 @@ describe(`Query Collections`, () => {
           id: `pre-created-is-ready-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       cleanup = $effect.root(() => {
@@ -904,7 +994,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
 
         expect(query.isReady).toBe(false)
@@ -957,7 +1047,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
 
         // Initially should be true
@@ -1001,7 +1091,7 @@ describe(`Query Collections`, () => {
           id: `live-updates-is-ready-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       cleanup = $effect.root(() => {
@@ -1012,7 +1102,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
 
         flushSync()
@@ -1083,13 +1173,13 @@ describe(`Query Collections`, () => {
           q
             .from({ issues: issueCollection })
             .join({ persons: personCollection }, ({ issues, persons }) =>
-              eq(issues.userId, persons.id)
+              eq(issues.userId, persons.id),
             )
             .select(({ issues, persons }) => ({
               id: issues.id,
               title: issues.title,
               name: persons.name,
-            }))
+            })),
         )
 
         expect(query.isReady).toBe(false)
@@ -1158,7 +1248,7 @@ describe(`Query Collections`, () => {
                 id: c.id,
                 name: c.name,
               })),
-          [() => minAge]
+          [() => minAge],
         )
 
         expect(query.isReady).toBe(false)
@@ -1222,7 +1312,7 @@ describe(`Query Collections`, () => {
             .select(({ collection: c }) => ({
               id: c.id,
               name: c.name,
-            }))
+            })),
         )
 
         // Initially should be loading
@@ -1256,6 +1346,91 @@ describe(`Query Collections`, () => {
         expect(query.status).toBe(`ready`)
       })
     })
+
+    it(`should reactively trigger effects when status changes`, () => {
+      let beginFn: (() => void) | undefined
+      let commitFn: (() => void) | undefined
+      let markReadyFn: (() => void) | undefined
+
+      const collection = createCollection<Person>({
+        id: `reactive-status-test`,
+        getKey: (person: Person) => person.id,
+        startSync: false,
+        sync: {
+          sync: ({ begin, commit, markReady }) => {
+            beginFn = begin
+            commitFn = commit
+            markReadyFn = markReady
+          },
+        },
+        onInsert: () => Promise.resolve(),
+        onUpdate: () => Promise.resolve(),
+        onDelete: () => Promise.resolve(),
+      })
+
+      cleanup = $effect.root(() => {
+        const query = useLiveQuery((q) =>
+          q
+            .from({ collection })
+            .where(({ collection: c }) => gt(c.age, 30))
+            .select(({ collection: c }) => ({
+              id: c.id,
+              name: c.name,
+            })),
+        )
+
+        let readyEffectCount = 0
+        let loadingEffectCount = 0
+        let lastReadyValue: boolean | undefined
+        let lastLoadingValue: boolean | undefined
+
+        // This effect should re-run whenever query.isReady changes
+        $effect(() => {
+          readyEffectCount++
+          lastReadyValue = query.isReady
+        })
+
+        // This effect should re-run whenever query.isLoading changes
+        $effect(() => {
+          loadingEffectCount++
+          lastLoadingValue = query.isLoading
+        })
+
+        flushSync()
+
+        // Initial execution
+        expect(readyEffectCount).toBe(1)
+        expect(loadingEffectCount).toBe(1)
+        expect(lastReadyValue).toBe(false)
+        expect(lastLoadingValue).toBe(true)
+
+        // Start sync and mark ready
+        collection.preload()
+        if (beginFn && commitFn && markReadyFn) {
+          beginFn()
+          commitFn()
+          markReadyFn()
+        }
+
+        // Insert data
+        collection.insert({
+          id: `1`,
+          name: `John Doe`,
+          age: 35,
+          email: `john.doe@example.com`,
+          isActive: true,
+          team: `team1`,
+        })
+
+        flushSync()
+
+        // Effects should have re-executed due to reactive status change
+        expect(readyEffectCount).toBeGreaterThan(1)
+        expect(loadingEffectCount).toBeGreaterThan(1)
+        expect(lastReadyValue).toBe(true)
+        expect(lastLoadingValue).toBe(false)
+      })
+    })
   })
 
   it(`should accept config object with pre-built QueryBuilder instance`, async () => {
@@ -1264,7 +1439,7 @@ describe(`Query Collections`, () => {
         id: `config-querybuilder-test-vue`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { Query } = await import(`@tanstack/db`)
@@ -1331,7 +1506,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
 
         // Initially isLoading should be true
@@ -1437,7 +1612,7 @@ describe(`Query Collections`, () => {
               id: persons.id,
               name: persons.name,
               team: persons.team,
-            }))
+            })),
         )
 
         // Start sync
@@ -1550,13 +1725,13 @@ describe(`Query Collections`, () => {
           q
             .from({ issues: issueCollection })
             .join({ persons: personCollection }, ({ issues, persons }) =>
-              eq(issues.userId, persons.id)
+              eq(issues.userId, persons.id),
             )
             .select(({ issues, persons }) => ({
               id: issues.id,
               title: issues.title,
               userName: persons.name,
-            }))
+            })),
         )
 
         // Start sync for both
@@ -1647,7 +1822,7 @@ describe(`Query Collections`, () => {
             .select(({ persons }) => ({
               id: persons.id,
               name: persons.name,
-            }))
+            })),
         )
 
         // Initially isLoading should be true
@@ -1677,4 +1852,221 @@ describe(`Query Collections`, () => {
       })
     })
   })
+
+  describe(`findOne() - single result queries`, () => {
+    it(`should return a single row when using findOne() with query function`, () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `test-persons-findone-1`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      cleanup = $effect.root(() => {
+        const query = useLiveQuery((q) =>
+          q
+            .from({ collection })
+            .where(({ collection: c }) => eq(c.id, `3`))
+            .findOne(),
+        )
+
+        flushSync()
+
+        // State should still contain the item as a Map entry
+        expect(query.state.size).toBe(1)
+        expect(query.state.get(`3`)).toMatchObject({
+          id: `3`,
+          name: `John Smith`,
+        })
+
+        // Data should be a single object, not an array
+        expect(query.data).toMatchObject({
+          id: `3`,
+          name: `John Smith`,
+        })
+        expect(Array.isArray(query.data)).toBe(false)
+      })
+    })
+
+    it(`should return a single row when using findOne() with config object`, () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `test-persons-findone-2`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      cleanup = $effect.root(() => {
+        const query = useLiveQuery({
+          query: (q) =>
+            q
+              .from({ collection })
+              .where(({ collection: c }) => eq(c.id, `3`))
+              .findOne(),
+        })
+
+        flushSync()
+
+        expect(query.state.size).toBe(1)
+        expect(query.data).toMatchObject({
+          id: `3`,
+          name: `John Smith`,
+        })
+        expect(Array.isArray(query.data)).toBe(false)
+      })
+    })
+
+    it(`should return a single row with pre-created collection using findOne()`, () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `test-persons-findone-3`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      cleanup = $effect.root(() => {
+        const liveQueryCollection = createLiveQueryCollection({
+          query: (q) =>
+            q
+              .from({ collection })
+              .where(({ collection: c }) => eq(c.id, `3`))
+              .findOne(),
+        })
+
+        const query = useLiveQuery(liveQueryCollection)
+
+        flushSync()
+
+        expect(query.state.size).toBe(1)
+        expect(query.data).toMatchObject({
+          id: `3`,
+          name: `John Smith`,
+        })
+        expect(Array.isArray(query.data)).toBe(false)
+      })
+    })
+
+    it(`should return undefined when findOne() matches no rows`, () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `test-persons-findone-empty`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      cleanup = $effect.root(() => {
+        const query = useLiveQuery((q) =>
+          q
+            .from({ collection })
+            .where(({ collection: c }) => eq(c.id, `999`)) // Non-existent ID
+            .findOne(),
+        )
+
+        flushSync()
+
+        expect(query.state.size).toBe(0)
+        expect(query.data).toBeUndefined()
+      })
+    })
+
+    it(`should reactively update single result when data changes`, () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `test-persons-findone-reactive`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      cleanup = $effect.root(() => {
+        const query = useLiveQuery((q) =>
+          q
+            .from({ collection })
+            .where(({ collection: c }) => eq(c.id, `3`))
+            .findOne(),
+        )
+
+        flushSync()
+
+        expect(query.data).toMatchObject({
+          id: `3`,
+          name: `John Smith`,
+        })
+
+        // Update the person
+        collection.utils.begin()
+        collection.utils.write({
+          type: `update`,
+          value: {
+            id: `3`,
+            name: `John Smith Updated`,
+            age: 36,
+            email: `john.smith@example.com`,
+            isActive: true,
+            team: `team1`,
+          },
+        })
+        collection.utils.commit()
+
+        flushSync()
+
+        expect(query.data).toMatchObject({
+          id: `3`,
+          name: `John Smith Updated`,
+          age: 36,
+        })
+        expect(Array.isArray(query.data)).toBe(false)
+      })
+    })
+
+    it(`should transition from single result to undefined when item is deleted`, () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `test-persons-findone-delete`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      cleanup = $effect.root(() => {
+        const query = useLiveQuery((q) =>
+          q
+            .from({ collection })
+            .where(({ collection: c }) => eq(c.id, `3`))
+            .findOne(),
+        )
+
+        flushSync()
+
+        expect(query.data).toMatchObject({
+          id: `3`,
+          name: `John Smith`,
+        })
+
+        // Delete the person
+        collection.utils.begin()
+        collection.utils.write({
+          type: `delete`,
+          value: {
+            id: `3`,
+            name: `John Smith`,
+            age: 35,
+            email: `john.smith@example.com`,
+            isActive: true,
+            team: `team1`,
+          },
+        })
+        collection.utils.commit()
+
+        flushSync()
+
+        expect(query.data).toBeUndefined()
+        expect(query.state.size).toBe(0)
+      })
+    })
+  })
 })
diff --git a/packages/svelte-db/tsconfig.json b/packages/svelte-db/tsconfig.json
index fc534e3d5..58906938a 100644
--- a/packages/svelte-db/tsconfig.json
+++ b/packages/svelte-db/tsconfig.json
@@ -1,7 +1,6 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "types": ["svelte"],
     "target": "ES2020",
     "module": "ESNext",
     "moduleResolution": "Bundler",
diff --git a/packages/svelte-db/vite.config.ts b/packages/svelte-db/vite.config.ts
index c8adb39f8..eb445e040 100644
--- a/packages/svelte-db/vite.config.ts
+++ b/packages/svelte-db/vite.config.ts
@@ -1,6 +1,6 @@
-import { svelte } from "@sveltejs/vite-plugin-svelte"
-import { defineConfig } from "vitest/config"
-import packageJson from "./package.json" with { type: "json" }
+import { svelte } from '@sveltejs/vite-plugin-svelte'
+import { defineConfig } from 'vitest/config'
+import packageJson from './package.json' with { type: 'json' }
 
 export default defineConfig({
   plugins: [svelte()],
diff --git a/packages/trailbase-db-collection/CHANGELOG.md b/packages/trailbase-db-collection/CHANGELOG.md
index 62ca3a17b..0bf9cfe14 100644
--- a/packages/trailbase-db-collection/CHANGELOG.md
+++ b/packages/trailbase-db-collection/CHANGELOG.md
@@ -1,5 +1,251 @@
 # @tanstack/trailbase-db-collection
 
+## 0.1.68
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 0.1.67
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 0.1.66
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 0.1.65
+
+### Patch Changes
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 0.1.64
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 0.1.63
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 0.1.62
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 0.1.61
+
+### Patch Changes
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 0.1.60
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 0.1.59
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 0.1.58
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 0.1.57
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 0.1.56
+
+### Patch Changes
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 0.1.55
+
+### Patch Changes
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 0.1.54
+
+### Patch Changes
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/db@0.5.10
+
+## 0.1.53
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+
+## 0.1.52
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+
+## 0.1.51
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+
+## 0.1.50
+
+### Patch Changes
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 0.1.49
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 0.1.48
+
+### Patch Changes
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 0.1.47
+
+### Patch Changes
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 0.1.46
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+
+## 0.1.45
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 0.1.44
+
+### Patch Changes
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.1.43
+
+### Patch Changes
+
+- Trigger new release for trailbase-db-collection
+
+  Version 0.1.42 was already published to npm. This changeset bumps the version to 0.1.43 to allow for a new release.
+
+## 0.1.42
+
+### Patch Changes
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.1.41
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.1.40
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.1.39
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+
+## 0.1.38
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+
+## 0.1.37
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+
+## 0.1.36
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+
+## 0.1.35
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+
+## 0.1.34
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+
 ## 0.1.33
 
 ### Patch Changes
@@ -319,7 +565,7 @@
   try {
     collection.insert(data)
   } catch (error) {
-    if (error.message.includes("already exists")) {
+    if (error.message.includes('already exists')) {
       // Handle duplicate key error
     }
   }
@@ -328,7 +574,7 @@
   **After:**
 
   ```ts
-  import { DuplicateKeyError } from "@tanstack/db"
+  import { DuplicateKeyError } from '@tanstack/db'
 
   try {
     collection.insert(data)
@@ -345,14 +591,14 @@
 
   ```ts
   // Electric collection errors were imported from @tanstack/db
-  import { ElectricInsertHandlerMustReturnTxIdError } from "@tanstack/db"
+  import { ElectricInsertHandlerMustReturnTxIdError } from '@tanstack/db'
   ```
 
   **After:**
 
   ```ts
   // Now import from the specific adapter package
-  import { ElectricInsertHandlerMustReturnTxIdError } from "@tanstack/electric-db-collection"
+  import { ElectricInsertHandlerMustReturnTxIdError } from '@tanstack/electric-db-collection'
   ```
 
   ### Unified Error Handling
@@ -360,14 +606,14 @@
   **New:**
 
   ```ts
-  import { TanStackDBError } from "@tanstack/db"
+  import { TanStackDBError } from '@tanstack/db'
 
   try {
     // Any TanStack DB operation
   } catch (error) {
     if (error instanceof TanStackDBError) {
       // Handle all TanStack DB errors uniformly
-      console.log("TanStack DB error:", error.message)
+      console.log('TanStack DB error:', error.message)
     }
   }
   ```
diff --git a/packages/trailbase-db-collection/package.json b/packages/trailbase-db-collection/package.json
index 83c301d46..b4c478440 100644
--- a/packages/trailbase-db-collection/package.json
+++ b/packages/trailbase-db-collection/package.json
@@ -1,18 +1,31 @@
 {
   "name": "@tanstack/trailbase-db-collection",
+  "version": "0.1.68",
   "description": "TrailBase collection for TanStack DB",
-  "version": "0.1.33",
-  "dependencies": {
-    "@standard-schema/spec": "^1.0.0",
-    "@tanstack/db": "workspace:*",
-    "@tanstack/store": "^0.8.0",
-    "debug": "^4.4.3",
-    "trailbase": "^0.8.0"
+  "author": "Sebastian Jeltsch",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/db.git",
+    "directory": "packages/trailbase-db-collection"
   },
-  "devDependencies": {
-    "@types/debug": "^4.1.12",
-    "@vitest/coverage-istanbul": "^3.2.4"
+  "homepage": "https://tanstack.com/db",
+  "keywords": [
+    "trailbase",
+    "sql",
+    "optimistic",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "lint": "eslint . --fix",
+    "test": "vitest --run"
   },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -26,37 +39,23 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
-  "packageManager": "pnpm@10.18.3",
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "@tanstack/db": "workspace:*",
+    "@tanstack/store": "^0.8.0",
+    "debug": "^4.4.3",
+    "trailbase": "^0.8.0"
+  },
   "peerDependencies": {
     "typescript": ">=4.7"
   },
-  "author": "Sebastian Jeltsch",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/TanStack/db.git",
-    "directory": "packages/trailbase-db-collection"
-  },
-  "homepage": "https://tanstack.com/db",
-  "keywords": [
-    "trailbase",
-    "sql",
-    "optimistic",
-    "typescript"
-  ],
-  "scripts": {
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "lint": "eslint . --fix",
-    "test": "npx vitest --run"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@vitest/coverage-istanbul": "^3.2.4"
+  }
 }
diff --git a/packages/trailbase-db-collection/src/errors.ts b/packages/trailbase-db-collection/src/errors.ts
index a158ca933..ece48fcad 100644
--- a/packages/trailbase-db-collection/src/errors.ts
+++ b/packages/trailbase-db-collection/src/errors.ts
@@ -1,4 +1,4 @@
-import { TanStackDBError } from "@tanstack/db"
+import { TanStackDBError } from '@tanstack/db'
 
 // TrailBase DB Collection Errors
 export class TrailBaseDBCollectionError extends TanStackDBError {
diff --git a/packages/trailbase-db-collection/src/index.ts b/packages/trailbase-db-collection/src/index.ts
index 43dff974f..81c4593a7 100644
--- a/packages/trailbase-db-collection/src/index.ts
+++ b/packages/trailbase-db-collection/src/index.ts
@@ -2,6 +2,6 @@ export {
   trailBaseCollectionOptions,
   type TrailBaseCollectionConfig,
   type TrailBaseCollectionUtils,
-} from "./trailbase"
+} from './trailbase'
 
-export * from "./errors"
+export * from './errors'
diff --git a/packages/trailbase-db-collection/src/trailbase.ts b/packages/trailbase-db-collection/src/trailbase.ts
index 391928834..32b6755c5 100644
--- a/packages/trailbase-db-collection/src/trailbase.ts
+++ b/packages/trailbase-db-collection/src/trailbase.ts
@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-import { Store } from "@tanstack/store"
+import { Store } from '@tanstack/store'
 import {
   ExpectedDeleteTypeError,
   ExpectedInsertTypeError,
   ExpectedUpdateTypeError,
   TimeoutWaitingForIdsError,
-} from "./errors"
-import type { Event, RecordApi } from "trailbase"
+} from './errors'
+import type { Event, RecordApi } from 'trailbase'
 
 import type {
   BaseCollectionConfig,
@@ -16,7 +16,7 @@ import type {
   SyncConfig,
   UpdateMutationFnParams,
   UtilsRecord,
-} from "@tanstack/db"
+} from '@tanstack/db'
 
 type ShapeOf<T> = Record<keyof T, unknown>
 type Conversion<I, O> = (value: I) => O
@@ -52,7 +52,7 @@ function convert<
   OutputType extends ShapeOf<InputType>,
 >(
   conversions: Conversions<InputType, OutputType>,
-  input: InputType
+  input: InputType,
 ): OutputType {
   const c = conversions as Record<string, Conversion<InputType, OutputType>>
 
@@ -60,7 +60,7 @@ function convert<
     Object.keys(input).map((k: string) => {
       const value = input[k]
       return [k, c[k]?.(value as any) ?? value]
-    })
+    }),
   ) as OutputType
 }
 
@@ -69,7 +69,7 @@ function convertPartial<
   OutputType extends ShapeOf<InputType>,
 >(
   conversions: Conversions<InputType, OutputType>,
-  input: Partial<InputType>
+  input: Partial<InputType>,
 ): Partial<OutputType> {
   const c = conversions as Record<string, Conversion<InputType, OutputType>>
 
@@ -77,7 +77,7 @@ function convertPartial<
     Object.keys(input).map((k: string) => {
       const value = input[k]
       return [k, c[k]?.(value as any) ?? value]
-    })
+    }),
   ) as OutputType
 }
 
@@ -89,9 +89,9 @@ export interface TrailBaseCollectionConfig<
   TRecord extends ShapeOf<TItem> = TItem,
   TKey extends string | number = string | number,
 > extends Omit<
-    BaseCollectionConfig<TItem, TKey>,
-    `onInsert` | `onUpdate` | `onDelete`
-  > {
+  BaseCollectionConfig<TItem, TKey>,
+  `onInsert` | `onUpdate` | `onDelete`
+> {
   /**
    * Record API name
    */
@@ -112,7 +112,7 @@ export function trailBaseCollectionOptions<
   TRecord extends ShapeOf<TItem> = TItem,
   TKey extends string | number = string | number,
 >(
-  config: TrailBaseCollectionConfig<TItem, TRecord, TKey>
+  config: TrailBaseCollectionConfig<TItem, TRecord, TKey>,
 ): CollectionConfig<TItem, TKey> & { utils: TrailBaseCollectionUtils } {
   const getKey = config.getKey
 
@@ -127,7 +127,7 @@ export function trailBaseCollectionOptions<
 
   const awaitIds = (
     ids: Array<string>,
-    timeout: number = 120 * 1000
+    timeout: number = 120 * 1000,
   ): Promise<void> => {
     const completed = (value: Map<string, number>) =>
       ids.every((id) => value.has(id))
@@ -295,7 +295,7 @@ export function trailBaseCollectionOptions<
     sync,
     getKey,
     onInsert: async (
-      params: InsertMutationFnParams<TItem, TKey>
+      params: InsertMutationFnParams<TItem, TKey>,
     ): Promise<Array<number | string>> => {
       const ids = await config.recordApi.createBulk(
         params.transaction.mutations.map((tx) => {
@@ -304,7 +304,7 @@ export function trailBaseCollectionOptions<
             throw new ExpectedInsertTypeError(type)
           }
           return serialIns(modified)
-        })
+        }),
       )
 
       // The optimistic mutation overlay is removed on return, so at this point
@@ -325,7 +325,7 @@ export function trailBaseCollectionOptions<
           await config.recordApi.update(key, serialUpd(changes))
 
           return String(key)
-        })
+        }),
       )
 
       // The optimistic mutation overlay is removed on return, so at this point
@@ -343,7 +343,7 @@ export function trailBaseCollectionOptions<
 
           await config.recordApi.delete(key)
           return String(key)
-        })
+        }),
       )
 
       // The optimistic mutation overlay is removed on return, so at this point
diff --git a/packages/trailbase-db-collection/tests/trailbase.test.ts b/packages/trailbase-db-collection/tests/trailbase.test.ts
index bfec08cb4..f59605394 100644
--- a/packages/trailbase-db-collection/tests/trailbase.test.ts
+++ b/packages/trailbase-db-collection/tests/trailbase.test.ts
@@ -1,13 +1,22 @@
-import { describe, expect, it, vi } from "vitest"
-import { createCollection } from "@tanstack/db"
-import { trailBaseCollectionOptions } from "../src/trailbase"
+import { describe, expect, it, vi } from 'vitest'
+import { createCollection } from '@tanstack/db'
+import { trailBaseCollectionOptions } from '../src/trailbase'
 import type {
+  CreateOperation,
+  DeleteOperation,
   Event,
   FilterOrComposite,
+  ListOperation,
+  ListOpts,
   ListResponse,
   Pagination,
+  ReadOperation,
+  ReadOpts,
   RecordApi,
-} from "trailbase"
+  RecordId,
+  SubscribeOpts,
+  UpdateOperation,
+} from 'trailbase'
 
 type Data = {
   id: number | null
@@ -25,19 +34,25 @@ class MockRecordApi<T> implements RecordApi<T> {
       expand?: Array<string>
     }): Promise<ListResponse<T>> => {
       return Promise.resolve({ records: [] })
-    }
+    },
   )
+  listOp = vi.fn((_opts?: ListOpts): ListOperation<T> => {
+    throw `listOp`
+  })
 
   read = vi.fn(
     (
       _id: string | number,
       _opt?: {
         expand?: Array<string>
-      }
+      },
     ): Promise<T> => {
       throw `read`
-    }
+    },
   )
+  readOp = vi.fn((_id: RecordId, _opt?: ReadOpts): ReadOperation<T> => {
+    throw `readOp`
+  })
 
   create = vi.fn((_record: T): Promise<string | number> => {
     throw `create`
@@ -45,22 +60,38 @@ class MockRecordApi<T> implements RecordApi<T> {
   createBulk = vi.fn((_records: Array<T>): Promise<Array<string | number>> => {
     throw `createBulk`
   })
+  createOp = vi.fn((_record: T): CreateOperation<T> => {
+    throw `createOp`
+  })
 
   update = vi.fn((_id: string | number, _record: Partial<T>): Promise<void> => {
     throw `update`
   })
+  updateOp = vi.fn((_id: RecordId, _record: Partial<T>): UpdateOperation => {
+    throw `updateOp`
+  })
+
   delete = vi.fn((_id: string | number): Promise<void> => {
     throw `delete`
   })
+  deleteOp = vi.fn((_id: RecordId): DeleteOperation => {
+    throw `deleteOp`
+  })
+
   subscribe = vi.fn((_id: string | number): Promise<ReadableStream<Event>> => {
     return Promise.resolve(
       new ReadableStream({
         start: (controller: ReadableStreamDefaultController<Event>) => {
           controller.close()
         },
-      })
+      }),
     )
   })
+  subscribeAll = vi.fn(
+    (_opts?: SubscribeOpts): Promise<ReadableStream<Event>> => {
+      throw `subscribeAll`
+    },
+  )
 }
 
 function setUp(recordApi: MockRecordApi<Data>) {
@@ -124,7 +155,7 @@ describe(`TrailBase Integration`, () => {
     await injectEvent({ Update: updatedRecord })
 
     expect(collection.state).toEqual(
-      new Map([updatedRecord].map((d) => [d.id, d]))
+      new Map([updatedRecord].map((d) => [d.id, d])),
     )
 
     // Await cancellation.
@@ -196,7 +227,7 @@ describe(`TrailBase Integration`, () => {
         }, 1)
 
         return Promise.resolve(records.map((r) => r.id ?? 0))
-      }
+      },
     )
 
     const options = setUp(recordApi)
@@ -231,7 +262,7 @@ describe(`TrailBase Integration`, () => {
         })
         writer.releaseLock()
         return Promise.resolve()
-      }
+      },
     )
 
     collection.update(data.id, (old: Data) => {
@@ -250,7 +281,7 @@ describe(`TrailBase Integration`, () => {
         })
         writer.releaseLock()
         return Promise.resolve()
-      }
+      },
     )
 
     collection.delete(updatedData.id!)
diff --git a/packages/trailbase-db-collection/vite.config.ts b/packages/trailbase-db-collection/vite.config.ts
index c7968f28a..aa589f666 100644
--- a/packages/trailbase-db-collection/vite.config.ts
+++ b/packages/trailbase-db-collection/vite.config.ts
@@ -1,6 +1,6 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import packageJson from './package.json'
 
 const config = defineConfig({
   test: {
@@ -17,5 +17,5 @@ export default mergeConfig(
   tanstackViteConfig({
     entry: `./src/index.ts`,
     srcDir: `./src`,
-  })
+  }),
 )
diff --git a/packages/vue-db/CHANGELOG.md b/packages/vue-db/CHANGELOG.md
index 10421f8c7..32452fd6d 100644
--- a/packages/vue-db/CHANGELOG.md
+++ b/packages/vue-db/CHANGELOG.md
@@ -1,5 +1,255 @@
 # @tanstack/vue-db
 
+## 0.0.101
+
+### Patch Changes
+
+- Updated dependencies [[`7099459`](https://github.com/TanStack/db/commit/7099459291810b237a9fb24bbfe6e543852a2ab2)]:
+  - @tanstack/db@0.5.24
+
+## 0.0.100
+
+### Patch Changes
+
+- Updated dependencies [[`05130f2`](https://github.com/TanStack/db/commit/05130f2420eb682f11f099310a0af87afa3f35fe)]:
+  - @tanstack/db@0.5.23
+
+## 0.0.99
+
+### Patch Changes
+
+- Updated dependencies [[`f9b741e`](https://github.com/TanStack/db/commit/f9b741e9fb636be1c9f1502b7e28fe691bae2480)]:
+  - @tanstack/db@0.5.22
+
+## 0.0.98
+
+### Patch Changes
+
+- Updated dependencies [[`6745ed0`](https://github.com/TanStack/db/commit/6745ed003dc25cfd6fa0f7e60f708205a6069ff2), [`1b22e40`](https://github.com/TanStack/db/commit/1b22e40c56323cfa5e7f759272fed53320aa32f7), [`7a2cacd`](https://github.com/TanStack/db/commit/7a2cacd7a426530cb77844a8c2680f6b06e9ce2f), [`bdf9405`](https://github.com/TanStack/db/commit/bdf94059e7ab98b5181e0df7d8d25cd1dbb5ae58)]:
+  - @tanstack/db@0.5.21
+
+## 0.0.97
+
+### Patch Changes
+
+- Fix type of findOne queries in Vue such that they type to a singular result instead of an array of results. ([#1134](https://github.com/TanStack/db/pull/1134))
+
+## 0.0.96
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tanstack/db@0.5.20
+
+## 0.0.95
+
+### Patch Changes
+
+- Updated dependencies [[`29033b8`](https://github.com/TanStack/db/commit/29033b8f55b0ba5721371ad761037ec813440aa7), [`888ad6a`](https://github.com/TanStack/db/commit/888ad6afe5932b0467320c04fbd4583469cb9c47)]:
+  - @tanstack/db@0.5.19
+
+## 0.0.94
+
+### Patch Changes
+
+- Updated dependencies [[`c1247e8`](https://github.com/TanStack/db/commit/c1247e816950314da6d201613481577834c1d97a)]:
+  - @tanstack/db@0.5.18
+
+## 0.0.93
+
+### Patch Changes
+
+- Updated dependencies [[`f795a67`](https://github.com/TanStack/db/commit/f795a674f21659ef46ff370d4f3b9903a596bcaf), [`d542667`](https://github.com/TanStack/db/commit/d542667a3440415d8e6cbb449b20abd3cbd6855c), [`6503c09`](https://github.com/TanStack/db/commit/6503c091a259208331f471dca29abf086e881147), [`b1cc4a7`](https://github.com/TanStack/db/commit/b1cc4a7e018ffb6804ae7f1c99e9c6eb4bb22812)]:
+  - @tanstack/db@0.5.17
+
+## 0.0.92
+
+### Patch Changes
+
+- Updated dependencies [[`41308b8`](https://github.com/TanStack/db/commit/41308b8ee914aa467e22842cd454f06d1a60032e)]:
+  - @tanstack/db@0.5.16
+
+## 0.0.91
+
+### Patch Changes
+
+- Updated dependencies [[`32ec4d8`](https://github.com/TanStack/db/commit/32ec4d8478cca96f76f3a49efc259c95b85baa40)]:
+  - @tanstack/db@0.5.15
+
+## 0.0.90
+
+### Patch Changes
+
+- Updated dependencies [[`26ed0aa`](https://github.com/TanStack/db/commit/26ed0aad2def60e652508a99b2e980e73f70148e)]:
+  - @tanstack/db@0.5.14
+
+## 0.0.89
+
+### Patch Changes
+
+- Updated dependencies [[`8ed7725`](https://github.com/TanStack/db/commit/8ed7725514a6a501482a391162f7792aa8b371e5), [`01452bf`](https://github.com/TanStack/db/commit/01452bfd0d00da8bd52941a4954af73749473651)]:
+  - @tanstack/db@0.5.13
+
+## 0.0.88
+
+### Patch Changes
+
+- Updated dependencies [[`b3b1940`](https://github.com/TanStack/db/commit/b3b194000d8efcc2c6cc45a663029dadc26f13f0), [`09da081`](https://github.com/TanStack/db/commit/09da081b420fc915d7f0dc566c6cdbbc78582435), [`86ad40c`](https://github.com/TanStack/db/commit/86ad40c6bc37b2f5d4ad24d06f72168ca4b96161)]:
+  - @tanstack/db@0.5.12
+
+## 0.0.87
+
+### Patch Changes
+
+- Fixed `isReady` to return `true` for disabled queries in `useLiveQuery`/`injectLiveQuery` across all framework packages. When a query function returns `null` or `undefined` (disabling the query), there's no async operation to wait for, so the hook should be considered "ready" immediately. ([#886](https://github.com/TanStack/db/pull/886))
+
+  Additionally, all frameworks now have proper TypeScript overloads that explicitly support returning `undefined | null` from query functions, making the disabled query pattern type-safe.
+
+  This fixes the common pattern where users conditionally enable queries and don't want to show loading states when the query is disabled.
+
+- Updated dependencies [[`c4b9399`](https://github.com/TanStack/db/commit/c4b93997432743d974749683059bf68a082d3e5b), [`a1a484e`](https://github.com/TanStack/db/commit/a1a484ec4d2331d702ab9c4b7e5b02622c76b3dd)]:
+  - @tanstack/db@0.5.11
+
+## 0.0.86
+
+### Patch Changes
+
+- Updated dependencies [[`1d19d22`](https://github.com/TanStack/db/commit/1d19d2219cbbaef6483845df1c3b078077e4e3bd), [`b3e4e80`](https://github.com/TanStack/db/commit/b3e4e80c4b73d96c15391ac25efb518c7ae7ccbb)]:
+  - @tanstack/db@0.5.10
+
+## 0.0.85
+
+### Patch Changes
+
+- Updated dependencies [[`5f474f1`](https://github.com/TanStack/db/commit/5f474f1eabd57e144ba05b0f33d848f7efc8fb07)]:
+  - @tanstack/db@0.5.9
+
+## 0.0.84
+
+### Patch Changes
+
+- Updated dependencies [[`954c8fe`](https://github.com/TanStack/db/commit/954c8fed5ed92a348ac8b6d8333bc69c955f4f60), [`51c73aa`](https://github.com/TanStack/db/commit/51c73aaa2b27b27966edb98fb6664beb44eac1ac)]:
+  - @tanstack/db@0.5.8
+
+## 0.0.83
+
+### Patch Changes
+
+- Updated dependencies [[`295cb45`](https://github.com/TanStack/db/commit/295cb45797572b232650eddd3d62ffa937fa2fd7)]:
+  - @tanstack/db@0.5.7
+
+## 0.0.82
+
+### Patch Changes
+
+- Updated dependencies [[`c8a2c16`](https://github.com/TanStack/db/commit/c8a2c16aa528427d5ddd55cda4ee59a5cb369b5f)]:
+  - @tanstack/db@0.5.6
+
+## 0.0.81
+
+### Patch Changes
+
+- Updated dependencies [[`077fc1a`](https://github.com/TanStack/db/commit/077fc1a418ca090d7533115888c09f3f609e36b2)]:
+  - @tanstack/db@0.5.5
+
+## 0.0.80
+
+### Patch Changes
+
+- Updated dependencies [[`acb3e4f`](https://github.com/TanStack/db/commit/acb3e4f1441e6872ca577e74d92ae2d77deb5938), [`464805d`](https://github.com/TanStack/db/commit/464805d96bad6d0fd741e48fbfc98e90dc58bebe), [`2c2e4db`](https://github.com/TanStack/db/commit/2c2e4dbd781d278347d73373f66d3c51c6388116), [`15c772f`](https://github.com/TanStack/db/commit/15c772f5e42e49000a2d775fd8e4cfda3418243f)]:
+  - @tanstack/db@0.5.4
+
+## 0.0.79
+
+### Patch Changes
+
+- Updated dependencies [[`846a830`](https://github.com/TanStack/db/commit/846a8309a243197245f4400a5d53cef5cec6d5d9), [`8e26dcf`](https://github.com/TanStack/db/commit/8e26dcfde600e4a18cd51fbe524560d60ab98d70)]:
+  - @tanstack/db@0.5.3
+
+## 0.0.78
+
+### Patch Changes
+
+- Updated dependencies [[`99a3716`](https://github.com/TanStack/db/commit/99a371630b9f4632db86c43357c64701ecb53b0e)]:
+  - @tanstack/db@0.5.2
+
+## 0.0.77
+
+### Patch Changes
+
+- Updated dependencies [[`a83a818`](https://github.com/TanStack/db/commit/a83a8189514d22ca2fcdf34b9cb97206d3c03c38)]:
+  - @tanstack/db@0.5.1
+
+## 0.0.76
+
+### Patch Changes
+
+- Updated dependencies [[`243a35a`](https://github.com/TanStack/db/commit/243a35a632ee0aca20c3ee12ee2ac2929d8be11d), [`f9d11fc`](https://github.com/TanStack/db/commit/f9d11fc3d7297c61feb3c6876cb2f436edbb5b34), [`7aedf12`](https://github.com/TanStack/db/commit/7aedf12996a67ef64010bca0d78d51c919dd384f), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`28f81b5`](https://github.com/TanStack/db/commit/28f81b5165d0a9566f99c2b6cf0ad09533e1a2cb), [`f6ac7ea`](https://github.com/TanStack/db/commit/f6ac7eac50ae1334ddb173786a68c9fc732848f9), [`01093a7`](https://github.com/TanStack/db/commit/01093a762cf2f5f308edec7f466d1c3dabb5ea9f)]:
+  - @tanstack/db@0.5.0
+
+## 0.0.75
+
+### Patch Changes
+
+- Updated dependencies [[`6c55e16`](https://github.com/TanStack/db/commit/6c55e16a2545b479b1d47f548b6846d362573d45), [`7805afb`](https://github.com/TanStack/db/commit/7805afb7286b680168b336e77dd4de7dd1b6f06a), [`1367756`](https://github.com/TanStack/db/commit/1367756d0a68447405c5f5c1a3cca30ab0558d74)]:
+  - @tanstack/db@0.4.20
+
+## 0.0.74
+
+### Patch Changes
+
+- Updated dependencies [[`75470a8`](https://github.com/TanStack/db/commit/75470a8297f316b4817601b2ea92cb9b21cc7829)]:
+  - @tanstack/db@0.4.19
+
+## 0.0.73
+
+### Patch Changes
+
+- Updated dependencies [[`f416231`](https://github.com/TanStack/db/commit/f41623180c862b58b4fa6415383dfdb034f84ee9), [`b1b8299`](https://github.com/TanStack/db/commit/b1b82994cb9765225129b5a19be06e9369e3158d)]:
+  - @tanstack/db@0.4.18
+
+## 0.0.72
+
+### Patch Changes
+
+- Updated dependencies [[`49bcaa5`](https://github.com/TanStack/db/commit/49bcaa5557ba8d647c947811ed6e0c2450159d84)]:
+  - @tanstack/db@0.4.17
+
+## 0.0.71
+
+### Patch Changes
+
+- Updated dependencies [[`979a66f`](https://github.com/TanStack/db/commit/979a66f2f6eff0ffe44dfde7c67feea933ee6110), [`f8a979b`](https://github.com/TanStack/db/commit/f8a979ba3aa90ac7e85f7a065fc050bda6589b4b), [`cb25623`](https://github.com/TanStack/db/commit/cb256234c9cd8df7771808b147e5afc2be56f51f)]:
+  - @tanstack/db@0.4.16
+
+## 0.0.70
+
+### Patch Changes
+
+- Updated dependencies [[`6738247`](https://github.com/TanStack/db/commit/673824791bcfae04acf42fc35e5d6d8755adceb2)]:
+  - @tanstack/db@0.4.15
+
+## 0.0.69
+
+### Patch Changes
+
+- Updated dependencies [[`970616b`](https://github.com/TanStack/db/commit/970616b6db723d1716eecd5076417de5d6e9a884)]:
+  - @tanstack/db@0.4.14
+
+## 0.0.68
+
+### Patch Changes
+
+- Updated dependencies [[`3c9526c`](https://github.com/TanStack/db/commit/3c9526cd1fd80032ddddff32cf4a23dfa8376888)]:
+  - @tanstack/db@0.4.13
+
+## 0.0.67
+
+### Patch Changes
+
+- Updated dependencies [[`8b29841`](https://github.com/TanStack/db/commit/8b298417964340bbac5ad08a831766f8f1497477), [`8187c6d`](https://github.com/TanStack/db/commit/8187c6d69c4b498e306ac2eb5fc7115e4f8193a5)]:
+  - @tanstack/db@0.4.12
+
 ## 0.0.66
 
 ### Patch Changes
diff --git a/packages/vue-db/package.json b/packages/vue-db/package.json
index 1fd2a1679..38b258224 100644
--- a/packages/vue-db/package.json
+++ b/packages/vue-db/package.json
@@ -1,12 +1,12 @@
 {
   "name": "@tanstack/vue-db",
+  "version": "0.0.101",
   "description": "Vue integration for @tanstack/db",
-  "version": "0.0.66",
   "author": "Kyle Mathews",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/TanStack/db.git",
+    "url": "git+https://github.com/TanStack/db.git",
     "directory": "packages/vue-db"
   },
   "homepage": "https://tanstack.com/db",
@@ -15,16 +15,16 @@
     "vue",
     "typescript"
   ],
-  "packageManager": "pnpm@10.18.3",
-  "dependencies": {
-    "@tanstack/db": "workspace:*"
-  },
-  "devDependencies": {
-    "@electric-sql/client": "1.0.14",
-    "@vitejs/plugin-vue": "^6.0.1",
-    "@vitest/coverage-istanbul": "^3.2.4",
-    "vue": "^3.5.22"
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "vitest --run",
+    "lint": "eslint . --fix"
   },
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -38,22 +38,21 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
+  "dependencies": {
+    "@tanstack/db": "workspace:*"
+  },
   "peerDependencies": {
     "vue": ">=3.3.0"
   },
-  "scripts": {
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "test": "npx vitest --run",
-    "lint": "eslint . --fix"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
+  "devDependencies": {
+    "@electric-sql/client": "^1.3.1",
+    "@vitejs/plugin-vue": "^6.0.3",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "vue": "^3.5.26"
+  }
 }
diff --git a/packages/vue-db/src/index.ts b/packages/vue-db/src/index.ts
index bd98349f0..681078b9c 100644
--- a/packages/vue-db/src/index.ts
+++ b/packages/vue-db/src/index.ts
@@ -1,9 +1,9 @@
 // Re-export all public APIs
-export * from "./useLiveQuery"
+export * from './useLiveQuery'
 
 // Re-export everything from @tanstack/db
-export * from "@tanstack/db"
+export * from '@tanstack/db'
 
 // Re-export some stuff explicitly to ensure the type & value is exported
-export type { Collection } from "@tanstack/db"
-export { createTransaction } from "@tanstack/db"
+export type { Collection } from '@tanstack/db'
+export { createTransaction } from '@tanstack/db'
diff --git a/packages/vue-db/src/useLiveQuery.ts b/packages/vue-db/src/useLiveQuery.ts
index 298eaed91..479c92b2b 100644
--- a/packages/vue-db/src/useLiveQuery.ts
+++ b/packages/vue-db/src/useLiveQuery.ts
@@ -7,24 +7,28 @@ import {
   ref,
   toValue,
   watchEffect,
-} from "vue"
-import { createLiveQueryCollection } from "@tanstack/db"
+} from 'vue'
+import { createLiveQueryCollection } from '@tanstack/db'
 import type {
   ChangeMessage,
   Collection,
+  CollectionConfigSingleRowOption,
   CollectionStatus,
   Context,
   GetResult,
+  InferResultType,
   InitialQueryBuilder,
   LiveQueryCollectionConfig,
+  NonSingleResult,
   QueryBuilder,
-} from "@tanstack/db"
-import type { ComputedRef, MaybeRefOrGetter } from "vue"
+  SingleResult,
+} from '@tanstack/db'
+import type { ComputedRef, MaybeRefOrGetter } from 'vue'
 
 /**
  * Return type for useLiveQuery hook
  * @property state - Reactive Map of query results (key → item)
- * @property data - Reactive array of query results in order
+ * @property data - Reactive array of query results in order, or single result for findOne queries
  * @property collection - The underlying query collection instance
  * @property status - Current query status
  * @property isLoading - True while initial query data is loading
@@ -33,10 +37,10 @@ import type { ComputedRef, MaybeRefOrGetter } from "vue"
  * @property isError - True when query encountered an error
  * @property isCleanedUp - True when query has been cleaned up
  */
-export interface UseLiveQueryReturn<T extends object> {
-  state: ComputedRef<Map<string | number, T>>
-  data: ComputedRef<Array<T>>
-  collection: ComputedRef<Collection<T, string | number, {}>>
+export interface UseLiveQueryReturn<TContext extends Context> {
+  state: ComputedRef<Map<string | number, GetResult<TContext>>>
+  data: ComputedRef<InferResultType<TContext>>
+  collection: ComputedRef<Collection<GetResult<TContext>, string | number, {}>>
   status: ComputedRef<CollectionStatus>
   isLoading: ComputedRef<boolean>
   isReady: ComputedRef<boolean>
@@ -61,6 +65,22 @@ export interface UseLiveQueryReturnWithCollection<
   isCleanedUp: ComputedRef<boolean>
 }
 
+export interface UseLiveQueryReturnWithSingleResultCollection<
+  T extends object,
+  TKey extends string | number,
+  TUtils extends Record<string, any>,
+> {
+  state: ComputedRef<Map<TKey, T>>
+  data: ComputedRef<T | undefined>
+  collection: ComputedRef<Collection<T, TKey, TUtils> & SingleResult>
+  status: ComputedRef<CollectionStatus>
+  isLoading: ComputedRef<boolean>
+  isReady: ComputedRef<boolean>
+  isIdle: ComputedRef<boolean>
+  isError: ComputedRef<boolean>
+  isCleanedUp: ComputedRef<boolean>
+}
+
 /**
  * Create a live query using a query function
  * @param queryFn - Query function that defines what data to fetch
@@ -110,11 +130,19 @@ export interface UseLiveQueryReturnWithCollection<
  * //   <li v-for="todo in data" :key="todo.id">{{ todo.text }}</li>
  * // </ul>
  */
-// Overload 1: Accept just the query function
+// Overload 1: Accept query function that always returns QueryBuilder
 export function useLiveQuery<TContext extends Context>(
   queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,
-  deps?: Array<MaybeRefOrGetter<unknown>>
-): UseLiveQueryReturn<GetResult<TContext>>
+  deps?: Array<MaybeRefOrGetter<unknown>>,
+): UseLiveQueryReturn<TContext>
+
+// Overload 1b: Accept query function that can return undefined/null
+export function useLiveQuery<TContext extends Context>(
+  queryFn: (
+    q: InitialQueryBuilder,
+  ) => QueryBuilder<TContext> | undefined | null,
+  deps?: Array<MaybeRefOrGetter<unknown>>,
+): UseLiveQueryReturn<TContext>
 
 /**
  * Create a live query using configuration object
@@ -151,8 +179,8 @@ export function useLiveQuery<TContext extends Context>(
 // Overload 2: Accept config object
 export function useLiveQuery<TContext extends Context>(
   config: LiveQueryCollectionConfig<TContext>,
-  deps?: Array<MaybeRefOrGetter<unknown>>
-): UseLiveQueryReturn<GetResult<TContext>>
+  deps?: Array<MaybeRefOrGetter<unknown>>,
+): UseLiveQueryReturn<TContext>
 
 /**
  * Subscribe to an existing query collection (can be reactive)
@@ -193,32 +221,48 @@ export function useLiveQuery<TContext extends Context>(
  * //   <Item v-for="item in data" :key="item.id" v-bind="item" />
  * // </div>
  */
-// Overload 3: Accept pre-created live query collection (can be reactive)
+// Overload 3: Accept pre-created live query collection (can be reactive) - non-single result
 export function useLiveQuery<
   TResult extends object,
   TKey extends string | number,
   TUtils extends Record<string, any>,
 >(
-  liveQueryCollection: MaybeRefOrGetter<Collection<TResult, TKey, TUtils>>
+  liveQueryCollection: MaybeRefOrGetter<
+    Collection<TResult, TKey, TUtils> & NonSingleResult
+  >,
 ): UseLiveQueryReturnWithCollection<TResult, TKey, TUtils>
 
+// Overload 4: Accept pre-created live query collection with singleResult: true
+export function useLiveQuery<
+  TResult extends object,
+  TKey extends string | number,
+  TUtils extends Record<string, any>,
+>(
+  liveQueryCollection: MaybeRefOrGetter<
+    Collection<TResult, TKey, TUtils> & SingleResult
+  >,
+): UseLiveQueryReturnWithSingleResultCollection<TResult, TKey, TUtils>
+
 // Implementation
 export function useLiveQuery(
   configOrQueryOrCollection: any,
-  deps: Array<MaybeRefOrGetter<unknown>> = []
+  deps: Array<MaybeRefOrGetter<unknown>> = [],
 ): UseLiveQueryReturn<any> | UseLiveQueryReturnWithCollection<any, any, any> {
   const collection = computed(() => {
     // First check if the original parameter might be a ref/getter
     // by seeing if toValue returns something different than the original
+    // NOTE: Don't call toValue on functions - toValue treats functions as getters and calls them!
     let unwrappedParam = configOrQueryOrCollection
-    try {
-      const potentiallyUnwrapped = toValue(configOrQueryOrCollection)
-      if (potentiallyUnwrapped !== configOrQueryOrCollection) {
-        unwrappedParam = potentiallyUnwrapped
+    if (typeof configOrQueryOrCollection !== `function`) {
+      try {
+        const potentiallyUnwrapped = toValue(configOrQueryOrCollection)
+        if (potentiallyUnwrapped !== configOrQueryOrCollection) {
+          unwrappedParam = potentiallyUnwrapped
+        }
+      } catch {
+        // If toValue fails, use original parameter
+        unwrappedParam = configOrQueryOrCollection
       }
-    } catch {
-      // If toValue fails, use original parameter
-      unwrappedParam = configOrQueryOrCollection
     }
 
     // Check if it's already a collection by checking for specific collection methods
@@ -230,6 +274,20 @@ export function useLiveQuery(
       typeof unwrappedParam.id === `string`
 
     if (isCollection) {
+      // Warn when passing a collection directly with on-demand sync mode
+      // In on-demand mode, data is only loaded when queries with predicates request it
+      // Passing the collection directly doesn't provide any predicates, so no data loads
+      const syncMode = (unwrappedParam as { config?: { syncMode?: string } })
+        .config?.syncMode
+      if (syncMode === `on-demand`) {
+        console.warn(
+          `[useLiveQuery] Warning: Passing a collection with syncMode "on-demand" directly to useLiveQuery ` +
+            `will not load any data. In on-demand mode, data is only loaded when queries with predicates request it.\n\n` +
+            `Instead, use a query builder function:\n` +
+            `  const { data } = useLiveQuery((q) => q.from({ c: myCollection }).select(({ c }) => c))\n\n` +
+            `Or switch to syncMode "eager" if you want all data to sync automatically.`,
+        )
+      }
       // It's already a collection, ensure sync is started for Vue hooks
       // Only start sync if the collection is in idle state
       if (unwrappedParam.status === `idle`) {
@@ -243,10 +301,31 @@ export function useLiveQuery(
 
     // Ensure we always start sync for Vue hooks
     if (typeof unwrappedParam === `function`) {
-      return createLiveQueryCollection({
-        query: unwrappedParam,
-        startSync: true,
-      })
+      // To avoid calling the query function twice, we wrap it to handle null/undefined returns
+      // The wrapper will be called once by createLiveQueryCollection
+      const wrappedQuery = (q: InitialQueryBuilder) => {
+        const result = unwrappedParam(q)
+        // If the query function returns null/undefined, throw a special error
+        // that we'll catch to return null collection
+        if (result === undefined || result === null) {
+          throw new Error(`__DISABLED_QUERY__`)
+        }
+        return result
+      }
+
+      try {
+        return createLiveQueryCollection({
+          query: wrappedQuery,
+          startSync: true,
+        })
+      } catch (error) {
+        // Check if this is our special disabled query marker
+        if (error instanceof Error && error.message === `__DISABLED_QUERY__`) {
+          return null
+        }
+        // Re-throw other errors
+        throw error
+      }
     } else {
       return createLiveQueryCollection({
         ...unwrappedParam,
@@ -262,14 +341,25 @@ export function useLiveQuery(
   const internalData = reactive<Array<any>>([])
 
   // Computed wrapper for the data to match expected return type
-  const data = computed(() => internalData)
+  // Returns single item for singleResult collections, array otherwise
+  const data = computed(() => {
+    const currentCollection = collection.value
+    if (!currentCollection) {
+      return internalData
+    }
+    const config: CollectionConfigSingleRowOption<any, any, any> =
+      currentCollection.config
+    return config.singleResult ? internalData[0] : internalData
+  })
 
   // Track collection status reactively
-  const status = ref(collection.value.status)
+  const status = ref(
+    collection.value ? collection.value.status : (`disabled` as const),
+  )
 
   // Helper to sync data array from collection in correct order
   const syncDataFromCollection = (
-    currentCollection: Collection<any, any, any>
+    currentCollection: Collection<any, any, any>,
   ) => {
     internalData.length = 0
     internalData.push(...Array.from(currentCollection.values()))
@@ -282,6 +372,18 @@ export function useLiveQuery(
   watchEffect((onInvalidate) => {
     const currentCollection = collection.value
 
+    // Handle null collection (disabled query)
+    if (!currentCollection) {
+      status.value = `disabled` as const
+      state.clear()
+      internalData.length = 0
+      if (currentUnsubscribe) {
+        currentUnsubscribe()
+        currentUnsubscribe = null
+      }
+      return
+    }
+
     // Update status ref whenever the effect runs
     status.value = currentCollection.status
 
@@ -331,7 +433,7 @@ export function useLiveQuery(
       },
       {
         includeInitialState: true,
-      }
+      },
     )
 
     currentUnsubscribe = subscription.unsubscribe.bind(subscription)
@@ -366,7 +468,9 @@ export function useLiveQuery(
     collection: computed(() => collection.value),
     status: computed(() => status.value),
     isLoading: computed(() => status.value === `loading`),
-    isReady: computed(() => status.value === `ready`),
+    isReady: computed(
+      () => status.value === `ready` || status.value === `disabled`,
+    ),
     isIdle: computed(() => status.value === `idle`),
     isError: computed(() => status.value === `error`),
     isCleanedUp: computed(() => status.value === `cleaned-up`),
diff --git a/packages/vue-db/tests/useLiveQuery.test-d.ts b/packages/vue-db/tests/useLiveQuery.test-d.ts
new file mode 100644
index 000000000..df54ec2be
--- /dev/null
+++ b/packages/vue-db/tests/useLiveQuery.test-d.ts
@@ -0,0 +1,139 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import { createCollection } from '../../db/src/collection/index'
+import { mockSyncCollectionOptions } from '../../db/tests/utils'
+import {
+  createLiveQueryCollection,
+  eq,
+  liveQueryCollectionOptions,
+} from '../../db/src/query/index'
+import { useLiveQuery } from '../src/useLiveQuery'
+import type { SingleResult } from '../../db/src/types'
+
+type Person = {
+  id: string
+  name: string
+  age: number
+  email: string
+  isActive: boolean
+  team: string
+}
+
+describe(`useLiveQuery type assertions`, () => {
+  it(`should type findOne query builder to return a single row`, () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-findone-vue`,
+        getKey: (person: Person) => person.id,
+        initialData: [],
+      }),
+    )
+
+    const { data } = useLiveQuery((q) =>
+      q
+        .from({ collection })
+        .where(({ collection: c }) => eq(c.id, `3`))
+        .findOne(),
+    )
+
+    // BUG: Currently returns ComputedRef<Array<Person>> but should be ComputedRef<Person | undefined>
+    expectTypeOf(data.value).toEqualTypeOf<Person | undefined>()
+  })
+
+  it(`should type findOne config object to return a single row`, () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-findone-config-vue`,
+        getKey: (person: Person) => person.id,
+        initialData: [],
+      }),
+    )
+
+    const { data } = useLiveQuery({
+      query: (q) =>
+        q
+          .from({ collection })
+          .where(({ collection: c }) => eq(c.id, `3`))
+          .findOne(),
+    })
+
+    // BUG: Currently returns ComputedRef<Array<Person>> but should be ComputedRef<Person | undefined>
+    expectTypeOf(data.value).toEqualTypeOf<Person | undefined>()
+  })
+
+  it(`should type findOne collection using liveQueryCollectionOptions to return a single row`, () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-findone-options-vue`,
+        getKey: (person: Person) => person.id,
+        initialData: [],
+      }),
+    )
+
+    const options = liveQueryCollectionOptions({
+      query: (q) =>
+        q
+          .from({ collection })
+          .where(({ collection: c }) => eq(c.id, `3`))
+          .findOne(),
+    })
+
+    const liveQueryCollection = createCollection(options)
+
+    expectTypeOf(liveQueryCollection).toExtend<SingleResult>()
+
+    const { data } = useLiveQuery(liveQueryCollection)
+
+    // BUG: Currently returns ComputedRef<Array<Person>> but should be ComputedRef<Person | undefined>
+    expectTypeOf(data.value).toEqualTypeOf<Person | undefined>()
+  })
+
+  it(`should type findOne collection using createLiveQueryCollection to return a single row`, () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-findone-create-vue`,
+        getKey: (person: Person) => person.id,
+        initialData: [],
+      }),
+    )
+
+    const liveQueryCollection = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ collection })
+          .where(({ collection: c }) => eq(c.id, `3`))
+          .findOne(),
+    })
+
+    expectTypeOf(liveQueryCollection).toExtend<SingleResult>()
+
+    const { data } = useLiveQuery(liveQueryCollection)
+
+    // BUG: Currently returns ComputedRef<Array<Person>> but should be ComputedRef<Person | undefined>
+    expectTypeOf(data.value).toEqualTypeOf<Person | undefined>()
+  })
+
+  it(`should type regular query to return an array`, () => {
+    const collection = createCollection(
+      mockSyncCollectionOptions<Person>({
+        id: `test-persons-array-vue`,
+        getKey: (person: Person) => person.id,
+        initialData: [],
+      }),
+    )
+
+    const { data } = useLiveQuery((q) =>
+      q
+        .from({ collection })
+        .where(({ collection: c }) => eq(c.isActive, true))
+        .select(({ collection: c }) => ({
+          id: c.id,
+          name: c.name,
+        })),
+    )
+
+    // Regular queries should return an array
+    expectTypeOf(data.value).toEqualTypeOf<
+      Array<{ id: string; name: string }>
+    >()
+  })
+})
diff --git a/packages/vue-db/tests/useLiveQuery.test.ts b/packages/vue-db/tests/useLiveQuery.test.ts
index 372bba52d..634c5ff8d 100644
--- a/packages/vue-db/tests/useLiveQuery.test.ts
+++ b/packages/vue-db/tests/useLiveQuery.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest"
+import { describe, expect, it } from 'vitest'
 import {
   count,
   createCollection,
@@ -6,10 +6,10 @@ import {
   createOptimisticAction,
   eq,
   gt,
-} from "@tanstack/db"
-import { nextTick, ref, watchEffect } from "vue"
-import { useLiveQuery } from "../src/useLiveQuery"
-import { mockSyncCollectionOptions } from "../../db/tests/utils"
+} from '@tanstack/db'
+import { nextTick, ref, watchEffect } from 'vue'
+import { useLiveQuery } from '../src/useLiveQuery'
+import { mockSyncCollectionOptions } from '../../db/tests/utils'
 
 type Person = {
   id: string
@@ -105,7 +105,7 @@ describe(`Query Collections`, () => {
         id: `test-persons`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { state, data } = useLiveQuery((q) =>
@@ -116,7 +116,7 @@ describe(`Query Collections`, () => {
           id: persons.id,
           name: persons.name,
           age: persons.age,
-        }))
+        })),
     )
 
     // Wait for Vue reactivity to update
@@ -139,7 +139,7 @@ describe(`Query Collections`, () => {
         id: `test-persons-2`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const { state, data } = useLiveQuery((q) =>
@@ -150,7 +150,7 @@ describe(`Query Collections`, () => {
           id: c.id,
           name: c.name,
         }))
-        .orderBy(({ collection: c }) => c.id, `asc`)
+        .orderBy(({ collection: c }) => c.id, `asc`),
     )
 
     // Wait for collection to sync
@@ -206,7 +206,7 @@ describe(`Query Collections`, () => {
           id: `4`,
           name: `Kyle Doe`,
         }),
-      ])
+      ]),
     )
 
     // Update the person
@@ -243,7 +243,7 @@ describe(`Query Collections`, () => {
           id: `4`,
           name: `Kyle Doe 2`,
         }),
-      ])
+      ]),
     )
 
     // Delete the person
@@ -280,7 +280,7 @@ describe(`Query Collections`, () => {
         id: `person-collection-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create issue collection
@@ -289,20 +289,20 @@ describe(`Query Collections`, () => {
         id: `issue-collection-test`,
         getKey: (issue: Issue) => issue.id,
         initialData: initialIssues,
-      })
+      }),
     )
 
     const { state } = useLiveQuery((q) =>
       q
         .from({ issues: issueCollection })
         .join({ persons: personCollection }, ({ issues, persons }) =>
-          eq(issues.userId, persons.id)
+          eq(issues.userId, persons.id),
         )
         .select(({ issues, persons }) => ({
           id: issues.id,
           title: issues.title,
-          name: persons.name,
-        }))
+          name: persons?.name,
+        })),
     )
 
     // Wait for collections to sync
@@ -399,7 +399,7 @@ describe(`Query Collections`, () => {
         id: `params-change-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const minAge = ref(30)
@@ -414,7 +414,7 @@ describe(`Query Collections`, () => {
             name: c.name,
             age: c.age,
           })),
-      [minAge]
+      [minAge],
     )
 
     // Wait for collection to sync
@@ -466,7 +466,7 @@ describe(`Query Collections`, () => {
         id: `optimistic-changes-test`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Initial query
@@ -480,7 +480,7 @@ describe(`Query Collections`, () => {
             name: c.name,
             team: c.team,
           }))
-          .orderBy(({ collection: c }) => c.id, `asc`)
+          .orderBy(({ collection: c }) => c.id, `asc`),
       )
 
     // Wait for collection to sync
@@ -494,7 +494,7 @@ describe(`Query Collections`, () => {
         .select(({ queryResult }) => ({
           team: queryResult.team,
           count: count(queryResult.id),
-        }))
+        })),
     )
 
     // Wait for grouped query to sync
@@ -568,7 +568,7 @@ describe(`Query Collections`, () => {
         id: `person-collection-test-bug`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create issue collection
@@ -577,7 +577,7 @@ describe(`Query Collections`, () => {
         id: `issue-collection-test-bug`,
         getKey: (issue: Issue) => issue.id,
         initialData: initialIssues,
-      })
+      }),
     )
 
     // Render the hook with a query that joins persons and issues
@@ -585,13 +585,13 @@ describe(`Query Collections`, () => {
       q
         .from({ issues: issueCollection })
         .join({ persons: personCollection }, ({ issues, persons }) =>
-          eq(issues.userId, persons.id)
+          eq(issues.userId, persons.id),
         )
         .select(({ issues, persons }) => ({
           id: issues.id,
           title: issues.title,
-          name: persons.name,
-        }))
+          name: persons?.name,
+        })),
     )
 
     const { state } = queryResult
@@ -701,7 +701,7 @@ describe(`Query Collections`, () => {
         id: `pre-created-collection-test-vue`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create a live query collection beforehand
@@ -747,7 +747,7 @@ describe(`Query Collections`, () => {
         id: `collection-1-vue`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     const collection2 = createCollection(
@@ -772,7 +772,7 @@ describe(`Query Collections`, () => {
             team: `team3`,
           },
         ],
-      })
+      }),
     )
 
     // Create two different live query collections
@@ -867,7 +867,7 @@ describe(`Query Collections`, () => {
           .select(({ persons }) => ({
             id: persons.id,
             name: persons.name,
-          }))
+          })),
       )
 
       // Initially isReady should be false (collection is in idle state)
@@ -902,7 +902,7 @@ describe(`Query Collections`, () => {
           id: `pre-created-is-ready-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       // Create a live query collection that's already syncing
@@ -984,7 +984,7 @@ describe(`Query Collections`, () => {
           .select(({ persons }) => ({
             id: persons.id,
             name: persons.name,
-          }))
+          })),
       )
 
       expect(isReady.value).toBe(false)
@@ -1034,7 +1034,7 @@ describe(`Query Collections`, () => {
           .select(({ persons }) => ({
             id: persons.id,
             name: persons.name,
-          }))
+          })),
       )
 
       // Initially should be true
@@ -1078,7 +1078,7 @@ describe(`Query Collections`, () => {
           id: `live-updates-is-ready-test`,
           getKey: (person: Person) => person.id,
           initialData: initialPersons,
-        })
+        }),
       )
 
       const { isReady } = useLiveQuery((q) =>
@@ -1088,7 +1088,7 @@ describe(`Query Collections`, () => {
           .select(({ persons }) => ({
             id: persons.id,
             name: persons.name,
-          }))
+          })),
       )
 
       await waitForVueUpdate()
@@ -1157,13 +1157,13 @@ describe(`Query Collections`, () => {
         q
           .from({ issues: issueCollection })
           .join({ persons: personCollection }, ({ issues, persons }) =>
-            eq(issues.userId, persons.id)
+            eq(issues.userId, persons.id),
           )
           .select(({ issues, persons }) => ({
             id: issues.id,
             title: issues.title,
-            name: persons.name,
-          }))
+            name: persons?.name,
+          })),
       )
 
       expect(isReady.value).toBe(false)
@@ -1229,7 +1229,7 @@ describe(`Query Collections`, () => {
               id: c.id,
               name: c.name,
             })),
-        [minAge]
+        [minAge],
       )
 
       expect(isReady.value).toBe(false)
@@ -1288,7 +1288,7 @@ describe(`Query Collections`, () => {
           .select(({ collection: c }) => ({
             id: c.id,
             name: c.name,
-          }))
+          })),
       )
 
       // Initially should be loading
@@ -1357,7 +1357,7 @@ describe(`Query Collections`, () => {
           .select(({ collection: c }) => ({
             id: c.id,
             name: c.name,
-          }))
+          })),
       )
 
       // Initially should be loading
@@ -1402,7 +1402,7 @@ describe(`Query Collections`, () => {
         id: `config-querybuilder-test-vue`,
         getKey: (person: Person) => person.id,
         initialData: initialPersons,
-      })
+      }),
     )
 
     // Create a pre-built QueryBuilder instance
@@ -1465,7 +1465,7 @@ describe(`Query Collections`, () => {
           .select(({ persons }) => ({
             id: persons.id,
             name: persons.name,
-          }))
+          })),
       )
 
       // Initially isLoading should be true
@@ -1571,7 +1571,7 @@ describe(`Query Collections`, () => {
             id: persons.id,
             name: persons.name,
             team: persons.team,
-          }))
+          })),
       )
 
       // Start sync
@@ -1684,13 +1684,13 @@ describe(`Query Collections`, () => {
         q
           .from({ issues: issueCollection })
           .join({ persons: personCollection }, ({ issues, persons }) =>
-            eq(issues.userId, persons.id)
+            eq(issues.userId, persons.id),
           )
           .select(({ issues, persons }) => ({
             id: issues.id,
             title: issues.title,
-            userName: persons.name,
-          }))
+            userName: persons?.name,
+          })),
       )
 
       // Start sync for both
@@ -1781,7 +1781,7 @@ describe(`Query Collections`, () => {
           .select(({ persons }) => ({
             id: persons.id,
             name: persons.name,
-          }))
+          })),
       )
 
       // Initially isLoading should be true
@@ -1812,4 +1812,105 @@ describe(`Query Collections`, () => {
       expect(status.value).toBe(`ready`)
     })
   })
+
+  describe(`Disabled queries`, () => {
+    it(`should handle callback returning undefined with proper state`, async () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `disabled-undefined-test`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      const enabled = ref(false)
+      const result = useLiveQuery(
+        (q) => {
+          if (!enabled.value) return undefined
+          return q
+            .from({ persons: collection })
+            .where(({ persons }) => gt(persons.age, 30))
+            .select(({ persons }) => ({
+              id: persons.id,
+              name: persons.name,
+              age: persons.age,
+            }))
+        },
+        [() => enabled.value],
+      )
+
+      // When callback returns undefined, should return disabled state
+      expect(result.state.value.size).toBe(0)
+      expect(result.data.value).toEqual([])
+      expect(result.collection.value).toBeNull()
+      expect(result.status.value).toBe(`disabled`)
+      expect(result.isLoading.value).toBe(false)
+      expect(result.isReady.value).toBe(true)
+
+      // Enable the query
+      enabled.value = true
+      await waitFor(() => {
+        expect(result.collection.value).not.toBeNull()
+      })
+
+      await waitFor(() => {
+        expect(result.state.value.size).toBe(1) // Only John Smith (age 35)
+      })
+      expect(result.data.value).toHaveLength(1)
+      expect(result.isReady.value).toBe(true)
+
+      // Disable the query again
+      enabled.value = false
+      await waitFor(() => {
+        expect(result.status.value).toBe(`disabled`)
+      })
+      expect(result.isReady.value).toBe(true)
+    })
+
+    it(`should handle callback returning null with proper state`, async () => {
+      const collection = createCollection(
+        mockSyncCollectionOptions<Person>({
+          id: `disabled-null-test`,
+          getKey: (person: Person) => person.id,
+          initialData: initialPersons,
+        }),
+      )
+
+      const enabled = ref(false)
+      const result = useLiveQuery(
+        (q) => {
+          if (!enabled.value) return null
+          return q
+            .from({ persons: collection })
+            .where(({ persons }) => gt(persons.age, 30))
+            .select(({ persons }) => ({
+              id: persons.id,
+              name: persons.name,
+              age: persons.age,
+            }))
+        },
+        [() => enabled.value],
+      )
+
+      // When callback returns null, should return disabled state
+      expect(result.state.value.size).toBe(0)
+      expect(result.data.value).toEqual([])
+      expect(result.collection.value).toBeNull()
+      expect(result.status.value).toBe(`disabled`)
+      expect(result.isLoading.value).toBe(false)
+      expect(result.isReady.value).toBe(true)
+
+      // Enable the query
+      enabled.value = true
+      await waitFor(() => {
+        expect(result.collection.value).not.toBeNull()
+      })
+
+      await waitFor(() => {
+        expect(result.state.value.size).toBe(1)
+      })
+      expect(result.data.value).toHaveLength(1)
+      expect(result.isReady.value).toBe(true)
+    })
+  })
 })
diff --git a/packages/vue-db/vite.config.ts b/packages/vue-db/vite.config.ts
index bf10fb50d..7fffa40fc 100644
--- a/packages/vue-db/vite.config.ts
+++ b/packages/vue-db/vite.config.ts
@@ -1,7 +1,7 @@
-import { defineConfig, mergeConfig } from "vitest/config"
-import { tanstackViteConfig } from "@tanstack/config/vite"
-import vue from "@vitejs/plugin-vue"
-import packageJson from "./package.json"
+import { defineConfig, mergeConfig } from 'vitest/config'
+import { tanstackViteConfig } from '@tanstack/vite-config'
+import vue from '@vitejs/plugin-vue'
+import packageJson from './package.json'
 
 const config = defineConfig({
   plugins: [vue()],
@@ -19,5 +19,5 @@ export default mergeConfig(
   tanstackViteConfig({
     entry: `./src/index.ts`,
     srcDir: `./src`,
-  })
+  }),
 )
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 449535b38..f54cb8a82 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -4,25 +4,34 @@ settings:
   autoInstallPeers: true
   excludeLinksFromLockfile: false
 
+overrides:
+  metro: 0.82.5
+
 importers:
 
   .:
     devDependencies:
       '@changesets/cli':
-        specifier: ^2.29.7
-        version: 2.29.7(@types/node@24.7.0)
+        specifier: ^2.29.8
+        version: 2.29.8(@types/node@24.7.0)
       '@eslint/js':
-        specifier: ^9.38.0
-        version: 9.38.0
-      '@stylistic/eslint-plugin':
-        specifier: ^4.4.1
-        version: 4.4.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        specifier: ^9.39.2
+        version: 9.39.2
+      '@fast-check/vitest':
+        specifier: ^0.2.0
+        version: 0.2.4(vitest@3.2.4)
       '@svitejs/changesets-changelog-github-compact':
         specifier: ^1.2.0
         version: 1.2.0(encoding@0.1.13)
-      '@tanstack/config':
-        specifier: ^0.22.0
-        version: 0.22.0(@types/node@24.7.0)(@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(rollup@4.52.5)(typescript@5.9.3)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      '@tanstack/eslint-config':
+        specifier: 0.3.4
+        version: 0.3.4(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@tanstack/typedoc-config':
+        specifier: 0.3.3
+        version: 0.3.3(typescript@5.9.3)
+      '@tanstack/vite-config':
+        specifier: 0.4.3
+        version: 0.4.3(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@testing-library/jest-dom':
         specifier: ^6.9.1
         version: 6.9.1
@@ -30,80 +39,77 @@ importers:
         specifier: ^24.6.2
         version: 24.7.0
       '@types/react':
-        specifier: ^19.2.2
-        version: 19.2.2
+        specifier: ^19.2.7
+        version: 19.2.7
       '@types/react-dom':
-        specifier: ^19.2.2
-        version: 19.2.2(@types/react@19.2.2)
+        specifier: ^19.2.3
+        version: 19.2.3(@types/react@19.2.7)
       '@types/use-sync-external-store':
         specifier: ^1.5.0
         version: 1.5.0
       '@typescript-eslint/eslint-plugin':
-        specifier: ^8.46.1
-        version: 8.46.1(@typescript-eslint/parser@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        specifier: ^8.51.0
+        version: 8.51.0(@typescript-eslint/parser@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       '@typescript-eslint/parser':
-        specifier: ^8.46.1
-        version: 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        specifier: ^8.51.0
+        version: 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       '@vitejs/plugin-react':
-        specifier: ^5.0.4
-        version: 5.0.4(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^5.1.2
+        version: 5.1.2(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       eslint:
-        specifier: ^9.38.0
-        version: 9.38.0(jiti@2.6.0)
-      eslint-config-prettier:
-        specifier: ^10.1.8
-        version: 10.1.8(eslint@9.38.0(jiti@2.6.0))
+        specifier: ^9.39.2
+        version: 9.39.2(jiti@2.6.1)
       eslint-import-resolver-typescript:
         specifier: ^4.4.4
-        version: 4.4.4(eslint-plugin-import-x@4.16.1(@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0)))(eslint@9.38.0(jiti@2.6.0))
-      eslint-plugin-prettier:
-        specifier: ^5.5.4
-        version: 5.5.4(eslint-config-prettier@10.1.8(eslint@9.38.0(jiti@2.6.0)))(eslint@9.38.0(jiti@2.6.0))(prettier@3.6.2)
+        version: 4.4.4(eslint-plugin-import-x@4.16.1(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1)))(eslint@9.39.2(jiti@2.6.1))
       eslint-plugin-react:
         specifier: ^7.37.5
-        version: 7.37.5(eslint@9.38.0(jiti@2.6.0))
+        version: 7.37.5(eslint@9.39.2(jiti@2.6.1))
+      fast-check:
+        specifier: ^3.23.0
+        version: 3.23.2
       husky:
         specifier: ^9.1.7
         version: 9.1.7
       jsdom:
-        specifier: ^27.0.1
-        version: 27.0.1(postcss@8.5.6)
+        specifier: ^27.4.0
+        version: 27.4.0
       knip:
-        specifier: ^5.66.1
-        version: 5.66.1(@types/node@24.7.0)(typescript@5.9.3)
+        specifier: ^5.79.0
+        version: 5.79.0(@types/node@24.7.0)(typescript@5.9.3)
       lint-staged:
         specifier: ^15.5.2
         version: 15.5.2
       markdown-link-extractor:
-        specifier: ^4.0.2
-        version: 4.0.2
-      mitt:
-        specifier: ^3.0.1
-        version: 3.0.1
+        specifier: ^4.0.3
+        version: 4.0.3
       prettier:
-        specifier: ^3.6.2
-        version: 3.6.2
+        specifier: ^3.7.4
+        version: 3.7.4
       publint:
-        specifier: ^0.3.14
-        version: 0.3.14
+        specifier: ^0.3.16
+        version: 0.3.16
       sherif:
-        specifier: ^1.6.1
-        version: 1.6.1
+        specifier: ^1.9.0
+        version: 1.9.0
       shx:
         specifier: ^0.4.0
         version: 0.4.0
       tinyglobby:
         specifier: ^0.2.15
         version: 0.2.15
+      tsx:
+        specifier: ^4.21.0
+        version: 4.21.0
       typescript:
         specifier: ^5.9.2
         version: 5.9.3
       vite:
-        specifier: ^7.1.10
-        version: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+        specifier: ^7.3.0
+        version: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
       vitest:
         specifier: ^3.2.4
-        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
       zod:
         specifier: ^3.25.76
         version: 3.25.76
@@ -111,57 +117,57 @@ importers:
   examples/angular/todos:
     dependencies:
       '@angular/common':
-        specifier: ^20.3.6
-        version: 20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2)
+        specifier: ^19.2.17
+        version: 19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2)
       '@angular/compiler':
-        specifier: ^20.3.6
-        version: 20.3.6
+        specifier: ^20.3.15
+        version: 20.3.16
       '@angular/core':
-        specifier: ^20.3.6
-        version: 20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)
+        specifier: ^19.2.17
+        version: 19.2.18(rxjs@7.8.2)(zone.js@0.16.0)
       '@angular/forms':
-        specifier: ^20.3.6
-        version: 20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(@angular/platform-browser@20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)))(rxjs@7.8.2)
+        specifier: ^20.3.15
+        version: 20.3.15(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(@angular/platform-browser@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0)))(rxjs@7.8.2)
       '@angular/platform-browser':
-        specifier: ^20.3.6
-        version: 20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))
+        specifier: ^19.2.17
+        version: 19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))
       '@angular/router':
-        specifier: ^20.3.6
-        version: 20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(@angular/platform-browser@20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)))(rxjs@7.8.2)
+        specifier: ^20.3.15
+        version: 20.3.15(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(@angular/platform-browser@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0)))(rxjs@7.8.2)
       '@tanstack/angular-db':
-        specifier: workspace:*
+        specifier: ^0.1.50
         version: link:../../../packages/angular-db
       '@tanstack/db':
-        specifier: workspace:*
+        specifier: ^0.5.24
         version: link:../../../packages/db
       rxjs:
-        specifier: ~7.8.2
+        specifier: ^7.8.2
         version: 7.8.2
       tslib:
         specifier: ^2.8.1
         version: 2.8.1
       zone.js:
-        specifier: ~0.15.1
-        version: 0.15.1
+        specifier: ^0.16.0
+        version: 0.16.0
     devDependencies:
       '@angular/build':
-        specifier: ^20.3.6
-        version: 20.3.6(@angular/compiler-cli@20.3.6(@angular/compiler@20.3.6)(typescript@5.8.3))(@angular/compiler@20.3.6)(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(@angular/platform-browser@20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)))(@types/node@24.7.0)(chokidar@4.0.3)(jiti@2.6.0)(karma@6.4.4)(lightningcss@1.30.1)(postcss@8.5.6)(tailwindcss@3.4.18)(terser@5.44.0)(tslib@2.8.1)(tsx@4.20.6)(typescript@5.8.3)(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))(yaml@2.8.1)
+        specifier: ^20.3.13
+        version: 20.3.13(@angular/compiler-cli@20.3.15(@angular/compiler@20.3.16)(typescript@5.9.3))(@angular/compiler@20.3.16)(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(@angular/platform-browser@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0)))(@types/node@24.7.0)(chokidar@4.0.3)(jiti@2.6.1)(karma@6.4.4)(lightningcss@1.30.2)(postcss@8.5.6)(tailwindcss@4.1.18)(terser@5.44.0)(tslib@2.8.1)(tsx@4.21.0)(typescript@5.9.3)(vitest@3.2.4)(yaml@2.8.1)
       '@angular/cli':
-        specifier: ^20.3.6
-        version: 20.3.6(@types/node@24.7.0)(chokidar@4.0.3)
+        specifier: ^20.3.13
+        version: 20.3.13(@types/node@24.7.0)(chokidar@4.0.3)
       '@angular/compiler-cli':
-        specifier: ^20.3.6
-        version: 20.3.6(@angular/compiler@20.3.6)(typescript@5.8.3)
+        specifier: ^20.3.15
+        version: 20.3.15(@angular/compiler@20.3.16)(typescript@5.9.3)
+      '@tailwindcss/postcss':
+        specifier: ^4.1.18
+        version: 4.1.18
       '@types/jasmine':
-        specifier: ~5.1.12
-        version: 5.1.12
-      autoprefixer:
-        specifier: ^10.4.21
-        version: 10.4.21(postcss@8.5.6)
+        specifier: ~5.1.13
+        version: 5.1.13
       jasmine-core:
-        specifier: ~5.12.0
-        version: 5.12.0
+        specifier: ~5.13.0
+        version: 5.13.0
       karma:
         specifier: ~6.4.4
         version: 6.4.4
@@ -176,152 +182,335 @@ importers:
         version: 5.1.0(karma@6.4.4)
       karma-jasmine-html-reporter:
         specifier: ~2.1.0
-        version: 2.1.0(jasmine-core@5.12.0)(karma-jasmine@5.1.0(karma@6.4.4))(karma@6.4.4)
+        version: 2.1.0(jasmine-core@5.13.0)(karma-jasmine@5.1.0(karma@6.4.4))(karma@6.4.4)
       postcss:
         specifier: ^8.5.6
         version: 8.5.6
       tailwindcss:
-        specifier: ^3.4.18
-        version: 3.4.18
+        specifier: ^4.1.18
+        version: 4.1.18
+      typescript:
+        specifier: ^5.9.2
+        version: 5.9.3
+
+  examples/react-native/offline-transactions:
+    dependencies:
+      '@expo/metro-runtime':
+        specifier: ~5.0.5
+        version: 5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      '@react-native-async-storage/async-storage':
+        specifier: 2.1.2
+        version: 2.1.2(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      '@react-native-community/netinfo':
+        specifier: 11.4.1
+        version: 11.4.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      '@tanstack/offline-transactions':
+        specifier: ^1.0.14
+        version: link:../../../packages/offline-transactions
+      '@tanstack/query-db-collection':
+        specifier: ^1.0.21
+        version: link:../../../packages/query-db-collection
+      '@tanstack/react-db':
+        specifier: ^0.1.68
+        version: link:../../../packages/react-db
+      '@tanstack/react-query':
+        specifier: ^5.90.16
+        version: 5.90.16(react@19.2.3)
+      expo:
+        specifier: ~53.0.0
+        version: 53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      expo-constants:
+        specifier: ~17.1.0
+        version: 17.1.8(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      expo-linking:
+        specifier: ~7.1.0
+        version: 7.1.7(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      expo-router:
+        specifier: ~5.1.10
+        version: 5.1.10(4f28e76f0b81d75a7bbf5ddbb07ad280)
+      expo-status-bar:
+        specifier: ~2.2.0
+        version: 2.2.3(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      metro:
+        specifier: 0.82.5
+        version: 0.82.5
+      react:
+        specifier: ^19.2.3
+        version: 19.2.3
+      react-native:
+        specifier: 0.79.6
+        version: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+      react-native-safe-area-context:
+        specifier: 5.4.0
+        version: 5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      react-native-screens:
+        specifier: ~4.11.1
+        version: 4.11.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      zod:
+        specifier: ^3.25.76
+        version: 3.25.76
+    devDependencies:
+      '@babel/core':
+        specifier: ^7.26.0
+        version: 7.28.5
+      '@types/cors':
+        specifier: ^2.8.19
+        version: 2.8.19
+      '@types/express':
+        specifier: ^5.0.0
+        version: 5.0.5
+      '@types/react':
+        specifier: ^19.2.7
+        version: 19.2.7
+      cors:
+        specifier: ^2.8.5
+        version: 2.8.5
+      express:
+        specifier: ^5.0.1
+        version: 5.1.0
+      tsx:
+        specifier: ^4.21.0
+        version: 4.21.0
+      typescript:
+        specifier: ^5.9.2
+        version: 5.9.3
+
+  examples/react/offline-transactions:
+    dependencies:
+      '@tanstack/offline-transactions':
+        specifier: ^1.0.14
+        version: link:../../../packages/offline-transactions
+      '@tanstack/query-db-collection':
+        specifier: ^1.0.21
+        version: link:../../../packages/query-db-collection
+      '@tanstack/react-db':
+        specifier: ^0.1.68
+        version: link:../../../packages/react-db
+      '@tanstack/react-query':
+        specifier: ^5.90.16
+        version: 5.90.16(react@19.2.3)
+      '@tanstack/react-router':
+        specifier: ^1.144.0
+        version: 1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@tanstack/react-router-devtools':
+        specifier: ^1.144.0
+        version: 1.144.0(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(@tanstack/router-core@1.144.0)(csstype@3.2.3)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)
+      '@tanstack/react-start':
+        specifier: ^1.145.5
+        version: 1.145.5(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      react:
+        specifier: ^19.2.3
+        version: 19.2.3
+      react-dom:
+        specifier: ^19.2.3
+        version: 19.2.3(react@19.2.3)
+      tailwind-merge:
+        specifier: ^2.6.0
+        version: 2.6.0
+      zod:
+        specifier: ^3.25.76
+        version: 3.25.76
+    devDependencies:
+      '@tailwindcss/vite':
+        specifier: ^4.1.18
+        version: 4.1.18(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      '@types/node':
+        specifier: ^24.6.2
+        version: 24.7.0
+      '@types/react':
+        specifier: ^19.2.7
+        version: 19.2.7
+      '@types/react-dom':
+        specifier: ^19.2.3
+        version: 19.2.3(@types/react@19.2.7)
+      '@vitejs/plugin-react':
+        specifier: ^5.1.2
+        version: 5.1.2(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      chokidar:
+        specifier: ^4.0.3
+        version: 4.0.3
+      tailwindcss:
+        specifier: ^4.1.18
+        version: 4.1.18
+      typescript:
+        specifier: ^5.9.2
+        version: 5.9.3
+      vite:
+        specifier: ^7.3.0
+        version: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+      vite-tsconfig-paths:
+        specifier: ^5.1.4
+        version: 5.1.4(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+
+  examples/react/paced-mutations-demo:
+    dependencies:
+      '@tanstack/db':
+        specifier: ^0.5.24
+        version: link:../../../packages/db
+      '@tanstack/react-db':
+        specifier: ^0.1.68
+        version: link:../../../packages/react-db
+      mitt:
+        specifier: ^3.0.1
+        version: 3.0.1
+      react:
+        specifier: ^19.2.3
+        version: 19.2.3
+      react-dom:
+        specifier: ^19.2.3
+        version: 19.2.3(react@19.2.3)
+    devDependencies:
+      '@types/react':
+        specifier: ^19.2.7
+        version: 19.2.7
+      '@types/react-dom':
+        specifier: ^19.2.3
+        version: 19.2.3(@types/react@19.2.7)
+      '@vitejs/plugin-react':
+        specifier: ^5.1.2
+        version: 5.1.2(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       typescript:
-        specifier: ~5.8.2
-        version: 5.8.3
+        specifier: ^5.9.2
+        version: 5.9.3
+      vite:
+        specifier: ^7.3.0
+        version: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
 
   examples/react/projects:
     dependencies:
       '@tailwindcss/vite':
-        specifier: ^4.1.14
-        version: 4.1.14(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^4.1.18
+        version: 4.1.18(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@tanstack/query-core':
-        specifier: ^5.90.5
-        version: 5.90.5
+        specifier: ^5.90.16
+        version: 5.90.16
       '@tanstack/query-db-collection':
-        specifier: ^0.2.32
+        specifier: ^1.0.21
         version: link:../../../packages/query-db-collection
       '@tanstack/react-db':
-        specifier: ^0.1.33
+        specifier: ^0.1.68
         version: link:../../../packages/react-db
       '@tanstack/react-router':
-        specifier: ^1.133.15
-        version: 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+        specifier: ^1.144.0
+        version: 1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       '@tanstack/react-router-devtools':
-        specifier: ^1.133.15
-        version: 1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(@tanstack/router-core@1.133.15)(@types/node@24.7.0)(csstype@3.1.3)(jiti@2.6.0)(lightningcss@1.30.1)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)(sass@1.90.0)(solid-js@1.9.9)(terser@5.44.0)(tiny-invariant@1.3.3)(tsx@4.20.6)(yaml@2.8.1)
+        specifier: ^1.144.0
+        version: 1.144.0(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(@tanstack/router-core@1.144.0)(csstype@3.2.3)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)
       '@tanstack/react-router-with-query':
         specifier: ^1.130.17
-        version: 1.130.17(@tanstack/react-query@5.83.0(react@19.2.0))(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(@tanstack/router-core@1.133.15)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+        version: 1.130.17(@tanstack/react-query@5.90.16(react@19.2.3))(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(@tanstack/router-core@1.144.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       '@tanstack/react-start':
-        specifier: ^1.133.15
-        version: 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^1.145.5
+        version: 1.145.5(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@tanstack/router-plugin':
-        specifier: ^1.133.15
-        version: 1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^1.145.4
+        version: 1.145.4(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@trpc/client':
-        specifier: ^11.6.0
-        version: 11.6.0(@trpc/server@11.6.0(typescript@5.9.3))(typescript@5.9.3)
+        specifier: ^11.8.1
+        version: 11.8.1(@trpc/server@11.8.1(typescript@5.9.3))(typescript@5.9.3)
       '@trpc/server':
-        specifier: ^11.6.0
-        version: 11.6.0(typescript@5.9.3)
+        specifier: ^11.8.1
+        version: 11.8.1(typescript@5.9.3)
       better-auth:
         specifier: ^1.3.26
-        version: 1.3.27(react-dom@19.2.0(react@19.2.0))(react@19.2.0)(solid-js@1.9.9)
+        version: 1.3.26(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)
       dotenv:
         specifier: ^17.2.3
         version: 17.2.3
       drizzle-orm:
-        specifier: ^0.44.6
-        version: 0.44.6(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7)
+        specifier: ^0.45.1
+        version: 0.45.1(@opentelemetry/api@1.9.0)(@types/pg@8.16.0)(gel@2.1.1)(kysely@0.28.8)(pg@8.16.3)(postgres@3.4.7)
       drizzle-zod:
         specifier: ^0.8.3
-        version: 0.8.3(drizzle-orm@0.44.6(@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)
+        version: 0.8.3(drizzle-orm@0.45.1(@opentelemetry/api@1.9.0)(@types/pg@8.16.0)(gel@2.1.1)(kysely@0.28.8)(pg@8.16.3)(postgres@3.4.7))(zod@4.1.13)
       pg:
         specifier: ^8.16.3
         version: 8.16.3
       react:
-        specifier: ^19.2.0
-        version: 19.2.0
+        specifier: ^19.2.3
+        version: 19.2.3
       react-dom:
-        specifier: ^19.2.0
-        version: 19.2.0(react@19.2.0)
+        specifier: ^19.2.3
+        version: 19.2.3(react@19.2.3)
       tailwindcss:
-        specifier: ^4.1.14
-        version: 4.1.14
+        specifier: ^4.1.18
+        version: 4.1.18
       vite:
-        specifier: ^6.3.5
-        version: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+        specifier: ^7.3.0
+        version: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
       vite-tsconfig-paths:
         specifier: ^5.1.4
-        version: 5.1.4(typescript@5.9.3)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 5.1.4(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       zod:
         specifier: ^4.1.11
-        version: 4.1.11
+        version: 4.1.13
     devDependencies:
       '@eslint/compat':
-        specifier: ^1.4.0
-        version: 1.4.0(eslint@9.38.0(jiti@2.6.0))
+        specifier: ^1.4.1
+        version: 1.4.1(eslint@9.39.2(jiti@2.6.1))
       '@eslint/js':
-        specifier: ^9.38.0
-        version: 9.38.0
+        specifier: ^9.39.2
+        version: 9.39.2
       '@testing-library/dom':
         specifier: ^10.4.1
         version: 10.4.1
       '@testing-library/react':
-        specifier: ^16.3.0
-        version: 16.3.0(@testing-library/dom@10.4.1)(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+        specifier: ^16.3.1
+        version: 16.3.1(@testing-library/dom@10.4.1)(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       '@types/pg':
-        specifier: ^8.15.5
-        version: 8.15.5
+        specifier: ^8.16.0
+        version: 8.16.0
       '@types/react':
-        specifier: ^19.2.2
-        version: 19.2.2
+        specifier: ^19.2.7
+        version: 19.2.7
       '@types/react-dom':
-        specifier: ^19.2.2
-        version: 19.2.2(@types/react@19.2.2)
+        specifier: ^19.2.3
+        version: 19.2.3(@types/react@19.2.7)
       '@typescript-eslint/eslint-plugin':
-        specifier: ^8.46.1
-        version: 8.46.1(@typescript-eslint/parser@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        specifier: ^8.51.0
+        version: 8.51.0(@typescript-eslint/parser@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       '@typescript-eslint/parser':
-        specifier: ^8.46.1
-        version: 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        specifier: ^8.51.0
+        version: 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       '@vitejs/plugin-react':
-        specifier: ^5.0.4
-        version: 5.0.4(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^5.1.2
+        version: 5.1.2(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       concurrently:
         specifier: ^9.2.1
         version: 9.2.1
       drizzle-kit:
-        specifier: ^0.31.5
-        version: 0.31.5
+        specifier: ^0.31.8
+        version: 0.31.8
       eslint:
-        specifier: ^9.38.0
-        version: 9.38.0(jiti@2.6.0)
+        specifier: ^9.39.2
+        version: 9.39.2(jiti@2.6.1)
       eslint-config-prettier:
         specifier: ^10.1.8
-        version: 10.1.8(eslint@9.38.0(jiti@2.6.0))
+        version: 10.1.8(eslint@9.39.2(jiti@2.6.1))
       eslint-plugin-prettier:
         specifier: ^5.5.4
-        version: 5.5.4(eslint-config-prettier@10.1.8(eslint@9.38.0(jiti@2.6.0)))(eslint@9.38.0(jiti@2.6.0))(prettier@3.6.2)
+        version: 5.5.4(eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@2.6.1)))(eslint@9.39.2(jiti@2.6.1))(prettier@3.7.4)
       eslint-plugin-react:
         specifier: ^7.37.5
-        version: 7.37.5(eslint@9.38.0(jiti@2.6.0))
+        version: 7.37.5(eslint@9.39.2(jiti@2.6.1))
       globals:
-        specifier: ^16.4.0
-        version: 16.4.0
+        specifier: ^16.5.0
+        version: 16.5.0
       jsdom:
-        specifier: ^27.0.0
-        version: 27.0.1(postcss@8.5.6)
+        specifier: ^27.4.0
+        version: 27.4.0
       prettier:
-        specifier: ^3.6.2
-        version: 3.6.2
+        specifier: ^3.7.4
+        version: 3.7.4
       tsx:
-        specifier: ^4.20.6
-        version: 4.20.6
+        specifier: ^4.21.0
+        version: 4.21.0
       typescript:
         specifier: ^5.9.2
         version: 5.9.3
       vitest:
         specifier: ^3.2.4
-        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
       web-vitals:
         specifier: ^5.1.0
         version: 5.1.0
@@ -329,229 +518,229 @@ importers:
   examples/react/todo:
     dependencies:
       '@tanstack/electric-db-collection':
-        specifier: workspace:^
+        specifier: ^0.2.30
         version: link:../../../packages/electric-db-collection
       '@tanstack/query-core':
-        specifier: ^5.90.5
-        version: 5.90.5
+        specifier: ^5.90.16
+        version: 5.90.16
       '@tanstack/query-db-collection':
-        specifier: workspace:*
+        specifier: ^1.0.21
         version: link:../../../packages/query-db-collection
       '@tanstack/react-db':
-        specifier: workspace:*
+        specifier: ^0.1.68
         version: link:../../../packages/react-db
       '@tanstack/react-router':
-        specifier: ^1.133.15
-        version: 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+        specifier: ^1.144.0
+        version: 1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       '@tanstack/react-start':
-        specifier: ^1.133.15
-        version: 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^1.145.5
+        version: 1.145.5(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@tanstack/trailbase-db-collection':
-        specifier: workspace:^
+        specifier: ^0.1.68
         version: link:../../../packages/trailbase-db-collection
       cors:
         specifier: ^2.8.5
         version: 2.8.5
       drizzle-orm:
-        specifier: ^0.44.6
-        version: 0.44.6(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7)
+        specifier: ^0.45.1
+        version: 0.45.1(@opentelemetry/api@1.9.0)(@types/pg@8.16.0)(gel@2.1.1)(kysely@0.28.8)(pg@8.16.3)(postgres@3.4.7)
       drizzle-zod:
         specifier: ^0.8.3
-        version: 0.8.3(drizzle-orm@0.44.6(@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)
+        version: 0.8.3(drizzle-orm@0.45.1(@opentelemetry/api@1.9.0)(@types/pg@8.16.0)(gel@2.1.1)(kysely@0.28.8)(pg@8.16.3)(postgres@3.4.7))(zod@4.1.13)
       express:
-        specifier: ^4.21.2
-        version: 4.21.2
+        specifier: ^5.0.1
+        version: 5.1.0
       postgres:
         specifier: ^3.4.7
         version: 3.4.7
       react:
-        specifier: ^19.2.0
-        version: 19.2.0
+        specifier: ^19.2.3
+        version: 19.2.3
       react-dom:
-        specifier: ^19.2.0
-        version: 19.2.0(react@19.2.0)
+        specifier: ^19.2.3
+        version: 19.2.3(react@19.2.3)
       tailwindcss:
-        specifier: ^4.1.14
-        version: 4.1.14
+        specifier: ^4.1.18
+        version: 4.1.18
       trailbase:
         specifier: ^0.8.0
         version: 0.8.0
       vite-tsconfig-paths:
         specifier: ^5.1.4
-        version: 5.1.4(typescript@5.9.3)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 5.1.4(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       zod:
         specifier: ^4.1.11
-        version: 4.1.11
+        version: 4.1.13
     devDependencies:
       '@eslint/js':
-        specifier: ^9.38.0
-        version: 9.38.0
+        specifier: ^9.39.2
+        version: 9.39.2
       '@tailwindcss/vite':
-        specifier: ^4.1.14
-        version: 4.1.14(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^4.1.18
+        version: 4.1.18(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@types/cors':
         specifier: ^2.8.19
         version: 2.8.19
       '@types/express':
-        specifier: ^4.17.23
-        version: 4.17.23
+        specifier: ^5.0.0
+        version: 5.0.5
       '@types/node':
-        specifier: ^24.5.2
+        specifier: ^24.6.2
         version: 24.7.0
       '@types/pg':
-        specifier: ^8.15.5
-        version: 8.15.5
+        specifier: ^8.16.0
+        version: 8.16.0
       '@types/react':
-        specifier: ^19.2.2
-        version: 19.2.2
+        specifier: ^19.2.7
+        version: 19.2.7
       '@types/react-dom':
-        specifier: ^19.2.2
-        version: 19.2.2(@types/react@19.2.2)
+        specifier: ^19.2.3
+        version: 19.2.3(@types/react@19.2.7)
       '@typescript-eslint/eslint-plugin':
-        specifier: ^8.46.1
-        version: 8.46.1(@typescript-eslint/parser@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        specifier: ^8.51.0
+        version: 8.51.0(@typescript-eslint/parser@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       '@typescript-eslint/parser':
-        specifier: ^8.46.1
-        version: 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        specifier: ^8.51.0
+        version: 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       '@vitejs/plugin-react':
-        specifier: ^5.0.3
-        version: 5.0.4(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^5.1.2
+        version: 5.1.2(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       concurrently:
         specifier: ^9.2.1
         version: 9.2.1
       dotenv:
-        specifier: ^17.2.2
+        specifier: ^17.2.3
         version: 17.2.3
       drizzle-kit:
-        specifier: ^0.31.5
-        version: 0.31.5
+        specifier: ^0.31.8
+        version: 0.31.8
       eslint:
-        specifier: ^9.38.0
-        version: 9.38.0(jiti@2.6.0)
+        specifier: ^9.39.2
+        version: 9.39.2(jiti@2.6.1)
       eslint-plugin-react-hooks:
         specifier: ^5.2.0
-        version: 5.2.0(eslint@9.38.0(jiti@2.6.0))
+        version: 5.2.0(eslint@9.39.2(jiti@2.6.1))
       eslint-plugin-react-refresh:
-        specifier: ^0.4.24
-        version: 0.4.24(eslint@9.38.0(jiti@2.6.0))
+        specifier: ^0.4.26
+        version: 0.4.26(eslint@9.39.2(jiti@2.6.1))
       pg:
         specifier: ^8.16.3
         version: 8.16.3
       tsx:
-        specifier: ^4.20.6
-        version: 4.20.6
+        specifier: ^4.21.0
+        version: 4.21.0
       typescript:
         specifier: ^5.9.2
         version: 5.9.3
       vite:
-        specifier: ^6.1.1
-        version: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+        specifier: ^7.3.0
+        version: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
 
   examples/solid/todo:
     dependencies:
       '@tanstack/electric-db-collection':
-        specifier: ^0.1.35
+        specifier: ^0.2.30
         version: link:../../../packages/electric-db-collection
       '@tanstack/query-core':
-        specifier: ^5.90.5
-        version: 5.90.5
+        specifier: ^5.90.16
+        version: 5.90.16
       '@tanstack/query-db-collection':
-        specifier: ^0.2.32
+        specifier: ^1.0.21
         version: link:../../../packages/query-db-collection
       '@tanstack/solid-db':
-        specifier: ^0.1.33
+        specifier: ^0.2.4
         version: link:../../../packages/solid-db
       '@tanstack/solid-router':
-        specifier: ^1.133.15
-        version: 1.133.15(solid-js@1.9.9)
+        specifier: ^1.144.0
+        version: 1.144.0(solid-js@1.9.10)
       '@tanstack/solid-start':
-        specifier: ^1.133.15
-        version: 1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(solid-js@1.9.9)(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^1.145.5
+        version: 1.145.5(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(solid-js@1.9.10)(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@tanstack/trailbase-db-collection':
-        specifier: ^0.1.33
+        specifier: ^0.1.68
         version: link:../../../packages/trailbase-db-collection
       cors:
         specifier: ^2.8.5
         version: 2.8.5
       drizzle-orm:
-        specifier: ^0.44.6
-        version: 0.44.6(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7)
+        specifier: ^0.45.1
+        version: 0.45.1(@opentelemetry/api@1.9.0)(@types/pg@8.16.0)(gel@2.1.1)(kysely@0.28.8)(pg@8.16.3)(postgres@3.4.7)
       drizzle-zod:
         specifier: ^0.8.3
-        version: 0.8.3(drizzle-orm@0.44.6(@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.45.1(@opentelemetry/api@1.9.0)(@types/pg@8.16.0)(gel@2.1.1)(kysely@0.28.8)(pg@8.16.3)(postgres@3.4.7))(zod@4.1.13)
       express:
-        specifier: ^4.21.2
-        version: 4.21.2
+        specifier: ^5.0.1
+        version: 5.1.0
       postgres:
         specifier: ^3.4.7
         version: 3.4.7
       solid-js:
-        specifier: ^1.9.9
-        version: 1.9.9
+        specifier: ^1.9.10
+        version: 1.9.10
       tailwindcss:
-        specifier: ^4.1.14
-        version: 4.1.14
+        specifier: ^4.1.18
+        version: 4.1.18
       trailbase:
         specifier: ^0.8.0
         version: 0.8.0
       vite-tsconfig-paths:
         specifier: ^5.1.4
-        version: 5.1.4(typescript@5.9.3)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 5.1.4(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
     devDependencies:
       '@eslint/js':
-        specifier: ^9.38.0
-        version: 9.38.0
+        specifier: ^9.39.2
+        version: 9.39.2
       '@tailwindcss/vite':
-        specifier: ^4.1.14
-        version: 4.1.14(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^4.1.18
+        version: 4.1.18(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@types/cors':
         specifier: ^2.8.19
         version: 2.8.19
       '@types/express':
-        specifier: ^4.17.23
-        version: 4.17.23
+        specifier: ^5.0.0
+        version: 5.0.5
       '@types/node':
-        specifier: ^22.18.1
-        version: 22.18.1
+        specifier: ^24.6.2
+        version: 24.7.0
       '@types/pg':
-        specifier: ^8.15.5
-        version: 8.15.5
+        specifier: ^8.16.0
+        version: 8.16.0
       '@typescript-eslint/eslint-plugin':
-        specifier: ^8.46.1
-        version: 8.46.1(@typescript-eslint/parser@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        specifier: ^8.51.0
+        version: 8.51.0(@typescript-eslint/parser@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       '@typescript-eslint/parser':
-        specifier: ^8.46.1
-        version: 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        specifier: ^8.51.0
+        version: 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       concurrently:
         specifier: ^9.2.1
         version: 9.2.1
       dotenv:
-        specifier: ^16.6.1
-        version: 16.6.1
+        specifier: ^17.2.3
+        version: 17.2.3
       drizzle-kit:
-        specifier: ^0.31.5
-        version: 0.31.5
+        specifier: ^0.31.8
+        version: 0.31.8
       eslint:
-        specifier: ^9.38.0
-        version: 9.38.0(jiti@2.6.0)
+        specifier: ^9.39.2
+        version: 9.39.2(jiti@2.6.1)
       eslint-plugin-solid:
         specifier: ^0.14.5
-        version: 0.14.5(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+        version: 0.14.5(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       pg:
         specifier: ^8.16.3
         version: 8.16.3
       tsx:
-        specifier: ^4.20.6
-        version: 4.20.6
+        specifier: ^4.21.0
+        version: 4.21.0
       typescript:
         specifier: ^5.9.2
         version: 5.9.3
       vite:
-        specifier: ^6.3.6
-        version: 6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+        specifier: ^7.3.0
+        version: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
       vite-plugin-solid:
-        specifier: ^2.11.9
-        version: 2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^2.11.10
+        version: 2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
 
   packages/angular-db:
     dependencies:
@@ -560,52 +749,97 @@ importers:
         version: link:../db
     devDependencies:
       '@angular/common':
-        specifier: ^19.2.15
-        version: 19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2)
+        specifier: ^19.2.17
+        version: 19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2)
       '@angular/compiler':
-        specifier: ^19.2.15
-        version: 19.2.15
+        specifier: ^20.3.15
+        version: 20.3.16
       '@angular/core':
-        specifier: ^19.2.15
-        version: 19.2.15(rxjs@7.8.2)(zone.js@0.15.1)
+        specifier: ^19.2.17
+        version: 19.2.18(rxjs@7.8.2)(zone.js@0.16.0)
       '@angular/platform-browser':
-        specifier: ^19.2.15
-        version: 19.2.15(@angular/common@19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))
+        specifier: ^19.2.17
+        version: 19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))
       '@angular/platform-browser-dynamic':
-        specifier: ^19.2.15
-        version: 19.2.15(@angular/common@19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/compiler@19.2.15)(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(@angular/platform-browser@19.2.15(@angular/common@19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1)))
+        specifier: ^19.2.17
+        version: 19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/compiler@20.3.16)(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(@angular/platform-browser@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0)))
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
       rxjs:
         specifier: ^7.8.2
         version: 7.8.2
       zone.js:
-        specifier: ^0.15.1
-        version: 0.15.1
+        specifier: ^0.16.0
+        version: 0.16.0
 
   packages/db:
     dependencies:
       '@standard-schema/spec':
-        specifier: ^1.0.0
-        version: 1.0.0
+        specifier: ^1.1.0
+        version: 1.1.0
       '@tanstack/db-ivm':
         specifier: workspace:*
         version: link:../db-ivm
+      '@tanstack/pacer-lite':
+        specifier: ^0.2.0
+        version: 0.2.0
       typescript:
         specifier: '>=4.7'
         version: 5.9.3
     devDependencies:
+      '@tanstack/config':
+        specifier: ^0.22.2
+        version: 0.22.2(@types/node@24.7.0)(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(rollup@4.52.5)(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
       arktype:
-        specifier: ^2.1.23
-        version: 2.1.23
+        specifier: ^2.1.29
+        version: 2.1.29
+      mitt:
+        specifier: ^3.0.1
+        version: 3.0.1
+      superjson:
+        specifier: ^2.2.6
+        version: 2.2.6
       temporal-polyfill:
         specifier: ^0.3.0
         version: 0.3.0
 
+  packages/db-collection-e2e:
+    dependencies:
+      '@tanstack/db':
+        specifier: workspace:*
+        version: link:../db
+      '@tanstack/electric-db-collection':
+        specifier: workspace:*
+        version: link:../electric-db-collection
+      '@tanstack/query-db-collection':
+        specifier: workspace:*
+        version: link:../query-db-collection
+      pg:
+        specifier: ^8.16.3
+        version: 8.16.3
+    devDependencies:
+      '@types/pg':
+        specifier: ^8.16.0
+        version: 8.16.0
+      '@vitest/ui':
+        specifier: ^3.2.4
+        version: 3.2.4(vitest@3.2.4)
+      typescript:
+        specifier: ^5.9.2
+        version: 5.9.3
+      vite:
+        specifier: ^7.3.0
+        version: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+      vitest:
+        specifier: ^3.2.4
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+
+  packages/db-collections: {}
+
   packages/db-ivm:
     dependencies:
       fractional-indexing:
@@ -623,16 +857,69 @@ importers:
         version: 4.1.12
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
 
   packages/electric-db-collection:
     dependencies:
       '@electric-sql/client':
-        specifier: ^1.0.14
-        version: 1.0.14
+        specifier: ^1.3.1
+        version: 1.3.1
+      '@standard-schema/spec':
+        specifier: ^1.1.0
+        version: 1.1.0
+      '@tanstack/db':
+        specifier: workspace:*
+        version: link:../db
+      '@tanstack/store':
+        specifier: ^0.8.0
+        version: 0.8.0
+      debug:
+        specifier: ^4.4.3
+        version: 4.4.3
+    devDependencies:
+      '@types/debug':
+        specifier: ^4.1.12
+        version: 4.1.12
+      '@types/pg':
+        specifier: ^8.16.0
+        version: 8.16.0
+      '@vitest/coverage-istanbul':
+        specifier: ^3.2.4
+        version: 3.2.4(vitest@3.2.4)
+      pg:
+        specifier: ^8.16.3
+        version: 8.16.3
+
+  packages/offline-transactions:
+    dependencies:
+      '@tanstack/db':
+        specifier: workspace:*
+        version: link:../db
+    devDependencies:
+      '@react-native-community/netinfo':
+        specifier: 11.4.1
+        version: 11.4.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      '@types/node':
+        specifier: ^24.6.2
+        version: 24.7.0
+      eslint:
+        specifier: ^9.39.2
+        version: 9.39.2(jiti@2.6.1)
+      react-native:
+        specifier: 0.79.6
+        version: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+      typescript:
+        specifier: ^5.9.2
+        version: 5.9.3
+      vitest:
+        specifier: ^3.2.4
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+
+  packages/powersync-db-collection:
+    dependencies:
       '@standard-schema/spec':
-        specifier: ^1.0.0
-        version: 1.0.0
+        specifier: ^1.1.0
+        version: 1.1.0
       '@tanstack/db':
         specifier: workspace:*
         version: link:../db
@@ -642,19 +929,28 @@ importers:
       debug:
         specifier: ^4.4.3
         version: 4.4.3
+      p-defer:
+        specifier: ^4.0.1
+        version: 4.0.1
     devDependencies:
+      '@powersync/common':
+        specifier: ^1.44.0
+        version: 1.44.0
+      '@powersync/node':
+        specifier: ^0.15.1
+        version: 0.15.1(@powersync/common@1.44.0)
       '@types/debug':
         specifier: ^4.1.12
         version: 4.1.12
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
 
   packages/query-db-collection:
     dependencies:
       '@standard-schema/spec':
-        specifier: ^1.0.0
-        version: 1.0.0
+        specifier: ^1.1.0
+        version: 1.1.0
       '@tanstack/db':
         specifier: workspace:*
         version: link:../db
@@ -663,11 +959,11 @@ importers:
         version: 5.9.3
     devDependencies:
       '@tanstack/query-core':
-        specifier: ^5.90.5
-        version: 5.90.5
+        specifier: ^5.90.16
+        version: 5.90.16
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
 
   packages/react-db:
     dependencies:
@@ -676,38 +972,38 @@ importers:
         version: link:../db
       use-sync-external-store:
         specifier: ^1.6.0
-        version: 1.6.0(react@19.2.0)
+        version: 1.6.0(react@19.2.3)
     devDependencies:
       '@electric-sql/client':
-        specifier: 1.0.14
-        version: 1.0.14
+        specifier: ^1.3.1
+        version: 1.3.1
       '@testing-library/react':
-        specifier: ^16.3.0
-        version: 16.3.0(@testing-library/dom@10.4.1)(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+        specifier: ^16.3.1
+        version: 16.3.1(@testing-library/dom@10.4.1)(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       '@types/react':
-        specifier: ^19.2.2
-        version: 19.2.2
+        specifier: ^19.2.7
+        version: 19.2.7
       '@types/react-dom':
-        specifier: ^19.2.2
-        version: 19.2.2(@types/react@19.2.2)
+        specifier: ^19.2.3
+        version: 19.2.3(@types/react@19.2.7)
       '@types/use-sync-external-store':
         specifier: ^1.5.0
         version: 1.5.0
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
       react:
-        specifier: ^19.2.0
-        version: 19.2.0
+        specifier: ^19.2.3
+        version: 19.2.3
       react-dom:
-        specifier: ^19.2.0
-        version: 19.2.0(react@19.2.0)
+        specifier: ^19.2.3
+        version: 19.2.3(react@19.2.3)
 
   packages/rxdb-db-collection:
     dependencies:
       '@standard-schema/spec':
-        specifier: ^1.0.0
-        version: 1.0.0
+        specifier: ^1.1.0
+        version: 1.1.0
       '@tanstack/db':
         specifier: workspace:*
         version: link:../db
@@ -718,8 +1014,8 @@ importers:
         specifier: ^4.4.3
         version: 4.4.3
       rxdb:
-        specifier: 16.19.1
-        version: 16.19.1(rxjs@7.8.2)(socks@2.8.7)
+        specifier: 16.21.1
+        version: 16.21.1(rxjs@7.8.2)(socks@2.8.7)
       rxjs:
         specifier: '>=7.8.2'
         version: 7.8.2
@@ -732,38 +1028,38 @@ importers:
         version: 4.1.12
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
 
   packages/solid-db:
     dependencies:
       '@solid-primitives/map':
         specifier: ^0.7.2
-        version: 0.7.2(solid-js@1.9.9)
+        version: 0.7.2(solid-js@1.9.10)
       '@tanstack/db':
         specifier: workspace:*
         version: link:../db
     devDependencies:
       '@electric-sql/client':
-        specifier: 1.0.14
-        version: 1.0.14
+        specifier: ^1.3.1
+        version: 1.3.1
       '@solidjs/testing-library':
         specifier: ^0.8.10
-        version: 0.8.10(solid-js@1.9.9)
+        version: 0.8.10(solid-js@1.9.10)
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
       jsdom:
-        specifier: ^27.0.1
-        version: 27.0.1(postcss@8.5.6)
+        specifier: ^27.4.0
+        version: 27.4.0
       solid-js:
-        specifier: ^1.9.9
-        version: 1.9.9
+        specifier: ^1.9.10
+        version: 1.9.10
       vite-plugin-solid:
-        specifier: ^2.11.9
-        version: 2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        specifier: ^2.11.10
+        version: 2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       vitest:
         specifier: ^3.2.4
-        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
 
   packages/svelte-db:
     dependencies:
@@ -772,29 +1068,29 @@ importers:
         version: link:../db
     devDependencies:
       '@sveltejs/package':
-        specifier: ^2.5.4
-        version: 2.5.4(svelte@5.41.0)(typescript@5.9.3)
+        specifier: ^2.5.7
+        version: 2.5.7(svelte@5.46.4)(typescript@5.9.3)
       '@sveltejs/vite-plugin-svelte':
         specifier: ^6.2.1
-        version: 6.2.1(svelte@5.41.0)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 6.2.1(svelte@5.46.4)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
       publint:
-        specifier: ^0.3.14
-        version: 0.3.14
+        specifier: ^0.3.16
+        version: 0.3.16
       svelte:
-        specifier: ^5.41.0
-        version: 5.41.0
+        specifier: ^5.46.1
+        version: 5.46.4
       svelte-check:
-        specifier: ^4.3.3
-        version: 4.3.3(picomatch@4.0.3)(svelte@5.41.0)(typescript@5.9.3)
+        specifier: ^4.3.5
+        version: 4.3.5(picomatch@4.0.3)(svelte@5.46.4)(typescript@5.9.3)
 
   packages/trailbase-db-collection:
     dependencies:
       '@standard-schema/spec':
-        specifier: ^1.0.0
-        version: 1.0.0
+        specifier: ^1.1.0
+        version: 1.1.0
       '@tanstack/db':
         specifier: workspace:*
         version: link:../db
@@ -816,7 +1112,7 @@ importers:
         version: 4.1.12
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
 
   packages/vue-db:
     dependencies:
@@ -825,20 +1121,31 @@ importers:
         version: link:../db
     devDependencies:
       '@electric-sql/client':
-        specifier: 1.0.14
-        version: 1.0.14
+        specifier: ^1.3.1
+        version: 1.3.1
       '@vitejs/plugin-vue':
-        specifier: ^6.0.1
-        version: 6.0.1(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))(vue@3.5.22(typescript@5.9.3))
+        specifier: ^6.0.3
+        version: 6.0.3(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))(vue@3.5.26(typescript@5.9.3))
       '@vitest/coverage-istanbul':
         specifier: ^3.2.4
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+        version: 3.2.4(vitest@3.2.4)
       vue:
-        specifier: ^3.5.22
-        version: 3.5.22(typescript@5.9.3)
+        specifier: ^3.5.26
+        version: 3.5.26(typescript@5.9.3)
 
 packages:
 
+  '@0no-co/graphql.web@1.2.0':
+    resolution: {integrity: sha512-/1iHy9TTr63gE1YcR5idjx8UREz1s0kFhydf3bBLCXyqjhkIc6igAzTOx3zPifCwFR87tsh/4Pa9cNts6d2otw==}
+    peerDependencies:
+      graphql: ^14.0.0 || ^15.0.0 || ^16.0.0
+    peerDependenciesMeta:
+      graphql:
+        optional: true
+
+  '@acemir/cssom@0.9.30':
+    resolution: {integrity: sha512-9CnlMCI0LmCIq0olalQqdWrJHPzm0/tw3gzOA9zJSgvFX7Xau3D24mAGa4BtwxwY69nsuJW6kQqqCzf/mEcQgg==}
+
   '@adobe/css-tools@4.4.4':
     resolution: {integrity: sha512-Elp+iwUx5rN5+Y8xLt5/GRoG20WGoDCQ/1Fb+1LiGtvwbDavuSk0jhD/eZdckHAuzcDzccnkv+rEjyWfRx18gg==}
 
@@ -906,12 +1213,12 @@ packages:
     resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==}
     engines: {node: '>=6.0.0'}
 
-  '@angular-devkit/architect@0.2003.6':
-    resolution: {integrity: sha512-VtXxfJzrBZ8MQN83shXNaTUaLSOIwa+4/3LD5drxSnHuYJrz+d3FIApWAxcA9QzucsTDZwXyFxaWZN/e5XVm6g==}
+  '@angular-devkit/architect@0.2003.13':
+    resolution: {integrity: sha512-JyH6Af6PNC1IHJToColFk1RaXDU87mpPjz7M5sWDfn8bC+KBipw6dSdRkCEuw0D9HY1lZkC9EBV9k9GhpvHjCQ==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: ^6.11.0 || ^7.5.6 || >=8.0.0, yarn: '>= 1.13.0'}
 
-  '@angular-devkit/core@20.3.6':
-    resolution: {integrity: sha512-uLRk3865Iz/EO9Zm/mrFfdyoZinJBihXE6HVDYRYjAqsgW14LsD8pkpWy9+LYlOwcH96Ndnev+msxaTJaNXtPg==}
+  '@angular-devkit/core@20.3.13':
+    resolution: {integrity: sha512-/D84T1Caxll3I2sRihPDR9UaWBhF50M+tAX15PdP6uSh/TxwAlLl9p7Rm1bD0mPjPercqaEKA+h9a9qLP16hug==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: ^6.11.0 || ^7.5.6 || >=8.0.0, yarn: '>= 1.13.0'}
     peerDependencies:
       chokidar: ^4.0.0
@@ -919,12 +1226,12 @@ packages:
       chokidar:
         optional: true
 
-  '@angular-devkit/schematics@20.3.6':
-    resolution: {integrity: sha512-QD7QS1oR0XcZ9ZI4D1c4JjKmSn2up/ocOU2FS1mMO7S5RtAZMsPv4J3r+6ywHA2ev2sRySOQ0D8OYBcEuYX9Jw==}
+  '@angular-devkit/schematics@20.3.13':
+    resolution: {integrity: sha512-hdMKY4rUTko8xqeWYGnwwDYDomkeOoLsYsP6SdaHWK7hpGvzWsT6Q/aIv8J8NrCYkLu+M+5nLiKOooweUZu3GQ==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: ^6.11.0 || ^7.5.6 || >=8.0.0, yarn: '>= 1.13.0'}
 
-  '@angular/build@20.3.6':
-    resolution: {integrity: sha512-O5qyxCCe77tu1zy9XudKxqFqi5zih0ZI8J8Anra/ZZdtTKbLMprXMGFzMYzwCqvcIzzbmOumkSJKoXbFazHaaw==}
+  '@angular/build@20.3.13':
+    resolution: {integrity: sha512-/5pM3ZS+lLkZgA+n6TMmNV8I6t9Ow1C6Vkj6bXqWeOgFDH5LwnIEZFAKzEDBkCGos0m2gPKPcREcDD5tfp9h4g==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: ^6.11.0 || ^7.5.6 || >=8.0.0, yarn: '>= 1.13.0'}
     peerDependencies:
       '@angular/compiler': ^20.0.0
@@ -934,7 +1241,7 @@ packages:
       '@angular/platform-browser': ^20.0.0
       '@angular/platform-server': ^20.0.0
       '@angular/service-worker': ^20.0.0
-      '@angular/ssr': ^20.3.6
+      '@angular/ssr': ^20.3.13
       karma: ^6.4.0
       less: ^4.2.0
       ng-packagr: ^20.0.0
@@ -969,187 +1276,163 @@ packages:
       vitest:
         optional: true
 
-  '@angular/cli@20.3.6':
-    resolution: {integrity: sha512-1RozAub7Gcl5ES3vBYatIgoMDgujlvySwHARoYT+1VhbYvM0RTt4sn2aDhHxqG0GcyiXR5zISkzJvldaY2nQCQ==}
+  '@angular/cli@20.3.13':
+    resolution: {integrity: sha512-G78I/HDJULloS2LSqfUfbmBlhDCbcWujIRWfuMnGsRf82TyGA2OEPe3IA/F8MrJfeOzPQim2fMyn24MqHL40Vg==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: ^6.11.0 || ^7.5.6 || >=8.0.0, yarn: '>= 1.13.0'}
     hasBin: true
 
-  '@angular/common@19.2.15':
-    resolution: {integrity: sha512-aVa/ctBYH/4qgA7r4sS7TV+/DzRYmcS+3d6l89pNKUXkI8gpmsd+r3FjccaemX4Wqru1QOrMvC+i+e7IBIVv0g==}
+  '@angular/common@19.2.17':
+    resolution: {integrity: sha512-yFUXAdpvOFirGD/EGDwp1WHravHzI4sdyRE2iH7i8im9l8IE2VZ6D1KDJp8VVpMJt38LNlRAWYek3s+z6OcAkg==}
     engines: {node: ^18.19.1 || ^20.11.1 || >=22.0.0}
     peerDependencies:
-      '@angular/core': 19.2.15
-      rxjs: ^6.5.3 || ^7.4.0
-
-  '@angular/common@20.3.6':
-    resolution: {integrity: sha512-+gHMuFe0wz4f+vfGZ2q+fSQSYaY7KlN7QdDrFqLnA7H2sythzhXvRbXEtp4DkPjihh9gupXg2MeLh1ROy5AfSw==}
-    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
-    peerDependencies:
-      '@angular/core': 20.3.6
+      '@angular/core': 19.2.17
       rxjs: ^6.5.3 || ^7.4.0
 
-  '@angular/compiler-cli@20.3.6':
-    resolution: {integrity: sha512-VOFRBx9fBt2jW9I8qD23fwGeKxBI8JssJBAMqnFPl3k59VJWHQi6LlXZCLCBNdfwflTJdKeRvdgT51Q0k6tnFQ==}
+  '@angular/compiler-cli@20.3.15':
+    resolution: {integrity: sha512-8sJoxodxsfyZ8eJ5r6Bx7BCbazXYgsZ1+dE8t5u5rTQ6jNggwNtYEzkyReoD5xvP+MMtRkos3xpwq4rtFnpI6A==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
     hasBin: true
     peerDependencies:
-      '@angular/compiler': 20.3.6
+      '@angular/compiler': 20.3.15
       typescript: '>=5.8 <6.0'
     peerDependenciesMeta:
       typescript:
         optional: true
 
-  '@angular/compiler@19.2.15':
-    resolution: {integrity: sha512-hMHZU6/03xG0tbPDIm1hbVSTFLnRkGYfh+xdBwUMnIFYYTS0QJ2hdPfEZKCJIXm+fz9IAI5MPdDTfeyp0sgaHQ==}
-    engines: {node: ^18.19.1 || ^20.11.1 || >=22.0.0}
-
-  '@angular/compiler@20.3.6':
-    resolution: {integrity: sha512-OdjXBsAsnn7qiW6fSHClwn9XwjVxhtO9+RbDc6Mf+YPCnJq0s8T78H2fc8VdJFp/Rs+tMZcwwjd9VZPm8+2XWA==}
+  '@angular/compiler@20.3.16':
+    resolution: {integrity: sha512-Pt9Ms9GwTThgzdxWBwMfN8cH1JEtQ2DK5dc2yxYtPSaD+WKmG9AVL1PrzIYQEbaKcWk2jxASUHpEWSlNiwo8uw==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
 
-  '@angular/core@19.2.15':
-    resolution: {integrity: sha512-PxhzCwwm23N4Mq6oV7UPoYiJF4r6FzGhRSxOBBlEp322k7zEQbIxd/XO6F3eoG73qC1UsOXMYYv6GnQpx42y3A==}
+  '@angular/core@19.2.18':
+    resolution: {integrity: sha512-+QRrf0Igt8ccUWXHA+7doK5W6ODyhHdqVyblSlcQ8OciwkzIIGGEYNZom5OZyWMh+oI54lcSeyV2O3xaDepSrQ==}
     engines: {node: ^18.19.1 || ^20.11.1 || >=22.0.0}
     peerDependencies:
       rxjs: ^6.5.3 || ^7.4.0
       zone.js: ~0.15.0
 
-  '@angular/core@20.3.6':
-    resolution: {integrity: sha512-sDURQWnjwE4Y750u/5qwkZEYMoI4CrKghnx4aKulxCnohR3//C78wvz6p8MtCuqYfzGkdQZDYFg8tgAz17qgPw==}
-    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
-    peerDependencies:
-      '@angular/compiler': 20.3.6
-      rxjs: ^6.5.3 || ^7.4.0
-      zone.js: ~0.15.0
-    peerDependenciesMeta:
-      '@angular/compiler':
-        optional: true
-      zone.js:
-        optional: true
-
-  '@angular/forms@20.3.6':
-    resolution: {integrity: sha512-tBGo/LBtCtSrClMY4DTm/3UiSjqLLMEYXS/4E0nW1mFDv7ulKnaAQB+KbfBmmTHYxlKLs+SxjKv6GoydMPSurA==}
+  '@angular/forms@20.3.15':
+    resolution: {integrity: sha512-gS5hQkinq52pm/7mxz4yHPCzEcmRWjtUkOVddPH0V1BW/HMni/p4Y6k2KqKBeGb9p8S5EAp6PDxDVLOPukp3mg==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
     peerDependencies:
-      '@angular/common': 20.3.6
-      '@angular/core': 20.3.6
-      '@angular/platform-browser': 20.3.6
+      '@angular/common': 20.3.15
+      '@angular/core': 20.3.15
+      '@angular/platform-browser': 20.3.15
       rxjs: ^6.5.3 || ^7.4.0
 
-  '@angular/platform-browser-dynamic@19.2.15':
-    resolution: {integrity: sha512-dKy0SS395FCh8cW9AQ8nf4Wn3XlONaH7z50T1bGxm3eOoRqjxJYyIeIlEbDdJakMz4QPR3dGr81HleZd8TJumQ==}
+  '@angular/platform-browser-dynamic@19.2.17':
+    resolution: {integrity: sha512-jrps9QKhuPrHBZwLv+43z+WldT4aVKZu8v7LPpRHb7/pVLvqccXtIxt3Ttm7sa4tc2SwlKazdE8/ezaNWIRnAg==}
     engines: {node: ^18.19.1 || ^20.11.1 || >=22.0.0}
     peerDependencies:
-      '@angular/common': 19.2.15
-      '@angular/compiler': 19.2.15
-      '@angular/core': 19.2.15
-      '@angular/platform-browser': 19.2.15
+      '@angular/common': 19.2.17
+      '@angular/compiler': 19.2.17
+      '@angular/core': 19.2.17
+      '@angular/platform-browser': 19.2.17
 
-  '@angular/platform-browser@19.2.15':
-    resolution: {integrity: sha512-OelQ6weCjon8kZD8kcqNzwugvZJurjS3uMJCwsA2vXmP/3zJ31SWtNqE2zLT1R2csVuwnp0h+nRMgq+pINU7Rg==}
+  '@angular/platform-browser@19.2.17':
+    resolution: {integrity: sha512-Rn23nIQwYMSeGXWFHI/X8bGHAkdahRxH9UIGUlJKxW61MSkK6AW4kCHG/Ev1TvDq9HjijsMjcqcsd6/Sb8aBXg==}
     engines: {node: ^18.19.1 || ^20.11.1 || >=22.0.0}
     peerDependencies:
-      '@angular/animations': 19.2.15
-      '@angular/common': 19.2.15
-      '@angular/core': 19.2.15
-    peerDependenciesMeta:
-      '@angular/animations':
-        optional: true
-
-  '@angular/platform-browser@20.3.6':
-    resolution: {integrity: sha512-gFp1yd+HtRN8XdpMatRLO5w6FLIzsnF31lD2Duo4BUTCoMAMdfaNT6FtcvNdKu7ANo27Ke26fxEEE2bh6FU98A==}
-    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
-    peerDependencies:
-      '@angular/animations': 20.3.6
-      '@angular/common': 20.3.6
-      '@angular/core': 20.3.6
+      '@angular/animations': 19.2.17
+      '@angular/common': 19.2.17
+      '@angular/core': 19.2.17
     peerDependenciesMeta:
       '@angular/animations':
         optional: true
 
-  '@angular/router@20.3.6':
-    resolution: {integrity: sha512-fSAYOR9nKpH5PoBYFNdII3nAFl2maUrYiISU33CnGwb7J7Q0s09k231c/P5tVN4URi+jdADVwiBI8cIYk8SVrg==}
+  '@angular/router@20.3.15':
+    resolution: {integrity: sha512-6+qgk8swGSoAu7ISSY//GatAyCP36hEvvUgvjbZgkXLLH9yUQxdo77ij05aJ5s0OyB25q/JkqS8VTY0z1yE9NQ==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
     peerDependencies:
-      '@angular/common': 20.3.6
-      '@angular/core': 20.3.6
-      '@angular/platform-browser': 20.3.6
+      '@angular/common': 20.3.15
+      '@angular/core': 20.3.15
+      '@angular/platform-browser': 20.3.15
       rxjs: ^6.5.3 || ^7.4.0
 
-  '@ark/regex@0.0.0':
-    resolution: {integrity: sha512-p4vsWnd/LRGOdGQglbwOguIVhPmCAf5UzquvnDoxqhhPWTP84wWgi1INea8MgJ4SnI2gp37f13oA4Waz9vwNYg==}
+  '@ark/schema@0.56.0':
+    resolution: {integrity: sha512-ECg3hox/6Z/nLajxXqNhgPtNdHWC9zNsDyskwO28WinoFEnWow4IsERNz9AnXRhTZJnYIlAJ4uGn3nlLk65vZA==}
 
-  '@ark/schema@0.50.0':
-    resolution: {integrity: sha512-hfmP82GltBZDadIOeR3argKNlYYyB2wyzHp0eeAqAOFBQguglMV/S7Ip2q007bRtKxIMLDqFY6tfPie1dtssaQ==}
+  '@ark/util@0.56.0':
+    resolution: {integrity: sha512-BghfRC8b9pNs3vBoDJhcta0/c1J1rsoS1+HgVUreMFPdhz/CRAKReAu57YEllNaSy98rWAdY1gE+gFup7OXpgA==}
 
-  '@ark/util@0.50.0':
-    resolution: {integrity: sha512-tIkgIMVRpkfXRQIEf0G2CJryZVtHVrqcWHMDa5QKo0OEEBu0tHkRSIMm4Ln8cd8Bn9TPZtvc/kE2Gma8RESPSg==}
+  '@asamuzakjp/css-color@4.1.1':
+    resolution: {integrity: sha512-B0Hv6G3gWGMn0xKJ0txEi/jM5iFpT3MfDxmhZFb4W047GvytCf1DHQ1D69W3zHI4yWe2aTZAA0JnbMZ7Xc8DuQ==}
 
-  '@asamuzakjp/css-color@4.0.5':
-    resolution: {integrity: sha512-lMrXidNhPGsDjytDy11Vwlb6OIGrT3CmLg3VWNFyWkLWtijKl7xjvForlh8vuj0SHGjgl4qZEQzUmYTeQA2JFQ==}
-
-  '@asamuzakjp/dom-selector@6.7.2':
-    resolution: {integrity: sha512-ccKogJI+0aiDhOahdjANIc9SDixSud1gbwdVrhn7kMopAtLXqsz9MKmQQtIl6Y5aC2IYq+j4dz/oedL2AVMmVQ==}
+  '@asamuzakjp/dom-selector@6.7.6':
+    resolution: {integrity: sha512-hBaJER6A9MpdG3WgdlOolHmbOYvSk46y7IQN/1+iqiCuUu6iWdQrs9DGKF8ocqsEqWujWf/V7b7vaDgiUmIvUg==}
 
   '@asamuzakjp/nwsapi@2.3.9':
     resolution: {integrity: sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==}
 
-  '@babel/code-frame@7.26.2':
-    resolution: {integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==}
-    engines: {node: '>=6.9.0'}
+  '@babel/code-frame@7.10.4':
+    resolution: {integrity: sha512-vG6SvB6oYEhvgisZNFRmRCUkLz11c7rp+tbNTynGqc6mS1d5ATd/sGyV6W0KZZnXRKMTzZDRgQT3Ou9jhpAfUg==}
 
   '@babel/code-frame@7.27.1':
     resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/compat-data@7.28.4':
-    resolution: {integrity: sha512-YsmSKC29MJwf0gF8Rjjrg5LQCmyh+j/nD8/eP7f+BeoQTKYqs9RoWbjGOdy0+1Ekr68RJZMUOPVQaQisnIo4Rw==}
+  '@babel/code-frame@7.28.6':
+    resolution: {integrity: sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/compat-data@7.28.6':
+    resolution: {integrity: sha512-2lfu57JtzctfIrcGMz992hyLlByuzgIk58+hhGCxjKZ3rWI82NnVLjXcaTqkI2NvlcvOskZaiZ5kjUALo3Lpxg==}
     engines: {node: '>=6.9.0'}
 
   '@babel/core@7.28.3':
     resolution: {integrity: sha512-yDBHV9kQNcr2/sUr9jghVyz9C3Y5G2zUM2H2lo+9mKv4sFgbA8s8Z9t8D1jiTkGoO/NoIfKMyKWr4s6CN23ZwQ==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/core@7.28.4':
-    resolution: {integrity: sha512-2BCOP7TN8M+gVDj7/ht3hsaO/B/n5oDbiAyyvnRlNOs+u1o+JWNYTQrmpuNp1/Wq2gcFrI01JAW+paEKDMx/CA==}
+  '@babel/core@7.28.5':
+    resolution: {integrity: sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/generator@7.28.3':
-    resolution: {integrity: sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==}
+  '@babel/generator@7.28.6':
+    resolution: {integrity: sha512-lOoVRwADj8hjf7al89tvQ2a1lf53Z+7tiXMgpZJL3maQPDxh0DgLMN62B2MKUOFcoodBHLMbDM6WAbKgNy5Suw==}
     engines: {node: '>=6.9.0'}
 
   '@babel/helper-annotate-as-pure@7.27.3':
     resolution: {integrity: sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-compilation-targets@7.27.2':
-    resolution: {integrity: sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==}
+  '@babel/helper-compilation-targets@7.28.6':
+    resolution: {integrity: sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-create-class-features-plugin@7.28.3':
-    resolution: {integrity: sha512-V9f6ZFIYSLNEbuGA/92uOvYsGCJNsuA8ESZ4ldc09bWk/j8H8TKiPw8Mk1eG6olpnO0ALHJmYfZvF4MEE4gajg==}
+  '@babel/helper-create-class-features-plugin@7.28.6':
+    resolution: {integrity: sha512-dTOdvsjnG3xNT9Y0AUg1wAl38y+4Rl4sf9caSQZOXdNqVn+H+HbbJ4IyyHaIqNR6SW9oJpA/RuRjsjCw2IdIow==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
 
+  '@babel/helper-create-regexp-features-plugin@7.28.5':
+    resolution: {integrity: sha512-N1EhvLtHzOvj7QQOUCCS3NrPJP8c5W6ZXCHDn7Yialuy1iu4r5EmIYkXlKNqT99Ciw+W0mDqWoR6HWMZlFP3hw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-define-polyfill-provider@0.6.5':
+    resolution: {integrity: sha512-uJnGFcPsWQK8fvjgGP5LZUZZsYGIoPeRjSF5PGwrelYgq7Q15/Ft9NGFp1zglwgIv//W0uG4BevRuSJRyylZPg==}
+    peerDependencies:
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
+
   '@babel/helper-globals@7.28.0':
     resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-member-expression-to-functions@7.27.1':
-    resolution: {integrity: sha512-E5chM8eWjTp/aNoVpcbfM7mLxu9XGLWYise2eBKGQomAk/Mb4XoxyqXTZbuTohbsl8EKqdlMhnDI2CCLfcs9wA==}
+  '@babel/helper-member-expression-to-functions@7.28.5':
+    resolution: {integrity: sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg==}
     engines: {node: '>=6.9.0'}
 
   '@babel/helper-module-imports@7.18.6':
     resolution: {integrity: sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-module-imports@7.27.1':
-    resolution: {integrity: sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==}
+  '@babel/helper-module-imports@7.28.6':
+    resolution: {integrity: sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-module-transforms@7.28.3':
-    resolution: {integrity: sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==}
+  '@babel/helper-module-transforms@7.28.6':
+    resolution: {integrity: sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
@@ -1158,12 +1441,18 @@ packages:
     resolution: {integrity: sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-plugin-utils@7.27.1':
-    resolution: {integrity: sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==}
+  '@babel/helper-plugin-utils@7.28.6':
+    resolution: {integrity: sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-remap-async-to-generator@7.27.1':
+    resolution: {integrity: sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==}
     engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
 
-  '@babel/helper-replace-supers@7.27.1':
-    resolution: {integrity: sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA==}
+  '@babel/helper-replace-supers@7.28.6':
+    resolution: {integrity: sha512-mq8e+laIk94/yFec3DxSjCRD2Z0TAjhVbEJY3UQrlwVo15Lmt7C2wAUbK4bjnTs4APkwsYLTahXRraQXhb1WCg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
@@ -1180,109 +1469,431 @@ packages:
     resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-validator-identifier@7.27.1':
-    resolution: {integrity: sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==}
+  '@babel/helper-validator-identifier@7.28.5':
+    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
     engines: {node: '>=6.9.0'}
 
   '@babel/helper-validator-option@7.27.1':
     resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/helper-wrap-function@7.28.6':
+    resolution: {integrity: sha512-z+PwLziMNBeSQJonizz2AGnndLsP2DeGHIxDAn+wdHOGuo4Fo1x1HBPPXeE9TAOPHNNWQKCSlA2VZyYyyibDnQ==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/helpers@7.28.4':
     resolution: {integrity: sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/parser@7.28.4':
-    resolution: {integrity: sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==}
+  '@babel/highlight@7.25.9':
+    resolution: {integrity: sha512-llL88JShoCsth8fF8R4SJnIn+WLvR6ccFxu1H3FlMhDontdcmZWf2HgIZ7AIqV3Xcck1idlohrN4EUBQz6klbw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/parser@7.28.6':
+    resolution: {integrity: sha512-TeR9zWR18BvbfPmGbLampPMW+uW1NZnJlRuuHso8i87QZNq2JRF9i6RgxRqtEq+wQGsS19NNTWr2duhnE49mfQ==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
-  '@babel/plugin-syntax-jsx@7.27.1':
-    resolution: {integrity: sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w==}
+  '@babel/plugin-proposal-decorators@7.28.6':
+    resolution: {integrity: sha512-RVdFPPyY9fCRAX68haPmOk2iyKW8PKJFthmm8NeSI3paNxKWGZIn99+VbIf0FrtCpFnPgnpF/L48tadi617ULg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-syntax-typescript@7.27.1':
-    resolution: {integrity: sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ==}
+  '@babel/plugin-proposal-export-default-from@7.27.1':
+    resolution: {integrity: sha512-hjlsMBl1aJc5lp8MoCDEZCiYzlgdRAShOjAfRw6X+GlpLpUPU7c3XNLsKFZbQk/1cRzBlJ7CXg3xJAJMrFa1Uw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-modules-commonjs@7.27.1':
-    resolution: {integrity: sha512-OJguuwlTYlN0gBZFRPqwOGNWssZjfIUdS7HMYtN8c1KmwpwHFBwTeFZrg9XZa+DFTitWOW5iTAG7tyCUPsCCyw==}
-    engines: {node: '>=6.9.0'}
+  '@babel/plugin-syntax-async-generators@7.8.4':
+    resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-react-jsx-self@7.27.1':
-    resolution: {integrity: sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==}
-    engines: {node: '>=6.9.0'}
+  '@babel/plugin-syntax-bigint@7.8.3':
+    resolution: {integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-react-jsx-source@7.27.1':
-    resolution: {integrity: sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==}
-    engines: {node: '>=6.9.0'}
+  '@babel/plugin-syntax-class-properties@7.12.13':
+    resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-typescript@7.28.0':
-    resolution: {integrity: sha512-4AEiDEBPIZvLQaWlc9liCavE0xRM0dNca41WtBeM3jgFptfUOSG9z0uteLhq6+3rq+WB6jIvUwKDTpXEHPJ2Vg==}
+  '@babel/plugin-syntax-class-static-block@7.14.5':
+    resolution: {integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/preset-typescript@7.27.1':
-    resolution: {integrity: sha512-l7WfQfX0WK4M0v2RudjuQK4u99BS6yLHYEmdtVPP7lKV013zr9DygFuWNlnbvQ9LR+LS0Egz/XAvGx5U9MX0fQ==}
+  '@babel/plugin-syntax-decorators@7.28.6':
+    resolution: {integrity: sha512-71EYI0ONURHJBL4rSFXnITXqXrrY8q4P0q006DPfN+Rk+ASM+++IBXem/ruokgBZR8YNEWZ8R6B+rCb8VcUTqA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/runtime@7.27.0':
-    resolution: {integrity: sha512-VtPOkrdPHZsKc/clNqyi9WUA8TINkZ4cGk63UUE3u4pmB2k+ZMQRDuIOagv8UVd6j7k0T3+RRIb7beKTebNbcw==}
-    engines: {node: '>=6.9.0'}
+  '@babel/plugin-syntax-dynamic-import@7.8.3':
+    resolution: {integrity: sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@babel/runtime@7.28.4':
-    resolution: {integrity: sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==}
+  '@babel/plugin-syntax-export-default-from@7.28.6':
+    resolution: {integrity: sha512-Svlx1fjJFnNz0LZeUaybRukSxZI3KkpApUmIRzEdXC5k8ErTOz0OD0kNrICi5Vc3GlpP5ZCeRyRO+mfWTSz+iQ==}
     engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@babel/template@7.27.2':
-    resolution: {integrity: sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==}
+  '@babel/plugin-syntax-flow@7.28.6':
+    resolution: {integrity: sha512-D+OrJumc9McXNEBI/JmFnc/0uCM2/Y3PEBG3gfV3QIYkKv5pvnpzFrl1kYCrcHJP8nOeFB/SHi1IHz29pNGuew==}
     engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@babel/traverse@7.28.4':
-    resolution: {integrity: sha512-YEzuboP2qvQavAcjgQNVgsvHIDv6ZpwXvcvjmyySP2DIMuByS/6ioU5G9pYrWHM6T2YDfc7xga9iNzYOs12CFQ==}
+  '@babel/plugin-syntax-import-attributes@7.28.6':
+    resolution: {integrity: sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==}
     engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@babel/types@7.28.4':
-    resolution: {integrity: sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==}
-    engines: {node: '>=6.9.0'}
+  '@babel/plugin-syntax-import-meta@7.10.4':
+    resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@better-auth/core@1.3.27':
-    resolution: {integrity: sha512-3Sfdax6MQyronY+znx7bOsfQHI6m1SThvJWb0RDscFEAhfqLy95k1sl+/PgGyg0cwc2cUXoEiAOSqYdFYrg3vA==}
+  '@babel/plugin-syntax-json-strings@7.8.3':
+    resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@better-auth/utils@0.3.0':
-    resolution: {integrity: sha512-W+Adw6ZA6mgvnSnhOki270rwJ42t4XzSK6YWGF//BbVXL6SwCLWfyzBc1lN2m/4RM28KubdBKQ4X5VMoLRNPQw==}
+  '@babel/plugin-syntax-jsx@7.28.6':
+    resolution: {integrity: sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@better-fetch/fetch@1.1.18':
-    resolution: {integrity: sha512-rEFOE1MYIsBmoMJtQbl32PGHHXuG2hDxvEd7rUHE0vCBoFQVSDqaVs9hkZEtHCxRoY+CljXKFCOuJ8uxqw1LcA==}
+  '@babel/plugin-syntax-logical-assignment-operators@7.10.4':
+    resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@changesets/apply-release-plan@7.0.13':
-    resolution: {integrity: sha512-BIW7bofD2yAWoE8H4V40FikC+1nNFEKBisMECccS16W1rt6qqhNTBDmIw5HaqmMgtLNz9e7oiALiEUuKrQ4oHg==}
+  '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3':
+    resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@changesets/assemble-release-plan@6.0.9':
-    resolution: {integrity: sha512-tPgeeqCHIwNo8sypKlS3gOPmsS3wP0zHt67JDuL20P4QcXiw/O4Hl7oXiuLnP9yg+rXLQ2sScdV1Kkzde61iSQ==}
+  '@babel/plugin-syntax-numeric-separator@7.10.4':
+    resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@changesets/changelog-git@0.2.1':
-    resolution: {integrity: sha512-x/xEleCFLH28c3bQeQIyeZf8lFXyDFVn1SgcBiR2Tw/r4IAWlk1fzxCEZ6NxQAjF2Nwtczoen3OA2qR+UawQ8Q==}
+  '@babel/plugin-syntax-object-rest-spread@7.8.3':
+    resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
 
-  '@changesets/cli@2.29.7':
-    resolution: {integrity: sha512-R7RqWoaksyyKXbKXBTbT4REdy22yH81mcFK6sWtqSanxUCbUi9Uf+6aqxZtDQouIqPdem2W56CdxXgsxdq7FLQ==}
+  '@babel/plugin-syntax-optional-catch-binding@7.8.3':
+    resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-syntax-optional-chaining@7.8.3':
+    resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-syntax-private-property-in-object@7.14.5':
+    resolution: {integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-syntax-top-level-await@7.14.5':
+    resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-syntax-typescript@7.28.6':
+    resolution: {integrity: sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-arrow-functions@7.27.1':
+    resolution: {integrity: sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-async-generator-functions@7.28.6':
+    resolution: {integrity: sha512-9knsChgsMzBV5Yh3kkhrZNxH3oCYAfMBkNNaVN4cP2RVlFPe8wYdwwcnOsAbkdDoV9UjFtOXWrWB52M8W4jNeA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-async-to-generator@7.28.6':
+    resolution: {integrity: sha512-ilTRcmbuXjsMmcZ3HASTe4caH5Tpo93PkTxF9oG2VZsSWsahydmcEHhix9Ik122RcTnZnUzPbmux4wh1swfv7g==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-block-scoping@7.28.6':
+    resolution: {integrity: sha512-tt/7wOtBmwHPNMPu7ax4pdPz6shjFrmHDghvNC+FG9Qvj7D6mJcoRQIF5dy4njmxR941l6rgtvfSB2zX3VlUIw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-class-properties@7.28.6':
+    resolution: {integrity: sha512-dY2wS3I2G7D697VHndN91TJr8/AAfXQNt5ynCTI/MpxMsSzHp+52uNivYT5wCPax3whc47DR8Ba7cmlQMg24bw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-classes@7.28.6':
+    resolution: {integrity: sha512-EF5KONAqC5zAqT783iMGuM2ZtmEBy+mJMOKl2BCvPZ2lVrwvXnB6o+OBWCS+CoeCCpVRF2sA2RBKUxvT8tQT5Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-computed-properties@7.28.6':
+    resolution: {integrity: sha512-bcc3k0ijhHbc2lEfpFHgx7eYw9KNXqOerKWfzbxEHUGKnS3sz9C4CNL9OiFN1297bDNfUiSO7DaLzbvHQQQ1BQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-destructuring@7.28.5':
+    resolution: {integrity: sha512-Kl9Bc6D0zTUcFUvkNuQh4eGXPKKNDOJQXVyyM4ZAQPMveniJdxi8XMJwLo+xSoW3MIq81bD33lcUe9kZpl0MCw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-export-namespace-from@7.27.1':
+    resolution: {integrity: sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-flow-strip-types@7.27.1':
+    resolution: {integrity: sha512-G5eDKsu50udECw7DL2AcsysXiQyB7Nfg521t2OAJ4tbfTJ27doHLeF/vlI1NZGlLdbb/v+ibvtL1YBQqYOwJGg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-for-of@7.27.1':
+    resolution: {integrity: sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-function-name@7.27.1':
+    resolution: {integrity: sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-literals@7.27.1':
+    resolution: {integrity: sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-logical-assignment-operators@7.28.6':
+    resolution: {integrity: sha512-+anKKair6gpi8VsM/95kmomGNMD0eLz1NQ8+Pfw5sAwWH9fGYXT50E55ZpV0pHUHWf6IUTWPM+f/7AAff+wr9A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-modules-commonjs@7.28.6':
+    resolution: {integrity: sha512-jppVbf8IV9iWWwWTQIxJMAJCWBuuKx71475wHwYytrRGQ2CWiDvYlADQno3tcYpS/T2UUWFQp3nVtYfK/YBQrA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-named-capturing-groups-regex@7.27.1':
+    resolution: {integrity: sha512-SstR5JYy8ddZvD6MhV0tM/j16Qds4mIpJTOd1Yu9J9pJjH93bxHECF7pgtc28XvkzTD6Pxcm/0Z73Hvk7kb3Ng==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/plugin-transform-nullish-coalescing-operator@7.28.6':
+    resolution: {integrity: sha512-3wKbRgmzYbw24mDJXT7N+ADXw8BC/imU9yo9c9X9NKaLF1fW+e5H1U5QjMUBe4Qo4Ox/o++IyUkl1sVCLgevKg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-numeric-separator@7.28.6':
+    resolution: {integrity: sha512-SJR8hPynj8outz+SlStQSwvziMN4+Bq99it4tMIf5/Caq+3iOc0JtKyse8puvyXkk3eFRIA5ID/XfunGgO5i6w==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-object-rest-spread@7.28.6':
+    resolution: {integrity: sha512-5rh+JR4JBC4pGkXLAcYdLHZjXudVxWMXbB6u6+E9lRL5TrGVbHt1TjxGbZ8CkmYw9zjkB7jutzOROArsqtncEA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-optional-catch-binding@7.28.6':
+    resolution: {integrity: sha512-R8ja/Pyrv0OGAvAXQhSTmWyPJPml+0TMqXlO5w+AsMEiwb2fg3WkOvob7UxFSL3OIttFSGSRFKQsOhJ/X6HQdQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-optional-chaining@7.28.6':
+    resolution: {integrity: sha512-A4zobikRGJTsX9uqVFdafzGkqD30t26ck2LmOzAuLL8b2x6k3TIqRiT2xVvA9fNmFeTX484VpsdgmKNA0bS23w==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-parameters@7.27.7':
+    resolution: {integrity: sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-private-methods@7.28.6':
+    resolution: {integrity: sha512-piiuapX9CRv7+0st8lmuUlRSmX6mBcVeNQ1b4AYzJxfCMuBfB0vBXDiGSmm03pKJw1v6cZ8KSeM+oUnM6yAExg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-private-property-in-object@7.28.6':
+    resolution: {integrity: sha512-b97jvNSOb5+ehyQmBpmhOCiUC5oVK4PMnpRvO7+ymFBoqYjeDHIU9jnrNUuwHOiL9RpGDoKBpSViarV+BU+eVA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-react-display-name@7.28.0':
+    resolution: {integrity: sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-react-jsx-development@7.27.1':
+    resolution: {integrity: sha512-ykDdF5yI4f1WrAolLqeF3hmYU12j9ntLQl/AOG1HAS21jxyg1Q0/J/tpREuYLfatGdGmXp/3yS0ZA76kOlVq9Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-react-jsx-self@7.27.1':
+    resolution: {integrity: sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-react-jsx-source@7.27.1':
+    resolution: {integrity: sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-react-jsx@7.28.6':
+    resolution: {integrity: sha512-61bxqhiRfAACulXSLd/GxqmAedUSrRZIu/cbaT18T1CetkTmtDN15it7i80ru4DVqRK1WMxQhXs+Lf9kajm5Ow==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-react-pure-annotations@7.27.1':
+    resolution: {integrity: sha512-JfuinvDOsD9FVMTHpzA/pBLisxpv1aSf+OIV8lgH3MuWrks19R27e6a6DipIg4aX1Zm9Wpb04p8wljfKrVSnPA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-regenerator@7.28.6':
+    resolution: {integrity: sha512-eZhoEZHYQLL5uc1gS5e9/oTknS0sSSAtd5TkKMUp3J+S/CaUjagc0kOUPsEbDmMeva0nC3WWl4SxVY6+OBuxfw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-runtime@7.28.5':
+    resolution: {integrity: sha512-20NUVgOrinudkIBzQ2bNxP08YpKprUkRTiRSd2/Z5GOdPImJGkoN4Z7IQe1T5AdyKI1i5L6RBmluqdSzvaq9/w==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-shorthand-properties@7.27.1':
+    resolution: {integrity: sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-spread@7.28.6':
+    resolution: {integrity: sha512-9U4QObUC0FtJl05AsUcodau/RWDytrU6uKgkxu09mLR9HLDAtUMoPuuskm5huQsoktmsYpI+bGmq+iapDcriKA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-sticky-regex@7.27.1':
+    resolution: {integrity: sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-typescript@7.28.6':
+    resolution: {integrity: sha512-0YWL2RFxOqEm9Efk5PvreamxPME8OyY0wM5wh5lHjF+VtVhdneCWGzZeSqzOfiobVqQaNCd2z0tQvnI9DaPWPw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-unicode-regex@7.27.1':
+    resolution: {integrity: sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/preset-react@7.28.5':
+    resolution: {integrity: sha512-Z3J8vhRq7CeLjdC58jLv4lnZ5RKFUJWqH5emvxmv9Hv3BD1T9R/Im713R4MTKwvFaV74ejZ3sM01LyEKk4ugNQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/preset-typescript@7.28.5':
+    resolution: {integrity: sha512-+bQy5WOI2V6LJZpPVxY+yp66XdZ2yifu0Mc1aP5CQKgjn4QM5IN2i5fAZ4xKop47pr8rpVhiAeu+nDQa12C8+g==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/runtime@7.28.4':
+    resolution: {integrity: sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/template@7.28.6':
+    resolution: {integrity: sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/traverse@7.28.6':
+    resolution: {integrity: sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/types@7.28.6':
+    resolution: {integrity: sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg==}
+    engines: {node: '>=6.9.0'}
+
+  '@better-auth/core@1.3.26':
+    resolution: {integrity: sha512-S5ooXaOcn9eLV3/JayfbMsAB5PkfoTRaRrtpb5djwvI/UAJOgLyjqhd+rObsBycovQ/nPQvMKjzyM/G1oBKngA==}
+
+  '@better-auth/utils@0.3.0':
+    resolution: {integrity: sha512-W+Adw6ZA6mgvnSnhOki270rwJ42t4XzSK6YWGF//BbVXL6SwCLWfyzBc1lN2m/4RM28KubdBKQ4X5VMoLRNPQw==}
+
+  '@better-fetch/fetch@1.1.18':
+    resolution: {integrity: sha512-rEFOE1MYIsBmoMJtQbl32PGHHXuG2hDxvEd7rUHE0vCBoFQVSDqaVs9hkZEtHCxRoY+CljXKFCOuJ8uxqw1LcA==}
+
+  '@changesets/apply-release-plan@7.0.14':
+    resolution: {integrity: sha512-ddBvf9PHdy2YY0OUiEl3TV78mH9sckndJR14QAt87KLEbIov81XO0q0QAmvooBxXlqRRP8I9B7XOzZwQG7JkWA==}
+
+  '@changesets/assemble-release-plan@6.0.9':
+    resolution: {integrity: sha512-tPgeeqCHIwNo8sypKlS3gOPmsS3wP0zHt67JDuL20P4QcXiw/O4Hl7oXiuLnP9yg+rXLQ2sScdV1Kkzde61iSQ==}
+
+  '@changesets/changelog-git@0.2.1':
+    resolution: {integrity: sha512-x/xEleCFLH28c3bQeQIyeZf8lFXyDFVn1SgcBiR2Tw/r4IAWlk1fzxCEZ6NxQAjF2Nwtczoen3OA2qR+UawQ8Q==}
+
+  '@changesets/cli@2.29.8':
+    resolution: {integrity: sha512-1weuGZpP63YWUYjay/E84qqwcnt5yJMM0tep10Up7Q5cS/DGe2IZ0Uj3HNMxGhCINZuR7aO9WBMdKnPit5ZDPA==}
     hasBin: true
 
-  '@changesets/config@3.1.1':
-    resolution: {integrity: sha512-bd+3Ap2TKXxljCggI0mKPfzCQKeV/TU4yO2h2C6vAihIo8tzseAn2e7klSuiyYYXvgu53zMN1OeYMIQkaQoWnA==}
+  '@changesets/config@3.1.2':
+    resolution: {integrity: sha512-CYiRhA4bWKemdYi/uwImjPxqWNpqGPNbEBdX1BdONALFIDK7MCUj6FPkzD+z9gJcvDFUQJn9aDVf4UG7OT6Kog==}
 
   '@changesets/errors@0.2.0':
     resolution: {integrity: sha512-6BLOQUscTpZeGljvyQXlWOItQyU71kCdGz7Pi8H8zdw6BI0g3m43iL4xKUVPWtG+qrrL9DTjpdn8eYuCQSRpow==}
@@ -1293,8 +1904,8 @@ packages:
   '@changesets/get-github-info@0.6.0':
     resolution: {integrity: sha512-v/TSnFVXI8vzX9/w3DU2Ol+UlTZcu3m0kXTjTT4KlAdwSvwutcByYwyYn9hwerPWfPkT2JfpoX0KgvCEi8Q/SA==}
 
-  '@changesets/get-release-plan@4.0.13':
-    resolution: {integrity: sha512-DWG1pus72FcNeXkM12tx+xtExyH/c9I1z+2aXlObH3i9YA7+WZEVaiHzHl03thpvAgWTRaH64MpfHxozfF7Dvg==}
+  '@changesets/get-release-plan@4.0.14':
+    resolution: {integrity: sha512-yjZMHpUHgl4Xl5gRlolVuxDkm4HgSJqT93Ri1Uz8kGrQb+5iJ8dkXJ20M2j/Y4iV5QzS2c5SeTxVSKX+2eMI0g==}
 
   '@changesets/get-version-range-type@0.4.0':
     resolution: {integrity: sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==}
@@ -1305,14 +1916,14 @@ packages:
   '@changesets/logger@0.1.1':
     resolution: {integrity: sha512-OQtR36ZlnuTxKqoW4Sv6x5YIhOmClRd5pWsjZsddYxpWs517R0HkyiefQPIytCVh4ZcC5x9XaG8KTdd5iRQUfg==}
 
-  '@changesets/parse@0.4.1':
-    resolution: {integrity: sha512-iwksMs5Bf/wUItfcg+OXrEpravm5rEd9Bf4oyIPL4kVTmJQ7PNDSd6MDYkpSJR1pn7tz/k8Zf2DhTCqX08Ou+Q==}
+  '@changesets/parse@0.4.2':
+    resolution: {integrity: sha512-Uo5MC5mfg4OM0jU3up66fmSn6/NE9INK+8/Vn/7sMVcdWg46zfbvvUSjD9EMonVqPi9fbrJH9SXHn48Tr1f2yA==}
 
   '@changesets/pre@2.0.2':
     resolution: {integrity: sha512-HaL/gEyFVvkf9KFg6484wR9s0qjAXlZ8qWPDkTyKF6+zqjBe/I2mygg3MbpZ++hdi0ToqNUF8cjj7fBy0dg8Ug==}
 
-  '@changesets/read@0.6.5':
-    resolution: {integrity: sha512-UPzNGhsSjHD3Veb0xO/MwvasGe8eMyNrR/sT9gR8Q3DhOQZirgKhhXv/8hVsI0QpPjR004Z9iFxoJU6in3uGMg==}
+  '@changesets/read@0.6.6':
+    resolution: {integrity: sha512-P5QaN9hJSQQKJShzzpBT13FzOSPyHbqdoIBUd2DJdgvnECCyO6LmAOWSV+O8se2TaZJVwSXjL+v9yhb+a9JeJg==}
 
   '@changesets/should-skip-package@0.1.2':
     resolution: {integrity: sha512-qAK/WrqWLNCP22UDdBTMPH5f41elVDlsNyat180A33dWxuUDyNpg6fPi/FyTZwRriVjg0L8gnjJn2F9XAoF0qw==}
@@ -1330,12 +1941,12 @@ packages:
     resolution: {integrity: sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==}
     engines: {node: '>=0.1.90'}
 
-  '@commitlint/parse@19.8.1':
-    resolution: {integrity: sha512-mmAHYcMBmAgJDKWdkjIGq50X4yB0pSGpxyOODwYmoexxxiUCy5JJT99t1+PEMK7KtsCtzuWYIAXYAiKR+k+/Jw==}
+  '@commitlint/parse@20.2.0':
+    resolution: {integrity: sha512-LXStagGU1ivh07X7sM+hnEr4BvzFYn1iBJ6DRg2QsIN8lBfSzyvkUcVCDwok9Ia4PWiEgei5HQjju6xfJ1YaSQ==}
     engines: {node: '>=v18'}
 
-  '@commitlint/types@19.8.1':
-    resolution: {integrity: sha512-/yCrWGCoA1SVKOks25EGadP9Pnj0oAIHGpl2wH2M2Y46dPM2ueb8wyCVOD7O3WCTkaJ0IkKvzhl1JY7+uCT2Dw==}
+  '@commitlint/types@20.2.0':
+    resolution: {integrity: sha512-KTy0OqRDLR5y/zZMnizyx09z/rPlPC/zKhYgH8o/q6PuAjoQAKlRfY4zzv0M64yybQ//6//4H1n14pxaLZfUnA==}
     engines: {node: '>=v18'}
 
   '@csstools/color-helpers@5.1.0':
@@ -1362,11 +1973,9 @@ packages:
     peerDependencies:
       '@csstools/css-tokenizer': ^3.0.4
 
-  '@csstools/css-syntax-patches-for-csstree@1.0.14':
-    resolution: {integrity: sha512-zSlIxa20WvMojjpCSy8WrNpcZ61RqfTfX3XTaOeVlGJrt/8HF3YbzgFZa01yTbT4GWQLwfTcC3EB8i3XnB647Q==}
+  '@csstools/css-syntax-patches-for-csstree@1.0.22':
+    resolution: {integrity: sha512-qBcx6zYlhleiFfdtzkRgwNC7VVoAwfK76Vmsw5t+PbvtdknO9StgRk7ROvq9so1iqbdW4uLIDAsXRsTfUrIoOw==}
     engines: {node: '>=18'}
-    peerDependencies:
-      postcss: ^8.4
 
   '@csstools/css-tokenizer@3.0.4':
     resolution: {integrity: sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==}
@@ -1375,14 +1984,14 @@ packages:
   '@drizzle-team/brocli@0.10.2':
     resolution: {integrity: sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w==}
 
-  '@electric-sql/client@1.0.14':
-    resolution: {integrity: sha512-LtPAfeMxXRiYS0hyDQ5hue2PjljUiK9stvzsVyVb4nwxWQxfOWTSF42bHTs/o5i3x1T4kAQ7mwHpxa4A+f8X7Q==}
+  '@electric-sql/client@1.3.1':
+    resolution: {integrity: sha512-Tr7jY60acKfxuODOzGcJYzEXtTJyiE8l237hMpCPHjflr+qSGYVZ0NkOnFgAE2xIPFgP1zn05nQb3+mkUu8qUQ==}
 
-  '@emnapi/core@1.5.0':
-    resolution: {integrity: sha512-sbP8GzB1WDzacS8fgNPpHlp6C9VZe+SJP3F90W9rLemaQj2PzIuTEl1qDOYQf58YIpyjViI24y9aPWCjEzY2cg==}
+  '@emnapi/core@1.7.1':
+    resolution: {integrity: sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg==}
 
-  '@emnapi/runtime@1.5.0':
-    resolution: {integrity: sha512-97/BJ3iXHww3djw6hYIfErCZFee7qCtrneuLa20UXFCOTCfBM2cvQHjWJ2EG0s0MtdNwInarqCTz35i4wWXHsQ==}
+  '@emnapi/runtime@1.7.1':
+    resolution: {integrity: sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==}
 
   '@emnapi/wasi-threads@1.1.0':
     resolution: {integrity: sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==}
@@ -1407,6 +2016,12 @@ packages:
     cpu: [ppc64]
     os: [aix]
 
+  '@esbuild/aix-ppc64@0.27.2':
+    resolution: {integrity: sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
   '@esbuild/android-arm64@0.18.20':
     resolution: {integrity: sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==}
     engines: {node: '>=12'}
@@ -1425,6 +2040,12 @@ packages:
     cpu: [arm64]
     os: [android]
 
+  '@esbuild/android-arm64@0.27.2':
+    resolution: {integrity: sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
   '@esbuild/android-arm@0.18.20':
     resolution: {integrity: sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==}
     engines: {node: '>=12'}
@@ -1443,6 +2064,12 @@ packages:
     cpu: [arm]
     os: [android]
 
+  '@esbuild/android-arm@0.27.2':
+    resolution: {integrity: sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
   '@esbuild/android-x64@0.18.20':
     resolution: {integrity: sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==}
     engines: {node: '>=12'}
@@ -1461,6 +2088,12 @@ packages:
     cpu: [x64]
     os: [android]
 
+  '@esbuild/android-x64@0.27.2':
+    resolution: {integrity: sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
   '@esbuild/darwin-arm64@0.18.20':
     resolution: {integrity: sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==}
     engines: {node: '>=12'}
@@ -1479,6 +2112,12 @@ packages:
     cpu: [arm64]
     os: [darwin]
 
+  '@esbuild/darwin-arm64@0.27.2':
+    resolution: {integrity: sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
   '@esbuild/darwin-x64@0.18.20':
     resolution: {integrity: sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==}
     engines: {node: '>=12'}
@@ -1497,6 +2136,12 @@ packages:
     cpu: [x64]
     os: [darwin]
 
+  '@esbuild/darwin-x64@0.27.2':
+    resolution: {integrity: sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
   '@esbuild/freebsd-arm64@0.18.20':
     resolution: {integrity: sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==}
     engines: {node: '>=12'}
@@ -1515,6 +2160,12 @@ packages:
     cpu: [arm64]
     os: [freebsd]
 
+  '@esbuild/freebsd-arm64@0.27.2':
+    resolution: {integrity: sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
   '@esbuild/freebsd-x64@0.18.20':
     resolution: {integrity: sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==}
     engines: {node: '>=12'}
@@ -1533,6 +2184,12 @@ packages:
     cpu: [x64]
     os: [freebsd]
 
+  '@esbuild/freebsd-x64@0.27.2':
+    resolution: {integrity: sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
   '@esbuild/linux-arm64@0.18.20':
     resolution: {integrity: sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==}
     engines: {node: '>=12'}
@@ -1551,6 +2208,12 @@ packages:
     cpu: [arm64]
     os: [linux]
 
+  '@esbuild/linux-arm64@0.27.2':
+    resolution: {integrity: sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
   '@esbuild/linux-arm@0.18.20':
     resolution: {integrity: sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==}
     engines: {node: '>=12'}
@@ -1569,6 +2232,12 @@ packages:
     cpu: [arm]
     os: [linux]
 
+  '@esbuild/linux-arm@0.27.2':
+    resolution: {integrity: sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
   '@esbuild/linux-ia32@0.18.20':
     resolution: {integrity: sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==}
     engines: {node: '>=12'}
@@ -1587,6 +2256,12 @@ packages:
     cpu: [ia32]
     os: [linux]
 
+  '@esbuild/linux-ia32@0.27.2':
+    resolution: {integrity: sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
   '@esbuild/linux-loong64@0.18.20':
     resolution: {integrity: sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==}
     engines: {node: '>=12'}
@@ -1605,6 +2280,12 @@ packages:
     cpu: [loong64]
     os: [linux]
 
+  '@esbuild/linux-loong64@0.27.2':
+    resolution: {integrity: sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
   '@esbuild/linux-mips64el@0.18.20':
     resolution: {integrity: sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==}
     engines: {node: '>=12'}
@@ -1623,6 +2304,12 @@ packages:
     cpu: [mips64el]
     os: [linux]
 
+  '@esbuild/linux-mips64el@0.27.2':
+    resolution: {integrity: sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
   '@esbuild/linux-ppc64@0.18.20':
     resolution: {integrity: sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==}
     engines: {node: '>=12'}
@@ -1641,6 +2328,12 @@ packages:
     cpu: [ppc64]
     os: [linux]
 
+  '@esbuild/linux-ppc64@0.27.2':
+    resolution: {integrity: sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
   '@esbuild/linux-riscv64@0.18.20':
     resolution: {integrity: sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==}
     engines: {node: '>=12'}
@@ -1659,6 +2352,12 @@ packages:
     cpu: [riscv64]
     os: [linux]
 
+  '@esbuild/linux-riscv64@0.27.2':
+    resolution: {integrity: sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
   '@esbuild/linux-s390x@0.18.20':
     resolution: {integrity: sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==}
     engines: {node: '>=12'}
@@ -1677,6 +2376,12 @@ packages:
     cpu: [s390x]
     os: [linux]
 
+  '@esbuild/linux-s390x@0.27.2':
+    resolution: {integrity: sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
   '@esbuild/linux-x64@0.18.20':
     resolution: {integrity: sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==}
     engines: {node: '>=12'}
@@ -1695,6 +2400,12 @@ packages:
     cpu: [x64]
     os: [linux]
 
+  '@esbuild/linux-x64@0.27.2':
+    resolution: {integrity: sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
   '@esbuild/netbsd-arm64@0.25.11':
     resolution: {integrity: sha512-hr9Oxj1Fa4r04dNpWr3P8QKVVsjQhqrMSUzZzf+LZcYjZNqhA3IAfPQdEh1FLVUJSiu6sgAwp3OmwBfbFgG2Xg==}
     engines: {node: '>=18'}
@@ -1707,6 +2418,12 @@ packages:
     cpu: [arm64]
     os: [netbsd]
 
+  '@esbuild/netbsd-arm64@0.27.2':
+    resolution: {integrity: sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
   '@esbuild/netbsd-x64@0.18.20':
     resolution: {integrity: sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==}
     engines: {node: '>=12'}
@@ -1725,6 +2442,12 @@ packages:
     cpu: [x64]
     os: [netbsd]
 
+  '@esbuild/netbsd-x64@0.27.2':
+    resolution: {integrity: sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
   '@esbuild/openbsd-arm64@0.25.11':
     resolution: {integrity: sha512-Qq6YHhayieor3DxFOoYM1q0q1uMFYb7cSpLD2qzDSvK1NAvqFi8Xgivv0cFC6J+hWVw2teCYltyy9/m/14ryHg==}
     engines: {node: '>=18'}
@@ -1737,6 +2460,12 @@ packages:
     cpu: [arm64]
     os: [openbsd]
 
+  '@esbuild/openbsd-arm64@0.27.2':
+    resolution: {integrity: sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
   '@esbuild/openbsd-x64@0.18.20':
     resolution: {integrity: sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==}
     engines: {node: '>=12'}
@@ -1755,6 +2484,12 @@ packages:
     cpu: [x64]
     os: [openbsd]
 
+  '@esbuild/openbsd-x64@0.27.2':
+    resolution: {integrity: sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
   '@esbuild/openharmony-arm64@0.25.11':
     resolution: {integrity: sha512-rOREuNIQgaiR+9QuNkbkxubbp8MSO9rONmwP5nKncnWJ9v5jQ4JxFnLu4zDSRPf3x4u+2VN4pM4RdyIzDty/wQ==}
     engines: {node: '>=18'}
@@ -1767,6 +2502,12 @@ packages:
     cpu: [arm64]
     os: [openharmony]
 
+  '@esbuild/openharmony-arm64@0.27.2':
+    resolution: {integrity: sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
   '@esbuild/sunos-x64@0.18.20':
     resolution: {integrity: sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==}
     engines: {node: '>=12'}
@@ -1785,6 +2526,12 @@ packages:
     cpu: [x64]
     os: [sunos]
 
+  '@esbuild/sunos-x64@0.27.2':
+    resolution: {integrity: sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
   '@esbuild/win32-arm64@0.18.20':
     resolution: {integrity: sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==}
     engines: {node: '>=12'}
@@ -1803,6 +2550,12 @@ packages:
     cpu: [arm64]
     os: [win32]
 
+  '@esbuild/win32-arm64@0.27.2':
+    resolution: {integrity: sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
   '@esbuild/win32-ia32@0.18.20':
     resolution: {integrity: sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==}
     engines: {node: '>=12'}
@@ -1821,6 +2574,12 @@ packages:
     cpu: [ia32]
     os: [win32]
 
+  '@esbuild/win32-ia32@0.27.2':
+    resolution: {integrity: sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
   '@esbuild/win32-x64@0.18.20':
     resolution: {integrity: sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==}
     engines: {node: '>=12'}
@@ -1839,6 +2598,12 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@esbuild/win32-x64@0.27.2':
+    resolution: {integrity: sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
   '@eslint-community/eslint-utils@4.9.0':
     resolution: {integrity: sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -1849,42 +2614,142 @@ packages:
     resolution: {integrity: sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
 
-  '@eslint/compat@1.4.0':
-    resolution: {integrity: sha512-DEzm5dKeDBPm3r08Ixli/0cmxr8LkRdwxMRUIJBlSCpAwSrvFEJpVBzV+66JhDxiaqKxnRzCXhtiMiczF7Hglg==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-    peerDependencies:
-      eslint: ^8.40 || 9
-    peerDependenciesMeta:
-      eslint:
-        optional: true
+  '@eslint/compat@1.4.1':
+    resolution: {integrity: sha512-cfO82V9zxxGBxcQDr1lfaYB7wykTa0b00mGa36FrJl7iTFd0Z2cHfEYuxcBRP/iNijCsWsEkA+jzT8hGYmv33w==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.40 || 9
+    peerDependenciesMeta:
+      eslint:
+        optional: true
+
+  '@eslint/config-array@0.21.1':
+    resolution: {integrity: sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/config-helpers@0.4.2':
+    resolution: {integrity: sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/core@0.17.0':
+    resolution: {integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/eslintrc@3.3.1':
+    resolution: {integrity: sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/js@9.39.2':
+    resolution: {integrity: sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/object-schema@2.1.7':
+    resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/plugin-kit@0.4.1':
+    resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@exodus/bytes@1.7.0':
+    resolution: {integrity: sha512-5i+BtvujK/vM07YCGDyz4C4AyDzLmhxHMtM5HpUyPRtJPBdFPsj290ffXW+UXY21/G7GtXeHD2nRmq0T1ShyQQ==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+    peerDependencies:
+      '@exodus/crypto': ^1.0.0-rc.4
+    peerDependenciesMeta:
+      '@exodus/crypto':
+        optional: true
+
+  '@expo/cli@0.24.23':
+    resolution: {integrity: sha512-uIlgadw38yVOczYOm9BeW0wkWdC5rtcSP0+NHqOS31DAh2KNzOPRt9dnNuP0ErS+QJM3ymZSjZgo4hUvyFQ7Kw==}
+    hasBin: true
+
+  '@expo/code-signing-certificates@0.0.5':
+    resolution: {integrity: sha512-BNhXkY1bblxKZpltzAx98G2Egj9g1Q+JRcvR7E99DOj862FTCX+ZPsAUtPTr7aHxwtrL7+fL3r0JSmM9kBm+Bw==}
+
+  '@expo/config-plugins@10.1.2':
+    resolution: {integrity: sha512-IMYCxBOcnuFStuK0Ay+FzEIBKrwW8OVUMc65+v0+i7YFIIe8aL342l7T4F8lR4oCfhXn7d6M5QPgXvjtc/gAcw==}
+
+  '@expo/config-types@53.0.5':
+    resolution: {integrity: sha512-kqZ0w44E+HEGBjy+Lpyn0BVL5UANg/tmNixxaRMLS6nf37YsDrLk2VMAmeKMMk5CKG0NmOdVv3ngeUjRQMsy9g==}
+
+  '@expo/config@11.0.13':
+    resolution: {integrity: sha512-TnGb4u/zUZetpav9sx/3fWK71oCPaOjZHoVED9NaEncktAd0Eonhq5NUghiJmkUGt3gGSjRAEBXiBbbY9/B1LA==}
+
+  '@expo/devcert@1.2.1':
+    resolution: {integrity: sha512-qC4eaxmKMTmJC2ahwyui6ud8f3W60Ss7pMkpBq40Hu3zyiAaugPXnZ24145U7K36qO9UHdZUVxsCvIpz2RYYCA==}
+
+  '@expo/env@1.0.7':
+    resolution: {integrity: sha512-qSTEnwvuYJ3umapO9XJtrb1fAqiPlmUUg78N0IZXXGwQRt+bkp0OBls+Y5Mxw/Owj8waAM0Z3huKKskRADR5ow==}
+
+  '@expo/fingerprint@0.13.4':
+    resolution: {integrity: sha512-MYfPYBTMfrrNr07DALuLhG6EaLVNVrY/PXjEzsjWdWE4ZFn0yqI0IdHNkJG7t1gePT8iztHc7qnsx+oo/rDo6w==}
+    hasBin: true
+
+  '@expo/image-utils@0.7.6':
+    resolution: {integrity: sha512-GKnMqC79+mo/1AFrmAcUcGfbsXXTRqOMNS1umebuevl3aaw+ztsYEFEiuNhHZW7PQ3Xs3URNT513ZxKhznDscw==}
+
+  '@expo/json-file@10.0.8':
+    resolution: {integrity: sha512-9LOTh1PgKizD1VXfGQ88LtDH0lRwq9lsTb4aichWTWSWqy3Ugfkhfm3BhzBIkJJfQQ5iJu3m/BoRlEIjoCGcnQ==}
+
+  '@expo/json-file@9.1.5':
+    resolution: {integrity: sha512-prWBhLUlmcQtvN6Y7BpW2k9zXGd3ySa3R6rAguMJkp1z22nunLN64KYTUWfijFlprFoxm9r2VNnGkcbndAlgKA==}
+
+  '@expo/metro-config@0.20.18':
+    resolution: {integrity: sha512-qPYq3Cq61KQO1CppqtmxA1NGKpzFOmdiL7WxwLhEVnz73LPSgneW7dV/3RZwVFkjThzjA41qB4a9pxDqtpepPg==}
+
+  '@expo/metro-runtime@5.0.5':
+    resolution: {integrity: sha512-P8UFTi+YsmiD1BmdTdiIQITzDMcZgronsA3RTQ4QKJjHM3bas11oGzLQOnFaIZnlEV8Rrr3m1m+RHxvnpL+t/A==}
+    peerDependencies:
+      react-native: '*'
+
+  '@expo/osascript@2.3.8':
+    resolution: {integrity: sha512-/TuOZvSG7Nn0I8c+FcEaoHeBO07yu6vwDgk7rZVvAXoeAK5rkA09jRyjYsZo+0tMEFaToBeywA6pj50Mb3ny9w==}
+    engines: {node: '>=12'}
+
+  '@expo/package-manager@1.9.9':
+    resolution: {integrity: sha512-Nv5THOwXzPprMJwbnXU01iXSrCp3vJqly9M4EJ2GkKko9Ifer2ucpg7x6OUsE09/lw+npaoUnHMXwkw7gcKxlg==}
+
+  '@expo/plist@0.3.5':
+    resolution: {integrity: sha512-9RYVU1iGyCJ7vWfg3e7c/NVyMFs8wbl+dMWZphtFtsqyN9zppGREU3ctlD3i8KUE0sCUTVnLjCWr+VeUIDep2g==}
+
+  '@expo/prebuild-config@9.0.12':
+    resolution: {integrity: sha512-AKH5Scf+gEMgGxZZaimrJI2wlUJlRoqzDNn7/rkhZa5gUTnO4l6slKak2YdaH+nXlOWCNfAQWa76NnpQIfmv6Q==}
+
+  '@expo/schema-utils@0.1.8':
+    resolution: {integrity: sha512-9I6ZqvnAvKKDiO+ZF8BpQQFYWXOJvTAL5L/227RUbWG1OVZDInFifzCBiqAZ3b67NRfeAgpgvbA7rejsqhY62A==}
 
-  '@eslint/config-array@0.21.1':
-    resolution: {integrity: sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+  '@expo/sdk-runtime-versions@1.0.0':
+    resolution: {integrity: sha512-Doz2bfiPndXYFPMRwPyGa1k5QaKDVpY806UJj570epIiMzWaYyCtobasyfC++qfIXVb5Ocy7r3tP9d62hAQ7IQ==}
 
-  '@eslint/config-helpers@0.4.1':
-    resolution: {integrity: sha512-csZAzkNhsgwb0I/UAV6/RGFTbiakPCf0ZrGmrIxQpYvGZ00PhTkSnyKNolphgIvmnJeGw6rcGVEXfTzUnFuEvw==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+  '@expo/server@0.6.3':
+    resolution: {integrity: sha512-Ea7NJn9Xk1fe4YeJ86rObHSv/bm3u/6WiQPXEqXJ2GrfYpVab2Swoh9/PnSM3KjR64JAgKjArDn1HiPjITCfHA==}
 
-  '@eslint/core@0.16.0':
-    resolution: {integrity: sha512-nmC8/totwobIiFcGkDza3GIKfAw1+hLiYVrh3I1nIomQ8PEr5cxg34jnkmGawul/ep52wGRAcyeDCNtWKSOj4Q==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+  '@expo/spawn-async@1.7.2':
+    resolution: {integrity: sha512-QdWi16+CHB9JYP7gma19OVVg0BFkvU8zNj9GjWorYI8Iv8FUxjOCcYRuAmX4s/h91e4e7BPsskc8cSrZYho9Ew==}
+    engines: {node: '>=12'}
 
-  '@eslint/eslintrc@3.3.1':
-    resolution: {integrity: sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+  '@expo/sudo-prompt@9.3.2':
+    resolution: {integrity: sha512-HHQigo3rQWKMDzYDLkubN5WQOYXJJE2eNqIQC2axC2iO3mHdwnIR7FgZVvHWtBwAdzBgAP0ECp8KqS8TiMKvgw==}
 
-  '@eslint/js@9.38.0':
-    resolution: {integrity: sha512-UZ1VpFvXf9J06YG9xQBdnzU+kthors6KjhMAl6f4gH4usHyh31rUf2DLGInT8RFYIReYXNSydgPY0V2LuWgl7A==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+  '@expo/vector-icons@14.1.0':
+    resolution: {integrity: sha512-7T09UE9h8QDTsUeMGymB4i+iqvtEeaO5VvUjryFB4tugDTG/bkzViWA74hm5pfjjDEhYMXWaX112mcvhccmIwQ==}
+    peerDependencies:
+      expo-font: '*'
+      react: '*'
+      react-native: '*'
 
-  '@eslint/object-schema@2.1.7':
-    resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+  '@expo/ws-tunnel@1.0.6':
+    resolution: {integrity: sha512-nDRbLmSrJar7abvUjp3smDwH8HcbZcoOEa5jVPUv9/9CajgmWw20JNRwTuBRzWIWIkEJDkz20GoNA+tSwUqk0Q==}
 
-  '@eslint/plugin-kit@0.4.0':
-    resolution: {integrity: sha512-sB5uyeq+dwCWyPi31B2gQlVlo+j5brPlWx4yZBrEaRo/nhdDE8Xke1gsGgtiBdaBTxuTkceLVuVt/pclrasb0A==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+  '@expo/xcpretty@4.3.2':
+    resolution: {integrity: sha512-ReZxZ8pdnoI3tP/dNnJdnmAk7uLT4FjsKDGW7YeDdvdOMz2XCQSmSCM9IWlrXuWtMF9zeSB6WJtEhCQ41gQOfw==}
+    hasBin: true
+
+  '@fast-check/vitest@0.2.4':
+    resolution: {integrity: sha512-Ilcr+JAIPhb1s6FRm4qoglQYSGXXrS+zAupZeNuWAA3qHVGDA1d1Gb84Hb/+otL3GzVZjFJESg5/1SfIvrgssA==}
+    peerDependencies:
+      vitest: ^1 || ^2 || ^3 || ^4
 
   '@firebase/ai@1.4.1':
     resolution: {integrity: sha512-bcusQfA/tHjUjBTnMx6jdoPMpDl3r8K15Z+snHz9wq0Foox0F/V+kNLXucEOHoTL2hTc9l+onZCyBJs2QoIC3g==}
@@ -2181,8 +3046,8 @@ packages:
       '@types/node':
         optional: true
 
-  '@inquirer/external-editor@1.0.1':
-    resolution: {integrity: sha512-Oau4yL24d2B5IL4ma4UpbQigkVhzPDXLoqy1ggK4gnHg/stmkffJE4oOXHXF3uz0UEpywG68KcyXsyYpA1Re/Q==}
+  '@inquirer/external-editor@1.0.3':
+    resolution: {integrity: sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==}
     engines: {node: '>=18'}
     peerDependencies:
       '@types/node': '>=18'
@@ -2282,10 +3147,42 @@ packages:
     resolution: {integrity: sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==}
     engines: {node: '>=18.0.0'}
 
+  '@isaacs/ttlcache@1.4.1':
+    resolution: {integrity: sha512-RQgQ4uQ+pLbqXfOmieB91ejmLwvSgv9nLx6sT6sD83s7umBypgg+OIBOBbEUiJXrfpnp9j0mRhYYdzp9uqq3lA==}
+    engines: {node: '>=12'}
+
+  '@istanbuljs/load-nyc-config@1.1.0':
+    resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==}
+    engines: {node: '>=8'}
+
   '@istanbuljs/schema@0.1.3':
     resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==}
     engines: {node: '>=8'}
 
+  '@jest/create-cache-key-function@29.7.0':
+    resolution: {integrity: sha512-4QqS3LY5PBmTRHj9sAg1HLoPzqAI0uOX6wI/TRqHIcOxlFidy6YEmCQJk6FSZjNLGCeubDMfmkWL+qaLKhSGQA==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  '@jest/environment@29.7.0':
+    resolution: {integrity: sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  '@jest/fake-timers@29.7.0':
+    resolution: {integrity: sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  '@jest/schemas@29.6.3':
+    resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  '@jest/transform@29.7.0':
+    resolution: {integrity: sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  '@jest/types@29.6.3':
+    resolution: {integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
   '@jridgewell/gen-mapping@0.3.13':
     resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
 
@@ -2378,9 +3275,15 @@ packages:
   '@microsoft/tsdoc@0.15.1':
     resolution: {integrity: sha512-4aErSrCR/On/e5G2hDP0wjooqDdauzEbIq8hIkIe5pXV0rtWJZvdCEKL0ykZxex+IxIwBp0eGeV48hQN07dXtw==}
 
-  '@modelcontextprotocol/sdk@1.17.3':
-    resolution: {integrity: sha512-JPwUKWSsbzx+DLFznf/QZ32Qa+ptfbUlHhRLrBQBAFu9iI1iYvizM4p+zhhRDceSsPutXp4z+R/HPVphlIiclg==}
+  '@modelcontextprotocol/sdk@1.24.0':
+    resolution: {integrity: sha512-D8h5KXY2vHFW8zTuxn2vuZGN0HGrQ5No6LkHwlEA9trVgNdPL3TF1dSqKA7Dny6BbBYKSW/rOBDXdC8KJAjUCg==}
     engines: {node: '>=18'}
+    peerDependencies:
+      '@cfworker/json-schema': ^4.1.1
+      zod: ^3.25 || ^4.0
+    peerDependenciesMeta:
+      '@cfworker/json-schema':
+        optional: true
 
   '@mongodb-js/saslprep@1.3.0':
     resolution: {integrity: sha512-zlayKCsIjYb7/IdfqxorK5+xUMyi4vOKcFy10wKJYc63NSdKI8mNME+uJqfatkPmOSMMUiojrL58IePKBm3gvQ==}
@@ -2524,15 +3427,15 @@ packages:
   '@napi-rs/wasm-runtime@0.2.12':
     resolution: {integrity: sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==}
 
-  '@napi-rs/wasm-runtime@1.0.5':
-    resolution: {integrity: sha512-TBr9Cf9onSAS2LQ2+QHx6XcC6h9+RIzJgbqG3++9TUZSH204AwEy5jg3BTQ0VATsyoGj4ee49tN/y6rvaOOtcg==}
+  '@napi-rs/wasm-runtime@1.1.0':
+    resolution: {integrity: sha512-Fq6DJW+Bb5jaWE69/qOE0D1TUN9+6uWhCeZpdnSBk14pjLcCWR7Q8n49PTSPHazM37JqrsdpEthXy2xn6jWWiA==}
 
-  '@noble/ciphers@2.0.0':
-    resolution: {integrity: sha512-j/l6jpnpaIBM87cAYPJzi/6TgqmBv9spkqPyCXvRYsu5uxqh6tPJZDnD85yo8VWqzTuTQPgfv7NgT63u7kbwAQ==}
+  '@noble/ciphers@2.0.1':
+    resolution: {integrity: sha512-xHK3XHPUW8DTAobU+G0XT+/w+JLM7/8k1UFdB5xg/zTFPnFCobhftzw8wl4Lw2aq/Rvir5pxfZV5fEazmeCJ2g==}
     engines: {node: '>= 20.19.0'}
 
-  '@noble/hashes@2.0.0':
-    resolution: {integrity: sha512-h8VUBlE8R42+XIDO229cgisD287im3kdY6nbNZJFjc6ZvKIXPYXe6Vc/t+kyjFdMFyt5JpapzTsEg8n63w5/lw==}
+  '@noble/hashes@2.0.1':
+    resolution: {integrity: sha512-XlOlEbQcE9fmuXxrVTXCTlG2nlRXa9Rj3rr5Ue/+tX+nmkgbX720YHh0VR3hBF9xDvwnb8D2shVGOwNx+ulArw==}
     engines: {node: '>= 20.19.0'}
 
   '@nodelib/fs.scandir@2.1.5':
@@ -2587,114 +3490,123 @@ packages:
     resolution: {integrity: sha512-aoNSbxtkePXUlbZB+anS1LqsJdctG5n3UVhfU47+CDdwMi6uNTBMF9gPcQRnqghQd2FGzcwwIFBruFMxjhBewg==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
-  '@oozcitak/dom@1.15.10':
-    resolution: {integrity: sha512-0JT29/LaxVgRcGKvHmSrUTEvZ8BXvZhGl2LASRUgHqDTC1M5g1pLmVv56IYNyt3bG2CUjDkc67wnyZC14pbQrQ==}
-    engines: {node: '>=8.0'}
+  '@oozcitak/dom@2.0.2':
+    resolution: {integrity: sha512-GjpKhkSYC3Mj4+lfwEyI1dqnsKTgwGy48ytZEhm4A/xnH/8z9M3ZVXKr/YGQi3uCLs1AEBS+x5T2JPiueEDW8w==}
+    engines: {node: '>=20.0'}
 
-  '@oozcitak/infra@1.0.8':
-    resolution: {integrity: sha512-JRAUc9VR6IGHOL7OGF+yrvs0LO8SlqGnPAMqyzOuFZPSZSXI7Xf2O9+awQPSMXgIWGtgUf/dA6Hs6X6ySEaWTg==}
-    engines: {node: '>=6.0'}
+  '@oozcitak/infra@2.0.2':
+    resolution: {integrity: sha512-2g+E7hoE2dgCz/APPOEK5s3rMhJvNxSMBrP+U+j1OWsIbtSpWxxlUjq1lU8RIsFJNYv7NMlnVsCuHcUzJW+8vA==}
+    engines: {node: '>=20.0'}
 
-  '@oozcitak/url@1.0.4':
-    resolution: {integrity: sha512-kDcD8y+y3FCSOvnBI6HJgl00viO/nGbQoCINmQ0h98OhnGITrWR3bOGfwYCthgcrV8AnTJz8MzslTQbC3SOAmw==}
-    engines: {node: '>=8.0'}
+  '@oozcitak/url@3.0.0':
+    resolution: {integrity: sha512-ZKfET8Ak1wsLAiLWNfFkZc/BraDccuTJKR6svTYc7sVjbR+Iu0vtXdiDMY4o6jaFl5TW2TlS7jbLl4VovtAJWQ==}
+    engines: {node: '>=20.0'}
 
-  '@oozcitak/util@8.3.8':
-    resolution: {integrity: sha512-T8TbSnGsxo6TDBJx/Sgv/BlVJL3tshxZP7Aq5R1mSnM5OcHY2dQaxLMu2+E8u3gN0MLOzdjurqN4ZRVuzQycOQ==}
-    engines: {node: '>=8.0'}
+  '@oozcitak/util@10.0.0':
+    resolution: {integrity: sha512-hAX0pT/73190NLqBPPWSdBVGtbY6VOhWYK3qqHqtXQ1gK7kS2yz4+ivsN07hpJ6I3aeMtKP6J6npsEKOAzuTLA==}
+    engines: {node: '>=20.0'}
+
+  '@opentelemetry/api@1.9.0':
+    resolution: {integrity: sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==}
+    engines: {node: '>=8.0.0'}
 
-  '@oxc-resolver/binding-android-arm-eabi@11.8.4':
-    resolution: {integrity: sha512-6BjMji0TcvQfJ4EoSunOSyu/SiyHKficBD0V3Y0NxF0beaNnnZ7GYEi2lHmRNnRCuIPK8IuVqQ6XizYau+CkKw==}
+  '@oxc-resolver/binding-android-arm-eabi@11.16.2':
+    resolution: {integrity: sha512-lVJbvydLQIDZHKUb6Zs9Rq80QVTQ9xdCQE30eC9/cjg4wsMoEOg65QZPymUAIVJotpUAWJD0XYcwE7ugfxx5kQ==}
     cpu: [arm]
     os: [android]
 
-  '@oxc-resolver/binding-android-arm64@11.8.4':
-    resolution: {integrity: sha512-SxF4X6rzCBS9XNPXKZGoIHIABjfGmtQpEgRBDzpDHx5VTuLAUmwLTHXnVBAZoX5bmnhF79RiMElavzFdJ2cA1A==}
+  '@oxc-resolver/binding-android-arm64@11.16.2':
+    resolution: {integrity: sha512-fEk+g/g2rJ6LnBVPqeLcx+/alWZ/Db1UlXG+ZVivip0NdrnOzRL48PAmnxTMGOrLwsH1UDJkwY3wOjrrQltCqg==}
     cpu: [arm64]
     os: [android]
 
-  '@oxc-resolver/binding-darwin-arm64@11.8.4':
-    resolution: {integrity: sha512-8zWeERrzgscAniE6kh1TQ4E7GJyglYsvdoKrHYLBCbHWD+0/soffiwAYxZuckKEQSc2RXMSPjcu+JTCALaY0Dw==}
+  '@oxc-resolver/binding-darwin-arm64@11.16.2':
+    resolution: {integrity: sha512-Pkbp1qi7kdUX6k3Fk1PvAg6p7ruwaWKg1AhOlDgrg2vLXjtv9ZHo7IAQN6kLj0W771dPJZWqNxoqTPacp2oYWA==}
     cpu: [arm64]
     os: [darwin]
 
-  '@oxc-resolver/binding-darwin-x64@11.8.4':
-    resolution: {integrity: sha512-BUwggKz8Hi5uEQ0AeVTSun1+sp4lzNcItn+L7fDsHu5Cx0Zueuo10BtVm+dIwmYVVPL5oGYOeD0fS7MKAazKiw==}
+  '@oxc-resolver/binding-darwin-x64@11.16.2':
+    resolution: {integrity: sha512-FYCGcU1iSoPkADGLfQbuj0HWzS+0ItjDCt9PKtu2Hzy6T0dxO4Y1enKeCOxCweOlmLEkSxUlW5UPT4wvT3LnAg==}
     cpu: [x64]
     os: [darwin]
 
-  '@oxc-resolver/binding-freebsd-x64@11.8.4':
-    resolution: {integrity: sha512-fPO5TQhnn8gA6yP4o49lc4Gn8KeDwAp9uYd4PlE3Q00JVqU6cY9WecDhYHrWtiFcyoZ8UVBlIxuhRqT/DP4Z4A==}
+  '@oxc-resolver/binding-freebsd-x64@11.16.2':
+    resolution: {integrity: sha512-1zHCoK6fMcBjE54P2EG/z70rTjcRxvyKfvk4E/QVrWLxNahuGDFZIxoEoo4kGnnEcmPj41F0c2PkrQbqlpja5g==}
     cpu: [x64]
     os: [freebsd]
 
-  '@oxc-resolver/binding-linux-arm-gnueabihf@11.8.4':
-    resolution: {integrity: sha512-QuNbdUaVGiP0W0GrXsvCDZjqeL4lZGU7aXlx/S2tCvyTk3wh6skoiLJgqUf/eeqXfUPnzTfntYqyfolzCAyBYA==}
+  '@oxc-resolver/binding-linux-arm-gnueabihf@11.16.2':
+    resolution: {integrity: sha512-+ucLYz8EO5FDp6kZ4o1uDmhoP+M98ysqiUW4hI3NmfiOJQWLrAzQjqaTdPfIOzlCXBU9IHp5Cgxu6wPjVb8dbA==}
     cpu: [arm]
     os: [linux]
 
-  '@oxc-resolver/binding-linux-arm-musleabihf@11.8.4':
-    resolution: {integrity: sha512-p/zLMfza8OsC4BDKxqeZ9Qel+4eA/oiMSyKLRkMrTgt6OWQq1d5nHntjfG35Abcw4ev6Q9lRU3NOW5hj0xlUbw==}
+  '@oxc-resolver/binding-linux-arm-musleabihf@11.16.2':
+    resolution: {integrity: sha512-qq+TpNXyw1odDgoONRpMLzH4hzhwnEw55398dL8rhKGvvYbio71WrJ00jE+hGlEi7H1Gkl11KoPJRaPlRAVGPw==}
     cpu: [arm]
     os: [linux]
 
-  '@oxc-resolver/binding-linux-arm64-gnu@11.8.4':
-    resolution: {integrity: sha512-bvJF9wWxF1+a5YZATlS5JojpOMC7OsnTatA6sXVHoOb7MIigjledYB5ZMAeRrnWWexRMiEX3YSaA46oSfOzmOg==}
+  '@oxc-resolver/binding-linux-arm64-gnu@11.16.2':
+    resolution: {integrity: sha512-xlMh4gNtplNQEwuF5icm69udC7un0WyzT5ywOeHrPMEsghKnLjXok2wZgAA7ocTm9+JsI+nVXIQa5XO1x+HPQg==}
     cpu: [arm64]
     os: [linux]
 
-  '@oxc-resolver/binding-linux-arm64-musl@11.8.4':
-    resolution: {integrity: sha512-gf4nwGBfu+EFwOn5p7/T7VF4jmIdfodwJS9MRkOBHvuAm3LQgCX7O6d3Y80mm0TV7ZMRD/trfW628rHfd5++vQ==}
+  '@oxc-resolver/binding-linux-arm64-musl@11.16.2':
+    resolution: {integrity: sha512-OZs33QTMi0xmHv/4P0+RAKXJTBk7UcMH5tpTaCytWRXls/DGaJ48jOHmriQGK2YwUqXl+oneuNyPOUO0obJ+Hg==}
     cpu: [arm64]
     os: [linux]
 
-  '@oxc-resolver/binding-linux-ppc64-gnu@11.8.4':
-    resolution: {integrity: sha512-T120R5GIzRd41rYWWKCI6cSYrZjmRQzf3X4xeE1WX396Uabz5DX8KU7RnVHihSK+KDxccCVOFBxcH3ITd+IEpw==}
+  '@oxc-resolver/binding-linux-ppc64-gnu@11.16.2':
+    resolution: {integrity: sha512-UVyuhaV32dJGtF6fDofOcBstg9JwB2Jfnjfb8jGlu3xcG+TsubHRhuTwQ6JZ1sColNT1nMxBiu7zdKUEZi1kwg==}
     cpu: [ppc64]
     os: [linux]
 
-  '@oxc-resolver/binding-linux-riscv64-gnu@11.8.4':
-    resolution: {integrity: sha512-PVG7SxBFFjAaQ76p9O/0Xt5mTBlziRwpck+6cRNhy/hbWY/hSt8BFfPqw0EDSfnl40Uuh+NPsHFMnaWWyxbQEg==}
+  '@oxc-resolver/binding-linux-riscv64-gnu@11.16.2':
+    resolution: {integrity: sha512-YZZS0yv2q5nE1uL/Fk4Y7m9018DSEmDNSG8oJzy1TJjA1jx5HL52hEPxi98XhU6OYhSO/vC1jdkJeE8TIHugug==}
     cpu: [riscv64]
     os: [linux]
 
-  '@oxc-resolver/binding-linux-riscv64-musl@11.8.4':
-    resolution: {integrity: sha512-L0OklUhM2qLGaKvPSyKmwWpoijfc++VJtPyVgz031ShOXyo0WjD0ZGzusyJMsA1a/gdulAmN6CQ/0Sf4LGXEcw==}
+  '@oxc-resolver/binding-linux-riscv64-musl@11.16.2':
+    resolution: {integrity: sha512-9VYuypwtx4kt1lUcwJAH4dPmgJySh4/KxtAPdRoX2BTaZxVm/yEXHq0mnl/8SEarjzMvXKbf7Cm6UBgptm3DZw==}
     cpu: [riscv64]
     os: [linux]
 
-  '@oxc-resolver/binding-linux-s390x-gnu@11.8.4':
-    resolution: {integrity: sha512-18Ajz5hqO4cRGuoHzLFUsIPod9GIaIRDiXFg2m6CS3NgVdHx7iCZscplYH7KtjdE42M8nGWYMyyq5BOk7QVgPw==}
+  '@oxc-resolver/binding-linux-s390x-gnu@11.16.2':
+    resolution: {integrity: sha512-3gbwQ+xlL5gpyzgSDdC8B4qIM4mZaPDLaFOi3c/GV7CqIdVJc5EZXW4V3T6xwtPBOpXPXfqQLbhTnUD4SqwJtA==}
     cpu: [s390x]
     os: [linux]
 
-  '@oxc-resolver/binding-linux-x64-gnu@11.8.4':
-    resolution: {integrity: sha512-uHvH4RyYBdQ/lFGV9H+R1ScHg6EBnAhE3mnX+u+mO/btnalvg7j80okuHf8Qw0tLQiP5P1sEBoVeE6zviXY9IA==}
+  '@oxc-resolver/binding-linux-x64-gnu@11.16.2':
+    resolution: {integrity: sha512-m0WcK0j54tSwWa+hQaJMScZdWneqE7xixp/vpFqlkbhuKW9dRHykPAFvSYg1YJ3MJgu9ZzVNpYHhPKJiEQq57Q==}
     cpu: [x64]
     os: [linux]
 
-  '@oxc-resolver/binding-linux-x64-musl@11.8.4':
-    resolution: {integrity: sha512-X5z44qh5DdJfVhcqXAQFTDFUpcxdpf6DT/lHL5CFcdQGIZxatjc7gFUy05IXPI9xwfq39RValjJBvFovUk9XBw==}
+  '@oxc-resolver/binding-linux-x64-musl@11.16.2':
+    resolution: {integrity: sha512-ZjUm3w96P2t47nWywGwj1A2mAVBI/8IoS7XHhcogWCfXnEI3M6NPIRQPYAZW4s5/u3u6w1uPtgOwffj2XIOb/g==}
     cpu: [x64]
     os: [linux]
 
-  '@oxc-resolver/binding-wasm32-wasi@11.8.4':
-    resolution: {integrity: sha512-z3906y+cd8RRhBGNwHRrRAFxnKjXsBeL3+rdQjZpBrUyrhhsaV5iKD/ROx64FNJ9GjL/9mfon8A5xx/McYIqHA==}
+  '@oxc-resolver/binding-openharmony-arm64@11.16.2':
+    resolution: {integrity: sha512-OFVQ2x3VenTp13nIl6HcQ/7dmhFmM9dg2EjKfHcOtYfrVLQdNR6THFU7GkMdmc8DdY1zLUeilHwBIsyxv5hkwQ==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@oxc-resolver/binding-wasm32-wasi@11.16.2':
+    resolution: {integrity: sha512-+O1sY3RrGyA2AqDnd3yaDCsqZqCblSTEpY7TbbaOaw0X7iIbGjjRLdrQk9StG3QSiZuBy9FdFwotIiSXtwvbAQ==}
     engines: {node: '>=14.0.0'}
     cpu: [wasm32]
 
-  '@oxc-resolver/binding-win32-arm64-msvc@11.8.4':
-    resolution: {integrity: sha512-70vXFs74uA3X5iYOkpclbkWlQEF+MI325uAQ+Or2n8HJip2T0SEmuBlyw/sRL2E8zLC4oocb+1g25fmzlDVkmg==}
+  '@oxc-resolver/binding-win32-arm64-msvc@11.16.2':
+    resolution: {integrity: sha512-jMrMJL+fkx6xoSMFPOeyQ1ctTFjavWPOSZEKUY5PebDwQmC9cqEr4LhdTnGsOtFrWYLXlEU4xWeMdBoc/XKkOA==}
     cpu: [arm64]
     os: [win32]
 
-  '@oxc-resolver/binding-win32-ia32-msvc@11.8.4':
-    resolution: {integrity: sha512-SEOUAzTvr+nyMia3nx1dMtD7YUxZwuhQ3QAPnxy21261Lj0yT3JY4EIfwWH54lAWWfMdRSRRMFuGeF/dq7XjEw==}
+  '@oxc-resolver/binding-win32-ia32-msvc@11.16.2':
+    resolution: {integrity: sha512-tl0xDA5dcQplG2yg2ZhgVT578dhRFafaCfyqMEAXq8KNpor85nJ53C3PLpfxD2NKzPioFgWEexNsjqRi+kW2Mg==}
     cpu: [ia32]
     os: [win32]
 
-  '@oxc-resolver/binding-win32-x64-msvc@11.8.4':
-    resolution: {integrity: sha512-1gARIQsOPOU7LJ7jvMyPmZEVMapL/PymeG3J7naOdLZDrIZKX6CTvgawJmETYKt+8icP8M6KbBinrVkKVqFd+A==}
+  '@oxc-resolver/binding-win32-x64-msvc@11.16.2':
+    resolution: {integrity: sha512-M7z0xjYQq1HdJk2DxTSLMvRMyBSI4wn4FXGcVQBsbAihgXevAReqwMdb593nmCK/OiFwSNcOaGIzUvzyzQ+95w==}
     cpu: [x64]
     os: [win32]
 
@@ -2780,20 +3692,42 @@ packages:
     resolution: {integrity: sha512-dfUnCxiN9H4ap84DvD2ubjw+3vUNpstxa0TneY/Paat8a3R4uQZDLSvWjmznAY/DoahqTHl9V46HF/Zs3F29pg==}
     engines: {node: '>= 10.0.0'}
 
-  '@peculiar/asn1-android@2.5.0':
-    resolution: {integrity: sha512-t8A83hgghWQkcneRsgGs2ebAlRe54ns88p7ouv8PW2tzF1nAW4yHcL4uZKrFpIU+uszIRzTkcCuie37gpkId0A==}
+  '@peculiar/asn1-android@2.6.0':
+    resolution: {integrity: sha512-cBRCKtYPF7vJGN76/yG8VbxRcHLPF3HnkoHhKOZeHpoVtbMYfY9ROKtH3DtYUY9m8uI1Mh47PRhHf2hSK3xcSQ==}
+
+  '@peculiar/asn1-cms@2.6.0':
+    resolution: {integrity: sha512-2uZqP+ggSncESeUF/9Su8rWqGclEfEiz1SyU02WX5fUONFfkjzS2Z/F1Li0ofSmf4JqYXIOdCAZqIXAIBAT1OA==}
 
-  '@peculiar/asn1-ecc@2.5.0':
-    resolution: {integrity: sha512-t4eYGNhXtLRxaP50h3sfO6aJebUCDGQACoeexcelL4roMFRRVgB20yBIu2LxsPh/tdW9I282gNgMOyg3ywg/mg==}
+  '@peculiar/asn1-csr@2.6.0':
+    resolution: {integrity: sha512-BeWIu5VpTIhfRysfEp73SGbwjjoLL/JWXhJ/9mo4vXnz3tRGm+NGm3KNcRzQ9VMVqwYS2RHlolz21svzRXIHPQ==}
 
-  '@peculiar/asn1-rsa@2.5.0':
-    resolution: {integrity: sha512-qMZ/vweiTHy9syrkkqWFvbT3eLoedvamcUdnnvwyyUNv5FgFXA3KP8td+ATibnlZ0EANW5PYRm8E6MJzEB/72Q==}
+  '@peculiar/asn1-ecc@2.6.0':
+    resolution: {integrity: sha512-FF3LMGq6SfAOwUG2sKpPXblibn6XnEIKa+SryvUl5Pik+WR9rmRA3OCiwz8R3lVXnYnyRkSZsSLdml8H3UiOcw==}
 
-  '@peculiar/asn1-schema@2.5.0':
-    resolution: {integrity: sha512-YM/nFfskFJSlHqv59ed6dZlLZqtZQwjRVJ4bBAiWV08Oc+1rSd5lDZcBEx0lGDHfSoH3UziI2pXt2UM33KerPQ==}
+  '@peculiar/asn1-pfx@2.6.0':
+    resolution: {integrity: sha512-rtUvtf+tyKGgokHHmZzeUojRZJYPxoD/jaN1+VAB4kKR7tXrnDCA/RAWXAIhMJJC+7W27IIRGe9djvxKgsldCQ==}
 
-  '@peculiar/asn1-x509@2.5.0':
-    resolution: {integrity: sha512-CpwtMCTJvfvYTFMuiME5IH+8qmDe3yEWzKHe7OOADbGfq7ohxeLaXwQo0q4du3qs0AII3UbLCvb9NF/6q0oTKQ==}
+  '@peculiar/asn1-pkcs8@2.6.0':
+    resolution: {integrity: sha512-KyQ4D8G/NrS7Fw3XCJrngxmjwO/3htnA0lL9gDICvEQ+GJ+EPFqldcJQTwPIdvx98Tua+WjkdKHSC0/Km7T+lA==}
+
+  '@peculiar/asn1-pkcs9@2.6.0':
+    resolution: {integrity: sha512-b78OQ6OciW0aqZxdzliXGYHASeCvvw5caqidbpQRYW2mBtXIX2WhofNXTEe7NyxTb0P6J62kAAWLwn0HuMF1Fw==}
+
+  '@peculiar/asn1-rsa@2.6.0':
+    resolution: {integrity: sha512-Nu4C19tsrTsCp9fDrH+sdcOKoVfdfoQQ7S3VqjJU6vedR7tY3RLkQ5oguOIB3zFW33USDUuYZnPEQYySlgha4w==}
+
+  '@peculiar/asn1-schema@2.6.0':
+    resolution: {integrity: sha512-xNLYLBFTBKkCzEZIw842BxytQQATQv+lDTCEMZ8C196iJcJJMBUZxrhSTxLaohMyKK8QlzRNTRkUmanucnDSqg==}
+
+  '@peculiar/asn1-x509-attr@2.6.0':
+    resolution: {integrity: sha512-MuIAXFX3/dc8gmoZBkwJWxUWOSvG4MMDntXhrOZpJVMkYX+MYc/rUAU2uJOved9iJEoiUx7//3D8oG83a78UJA==}
+
+  '@peculiar/asn1-x509@2.6.0':
+    resolution: {integrity: sha512-uzYbPEpoQiBoTq0/+jZtpM6Gq6zADBx+JNFP3yqRgziWBxQ/Dt/HcuvRfm9zJTPdRcBqPNdaRHTVwpyiq6iNMA==}
+
+  '@peculiar/x509@1.14.2':
+    resolution: {integrity: sha512-r2w1Hg6pODDs0zfAKHkSS5HLkOLSeburtcgwvlLLWWCixw+MmW3U6kD5ddyvc2Y2YdbGuVwCF2S2ASoU1cFAag==}
+    engines: {node: '>=22.0.0'}
 
   '@petamoriken/float16@3.9.3':
     resolution: {integrity: sha512-8awtpHXCx/bNpFt4mt2xdkgtgVvKqty8VbjHI/WWWQuEw+KLzFot3f4+LkQY9YmOtq7A5GdOnqoIC8Pdygjk2g==}
@@ -2806,6 +3740,21 @@ packages:
     resolution: {integrity: sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==}
     engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
 
+  '@polka/url@1.0.0-next.29':
+    resolution: {integrity: sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==}
+
+  '@powersync/common@1.44.0':
+    resolution: {integrity: sha512-vdjSKJzXtjnenOT4EFRcTpQQ8MFV8+0KA+sf7GBVEo7zy6cg7SpQSv5AjdyX/CivOolMosjsV6Xk3WP9e7djBw==}
+
+  '@powersync/node@0.15.1':
+    resolution: {integrity: sha512-t/XSvWVt7vA2ZsCRl10ma/33ERwRa3qzpmmkZI/2lb3WMvPx8Wirj41VE8vHh7EQ7WEuhhkXSso4Hvoa4/KDdw==}
+    peerDependencies:
+      '@powersync/common': ^1.44.0
+      better-sqlite3: 12.x
+    peerDependenciesMeta:
+      better-sqlite3:
+        optional: true
+
   '@protobufjs/aspromise@1.1.2':
     resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==}
 
@@ -2840,15 +3789,143 @@ packages:
     resolution: {integrity: sha512-S+9ANAvUmjutrshV4jZjaiG8XQyuJIZ8a4utWmN/vW1sgQ9IfBnPndwkmQYw53QmouOIytT874u65HEmu6H5jw==}
     engines: {node: '>=18'}
 
-  '@rolldown/pluginutils@1.0.0-beta.29':
-    resolution: {integrity: sha512-NIJgOsMjbxAXvoGq/X0gD7VPMQ8j9g0BiDaNjVNVjvl+iKXxL3Jre0v31RmBYeLEmkbj2s02v8vFTbUXi5XS2Q==}
+  '@radix-ui/react-compose-refs@1.1.2':
+    resolution: {integrity: sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-slot@1.2.0':
+    resolution: {integrity: sha512-ujc+V6r0HNDviYqIK3rW4ffgYiZ8g5DEHrGJVk4x7kTlLXRDILnKX9vAUYeIsLOoDpDJ0ujpqMkjH4w2ofuo6w==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@react-native-async-storage/async-storage@2.1.2':
+    resolution: {integrity: sha512-dvlNq4AlGWC+ehtH12p65+17V0Dx7IecOWl6WanF2ja38O1Dcjjvn7jVzkUHJ5oWkQBlyASurTPlTHgKXyYiow==}
+    peerDependencies:
+      react-native: ^0.0.0-0 || >=0.65 <1.0
+
+  '@react-native-community/netinfo@11.4.1':
+    resolution: {integrity: sha512-B0BYAkghz3Q2V09BF88RA601XursIEA111tnc2JOaN7axJWmNefmfjZqw/KdSxKZp7CZUuPpjBmz/WCR9uaHYg==}
+    peerDependencies:
+      react-native: '>=0.59'
+
+  '@react-native/assets-registry@0.79.6':
+    resolution: {integrity: sha512-UVSP1224PWg0X+mRlZNftV5xQwZGfawhivuW8fGgxNK9MS/U84xZ+16lkqcPh1ank6MOt239lIWHQ1S33CHgqA==}
+    engines: {node: '>=18'}
+
+  '@react-native/babel-plugin-codegen@0.79.6':
+    resolution: {integrity: sha512-CS5OrgcMPixOyUJ/Sk/HSsKsKgyKT5P7y3CojimOQzWqRZBmoQfxdST4ugj7n1H+ebM2IKqbgovApFbqXsoX0g==}
+    engines: {node: '>=18'}
+
+  '@react-native/babel-preset@0.79.6':
+    resolution: {integrity: sha512-H+FRO+r2Ql6b5IwfE0E7D52JhkxjeGSBSUpCXAI5zQ60zSBJ54Hwh2bBJOohXWl4J+C7gKYSAd2JHMUETu+c/A==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@babel/core': '*'
+
+  '@react-native/codegen@0.79.6':
+    resolution: {integrity: sha512-iRBX8Lgbqypwnfba7s6opeUwVyaR23mowh9ILw7EcT2oLz3RqMmjJdrbVpWhGSMGq2qkPfqAH7bhO8C7O+xfjQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@babel/core': '*'
+
+  '@react-native/community-cli-plugin@0.79.6':
+    resolution: {integrity: sha512-ZHVst9vByGsegeaddkD2YbZ6NvYb4n3pD9H7Pit94u+NlByq2uBJghoOjT6EKqg+UVl8tLRdi88cU2pDPwdHqA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@react-native-community/cli': '*'
+    peerDependenciesMeta:
+      '@react-native-community/cli':
+        optional: true
+
+  '@react-native/debugger-frontend@0.79.6':
+    resolution: {integrity: sha512-lIK/KkaH7ueM22bLO0YNaQwZbT/oeqhaghOvmZacaNVbJR1Cdh/XAqjT8FgCS+7PUnbxA8B55NYNKGZG3O2pYw==}
+    engines: {node: '>=18'}
+
+  '@react-native/dev-middleware@0.79.6':
+    resolution: {integrity: sha512-BK3GZBa9c7XSNR27EDRtxrgyyA3/mf1j3/y+mPk7Ac0Myu85YNrXnC9g3mL5Ytwo0g58TKrAIgs1fF2Q5Mn6mQ==}
+    engines: {node: '>=18'}
+
+  '@react-native/gradle-plugin@0.79.6':
+    resolution: {integrity: sha512-C5odetI6py3CSELeZEVz+i00M+OJuFZXYnjVD4JyvpLn462GesHRh+Se8mSkU5QSaz9cnpMnyFLJAx05dokWbA==}
+    engines: {node: '>=18'}
+
+  '@react-native/js-polyfills@0.79.6':
+    resolution: {integrity: sha512-6wOaBh1namYj9JlCNgX2ILeGUIwc6OP6MWe3Y5jge7Xz9fVpRqWQk88Q5Y9VrAtTMTcxoX3CvhrfRr3tGtSfQw==}
+    engines: {node: '>=18'}
+
+  '@react-native/normalize-colors@0.79.6':
+    resolution: {integrity: sha512-0v2/ruY7eeKun4BeKu+GcfO+SHBdl0LJn4ZFzTzjHdWES0Cn+ONqKljYaIv8p9MV2Hx/kcdEvbY4lWI34jC/mQ==}
+
+  '@react-native/virtualized-lists@0.79.6':
+    resolution: {integrity: sha512-khA/Hrbb+rB68YUHrLubfLgMOD9up0glJhw25UE3Kntj32YDyuO0Tqc81ryNTcCekFKJ8XrAaEjcfPg81zBGPw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/react': ^19.0.0
+      react: '*'
+      react-native: '*'
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@react-navigation/bottom-tabs@7.9.1':
+    resolution: {integrity: sha512-1MHn1b5tWFa8t8LXUvaNtlg5WGVXcNTsiV00ygQDBFDusMcu0ZPOU1exqELZwHf6kDntmTQE96/NRM+Cd2QR+A==}
+    peerDependencies:
+      '@react-navigation/native': ^7.1.27
+      react: '>= 18.2.0'
+      react-native: '*'
+      react-native-safe-area-context: '>= 4.0.0'
+      react-native-screens: '>= 4.0.0'
+
+  '@react-navigation/core@7.13.7':
+    resolution: {integrity: sha512-k2ABo3250vq1ovOh/iVwXS6Hwr5PVRGXoPh/ewVFOOuEKTvOx9i//OBzt8EF+HokBxS2HBRlR2b+aCOmscRqBw==}
+    peerDependencies:
+      react: '>= 18.2.0'
+
+  '@react-navigation/elements@2.9.4':
+    resolution: {integrity: sha512-TMFh+QzwesEuSaKpvZk4BFC5105t5gJs9eq+jG7jtfdlMKyrcFwheu2/dy1zfrW4WYbVcoMxhzFqCU4mKwI4fw==}
+    peerDependencies:
+      '@react-native-masked-view/masked-view': '>= 0.2.0'
+      '@react-navigation/native': ^7.1.27
+      react: '>= 18.2.0'
+      react-native: '*'
+      react-native-safe-area-context: '>= 4.0.0'
+    peerDependenciesMeta:
+      '@react-native-masked-view/masked-view':
+        optional: true
 
-  '@rolldown/pluginutils@1.0.0-beta.38':
-    resolution: {integrity: sha512-N/ICGKleNhA5nc9XXQG/kkKHJ7S55u0x0XUJbbkmdCnFuoRkM1Il12q9q0eX19+M7KKUEPw/daUPIRnxhcxAIw==}
+  '@react-navigation/native-stack@7.9.1':
+    resolution: {integrity: sha512-DIRv72UliHvCWkBO1xwvik0maRka4aebn10huL9u4lPRXZZjumlMFHhA9z8vOaj02ri54m8pQUybRdbVzNeqgQ==}
+    peerDependencies:
+      '@react-navigation/native': ^7.1.27
+      react: '>= 18.2.0'
+      react-native: '*'
+      react-native-safe-area-context: '>= 4.0.0'
+      react-native-screens: '>= 4.0.0'
+
+  '@react-navigation/native@7.1.27':
+    resolution: {integrity: sha512-kW7LGP/RrisktpGyizTKw6HwSeQJdXnAN9L8GyQJcJAlgL9YtfEg6yEyD5n9RWH90CL8G0cRyUhphKIAFf4lVw==}
+    peerDependencies:
+      react: '>= 18.2.0'
+      react-native: '*'
+
+  '@react-navigation/routers@7.5.3':
+    resolution: {integrity: sha512-1tJHg4KKRJuQ1/EvJxatrMef3NZXEPzwUIUZ3n1yJ2t7Q97siwRtbynRpQG9/69ebbtiZ8W3ScOZF/OmhvM4Rg==}
 
   '@rolldown/pluginutils@1.0.0-beta.40':
     resolution: {integrity: sha512-s3GeJKSQOwBlzdUrj4ISjJj5SfSh+aqn0wjOar4Bx95iV1ETI7F6S/5hLcfAxZ9kXDcyrAkxPlqmd1ZITttf+w==}
 
+  '@rolldown/pluginutils@1.0.0-beta.53':
+    resolution: {integrity: sha512-vENRlFU4YbrwVqNDZ7fLvy+JR1CRkyr01jhSiDpE1u6py3OMzQfztQU2jxykW3ALNxO4kSlqIDeYyD0Y9RcQeQ==}
+
   '@rollup/pluginutils@5.3.0':
     resolution: {integrity: sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q==}
     engines: {node: '>=14.0.0'}
@@ -3100,8 +4177,8 @@ packages:
   '@rushstack/ts-command-line@4.22.6':
     resolution: {integrity: sha512-QSRqHT/IfoC5nk9zn6+fgyqOPXHME0BfchII9EUPR19pocsNp/xSbeBCbD3PIR2Lg+Q5qk7OFqk1VhWPMdKHJg==}
 
-  '@schematics/angular@20.3.6':
-    resolution: {integrity: sha512-YPIEyKPBOyJYlda5fA49kMThzZ4WidomEMDghshux8xidbjDaPWBZdyVPQj3IXyW0teGlUM/TH0TH2weumMZrg==}
+  '@schematics/angular@20.3.13':
+    resolution: {integrity: sha512-ETJ1budKmrkdxojo5QP6TPr6zQZYGxtWWf8NrX1cBIS851zPCmFkKyhSFLZsoksariYF/LP8ljvm8tlcIzt/XA==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: ^6.11.0 || ^7.5.6 || >=8.0.0, yarn: '>= 1.13.0'}
 
   '@shikijs/engine-oniguruma@3.13.0':
@@ -3143,13 +4220,22 @@ packages:
     resolution: {integrity: sha512-hVJD77oT67aowHxwT4+M6PGOp+E2LtLdTK3+FC0lBO9T7sYwItDMXZ7Z07IDCvR1M717a4axbIWckrW67KMP/w==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
-  '@simplewebauthn/browser@13.1.2':
-    resolution: {integrity: sha512-aZnW0KawAM83fSBUgglP5WofbrLbLyr7CoPqYr66Eppm7zO86YX6rrCjRB3hQKPrL7ATvY4FVXlykZ6w6FwYYw==}
+  '@simplewebauthn/browser@13.2.2':
+    resolution: {integrity: sha512-FNW1oLQpTJyqG5kkDg5ZsotvWgmBaC6jCHR7Ej0qUNep36Wl9tj2eZu7J5rP+uhXgHaLk+QQ3lqcw2vS5MX1IA==}
 
-  '@simplewebauthn/server@13.1.2':
-    resolution: {integrity: sha512-VwoDfvLXSCaRiD+xCIuyslU0HLxVggeE5BL06+GbsP2l1fGf5op8e0c3ZtKoi+vSg1q4ikjtAghC23ze2Q3H9g==}
+  '@simplewebauthn/server@13.2.2':
+    resolution: {integrity: sha512-HcWLW28yTMGXpwE9VLx9J+N2KEUaELadLrkPEEI9tpI5la70xNEVEsu/C+m3u7uoq4FulLqZQhgBCzR9IZhFpA==}
     engines: {node: '>=20.0.0'}
 
+  '@sinclair/typebox@0.27.8':
+    resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==}
+
+  '@sinonjs/commons@3.0.1':
+    resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==}
+
+  '@sinonjs/fake-timers@10.3.0':
+    resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==}
+
   '@socket.io/component-emitter@3.1.2':
     resolution: {integrity: sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==}
 
@@ -3248,14 +4334,8 @@ packages:
       '@solidjs/router':
         optional: true
 
-  '@standard-schema/spec@1.0.0':
-    resolution: {integrity: sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==}
-
-  '@stylistic/eslint-plugin@4.4.1':
-    resolution: {integrity: sha512-CEigAk7eOLyHvdgmpZsKFwtiqS2wFwI1fn4j09IU9GmD4euFM4jEBAViWeCqaNLlbX2k2+A/Fq9cje4HQBXuJQ==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-    peerDependencies:
-      eslint: '>=9.0.0'
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
 
   '@stylistic/eslint-plugin@5.4.0':
     resolution: {integrity: sha512-UG8hdElzuBDzIbjG1QDwnYH0MQ73YLXDFHgZzB4Zh/YJfnw8XNsloVtytqzx0I2Qky9THSdpTmi8Vjn/pf/Lew==}
@@ -3263,13 +4343,13 @@ packages:
     peerDependencies:
       eslint: '>=9.0.0'
 
-  '@sveltejs/acorn-typescript@1.0.5':
-    resolution: {integrity: sha512-IwQk4yfwLdibDlrXVE04jTZYlLnwsTT2PIOQQGNLWfjavGifnk1JD1LcZjZaBTRcxZu2FfPfNLOE04DSu9lqtQ==}
+  '@sveltejs/acorn-typescript@1.0.8':
+    resolution: {integrity: sha512-esgN+54+q0NjB0Y/4BomT9samII7jGwNy/2a3wNZbT2A2RpmXsXwUt24LvLhx6jUq2gVk4cWEvcRO6MFQbOfNA==}
     peerDependencies:
       acorn: ^8.9.0
 
-  '@sveltejs/package@2.5.4':
-    resolution: {integrity: sha512-8+1hccAt0M3PPkHVPKH54Wc+cc1PNxRqCrICZiv/hEEto8KwbQVRghxNgTB4htIPyle+4CIB8RayTQH5zRQh9A==}
+  '@sveltejs/package@2.5.7':
+    resolution: {integrity: sha512-qqD9xa9H7TDiGFrF6rz7AirOR8k15qDK/9i4MIE8te4vWsv5GEogPks61rrZcLy+yWph+aI6pIj2MdoK3YI8AQ==}
     engines: {node: ^16.14 || >=18}
     hasBin: true
     peerDependencies:
@@ -3294,65 +4374,65 @@ packages:
     resolution: {integrity: sha512-08eKiDAjj4zLug1taXSIJ0kGL5cawjVCyJkBb6EWSg5fEPX6L+Wtr0CH2If4j5KYylz85iaZiFlUItvgJvll5g==}
     engines: {node: ^14.13.1 || ^16.0.0 || >=18}
 
-  '@tailwindcss/node@4.1.14':
-    resolution: {integrity: sha512-hpz+8vFk3Ic2xssIA3e01R6jkmsAhvkQdXlEbRTk6S10xDAtiQiM3FyvZVGsucefq764euO/b8WUW9ysLdThHw==}
+  '@tailwindcss/node@4.1.18':
+    resolution: {integrity: sha512-DoR7U1P7iYhw16qJ49fgXUlry1t4CpXeErJHnQ44JgTSKMaZUdf17cfn5mHchfJ4KRBZRFA/Coo+MUF5+gOaCQ==}
 
-  '@tailwindcss/oxide-android-arm64@4.1.14':
-    resolution: {integrity: sha512-a94ifZrGwMvbdeAxWoSuGcIl6/DOP5cdxagid7xJv6bwFp3oebp7y2ImYsnZBMTwjn5Ev5xESvS3FFYUGgPODQ==}
+  '@tailwindcss/oxide-android-arm64@4.1.18':
+    resolution: {integrity: sha512-dJHz7+Ugr9U/diKJA0W6N/6/cjI+ZTAoxPf9Iz9BFRF2GzEX8IvXxFIi/dZBloVJX/MZGvRuFA9rqwdiIEZQ0Q==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [android]
 
-  '@tailwindcss/oxide-darwin-arm64@4.1.14':
-    resolution: {integrity: sha512-HkFP/CqfSh09xCnrPJA7jud7hij5ahKyWomrC3oiO2U9i0UjP17o9pJbxUN0IJ471GTQQmzwhp0DEcpbp4MZTA==}
+  '@tailwindcss/oxide-darwin-arm64@4.1.18':
+    resolution: {integrity: sha512-Gc2q4Qhs660bhjyBSKgq6BYvwDz4G+BuyJ5H1xfhmDR3D8HnHCmT/BSkvSL0vQLy/nkMLY20PQ2OoYMO15Jd0A==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [darwin]
 
-  '@tailwindcss/oxide-darwin-x64@4.1.14':
-    resolution: {integrity: sha512-eVNaWmCgdLf5iv6Qd3s7JI5SEFBFRtfm6W0mphJYXgvnDEAZ5sZzqmI06bK6xo0IErDHdTA5/t7d4eTfWbWOFw==}
+  '@tailwindcss/oxide-darwin-x64@4.1.18':
+    resolution: {integrity: sha512-FL5oxr2xQsFrc3X9o1fjHKBYBMD1QZNyc1Xzw/h5Qu4XnEBi3dZn96HcHm41c/euGV+GRiXFfh2hUCyKi/e+yw==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [darwin]
 
-  '@tailwindcss/oxide-freebsd-x64@4.1.14':
-    resolution: {integrity: sha512-QWLoRXNikEuqtNb0dhQN6wsSVVjX6dmUFzuuiL09ZeXju25dsei2uIPl71y2Ic6QbNBsB4scwBoFnlBfabHkEw==}
+  '@tailwindcss/oxide-freebsd-x64@4.1.18':
+    resolution: {integrity: sha512-Fj+RHgu5bDodmV1dM9yAxlfJwkkWvLiRjbhuO2LEtwtlYlBgiAT4x/j5wQr1tC3SANAgD+0YcmWVrj8R9trVMA==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [freebsd]
 
-  '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.14':
-    resolution: {integrity: sha512-VB4gjQni9+F0VCASU+L8zSIyjrLLsy03sjcR3bM0V2g4SNamo0FakZFKyUQ96ZVwGK4CaJsc9zd/obQy74o0Fw==}
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.18':
+    resolution: {integrity: sha512-Fp+Wzk/Ws4dZn+LV2Nqx3IilnhH51YZoRaYHQsVq3RQvEl+71VGKFpkfHrLM/Li+kt5c0DJe/bHXK1eHgDmdiA==}
     engines: {node: '>= 10'}
     cpu: [arm]
     os: [linux]
 
-  '@tailwindcss/oxide-linux-arm64-gnu@4.1.14':
-    resolution: {integrity: sha512-qaEy0dIZ6d9vyLnmeg24yzA8XuEAD9WjpM5nIM1sUgQ/Zv7cVkharPDQcmm/t/TvXoKo/0knI3me3AGfdx6w1w==}
+  '@tailwindcss/oxide-linux-arm64-gnu@4.1.18':
+    resolution: {integrity: sha512-S0n3jboLysNbh55Vrt7pk9wgpyTTPD0fdQeh7wQfMqLPM/Hrxi+dVsLsPrycQjGKEQk85Kgbx+6+QnYNiHalnw==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
 
-  '@tailwindcss/oxide-linux-arm64-musl@4.1.14':
-    resolution: {integrity: sha512-ISZjT44s59O8xKsPEIesiIydMG/sCXoMBCqsphDm/WcbnuWLxxb+GcvSIIA5NjUw6F8Tex7s5/LM2yDy8RqYBQ==}
+  '@tailwindcss/oxide-linux-arm64-musl@4.1.18':
+    resolution: {integrity: sha512-1px92582HkPQlaaCkdRcio71p8bc8i/ap5807tPRDK/uw953cauQBT8c5tVGkOwrHMfc2Yh6UuxaH4vtTjGvHg==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
 
-  '@tailwindcss/oxide-linux-x64-gnu@4.1.14':
-    resolution: {integrity: sha512-02c6JhLPJj10L2caH4U0zF8Hji4dOeahmuMl23stk0MU1wfd1OraE7rOloidSF8W5JTHkFdVo/O7uRUJJnUAJg==}
+  '@tailwindcss/oxide-linux-x64-gnu@4.1.18':
+    resolution: {integrity: sha512-v3gyT0ivkfBLoZGF9LyHmts0Isc8jHZyVcbzio6Wpzifg/+5ZJpDiRiUhDLkcr7f/r38SWNe7ucxmGW3j3Kb/g==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
 
-  '@tailwindcss/oxide-linux-x64-musl@4.1.14':
-    resolution: {integrity: sha512-TNGeLiN1XS66kQhxHG/7wMeQDOoL0S33x9BgmydbrWAb9Qw0KYdd8o1ifx4HOGDWhVmJ+Ul+JQ7lyknQFilO3Q==}
+  '@tailwindcss/oxide-linux-x64-musl@4.1.18':
+    resolution: {integrity: sha512-bhJ2y2OQNlcRwwgOAGMY0xTFStt4/wyU6pvI6LSuZpRgKQwxTec0/3Scu91O8ir7qCR3AuepQKLU/kX99FouqQ==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
 
-  '@tailwindcss/oxide-wasm32-wasi@4.1.14':
-    resolution: {integrity: sha512-uZYAsaW/jS/IYkd6EWPJKW/NlPNSkWkBlaeVBi/WsFQNP05/bzkebUL8FH1pdsqx4f2fH/bWFcUABOM9nfiJkQ==}
+  '@tailwindcss/oxide-wasm32-wasi@4.1.18':
+    resolution: {integrity: sha512-LffYTvPjODiP6PT16oNeUQJzNVyJl1cjIebq/rWWBF+3eDst5JGEFSc5cWxyRCJ0Mxl+KyIkqRxk1XPEs9x8TA==}
     engines: {node: '>=14.0.0'}
     cpu: [wasm32]
     bundledDependencies:
@@ -3363,67 +4443,76 @@ packages:
       - '@emnapi/wasi-threads'
       - tslib
 
-  '@tailwindcss/oxide-win32-arm64-msvc@4.1.14':
-    resolution: {integrity: sha512-Az0RnnkcvRqsuoLH2Z4n3JfAef0wElgzHD5Aky/e+0tBUxUhIeIqFBTMNQvmMRSP15fWwmvjBxZ3Q8RhsDnxAA==}
+  '@tailwindcss/oxide-win32-arm64-msvc@4.1.18':
+    resolution: {integrity: sha512-HjSA7mr9HmC8fu6bdsZvZ+dhjyGCLdotjVOgLA2vEqxEBZaQo9YTX4kwgEvPCpRh8o4uWc4J/wEoFzhEmjvPbA==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [win32]
 
-  '@tailwindcss/oxide-win32-x64-msvc@4.1.14':
-    resolution: {integrity: sha512-ttblVGHgf68kEE4om1n/n44I0yGPkCPbLsqzjvybhpwa6mKKtgFfAzy6btc3HRmuW7nHe0OOrSeNP9sQmmH9XA==}
+  '@tailwindcss/oxide-win32-x64-msvc@4.1.18':
+    resolution: {integrity: sha512-bJWbyYpUlqamC8dpR7pfjA0I7vdF6t5VpUGMWRkXVE3AXgIZjYUYAK7II1GNaxR8J1SSrSrppRar8G++JekE3Q==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [win32]
 
-  '@tailwindcss/oxide@4.1.14':
-    resolution: {integrity: sha512-23yx+VUbBwCg2x5XWdB8+1lkPajzLmALEfMb51zZUBYaYVPDQvBSD/WYDqiVyBIo2BZFa3yw1Rpy3G2Jp+K0dw==}
+  '@tailwindcss/oxide@4.1.18':
+    resolution: {integrity: sha512-EgCR5tTS5bUSKQgzeMClT6iCY3ToqE1y+ZB0AKldj809QXk1Y+3jB0upOYZrn9aGIzPtUsP7sX4QQ4XtjBB95A==}
     engines: {node: '>= 10'}
 
-  '@tailwindcss/vite@4.1.14':
-    resolution: {integrity: sha512-BoFUoU0XqgCUS1UXWhmDJroKKhNXeDzD7/XwabjkDIAbMnc4ULn5e2FuEuBbhZ6ENZoSYzKlzvZ44Yr6EUDUSA==}
+  '@tailwindcss/postcss@4.1.18':
+    resolution: {integrity: sha512-Ce0GFnzAOuPyfV5SxjXGn0CubwGcuDB0zcdaPuCSzAa/2vII24JTkH+I6jcbXLb1ctjZMZZI6OjDaLPJQL1S0g==}
+
+  '@tailwindcss/vite@4.1.18':
+    resolution: {integrity: sha512-jVA+/UpKL1vRLg6Hkao5jldawNmRo7mQYrZtNHMIVpLfLhDml5nMRUo/8MwoX2vNXvnaXNNMedrMfMugAVX1nA==}
     peerDependencies:
       vite: ^5.2.0 || ^6 || ^7
 
-  '@tanstack/config@0.22.0':
-    resolution: {integrity: sha512-7Wwfw6wBv2Kc+OBNIJQzBSJ6q7GABtwVT+VOQ/7/Gl7z8z1rtEYUZrxUrNvbbrHY+J5/WNZNZjJjTWDf8nTUBw==}
+  '@tanstack/config@0.22.2':
+    resolution: {integrity: sha512-zP1b6xd864AOOJQ7u6r+kicohRc8dAyql6sBbQh2f2RjoEynAfn0GrMHGeqhl1LN8JThokCkcjfGnXbPEz3q3A==}
     engines: {node: '>=18'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
 
-  '@tanstack/directive-functions-plugin@1.133.9':
-    resolution: {integrity: sha512-mnJXMQNovd+BhAp5SoSF6BXWfB8e/s0PdxY1AW3wqGOoGA1T7cLXHXhvzuiefX0FVKyAbvsyejs1d5usHePjEA==}
-    engines: {node: '>=12'}
-    peerDependencies:
-      vite: '>=6.0.0 || >=7.0.0'
+  '@tanstack/eslint-config@0.3.3':
+    resolution: {integrity: sha512-8VFyAaIFV9onJcfc5yVj5WWl6DmN3W4m+t0Mb+nZrQmqHy+kDndw5O5Xv2BHVWRRPTqnhlJYh6wHWGh0R81ZzQ==}
+    engines: {node: '>=18'}
 
-  '@tanstack/eslint-config@0.3.2':
-    resolution: {integrity: sha512-2g+PuGR3GuvvCiR3xZs+IMqAvnYU9bvH+jRml0BFBSxHBj22xFCTNvJWhvgj7uICFF9IchDkFUto91xDPMu5cg==}
+  '@tanstack/eslint-config@0.3.4':
+    resolution: {integrity: sha512-5Ou1XWJRCTx5G8WoCbT7+6nQ4iNdsISzBAc4lXpFy2fEOO7xioOSPvcPIv+r9V0drPPETou2tr6oLGZZ909FKg==}
     engines: {node: '>=18'}
+    peerDependencies:
+      eslint: ^8.0.0 || ^9.0.0
 
-  '@tanstack/history@1.133.3':
-    resolution: {integrity: sha512-zFQnGdX0S4g5xRuS+95iiEXM+qlGvYG7ksmOKx7LaMv60lDWa0imR8/24WwXXvBWJT1KnwVdZcjvhCwz9IiJCw==}
+  '@tanstack/history@1.141.0':
+    resolution: {integrity: sha512-LS54XNyxyTs5m/pl1lkwlg7uZM3lvsv2FIIV1rsJgnfwVCnI+n4ZGZ2CcjNT13BPu/3hPP+iHmliBSscJxW5FQ==}
     engines: {node: '>=12'}
 
-  '@tanstack/publish-config@0.2.1':
-    resolution: {integrity: sha512-URVXmXwlZXL75AFyvyOORef1tv2f16dEaFntwLYnBHoKLQMxyWYRzQrnXooxO1xf+GidJuDSZSC6Rc9UX1aK7g==}
+  '@tanstack/pacer-lite@0.2.0':
+    resolution: {integrity: sha512-aT/tP+xu/FLSxI32LhyE3hF+3fB6iD1K3f57+y2tWAHAZ3jb+hqdCpXrpYBVdbgeTKJ9u1L+z4pW96R1/3VxBw==}
     engines: {node: '>=18'}
 
-  '@tanstack/query-core@5.83.0':
-    resolution: {integrity: sha512-0M8dA+amXUkyz5cVUm/B+zSk3xkQAcuXuz5/Q/LveT4ots2rBpPTZOzd7yJa2Utsf8D2Upl5KyjhHRY+9lB/XA==}
+  '@tanstack/publish-config@0.2.2':
+    resolution: {integrity: sha512-hTW2rLeZLBMmpwVzWmUJ5L50hPlf4Ea74rZtecbT6qQYCT16JEAbryfHm1u07KIICI2vEArsm2YguckjODqx0w==}
+    engines: {node: '>=18'}
 
-  '@tanstack/query-core@5.90.5':
-    resolution: {integrity: sha512-wLamYp7FaDq6ZnNehypKI5fNvxHPfTYylE0m/ZpuuzJfJqhR5Pxg9gvGBHZx4n7J+V5Rg5mZxHHTlv25Zt5u+w==}
+  '@tanstack/query-core@5.90.16':
+    resolution: {integrity: sha512-MvtWckSVufs/ja463/K4PyJeqT+HMlJWtw6PrCpywznd2NSgO3m4KwO9RqbFqGg6iDE8vVMFWMeQI4Io3eEYww==}
 
-  '@tanstack/react-query@5.83.0':
-    resolution: {integrity: sha512-/XGYhZ3foc5H0VM2jLSD/NyBRIOK4q9kfeml4+0x2DlL6xVuAcVEW+hTlTapAmejObg0i3eNqhkr2dT+eciwoQ==}
+  '@tanstack/react-query@5.90.16':
+    resolution: {integrity: sha512-bpMGOmV4OPmif7TNMteU/Ehf/hoC0Kf98PDc0F4BZkFrEapRMEqI/V6YS0lyzwSV6PQpY1y4xxArUIfBW5LVxQ==}
     peerDependencies:
       react: ^18 || ^19
 
-  '@tanstack/react-router-devtools@1.133.15':
-    resolution: {integrity: sha512-EBkWLTdafkWY+M0A32qeFMSJc6SLU3DBg2oPQ4zDOy55BTeFSRMw7Y2z3V00BwO2eGI+yB73Ym/Noy28qGySvQ==}
+  '@tanstack/react-router-devtools@1.144.0':
+    resolution: {integrity: sha512-nstjZvZbOM4U0/Hzi82rtsP1DsR2tfigBidK+WuaDRVVstBsnwVor3DQXTGY5CcfgIiMI3eKzI17VOy3SQDDoQ==}
     engines: {node: '>=12'}
     peerDependencies:
-      '@tanstack/react-router': ^1.133.15
+      '@tanstack/react-router': ^1.144.0
+      '@tanstack/router-core': ^1.144.0
       react: '>=18.0.0 || >=19.0.0'
       react-dom: '>=18.0.0 || >=19.0.0'
+    peerDependenciesMeta:
+      '@tanstack/router-core':
+        optional: true
 
   '@tanstack/react-router-with-query@1.130.17':
     resolution: {integrity: sha512-TNaSocW20KuPwUojEm130DLWTr9M5hsSzxiu4QqS2jNCnrGLuDrwMHyP+6fq13lG3YuU4u9O1qajxfJIGomZCg==}
@@ -3435,69 +4524,68 @@ packages:
       react: '>=18.0.0 || >=19.0.0'
       react-dom: '>=18.0.0 || >=19.0.0'
 
-  '@tanstack/react-router@1.133.15':
-    resolution: {integrity: sha512-3gQitqq/5lL//KSv9Ro34Fw7xak2ZQcPbR7x6bu5X4W0v97xTE7+bMbBS5UAg9zXTq0FNyB124GabgyBgeQ0NA==}
+  '@tanstack/react-router@1.144.0':
+    resolution: {integrity: sha512-GmRyIGmHtGj3VLTHXepIwXAxTcHyL5W7Vw7O1CnVEtFxQQWKMVOnWgI7tPY6FhlNwMKVb3n0mPFWz9KMYyd2GA==}
     engines: {node: '>=12'}
     peerDependencies:
       react: '>=18.0.0 || >=19.0.0'
       react-dom: '>=18.0.0 || >=19.0.0'
 
-  '@tanstack/react-start-client@1.133.15':
-    resolution: {integrity: sha512-eQ8n4+61G5PizQpuso9MpyOsW8dVL5ZlTMa7BNdGt96OGkenj/dXnqXi3gZ9xYAIkn7VRcFZMpagZQo/Yksp5Q==}
+  '@tanstack/react-start-client@1.145.0':
+    resolution: {integrity: sha512-UC/+ONaOzuFnlHbOEudYS+AHOrcwAJaqbnfh9zZ5pUtTkJToBawW3YabDbMnS3o6lEiKggc8uGpsiCglUJrBcA==}
     engines: {node: '>=22.12.0'}
     peerDependencies:
       react: '>=18.0.0 || >=19.0.0'
       react-dom: '>=18.0.0 || >=19.0.0'
 
-  '@tanstack/react-start-server@1.133.15':
-    resolution: {integrity: sha512-dF5PyB1BGOYRKY1B+p1e617pSpg7BEeHT3mDPH6XMy3whzMKnlo9vXSOvRekoZ0phtMloYq4/TlP7qK4lWdS2g==}
+  '@tanstack/react-start-server@1.145.5':
+    resolution: {integrity: sha512-j3zRyM7QplTPsHDT3WRNc8Z15u/JHlYOdWgI2He2S0m9Ivhf25r9T5RvxAZLLMlWgn4ZdcG0YNt5U+MMOvWFdw==}
     engines: {node: '>=22.12.0'}
     peerDependencies:
       react: '>=18.0.0 || >=19.0.0'
       react-dom: '>=18.0.0 || >=19.0.0'
 
-  '@tanstack/react-start@1.133.15':
-    resolution: {integrity: sha512-E2VOqrPp9D28QHwig5jvIZMEQYjUYoLBZ4PQt6esymKr5DduI3KdFFD495jLm4dxRIH3rE4BHZjkEKGvuB2XLw==}
+  '@tanstack/react-start@1.145.5':
+    resolution: {integrity: sha512-fOAAq2qlyphXmTyfyp1X9biVsJNdU0c8PL7Nm7ktzw3/d0VLHhgyDZunFOtupFleGFkHrq8/2HLPQmWEjyE5BQ==}
     engines: {node: '>=22.12.0'}
     peerDependencies:
       react: '>=18.0.0 || >=19.0.0'
       react-dom: '>=18.0.0 || >=19.0.0'
       vite: '>=7.0.0'
 
-  '@tanstack/react-store@0.7.5':
-    resolution: {integrity: sha512-A+WZtEnHZpvbKXm8qR+xndNKywBLez2KKKKEQc7w0Qs45GvY1LpRI3BTZNmELwEVim8+Apf99iEDH2J+MUIzlQ==}
+  '@tanstack/react-store@0.8.0':
+    resolution: {integrity: sha512-1vG9beLIuB7q69skxK9r5xiLN3ztzIPfSQSs0GfeqWGO2tGIyInZx0x1COhpx97RKaONSoAb8C3dxacWksm1ow==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
       react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
-  '@tanstack/router-core@1.133.15':
-    resolution: {integrity: sha512-ZWAmoFcgi27Ojv2FH3Dq3D6Vt73LswdTnA1tyHShNWQf7wOMH/VKKB9JxiXJqpLTK4NJqpnUp/x0/3nvmdrIqg==}
+  '@tanstack/router-core@1.144.0':
+    resolution: {integrity: sha512-6oVERtK9XDHCP4XojgHsdHO56ZSj11YaWjF5g/zw39LhyA6Lx+/X86AEIHO4y0BUrMQaJfcjdAQMVSAs6Vjtdg==}
     engines: {node: '>=12'}
 
-  '@tanstack/router-devtools-core@1.133.15':
-    resolution: {integrity: sha512-TseqoP0fRfgkdb1kYzPC0S8td3pRt04BudOpenCabn8/f1EDmraxHdWh5O7S5x0VXr9dpvnj0KAUG+ip7x+iEg==}
+  '@tanstack/router-devtools-core@1.144.0':
+    resolution: {integrity: sha512-rbpQn1aHUtcfY3U3SyJqOZRqDu0a2uPK+TE2CH50HieJApmCuNKj5RsjVQYHgwiFFvR0w0LUmueTnl2X2hiWTg==}
     engines: {node: '>=12'}
     peerDependencies:
-      '@tanstack/router-core': ^1.133.15
+      '@tanstack/router-core': ^1.144.0
       csstype: ^3.0.10
       solid-js: '>=1.9.5'
-      tiny-invariant: ^1.3.3
     peerDependenciesMeta:
       csstype:
         optional: true
 
-  '@tanstack/router-generator@1.133.15':
-    resolution: {integrity: sha512-TXI07UzV5t1j1LeJ2eOErV9TxvzBRx2oSCEmkVaWMXaGKuQL7I4VB9e9w15ylHnvCO2Z/4DgIhUVF6h9/ZS3Mw==}
+  '@tanstack/router-generator@1.145.4':
+    resolution: {integrity: sha512-TQN96VBJVwXg7VmA9ePocjhSZN53w0+lekT4ca3lBhDSnwkTOrPJffBadISZJugWNRkbIuxcsbii010a0uie3w==}
     engines: {node: '>=12'}
 
-  '@tanstack/router-plugin@1.133.15':
-    resolution: {integrity: sha512-c3m7Pfuth/TXiRol0OpTw+cJyE7RxJpiMXDLooCiZgRDu2VhyXaanPLuuti9vyZiVdSrVZTQ7tJBFABymWbX5w==}
+  '@tanstack/router-plugin@1.145.4':
+    resolution: {integrity: sha512-F2QhlQzbsLHC7BTFFsSML0C/q+HfRqcRc9dC+gPZkSzEE/zcotiRXgRudbDYHa/vYf8zAP97L5OZrhR4JMCGwQ==}
     engines: {node: '>=12'}
     peerDependencies:
       '@rsbuild/core': '>=1.0.2'
-      '@tanstack/react-router': ^1.133.15
+      '@tanstack/react-router': ^1.144.0
       vite: '>=5.0.0 || >=6.0.0 || >=7.0.0'
-      vite-plugin-solid: ^2.11.8
+      vite-plugin-solid: ^2.11.10
       webpack: '>=5.92.0'
     peerDependenciesMeta:
       '@rsbuild/core':
@@ -3511,85 +4599,86 @@ packages:
       webpack:
         optional: true
 
-  '@tanstack/router-utils@1.133.3':
-    resolution: {integrity: sha512-miPFlt0aG6ID5VDolYuRXgLS7cofvbZGMvHwf2Wmyxjo6GLp/kxxpkQrfM4T1I5cwjwYZZAQmdUKbVHwFZz9sQ==}
+  '@tanstack/router-utils@1.143.11':
+    resolution: {integrity: sha512-N24G4LpfyK8dOlnP8BvNdkuxg1xQljkyl6PcrdiPSA301pOjatRT1y8wuCCJZKVVD8gkd0MpCZ0VEjRMGILOtA==}
     engines: {node: '>=12'}
 
-  '@tanstack/server-functions-plugin@1.133.11':
-    resolution: {integrity: sha512-i6w1fmnXCWsbIEq5LZ1+tSVsqy0Iy7zAUVJzfNw6AzfbWZymwl508xwQJkIowv7v+kH1yIqNaeZ75gyWNZuVEg==}
-    engines: {node: '>=12'}
-
-  '@tanstack/solid-router@1.133.15':
-    resolution: {integrity: sha512-P1ymkQDeoQHdpfkNibol8IhVTvDVt6mrefIjGXZBa+hY/Cbt4/6VOQ5OYbmo5YYLHQpaMmYrZYdsAmdtM0ynfw==}
+  '@tanstack/solid-router@1.144.0':
+    resolution: {integrity: sha512-8S2BFvYE4MLw5SXCNwL69NF/E9fdOQmXokQDsM6NTfDuJGGuNvXRTiVxgnk9ungEmVbMZ3kowXMGxOuuVbZnIg==}
     engines: {node: '>=12'}
     peerDependencies:
-      solid-js: ^1.9.5
+      solid-js: ^1.9.10
 
-  '@tanstack/solid-start-client@1.133.15':
-    resolution: {integrity: sha512-EgOMR3J4wv1oHfwwkyJga9ZhrKfPLbYB0zEFJVsjK6hwOtUGNSE+jqBss50VcMK5zbvJIP23XSE0QRO/NCCt5w==}
+  '@tanstack/solid-start-client@1.145.0':
+    resolution: {integrity: sha512-yW2LKuzggw88lFMS+HUPqZ4y/68fZaJE317Z01lmCTpjLa+FqDq8gA06hFZNmumh46FqC1a0CYohfXHk/tRGXA==}
     engines: {node: '>=22.12.0'}
     peerDependencies:
       solid-js: '>=1.0.0'
 
-  '@tanstack/solid-start-server@1.133.15':
-    resolution: {integrity: sha512-ANLqKIxDyRQA4pIUARWRjvwpDaYpU15QcUrsk58a5+QmcGEWx2oxiVAJ+3ounASx/XOhpbk6gKqE/FidSijSjQ==}
+  '@tanstack/solid-start-server@1.145.5':
+    resolution: {integrity: sha512-d0qJXl8lMkMHQd+TlMuNt/qQgXkdUJpZmQ5yhV1FIuo8yauMj/sCm8TFWwGYnyK7EPbnBnhDTvFPIK+EcBwmlA==}
     engines: {node: '>=22.12.0'}
     peerDependencies:
       solid-js: ^1.0.0
 
-  '@tanstack/solid-start@1.133.15':
-    resolution: {integrity: sha512-EoXEfVr5tYw2DkGXXZ/cskkuDn1JcKsFUEL9c6sTnF19ZlnsQXzfkJ0fICTf4n8kS453mIiYlw4uvD9Sb+ulVQ==}
+  '@tanstack/solid-start@1.145.5':
+    resolution: {integrity: sha512-sfNWxBGopZ7I+yvLa7KyguJ3mL5se8rK3MVcGSbpU+xKGdbaD/BT0P0c5pxnmyZ8My6yx5840+Fq4ur/16sARQ==}
     engines: {node: '>=22.12.0'}
     peerDependencies:
       solid-js: '>=1.0.0'
       vite: '>=7.0.0'
 
-  '@tanstack/solid-store@0.7.0':
-    resolution: {integrity: sha512-uDQYkUuH3MppitiduZLTEcItkTr8vEJ33jzp2rH2VvlNRMGbuU54GQcqf3dLIlTbZ1/Z2TtIBtBjjl+N/OhwRg==}
+  '@tanstack/solid-store@0.8.0':
+    resolution: {integrity: sha512-JwqTedbxyOGw7mfmdGkB0RGgefRCw/tNauc8tlMcaS1mV5wTFT8c1KIB3LgttuHaanMJEBeqQJ7bc/R0WTP1fA==}
     peerDependencies:
       solid-js: ^1.6.0
 
-  '@tanstack/start-client-core@1.133.15':
-    resolution: {integrity: sha512-Rnr2grPF+7ygtc6Dy6SnJrAlTeF+tr+cKv12SMvtGq1Tg2WkjmFXmGe6ac5pHqNTPs+jVBAD3MtYo3FJmIK/Fw==}
+  '@tanstack/start-client-core@1.145.0':
+    resolution: {integrity: sha512-pqINeN7ZqdfTZrkhy9C7isxRr8U3cByH5ZtLVnUxJp9fvLgwX7LlI+OWpGI0q3E8f/mHMUqJdeE56+atSs8Khw==}
+    engines: {node: '>=22.12.0'}
+
+  '@tanstack/start-fn-stubs@1.143.8':
+    resolution: {integrity: sha512-2IKUPh/TlxwzwHMiHNeFw95+L2sD4M03Es27SxMR0A60Qc4WclpaD6gpC8FsbuNASM2jBxk2UyeYClJxW1GOAQ==}
     engines: {node: '>=22.12.0'}
 
-  '@tanstack/start-plugin-core@1.133.15':
-    resolution: {integrity: sha512-t8z45y0wc3zQISvVaZIRspzJ+52nIEBE4J1mGHncxQN+43EO+sHWhN7HHA60vbYVI+PNI57QmBGZEsa23SmdBg==}
+  '@tanstack/start-plugin-core@1.145.5':
+    resolution: {integrity: sha512-lRN+qbJw6yF5PysOoNSvkiYpbDML+O5sVERuLI/iiz8ghR0RXLCWTfESEZYpU1gneJAQajj8zRTQdruKZbI/sA==}
     engines: {node: '>=22.12.0'}
     peerDependencies:
       vite: '>=7.0.0'
 
-  '@tanstack/start-server-core@1.133.15':
-    resolution: {integrity: sha512-mw7Sv+Tk2oFcFpVYSRVEZv+u5GQVU8VhgyA/h8K3i9xViuBztzqsUABEPPI+sU7Nz+jnnVSfQLH6mzy9rrr12g==}
+  '@tanstack/start-server-core@1.145.5':
+    resolution: {integrity: sha512-WYCgon3vJ8VQyNo08IgSQBignEwCzCecTQrdNcUQcKnvEDZW1Qi3xdqlTrfsOschgB778Yap5iMnRGHAt57uEQ==}
     engines: {node: '>=22.12.0'}
 
-  '@tanstack/start-storage-context@1.133.15':
-    resolution: {integrity: sha512-nkC/U2Ul8oTcdBJJRHcp0prpbsw9pHQEQIJW9G+BTRRZMFV5DeZPmjMmw6W29VZyXT5TMm/kHcXMqlc7x6ppPg==}
+  '@tanstack/start-storage-context@1.144.0':
+    resolution: {integrity: sha512-DuUx5CXfLNettyJlsHDQp66y5haeqzXJkUor7kp5p10SVv24p76dTYqBOpw+wQz//RfJlOciIZFVBcKezXXY0w==}
     engines: {node: '>=22.12.0'}
 
-  '@tanstack/store@0.7.0':
-    resolution: {integrity: sha512-CNIhdoUsmD2NolYuaIs8VfWM467RK6oIBAW4nPEKZhg1smZ+/CwtCdpURgp7nxSqOaV9oKkzdWD80+bC66F/Jg==}
-
-  '@tanstack/store@0.7.5':
-    resolution: {integrity: sha512-qd/OjkjaFRKqKU4Yjipaen/EOB9MyEg6Wr9fW103RBPACf1ZcKhbhcu2S5mj5IgdPib6xFIgCUti/mKVkl+fRw==}
-
-  '@tanstack/store@0.7.7':
-    resolution: {integrity: sha512-xa6pTan1bcaqYDS9BDpSiS63qa6EoDkPN9RsRaxHuDdVDNntzq3xNwR5YKTU/V3SkSyC9T4YVOPh2zRQN0nhIQ==}
-
   '@tanstack/store@0.8.0':
     resolution: {integrity: sha512-Om+BO0YfMZe//X2z0uLF2j+75nQga6TpTJgLJQBiq85aOyZNIhkCgleNcud2KQg4k4v9Y9l+Uhru3qWMPGTOzQ==}
 
-  '@tanstack/typedoc-config@0.3.0':
-    resolution: {integrity: sha512-g7sfxscIq0wYUGtOLegnTbiMTsNiAz6r28CDgdZqIIjI1naWZoIlABpWH2qdI3IIJUDWvhOaVwAo6sfqzm6GsQ==}
+  '@tanstack/typedoc-config@0.3.2':
+    resolution: {integrity: sha512-4S6vIl2JmjvSQC87py/ZS9YWb1//1RRlHQRCUNLaGAdnptZYX7qJvSJS8GmAZ6nele2eRlpmPZGSw3MpCR22Tg==}
+    engines: {node: '>=18'}
+
+  '@tanstack/typedoc-config@0.3.3':
+    resolution: {integrity: sha512-wVT2YfKDSpd+4f7fk6UaPIP3a2J7LSovlyVuFF1PH2yQb7gjqehod5zdFiwFyEXgvI9XGuFvvs1OehkKNYcr6A==}
     engines: {node: '>=18'}
 
-  '@tanstack/virtual-file-routes@1.133.3':
-    resolution: {integrity: sha512-6d2AP9hAjEi8mcIew2RkxBX+wClH1xedhfaYhs8fUiX+V2Cedk7RBD9E9ww2z6BGUYD8Es4fS0OIrzXZWHKGhw==}
+  '@tanstack/virtual-file-routes@1.145.4':
+    resolution: {integrity: sha512-CI75JrfqSluhdGwLssgVeQBaCphgfkMQpi8MCY3UJX1hoGzXa8kHYJcUuIFMOLs1q7zqHy++EVVtMK03osR5wQ==}
     engines: {node: '>=12'}
 
-  '@tanstack/vite-config@0.4.0':
-    resolution: {integrity: sha512-sTlzLXTvFwtPFAFrRNmU93ppl+atpX9ehWQDu+ZqfEX9vXxX/d1hUQp3wcbpgudA2SsIV7z0a8Hv6MBU63sGwQ==}
+  '@tanstack/vite-config@0.4.1':
+    resolution: {integrity: sha512-FOl8EF6SAcljanKSm5aBeJaflFcxQAytTbxtNW8HC6D4x+UBW68IC4tBcrlrsI0wXHBmC/Gz4Ovvv8qCtiXSgQ==}
+    engines: {node: '>=18'}
+
+  '@tanstack/vite-config@0.4.3':
+    resolution: {integrity: sha512-bqXfdPmD6DuAZdE08ih5bSqpcge9Im9nEym3CKcQ9OsPo0jmGW7WrJarLaoVB6qWEysh3FIwWQN1gtfeC7q8UQ==}
     engines: {node: '>=18'}
+    peerDependencies:
+      vite: ^6.0.0 || ^7.0.0
 
   '@testing-library/dom@10.4.1':
     resolution: {integrity: sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==}
@@ -3599,8 +4688,8 @@ packages:
     resolution: {integrity: sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==}
     engines: {node: '>=14', npm: '>=6', yarn: '>=1'}
 
-  '@testing-library/react@16.3.0':
-    resolution: {integrity: sha512-kFSyxiEDwv1WLl2fgsq6pPBbw5aWKrsY2/noi1Id0TK0UParSF62oFQFGHXIyaG4pp2tEub/Zlel+fjjZILDsw==}
+  '@testing-library/react@16.3.1':
+    resolution: {integrity: sha512-gr4KtAWqIOQoucWYD/f6ki+j5chXfcPc74Col/6poTyqTmn7zRmodWahWRCp8tYd+GMqBonw6hstNzqjbs6gjw==}
     engines: {node: '>=18'}
     peerDependencies:
       '@testing-library/dom': ^10.0.0
@@ -3614,14 +4703,14 @@ packages:
       '@types/react-dom':
         optional: true
 
-  '@trpc/client@11.6.0':
-    resolution: {integrity: sha512-DyWbYk2hd50BaVrXWVkaUnaSwgAF5g/lfBkXtkF1Aqlk6BtSzGUo3owPkgqQO2I5LwWy1+ra9TsSfBBvIZpTwg==}
+  '@trpc/client@11.8.1':
+    resolution: {integrity: sha512-L/SJFGanr9xGABmuDoeXR4xAdHJmsXsiF9OuH+apecJ+8sUITzVT1EPeqp0ebqA6lBhEl5pPfg3rngVhi/h60Q==}
     peerDependencies:
-      '@trpc/server': 11.6.0
+      '@trpc/server': 11.8.1
       typescript: '>=5.7.2'
 
-  '@trpc/server@11.6.0':
-    resolution: {integrity: sha512-skTso0AWbOZck40jwNeYv++AMZXNWLUWdyk+pB5iVaYmEKTuEeMoPrEudR12VafbEU6tZa8HK3QhBfTYYHDCdg==}
+  '@trpc/server@11.8.1':
+    resolution: {integrity: sha512-P4rzZRpEL7zDFgjxK65IdyH0e41FMFfTkQkuq0BA5tKcr7E6v9/v38DEklCpoDN6sPiB1Sigy/PUEzHENhswDA==}
     peerDependencies:
       typescript: '>=5.7.2'
 
@@ -3669,8 +4758,8 @@ packages:
   '@types/connect@3.4.38':
     resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==}
 
-  '@types/conventional-commits-parser@5.0.1':
-    resolution: {integrity: sha512-7uz5EHdzz2TqoMfV7ee61Egf5y6NkcO4FB/1iCCQnbeiI1F3xzv3vK5dBCXUCLQgGYS+mUeigK1iKQzvED+QnQ==}
+  '@types/conventional-commits-parser@5.0.2':
+    resolution: {integrity: sha512-BgT2szDXnVypgpNxOK8aL5SGjUdaQbC++WZNjF1Qge3Og2+zhHj+RWhmehLhYyvQwqAmvezruVfOf8+3m74W+g==}
 
   '@types/cors@2.8.19':
     resolution: {integrity: sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==}
@@ -3684,17 +4773,14 @@ packages:
   '@types/estree@1.0.8':
     resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
 
-  '@types/express-serve-static-core@4.19.6':
-    resolution: {integrity: sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==}
-
   '@types/express-serve-static-core@5.0.7':
     resolution: {integrity: sha512-R+33OsgWw7rOhD1emjU7dzCDHucJrgJXMA5PYCzJxVil0dsyx5iBEPHqpPfiKNJQb7lZ1vxwoLR4Z87bBUpeGQ==}
 
-  '@types/express@4.17.23':
-    resolution: {integrity: sha512-Crp6WY9aTYP3qPi2wGDo9iUe/rceX01UMhnF1jmwDcKCFM6cx7YhGP/Mpr3y9AASpfHixIG0E6azCcL5OcDHsQ==}
+  '@types/express@5.0.5':
+    resolution: {integrity: sha512-LuIQOcb6UmnF7C1PCFmEU1u2hmiHL43fgFQX67sN3H4Z+0Yk0Neo++mFsBjhOAuLzvlQeqAAkeDOZrJs9rzumQ==}
 
-  '@types/express@5.0.3':
-    resolution: {integrity: sha512-wGA0NX93b19/dZC1J18tKWVIYWyyF2ZjT9vin/NRu0qzzvfVzWjs04iq2rQ3H65vCTQYlRqs3YHfY7zjdV+9Kw==}
+  '@types/graceful-fs@4.1.9':
+    resolution: {integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==}
 
   '@types/hast@3.0.4':
     resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
@@ -3702,8 +4788,17 @@ packages:
   '@types/http-errors@2.0.5':
     resolution: {integrity: sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==}
 
-  '@types/jasmine@5.1.12':
-    resolution: {integrity: sha512-1BzPxNsFDLDfj9InVR3IeY0ZVf4o9XV+4mDqoCfyPkbsA7dYyKAPAb2co6wLFlHcvxPlt1wShm7zQdV7uTfLGA==}
+  '@types/istanbul-lib-coverage@2.0.6':
+    resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==}
+
+  '@types/istanbul-lib-report@3.0.3':
+    resolution: {integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==}
+
+  '@types/istanbul-reports@3.0.4':
+    resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==}
+
+  '@types/jasmine@5.1.13':
+    resolution: {integrity: sha512-MYCcDkruFc92LeYZux5BC0dmqo2jk+M5UIZ4/oFnAPCXN9mCcQhLyj7F3/Za7rocVyt5YRr1MmqJqFlvQ9LVcg==}
 
   '@types/json-schema@7.0.11':
     resolution: {integrity: sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==}
@@ -3720,14 +4815,11 @@ packages:
   '@types/node@12.20.55':
     resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
 
-  '@types/node@22.18.1':
-    resolution: {integrity: sha512-rzSDyhn4cYznVG+PCzGe1lwuMYJrcBS1fc3JqSa2PvtABwWo+dZ1ij5OVok3tqfpEBCBoaR4d7upFJk73HRJDw==}
-
   '@types/node@24.7.0':
     resolution: {integrity: sha512-IbKooQVqUBrlzWTi79E8Fw78l8k1RNtlDDNWsFZs7XonuQSJ8oNYfEeclhprUldXISRMLzBpILuKgPlIxm+/Yw==}
 
-  '@types/pg@8.15.5':
-    resolution: {integrity: sha512-LF7lF6zWEKxuT3/OR8wAZGzkg4ENGXFNyiV/JeOt9z5B+0ZVwbql9McqX5c/WStFq1GaGso7H1AzP/qSzmlCKQ==}
+  '@types/pg@8.16.0':
+    resolution: {integrity: sha512-RmhMd/wD+CF8Dfo+cVIy3RR5cl8CyfXQ0tGgW6XBL8L4LM/UTEbNXYRbLwU6w+CgrKBNbrQWt4FUtTfaU5jSYQ==}
 
   '@types/qs@6.14.0':
     resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==}
@@ -3735,13 +4827,13 @@ packages:
   '@types/range-parser@1.2.7':
     resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==}
 
-  '@types/react-dom@19.2.2':
-    resolution: {integrity: sha512-9KQPoO6mZCi7jcIStSnlOWn2nEF3mNmyr3rIAsGnAbQKYbRLyqmeSc39EVgtxXVia+LMT8j3knZLAZAh+xLmrw==}
+  '@types/react-dom@19.2.3':
+    resolution: {integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==}
     peerDependencies:
       '@types/react': ^19.2.0
 
-  '@types/react@19.2.2':
-    resolution: {integrity: sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA==}
+  '@types/react@19.2.7':
+    resolution: {integrity: sha512-MWtvHrGZLFttgeEj28VXHxpmwYbor/ATPYbBfSFZEIRK0ecCFLl2Qo55z52Hss+UV9CRN7trSeq1zbgx7YDWWg==}
 
   '@types/send@0.17.5':
     resolution: {integrity: sha512-z6F2D3cOStZvuk2SaP6YrwkNO65iTZcwA2ZkSABegdkAh/lf+Aa/YQndZVfmEXT5vgAp6zv06VQ3ejSVjAny4w==}
@@ -3749,8 +4841,11 @@ packages:
   '@types/serve-static@1.15.8':
     resolution: {integrity: sha512-roei0UY3LhpOJvjbIP6ZZFngyLKl5dskOtDhxY5THRSpO+ZI+nzJ+m5yUMzGrp89YRa7lvknKkMYjqQFGwA7Sg==}
 
-  '@types/simple-peer@9.11.8':
-    resolution: {integrity: sha512-rvqefdp2rvIA6wiomMgKWd2UZNPe6LM2EV5AuY3CPQJF+8TbdrL5TjYdMf0VAjGczzlkH4l1NjDkihwbj3Xodw==}
+  '@types/simple-peer@9.11.9':
+    resolution: {integrity: sha512-6Gdl7TSS5oh9nuwKD4Pl8cSmaxWycYeZz9HLnJBNvIwWjZuGVsmHe9RwW3+9RxfhC1aIR9Z83DvaJoMw6rhkbg==}
+
+  '@types/stack-utils@2.0.3':
+    resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==}
 
   '@types/unist@3.0.3':
     resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
@@ -3767,122 +4862,128 @@ packages:
   '@types/ws@8.18.1':
     resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
 
-  '@typescript-eslint/eslint-plugin@8.44.1':
-    resolution: {integrity: sha512-molgphGqOBT7t4YKCSkbasmu1tb1MgrZ2szGzHbclF7PNmOkSTQVHy+2jXOSnxvR3+Xe1yySHFZoqMpz3TfQsw==}
+  '@types/yargs-parser@21.0.3':
+    resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==}
+
+  '@types/yargs@17.0.35':
+    resolution: {integrity: sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==}
+
+  '@typescript-eslint/eslint-plugin@8.47.0':
+    resolution: {integrity: sha512-fe0rz9WJQ5t2iaLfdbDc9T80GJy0AeO453q8C3YCilnGozvOyCG5t+EZtg7j7D88+c3FipfP/x+wzGnh1xp8ZA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^8.44.1
+      '@typescript-eslint/parser': ^8.47.0
       eslint: ^8.57.0 || ^9.0.0
       typescript: '>=4.8.4 <6.0.0'
 
-  '@typescript-eslint/eslint-plugin@8.46.1':
-    resolution: {integrity: sha512-rUsLh8PXmBjdiPY+Emjz9NX2yHvhS11v0SR6xNJkm5GM1MO9ea/1GoDKlHHZGrOJclL/cZ2i/vRUYVtjRhrHVQ==}
+  '@typescript-eslint/eslint-plugin@8.51.0':
+    resolution: {integrity: sha512-XtssGWJvypyM2ytBnSnKtHYOGT+4ZwTnBVl36TA4nRO2f4PRNGz5/1OszHzcZCvcBMh+qb7I06uoCmLTRdR9og==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^8.46.1
+      '@typescript-eslint/parser': ^8.51.0
       eslint: ^8.57.0 || ^9.0.0
       typescript: '>=4.8.4 <6.0.0'
 
-  '@typescript-eslint/parser@8.44.1':
-    resolution: {integrity: sha512-EHrrEsyhOhxYt8MTg4zTF+DJMuNBzWwgvvOYNj/zm1vnaD/IC5zCXFehZv94Piqa2cRFfXrTFxIvO95L7Qc/cw==}
+  '@typescript-eslint/parser@8.47.0':
+    resolution: {integrity: sha512-lJi3PfxVmo0AkEY93ecfN+r8SofEqZNGByvHAI3GBLrvt1Cw6H5k1IM02nSzu0RfUafr2EvFSw0wAsZgubNplQ==}
     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/parser@8.46.1':
-    resolution: {integrity: sha512-6JSSaBZmsKvEkbRUkf7Zj7dru/8ZCrJxAqArcLaVMee5907JdtEbKGsZ7zNiIm/UAkpGUkaSMZEXShnN2D1HZA==}
+  '@typescript-eslint/parser@8.51.0':
+    resolution: {integrity: sha512-3xP4XzzDNQOIqBMWogftkwxhg5oMKApqY0BAflmLZiFYHqyhSOxv/cd/zPQLTcCXr4AkaKb25joocY0BD1WC6A==}
     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/project-service@8.44.1':
-    resolution: {integrity: sha512-ycSa60eGg8GWAkVsKV4E6Nz33h+HjTXbsDT4FILyL8Obk5/mx4tbvCNsLf9zret3ipSumAOG89UcCs/KRaKYrA==}
+  '@typescript-eslint/project-service@8.47.0':
+    resolution: {integrity: sha512-2X4BX8hUeB5JcA1TQJ7GjcgulXQ+5UkNb0DL8gHsHUHdFoiCTJoYLTpib3LtSDPZsRET5ygN4qqIWrHyYIKERA==}
     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.1':
-    resolution: {integrity: sha512-FOIaFVMHzRskXr5J4Jp8lFVV0gz5ngv3RHmn+E4HYxSJ3DgDzU7fVI1/M7Ijh1zf6S7HIoaIOtln1H5y8V+9Zg==}
+  '@typescript-eslint/project-service@8.51.0':
+    resolution: {integrity: sha512-Luv/GafO07Z7HpiI7qeEW5NW8HUtZI/fo/kE0YbtQEFpJRUuR0ajcWfCE5bnMvL7QQFrmT/odMe8QZww8X2nfQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.0.0'
 
-  '@typescript-eslint/scope-manager@8.44.1':
-    resolution: {integrity: sha512-NdhWHgmynpSvyhchGLXh+w12OMT308Gm25JoRIyTZqEbApiBiQHD/8xgb6LqCWCFcxFtWwaVdFsLPQI3jvhywg==}
+  '@typescript-eslint/scope-manager@8.47.0':
+    resolution: {integrity: sha512-a0TTJk4HXMkfpFkL9/WaGTNuv7JWfFTQFJd6zS9dVAjKsojmv9HT55xzbEpnZoY+VUb+YXLMp+ihMLz/UlZfDg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript-eslint/scope-manager@8.46.1':
-    resolution: {integrity: sha512-weL9Gg3/5F0pVQKiF8eOXFZp8emqWzZsOJuWRUNtHT+UNV2xSJegmpCNQHy37aEQIbToTq7RHKhWvOsmbM680A==}
+  '@typescript-eslint/scope-manager@8.51.0':
+    resolution: {integrity: sha512-JhhJDVwsSx4hiOEQPeajGhCWgBMBwVkxC/Pet53EpBVs7zHHtayKefw1jtPaNRXpI9RA2uocdmpdfE7T+NrizA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript-eslint/tsconfig-utils@8.44.1':
-    resolution: {integrity: sha512-B5OyACouEjuIvof3o86lRMvyDsFwZm+4fBOqFHccIctYgBjqR3qT39FBYGN87khcgf0ExpdCBeGKpKRhSFTjKQ==}
+  '@typescript-eslint/tsconfig-utils@8.47.0':
+    resolution: {integrity: sha512-ybUAvjy4ZCL11uryalkKxuT3w3sXJAuWhOoGS3T/Wu+iUu1tGJmk5ytSY8gbdACNARmcYEB0COksD2j6hfGK2g==}
     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.1':
-    resolution: {integrity: sha512-X88+J/CwFvlJB+mK09VFqx5FE4H5cXD+H/Bdza2aEWkSb8hnWIQorNcscRl4IEo1Cz9VI/+/r/jnGWkbWPx54g==}
+  '@typescript-eslint/tsconfig-utils@8.51.0':
+    resolution: {integrity: sha512-Qi5bSy/vuHeWyir2C8u/uqGMIlIDu8fuiYWv48ZGlZ/k+PRPHtaAu7erpc7p5bzw2WNNSniuxoMSO4Ar6V9OXw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.0.0'
 
-  '@typescript-eslint/type-utils@8.44.1':
-    resolution: {integrity: sha512-KdEerZqHWXsRNKjF9NYswNISnFzXfXNDfPxoTh7tqohU/PRIbwTmsjGK6V9/RTYWau7NZvfo52lgVk+sJh0K3g==}
+  '@typescript-eslint/type-utils@8.47.0':
+    resolution: {integrity: sha512-QC9RiCmZ2HmIdCEvhd1aJELBlD93ErziOXXlHEZyuBo3tBiAZieya0HLIxp+DoDWlsQqDawyKuNEhORyku+P8A==}
     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/type-utils@8.46.1':
-    resolution: {integrity: sha512-+BlmiHIiqufBxkVnOtFwjah/vrkF4MtKKvpXrKSPLCkCtAp8H01/VV43sfqA98Od7nJpDcFnkwgyfQbOG0AMvw==}
+  '@typescript-eslint/type-utils@8.51.0':
+    resolution: {integrity: sha512-0XVtYzxnobc9K0VU7wRWg1yiUrw4oQzexCG2V2IDxxCxhqBMSMbjB+6o91A+Uc0GWtgjCa3Y8bi7hwI0Tu4n5Q==}
     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/types@8.44.1':
-    resolution: {integrity: sha512-Lk7uj7y9uQUOEguiDIDLYLJOrYHQa7oBiURYVFqIpGxclAFQ78f6VUOM8lI2XEuNOKNB7XuvM2+2cMXAoq4ALQ==}
+  '@typescript-eslint/types@8.47.0':
+    resolution: {integrity: sha512-nHAE6bMKsizhA2uuYZbEbmp5z2UpffNrPEqiKIeN7VsV6UY/roxanWfoRrf6x/k9+Obf+GQdkm0nPU+vnMXo9A==}
     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==}
+  '@typescript-eslint/types@8.51.0':
+    resolution: {integrity: sha512-TizAvWYFM6sSscmEakjY3sPqGwxZRSywSsPEiuZF6d5GmGD9Gvlsv0f6N8FvAAA0CD06l3rIcWNbsN1e5F/9Ag==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript-eslint/typescript-estree@8.44.1':
-    resolution: {integrity: sha512-qnQJ+mVa7szevdEyvfItbO5Vo+GfZ4/GZWWDRRLjrxYPkhM+6zYB2vRYwCsoJLzqFCdZT4mEqyJoyzkunsZ96A==}
+  '@typescript-eslint/typescript-estree@8.47.0':
+    resolution: {integrity: sha512-k6ti9UepJf5NpzCjH31hQNLHQWupTRPhZ+KFF8WtTuTpy7uHPfeg2NM7cP27aCGajoEplxJDFVCEm9TGPYyiVg==}
     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.1':
-    resolution: {integrity: sha512-uIifjT4s8cQKFQ8ZBXXyoUODtRoAd7F7+G8MKmtzj17+1UbdzFl52AzRyZRyKqPHhgzvXunnSckVu36flGy8cg==}
+  '@typescript-eslint/typescript-estree@8.51.0':
+    resolution: {integrity: sha512-1qNjGqFRmlq0VW5iVlcyHBbCjPB7y6SxpBkrbhNWMy/65ZoncXCEPJxkRZL8McrseNH6lFhaxCIaX+vBuFnRng==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.0.0'
 
-  '@typescript-eslint/utils@8.44.1':
-    resolution: {integrity: sha512-DpX5Fp6edTlocMCwA+mHY8Mra+pPjRZ0TfHkXI8QFelIKcbADQz1LUPNtzOFUriBB2UYqw4Pi9+xV4w9ZczHFg==}
+  '@typescript-eslint/utils@8.47.0':
+    resolution: {integrity: sha512-g7XrNf25iL4TJOiPqatNuaChyqt49a/onq5YsJ9+hXeugK+41LVg7AxikMfM02PC6jbNtZLCJj6AUcQXJS/jGQ==}
     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.1':
-    resolution: {integrity: sha512-vkYUy6LdZS7q1v/Gxb2Zs7zziuXN0wxqsetJdeZdRe/f5dwJFglmuvZBfTUivCtjH725C1jWCDfpadadD95EDQ==}
+  '@typescript-eslint/utils@8.51.0':
+    resolution: {integrity: sha512-11rZYxSe0zabiKaCP2QAwRf/dnmgFgvTmeDTtZvUvXG3UuAdg/GU02NExmmIXzz3vLGgMdtrIosI84jITQOxUA==}
     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/visitor-keys@8.44.1':
-    resolution: {integrity: sha512-576+u0QD+Jp3tZzvfRfxon0EA2lzcDt3lhUbsC6Lgzy9x2VR4E+JUiNyGHi5T8vk0TV+fpJ5GLG1JsJuWCaKhw==}
+  '@typescript-eslint/visitor-keys@8.47.0':
+    resolution: {integrity: sha512-SIV3/6eftCy1bNzCQoPmbWsRLujS8t5iDIZ4spZOBHqrM+yfX2ogg8Tt3PDTAVKw3sSCiUgg30uOAvK2r9zGjQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript-eslint/visitor-keys@8.46.1':
-    resolution: {integrity: sha512-ptkmIf2iDkNUjdeu2bQqhFPV1m6qTnFFjg7PPDjxKWaMaP0Z6I9l30Jr3g5QqbZGdw8YdYvLp+XnqnWWZOg/NA==}
+  '@typescript-eslint/visitor-keys@8.51.0':
+    resolution: {integrity: sha512-mM/JRQOzhVN1ykejrvwnBRV3+7yTKK8tVANVN3o1O0t0v7o+jqdVu9crPy5Y9dov15TJk/FTIgoUGHrTOVL3Zg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@ungap/raw-json@0.4.4':
@@ -3983,23 +5084,31 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@urql/core@5.2.0':
+    resolution: {integrity: sha512-/n0ieD0mvvDnVAXEQgX/7qJiVcvYvNkOHeBvkwtylfjydar123caCXcl58PXFY11oU1oquJocVXHxLAbtv4x1A==}
+
+  '@urql/exchange-retry@1.3.2':
+    resolution: {integrity: sha512-TQMCz2pFJMfpNxmSfX1VSfTjwUIFx/mL+p1bnfM1xjjdla7Z+KnGMW/EhFbpckp3LyWAH4PgOsMwOMnIN+MBFg==}
+    peerDependencies:
+      '@urql/core': ^5.0.0
+
   '@vitejs/plugin-basic-ssl@2.1.0':
     resolution: {integrity: sha512-dOxxrhgyDIEUADhb/8OlV9JIqYLgos03YorAueTIeOUskLJSEsfwCByjbu98ctXitUN3znXKp0bYD/WHSudCeA==}
     engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
     peerDependencies:
       vite: ^6.0.0 || ^7.0.0
 
-  '@vitejs/plugin-react@5.0.4':
-    resolution: {integrity: sha512-La0KD0vGkVkSk6K+piWDKRUyg8Rl5iAIKRMH0vMJI0Eg47bq1eOxmoObAaQG37WMW9MSyk7Cs8EIWwJC1PtzKA==}
+  '@vitejs/plugin-react@5.1.2':
+    resolution: {integrity: sha512-EcA07pHJouywpzsoTUqNh5NwGayl2PPVEJKUSinGGSxFGYn+shYbqMGBg6FXDqgXum9Ou/ecb+411ssw8HImJQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     peerDependencies:
       vite: ^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
 
-  '@vitejs/plugin-vue@6.0.1':
-    resolution: {integrity: sha512-+MaE752hU0wfPFJEUAIxqw18+20euHHdxVtMvbFcOEpjEyfqXH/5DCoTHiVJ0J29EhTJdoTkjEv5YBKU9dnoTw==}
+  '@vitejs/plugin-vue@6.0.3':
+    resolution: {integrity: sha512-TlGPkLFLVOY3T7fZrwdvKpjprR3s4fxRln0ORDo1VQ7HHyxJwTlrjKU3kpVWTlaAjIEuCTokmjkZnr8Tpc925w==}
     engines: {node: ^20.19.0 || >=22.12.0}
     peerDependencies:
-      vite: ^5.0.0 || ^6.0.0 || ^7.0.0
+      vite: ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0
       vue: ^3.2.25
 
   '@vitest/coverage-istanbul@3.2.4':
@@ -4033,6 +5142,11 @@ packages:
   '@vitest/spy@3.2.4':
     resolution: {integrity: sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==}
 
+  '@vitest/ui@3.2.4':
+    resolution: {integrity: sha512-hGISOaP18plkzbWEcP/QvtRW1xDXF2+96HbEX6byqQhAUbiS5oH6/9JwW+QsQCIYON2bI6QZBF+2PvOmrRZ9wA==}
+    peerDependencies:
+      vitest: 3.2.4
+
   '@vitest/utils@3.2.4':
     resolution: {integrity: sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==}
 
@@ -4045,17 +5159,17 @@ packages:
   '@volar/typescript@2.4.23':
     resolution: {integrity: sha512-lAB5zJghWxVPqfcStmAP1ZqQacMpe90UrP5RJ3arDyrhy4aCUQqmxPPLB2PWDKugvylmO41ljK7vZ+t6INMTag==}
 
-  '@vue/compiler-core@3.5.22':
-    resolution: {integrity: sha512-jQ0pFPmZwTEiRNSb+i9Ow/I/cHv2tXYqsnHKKyCQ08irI2kdF5qmYedmF8si8mA7zepUFmJ2hqzS8CQmNOWOkQ==}
+  '@vue/compiler-core@3.5.26':
+    resolution: {integrity: sha512-vXyI5GMfuoBCnv5ucIT7jhHKl55Y477yxP6fc4eUswjP8FG3FFVFd41eNDArR+Uk3QKn2Z85NavjaxLxOC19/w==}
 
-  '@vue/compiler-dom@3.5.22':
-    resolution: {integrity: sha512-W8RknzUM1BLkypvdz10OVsGxnMAuSIZs9Wdx1vzA3mL5fNMN15rhrSCLiTm6blWeACwUwizzPVqGJgOGBEN/hA==}
+  '@vue/compiler-dom@3.5.26':
+    resolution: {integrity: sha512-y1Tcd3eXs834QjswshSilCBnKGeQjQXB6PqFn/1nxcQw4pmG42G8lwz+FZPAZAby6gZeHSt/8LMPfZ4Rb+Bd/A==}
 
-  '@vue/compiler-sfc@3.5.22':
-    resolution: {integrity: sha512-tbTR1zKGce4Lj+JLzFXDq36K4vcSZbJ1RBu8FxcDv1IGRz//Dh2EBqksyGVypz3kXpshIfWKGOCcqpSbyGWRJQ==}
+  '@vue/compiler-sfc@3.5.26':
+    resolution: {integrity: sha512-egp69qDTSEZcf4bGOSsprUr4xI73wfrY5oRs6GSgXFTiHrWj4Y3X5Ydtip9QMqiCMCPVwLglB9GBxXtTadJ3mA==}
 
-  '@vue/compiler-ssr@3.5.22':
-    resolution: {integrity: sha512-GdgyLvg4R+7T8Nk2Mlighx7XGxq/fJf9jaVofc3IL0EPesTE86cP/8DD1lT3h1JeZr2ySBvyqKQJgbS54IX1Ww==}
+  '@vue/compiler-ssr@3.5.26':
+    resolution: {integrity: sha512-lZT9/Y0nSIRUPVvapFJEVDbEXruZh2IYHMk2zTtEgJSlP5gVOqeWXH54xDKAaFS4rTnDeDBQUYDtxKyoW9FwDw==}
 
   '@vue/compiler-vue2@2.7.16':
     resolution: {integrity: sha512-qYC3Psj9S/mfu9uVi5WvNZIzq+xnXMhOwbTFKKDD7b1lhpnn71jXSFdTQ+WsIEk0ONCd7VV2IMm7ONl6tbQ86A==}
@@ -4068,22 +5182,26 @@ packages:
       typescript:
         optional: true
 
-  '@vue/reactivity@3.5.22':
-    resolution: {integrity: sha512-f2Wux4v/Z2pqc9+4SmgZC1p73Z53fyD90NFWXiX9AKVnVBEvLFOWCEgJD3GdGnlxPZt01PSlfmLqbLYzY/Fw4A==}
+  '@vue/reactivity@3.5.26':
+    resolution: {integrity: sha512-9EnYB1/DIiUYYnzlnUBgwU32NNvLp/nhxLXeWRhHUEeWNTn1ECxX8aGO7RTXeX6PPcxe3LLuNBFoJbV4QZ+CFQ==}
 
-  '@vue/runtime-core@3.5.22':
-    resolution: {integrity: sha512-EHo4W/eiYeAzRTN5PCextDUZ0dMs9I8mQ2Fy+OkzvRPUYQEyK9yAjbasrMCXbLNhF7P0OUyivLjIy0yc6VrLJQ==}
+  '@vue/runtime-core@3.5.26':
+    resolution: {integrity: sha512-xJWM9KH1kd201w5DvMDOwDHYhrdPTrAatn56oB/LRG4plEQeZRQLw0Bpwih9KYoqmzaxF0OKSn6swzYi84e1/Q==}
 
-  '@vue/runtime-dom@3.5.22':
-    resolution: {integrity: sha512-Av60jsryAkI023PlN7LsqrfPvwfxOd2yAwtReCjeuugTJTkgrksYJJstg1e12qle0NarkfhfFu1ox2D+cQotww==}
+  '@vue/runtime-dom@3.5.26':
+    resolution: {integrity: sha512-XLLd/+4sPC2ZkN/6+V4O4gjJu6kSDbHAChvsyWgm1oGbdSO3efvGYnm25yCjtFm/K7rrSDvSfPDgN1pHgS4VNQ==}
 
-  '@vue/server-renderer@3.5.22':
-    resolution: {integrity: sha512-gXjo+ao0oHYTSswF+a3KRHZ1WszxIqO7u6XwNHqcqb9JfyIL/pbWrrh/xLv7jeDqla9u+LK7yfZKHih1e1RKAQ==}
+  '@vue/server-renderer@3.5.26':
+    resolution: {integrity: sha512-TYKLXmrwWKSodyVuO1WAubucd+1XlLg4set0YoV+Hu8Lo79mp/YMwWV5mC5FgtsDxX3qo1ONrxFaTP1OQgy1uA==}
     peerDependencies:
-      vue: 3.5.22
+      vue: 3.5.26
+
+  '@vue/shared@3.5.26':
+    resolution: {integrity: sha512-7Z6/y3uFI5PRoKeorTOSXKcDj0MSasfNNltcslbFrPpcw6aXRUALq4IfJlaTRspiWIUOEZbrpM+iQGmCOiWe4A==}
 
-  '@vue/shared@3.5.22':
-    resolution: {integrity: sha512-F4yc6palwq3TT0u+FYf0Ns4Tfl9GRFURDN2gWG7L1ecIaS/4fCIuFOjMTnCyjsu/OK6vaDKLCrGAa+KvvH+h4w==}
+  '@xmldom/xmldom@0.8.11':
+    resolution: {integrity: sha512-cQzWCtO6C8TQiYl1ruKNn2U6Ao4o4WBBcbL61yJl84x+j5sOWWFU9X7DpND8XZG3daDppSsigMdfAIl2upQBRw==}
+    engines: {node: '>=10.0.0'}
 
   '@yarnpkg/lockfile@1.1.0':
     resolution: {integrity: sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ==}
@@ -4096,6 +5214,10 @@ packages:
     resolution: {integrity: sha512-AO2ac6pjRB3SJmGJo+v5/aK6Omggp6fsLrs6wN9bd35ulu4cCwaAU9+7ZhXjeqHVkaHThLuzH0nZr0YpCDhygg==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
+  abort-controller@3.0.0:
+    resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==}
+    engines: {node: '>=6.5'}
+
   accepts@1.3.8:
     resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}
     engines: {node: '>= 0.6'}
@@ -4150,6 +5272,9 @@ packages:
     resolution: {integrity: sha512-Y+moNhsqgLmvJdgTsO4GZNgsaDWv8AOGAaPeIeHKlDn/XunoAqYbA+XNpBd1dW8GOXAUDyxC9Rxc7AV4kpFcIg==}
     engines: {node: '>= 14.0.0'}
 
+  anser@1.4.10:
+    resolution: {integrity: sha512-hCv9AqTQ8ycjpSd3upOJd7vFwW1JaoYQ7tpham03GJ1ca8/65rqn0RpaWpItOAd6ylW9wAw6luXYPJIyPFVOww==}
+
   ansi-colors@4.1.3:
     resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
     engines: {node: '>=6'}
@@ -4162,6 +5287,10 @@ packages:
     resolution: {integrity: sha512-YdhtCd19sKRKfAAUsrcC1wzm4JuzJoiX4pOJqIoW2qmKj5WzG/dL8uUJ0361zaXtHqK7gEhOwtAtz7t3Yq3X5g==}
     engines: {node: '>=18'}
 
+  ansi-regex@4.1.1:
+    resolution: {integrity: sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==}
+    engines: {node: '>=6'}
+
   ansi-regex@5.0.1:
     resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
     engines: {node: '>=8'}
@@ -4170,6 +5299,10 @@ packages:
     resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
     engines: {node: '>=12'}
 
+  ansi-styles@3.2.1:
+    resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==}
+    engines: {node: '>=4'}
+
   ansi-styles@4.3.0:
     resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
     engines: {node: '>=8'}
@@ -4209,16 +5342,16 @@ packages:
     resolution: {integrity: sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==}
     engines: {node: '>= 0.4'}
 
-  arktype@2.1.23:
-    resolution: {integrity: sha512-tyxNWX6xJVMb2EPJJ3OjgQS1G/vIeQRrZuY4DeBNQmh8n7geS+czgbauQWB6Pr+RXiOO8ChEey44XdmxsqGmfQ==}
+  arkregex@0.0.5:
+    resolution: {integrity: sha512-ncYjBdLlh5/QnVsAA8De16Tc9EqmYM7y/WU9j+236KcyYNUXogpz3sC4ATIZYzzLxwI+0sEOaQLEmLmRleaEXw==}
+
+  arktype@2.1.29:
+    resolution: {integrity: sha512-jyfKk4xIOzvYNayqnD8ZJQqOwcrTOUbIU4293yrzAjA3O1dWh61j71ArMQ6tS/u4pD7vabSPe7nG3RCyoXW6RQ==}
 
   array-buffer-byte-length@1.0.2:
     resolution: {integrity: sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==}
     engines: {node: '>= 0.4'}
 
-  array-flatten@1.1.1:
-    resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==}
-
   array-ify@1.0.0:
     resolution: {integrity: sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==}
 
@@ -4256,6 +5389,9 @@ packages:
   as-typed@1.3.2:
     resolution: {integrity: sha512-94ezeKlKB97OJUyMaU7dQUAB+Cmjlgr4T9/cxCoKaLM4F2HAmuIHm3Q5ClGCsX5PvRwCQehCzAa/6foRFXRbqA==}
 
+  asap@2.0.6:
+    resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==}
+
   asn1js@3.0.6:
     resolution: {integrity: sha512-UOCGPYbl0tv8+006qks/dTgV9ajs97X2p0FAbyS2iyCRrmLSRolDaHdp+v/CLgnzHc3fVB+CwYiUmei7ndFcgA==}
     engines: {node: '>=12.0.0'}
@@ -4272,12 +5408,11 @@ packages:
     resolution: {integrity: sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==}
     engines: {node: '>= 0.4'}
 
-  autoprefixer@10.4.21:
-    resolution: {integrity: sha512-O+A6LWV5LDHSJD3LjHYoNi4VLsj/Whi7k6zG12xTYaU4cQ8oxQGckXNX8cRHK5yOZ/ppVHe0ZBXGzSV9jXdVbQ==}
-    engines: {node: ^10 || ^12 || >=14}
-    hasBin: true
-    peerDependencies:
-      postcss: ^8.1.0
+  async-limiter@1.0.1:
+    resolution: {integrity: sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==}
+
+  async-mutex@0.5.0:
+    resolution: {integrity: sha512-1A94B18jkJ3DYq284ohPxoXbfTA5HsQ7/Mf4DEhcyLx3Bz27Rh59iScbB6EPiP+B+joue6YCxcMXSbFC1tZKwA==}
 
   available-typed-arrays@1.0.7:
     resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
@@ -4287,14 +5422,71 @@ packages:
     resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==}
     engines: {node: '>= 0.4'}
 
-  babel-dead-code-elimination@1.0.10:
-    resolution: {integrity: sha512-DV5bdJZTzZ0zn0DC24v3jD7Mnidh6xhKa4GfKCbq3sfW8kaWhDdZjP3i81geA8T33tdYqWKw4D3fVv0CwEgKVA==}
+  babel-dead-code-elimination@1.0.11:
+    resolution: {integrity: sha512-mwq3W3e/pKSI6TG8lXMiDWvEi1VXYlSBlJlB3l+I0bAb5u1RNUl88udos85eOPNK3m5EXK9uO7d2g08pesTySQ==}
+
+  babel-jest@29.7.0:
+    resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+    peerDependencies:
+      '@babel/core': ^7.8.0
+
+  babel-plugin-istanbul@6.1.1:
+    resolution: {integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==}
+    engines: {node: '>=8'}
+
+  babel-plugin-jest-hoist@29.6.3:
+    resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
   babel-plugin-jsx-dom-expressions@0.40.1:
     resolution: {integrity: sha512-b4iHuirqK7RgaMzB2Lsl7MqrlDgQtVRSSazyrmx7wB3T759ggGjod5Rkok5MfHjQXhR7tRPmdwoeGPqBnW2KfA==}
     peerDependencies:
       '@babel/core': ^7.20.12
 
+  babel-plugin-polyfill-corejs2@0.4.14:
+    resolution: {integrity: sha512-Co2Y9wX854ts6U8gAAPXfn0GmAyctHuK8n0Yhfjd6t30g7yvKjspvvOo9yG+z52PZRgFErt7Ka2pYnXCjLKEpg==}
+    peerDependencies:
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
+
+  babel-plugin-polyfill-corejs3@0.13.0:
+    resolution: {integrity: sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==}
+    peerDependencies:
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
+
+  babel-plugin-polyfill-regenerator@0.6.5:
+    resolution: {integrity: sha512-ISqQ2frbiNU9vIJkzg7dlPpznPZ4jOiUQ1uSmB0fEHeowtN3COYRsXr/xexn64NpU13P06jc/L5TgiJXOgrbEg==}
+    peerDependencies:
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
+
+  babel-plugin-react-native-web@0.19.13:
+    resolution: {integrity: sha512-4hHoto6xaN23LCyZgL9LJZc3olmAxd7b6jDzlZnKXAh4rRAbZRKNBJoOOdp46OBqgy+K0t0guTj5/mhA8inymQ==}
+
+  babel-plugin-syntax-hermes-parser@0.25.1:
+    resolution: {integrity: sha512-IVNpGzboFLfXZUAwkLFcI/bnqVbwky0jP3eBno4HKtqvQJAHBLdgxiG6lQ4to0+Q/YCN3PO0od5NZwIKyY4REQ==}
+
+  babel-plugin-transform-flow-enums@0.0.2:
+    resolution: {integrity: sha512-g4aaCrDDOsWjbm0PUUeVnkcVd6AKJsVc/MbnPhEotEpkeJQP6b8nzewohQi7+QS8UyPehOhGWn0nOwjvWpmMvQ==}
+
+  babel-preset-current-node-syntax@1.2.0:
+    resolution: {integrity: sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==}
+    peerDependencies:
+      '@babel/core': ^7.0.0 || ^8.0.0-0
+
+  babel-preset-expo@13.2.4:
+    resolution: {integrity: sha512-3IKORo3KR+4qtLdCkZNDj8KeA43oBn7RRQejFGWfiZgu/NeaRUSri8YwYjZqybm7hn3nmMv9OLahlvXBX23o5Q==}
+    peerDependencies:
+      babel-plugin-react-compiler: ^19.0.0-beta-e993439-20250405
+    peerDependenciesMeta:
+      babel-plugin-react-compiler:
+        optional: true
+
+  babel-preset-jest@29.6.3:
+    resolution: {integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
   babel-preset-solid@1.9.9:
     resolution: {integrity: sha512-pCnxWrciluXCeli/dj5PIEHgbNzim3evtTn12snjqqg8QZWJNMjH1AWIp4iG/tbVjqQ72aBEymMSagvmgxubXw==}
     peerDependencies:
@@ -4314,12 +5506,16 @@ packages:
     resolution: {integrity: sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==}
     engines: {node: ^4.5.0 || >= 5.9}
 
+  baseline-browser-mapping@2.8.29:
+    resolution: {integrity: sha512-sXdt2elaVnhpDNRDz+1BDx1JQoJRuNk7oVlAlbGiFkLikHCAQiccexF/9e91zVi6RCgqspl04aP+6Cnl9zRLrA==}
+    hasBin: true
+
   beasties@0.3.5:
     resolution: {integrity: sha512-NaWu+f4YrJxEttJSm16AzMIFtVldCvaJ68b1L098KpqXmxt9xOLtKoLkKxb8ekhOrLqEJAbvT6n6SEvB/sac7A==}
     engines: {node: '>=14.0.0'}
 
-  better-auth@1.3.27:
-    resolution: {integrity: sha512-SwiGAJ7yU6dBhNg0NdV1h5M8T5sa7/AszZVc4vBfMDrLLmvUfbt9JoJ0uRUJUEdKRAAxTyl9yA+F3+GhtAD80w==}
+  better-auth@1.3.26:
+    resolution: {integrity: sha512-umaOGmv29yF4sD6o2zlW6B0Oayko5yD/A8mKJOFDDEIoVP/pR7nJ/2KsqKy+xvBpnDsKdrZseqA8fmczPviUHw==}
     peerDependencies:
       '@lynx-js/react': '*'
       '@sveltejs/kit': '*'
@@ -4350,6 +5546,10 @@ packages:
   better-call@1.0.19:
     resolution: {integrity: sha512-sI3GcA1SCVa3H+CDHl8W8qzhlrckwXOTKhqq3OOPXjgn5aTOMIqGY34zLY/pHA6tRRMjTUC3lz5Mi7EbDA24Kw==}
 
+  better-opn@3.0.2:
+    resolution: {integrity: sha512-aVNobHnJqLiUelTaHat9DZ1qM2w0C0Eym4LPI/3JxOnSokGVdsl1T1kN7TFvsEAD8G47A6VKQ0TVHqbBnYMJlQ==}
+    engines: {node: '>=12.0.0'}
+
   better-path-resolve@1.0.0:
     resolution: {integrity: sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==}
     engines: {node: '>=4'}
@@ -4357,6 +5557,10 @@ packages:
   bidi-js@1.0.3:
     resolution: {integrity: sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==}
 
+  big-integer@1.6.52:
+    resolution: {integrity: sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg==}
+    engines: {node: '>=0.6'}
+
   binary-decision-diagram@3.2.0:
     resolution: {integrity: sha512-Pu9LnLdNIpUI6nSSTSJW1IlmTmPVMCJHqr/atIigdeJYTDAI/198AvnAbxuSrCxiJLoTCNiPBzdpHEJMjOZiAQ==}
     engines: {node: '>=16'}
@@ -4376,6 +5580,17 @@ packages:
   boolbase@1.0.0:
     resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==}
 
+  bplist-creator@0.1.0:
+    resolution: {integrity: sha512-sXaHZicyEEmY86WyueLTQesbeoH/mquvarJaQNbjuOQO+7gbFcDEWqKmcWA4cOTLzFlfgvkiVxolk1k5bBIpmg==}
+
+  bplist-parser@0.3.1:
+    resolution: {integrity: sha512-PyJxiNtA5T2PlLIeBot4lbp7rj4OadzjnMZD/G5zuBNt8ei/yCU7+wW0h2bag9vr8c+/WuRWmSxbqAl9hL1rBA==}
+    engines: {node: '>= 5.10.0'}
+
+  bplist-parser@0.3.2:
+    resolution: {integrity: sha512-apC2+fspHGI3mMKj+dGevkGo/tCqVB8jMb6i+OX+E29p0Iposz07fABkRIfVUPNd5A5VbuOz1bZbnmkKLYF+wQ==}
+    engines: {node: '>= 5.10.0'}
+
   brace-expansion@1.1.12:
     resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
 
@@ -4386,14 +5601,17 @@ packages:
     resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
     engines: {node: '>=8'}
 
-  broadcast-channel@7.1.0:
-    resolution: {integrity: sha512-InJljddsYWbEL8LBnopnCg+qMQp9KcowvYWOt4YWrjD5HmxzDYKdVbDS1w/ji5rFZdRD58V5UxJPtBdpEbEJYw==}
+  broadcast-channel@7.2.0:
+    resolution: {integrity: sha512-JgraikEriG/TxBUi2W/w2O0jhHjXZUtXAvCZH0Yr3whjxYVgAg0hSe6r/teM+I5H5Q/q6RhyuKdC2pHNlFyepQ==}
 
-  browserslist@4.25.4:
-    resolution: {integrity: sha512-4jYpcjabC606xJ3kw2QwGEZKX0Aw7sgQdZCvIK9dhVSPh76BKo+C+btT1RRofH7B+8iNpEbgGNVWiLki5q93yg==}
+  browserslist@4.28.0:
+    resolution: {integrity: sha512-tbydkR/CxfMwelN0vwdP/pLkDwyAASZ+VfWm4EOwlB6SWhx1sYnWLqo8N5j0rAzPfzfRaxt0mM/4wPU/Su84RQ==}
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
     hasBin: true
 
+  bser@2.1.1:
+    resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==}
+
   bson@6.10.4:
     resolution: {integrity: sha512-WIsKqkSC0ABoBJuT1LEX+2HEvNmNKKgnTAyd0fL8qzK4SH2i9NXg+t08YtdZp/V9IZ33cxe3iV4yM0qg8lMQng==}
     engines: {node: '>=16.20.1'}
@@ -4401,6 +5619,9 @@ packages:
   buffer-from@1.1.2:
     resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
 
+  buffer@5.7.1:
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
+
   buffer@6.0.3:
     resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==}
 
@@ -4428,21 +5649,41 @@ packages:
     resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
     engines: {node: '>= 0.4'}
 
+  caller-callsite@2.0.0:
+    resolution: {integrity: sha512-JuG3qI4QOftFsZyOn1qq87fq5grLIyk1JYd5lJmdA+fG7aQ9pA/i3JIJGcO3q0MrRcHlOt1U+ZeHW8Dq9axALQ==}
+    engines: {node: '>=4'}
+
+  caller-path@2.0.0:
+    resolution: {integrity: sha512-MCL3sf6nCSXOwCTzvPKhN18TU7AHTvdtam8DAogxcrJ8Rjfbbg7Lgng64H9Iy+vUV6VGFClN/TyxBkAebLRR4A==}
+    engines: {node: '>=4'}
+
+  callsites@2.0.0:
+    resolution: {integrity: sha512-ksWePWBloaWPxJYQ8TL0JHvtci6G5QTKwQ95RcWAa/lzoAKuAOflGdAK92hpHXjkwb8zLxoLNUoNYZgVsaJzvQ==}
+    engines: {node: '>=4'}
+
   callsites@3.1.0:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
 
-  camelcase-css@2.0.1:
-    resolution: {integrity: sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==}
-    engines: {node: '>= 6'}
+  camelcase@5.3.1:
+    resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==}
+    engines: {node: '>=6'}
 
-  caniuse-lite@1.0.30001741:
-    resolution: {integrity: sha512-QGUGitqsc8ARjLdgAfxETDhRbJ0REsP6O3I96TAth/mVjh2cYzN2u+3AzPP3aVSm2FehEItaJw1xd+IGBXWeSw==}
+  camelcase@6.3.0:
+    resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
+    engines: {node: '>=10'}
+
+  caniuse-lite@1.0.30001755:
+    resolution: {integrity: sha512-44V+Jm6ctPj7R52Na4TLi3Zri4dWUljJd+RDm+j8LtNCc/ihLCT+X1TzoOAkRETEWqjuLnh9581Tl80FvK7jVA==}
 
   chai@5.3.3:
     resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==}
     engines: {node: '>=18'}
 
+  chalk@2.4.2:
+    resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==}
+    engines: {node: '>=4'}
+
   chalk@4.1.2:
     resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
     engines: {node: '>=10'}
@@ -4451,8 +5692,8 @@ packages:
     resolution: {integrity: sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==}
     engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
 
-  chardet@2.1.0:
-    resolution: {integrity: sha512-bNFETTG/pM5ryzQ9Ad0lJOTa6HWD/YsScAR3EnCPZRPlQh77JocYktSHOUHelyhm8IARL+o4c4F1bP5KVOjiRA==}
+  chardet@2.1.1:
+    resolution: {integrity: sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==}
 
   check-error@2.1.1:
     resolution: {integrity: sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==}
@@ -4473,6 +5714,10 @@ packages:
     resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==}
     engines: {node: '>= 14.16.0'}
 
+  chokidar@5.0.0:
+    resolution: {integrity: sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==}
+    engines: {node: '>= 20.19.0'}
+
   chownr@2.0.0:
     resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
     engines: {node: '>=10'}
@@ -4481,10 +5726,25 @@ packages:
     resolution: {integrity: sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==}
     engines: {node: '>=18'}
 
+  chrome-launcher@0.15.2:
+    resolution: {integrity: sha512-zdLEwNo3aUVzIhKhTtXfxhdvZhUghrnmkvcAq2NoDd+LeOHKf03H5jwZ8T/STsAlzyALkBVK552iaG1fGf1xVQ==}
+    engines: {node: '>=12.13.0'}
+    hasBin: true
+
+  chromium-edge-launcher@0.2.0:
+    resolution: {integrity: sha512-JfJjUnq25y9yg4FABRRVPmBGWPZZi+AQXT4mxupb67766/0UlhG8PAZCz6xzEMXTbW3CsSoE8PcCWA49n35mKg==}
+
+  ci-info@2.0.0:
+    resolution: {integrity: sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==}
+
   ci-info@3.9.0:
     resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==}
     engines: {node: '>=8'}
 
+  cli-cursor@2.1.0:
+    resolution: {integrity: sha512-8lgKz8LmCRYZZQDpRyT2m5rKJ08TnU4tR9FFFW2rxpxR1FzWi4PQ/NfyODchAatHaUgnSPVcx/R5w6NuTBzFiw==}
+    engines: {node: '>=4'}
+
   cli-cursor@5.0.0:
     resolution: {integrity: sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==}
     engines: {node: '>=18'}
@@ -4501,6 +5761,9 @@ packages:
     resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==}
     engines: {node: '>= 12'}
 
+  client-only@0.0.1:
+    resolution: {integrity: sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==}
+
   cliui@7.0.4:
     resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==}
 
@@ -4512,24 +5775,48 @@ packages:
     resolution: {integrity: sha512-k7ndgKhwoQveBL+/1tqGJYNz097I7WOvwbmmU2AR5+magtbjPWQTS1C5vzGkBC8Ym8UWRzfKUzUUqFLypY4Q+w==}
     engines: {node: '>=20'}
 
+  clone@1.0.4:
+    resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==}
+    engines: {node: '>=0.8'}
+
   clsx@2.1.1:
     resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
     engines: {node: '>=6'}
 
+  color-convert@1.9.3:
+    resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
+
   color-convert@2.0.1:
     resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
     engines: {node: '>=7.0.0'}
 
+  color-name@1.1.3:
+    resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==}
+
   color-name@1.1.4:
     resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
 
+  color-string@1.9.1:
+    resolution: {integrity: sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==}
+
+  color@4.2.3:
+    resolution: {integrity: sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==}
+    engines: {node: '>=12.5.0'}
+
   colorette@2.0.20:
     resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==}
 
+  comlink@4.4.2:
+    resolution: {integrity: sha512-OxGdvBmJuNKSCMO4NTl1L47VRp6xn2wG4F/2hYzB6tiCb709otOxtEYCSvK80PtjODfXXZu8ds+Nw5kVCjqd2g==}
+
   commander@11.1.0:
     resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==}
     engines: {node: '>=16'}
 
+  commander@12.1.0:
+    resolution: {integrity: sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==}
+    engines: {node: '>=18'}
+
   commander@13.1.0:
     resolution: {integrity: sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==}
     engines: {node: '>=18'}
@@ -4541,6 +5828,10 @@ packages:
     resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==}
     engines: {node: '>= 6'}
 
+  commander@7.2.0:
+    resolution: {integrity: sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==}
+    engines: {node: '>= 10'}
+
   comment-parser@1.4.1:
     resolution: {integrity: sha512-buhp5kePrmda3vhc5B9t7pUQXAb2Tnd0qgpkIhPhkHXxJpiPJ11H0ZEU0oBpJ2QztSbzG/ZxMj/CHsYJqRHmyg==}
     engines: {node: '>= 12.0.0'}
@@ -4555,6 +5846,14 @@ packages:
   compare-versions@6.1.1:
     resolution: {integrity: sha512-4hm4VPpIecmlg59CHXnRDnqGplJFrbLG4aFEl5vl6cK1u76ws3LLvX7ikFnTDl5vo39sjWD6AaDPYodJp/NNHg==}
 
+  compressible@2.0.18:
+    resolution: {integrity: sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==}
+    engines: {node: '>= 0.6'}
+
+  compression@1.8.1:
+    resolution: {integrity: sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==}
+    engines: {node: '>= 0.8.0'}
+
   computeds@0.0.1:
     resolution: {integrity: sha512-7CEBgcMjVmitjYo5q8JTJVra6X5mQ20uTThdK+0kR7UEaDrAWEQcRiBtWJzga4eRpP6afNwwLsX2SET2JhVB1Q==}
 
@@ -4573,10 +5872,6 @@ packages:
     resolution: {integrity: sha512-ZqRXc+tZukToSNmh5C2iWMSoV3X1YUcPbqEM4DkEG5tNQXrQUZCNVGGv3IuicnkMtPfGf3Xtp8WCXs295iQ1pQ==}
     engines: {node: '>= 0.10.0'}
 
-  content-disposition@0.5.4:
-    resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==}
-    engines: {node: '>= 0.6'}
-
   content-disposition@1.0.0:
     resolution: {integrity: sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==}
     engines: {node: '>= 0.6'}
@@ -4603,25 +5898,29 @@ packages:
   cookie-es@2.0.0:
     resolution: {integrity: sha512-RAj4E421UYRgqokKUmotqAwuplYw15qtdXfY+hGzgCJ/MBjCVZcSoHK/kH9kocfjRjcDME7IiDWR/1WX1TM2Pg==}
 
-  cookie-signature@1.0.6:
-    resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==}
-
   cookie-signature@1.2.2:
     resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==}
     engines: {node: '>=6.6.0'}
 
-  cookie@0.7.1:
-    resolution: {integrity: sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==}
-    engines: {node: '>= 0.6'}
-
   cookie@0.7.2:
     resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==}
     engines: {node: '>= 0.6'}
 
+  copy-anything@4.0.5:
+    resolution: {integrity: sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==}
+    engines: {node: '>=18'}
+
+  core-js-compat@3.47.0:
+    resolution: {integrity: sha512-IGfuznZ/n7Kp9+nypamBhvwdwLsW6KC8IOaURw2doAK5e98AG3acVLdh0woOnEqCfUtS+Vu882JE4k/DAm3ItQ==}
+
   cors@2.8.5:
     resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==}
     engines: {node: '>= 0.10'}
 
+  cosmiconfig@5.2.1:
+    resolution: {integrity: sha512-H65gsXo1SKjf8zmrJ67eJk8aIRKV5ff2D4uKZIBZShbhGSpEmsQOPW/SKMKYhSTrqR7ufy6RP69rPogdaPh/kA==}
+    engines: {node: '>=4'}
+
   cross-spawn@6.0.6:
     resolution: {integrity: sha512-VqCUuhcd1iB+dsv8gxPttb5iZh/D0iubSP21g36KXdEuf6I5JiioesUVjpCdHV9MZRUfVFlvwtIUyPfxo5trtw==}
     engines: {node: '>=4.8'}
@@ -4633,6 +5932,10 @@ packages:
   crypto-js@4.2.0:
     resolution: {integrity: sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==}
 
+  crypto-random-string@2.0.0:
+    resolution: {integrity: sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==}
+    engines: {node: '>=8'}
+
   css-select@5.2.2:
     resolution: {integrity: sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==}
 
@@ -4654,17 +5957,12 @@ packages:
   css.escape@1.5.1:
     resolution: {integrity: sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==}
 
-  cssesc@3.0.0:
-    resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
-    engines: {node: '>=4'}
-    hasBin: true
-
-  cssstyle@5.3.1:
-    resolution: {integrity: sha512-g5PC9Aiph9eiczFpcgUhd9S4UUO3F+LHGRIi5NUMZ+4xtoIYbHNZwZnWA2JsFGe8OU8nl4WyaEFiZuGuxlutJQ==}
+  cssstyle@5.3.5:
+    resolution: {integrity: sha512-GlsEptulso7Jg0VaOZ8BXQi3AkYM5BOJKEO/rjMidSCq70FkIC5y0eawrCXeYzxgt3OCf4Ls+eoxN+/05vN0Ag==}
     engines: {node: '>=20'}
 
-  csstype@3.1.3:
-    resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
 
   custom-event@1.0.1:
     resolution: {integrity: sha512-GAj5FOq0Hd+RsCGVJxZuKaIDXDf3h6GQoNEjFgbLLI/trgtavwUbSnZ5pVfg27DVCaWjIohryS0JFwIJyT2cMg==}
@@ -4706,6 +6004,14 @@ packages:
       supports-color:
         optional: true
 
+  debug@3.2.7:
+    resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
   debug@4.3.7:
     resolution: {integrity: sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==}
     engines: {node: '>=6.0'}
@@ -4727,6 +6033,10 @@ packages:
   decimal.js@10.6.0:
     resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==}
 
+  decode-uri-component@0.2.2:
+    resolution: {integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==}
+    engines: {node: '>=0.10'}
+
   dedent-js@1.0.1:
     resolution: {integrity: sha512-OUepMozQULMLUmhxS95Vudo0jb0UchLimi3+pQ2plj61Fcy8axbP9hbiD4Sz6DPqn6XG3kfmziVfQ1rSys5AJQ==}
 
@@ -4734,6 +6044,10 @@ packages:
     resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==}
     engines: {node: '>=6'}
 
+  deep-extend@0.6.0:
+    resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==}
+    engines: {node: '>=4.0.0'}
+
   deep-is@0.1.4:
     resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
 
@@ -4741,6 +6055,9 @@ packages:
     resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
     engines: {node: '>=0.10.0'}
 
+  defaults@1.0.4:
+    resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==}
+
   defekt@9.3.0:
     resolution: {integrity: sha512-AWfM0vhFmESRZawEJfLhRJMsAR5IOhwyxGxIDOh9RXGKcdV65cWtkFB31MNjUfFvAlfbk3c2ooX0rr1pWIXshw==}
     deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
@@ -4749,6 +6066,10 @@ packages:
     resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==}
     engines: {node: '>= 0.4'}
 
+  define-lazy-prop@2.0.0:
+    resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
+    engines: {node: '>=8'}
+
   define-properties@1.2.1:
     resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==}
     engines: {node: '>= 0.4'}
@@ -4781,15 +6102,15 @@ packages:
     resolution: {integrity: sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==}
     engines: {node: '>=8'}
 
+  devalue@5.6.2:
+    resolution: {integrity: sha512-nPRkjWzzDQlsejL1WVifk5rvcFi/y1onBRxjaFMjZeR9mFpqu2gmAZ9xUB9/IEanEP/vBtGeGganC/GO1fmufg==}
+
   dexie@4.0.10:
     resolution: {integrity: sha512-eM2RzuR3i+M046r2Q0Optl3pS31qTWf8aFuA7H9wnsHTwl8EPvroVLwvQene/6paAs39Tbk6fWZcn2aZaHkc/w==}
 
   di@0.0.1:
     resolution: {integrity: sha512-uJaamHkagcZtHPqCIHZxnFrXlunQXgBOsZSUOWwFw31QJCAbyTBoHMW75YOTur5ZNx8pIeAKgf6GWIgaqqiLhA==}
 
-  didyoumean@1.2.2:
-    resolution: {integrity: sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==}
-
   diff@8.0.2:
     resolution: {integrity: sha512-sSuxWU5j5SR9QQji/o2qMvqRNYRDOcBTgsJ/DeCf4iSN4gW+gNMXM7wFIP+fdXZxoNiAnHUTGjCr+TSWXdRDKg==}
     engines: {node: '>=0.3.1'}
@@ -4798,9 +6119,6 @@ packages:
     resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
     engines: {node: '>=8'}
 
-  dlv@1.1.3:
-    resolution: {integrity: sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==}
-
   doctrine@2.1.0:
     resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==}
     engines: {node: '>=0.10.0'}
@@ -4831,6 +6149,14 @@ packages:
     resolution: {integrity: sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==}
     engines: {node: '>=8'}
 
+  dotenv-expand@11.0.7:
+    resolution: {integrity: sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA==}
+    engines: {node: '>=12'}
+
+  dotenv@16.4.7:
+    resolution: {integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==}
+    engines: {node: '>=12'}
+
   dotenv@16.6.1:
     resolution: {integrity: sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==}
     engines: {node: '>=12'}
@@ -4839,12 +6165,12 @@ packages:
     resolution: {integrity: sha512-JVUnt+DUIzu87TABbhPmNfVdBDt18BLOWjMUFJMSi/Qqg7NTYtabbvSNJGOJ7afbRuv9D/lngizHtP7QyLQ+9w==}
     engines: {node: '>=12'}
 
-  drizzle-kit@0.31.5:
-    resolution: {integrity: sha512-+CHgPFzuoTQTt7cOYCV6MOw2w8vqEn/ap1yv4bpZOWL03u7rlVRQhUY0WYT3rHsgVTXwYQDZaSUJSQrMBUKuWg==}
+  drizzle-kit@0.31.8:
+    resolution: {integrity: sha512-O9EC/miwdnRDY10qRxM8P3Pg8hXe3LyU4ZipReKOgTwn4OqANmftj8XJz1UPUAS6NMHf0E2htjsbQujUTkncCg==}
     hasBin: true
 
-  drizzle-orm@0.44.6:
-    resolution: {integrity: sha512-uy6uarrrEOc9K1u5/uhBFJbdF5VJ5xQ/Yzbecw3eAYOunv5FDeYkR2m8iitocdHBOHbvorviKOW5GVw0U1j4LQ==}
+  drizzle-orm@0.45.1:
+    resolution: {integrity: sha512-Te0FOdKIistGNPMq2jscdqngBRfBpC8uMFVwqjf6gtTVJHIQ/dosgV/CLBU2N4ZJBsXL5savCba9b0YJskKdcA==}
     peerDependencies:
       '@aws-sdk/client-rds-data': '>=3'
       '@cloudflare/workers-types': '>=4'
@@ -4951,8 +6277,8 @@ packages:
   ee-first@1.1.1:
     resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
 
-  electron-to-chromium@1.5.215:
-    resolution: {integrity: sha512-TIvGp57UpeNetj/wV/xpFNpWGb0b/ROw372lHPx5Aafx02gjTBtWnEEcaSX3W2dLM3OSdGGyHX/cHl01JQsLaQ==}
+  electron-to-chromium@1.5.254:
+    resolution: {integrity: sha512-DcUsWpVhv9svsKRxnSCZ86SjD+sp32SGidNB37KpqXJncp1mfUgKbHvBomE89WJDbfVKw1mdv5+ikrvd43r+Bg==}
 
   emoji-regex@10.5.0:
     resolution: {integrity: sha512-lb49vf1Xzfx080OKA0o6l8DQQpV+6Vg95zyCJX9VB/BqKYlhG7N4wgROUUHRA+ZPUefLnteQOad7z1kT2bV7bg==}
@@ -5008,6 +6334,14 @@ packages:
     resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==}
     engines: {node: '>=0.12'}
 
+  entities@7.0.0:
+    resolution: {integrity: sha512-FDWG5cmEYf2Z00IkYRhbFrwIwvdFKH07uV8dvNy0omp/Qb1xcyCWp2UDtcwJF4QZZvk0sLudP6/hAu42TaqVhQ==}
+    engines: {node: '>=0.12'}
+
+  env-editor@0.4.2:
+    resolution: {integrity: sha512-ObFo8v4rQJAE59M69QzwloxPZtd33TpYEIjtKD1rrFDcM1Gd7IkDxEBU+HriziN6HSHQnBJi8Dmy+JWkav5HKA==}
+    engines: {node: '>=8'}
+
   env-paths@2.2.1:
     resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
     engines: {node: '>=6'}
@@ -5026,6 +6360,12 @@ packages:
   err-code@3.0.1:
     resolution: {integrity: sha512-GiaH0KJUewYok+eeY05IIgjtAe4Yltygk9Wqp1V5yVWLdhf0hYZchRjNIT9bb0mSwRcIusT3cx7PJUf3zEIfUA==}
 
+  error-ex@1.3.4:
+    resolution: {integrity: sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==}
+
+  error-stack-parser@2.1.4:
+    resolution: {integrity: sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ==}
+
   es-abstract@1.24.0:
     resolution: {integrity: sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==}
     engines: {node: '>= 0.4'}
@@ -5081,6 +6421,11 @@ packages:
     engines: {node: '>=18'}
     hasBin: true
 
+  esbuild@0.27.2:
+    resolution: {integrity: sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   escalade@3.2.0:
     resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
     engines: {node: '>=6'}
@@ -5088,6 +6433,14 @@ packages:
   escape-html@1.0.3:
     resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==}
 
+  escape-string-regexp@1.0.5:
+    resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==}
+    engines: {node: '>=0.8.0'}
+
+  escape-string-regexp@2.0.0:
+    resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==}
+    engines: {node: '>=8'}
+
   escape-string-regexp@4.0.0:
     resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
     engines: {node: '>=10'}
@@ -5171,8 +6524,8 @@ packages:
     peerDependencies:
       eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0
 
-  eslint-plugin-react-refresh@0.4.24:
-    resolution: {integrity: sha512-nLHIW7TEq3aLrEYWpVaJ1dRgFR+wLDPN8e8FpYAql/bMV2oBEfC37K0gLEGgv9fy66juNShSMV8OkTqzltcG/w==}
+  eslint-plugin-react-refresh@0.4.26:
+    resolution: {integrity: sha512-1RETEylht2O6FM/MvgnyvT+8K21wLqDNg4qD51Zj3guhjt433XbnnkVttHMyaVyAFD03QSV4LPS5iE3VQmO7XQ==}
     peerDependencies:
       eslint: '>=8.40'
 
@@ -5201,8 +6554,8 @@ packages:
     resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  eslint@9.38.0:
-    resolution: {integrity: sha512-t5aPOpmtJcZcz5UJyY2GbvpDlsK5E8JqRqoKtfiKE3cNh437KIqfJr3A3AKf5k64NPx6d0G3dno6XDY05PqPtw==}
+  eslint@9.39.2:
+    resolution: {integrity: sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     hasBin: true
     peerDependencies:
@@ -5227,8 +6580,8 @@ packages:
     resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==}
     engines: {node: '>=0.10'}
 
-  esrap@2.1.0:
-    resolution: {integrity: sha512-yzmPNpl7TBbMRC5Lj2JlJZNPml0tzqoqP5B1JXycNUwtqma9AKCO0M2wHrdgsHcy1WRW7S9rJknAMtByg3usgA==}
+  esrap@2.2.1:
+    resolution: {integrity: sha512-GiYWG34AN/4CUyaWAgunGt0Rxvr1PTMlGC0vvEov/uOQYWne2bpN03Um+k8jT+q3op33mKouP2zeJ6OlM+qeUg==}
 
   esrecurse@4.3.0:
     resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
@@ -5252,10 +6605,17 @@ packages:
     resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
     engines: {node: '>= 0.6'}
 
+  event-iterator@2.0.0:
+    resolution: {integrity: sha512-KGft0ldl31BZVV//jj+IAIGCxkvvUkkON+ScH6zfoX+l+omX6001ggyRSpI0Io2Hlro0ThXotswCtfzS8UkIiQ==}
+
   event-reduce-js@5.2.7:
     resolution: {integrity: sha512-Vi6aIiAmakzx81JAwhw8L988aSX5a3ZqqVjHyZa9xFU6P4oT1IotoDreWtjNlS+fvEnASvyIQT565nmkOtns/Q==}
     engines: {node: '>=16'}
 
+  event-target-shim@5.0.1:
+    resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==}
+    engines: {node: '>=6'}
+
   eventemitter3@4.0.7:
     resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
 
@@ -5270,6 +6630,9 @@ packages:
     resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==}
     engines: {node: '>=18.0.0'}
 
+  exec-async@2.2.0:
+    resolution: {integrity: sha512-87OpwcEiMia/DeiKFzaQNBNFeN3XkkpYIh9FyOqq5mS2oKv3CBE67PXoEKcr6nodWdXNogTiQ0jE2NGuoffXPw==}
+
   execa@1.0.0:
     resolution: {integrity: sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==}
     engines: {node: '>=6'}
@@ -5282,6 +6645,95 @@ packages:
     resolution: {integrity: sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==}
     engines: {node: '>=12.0.0'}
 
+  expo-asset@11.1.7:
+    resolution: {integrity: sha512-b5P8GpjUh08fRCf6m5XPVAh7ra42cQrHBIMgH2UXP+xsj4Wufl6pLy6jRF5w6U7DranUMbsXm8TOyq4EHy7ADg==}
+    peerDependencies:
+      expo: '*'
+      react: '*'
+      react-native: '*'
+
+  expo-constants@17.1.8:
+    resolution: {integrity: sha512-sOCeMN/BWLA7hBP6lMwoEQzFNgTopk6YY03sBAmwT216IHyL54TjNseg8CRU1IQQ/+qinJ2fYWCl7blx2TiNcA==}
+    peerDependencies:
+      expo: '*'
+      react-native: '*'
+
+  expo-file-system@18.1.11:
+    resolution: {integrity: sha512-HJw/m0nVOKeqeRjPjGdvm+zBi5/NxcdPf8M8P3G2JFvH5Z8vBWqVDic2O58jnT1OFEy0XXzoH9UqFu7cHg9DTQ==}
+    peerDependencies:
+      expo: '*'
+      react-native: '*'
+
+  expo-font@13.3.2:
+    resolution: {integrity: sha512-wUlMdpqURmQ/CNKK/+BIHkDA5nGjMqNlYmW0pJFXY/KE/OG80Qcavdu2sHsL4efAIiNGvYdBS10WztuQYU4X0A==}
+    peerDependencies:
+      expo: '*'
+      react: '*'
+
+  expo-keep-awake@14.1.4:
+    resolution: {integrity: sha512-wU9qOnosy4+U4z/o4h8W9PjPvcFMfZXrlUoKTMBW7F4pLqhkkP/5G4EviPZixv4XWFMjn1ExQ5rV6BX8GwJsWA==}
+    peerDependencies:
+      expo: '*'
+      react: '*'
+
+  expo-linking@7.1.7:
+    resolution: {integrity: sha512-ZJaH1RIch2G/M3hx2QJdlrKbYFUTOjVVW4g39hfxrE5bPX9xhZUYXqxqQtzMNl1ylAevw9JkgEfWbBWddbZ3UA==}
+    peerDependencies:
+      react: '*'
+      react-native: '*'
+
+  expo-modules-autolinking@2.1.14:
+    resolution: {integrity: sha512-nT5ERXwc+0ZT/pozDoJjYZyUQu5RnXMk9jDGm5lg+PiKvsrCTSA/2/eftJGMxLkTjVI2MXp5WjSz3JRjbA7UXA==}
+    hasBin: true
+
+  expo-modules-core@2.5.0:
+    resolution: {integrity: sha512-aIbQxZE2vdCKsolQUl6Q9Farlf8tjh/ROR4hfN1qT7QBGPl1XrJGnaOKkcgYaGrlzCPg/7IBe0Np67GzKMZKKQ==}
+
+  expo-router@5.1.10:
+    resolution: {integrity: sha512-Txi2KX5iF5D+60n8vhgWFlmbxHOjaAO7y/VuQa+WdCh0nuyEJkJEmza2kt+nvH/JCi8sYIGU2ZDNNejObN6sDg==}
+    peerDependencies:
+      '@react-navigation/drawer': ^7.3.9
+      '@testing-library/jest-native': '*'
+      expo: '*'
+      expo-constants: '*'
+      expo-linking: '*'
+      react-native-reanimated: '*'
+      react-native-safe-area-context: '*'
+      react-native-screens: '*'
+      react-server-dom-webpack: ~19.0.3 || ~19.1.4 || ~19.2.3
+    peerDependenciesMeta:
+      '@react-navigation/drawer':
+        optional: true
+      '@testing-library/jest-native':
+        optional: true
+      react-native-reanimated:
+        optional: true
+      react-server-dom-webpack:
+        optional: true
+
+  expo-status-bar@2.2.3:
+    resolution: {integrity: sha512-+c8R3AESBoduunxTJ8353SqKAKpxL6DvcD8VKBuh81zzJyUUbfB4CVjr1GufSJEKsMzNPXZU+HJwXx7Xh7lx8Q==}
+    peerDependencies:
+      react: '*'
+      react-native: '*'
+
+  expo@53.0.25:
+    resolution: {integrity: sha512-KMaIMAd0vKl2ooiDB9XMKTuRAhSmrLdPOEON8Ck9mPmSrJB1FHBs6gb63d5IJTQAE1jBZLZj0JBg6rqRBOrTjg==}
+    hasBin: true
+    peerDependencies:
+      '@expo/dom-webview': '*'
+      '@expo/metro-runtime': '*'
+      react: '*'
+      react-native: '*'
+      react-native-webview: '*'
+    peerDependenciesMeta:
+      '@expo/dom-webview':
+        optional: true
+      '@expo/metro-runtime':
+        optional: true
+      react-native-webview:
+        optional: true
+
   exponential-backoff@3.1.2:
     resolution: {integrity: sha512-8QxYTVXUkuy7fIIoitQkPwGonB8F3Zj8eEO8Sqg9Zv/bkI7RJAzowee4gr81Hak/dUTpA2Z7VfQgoijjPNlUZA==}
 
@@ -5291,10 +6743,6 @@ packages:
     peerDependencies:
       express: '>= 4.11'
 
-  express@4.21.2:
-    resolution: {integrity: sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==}
-    engines: {node: '>= 0.10.0'}
-
   express@5.1.0:
     resolution: {integrity: sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==}
     engines: {node: '>= 18'}
@@ -5308,6 +6756,10 @@ packages:
   extendable-error@0.1.7:
     resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==}
 
+  fast-check@3.23.2:
+    resolution: {integrity: sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A==}
+    engines: {node: '>=8.0.0'}
+
   fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
@@ -5334,6 +6786,9 @@ packages:
     resolution: {integrity: sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==}
     engines: {node: '>=0.8.0'}
 
+  fb-watchman@2.0.2:
+    resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==}
+
   fd-package-json@2.0.0:
     resolution: {integrity: sha512-jKmm9YtsNXN789RS/0mSzOC1NUq9mkVd65vbSSVsKdjGvYXBuE4oWe2QOEoFeRmJg+lPuZxpmrfFclNhoRMneQ==}
 
@@ -5346,8 +6801,8 @@ packages:
       picomatch:
         optional: true
 
-  fetchdts@0.1.7:
-    resolution: {integrity: sha512-YoZjBdafyLIop9lSxXVI33oLD5kN31q4Td+CasofLLYeLXRFeOsuOw0Uo+XNRi9PZlbfdlN2GmRtm4tCEQ9/KA==}
+  fflate@0.8.2:
+    resolution: {integrity: sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==}
 
   file-entry-cache@8.0.0:
     resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
@@ -5357,14 +6812,14 @@ packages:
     resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
     engines: {node: '>=8'}
 
+  filter-obj@1.1.0:
+    resolution: {integrity: sha512-8rXg1ZnX7xzy2NGDVkBVaAy+lSlPNwad13BtgSlLuxfIslyt5Vg64U7tFcCt4WS1R0hvtnQybT/IyCkGZ3DpXQ==}
+    engines: {node: '>=0.10.0'}
+
   finalhandler@1.1.2:
     resolution: {integrity: sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==}
     engines: {node: '>= 0.8'}
 
-  finalhandler@1.3.1:
-    resolution: {integrity: sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==}
-    engines: {node: '>= 0.8'}
-
   finalhandler@2.1.0:
     resolution: {integrity: sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==}
     engines: {node: '>= 0.8'}
@@ -5387,6 +6842,9 @@ packages:
   flatted@3.3.3:
     resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
 
+  flow-enums-runtime@0.0.6:
+    resolution: {integrity: sha512-3PYnM29RFXwvAN6Pc/scUfkI7RwhQ/xqyLUyPNlXUp9S40zI8nup9tUSrTLSVnWGBN38FNiGWbwZOB6uR4OGdw==}
+
   follow-redirects@1.15.11:
     resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==}
     engines: {node: '>=4.0'}
@@ -5396,6 +6854,9 @@ packages:
       debug:
         optional: true
 
+  fontfaceobserver@2.3.0:
+    resolution: {integrity: sha512-6FPvD/IVyT4ZlNe7Wcn5Fb/4ChigpucKYSvD6a+0iMoLn2inpo711eyIcKjmDtE5XNcgAkSH9uN/nfAeZzHEfg==}
+
   for-each@0.3.5:
     resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
     engines: {node: '>= 0.4'}
@@ -5413,13 +6874,14 @@ packages:
     resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}
     engines: {node: '>= 0.6'}
 
-  fraction.js@4.3.7:
-    resolution: {integrity: sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==}
-
   fractional-indexing@3.2.0:
     resolution: {integrity: sha512-PcOxmqwYCW7O2ovKRU8OoQQj2yqTfEB/yeTYk4gPid6dN5ODRfU1hXd9tTVZzax/0NkO7AxpHykvZnT1aYp/BQ==}
     engines: {node: ^14.13.1 || >=16.0.0}
 
+  freeport-async@2.0.0:
+    resolution: {integrity: sha512-K7od3Uw45AJg00XUmy15+Hae2hOcgKcmN3/EF6Y7i01O0gaqiRx8sUSpsb9+BRNL8RPBrhzPsVfy8q9ADlJuWQ==}
+    engines: {node: '>=8'}
+
   fresh@0.5.2:
     resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==}
     engines: {node: '>= 0.6'}
@@ -5496,6 +6958,10 @@ packages:
     resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
     engines: {node: '>= 0.4'}
 
+  get-package-type@0.1.0:
+    resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==}
+    engines: {node: '>=8.0.0'}
+
   get-proto@1.0.1:
     resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
     engines: {node: '>= 0.4'}
@@ -5515,6 +6981,10 @@ packages:
   get-tsconfig@4.10.1:
     resolution: {integrity: sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==}
 
+  getenv@2.0.0:
+    resolution: {integrity: sha512-VilgtJj/ALgGY77fiLam5iD336eSWi96Q15JSAG1zi8NRBysm3LXKdGnHb4m5cuyxvOLQQKWpBZAT6ni4FI2iQ==}
+    engines: {node: '>=6'}
+
   glob-parent@5.1.2:
     resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
     engines: {node: '>= 6'}
@@ -5542,8 +7012,8 @@ packages:
     resolution: {integrity: sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg==}
     engines: {node: '>=18'}
 
-  globals@16.4.0:
-    resolution: {integrity: sha512-ob/2LcVVaVGCYN+r14cnwnoDPUufjiYgSqRhiFD0Q1iI4Odora5RE8Iv1D24hAz5oMophRGkGz+yuvQmmUMnMw==}
+  globals@16.5.0:
+    resolution: {integrity: sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==}
     engines: {node: '>=18'}
 
   globalthis@1.0.4:
@@ -5578,12 +7048,12 @@ packages:
     peerDependencies:
       graphql: '>=0.11 <=16'
 
-  graphql@15.10.1:
-    resolution: {integrity: sha512-BL/Xd/T9baO6NFzoMpiMD7YUZ62R6viR5tp/MULVEnbYJXZA//kRNW7J0j1w/wXArgL0sCxhDfK5dczSKn3+cg==}
-    engines: {node: '>= 10.x'}
+  graphql@16.12.0:
+    resolution: {integrity: sha512-DKKrynuQRne0PNpEbzuEdHlYOMksHSUI8Zc9Unei5gTsMNA2/vMpoMz/yKba50pejK56qj98qM0SjYxAKi13gQ==}
+    engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0}
 
-  h3@2.0.0-beta.4:
-    resolution: {integrity: sha512-/JdwHUGuHjbBXAVxQN7T7QeI9cVlhsqMKVNFHebZVs9RoEYH85Ogh9O1DEy/1ZiJkmMwa1gNg6bBcGhc1Itjdg==}
+  h3@2.0.1-rc.7:
+    resolution: {integrity: sha512-qbrRu1OLXmUYnysWOCVrYhtC/m8ZuXu/zCbo3U/KyphJxbPFiC76jHYwVrmEcss9uNAHO5BoUguQ46yEpgI2PA==}
     engines: {node: '>=20.11.1'}
     peerDependencies:
       crossws: ^0.4.1
@@ -5595,6 +7065,10 @@ packages:
     resolution: {integrity: sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==}
     engines: {node: '>= 0.4'}
 
+  has-flag@3.0.0:
+    resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==}
+    engines: {node: '>=4'}
+
   has-flag@4.0.0:
     resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
     engines: {node: '>=8'}
@@ -5622,6 +7096,22 @@ packages:
     resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==}
     hasBin: true
 
+  hermes-estree@0.25.1:
+    resolution: {integrity: sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==}
+
+  hermes-estree@0.29.1:
+    resolution: {integrity: sha512-jl+x31n4/w+wEqm0I2r4CMimukLbLQEYpisys5oCre611CI5fc9TxhqkBBCJ1edDG4Kza0f7CgNz8xVMLZQOmQ==}
+
+  hermes-parser@0.25.1:
+    resolution: {integrity: sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==}
+
+  hermes-parser@0.29.1:
+    resolution: {integrity: sha512-xBHWmUtRC5e/UL0tI7Ivt2riA/YBq9+SiYFU7C1oBa/j2jYGlIF9043oak1F47ihuDIxQ5nbsKueYJDRY02UgA==}
+
+  hosted-git-info@7.0.2:
+    resolution: {integrity: sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==}
+    engines: {node: ^16.14.0 || >=18.0.0}
+
   hosted-git-info@8.1.0:
     resolution: {integrity: sha512-Rw/B2DNQaPBICNXEm8balFz9a6WpZrkCGpcWFpy7nCj+NyhSdqXipmfvtmWt9xGfp0wZnBxB+iVpLmQMYt47Tw==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -5630,9 +7120,9 @@ packages:
     resolution: {integrity: sha512-gEf705MZLrDPkbbhi8PnoO4ZwYgKoNL+ISZ3AjZMht2r3N5tuTwncyDi6Fv2/qDnMmZxgs0yI8WDOyR8q3G+SQ==}
     engines: {node: ^20.17.0 || >=22.9.0}
 
-  html-encoding-sniffer@4.0.0:
-    resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==}
-    engines: {node: '>=18'}
+  html-encoding-sniffer@6.0.0:
+    resolution: {integrity: sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
 
   html-entities@2.3.3:
     resolution: {integrity: sha512-DV5Ln36z34NNTDgnz0EWGBLZENelNAtkiFA4kyNOG2tDI6Mz1uSWiq1wAKdyjnJwyDiDO7Fa2SO1CTxPXL8VxA==}
@@ -5715,9 +7205,18 @@ packages:
     resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==}
     engines: {node: '>= 4'}
 
+  image-size@1.2.1:
+    resolution: {integrity: sha512-rH+46sQJ2dlwfjfhCyNx5thzrv+dtmBIhPHk0zgRUukHzZ/kRueTJXoYYsclBaKcSMBWuGbOFXtioLpzTb5euw==}
+    engines: {node: '>=16.x'}
+    hasBin: true
+
   immutable@5.1.3:
     resolution: {integrity: sha512-+chQdDfvscSF1SJqv2gn4SRO2ZyS3xL3r7IW/wWEEzrzLisnOlKiQu5ytC/BVNcS15C39WT2Hg/bjKjDMcu+zg==}
 
+  import-fresh@2.0.0:
+    resolution: {integrity: sha512-eZ5H8rcgYazHbKC3PG4ClHNykCSxtAhxSSEM+2mb+7evD2CKF5V7c0dNum7AdpDh0ZdICwZY9sRSn8f+KH96sg==}
+    engines: {node: '>=4'}
+
   import-fresh@3.3.1:
     resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
     engines: {node: '>=6'}
@@ -5741,6 +7240,9 @@ packages:
   inherits@2.0.4:
     resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
 
+  ini@1.3.8:
+    resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
+
   ini@5.0.0:
     resolution: {integrity: sha512-+N0ngpO3e7cRUWOJAS7qw0IZIVc6XPrW4MlFBdD066F2L4k1L6ker3hLqSq7iXxU5tgS4WGkIUElWn5vogAEnw==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -5756,6 +7258,9 @@ packages:
     resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==}
     engines: {node: '>= 0.10'}
 
+  invariant@2.2.4:
+    resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==}
+
   ip-address@10.0.1:
     resolution: {integrity: sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==}
     engines: {node: '>= 12'}
@@ -5772,6 +7277,12 @@ packages:
     resolution: {integrity: sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==}
     engines: {node: '>= 0.4'}
 
+  is-arrayish@0.2.1:
+    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
+
+  is-arrayish@0.3.4:
+    resolution: {integrity: sha512-m6UrgzFVUYawGBh1dUsWR5M2Clqic9RVXC/9f8ceNlv2IcO9j9J/z8UoCLPqtsPBFNzEpfR3xftohbfqDx8EQA==}
+
   is-async-function@2.1.1:
     resolution: {integrity: sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==}
     engines: {node: '>= 0.4'}
@@ -5807,6 +7318,15 @@ packages:
     resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==}
     engines: {node: '>= 0.4'}
 
+  is-directory@0.3.1:
+    resolution: {integrity: sha512-yVChGzahRFvbkscn2MlwGismPO12i9+znNruC5gVEntG3qu0xQMzsGg/JFbrsqDOHtHFPci+V5aP5T9I+yeKqw==}
+    engines: {node: '>=0.10.0'}
+
+  is-docker@2.2.1:
+    resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
+    engines: {node: '>=8'}
+    hasBin: true
+
   is-extglob@2.1.1:
     resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
     engines: {node: '>=0.10.0'}
@@ -5869,6 +7389,10 @@ packages:
     resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==}
     engines: {node: '>=8'}
 
+  is-plain-obj@2.1.0:
+    resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==}
+    engines: {node: '>=8'}
+
   is-potential-custom-element-name@1.0.1:
     resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
 
@@ -5945,10 +7469,18 @@ packages:
     resolution: {integrity: sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==}
     engines: {node: '>=12.13'}
 
+  is-what@5.5.0:
+    resolution: {integrity: sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==}
+    engines: {node: '>=18'}
+
   is-windows@1.0.2:
     resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
     engines: {node: '>=0.10.0'}
 
+  is-wsl@2.2.0:
+    resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==}
+    engines: {node: '>=8'}
+
   isarray@2.0.5:
     resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
 
@@ -6010,22 +7542,57 @@ packages:
   jasmine-core@4.6.1:
     resolution: {integrity: sha512-VYz/BjjmC3klLJlLwA4Kw8ytk0zDSmbbDLNs794VnWmkcCB7I9aAL/D48VNQtmITyPvea2C3jdUMfc3kAoy0PQ==}
 
-  jasmine-core@5.12.0:
-    resolution: {integrity: sha512-QqO4pX33GEML5JoGQU6BM5NHKPgEsg+TXp3jCIDek9MbfEp2JUYEFBo9EF1+hegWy/bCHS1m5nP0BOp18G6rVA==}
+  jasmine-core@5.13.0:
+    resolution: {integrity: sha512-vsYjfh7lyqvZX5QgqKc4YH8phs7g96Z8bsdIFNEU3VqXhlHaq+vov/Fgn/sr6MiUczdZkyXRC3TX369Ll4Nzbw==}
 
-  jiti@1.21.7:
-    resolution: {integrity: sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==}
-    hasBin: true
+  jest-environment-node@29.7.0:
+    resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  jest-get-type@29.6.3:
+    resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  jest-haste-map@29.7.0:
+    resolution: {integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
-  jiti@2.6.0:
-    resolution: {integrity: sha512-VXe6RjJkBPj0ohtqaO8vSWP3ZhAKo66fKrFNCll4BTcwljPLz03pCbaNKfzGP5MbrCYcbJ7v0nOYYwUzTEIdXQ==}
+  jest-message-util@29.7.0:
+    resolution: {integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  jest-mock@29.7.0:
+    resolution: {integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  jest-regex-util@29.6.3:
+    resolution: {integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  jest-util@29.7.0:
+    resolution: {integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  jest-validate@29.7.0:
+    resolution: {integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  jest-worker@29.7.0:
+    resolution: {integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  jimp-compact@0.16.1:
+    resolution: {integrity: sha512-dZ6Ra7u1G8c4Letq/B5EzAxj4tLFHL+cGtdpR+PVm4yzPDj+lCk+AbivWt1eOM+ikzkowtyV7qSqX6qr3t71Ww==}
+
+  jiti@2.6.1:
+    resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
     hasBin: true
 
   jju@1.4.0:
     resolution: {integrity: sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==}
 
-  jose@6.1.0:
-    resolution: {integrity: sha512-TTQJyoEoKcC1lscpVDCSsVgYzUDg/0Bt3WE//WiTPK6uOCQC2KZS4MpugbMWt/zyjkopgZoXhZuCi00gLudfUA==}
+  jose@6.1.2:
+    resolution: {integrity: sha512-MpcPtHLE5EmztuFIqB0vzHAWJPpmN1E6L4oo+kze56LIs3MyXIj9ZHMDxqOvkP38gBR7K1v3jqd4WU2+nrfONQ==}
 
   js-base64@3.7.8:
     resolution: {integrity: sha512-hNngCeKxIUQiEUN3GPJOkz4wF/YvdUdbNL9hsBcMQTkKzboD7T/q3OYOuuPZLUE6dBxSGpwhk5mwuDud7JVAow==}
@@ -6040,13 +7607,16 @@ packages:
     resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==}
     hasBin: true
 
-  js-yaml@4.1.0:
-    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+  js-yaml@4.1.1:
+    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
     hasBin: true
 
-  jsdom@27.0.1:
-    resolution: {integrity: sha512-SNSQteBL1IlV2zqhwwolaG9CwhIhTvVHWg3kTss/cLE7H/X4644mtPQqYvCfsSrGQWt9hSZcgOXX8bOZaMN+kA==}
-    engines: {node: '>=20'}
+  jsc-safe-url@0.2.4:
+    resolution: {integrity: sha512-0wM3YBWtYePOjfyXQH5MWQ8H7sdk5EXSwZvmSLKk2RboVQ2Bu239jycHDz5J/8Blf3K0Qnoy2b6xD+z10MFB+Q==}
+
+  jsdom@27.4.0:
+    resolution: {integrity: sha512-mjzqwWRD9Y1J1KUi7W97Gja1bwOOM5Ug0EZ6UDK3xS7j7mndrkwozHtSblfomlzyB4NepioNt+B2sOSzczVgtQ==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
     peerDependencies:
       canvas: ^3.0.0
     peerDependenciesMeta:
@@ -6061,6 +7631,9 @@ packages:
   json-buffer@3.0.1:
     resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
 
+  json-parse-better-errors@1.0.2:
+    resolution: {integrity: sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==}
+
   json-parse-even-better-errors@4.0.0:
     resolution: {integrity: sha512-lR4MXjGNgkJc7tkQ97kb2nuEMnNCyU//XYVH0MKTGcXEiSudQ5MKGKen3C5QubYy0vmq+JGitUg92uuywGEwIA==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -6138,12 +7711,16 @@ packages:
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
+  kleur@3.0.3:
+    resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==}
+    engines: {node: '>=6'}
+
   kleur@4.1.5:
     resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==}
     engines: {node: '>=6'}
 
-  knip@5.66.1:
-    resolution: {integrity: sha512-Ad3VUPIk9GZYovKuwKtGMheupek7IoPGaDEBAvnCYLKJXnwmqNLyXqMp+l5r3OOpFVjF7DdkFIZFVrXESDNylQ==}
+  knip@5.79.0:
+    resolution: {integrity: sha512-rcg+mNdqm6UiTuRVyy6UuuHw1n4ABMpNXDtrfGaCeUtJoRBAvAENIebr8YMtOz6XE7iVHZ8+rY7skgEtosczhQ==}
     engines: {node: '>=18.18.0'}
     hasBin: true
     peerDependencies:
@@ -6156,76 +7733,157 @@ packages:
   kolorist@1.8.0:
     resolution: {integrity: sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==}
 
-  kysely@0.28.5:
-    resolution: {integrity: sha512-rlB0I/c6FBDWPcQoDtkxi9zIvpmnV5xoIalfCMSMCa7nuA6VGA3F54TW9mEgX4DVf10sXAWCF5fDbamI/5ZpKA==}
+  kysely@0.28.8:
+    resolution: {integrity: sha512-QUOgl5ZrS9IRuhq5FvOKFSsD/3+IA6MLE81/bOOTRA/YQpKDza2sFdN5g6JCB9BOpqMJDGefLCQ9F12hRS13TA==}
     engines: {node: '>=20.0.0'}
 
+  lan-network@0.1.7:
+    resolution: {integrity: sha512-mnIlAEMu4OyEvUNdzco9xpuB9YVcPkQec+QsgycBCtPZvEqWPCDPfbAE4OJMdBBWpZWtpCn1xw9jJYlwjWI5zQ==}
+    hasBin: true
+
+  leven@3.1.0:
+    resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==}
+    engines: {node: '>=6'}
+
   levn@0.4.1:
     resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
     engines: {node: '>= 0.8.0'}
 
-  lightningcss-darwin-arm64@1.30.1:
-    resolution: {integrity: sha512-c8JK7hyE65X1MHMN+Viq9n11RRC7hgin3HhYKhrMyaXflk5GVplZ60IxyoVtzILeKr+xAJwg6zK6sjTBJ0FKYQ==}
+  lighthouse-logger@1.4.2:
+    resolution: {integrity: sha512-gPWxznF6TKmUHrOQjlVo2UbaL2EJ71mb2CCeRs/2qBpi4L/g4LUVc9+3lKQ6DTUZwJswfM7ainGrLO1+fOqa2g==}
+
+  lightningcss-android-arm64@1.30.2:
+    resolution: {integrity: sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [android]
+
+  lightningcss-darwin-arm64@1.27.0:
+    resolution: {integrity: sha512-Gl/lqIXY+d+ySmMbgDf0pgaWSqrWYxVHoc88q+Vhf2YNzZ8DwoRzGt5NZDVqqIW5ScpSnmmjcgXP87Dn2ylSSQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  lightningcss-darwin-arm64@1.30.2:
+    resolution: {integrity: sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [darwin]
 
-  lightningcss-darwin-x64@1.30.1:
-    resolution: {integrity: sha512-k1EvjakfumAQoTfcXUcHQZhSpLlkAuEkdMBsI/ivWw9hL+7FtilQc0Cy3hrx0AAQrVtQAbMI7YjCgYgvn37PzA==}
+  lightningcss-darwin-x64@1.27.0:
+    resolution: {integrity: sha512-0+mZa54IlcNAoQS9E0+niovhyjjQWEMrwW0p2sSdLRhLDc8LMQ/b67z7+B5q4VmjYCMSfnFi3djAAQFIDuj/Tg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  lightningcss-darwin-x64@1.30.2:
+    resolution: {integrity: sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [darwin]
 
-  lightningcss-freebsd-x64@1.30.1:
-    resolution: {integrity: sha512-kmW6UGCGg2PcyUE59K5r0kWfKPAVy4SltVeut+umLCFoJ53RdCUWxcRDzO1eTaxf/7Q2H7LTquFHPL5R+Gjyig==}
+  lightningcss-freebsd-x64@1.27.0:
+    resolution: {integrity: sha512-n1sEf85fePoU2aDN2PzYjoI8gbBqnmLGEhKq7q0DKLj0UTVmOTwDC7PtLcy/zFxzASTSBlVQYJUhwIStQMIpRA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [freebsd]
+
+  lightningcss-freebsd-x64@1.30.2:
+    resolution: {integrity: sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [freebsd]
 
-  lightningcss-linux-arm-gnueabihf@1.30.1:
-    resolution: {integrity: sha512-MjxUShl1v8pit+6D/zSPq9S9dQ2NPFSQwGvxBCYaBYLPlCWuPh9/t1MRS8iUaR8i+a6w7aps+B4N0S1TYP/R+Q==}
+  lightningcss-linux-arm-gnueabihf@1.27.0:
+    resolution: {integrity: sha512-MUMRmtdRkOkd5z3h986HOuNBD1c2lq2BSQA1Jg88d9I7bmPGx08bwGcnB75dvr17CwxjxD6XPi3Qh8ArmKFqCA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm]
+    os: [linux]
+
+  lightningcss-linux-arm-gnueabihf@1.30.2:
+    resolution: {integrity: sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm]
     os: [linux]
 
-  lightningcss-linux-arm64-gnu@1.30.1:
-    resolution: {integrity: sha512-gB72maP8rmrKsnKYy8XUuXi/4OctJiuQjcuqWNlJQ6jZiWqtPvqFziskH3hnajfvKB27ynbVCucKSm2rkQp4Bw==}
+  lightningcss-linux-arm64-gnu@1.27.0:
+    resolution: {integrity: sha512-cPsxo1QEWq2sfKkSq2Bq5feQDHdUEwgtA9KaB27J5AX22+l4l0ptgjMZZtYtUnteBofjee+0oW1wQ1guv04a7A==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  lightningcss-linux-arm64-gnu@1.30.2:
+    resolution: {integrity: sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  lightningcss-linux-arm64-musl@1.27.0:
+    resolution: {integrity: sha512-rCGBm2ax7kQ9pBSeITfCW9XSVF69VX+fm5DIpvDZQl4NnQoMQyRwhZQm9pd59m8leZ1IesRqWk2v/DntMo26lg==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [linux]
 
-  lightningcss-linux-arm64-musl@1.30.1:
-    resolution: {integrity: sha512-jmUQVx4331m6LIX+0wUhBbmMX7TCfjF5FoOH6SD1CttzuYlGNVpA7QnrmLxrsub43ClTINfGSYyHe2HWeLl5CQ==}
+  lightningcss-linux-arm64-musl@1.30.2:
+    resolution: {integrity: sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [linux]
 
-  lightningcss-linux-x64-gnu@1.30.1:
-    resolution: {integrity: sha512-piWx3z4wN8J8z3+O5kO74+yr6ze/dKmPnI7vLqfSqI8bccaTGY5xiSGVIJBDd5K5BHlvVLpUB3S2YCfelyJ1bw==}
+  lightningcss-linux-x64-gnu@1.27.0:
+    resolution: {integrity: sha512-Dk/jovSI7qqhJDiUibvaikNKI2x6kWPN79AQiD/E/KeQWMjdGe9kw51RAgoWFDi0coP4jinaH14Nrt/J8z3U4A==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  lightningcss-linux-x64-gnu@1.30.2:
+    resolution: {integrity: sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  lightningcss-linux-x64-musl@1.27.0:
+    resolution: {integrity: sha512-QKjTxXm8A9s6v9Tg3Fk0gscCQA1t/HMoF7Woy1u68wCk5kS4fR+q3vXa1p3++REW784cRAtkYKrPy6JKibrEZA==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [linux]
 
-  lightningcss-linux-x64-musl@1.30.1:
-    resolution: {integrity: sha512-rRomAK7eIkL+tHY0YPxbc5Dra2gXlI63HL+v1Pdi1a3sC+tJTcFrHX+E86sulgAXeI7rSzDYhPSeHHjqFhqfeQ==}
+  lightningcss-linux-x64-musl@1.30.2:
+    resolution: {integrity: sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [linux]
 
-  lightningcss-win32-arm64-msvc@1.30.1:
-    resolution: {integrity: sha512-mSL4rqPi4iXq5YVqzSsJgMVFENoa4nGTT/GjO2c0Yl9OuQfPsIfncvLrEW6RbbB24WtZ3xP/2CCmI3tNkNV4oA==}
+  lightningcss-win32-arm64-msvc@1.27.0:
+    resolution: {integrity: sha512-/wXegPS1hnhkeG4OXQKEMQeJd48RDC3qdh+OA8pCuOPCyvnm/yEayrJdJVqzBsqpy1aJklRCVxscpFur80o6iQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  lightningcss-win32-arm64-msvc@1.30.2:
+    resolution: {integrity: sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [win32]
 
-  lightningcss-win32-x64-msvc@1.30.1:
-    resolution: {integrity: sha512-PVqXh48wh4T53F/1CCu8PIPCxLzWyCnn/9T5W1Jpmdy5h9Cwd+0YQS6/LwhHXSafuc61/xg9Lv5OrCby6a++jg==}
+  lightningcss-win32-x64-msvc@1.27.0:
+    resolution: {integrity: sha512-/OJLj94Zm/waZShL8nB5jsNj3CfNATLCTyFxZyouilfTmSoLDX7VlVAmhPHoZWVFp4vdmoiEbPEYC8HID3m6yw==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [win32]
+
+  lightningcss-win32-x64-msvc@1.30.2:
+    resolution: {integrity: sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [win32]
 
-  lightningcss@1.30.1:
-    resolution: {integrity: sha512-xi6IyHML+c9+Q3W0S4fCQJOym42pyurFiJUHEcEyHS0CeKzia4yZDEsLlqOFykxOdHpNy0NmvVO31vcSqAxJCg==}
+  lightningcss@1.27.0:
+    resolution: {integrity: sha512-8f7aNmS1+etYSLHht0fQApPc2kNO8qGRutifN5rVIc6Xo6ABsEbqOr758UwI7ALVbTt4x1fllKt0PYgzD9S3yQ==}
+    engines: {node: '>= 12.0.0'}
+
+  lightningcss@1.30.2:
+    resolution: {integrity: sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ==}
     engines: {node: '>= 12.0.0'}
 
   lilconfig@3.1.3:
@@ -6273,6 +7931,9 @@ packages:
   lodash.camelcase@4.3.0:
     resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==}
 
+  lodash.debounce@4.0.8:
+    resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==}
+
   lodash.get@4.4.2:
     resolution: {integrity: sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==}
     deprecated: This package is deprecated. Use the optional chaining (?.) operator instead.
@@ -6287,9 +7948,16 @@ packages:
   lodash.startcase@4.4.0:
     resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==}
 
+  lodash.throttle@4.1.1:
+    resolution: {integrity: sha512-wIkUCfVKpVsWo3JSZlc+8MB5it+2AN5W8J7YVMST30UrvcQNZ1Okbj+rbVniijTWE6FGYy4XJq/rHkas8qJMLQ==}
+
   lodash@4.17.21:
     resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
 
+  log-symbols@2.2.0:
+    resolution: {integrity: sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==}
+    engines: {node: '>=4'}
+
   log-symbols@6.0.0:
     resolution: {integrity: sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw==}
     engines: {node: '>=18'}
@@ -6318,8 +7986,8 @@ packages:
   lru-cache@10.4.3:
     resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
-  lru-cache@11.2.2:
-    resolution: {integrity: sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==}
+  lru-cache@11.2.4:
+    resolution: {integrity: sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==}
     engines: {node: 20 || >=22}
 
   lru-cache@5.1.1:
@@ -6339,8 +8007,8 @@ packages:
   magic-string@0.30.17:
     resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==}
 
-  magic-string@0.30.19:
-    resolution: {integrity: sha512-2N21sPY9Ws53PZvsEpVtNuSW+ScYbQdp4b9qUaL+9QkHUrGFKo56Lg9Emg5s9V/qrtNBmiR01sYhUOwu3H+VOw==}
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
 
   magicast@0.3.5:
     resolution: {integrity: sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==}
@@ -6353,18 +8021,24 @@ packages:
     resolution: {integrity: sha512-QMjGbFTP0blj97EeidG5hk/QhKQ3T4ICckQGLgz38QF7Vgbk6e6FTARN8KhKxyBbWn8R0HU+bnw8aSoFPD4qtQ==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
+  makeerror@1.0.12:
+    resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==}
+
   markdown-it@14.1.0:
     resolution: {integrity: sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==}
     hasBin: true
 
-  markdown-link-extractor@4.0.2:
-    resolution: {integrity: sha512-5cUOu4Vwx1wenJgxaudsJ8xwLUMN7747yDJX3V/L7+gi3e4MsCm7w5nbrDQQy8nEfnl4r5NV3pDXMAjhGXYXAw==}
+  markdown-link-extractor@4.0.3:
+    resolution: {integrity: sha512-aEltJiQ4/oC0h6Jbw/uuATGSHZPkcH8DIunNH1A0e+GSFkvZ6BbBkdvBTVfIV8r6HapCU3yTd0eFdi3ZeM1eAQ==}
 
-  marked@12.0.2:
-    resolution: {integrity: sha512-qXUm7e/YKFoqFPYPa3Ukg9xlI5cyAtGmyEIzMfW//m6kXwCy2Ps9DYf5ioijFKQ8qyuscrHoY04iJGctu2Kg0Q==}
-    engines: {node: '>= 18'}
+  marked@17.0.1:
+    resolution: {integrity: sha512-boeBdiS0ghpWcSwoNm/jJBwdpFaMnZWRzjA6SkUMYb40SVaN1x7mmfGKp0jvexGcx+7y2La5zRZsYFZI6Qpypg==}
+    engines: {node: '>= 20'}
     hasBin: true
 
+  marky@1.3.0:
+    resolution: {integrity: sha512-ocnPZQLNpvbedwTy9kNrQEsknEfgvcLMvOtz3sFeWApDq1MXH1TqkCIx58xlpESsfwQOnuBO9beyQuNGzVvuhQ==}
+
   math-intrinsics@1.1.0:
     resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
     engines: {node: '>= 0.4'}
@@ -6383,6 +8057,9 @@ packages:
     resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==}
     engines: {node: '>= 0.8'}
 
+  memoize-one@5.2.1:
+    resolution: {integrity: sha512-zYiwtZUcYyXKo/np96AGZAckk+FWWsUdJ3cHGGmld7+AhvcWmQyGCYUh1hc4Q/pkOhb65dQR/pqCyK0cOaHz4Q==}
+
   memory-pager@1.5.0:
     resolution: {integrity: sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg==}
 
@@ -6394,13 +8071,14 @@ packages:
     resolution: {integrity: sha512-eRtbOb1N5iyH0tkQDAoQ4Ipsp/5qSR79Dzrz8hEPxRX10RWWR/iQXdoKmBSRCThY1Fh5EhISDtpSc93fpxUniQ==}
     engines: {node: '>=12.13'}
 
-  merge-descriptors@1.0.3:
-    resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==}
-
   merge-descriptors@2.0.0:
     resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==}
     engines: {node: '>=18'}
 
+  merge-options@3.0.4:
+    resolution: {integrity: sha512-2Sug1+knBjkaMsMgf1ctR1Ujx+Ayku4EdJN4Z+C2+JzoeF7A3OZ9KM2GY0CpQS51NR61LTurMJrRKPhSs3ZRTQ==}
+    engines: {node: '>=10'}
+
   merge-stream@2.0.0:
     resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
 
@@ -6408,9 +8086,63 @@ packages:
     resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
     engines: {node: '>= 8'}
 
-  methods@1.1.2:
-    resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}
-    engines: {node: '>= 0.6'}
+  metro-babel-transformer@0.82.5:
+    resolution: {integrity: sha512-W/scFDnwJXSccJYnOFdGiYr9srhbHPdxX9TvvACOFsIXdLilh3XuxQl/wXW6jEJfgIb0jTvoTlwwrqvuwymr6Q==}
+    engines: {node: '>=18.18'}
+
+  metro-cache-key@0.82.5:
+    resolution: {integrity: sha512-qpVmPbDJuRLrT4kcGlUouyqLGssJnbTllVtvIgXfR7ZuzMKf0mGS+8WzcqzNK8+kCyakombQWR0uDd8qhWGJcA==}
+    engines: {node: '>=18.18'}
+
+  metro-cache@0.82.5:
+    resolution: {integrity: sha512-AwHV9607xZpedu1NQcjUkua8v7HfOTKfftl6Vc9OGr/jbpiJX6Gpy8E/V9jo/U9UuVYX2PqSUcVNZmu+LTm71Q==}
+    engines: {node: '>=18.18'}
+
+  metro-config@0.82.5:
+    resolution: {integrity: sha512-/r83VqE55l0WsBf8IhNmc/3z71y2zIPe5kRSuqA5tY/SL/ULzlHUJEMd1szztd0G45JozLwjvrhAzhDPJ/Qo/g==}
+    engines: {node: '>=18.18'}
+
+  metro-core@0.82.5:
+    resolution: {integrity: sha512-OJL18VbSw2RgtBm1f2P3J5kb892LCVJqMvslXxuxjAPex8OH7Eb8RBfgEo7VZSjgb/LOf4jhC4UFk5l5tAOHHA==}
+    engines: {node: '>=18.18'}
+
+  metro-file-map@0.82.5:
+    resolution: {integrity: sha512-vpMDxkGIB+MTN8Af5hvSAanc6zXQipsAUO+XUx3PCQieKUfLwdoa8qaZ1WAQYRpaU+CJ8vhBcxtzzo3d9IsCIQ==}
+    engines: {node: '>=18.18'}
+
+  metro-minify-terser@0.82.5:
+    resolution: {integrity: sha512-v6Nx7A4We6PqPu/ta1oGTqJ4Usz0P7c+3XNeBxW9kp8zayS3lHUKR0sY0wsCHInxZlNAEICx791x+uXytFUuwg==}
+    engines: {node: '>=18.18'}
+
+  metro-resolver@0.82.5:
+    resolution: {integrity: sha512-kFowLnWACt3bEsuVsaRNgwplT8U7kETnaFHaZePlARz4Fg8tZtmRDUmjaD68CGAwc0rwdwNCkWizLYpnyVcs2g==}
+    engines: {node: '>=18.18'}
+
+  metro-runtime@0.82.5:
+    resolution: {integrity: sha512-rQZDoCUf7k4Broyw3Ixxlq5ieIPiR1ULONdpcYpbJQ6yQ5GGEyYjtkztGD+OhHlw81LCR2SUAoPvtTus2WDK5g==}
+    engines: {node: '>=18.18'}
+
+  metro-source-map@0.82.5:
+    resolution: {integrity: sha512-wH+awTOQJVkbhn2SKyaw+0cd+RVSCZ3sHVgyqJFQXIee/yLs3dZqKjjeKKhhVeudgjXo7aE/vSu/zVfcQEcUfw==}
+    engines: {node: '>=18.18'}
+
+  metro-symbolicate@0.82.5:
+    resolution: {integrity: sha512-1u+07gzrvYDJ/oNXuOG1EXSvXZka/0JSW1q2EYBWerVKMOhvv9JzDGyzmuV7hHbF2Hg3T3S2uiM36sLz1qKsiw==}
+    engines: {node: '>=18.18'}
+    hasBin: true
+
+  metro-transform-plugins@0.82.5:
+    resolution: {integrity: sha512-57Bqf3rgq9nPqLrT2d9kf/2WVieTFqsQ6qWHpEng5naIUtc/Iiw9+0bfLLWSAw0GH40iJ4yMjFcFJDtNSYynMA==}
+    engines: {node: '>=18.18'}
+
+  metro-transform-worker@0.82.5:
+    resolution: {integrity: sha512-mx0grhAX7xe+XUQH6qoHHlWedI8fhSpDGsfga7CpkO9Lk9W+aPitNtJWNGrW8PfjKEWbT9Uz9O50dkI8bJqigw==}
+    engines: {node: '>=18.18'}
+
+  metro@0.82.5:
+    resolution: {integrity: sha512-8oAXxL7do8QckID/WZEKaIFuQJFUTLzfVcC48ghkHhNK2RGuQq8Xvf4AVd+TUA0SZtX0q8TGNXZ/eba1ckeGCg==}
+    engines: {node: '>=18.18'}
+    hasBin: true
 
   micromatch@4.0.8:
     resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
@@ -6442,6 +8174,10 @@ packages:
     engines: {node: '>=4.0.0'}
     hasBin: true
 
+  mimic-fn@1.2.0:
+    resolution: {integrity: sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==}
+    engines: {node: '>=4'}
+
   mimic-fn@4.0.0:
     resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==}
     engines: {node: '>=12'}
@@ -6532,8 +8268,8 @@ packages:
   mongodb-connection-string-url@3.0.2:
     resolution: {integrity: sha512-rMO7CGo/9BFwyZABcKAWL8UJwH/Kc2x0g72uhDWzG48URRax5TCIcJ7Rc3RZqffZzO/Gwff/jyKwCU9TN8gehA==}
 
-  mongodb@6.18.0:
-    resolution: {integrity: sha512-fO5ttN9VC8P0F5fqtQmclAkgXZxbIkYRTUi1j8JO6IYwvamkhtYDilJr35jOPELR49zqCJgXZWwCtW7B+TM8vQ==}
+  mongodb@6.21.0:
+    resolution: {integrity: sha512-URyb/VXMjJ4da46OeSXg+puO39XH9DeQpWCslifrRn9JWugy0D+DvvBvkm2WxmHe61O/H19JM66p1z7RHVkZ6A==}
     engines: {node: '>=16.20.1'}
     peerDependencies:
       '@aws-sdk/credential-providers': ^3.188.0
@@ -6541,7 +8277,7 @@ packages:
       gcp-metadata: ^5.2.0
       kerberos: ^2.0.1
       mongodb-client-encryption: '>=6.0.0 <7'
-      snappy: ^7.2.2
+      snappy: ^7.3.2
       socks: ^2.7.1
     peerDependenciesMeta:
       '@aws-sdk/credential-providers':
@@ -6595,8 +8331,8 @@ packages:
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
-  nanostores@1.0.1:
-    resolution: {integrity: sha512-kNZ9xnoJYKg/AfxjrVL4SS0fKX++4awQReGqWnwTRHxeHGZ1FJFVgTqr/eMrNQdp0Tz7M7tG/TDaX8QfHDwVCw==}
+  nanostores@1.1.0:
+    resolution: {integrity: sha512-yJBmDJr18xy47dbNVlHcgdPrulSn1nhSE6Ns9vTG+Nx9VPT6iV1MD6aQFp/t52zpf82FhLLTXAXr30NuCnxvwA==}
     engines: {node: ^20.0.0 || >=22.0.0}
 
   napi-postinstall@0.3.3:
@@ -6615,10 +8351,17 @@ packages:
     resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
     engines: {node: '>= 0.6'}
 
+  negotiator@0.6.4:
+    resolution: {integrity: sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==}
+    engines: {node: '>= 0.6'}
+
   negotiator@1.0.0:
     resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==}
     engines: {node: '>= 0.6'}
 
+  nested-error-stacks@2.0.1:
+    resolution: {integrity: sha512-SrQrok4CATudVzBS7coSz26QRSmlK9TzzoFbeKfcPBUFPjcQM9Rqvr/DlJkOrwI/0KcgvMub1n1g5Jt9EgRn4A==}
+
   nice-try@1.0.5:
     resolution: {integrity: sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==}
 
@@ -6644,6 +8387,10 @@ packages:
       encoding:
         optional: true
 
+  node-forge@1.3.3:
+    resolution: {integrity: sha512-rLvcdSyRCyouf6jcOIPe/BgwG/d7hKjzMKOas33/pHEr6gbq18IK9zV7DiPvzsz0oBJPme6qr6H6kGZuI9/DZg==}
+    engines: {node: '>= 6.13.0'}
+
   node-gyp-build-optional-packages@5.2.2:
     resolution: {integrity: sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw==}
     hasBin: true
@@ -6653,8 +8400,11 @@ packages:
     engines: {node: ^18.17.0 || >=20.5.0}
     hasBin: true
 
-  node-releases@2.0.20:
-    resolution: {integrity: sha512-7gK6zSXEH6neM212JgfYFXe+GmZQM+fia5SsusuBIUgnPheLFBmIPhtFoAQRj8/7wASYQnbDlHPVwY0BefoFgA==}
+  node-int64@0.4.0:
+    resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==}
+
+  node-releases@2.0.27:
+    resolution: {integrity: sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==}
 
   nopt@8.1.0:
     resolution: {integrity: sha512-ieGu42u/Qsa4TFktmaKEwM6MQH0pOWnaB3htzh0JRtx84+Mebc0cbZYN5bC+6WTZ4+77xrL9Pn5m7CV6VIkV7A==}
@@ -6665,10 +8415,6 @@ packages:
     resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
     engines: {node: '>=0.10.0'}
 
-  normalize-range@0.1.2:
-    resolution: {integrity: sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==}
-    engines: {node: '>=0.10.0'}
-
   npm-bundled@4.0.0:
     resolution: {integrity: sha512-IxaQZDMsqfQ2Lz37VvyyEtKLe8FsRZuysmedy/N06TU1RyVppYKXrO4xIhR0F+7ubIBox6Q7nir6fQI3ej39iA==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -6681,6 +8427,10 @@ packages:
     resolution: {integrity: sha512-TZKxPvItzai9kN9H/TkmCtx/ZN/hvr3vUycjlfmH0ootY9yFBzNOpiXAdIn1Iteqsvk4lQn6B5PTrt+n6h8k/w==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
+  npm-package-arg@11.0.3:
+    resolution: {integrity: sha512-sHGJy8sOC1YraBywpzQlIKBE4pBbGbiF95U6Auspzyem956E0+FtDtsx1ZxlOJkQCZ1AFXAY/yuvtFYrOxF+Bw==}
+    engines: {node: ^16.14.0 || >=18.0.0}
+
   npm-package-arg@12.0.2:
     resolution: {integrity: sha512-f1NpFjNI9O4VbKMOlA5QoBq/vSQPORHcTZ2feJpFkTHJ9eQkdlmZEKSjcAhxTGInC7RlEyScT9ui67NaOsjFWA==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -6712,14 +8462,17 @@ packages:
   nth-check@2.1.1:
     resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==}
 
+  nullthrows@1.1.1:
+    resolution: {integrity: sha512-2vPPEi+Z7WqML2jZYddDIfy5Dqb0r2fze2zTxNNknZaFpVHU3mFB3R+DWeJWGVx0ecvttSGlJTI+WG+8Z4cDWw==}
+
+  ob1@0.82.5:
+    resolution: {integrity: sha512-QyQQ6e66f+Ut/qUVjEce0E/wux5nAGLXYZDn1jr15JWstHsCH3l6VVrg8NKDptW9NEiBXKOJeGF/ydxeSDF3IQ==}
+    engines: {node: '>=18.18'}
+
   object-assign@4.1.1:
     resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
     engines: {node: '>=0.10.0'}
 
-  object-hash@3.0.0:
-    resolution: {integrity: sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==}
-    engines: {node: '>= 6'}
-
   object-inspect@1.13.4:
     resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}
     engines: {node: '>= 0.4'}
@@ -6748,6 +8501,10 @@ packages:
     resolution: {integrity: sha512-szyd0ou0T8nsAqHtprRcP3WidfsN1TnAR5yWXf2mFCEr5ek3LEOkT6EZ/92Xfs74HIdyhG5WkGxIssMU0jBaeg==}
     engines: {node: '>=16'}
 
+  oblivious-set@2.0.0:
+    resolution: {integrity: sha512-QOUH5Xrsced9fKXaQTjWoDGKeS/Or7E2jB0FN63N4mkAO4qJdB7WR7e6qWAOHM5nk25FJ8TGjhP7DH4l6vFVLg==}
+    engines: {node: '>=16'}
+
   on-finished@2.3.0:
     resolution: {integrity: sha512-ikqdkGAAyf/X/gPhXGvfgAytDZtDbr+bkNUJ0N9h5MI/dmdgCs3l6hoHrcUv41sRKew3jIwrp4qQDXiK99Utww==}
     engines: {node: '>= 0.8'}
@@ -6756,9 +8513,17 @@ packages:
     resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
     engines: {node: '>= 0.8'}
 
+  on-headers@1.1.0:
+    resolution: {integrity: sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==}
+    engines: {node: '>= 0.8'}
+
   once@1.4.0:
     resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
 
+  onetime@2.0.1:
+    resolution: {integrity: sha512-oyyPpiMaKARvvcgip+JV+7zci5L8D1W9RZIz2l1o08AM3pfspitVWnPt3mzHcBPp12oYMTy0pqrFs/C+m3EwsQ==}
+    engines: {node: '>=4'}
+
   onetime@6.0.0:
     resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==}
     engines: {node: '>=12'}
@@ -6767,10 +8532,22 @@ packages:
     resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==}
     engines: {node: '>=18'}
 
+  open@7.4.2:
+    resolution: {integrity: sha512-MVHddDVweXZF3awtlAS+6pgKLlm/JgxZ90+/NBurBoQctVOOB/zDdVjcyPzQ+0laDGbsWgrRkflI65sQeOgT9Q==}
+    engines: {node: '>=8'}
+
+  open@8.4.2:
+    resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==}
+    engines: {node: '>=12'}
+
   optionator@0.9.4:
     resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
     engines: {node: '>= 0.8.0'}
 
+  ora@3.4.0:
+    resolution: {integrity: sha512-eNwHudNbO1folBP3JsZ19v9azXWtQZjICdr3Q0TDPIaeBQ3mXLrh54wM+er0+hSp+dWKf+Z8KM58CYzEyIYxYg==}
+    engines: {node: '>=6'}
+
   ora@8.2.0:
     resolution: {integrity: sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw==}
     engines: {node: '>=18'}
@@ -6785,8 +8562,12 @@ packages:
     resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
     engines: {node: '>= 0.4'}
 
-  oxc-resolver@11.8.4:
-    resolution: {integrity: sha512-qpimS3tHHEf+kgESMAme+q+rj7aCzMya00u9YdKOKyX2o7q4lozjPo6d7ZTTi979KHEcVOPWdNTueAKdeNq72w==}
+  oxc-resolver@11.16.2:
+    resolution: {integrity: sha512-Uy76u47vwhhF7VAmVY61Srn+ouiOobf45MU9vGct9GD2ARy6hKoqEElyHDB0L+4JOM6VLuZ431KiLwyjI/A21g==}
+
+  p-defer@4.0.1:
+    resolution: {integrity: sha512-Mr5KC5efvAK5VUptYEIopP1bakB85k2IWXaRC0rsh1uwn1L6M0LVml8OIQ4Gudg4oyZakf7FmeRLkMMtZW1i5A==}
+    engines: {node: '>=12'}
 
   p-filter@2.1.0:
     resolution: {integrity: sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==}
@@ -6838,8 +8619,8 @@ packages:
   package-manager-detector@0.2.11:
     resolution: {integrity: sha512-BEnLolu+yuz22S56CU1SUKq3XC3PkwD5wv4ikR4MfGvnRVcmzXR9DwSlW2fEamyTPyXHomBJRzgapeuBvRNzJQ==}
 
-  package-manager-detector@1.3.0:
-    resolution: {integrity: sha512-ZsEbbZORsyHuO00lY1kV3/t72yp6Ysay6Pd17ZAlNGuGwmWDLCJxFpRs0IzfXfj1o4icJOkUEioexFHzyPurSQ==}
+  package-manager-detector@1.6.0:
+    resolution: {integrity: sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==}
 
   pacote@21.0.0:
     resolution: {integrity: sha512-lcqexq73AMv6QNLo7SOpz0JJoaGdS3rBFgF122NZVl1bApo2mfu+XzUBU/X/XsiJu+iUmKpekRayqQYAs+PhkA==}
@@ -6850,6 +8631,14 @@ packages:
     resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
     engines: {node: '>=6'}
 
+  parse-json@4.0.0:
+    resolution: {integrity: sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==}
+    engines: {node: '>=4'}
+
+  parse-png@2.1.0:
+    resolution: {integrity: sha512-Nt/a5SfCLiTnQAjx3fHlqp8hRgTL3z7kTQZzvIMS9uCAepnCyjpdEc6M/sz69WqMBdaDBw9sF1F1UaHROYzGkQ==}
+    engines: {node: '>=10'}
+
   parse5-html-rewriting-stream@8.0.0:
     resolution: {integrity: sha512-wzh11mj8KKkno1pZEu+l2EVeWsuKDfR5KNWZOTsslfUX8lPDZx77m9T0kIoAVkFtD1nx6YF8oh4BnPHvxMtNMw==}
 
@@ -6905,9 +8694,6 @@ packages:
     resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
     engines: {node: '>=16 || 14 >=14.18'}
 
-  path-to-regexp@0.1.12:
-    resolution: {integrity: sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==}
-
   path-to-regexp@8.3.0:
     resolution: {integrity: sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==}
 
@@ -6963,6 +8749,10 @@ packages:
     resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
     engines: {node: '>=8.6'}
 
+  picomatch@3.0.1:
+    resolution: {integrity: sha512-I3EurrIQMlRc9IaAZnqRR044Phh2DXY+55o7uJ0V+hYZAcQYSuFWsc9q5PvyDHUSCe1Qxn/iBz+78s86zWnGag==}
+    engines: {node: '>=10'}
+
   picomatch@4.0.3:
     resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
     engines: {node: '>=12'}
@@ -6972,10 +8762,6 @@ packages:
     engines: {node: '>=0.10'}
     hasBin: true
 
-  pify@2.3.0:
-    resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
-    engines: {node: '>=0.10.0'}
-
   pify@4.0.1:
     resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
     engines: {node: '>=6'}
@@ -6995,49 +8781,24 @@ packages:
   pkg-types@1.3.1:
     resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==}
 
+  plist@3.1.0:
+    resolution: {integrity: sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ==}
+    engines: {node: '>=10.4.0'}
+
+  pngjs@3.4.0:
+    resolution: {integrity: sha512-NCrCHhWmnQklfH4MtJMRjZ2a8c80qXeMlQMv2uVp9ISJMTt562SbGd6n2oq0PaPgKm7Z6pL9E2UlLIhC+SHL3w==}
+    engines: {node: '>=4.0.0'}
+
   possible-typed-array-names@1.1.0:
     resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==}
     engines: {node: '>= 0.4'}
 
-  postcss-import@15.1.0:
-    resolution: {integrity: sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      postcss: ^8.0.0
-
-  postcss-js@4.0.1:
-    resolution: {integrity: sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==}
-    engines: {node: ^12 || ^14 || >= 16}
-    peerDependencies:
-      postcss: ^8.4.21
-
-  postcss-load-config@4.0.2:
-    resolution: {integrity: sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==}
-    engines: {node: '>= 14'}
-    peerDependencies:
-      postcss: '>=8.0.9'
-      ts-node: '>=9.0.0'
-    peerDependenciesMeta:
-      postcss:
-        optional: true
-      ts-node:
-        optional: true
-
   postcss-media-query-parser@0.2.3:
     resolution: {integrity: sha512-3sOlxmbKcSHMjlUXQZKQ06jOswE7oVkXPxmZdoB1r5l0q6gTFTQSHxNxOrCccElbW7dxNytifNEo8qidX2Vsig==}
 
-  postcss-nested@6.2.0:
-    resolution: {integrity: sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==}
-    engines: {node: '>=12.0'}
-    peerDependencies:
-      postcss: ^8.2.14
-
-  postcss-selector-parser@6.1.2:
-    resolution: {integrity: sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==}
-    engines: {node: '>=4'}
-
-  postcss-value-parser@4.2.0:
-    resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
+  postcss@8.4.49:
+    resolution: {integrity: sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==}
+    engines: {node: ^10 || ^12 || >=14}
 
   postcss@8.5.6:
     resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
@@ -7076,23 +8837,46 @@ packages:
     engines: {node: '>=10.13.0'}
     hasBin: true
 
-  prettier@3.6.2:
-    resolution: {integrity: sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==}
+  prettier@3.7.4:
+    resolution: {integrity: sha512-v6UNi1+3hSlVvv8fSaoUbggEM5VErKmmpGA7Pl3HF8V6uKY7rvClBOJlH6yNwQtfTueNkGVpOv/mtWL9L4bgRA==}
     engines: {node: '>=14'}
     hasBin: true
 
+  pretty-bytes@5.6.0:
+    resolution: {integrity: sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==}
+    engines: {node: '>=6'}
+
   pretty-format@27.5.1:
     resolution: {integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==}
     engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0}
 
+  pretty-format@29.7.0:
+    resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+
+  proc-log@4.2.0:
+    resolution: {integrity: sha512-g8+OnU/L2v+wyiVK+D5fA34J7EH8jZ8DDlvwhRCMxmMj7UCBvxiO1mGeN+36JXIKF4zevU4kRBd8lVgG9vLelA==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
+
   proc-log@5.0.0:
     resolution: {integrity: sha512-Azwzvl90HaF0aCz1JrDdXQykFakSSNPaPoiZ9fm5qJIMHioDZEi7OAdRwSm6rSoPtY3Qutnm3L7ogmg3dc+wbQ==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
+  progress@2.0.3:
+    resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
+    engines: {node: '>=0.4.0'}
+
   promise-retry@2.0.1:
     resolution: {integrity: sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==}
     engines: {node: '>=10'}
 
+  promise@8.3.0:
+    resolution: {integrity: sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==}
+
+  prompts@2.4.2:
+    resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==}
+    engines: {node: '>= 6'}
+
   prop-types@15.8.1:
     resolution: {integrity: sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==}
 
@@ -7104,8 +8888,8 @@ packages:
     resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
     engines: {node: '>= 0.10'}
 
-  publint@0.3.14:
-    resolution: {integrity: sha512-14/VNBvWsrBeqWNDw8c/DK5ERcZBUwL1rnkVx18cQnF3zadr3GfoYtvD8mxi1dhkWpaPHp8kfi92MDbjMeW3qw==}
+  publint@0.3.16:
+    resolution: {integrity: sha512-MFqyfRLAExPVZdTQFwkAQELzA8idyXzROVOytg6nEJ/GEypXBUmMGrVaID8cTuzRS1U5L8yTOdOJtMXgFUJAeA==}
     engines: {node: '>=18'}
     hasBin: true
 
@@ -7123,17 +8907,24 @@ packages:
     resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
     engines: {node: '>=6'}
 
+  pure-rand@6.1.0:
+    resolution: {integrity: sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==}
+
   pvtsutils@1.3.6:
     resolution: {integrity: sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==}
 
-  pvutils@1.1.3:
-    resolution: {integrity: sha512-pMpnA0qRdFp32b1sJl1wOJNxZLQ2cbQx+k6tjNtZ8CpvVhNqEPRgivZ2WOUev2YMajecdH7ctUPDvEe87nariQ==}
-    engines: {node: '>=6.0.0'}
+  pvutils@1.1.5:
+    resolution: {integrity: sha512-KTqnxsgGiQ6ZAzZCVlJH5eOjSnvlyEgx1m8bkRJfOhmGRqfo5KLvmAlACQkrjEtOQ4B7wF9TdSLIs9O90MX9xA==}
+    engines: {node: '>=16.0.0'}
 
   qjobs@1.2.0:
     resolution: {integrity: sha512-8YOJEHtxpySA3fFDyCRxA+UUV+fA+rTWnuWvylOK/NCjhY+b4ocCtmu8TtsWb+mYeU+GCHf/S66KZF/AsteKHg==}
     engines: {node: '>=0.9'}
 
+  qrcode-terminal@0.11.0:
+    resolution: {integrity: sha512-Uu7ii+FQy4Qf82G4xu7ShHhjhGahEpCWc3x8UavY3CTcWV+ufmmCtwkr7ZKsX42jdL0kr1B5FKUeqJvAn51jzQ==}
+    hasBin: true
+
   qs@6.13.0:
     resolution: {integrity: sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==}
     engines: {node: '>=0.6'}
@@ -7145,9 +8936,16 @@ packages:
   quansync@0.2.11:
     resolution: {integrity: sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==}
 
+  query-string@7.1.3:
+    resolution: {integrity: sha512-hh2WYhq4fi8+b+/2Kg9CEge4fDPvHS534aOOvOZeQ3+Vf2mCFsaFBYj0i+iXcAq6I9Vzp5fjMFBlONvayDC1qg==}
+    engines: {node: '>=6'}
+
   queue-microtask@1.2.3:
     resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
 
+  queue@6.0.2:
+    resolution: {integrity: sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==}
+
   randombytes@2.1.0:
     resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==}
 
@@ -7163,10 +8961,26 @@ packages:
     resolution: {integrity: sha512-9G8cA+tuMS75+6G/TzW8OtLzmBDMo8p1JRxN5AZ+LAp8uxGA8V8GZm4GQ4/N5QNQEnLmg6SS7wyuSmbKepiKqA==}
     engines: {node: '>= 0.10'}
 
-  react-dom@19.2.0:
-    resolution: {integrity: sha512-UlbRu4cAiGaIewkPyiRGJk0imDN2T3JjieT6spoL2UeSf5od4n5LB/mQ4ejmxhCFT1tYe8IvaFulzynWovsEFQ==}
+  rc@1.2.8:
+    resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}
+    hasBin: true
+
+  react-devtools-core@6.1.5:
+    resolution: {integrity: sha512-ePrwPfxAnB+7hgnEr8vpKxL9cmnp7F322t8oqcPshbIQQhDKgFDW4tjhF2wjVbdXF9O/nyuy3sQWd9JGpiLPvA==}
+
+  react-dom@19.2.3:
+    resolution: {integrity: sha512-yELu4WmLPw5Mr/lmeEpox5rw3RETacE++JgHqQzd2dg+YbJuat3jH4ingc+WPZhxaoFzdv9y33G+F7Nl5O0GBg==}
+    peerDependencies:
+      react: ^19.2.3
+
+  react-fast-compare@3.2.2:
+    resolution: {integrity: sha512-nsO+KSNgo1SbJqJEYRE9ERzo7YtYbou/OqjSQKxV7jcKox7+usiUVZOAC+XnDOABXggQTno0Y1CpVnuWEc1boQ==}
+
+  react-freeze@1.0.4:
+    resolution: {integrity: sha512-r4F0Sec0BLxWicc7HEyo2x3/2icUTrRmDjaaRyzzn+7aDyFZliszMDOgLVwSnQnYENOlL1o569Ze2HZefk8clA==}
+    engines: {node: '>=10'}
     peerDependencies:
-      react: ^19.2.0
+      react: '>=17.0.0'
 
   react-is@16.13.1:
     resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==}
@@ -7174,16 +8988,58 @@ packages:
   react-is@17.0.2:
     resolution: {integrity: sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==}
 
-  react-refresh@0.17.0:
-    resolution: {integrity: sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==}
+  react-is@18.3.1:
+    resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}
+
+  react-is@19.2.3:
+    resolution: {integrity: sha512-qJNJfu81ByyabuG7hPFEbXqNcWSU3+eVus+KJs+0ncpGfMyYdvSmxiJxbWR65lYi1I+/0HBcliO029gc4F+PnA==}
+
+  react-native-edge-to-edge@1.6.0:
+    resolution: {integrity: sha512-2WCNdE3Qd6Fwg9+4BpbATUxCLcouF6YRY7K+J36KJ4l3y+tWN6XCqAC4DuoGblAAbb2sLkhEDp4FOlbOIot2Og==}
+    peerDependencies:
+      react: '*'
+      react-native: '*'
+
+  react-native-is-edge-to-edge@1.2.1:
+    resolution: {integrity: sha512-FLbPWl/MyYQWz+KwqOZsSyj2JmLKglHatd3xLZWskXOpRaio4LfEDEz8E/A6uD8QoTHW6Aobw1jbEwK7KMgR7Q==}
+    peerDependencies:
+      react: '*'
+      react-native: '*'
+
+  react-native-safe-area-context@5.4.0:
+    resolution: {integrity: sha512-JaEThVyJcLhA+vU0NU8bZ0a1ih6GiF4faZ+ArZLqpYbL6j7R3caRqj+mE3lEtKCuHgwjLg3bCxLL1GPUJZVqUA==}
+    peerDependencies:
+      react: '*'
+      react-native: '*'
+
+  react-native-screens@4.11.1:
+    resolution: {integrity: sha512-F0zOzRVa3ptZfLpD0J8ROdo+y1fEPw+VBFq1MTY/iyDu08al7qFUO5hLMd+EYMda5VXGaTFCa8q7bOppUszhJw==}
+    peerDependencies:
+      react: '*'
+      react-native: '*'
+
+  react-native@0.79.6:
+    resolution: {integrity: sha512-kvIWSmf4QPfY41HC25TR285N7Fv0Pyn3DAEK8qRL9dA35usSaxsJkHfw+VqnonqJjXOaoKCEanwudRAJ60TBGA==}
+    engines: {node: '>=18'}
+    hasBin: true
+    peerDependencies:
+      '@types/react': ^19.0.0
+      react: ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  react-refresh@0.14.2:
+    resolution: {integrity: sha512-jCvmsr+1IUSMUyzOkRcvnVbX3ZYC6g9TDrDbFuFmRDq7PD4yaGbLKNQL6k2jnArV8hjYxh7hVhAZB6s9HDGpZA==}
     engines: {node: '>=0.10.0'}
 
-  react@19.2.0:
-    resolution: {integrity: sha512-tmbWg6W31tQLeB5cdIBOicJDJRR2KzXsV7uSK9iNfLWQ5bIZfxuPEHp7M8wiHyHnn0DD1i7w3Zmin0FtkrwoCQ==}
+  react-refresh@0.18.0:
+    resolution: {integrity: sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==}
     engines: {node: '>=0.10.0'}
 
-  read-cache@1.0.0:
-    resolution: {integrity: sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==}
+  react@19.2.3:
+    resolution: {integrity: sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==}
+    engines: {node: '>=0.10.0'}
 
   read-yaml-file@1.1.0:
     resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==}
@@ -7201,6 +9057,10 @@ packages:
     resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
     engines: {node: '>= 14.18.0'}
 
+  readdirp@5.0.0:
+    resolution: {integrity: sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ==}
+    engines: {node: '>= 20.19.0'}
+
   recast@0.23.11:
     resolution: {integrity: sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==}
     engines: {node: '>= 4'}
@@ -7223,13 +9083,31 @@ packages:
     resolution: {integrity: sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==}
     engines: {node: '>= 0.4'}
 
-  regenerator-runtime@0.14.1:
-    resolution: {integrity: sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==}
+  regenerate-unicode-properties@10.2.2:
+    resolution: {integrity: sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==}
+    engines: {node: '>=4'}
+
+  regenerate@1.4.2:
+    resolution: {integrity: sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==}
+
+  regenerator-runtime@0.13.11:
+    resolution: {integrity: sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==}
 
   regexp.prototype.flags@1.5.4:
     resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==}
     engines: {node: '>= 0.4'}
 
+  regexpu-core@6.4.0:
+    resolution: {integrity: sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==}
+    engines: {node: '>=4'}
+
+  regjsgen@0.8.0:
+    resolution: {integrity: sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==}
+
+  regjsparser@0.13.0:
+    resolution: {integrity: sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==}
+    hasBin: true
+
   require-directory@2.1.1:
     resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
     engines: {node: '>=0.10.0'}
@@ -7238,9 +9116,17 @@ packages:
     resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
     engines: {node: '>=0.10.0'}
 
+  requireg@0.2.2:
+    resolution: {integrity: sha512-nYzyjnFcPNGR3lx9lwPPPnuQxv6JWEZd2Ci0u9opN7N5zUEPIhY/GbL3vMGOr2UXwEg9WwSyV9X9Y/kLFgPsOg==}
+    engines: {node: '>= 4.0.0'}
+
   requires-port@1.0.0:
     resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==}
 
+  resolve-from@3.0.0:
+    resolution: {integrity: sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw==}
+    engines: {node: '>=4'}
+
   resolve-from@4.0.0:
     resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
     engines: {node: '>=4'}
@@ -7252,15 +9138,29 @@ packages:
   resolve-pkg-maps@1.0.0:
     resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
 
+  resolve-workspace-root@2.0.1:
+    resolution: {integrity: sha512-nR23LHAvaI6aHtMg6RWoaHpdR4D881Nydkzi2CixINyg9T00KgaJdJI6Vwty+Ps8WLxZHuxsS0BseWjxSA4C+w==}
+
+  resolve.exports@2.0.3:
+    resolution: {integrity: sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==}
+    engines: {node: '>=10'}
+
   resolve@1.22.10:
     resolution: {integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==}
     engines: {node: '>= 0.4'}
     hasBin: true
 
+  resolve@1.7.1:
+    resolution: {integrity: sha512-c7rwLofp8g1U+h1KNyHL/jicrKg1Ek4q+Lr33AL65uZTinUZHe30D5HlyN5V9NW0JX1D5dXQ4jqW5l7Sy/kGfw==}
+
   resolve@2.0.0-next.5:
     resolution: {integrity: sha512-U7WjGVG9sH8tvjW5SmGbQuui75FiyjAX72HX15DwBBwF9dNiQZRQAg9nnPhYy+TUnE0+VcrttuvNI8oSxZcocA==}
     hasBin: true
 
+  restore-cursor@2.0.0:
+    resolution: {integrity: sha512-6IzJLuGi4+R14vwagDHX+JrXmPVtPpn4mffDJ1UdR7/Edm87fl6yi8mMBIVvFtJaNTUvjughmW4hwLhRG7gC1Q==}
+    engines: {node: '>=4'}
+
   restore-cursor@5.1.0:
     resolution: {integrity: sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==}
     engines: {node: '>=18'}
@@ -7299,21 +9199,18 @@ packages:
   rou3@0.5.1:
     resolution: {integrity: sha512-OXMmJ3zRk2xeXFGfA3K+EOPHC5u7RDFG7lIOx0X1pdnhUkI8MdVrbV+sNsD80ElpUZ+MRHdyxPnFthq9VHs8uQ==}
 
-  rou3@0.7.8:
-    resolution: {integrity: sha512-21X/el5fdOaEsqwl3an/d9kpZ8hshVIyrwFCpsoleJ4ccAGRbN+PVoxyXzWXkHDxfMkVnLe4yzx+imz2qoem2Q==}
+  rou3@0.7.12:
+    resolution: {integrity: sha512-iFE4hLDuloSWcD7mjdCDhx2bKcIsYbtOTpfH5MHHLSKMOUyjqQXTeZVa289uuwEGEKFoE/BAPbhaU4B774nceg==}
 
   router@2.2.0:
     resolution: {integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==}
     engines: {node: '>= 18'}
 
-  rrweb-cssom@0.8.0:
-    resolution: {integrity: sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==}
-
   run-parallel@1.2.0:
     resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
 
-  rxdb@16.19.1:
-    resolution: {integrity: sha512-q+1GSgnNthoUY/mbOv9dlCc7008/QJiBfPbjaKtWxbBCR4nPVU7qf8dPatvvSImrezpMAFjSs/uvISQZxfmkhA==}
+  rxdb@16.21.1:
+    resolution: {integrity: sha512-4yFfP9qw6QFFPueR9Dlwi/WYZ4u79AZ8ltLsDCB1PXhAuEj0vRPbaUiKR/U2iXdGb+1tDqj9d4hhrdtSLvR5xA==}
     engines: {node: '>=18'}
     peerDependencies:
       rxjs: ^7.8.0
@@ -7348,10 +9245,17 @@ packages:
     engines: {node: '>=14.0.0'}
     hasBin: true
 
+  sax@1.4.4:
+    resolution: {integrity: sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw==}
+    engines: {node: '>=11.0.0'}
+
   saxes@6.0.0:
     resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==}
     engines: {node: '>=v12.22.7'}
 
+  scheduler@0.25.0:
+    resolution: {integrity: sha512-xFVuu11jh+xcO7JOAGJNOXld8/TcEHK/4CituBUeUb5hqxJLj9YuemAEuvm9gQ/+pgXYfbQuqAkiYu+u7YEsNA==}
+
   scheduler@0.27.0:
     resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==}
 
@@ -7368,6 +9272,11 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
+  semver@7.6.3:
+    resolution: {integrity: sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==}
+    engines: {node: '>=10'}
+    hasBin: true
+
   semver@7.7.2:
     resolution: {integrity: sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==}
     engines: {node: '>=10'}
@@ -7386,16 +9295,30 @@ packages:
     resolution: {integrity: sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==}
     engines: {node: '>= 18'}
 
+  serialize-error@2.1.0:
+    resolution: {integrity: sha512-ghgmKt5o4Tly5yEG/UJp8qTd0AN7Xalw4XBtDEKP655B699qMEtra1WlXeE6WIvdEG481JvRxULKsInq/iNysw==}
+    engines: {node: '>=0.10.0'}
+
   seroval-plugins@1.3.3:
     resolution: {integrity: sha512-16OL3NnUBw8JG1jBLUoZJsLnQq0n5Ua6aHalhJK4fMQkz1lqR7Osz1sA30trBtd9VUDc2NgkuRCn8+/pBwqZ+w==}
     engines: {node: '>=10'}
     peerDependencies:
       seroval: ^1.0
 
+  seroval-plugins@1.4.0:
+    resolution: {integrity: sha512-zir1aWzoiax6pbBVjoYVd0O1QQXgIL3eVGBMsBsNmM8Ukq90yGaWlfx0AB9dTS8GPqrOrbXn79vmItCUP9U3BQ==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      seroval: ^1.0
+
   seroval@1.3.2:
     resolution: {integrity: sha512-RbcPH1n5cfwKrru7v7+zrZvjLurgHhGyso3HTyGtRivGWgYjbOmGuivCQaORNELjNONoK35nj28EoWul9sb1zQ==}
     engines: {node: '>=10'}
 
+  seroval@1.4.2:
+    resolution: {integrity: sha512-N3HEHRCZYn3cQbsC4B5ldj9j+tHdf4JZoYPlcI4rRYu0Xy4qN8MQf1Z08EibzB0WpgRG5BGK08FTrmM66eSzKQ==}
+    engines: {node: '>=10'}
+
   serve-static@1.16.2:
     resolution: {integrity: sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==}
     engines: {node: '>= 0.8.0'}
@@ -7404,8 +9327,11 @@ packages:
     resolution: {integrity: sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==}
     engines: {node: '>= 18'}
 
-  set-cookie-parser@2.7.1:
-    resolution: {integrity: sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ==}
+  server-only@0.0.1:
+    resolution: {integrity: sha512-qepMx2JxAa5jjfzxG79yPPq+8BuFToHd1hm7kI+Z4zAq1ftQiP7HcxMhDDItrbtwVeLg/cY2JnKnrcFkmiswNA==}
+
+  set-cookie-parser@2.7.2:
+    resolution: {integrity: sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==}
 
   set-function-length@1.2.2:
     resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
@@ -7422,6 +9348,13 @@ packages:
   setprototypeof@1.2.0:
     resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
 
+  sf-symbols-typescript@2.2.0:
+    resolution: {integrity: sha512-TPbeg0b7ylrswdGCji8FRGFAKuqbpQlLbL8SOle3j1iHSs5Ob5mhvMAxWN2UItOjgALAB5Zp3fmMfj8mbWvXKw==}
+    engines: {node: '>=10'}
+
+  shallowequal@1.1.0:
+    resolution: {integrity: sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==}
+
   shebang-command@1.2.0:
     resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==}
     engines: {node: '>=0.10.0'}
@@ -7447,38 +9380,48 @@ packages:
     engines: {node: '>=18'}
     hasBin: true
 
-  sherif-darwin-arm64@1.6.1:
-    resolution: {integrity: sha512-J15oBJcrnCAZ0rQE8WbMShYw3204A18akCH6C/uZrILTwX/vZyJIqi7lAt5L00LzsadA3HcyQqVjLNNCvuihoQ==}
+  sherif-darwin-arm64@1.9.0:
+    resolution: {integrity: sha512-R+RpKSzlqZgBHean04CqHrdlmBBKu6Dhd/9BcdCpjx/KpqsalZsh9LzBVxTWLTtT9IBb/ccr23PNqFzWQTuh6A==}
     cpu: [arm64]
     os: [darwin]
 
-  sherif-darwin-x64@1.6.1:
-    resolution: {integrity: sha512-oLA/GtvUasi+qCl35LczOhQ4g/xY2mxE5/eiTYQGT3Ow7FKLscnkE6v5l28bgkFeR/uke0AgZ/CgHhozAf0ulg==}
+  sherif-darwin-x64@1.9.0:
+    resolution: {integrity: sha512-b/KX9MczzkzmyEjngGxYuBq/rOdM6CbGcDLFdQ0H990Dmn9foj4C/UpLlyqSxXcsJhy586ATMEVN68aM2hFQdQ==}
     cpu: [x64]
     os: [darwin]
 
-  sherif-linux-arm64@1.6.1:
-    resolution: {integrity: sha512-OoltlucT7v9BZdkYZRbs1QU0DYMCQ5qgpMqQdMW1Rq3w3amr7+oEiV9NHntD83udOo8xRxKq0uPXfNYu+VptJw==}
+  sherif-linux-arm64-musl@1.9.0:
+    resolution: {integrity: sha512-OZ4cKcCXTJTl8zaTxKnP8z0wu05nDeGtttxRQjaXHSKK+fjBwGkH/1qqFEVDcRANUxtLRLLdwmDyxvqQrCzhPQ==}
+    cpu: [arm64]
+    os: [linux]
+
+  sherif-linux-arm64@1.9.0:
+    resolution: {integrity: sha512-TyuGhaD/efCxGIk4scx09n6NsTr3qfKvH5qHYdyxtelv1mHRgbzVHwJ+Jj98jVktuzOZoexHpxr/hz7RUjd/nw==}
     cpu: [arm64]
     os: [linux]
 
-  sherif-linux-x64@1.6.1:
-    resolution: {integrity: sha512-qyDyYqpi3ABGkRuCnjnxN3OMT8DxMiiLzhS9p9xC05Y9nr5hjkxvqP4DdJ4e5opm4E7vzRAS7VQoZ6m7h6tsgQ==}
+  sherif-linux-x64-musl@1.9.0:
+    resolution: {integrity: sha512-JSbA6DN0HkWSabYU858BUkS4cMmkTsAamDZEYuUVDW+XvW9IjaI6o0HNatUr7oCjrITIfcjzqlqy7uizmNlr/A==}
     cpu: [x64]
     os: [linux]
 
-  sherif-windows-arm64@1.6.1:
-    resolution: {integrity: sha512-wAbCiqP//lo7bZUlHmZUV3/sGjnJxo6QB5/fqhz5/GUeWh4CTyvlSacJKZxLnXnzpiUSeFnWutquWnHkRov5Ug==}
+  sherif-linux-x64@1.9.0:
+    resolution: {integrity: sha512-iO+hTxndO36r0hgmipBRjntWFqFHKrrYFRODz0WnmDquVek88LInSzAY1xpS18/Thbff8IVc6ssefYNVFQQPWw==}
+    cpu: [x64]
+    os: [linux]
+
+  sherif-windows-arm64@1.9.0:
+    resolution: {integrity: sha512-lPqQXDB/95SJodtIbGAJc90O/KyxcunvKTycZqo+6RGjkOSYZB/XnRzm/tJ7If/6kz0/wcDP4uvkJmJxrxcj3A==}
     cpu: [arm64]
     os: [win32]
 
-  sherif-windows-x64@1.6.1:
-    resolution: {integrity: sha512-2r0qMxZGCMO2aq8Hlq7npxtAsUFVDsEFtUM/6dFo1npa/jHe2mbU7ii/Ymy0bloSa/qw/azrSfRV6GLU7Gjtxg==}
+  sherif-windows-x64@1.9.0:
+    resolution: {integrity: sha512-3cL+XVGLpmyLC3UOZYiPr4vY2OFBQqPZnCoCwoRKN+ONm8VfGMirO9iqI0OckgFBUtJoG4AQY/MWxoPhNmzD8A==}
     cpu: [x64]
     os: [win32]
 
-  sherif@1.6.1:
-    resolution: {integrity: sha512-ZnwyTnmXoUOPClkOA37JWIyFxCoozMGHmhk/p7XbTREI554XXCnBAn3BMX8UsqkhSzQ9eNQsq4U+jnImEIppsQ==}
+  sherif@1.9.0:
+    resolution: {integrity: sha512-5n7zqPAjL+RzR7n09NPKpWBXmDCtuRpQzIL+ycj8pe6MayV7cDuFmceoyPQJ0c95oFj6feY7SZvhX/+S0i1ukg==}
     hasBin: true
 
   shx@0.4.0:
@@ -7516,12 +9459,25 @@ packages:
     resolution: {integrity: sha512-ZpzWAFHIFqyFE56dXqgX/DkDRZdz+rRcjoIk/RQU4IX0wiCv1l8S7ZrXDHcCc+uaf+6o7w3h2l3g6GYG5TKN9Q==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
-  simple-git@3.28.0:
-    resolution: {integrity: sha512-Rs/vQRwsn1ILH1oBUy8NucJlXmnnLeLCfcvbSehkPzbv3wwoFWIdtfd6Ndo6ZPhlPsCZ60CPI4rxurnwAa+a2w==}
+  simple-git@3.30.0:
+    resolution: {integrity: sha512-q6lxyDsCmEal/MEGhP1aVyQ3oxnagGlBDOVSIB4XUVLl1iZh0Pah6ebC9V4xBap/RfgP2WlI8EKs0WS0rMEJHg==}
 
   simple-peer@9.11.1:
     resolution: {integrity: sha512-D1SaWpOW8afq1CZGWB8xTfrT3FekjQmPValrqncJMX7QFl8YwhrPTZvMCANLtgBwwdS+7zURyqxDDEmY558tTw==}
 
+  simple-plist@1.3.1:
+    resolution: {integrity: sha512-iMSw5i0XseMnrhtIzRb7XpQEXepa9xhWxGUojHBL43SIpQuDQkh3Wpy67ZbDzZVr6EKxvwVChnVpdl8hEVLDiw==}
+
+  simple-swizzle@0.2.4:
+    resolution: {integrity: sha512-nAu1WFPQSMNr2Zn9PGSZK9AGn4t/y97lEm+MXTtUDwfP0ksAIX4nO+6ruD9Jwut4C49SB1Ws+fbXsm/yScWOHw==}
+
+  sirv@3.0.2:
+    resolution: {integrity: sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==}
+    engines: {node: '>=18'}
+
+  sisteransi@1.0.5:
+    resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
+
   slash@3.0.0:
     resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
     engines: {node: '>=8'}
@@ -7534,12 +9490,16 @@ packages:
     resolution: {integrity: sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==}
     engines: {node: '>=18'}
 
+  slugify@1.6.6:
+    resolution: {integrity: sha512-h+z7HKHYXj6wJU+AnS/+IH8Uh9fdcX1Lrhg1/VMdf9PwoBQXFcXiAdsy2tSK0P6gKwJLXp02r90ahUCqHk9rrw==}
+    engines: {node: '>=8.0.0'}
+
   smart-buffer@4.2.0:
     resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
     engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
 
-  smol-toml@1.4.2:
-    resolution: {integrity: sha512-rInDH6lCNiEyn3+hH8KVGFdbjc099j47+OSgbMrfDYX1CmXLfdKd7qi6IfcWj2wFxvSVkuI46M+wPGYfEOEj6g==}
+  smol-toml@1.5.2:
+    resolution: {integrity: sha512-QlaZEqcAH3/RtNyet1IPIYPsEWAaYyXXv1Krsi+1L/QHppjX4Ifm8MQsBISz9vE8cHicIq3clogsheili5vhaQ==}
     engines: {node: '>= 18'}
 
   socket.io-adapter@2.5.5:
@@ -7561,8 +9521,8 @@ packages:
     resolution: {integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==}
     engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
 
-  solid-js@1.9.9:
-    resolution: {integrity: sha512-A0ZBPJQldAeGCTW0YRYJmt7RCeh5rbFfPZ2aOttgYnctHE7HgKeHCBB/PVc2P7eOfmNXqMFFFoYYdm3S4dcbkA==}
+  solid-js@1.9.10:
+    resolution: {integrity: sha512-Coz956cos/EPDlhs6+jsdTxKuJDPT7B5SVIWgABwROyxjY7Xbr8wkzD68Et+NxnV7DLJ3nJdAC2r9InuV/4Jew==}
 
   solid-refresh@0.6.3:
     resolution: {integrity: sha512-F3aPsX6hVw9ttm5LYlth8Q15x6MlI/J3Dn+o3EQyRTtTxidepSTwAYdozt01/YA+7ObcciagGEyXIopGZzQtbA==}
@@ -7579,6 +9539,10 @@ packages:
   source-map-support@0.5.21:
     resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
 
+  source-map@0.5.7:
+    resolution: {integrity: sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==}
+    engines: {node: '>=0.10.0'}
+
   source-map@0.6.1:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
@@ -7605,6 +9569,10 @@ packages:
   spdx-license-ids@3.0.22:
     resolution: {integrity: sha512-4PRT4nh1EImPbt2jASOKHX7PB7I+e4IWNLvkKFDxNhJlfjbYlleYQh285Z/3mPTHSAK/AvdMmw5BNNuYH8ShgQ==}
 
+  split-on-first@1.1.0:
+    resolution: {integrity: sha512-43ZssAJaMusuKWL8sKUBQXHWOpq8d6CfN/u1p4gUzfJkM05C8rxTmYrkIPTXapZpORA6LkkzcUulJ8FqA7Uudw==}
+    engines: {node: '>=6'}
+
   split2@4.2.0:
     resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==}
     engines: {node: '>= 10.x'}
@@ -7612,8 +9580,8 @@ packages:
   sprintf-js@1.0.3:
     resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
 
-  srvx@0.8.16:
-    resolution: {integrity: sha512-hmcGW4CgroeSmzgF1Ihwgl+Ths0JqAJ7HwjP2X7e3JzY7u4IydLMcdnlqGQiQGUswz+PO9oh/KtCpOISIvs9QQ==}
+  srvx@0.10.1:
+    resolution: {integrity: sha512-A//xtfak4eESMWWydSRFUVvCTQbSwivnGCEf8YGPe2eHU0+Z6znfUTCPF0a7oV3sObSOcrXHlL6Bs9vVctfXdg==}
     engines: {node: '>=20.16.0'}
     hasBin: true
 
@@ -7625,9 +9593,20 @@ packages:
     resolution: {integrity: sha512-o3yWv49B/o4QZk5ZcsALc6t0+eCelPc44zZsLtCQnZPDwFpDYSWcDnrv2TtMmMbQ7uKo3J0HTURCqckw23czNQ==}
     engines: {node: '>=12.0.0'}
 
+  stack-utils@2.0.6:
+    resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==}
+    engines: {node: '>=10'}
+
   stackback@0.0.2:
     resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
 
+  stackframe@1.3.4:
+    resolution: {integrity: sha512-oeVtt7eWQS+Na6F//S4kJ2K2VbRlS9D43mAlMyVpVWovy9o+jfgH8O9agzANzaiLjclA0oYzUXEM4PurhSUChw==}
+
+  stacktrace-parser@0.1.11:
+    resolution: {integrity: sha512-WjlahMgHmCJpqzU8bIBy4qtsZdU9lRlcZE3Lvyej6t4tuOuv1vk57OW3MBrj6hXBFx/nNoC9MPMTcr5YA7NQbg==}
+    engines: {node: '>=6'}
+
   statuses@1.5.0:
     resolution: {integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==}
     engines: {node: '>= 0.6'}
@@ -7651,10 +9630,18 @@ packages:
     resolution: {integrity: sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==}
     engines: {node: '>= 0.4'}
 
+  stream-buffers@2.2.0:
+    resolution: {integrity: sha512-uyQK/mx5QjHun80FLJTfaWE7JtwfRMKBLkMne6udYOmvH0CawotVa7TfgYHzAnpphn4+TweIx1QKMnRIbipmUg==}
+    engines: {node: '>= 0.10.0'}
+
   streamroller@3.1.5:
     resolution: {integrity: sha512-KFxaM7XT+irxvdqSP1LGLgNWbYN7ay5owZ3r/8t77p+EtSUAfUgtl7be3xtqtOmGUl9K9YPO2ca8133RlTjvKw==}
     engines: {node: '>=8.0'}
 
+  strict-uri-encode@2.0.0:
+    resolution: {integrity: sha512-QwiXZgpRcKkhTj2Scnn++4PKtWsH0kpzZ62L2R6c/LUVYv7hVnZqcg2+sMuT6R7Jusu1vviK/MFsu6kNJfWlEQ==}
+    engines: {node: '>=4'}
+
   string-argv@0.3.2:
     resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==}
     engines: {node: '>=0.6.19'}
@@ -7693,6 +9680,10 @@ packages:
   string_decoder@1.3.0:
     resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
 
+  strip-ansi@5.2.0:
+    resolution: {integrity: sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==}
+    engines: {node: '>=6'}
+
   strip-ansi@6.0.1:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
     engines: {node: '>=8'}
@@ -7717,17 +9708,24 @@ packages:
     resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==}
     engines: {node: '>=8'}
 
+  strip-json-comments@2.0.1:
+    resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}
+    engines: {node: '>=0.10.0'}
+
   strip-json-comments@3.1.1:
     resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
     engines: {node: '>=8'}
 
-  strip-json-comments@5.0.2:
-    resolution: {integrity: sha512-4X2FR3UwhNUE9G49aIsJW5hRRR3GXGTBTZRMfv568O60ojM8HcWjV/VxAxCDW3SUND33O6ZY66ZuRcdkj73q2g==}
+  strip-json-comments@5.0.3:
+    resolution: {integrity: sha512-1tB5mhVo7U+ETBKNf92xT4hrQa3pm0MZ0PQvuDnWgAAGHDsfp4lPSpiS6psrSiet87wyGPh9ft6wmhOMQ0hDiw==}
     engines: {node: '>=14.16'}
 
   strip-literal@3.0.0:
     resolution: {integrity: sha512-TcccoMhJOM3OebGhSBEmp3UZ2SfDMZUEBdRA/9ynfLi8yYajyWX3JiXArcJt4Umh4vISpspkQIY8ZZoCqjbviA==}
 
+  structured-headers@0.4.1:
+    resolution: {integrity: sha512-0MP/Cxx5SzeeZ10p/bZI0S6MpgD+yxAhi1BOQ34jgnMXsCq3j1t6tQnZu+KdlL7dvJTLT3g9xN8tl10TqgFMcg==}
+
   style-to-object@1.0.9:
     resolution: {integrity: sha512-G4qppLgKu/k6FwRpHiGiKPaPTFcG3g4wNVX/Qsfu+RqQM30E7Tyu/TEgxcL9PNLF5pdRLwQdE3YKKf+KF2Dzlw==}
 
@@ -7736,6 +9734,14 @@ packages:
     engines: {node: '>=16 || 14 >=14.17'}
     hasBin: true
 
+  superjson@2.2.6:
+    resolution: {integrity: sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==}
+    engines: {node: '>=16'}
+
+  supports-color@5.5.0:
+    resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
+    engines: {node: '>=4'}
+
   supports-color@7.2.0:
     resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
     engines: {node: '>=8'}
@@ -7744,12 +9750,16 @@ packages:
     resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==}
     engines: {node: '>=10'}
 
+  supports-hyperlinks@2.3.0:
+    resolution: {integrity: sha512-RpsAZlpWcDwOPQA22aCH4J0t7L8JmAvsCxfOSEwm7cQs3LshN36QaTkwd70DnBOXDWGssw2eUoc8CaRWT0XunA==}
+    engines: {node: '>=8'}
+
   supports-preserve-symlinks-flag@1.0.0:
     resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
     engines: {node: '>= 0.4'}
 
-  svelte-check@4.3.3:
-    resolution: {integrity: sha512-RYP0bEwenDXzfv0P1sKAwjZSlaRyqBn0Fz1TVni58lqyEiqgwztTpmodJrGzP6ZT2aHl4MbTvWP6gbmQ3FOnBg==}
+  svelte-check@4.3.5:
+    resolution: {integrity: sha512-e4VWZETyXaKGhpkxOXP+B/d0Fp/zKViZoJmneZWe/05Y2aqSKj3YN2nLfYPJBQ87WEiY4BQCQ9hWGu9mPT1a1Q==}
     engines: {node: '>= 18.0.0'}
     hasBin: true
     peerDependencies:
@@ -7762,8 +9772,8 @@ packages:
       svelte: ^3.55 || ^4.0.0-next.0 || ^4.0 || ^5.0.0-next.0
       typescript: ^4.9.4 || ^5.0.0
 
-  svelte@5.41.0:
-    resolution: {integrity: sha512-mP3vFFv5OUM5JN189+nJVW74kQ1dGqUrXTEzvCEVZqessY0GxZDls1nWVvt4Sxyv2USfQvAZO68VRaeIZvpzKg==}
+  svelte@5.46.4:
+    resolution: {integrity: sha512-VJwdXrmv9L8L7ZasJeWcCjoIuMRVbhuxbss0fpVnR8yorMmjNDwcjIH08vS6wmSzzzgAG5CADQ1JuXPS2nwt9w==}
     engines: {node: '>=18'}
 
   symbol-tree@3.2.4:
@@ -7773,13 +9783,11 @@ packages:
     resolution: {integrity: sha512-MeQTA1r0litLUf0Rp/iisCaL8761lKAZHaimlbGK4j0HysC4PLfqygQj9srcs0m2RdtDYnF8UuYyKpbjHYp7Jw==}
     engines: {node: ^14.18.0 || >=16.0.0}
 
-  tailwindcss@3.4.18:
-    resolution: {integrity: sha512-6A2rnmW5xZMdw11LYjhcI5846rt9pbLSabY5XPxo+XWdxwZaFEn47Go4NzFiHu9sNNmr/kXivP1vStfvMaK1GQ==}
-    engines: {node: '>=14.0.0'}
-    hasBin: true
+  tailwind-merge@2.6.0:
+    resolution: {integrity: sha512-P+Vu1qXfzediirmHOC3xKGAYeZtPcV9g76X+xg2FD4tYgR71ewMA35Y3sCz3zhiN/dwefRpJX0yBcgwi1fXNQA==}
 
-  tailwindcss@4.1.14:
-    resolution: {integrity: sha512-b7pCxjGO98LnxVkKjaZSDeNuljC4ueKUddjENJOADtubtdo8llTaJy7HwBMeLNSSo2N5QIAgklslK1+Ir8r6CA==}
+  tailwindcss@4.1.18:
+    resolution: {integrity: sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==}
 
   tapable@2.2.3:
     resolution: {integrity: sha512-ZL6DDuAlRlLGghwcfmSn9sK3Hr6ArtyudlSAiCqQ6IfE+b+HHbydbYDIG15IfS5do+7XQQBdBiubF/cV2dnDzg==}
@@ -7788,10 +9796,16 @@ packages:
   tar@6.2.1:
     resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
     engines: {node: '>=10'}
+    deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exhorbitant rates) by contacting i@izs.me
 
   tar@7.5.1:
     resolution: {integrity: sha512-nlGpxf+hv0v7GkWBK2V9spgactGOp0qvfWRxUMjqHyzrt3SgwE48DIv/FhqPHJYLHpgW1opq3nERbz5Anq7n1g==}
     engines: {node: '>=18'}
+    deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exhorbitant rates) by contacting i@izs.me
+
+  temp-dir@2.0.0:
+    resolution: {integrity: sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==}
+    engines: {node: '>=8'}
 
   temporal-polyfill@0.3.0:
     resolution: {integrity: sha512-qNsTkX9K8hi+FHDfHmf22e/OGuXmfBm9RqNismxBrnSmZVJKegQ+HYYXT+R7Ha8F/YSm2Y34vmzD4cxMu2u95g==}
@@ -7803,11 +9817,19 @@ packages:
     resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==}
     engines: {node: '>=8'}
 
+  terminal-link@2.1.1:
+    resolution: {integrity: sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ==}
+    engines: {node: '>=8'}
+
   terser@5.44.0:
     resolution: {integrity: sha512-nIVck8DK+GM/0Frwd+nIhZ84pR/BX7rmXMfYwyg+Sri5oGVE99/E3KvXqpC2xHFxyqXyGHTKBSioxxplrO4I4w==}
     engines: {node: '>=10'}
     hasBin: true
 
+  test-exclude@6.0.0:
+    resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==}
+    engines: {node: '>=8'}
+
   test-exclude@7.0.1:
     resolution: {integrity: sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==}
     engines: {node: '>=18'}
@@ -7823,6 +9845,9 @@ packages:
   thenify@3.3.1:
     resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==}
 
+  throat@5.0.0:
+    resolution: {integrity: sha512-fcwX4mndzpLQKBS1DVYhGAcYaYt7vsHNIvQV+WXMvnow5cgjPphq5CaayLaGsjRdSCKZFNGt7/GYAuXaNOiYCA==}
+
   through@2.3.8:
     resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
 
@@ -7869,6 +9894,9 @@ packages:
     resolution: {integrity: sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==}
     engines: {node: '>=14.14'}
 
+  tmpl@1.0.5:
+    resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==}
+
   to-regex-range@5.0.1:
     resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
     engines: {node: '>=8.0'}
@@ -7877,6 +9905,10 @@ packages:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
     engines: {node: '>=0.6'}
 
+  totalist@3.0.1:
+    resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
+    engines: {node: '>=6'}
+
   tough-cookie@6.0.0:
     resolution: {integrity: sha512-kXuRi1mtaKMrsLUxz3sQYvVl37B0Ns6MzfrtV5DvJceE9bPyspOqk9xxv7XbZWcfLWbFmm997vl83qUWVJA64w==}
     engines: {node: '>=16'}
@@ -7899,8 +9931,8 @@ packages:
     resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
     hasBin: true
 
-  ts-api-utils@2.1.0:
-    resolution: {integrity: sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==}
+  ts-api-utils@2.3.0:
+    resolution: {integrity: sha512-6eg3Y9SF7SsAvGzRHQvvc1skDAhwI4YQ32ui1scxD1Ccr0G5qIIbUBT3pFTKX8kmWIQClHobtUdNuaBgwdfdWg==}
     engines: {node: '>=18.12'}
     peerDependencies:
       typescript: '>=4.8.4'
@@ -7923,14 +9955,21 @@ packages:
       typescript:
         optional: true
 
+  tslib@1.14.1:
+    resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
+
   tslib@2.8.1:
     resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
-  tsx@4.20.6:
-    resolution: {integrity: sha512-ytQKuwgmrrkDTFP4LjR0ToE2nqgy886GpvRSpU0JAnrdBYppuY5rLkRUYPU1yCryb24SsKBTL/hlDQAEFVwtZg==}
+  tsx@4.21.0:
+    resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
     engines: {node: '>=18.0.0'}
     hasBin: true
 
+  tsyringe@4.10.0:
+    resolution: {integrity: sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==}
+    engines: {node: '>= 6.0.0'}
+
   tuf-js@3.1.0:
     resolution: {integrity: sha512-3T3T04WzowbwV2FDiGXBbr81t64g1MUGGJRgT4x5o97N+8ArdhVCAF9IxFrxuSJmM3E5Asn7nKHkao0ibcZXAg==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -7942,10 +9981,18 @@ packages:
     resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
     engines: {node: '>= 0.8.0'}
 
+  type-detect@4.0.8:
+    resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==}
+    engines: {node: '>=4'}
+
   type-fest@0.21.3:
     resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
     engines: {node: '>=10'}
 
+  type-fest@0.7.1:
+    resolution: {integrity: sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==}
+    engines: {node: '>=8'}
+
   type-is@1.6.18:
     resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}
     engines: {node: '>= 0.6'}
@@ -7988,8 +10035,8 @@ packages:
     peerDependencies:
       typescript: 5.0.x || 5.1.x || 5.2.x || 5.3.x || 5.4.x || 5.5.x || 5.6.x || 5.7.x || 5.8.x || 5.9.x
 
-  typescript-eslint@8.44.1:
-    resolution: {integrity: sha512-0ws8uWGrUVTjEeN2OM4K1pLKHK/4NiNP/vz6ns+LjT/6sqpaYzIVFajZb1fj/IDwpsrrHb3Jy0Qm5u9CPcKaeg==}
+  typescript-eslint@8.47.0:
+    resolution: {integrity: sha512-Lwe8i2XQ3WoMjua/r1PHrCTpkubPYJCAfOurtn+mtTzqB6jNd+14n9UN1bJ4s3F49x9ixAm0FLflB/JzQ57M8Q==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0
@@ -8000,11 +10047,6 @@ packages:
     engines: {node: '>=14.17'}
     hasBin: true
 
-  typescript@5.8.3:
-    resolution: {integrity: sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==}
-    engines: {node: '>=14.17'}
-    hasBin: true
-
   typescript@5.9.3:
     resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
     engines: {node: '>=14.17'}
@@ -8027,16 +10069,33 @@ packages:
   uncrypto@0.1.3:
     resolution: {integrity: sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==}
 
-  undici-types@6.21.0:
-    resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
-
   undici-types@7.14.0:
     resolution: {integrity: sha512-QQiYxHuyZ9gQUIrmPo3IA+hUl4KYk8uSA7cHrcKd/l3p1OTpZcM0Tbp9x7FAtXdAYhlasd60ncPpgu6ihG6TOA==}
 
+  undici@6.23.0:
+    resolution: {integrity: sha512-VfQPToRA5FZs/qJxLIinmU59u0r7LXqoJkCzinq3ckNJp3vKEh7jTWN589YQ5+aoAC/TGRLyJLCPKcLQbM8r9g==}
+    engines: {node: '>=18.17'}
+
   undici@7.16.0:
     resolution: {integrity: sha512-QEg3HPMll0o3t2ourKwOeUAZ159Kn9mx5pnzHRQO8+Wixmh88YdZRiIwat0iNzNNXn0yoEtXJqFpyW7eM8BV7g==}
     engines: {node: '>=20.18.1'}
 
+  unicode-canonical-property-names-ecmascript@2.0.1:
+    resolution: {integrity: sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==}
+    engines: {node: '>=4'}
+
+  unicode-match-property-ecmascript@2.0.0:
+    resolution: {integrity: sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==}
+    engines: {node: '>=4'}
+
+  unicode-match-property-value-ecmascript@2.2.1:
+    resolution: {integrity: sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==}
+    engines: {node: '>=4'}
+
+  unicode-property-aliases-ecmascript@2.2.0:
+    resolution: {integrity: sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==}
+    engines: {node: '>=4'}
+
   unique-filename@4.0.0:
     resolution: {integrity: sha512-XSnEewXmQ+veP7xX2dS5Q4yZAvO40cBN2MWkJ7D/6sW4Dg6wYBNwM1Vrnz1FhH5AdeLIlUXRI9e28z1YZi71NQ==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -8045,6 +10104,10 @@ packages:
     resolution: {integrity: sha512-9OdaqO5kwqR+1kVgHAhsp5vPNU0hnxRa26rBFNfNgM7M6pNtgzeBn3s/xbyCQL3dcjzOatcef6UUHpB/6MaETg==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
+  unique-string@2.0.0:
+    resolution: {integrity: sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==}
+    engines: {node: '>=8'}
+
   universalify@0.1.2:
     resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
     engines: {node: '>= 4.0.0'}
@@ -8067,8 +10130,8 @@ packages:
   unrs-resolver@1.11.1:
     resolution: {integrity: sha512-bSjt9pjaEBnNiGgc9rUiHGKv5l4/TGzDmYw3RhnkJGtLhbnnA/5qJj7x3dNDCRx/PJxu774LlH8lCOlB4hEfKg==}
 
-  update-browserslist-db@1.1.3:
-    resolution: {integrity: sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==}
+  update-browserslist-db@1.1.4:
+    resolution: {integrity: sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A==}
     hasBin: true
     peerDependencies:
       browserslist: '>= 4.21.0'
@@ -8076,6 +10139,11 @@ packages:
   uri-js@4.4.1:
     resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
 
+  use-latest-callback@0.2.6:
+    resolution: {integrity: sha512-FvRG9i1HSo0wagmX63Vrm8SnlUU3LMM3WyZkQ76RnslpBrX694AdG4A0zQBx2B3ZifFA0yv/BaEHGBnEax5rZg==}
+    peerDependencies:
+      react: '>=16.8'
+
   use-sync-external-store@1.6.0:
     resolution: {integrity: sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==}
     peerDependencies:
@@ -8095,12 +10163,20 @@ packages:
     resolution: {integrity: sha512-XQegIaBTVUjSHliKqcnFqYypAd4S+WCYt5NIeRs6w/UAry7z8Y9j5ZwRRL4kzq9U3sD6v+85er9FvkEaBpji2w==}
     hasBin: true
 
+  uuid@7.0.3:
+    resolution: {integrity: sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg==}
+    hasBin: true
+
   validate-html-nesting@1.2.3:
     resolution: {integrity: sha512-kdkWdCl6eCeLlRShJKbjVOU2kFKxMF8Ghu50n+crEoyx+VKm3FxAxF9z4DCy6+bbTOqNW0+jcIYRnjoIRzigRw==}
 
   validate-npm-package-license@3.0.4:
     resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
 
+  validate-npm-package-name@5.0.1:
+    resolution: {integrity: sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
+
   validate-npm-package-name@6.0.2:
     resolution: {integrity: sha512-IUoow1YUtvoBBC06dXs8bR8B9vuA3aJfmQNKMoaPG/OFsPmoQvw8xh+6Ye25Gx9DQhoEom3Pcu9MKHerm/NpUQ==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -8117,78 +10193,38 @@ packages:
     resolution: {integrity: sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==}
     engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
     hasBin: true
-
-  vite-plugin-dts@4.2.3:
-    resolution: {integrity: sha512-O5NalzHANQRwVw1xj8KQun3Bv8OSDAlNJXrnqoAz10BOuW8FVvY5g4ygj+DlJZL5mtSPuMu9vd3OfrdW5d4k6w==}
-    engines: {node: ^14.18.0 || >=16.0.0}
-    peerDependencies:
-      typescript: '*'
-      vite: '*'
-    peerDependenciesMeta:
-      vite:
-        optional: true
-
-  vite-plugin-externalize-deps@0.10.0:
-    resolution: {integrity: sha512-eQrtpT/Do7AvDn76l1yL6ZHyXJ+UWH2LaHVqhAes9go54qaAnPZuMbgxcroQ/7WY3ZyetZzYW2quQnDF0DV5qg==}
-    peerDependencies:
-      vite: ^2.0.0 || ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
-
-  vite-plugin-solid@2.11.9:
-    resolution: {integrity: sha512-bTA6p+bspXZsuulSd2y6aTzegF8xGaJYcq1Uyh/mv+W4DQtzCgL9nN6n2fsTaxp/dMk+ZHHKgGndlNeooqHLKw==}
-    peerDependencies:
-      '@testing-library/jest-dom': ^5.16.6 || ^5.17.0 || ^6.*
-      solid-js: ^1.7.2
-      vite: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
-    peerDependenciesMeta:
-      '@testing-library/jest-dom':
-        optional: true
-
-  vite-tsconfig-paths@5.1.4:
-    resolution: {integrity: sha512-cYj0LRuLV2c2sMqhqhGpaO3LretdtMn/BVX4cPLanIZuwwrkVl+lK84E/miEXkCHWXuq65rhNN4rXsBcOB3S4w==}
-    peerDependencies:
-      vite: '*'
-    peerDependenciesMeta:
-      vite:
-        optional: true
-
-  vite@6.4.1:
-    resolution: {integrity: sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==}
-    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
-    hasBin: true
-    peerDependencies:
-      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
-      jiti: '>=1.21.0'
-      less: '*'
-      lightningcss: ^1.21.0
-      sass: '*'
-      sass-embedded: '*'
-      stylus: '*'
-      sugarss: '*'
-      terser: ^5.16.0
-      tsx: ^4.8.1
-      yaml: ^2.4.2
-    peerDependenciesMeta:
-      '@types/node':
-        optional: true
-      jiti:
-        optional: true
-      less:
-        optional: true
-      lightningcss:
-        optional: true
-      sass:
-        optional: true
-      sass-embedded:
-        optional: true
-      stylus:
-        optional: true
-      sugarss:
-        optional: true
-      terser:
+
+  vite-plugin-dts@4.2.3:
+    resolution: {integrity: sha512-O5NalzHANQRwVw1xj8KQun3Bv8OSDAlNJXrnqoAz10BOuW8FVvY5g4ygj+DlJZL5mtSPuMu9vd3OfrdW5d4k6w==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      typescript: '*'
+      vite: '*'
+    peerDependenciesMeta:
+      vite:
         optional: true
-      tsx:
+
+  vite-plugin-externalize-deps@0.10.0:
+    resolution: {integrity: sha512-eQrtpT/Do7AvDn76l1yL6ZHyXJ+UWH2LaHVqhAes9go54qaAnPZuMbgxcroQ/7WY3ZyetZzYW2quQnDF0DV5qg==}
+    peerDependencies:
+      vite: ^2.0.0 || ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
+
+  vite-plugin-solid@2.11.10:
+    resolution: {integrity: sha512-Yr1dQybmtDtDAHkii6hXuc1oVH9CPcS/Zb2jN/P36qqcrkNnVPsMTzQ06jyzFPFjj3U1IYKMVt/9ZqcwGCEbjw==}
+    peerDependencies:
+      '@testing-library/jest-dom': ^5.16.6 || ^5.17.0 || ^6.*
+      solid-js: ^1.7.2
+      vite: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
+    peerDependenciesMeta:
+      '@testing-library/jest-dom':
         optional: true
-      yaml:
+
+  vite-tsconfig-paths@5.1.4:
+    resolution: {integrity: sha512-cYj0LRuLV2c2sMqhqhGpaO3LretdtMn/BVX4cPLanIZuwwrkVl+lK84E/miEXkCHWXuq65rhNN4rXsBcOB3S4w==}
+    peerDependencies:
+      vite: '*'
+    peerDependenciesMeta:
+      vite:
         optional: true
 
   vite@7.1.11:
@@ -8231,8 +10267,8 @@ packages:
       yaml:
         optional: true
 
-  vite@7.1.5:
-    resolution: {integrity: sha512-4cKBO9wR75r0BeIWWWId9XK9Lj6La5X846Zw9dFfzMRw38IlTk2iCcUt6hsyiDRcPidc55ZParFYDXi0nXOeLQ==}
+  vite@7.3.1:
+    resolution: {integrity: sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
     peerDependencies:
@@ -8307,6 +10343,9 @@ packages:
       jsdom:
         optional: true
 
+  vlq@1.0.1:
+    resolution: {integrity: sha512-gQpnTgkubC6hQgdIcRdYGDSDc+SaujOdyesZQMv6JlfQee/9Mp0Qhnys6WxDWvQnL5WZdT7o2Ul187aSt0Rq+w==}
+
   void-elements@2.0.1:
     resolution: {integrity: sha512-qZKX4RnBzH2ugr8Lxa7x+0V6XD9Sb/ouARtiasEQCHB1EVU4NXtmHsDDrx1dO4ne5fc3J6EW05BP1Dl0z0iung==}
     engines: {node: '>=0.10.0'}
@@ -8320,8 +10359,8 @@ packages:
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0
 
-  vue@3.5.22:
-    resolution: {integrity: sha512-toaZjQ3a/G/mYaLSbV+QsQhIdMo9x5rrqIpYRObsJ6T/J+RyCSFwN2LHNVH9v8uIcljDNa3QzPVdv3Y6b9hAJQ==}
+  vue@3.5.26:
+    resolution: {integrity: sha512-SJ/NTccVyAoNUJmkM9KUqPcYlY+u8OVL1X5EW9RIs3ch5H2uERxyyIUI4MRxVCSOiEcupX9xNGde1tL9ZKpimA==}
     peerDependencies:
       typescript: '*'
     peerDependenciesMeta:
@@ -8336,10 +10375,19 @@ packages:
     resolution: {integrity: sha512-3hu+tD8YzSLGuFYtPRb48vdhKMi0KQV5sn+uWr8+7dMEq/2G/dtLrdDinkLjqq5TIbIBjYJ4Ax/n3YiaW7QM8A==}
     engines: {node: 20 || >=22}
 
+  walker@1.0.8:
+    resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==}
+
+  warn-once@0.1.1:
+    resolution: {integrity: sha512-VkQZJbO8zVImzYFteBXvBOZEl1qL175WH8VmZcxF2fZAoudNhNDvHi+doCaAEdU2l2vtcIwa2zn0QK5+I1HQ3Q==}
+
   watchpack@2.4.4:
     resolution: {integrity: sha512-c5EGNOiyxxV5qmTtAB7rbiXxi1ooX1pQKMLX/MIabJjRA0SJBQOjKF+KSVfHkr9U1cADPon0mRiVe/riyaiDUA==}
     engines: {node: '>=10.13.0'}
 
+  wcwidth@1.0.1:
+    resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==}
+
   weak-lru-cache@1.2.2:
     resolution: {integrity: sha512-DEAoo25RfSYMuTGc9vPJzZcZullwIqRDSI9LOy+fkCJPi6hykCnfKaXTuPBDuXAUcqHXyOgFtHNp/kB2FjYHbw==}
 
@@ -8352,6 +10400,10 @@ packages:
   webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
+  webidl-conversions@5.0.0:
+    resolution: {integrity: sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA==}
+    engines: {node: '>=8'}
+
   webidl-conversions@7.0.0:
     resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
     engines: {node: '>=12'}
@@ -8374,11 +10426,19 @@ packages:
   whatwg-encoding@3.1.1:
     resolution: {integrity: sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==}
     engines: {node: '>=18'}
+    deprecated: Use @exodus/bytes instead for a more spec-conformant and faster implementation
+
+  whatwg-fetch@3.6.20:
+    resolution: {integrity: sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg==}
 
   whatwg-mimetype@4.0.0:
     resolution: {integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==}
     engines: {node: '>=18'}
 
+  whatwg-url-without-unicode@8.0.0-3:
+    resolution: {integrity: sha512-HoKuzZrUlgpz35YO27XgD28uh/WJH4B0+3ttFqRo//lmq+9T/mIOJ6kqmINI9HpUpz1imRC/nR/lxKpJiv0uig==}
+    engines: {node: '>=10'}
+
   whatwg-url@14.2.0:
     resolution: {integrity: sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==}
     engines: {node: '>=18'}
@@ -8430,6 +10490,9 @@ packages:
     engines: {node: '>=8'}
     hasBin: true
 
+  wonka@6.3.5:
+    resolution: {integrity: sha512-SSil+ecw6B4/Dm7Pf2sAshKQ5hWFvfyGlfPbEd6A14dOH6VDjrmbY86u6nZvy9omGwwIPFR8V41+of1EezgoUw==}
+
   word-wrap@1.2.5:
     resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
     engines: {node: '>=0.10.0'}
@@ -8453,6 +10516,33 @@ packages:
   wrappy@1.0.2:
     resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
 
+  write-file-atomic@4.0.2:
+    resolution: {integrity: sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==}
+    engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
+
+  ws@6.2.3:
+    resolution: {integrity: sha512-jmTjYU0j60B+vHey6TfR3Z7RD61z/hmxBS3VMSGIrroOWXQEneK1zNuotOUrGyBHQj0yrpsLHPWtigEFd13ndA==}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: ^5.0.2
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  ws@7.5.10:
+    resolution: {integrity: sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==}
+    engines: {node: '>=8.3.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: ^5.0.2
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
   ws@8.17.1:
     resolution: {integrity: sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==}
     engines: {node: '>=10.0.0'}
@@ -8477,13 +10567,29 @@ packages:
       utf-8-validate:
         optional: true
 
+  xcode@3.0.1:
+    resolution: {integrity: sha512-kCz5k7J7XbJtjABOvkc5lJmkiDh8VhjVCGNiqdKCscmVpdVUpEAyXv1xmCLkQJ5dsHqx3IPO4XW+NTDhU/fatA==}
+    engines: {node: '>=10.0.0'}
+
   xml-name-validator@5.0.0:
     resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==}
     engines: {node: '>=18'}
 
-  xmlbuilder2@3.1.1:
-    resolution: {integrity: sha512-WCSfbfZnQDdLQLiMdGUQpMxxckeQ4oZNMNhLVkcekTu7xhD4tuUDyAPoY8CwXvBYE6LwBHd6QW2WZXlOWr1vCw==}
-    engines: {node: '>=12.0'}
+  xml2js@0.6.0:
+    resolution: {integrity: sha512-eLTh0kA8uHceqesPqSE+VvO1CDDJWMwlQfB6LuN6T8w6MaDJ8Txm8P7s5cHD0miF0V+GGTZrDQfxPZQVsur33w==}
+    engines: {node: '>=4.0.0'}
+
+  xmlbuilder2@4.0.3:
+    resolution: {integrity: sha512-bx8Q1STctnNaaDymWnkfQLKofs0mGNN7rLLapJlGuV3VlvegD7Ls4ggMjE3aUSWItCCzU0PEv45lI87iSigiCA==}
+    engines: {node: '>=20.0'}
+
+  xmlbuilder@11.0.1:
+    resolution: {integrity: sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==}
+    engines: {node: '>=4.0'}
+
+  xmlbuilder@15.1.1:
+    resolution: {integrity: sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==}
+    engines: {node: '>=8.0'}
 
   xmlchars@2.2.0:
     resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==}
@@ -8551,22 +10657,28 @@ packages:
   zimmerframe@1.1.4:
     resolution: {integrity: sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==}
 
-  zod-to-json-schema@3.24.6:
-    resolution: {integrity: sha512-h/z3PKvcTcTetyjl1fkj79MHNEjm+HpD6NXheWjzOekY7kV+lwDYnHw+ivHkijnCSMz1yJaWBD9vu/Fcmk+vEg==}
+  zod-to-json-schema@3.25.0:
+    resolution: {integrity: sha512-HvWtU2UG41LALjajJrML6uQejQhNJx+JBO9IflpSja4R03iNWfKXrj6W2h7ljuLyc1nKS+9yDyL/9tD1U/yBnQ==}
     peerDependencies:
-      zod: ^3.24.1
+      zod: ^3.25 || ^4
 
   zod@3.25.76:
     resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==}
 
-  zod@4.1.11:
-    resolution: {integrity: sha512-WPsqwxITS2tzx1bzhIKsEs19ABD5vmCVa4xBo2tq/SrV4RNZtfws1EnCWQXM6yh8bD08a1idvkB5MZSBiZsjwg==}
+  zod@4.1.13:
+    resolution: {integrity: sha512-AvvthqfqrAhNH9dnfmrfKzX5upOdjUVJYFqNSlkmGf64gRaTzlPwz99IHYnVs28qYAybvAlBV+H7pn0saFY4Ig==}
 
-  zone.js@0.15.1:
-    resolution: {integrity: sha512-XE96n56IQpJM7NAoXswY3XRLcWFW83xe0BiAOeMD7K5k5xecOeul3Qcpx6GqEeeHNkW5DWL5zOyTbEfB4eti8w==}
+  zone.js@0.16.0:
+    resolution: {integrity: sha512-LqLPpIQANebrlxY6jKcYKdgN5DTXyyHAKnnWWjE5pPfEQ4n7j5zn7mOEEpwNZVKGqx3kKKmvplEmoBrvpgROTA==}
 
 snapshots:
 
+  '@0no-co/graphql.web@1.2.0(graphql@16.12.0)':
+    optionalDependencies:
+      graphql: 16.12.0
+
+  '@acemir/cssom@0.9.30': {}
+
   '@adobe/css-tools@4.4.4': {}
 
   '@algolia/abtesting@1.1.0':
@@ -8660,14 +10772,14 @@ snapshots:
       '@jridgewell/gen-mapping': 0.3.13
       '@jridgewell/trace-mapping': 0.3.31
 
-  '@angular-devkit/architect@0.2003.6(chokidar@4.0.3)':
+  '@angular-devkit/architect@0.2003.13(chokidar@4.0.3)':
     dependencies:
-      '@angular-devkit/core': 20.3.6(chokidar@4.0.3)
+      '@angular-devkit/core': 20.3.13(chokidar@4.0.3)
       rxjs: 7.8.2
     transitivePeerDependencies:
       - chokidar
 
-  '@angular-devkit/core@20.3.6(chokidar@4.0.3)':
+  '@angular-devkit/core@20.3.13(chokidar@4.0.3)':
     dependencies:
       ajv: 8.17.1
       ajv-formats: 3.0.1(ajv@8.17.1)
@@ -8678,9 +10790,9 @@ snapshots:
     optionalDependencies:
       chokidar: 4.0.3
 
-  '@angular-devkit/schematics@20.3.6(chokidar@4.0.3)':
+  '@angular-devkit/schematics@20.3.13(chokidar@4.0.3)':
     dependencies:
-      '@angular-devkit/core': 20.3.6(chokidar@4.0.3)
+      '@angular-devkit/core': 20.3.13(chokidar@4.0.3)
       jsonc-parser: 3.3.1
       magic-string: 0.30.17
       ora: 8.2.0
@@ -8688,19 +10800,19 @@ snapshots:
     transitivePeerDependencies:
       - chokidar
 
-  '@angular/build@20.3.6(@angular/compiler-cli@20.3.6(@angular/compiler@20.3.6)(typescript@5.8.3))(@angular/compiler@20.3.6)(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(@angular/platform-browser@20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)))(@types/node@24.7.0)(chokidar@4.0.3)(jiti@2.6.0)(karma@6.4.4)(lightningcss@1.30.1)(postcss@8.5.6)(tailwindcss@3.4.18)(terser@5.44.0)(tslib@2.8.1)(tsx@4.20.6)(typescript@5.8.3)(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))(yaml@2.8.1)':
+  '@angular/build@20.3.13(@angular/compiler-cli@20.3.15(@angular/compiler@20.3.16)(typescript@5.9.3))(@angular/compiler@20.3.16)(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(@angular/platform-browser@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0)))(@types/node@24.7.0)(chokidar@4.0.3)(jiti@2.6.1)(karma@6.4.4)(lightningcss@1.30.2)(postcss@8.5.6)(tailwindcss@4.1.18)(terser@5.44.0)(tslib@2.8.1)(tsx@4.21.0)(typescript@5.9.3)(vitest@3.2.4)(yaml@2.8.1)':
     dependencies:
       '@ampproject/remapping': 2.3.0
-      '@angular-devkit/architect': 0.2003.6(chokidar@4.0.3)
-      '@angular/compiler': 20.3.6
-      '@angular/compiler-cli': 20.3.6(@angular/compiler@20.3.6)(typescript@5.8.3)
+      '@angular-devkit/architect': 0.2003.13(chokidar@4.0.3)
+      '@angular/compiler': 20.3.16
+      '@angular/compiler-cli': 20.3.15(@angular/compiler@20.3.16)(typescript@5.9.3)
       '@babel/core': 7.28.3
       '@babel/helper-annotate-as-pure': 7.27.3
       '@babel/helper-split-export-declaration': 7.24.7
       '@inquirer/confirm': 5.1.14(@types/node@24.7.0)
-      '@vitejs/plugin-basic-ssl': 2.1.0(vite@7.1.5(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      '@vitejs/plugin-basic-ssl': 2.1.0(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.21.0)(yaml@2.8.1))
       beasties: 0.3.5
-      browserslist: 4.25.4
+      browserslist: 4.28.0
       esbuild: 0.25.9
       https-proxy-agent: 7.0.6
       istanbul-lib-instrument: 6.0.3
@@ -8717,17 +10829,17 @@ snapshots:
       source-map-support: 0.5.21
       tinyglobby: 0.2.14
       tslib: 2.8.1
-      typescript: 5.8.3
-      vite: 7.1.5(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      typescript: 5.9.3
+      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.21.0)(yaml@2.8.1)
       watchpack: 2.4.4
     optionalDependencies:
-      '@angular/core': 20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)
-      '@angular/platform-browser': 20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))
+      '@angular/core': 19.2.18(rxjs@7.8.2)(zone.js@0.16.0)
+      '@angular/platform-browser': 19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))
       karma: 6.4.4
       lmdb: 3.4.2
       postcss: 8.5.6
-      tailwindcss: 3.4.18
-      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      tailwindcss: 4.1.18
+      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
     transitivePeerDependencies:
       - '@types/node'
       - chokidar
@@ -8741,15 +10853,15 @@ snapshots:
       - tsx
       - yaml
 
-  '@angular/cli@20.3.6(@types/node@24.7.0)(chokidar@4.0.3)':
+  '@angular/cli@20.3.13(@types/node@24.7.0)(chokidar@4.0.3)':
     dependencies:
-      '@angular-devkit/architect': 0.2003.6(chokidar@4.0.3)
-      '@angular-devkit/core': 20.3.6(chokidar@4.0.3)
-      '@angular-devkit/schematics': 20.3.6(chokidar@4.0.3)
+      '@angular-devkit/architect': 0.2003.13(chokidar@4.0.3)
+      '@angular-devkit/core': 20.3.13(chokidar@4.0.3)
+      '@angular-devkit/schematics': 20.3.13(chokidar@4.0.3)
       '@inquirer/prompts': 7.8.2(@types/node@24.7.0)
       '@listr2/prompt-adapter-inquirer': 3.0.1(@inquirer/prompts@7.8.2(@types/node@24.7.0))(@types/node@24.7.0)(listr2@9.0.1)
-      '@modelcontextprotocol/sdk': 1.17.3
-      '@schematics/angular': 20.3.6(chokidar@4.0.3)
+      '@modelcontextprotocol/sdk': 1.24.0(zod@4.1.13)
+      '@schematics/angular': 20.3.13(chokidar@4.0.3)
       '@yarnpkg/lockfile': 1.1.0
       algoliasearch: 5.35.0
       ini: 5.0.0
@@ -8760,27 +10872,22 @@ snapshots:
       resolve: 1.22.10
       semver: 7.7.2
       yargs: 18.0.0
-      zod: 3.25.76
+      zod: 4.1.13
     transitivePeerDependencies:
+      - '@cfworker/json-schema'
       - '@types/node'
       - chokidar
       - supports-color
 
-  '@angular/common@19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2)':
-    dependencies:
-      '@angular/core': 19.2.15(rxjs@7.8.2)(zone.js@0.15.1)
-      rxjs: 7.8.2
-      tslib: 2.8.1
-
-  '@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2)':
+  '@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2)':
     dependencies:
-      '@angular/core': 20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)
+      '@angular/core': 19.2.18(rxjs@7.8.2)(zone.js@0.16.0)
       rxjs: 7.8.2
       tslib: 2.8.1
 
-  '@angular/compiler-cli@20.3.6(@angular/compiler@20.3.6)(typescript@5.8.3)':
+  '@angular/compiler-cli@20.3.15(@angular/compiler@20.3.16)(typescript@5.9.3)':
     dependencies:
-      '@angular/compiler': 20.3.6
+      '@angular/compiler': 20.3.16
       '@babel/core': 7.28.3
       '@jridgewell/sourcemap-codec': 1.5.5
       chokidar: 4.0.3
@@ -8790,122 +10897,104 @@ snapshots:
       tslib: 2.8.1
       yargs: 18.0.0
     optionalDependencies:
-      typescript: 5.8.3
+      typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@angular/compiler@19.2.15':
-    dependencies:
-      tslib: 2.8.1
-
-  '@angular/compiler@20.3.6':
-    dependencies:
-      tslib: 2.8.1
-
-  '@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1)':
+  '@angular/compiler@20.3.16':
     dependencies:
-      rxjs: 7.8.2
       tslib: 2.8.1
-      zone.js: 0.15.1
 
-  '@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)':
+  '@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0)':
     dependencies:
       rxjs: 7.8.2
       tslib: 2.8.1
-    optionalDependencies:
-      '@angular/compiler': 20.3.6
-      zone.js: 0.15.1
+      zone.js: 0.16.0
 
-  '@angular/forms@20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(@angular/platform-browser@20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)))(rxjs@7.8.2)':
+  '@angular/forms@20.3.15(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(@angular/platform-browser@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0)))(rxjs@7.8.2)':
     dependencies:
-      '@angular/common': 20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2)
-      '@angular/core': 20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)
-      '@angular/platform-browser': 20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))
+      '@angular/common': 19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2)
+      '@angular/core': 19.2.18(rxjs@7.8.2)(zone.js@0.16.0)
+      '@angular/platform-browser': 19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))
       rxjs: 7.8.2
       tslib: 2.8.1
 
-  '@angular/platform-browser-dynamic@19.2.15(@angular/common@19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/compiler@19.2.15)(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(@angular/platform-browser@19.2.15(@angular/common@19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1)))':
-    dependencies:
-      '@angular/common': 19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2)
-      '@angular/compiler': 19.2.15
-      '@angular/core': 19.2.15(rxjs@7.8.2)(zone.js@0.15.1)
-      '@angular/platform-browser': 19.2.15(@angular/common@19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))
-      tslib: 2.8.1
-
-  '@angular/platform-browser@19.2.15(@angular/common@19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))':
+  '@angular/platform-browser-dynamic@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/compiler@20.3.16)(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(@angular/platform-browser@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0)))':
     dependencies:
-      '@angular/common': 19.2.15(@angular/core@19.2.15(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2)
-      '@angular/core': 19.2.15(rxjs@7.8.2)(zone.js@0.15.1)
+      '@angular/common': 19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2)
+      '@angular/compiler': 20.3.16
+      '@angular/core': 19.2.18(rxjs@7.8.2)(zone.js@0.16.0)
+      '@angular/platform-browser': 19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))
       tslib: 2.8.1
 
-  '@angular/platform-browser@20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))':
+  '@angular/platform-browser@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))':
     dependencies:
-      '@angular/common': 20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2)
-      '@angular/core': 20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)
+      '@angular/common': 19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2)
+      '@angular/core': 19.2.18(rxjs@7.8.2)(zone.js@0.16.0)
       tslib: 2.8.1
 
-  '@angular/router@20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(@angular/platform-browser@20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)))(rxjs@7.8.2)':
+  '@angular/router@20.3.15(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(@angular/platform-browser@19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0)))(rxjs@7.8.2)':
     dependencies:
-      '@angular/common': 20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2)
-      '@angular/core': 20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1)
-      '@angular/platform-browser': 20.3.6(@angular/common@20.3.6(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))(rxjs@7.8.2))(@angular/core@20.3.6(@angular/compiler@20.3.6)(rxjs@7.8.2)(zone.js@0.15.1))
+      '@angular/common': 19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2)
+      '@angular/core': 19.2.18(rxjs@7.8.2)(zone.js@0.16.0)
+      '@angular/platform-browser': 19.2.17(@angular/common@19.2.17(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2))(@angular/core@19.2.18(rxjs@7.8.2)(zone.js@0.16.0))
       rxjs: 7.8.2
       tslib: 2.8.1
 
-  '@ark/regex@0.0.0':
-    dependencies:
-      '@ark/util': 0.50.0
-
-  '@ark/schema@0.50.0':
+  '@ark/schema@0.56.0':
     dependencies:
-      '@ark/util': 0.50.0
+      '@ark/util': 0.56.0
 
-  '@ark/util@0.50.0': {}
+  '@ark/util@0.56.0': {}
 
-  '@asamuzakjp/css-color@4.0.5':
+  '@asamuzakjp/css-color@4.1.1':
     dependencies:
       '@csstools/css-calc': 2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)
       '@csstools/css-color-parser': 3.1.0(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)
       '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
       '@csstools/css-tokenizer': 3.0.4
-      lru-cache: 11.2.2
+      lru-cache: 11.2.4
 
-  '@asamuzakjp/dom-selector@6.7.2':
+  '@asamuzakjp/dom-selector@6.7.6':
     dependencies:
       '@asamuzakjp/nwsapi': 2.3.9
       bidi-js: 1.0.3
       css-tree: 3.1.0
       is-potential-custom-element-name: 1.0.1
-      lru-cache: 11.2.2
+      lru-cache: 11.2.4
 
   '@asamuzakjp/nwsapi@2.3.9': {}
 
-  '@babel/code-frame@7.26.2':
+  '@babel/code-frame@7.10.4':
     dependencies:
-      '@babel/helper-validator-identifier': 7.27.1
+      '@babel/highlight': 7.25.9
+
+  '@babel/code-frame@7.27.1':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.28.5
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
-  '@babel/code-frame@7.27.1':
+  '@babel/code-frame@7.28.6':
     dependencies:
-      '@babel/helper-validator-identifier': 7.27.1
+      '@babel/helper-validator-identifier': 7.28.5
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
-  '@babel/compat-data@7.28.4': {}
+  '@babel/compat-data@7.28.6': {}
 
   '@babel/core@7.28.3':
     dependencies:
       '@ampproject/remapping': 2.3.0
-      '@babel/code-frame': 7.27.1
-      '@babel/generator': 7.28.3
-      '@babel/helper-compilation-targets': 7.27.2
-      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.3)
+      '@babel/code-frame': 7.28.6
+      '@babel/generator': 7.28.6
+      '@babel/helper-compilation-targets': 7.28.6
+      '@babel/helper-module-transforms': 7.28.6(@babel/core@7.28.3)
       '@babel/helpers': 7.28.4
-      '@babel/parser': 7.28.4
-      '@babel/template': 7.27.2
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/parser': 7.28.6
+      '@babel/template': 7.28.6
+      '@babel/traverse': 7.28.6
+      '@babel/types': 7.28.6
       convert-source-map: 2.0.0
       debug: 4.4.3
       gensync: 1.0.0-beta.2
@@ -8914,17 +11003,17 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/core@7.28.4':
+  '@babel/core@7.28.5':
     dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/generator': 7.28.3
-      '@babel/helper-compilation-targets': 7.27.2
-      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.4)
+      '@babel/code-frame': 7.28.6
+      '@babel/generator': 7.28.6
+      '@babel/helper-compilation-targets': 7.28.6
+      '@babel/helper-module-transforms': 7.28.6(@babel/core@7.28.5)
       '@babel/helpers': 7.28.4
-      '@babel/parser': 7.28.4
-      '@babel/template': 7.27.2
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/parser': 7.28.6
+      '@babel/template': 7.28.6
+      '@babel/traverse': 7.28.6
+      '@babel/types': 7.28.6
       '@jridgewell/remapping': 2.3.5
       convert-source-map: 2.0.0
       debug: 4.4.3
@@ -8934,209 +11023,600 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/generator@7.28.3':
+  '@babel/generator@7.28.6':
     dependencies:
-      '@babel/parser': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/parser': 7.28.6
+      '@babel/types': 7.28.6
       '@jridgewell/gen-mapping': 0.3.13
       '@jridgewell/trace-mapping': 0.3.31
       jsesc: 3.1.0
 
   '@babel/helper-annotate-as-pure@7.27.3':
     dependencies:
-      '@babel/types': 7.28.4
+      '@babel/types': 7.28.6
 
-  '@babel/helper-compilation-targets@7.27.2':
+  '@babel/helper-compilation-targets@7.28.6':
     dependencies:
-      '@babel/compat-data': 7.28.4
+      '@babel/compat-data': 7.28.6
       '@babel/helper-validator-option': 7.27.1
-      browserslist: 4.25.4
+      browserslist: 4.28.0
       lru-cache: 5.1.1
       semver: 6.3.1
 
-  '@babel/helper-create-class-features-plugin@7.28.3(@babel/core@7.28.4)':
+  '@babel/helper-create-class-features-plugin@7.28.6(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
-      '@babel/helper-member-expression-to-functions': 7.27.1
+      '@babel/helper-member-expression-to-functions': 7.28.5
       '@babel/helper-optimise-call-expression': 7.27.1
-      '@babel/helper-replace-supers': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-replace-supers': 7.28.6(@babel/core@7.28.5)
       '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
-      '@babel/traverse': 7.28.4
+      '@babel/traverse': 7.28.6
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-create-regexp-features-plugin@7.28.5(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-annotate-as-pure': 7.27.3
+      regexpu-core: 6.4.0
       semver: 6.3.1
+
+  '@babel/helper-define-polyfill-provider@0.6.5(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-compilation-targets': 7.28.6
+      '@babel/helper-plugin-utils': 7.28.6
+      debug: 4.4.3
+      lodash.debounce: 4.0.8
+      resolve: 1.22.10
     transitivePeerDependencies:
       - supports-color
 
   '@babel/helper-globals@7.28.0': {}
 
-  '@babel/helper-member-expression-to-functions@7.27.1':
+  '@babel/helper-member-expression-to-functions@7.28.5':
     dependencies:
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/traverse': 7.28.6
+      '@babel/types': 7.28.6
     transitivePeerDependencies:
       - supports-color
 
   '@babel/helper-module-imports@7.18.6':
     dependencies:
-      '@babel/types': 7.28.4
+      '@babel/types': 7.28.6
 
-  '@babel/helper-module-imports@7.27.1':
+  '@babel/helper-module-imports@7.28.6':
     dependencies:
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/traverse': 7.28.6
+      '@babel/types': 7.28.6
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-module-transforms@7.28.3(@babel/core@7.28.3)':
+  '@babel/helper-module-transforms@7.28.6(@babel/core@7.28.3)':
     dependencies:
       '@babel/core': 7.28.3
-      '@babel/helper-module-imports': 7.27.1
-      '@babel/helper-validator-identifier': 7.27.1
-      '@babel/traverse': 7.28.4
+      '@babel/helper-module-imports': 7.28.6
+      '@babel/helper-validator-identifier': 7.28.5
+      '@babel/traverse': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-transforms@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-module-imports': 7.28.6
+      '@babel/helper-validator-identifier': 7.28.5
+      '@babel/traverse': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-optimise-call-expression@7.27.1':
+    dependencies:
+      '@babel/types': 7.28.6
+
+  '@babel/helper-plugin-utils@7.28.6': {}
+
+  '@babel/helper-remap-async-to-generator@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-wrap-function': 7.28.6
+      '@babel/traverse': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-replace-supers@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-member-expression-to-functions': 7.28.5
+      '@babel/helper-optimise-call-expression': 7.27.1
+      '@babel/traverse': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-skip-transparent-expression-wrappers@7.27.1':
+    dependencies:
+      '@babel/traverse': 7.28.6
+      '@babel/types': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-split-export-declaration@7.24.7':
+    dependencies:
+      '@babel/types': 7.28.6
+
+  '@babel/helper-string-parser@7.27.1': {}
+
+  '@babel/helper-validator-identifier@7.28.5': {}
+
+  '@babel/helper-validator-option@7.27.1': {}
+
+  '@babel/helper-wrap-function@7.28.6':
+    dependencies:
+      '@babel/template': 7.28.6
+      '@babel/traverse': 7.28.6
+      '@babel/types': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helpers@7.28.4':
+    dependencies:
+      '@babel/template': 7.28.6
+      '@babel/types': 7.28.6
+
+  '@babel/highlight@7.25.9':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.28.5
+      chalk: 2.4.2
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/parser@7.28.6':
+    dependencies:
+      '@babel/types': 7.28.6
+
+  '@babel/plugin-proposal-decorators@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-create-class-features-plugin': 7.28.6(@babel/core@7.28.5)
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/plugin-syntax-decorators': 7.28.6(@babel/core@7.28.5)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-proposal-export-default-from@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-decorators@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-dynamic-import@7.8.3(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-export-default-from@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-flow@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-import-attributes@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-jsx@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-syntax-typescript@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-arrow-functions@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-async-generator-functions@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.28.5)
+      '@babel/traverse': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-async-to-generator@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-module-imports': 7.28.6
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.28.5)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-block-scoping@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-class-properties@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-create-class-features-plugin': 7.28.6(@babel/core@7.28.5)
+      '@babel/helper-plugin-utils': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-classes@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-compilation-targets': 7.28.6
+      '@babel/helper-globals': 7.28.0
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/helper-replace-supers': 7.28.6(@babel/core@7.28.5)
+      '@babel/traverse': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-computed-properties@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/template': 7.28.6
+
+  '@babel/plugin-transform-destructuring@7.28.5(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/traverse': 7.28.6
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-module-transforms@7.28.3(@babel/core@7.28.4)':
+  '@babel/plugin-transform-export-namespace-from@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-flow-strip-types@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/plugin-syntax-flow': 7.28.6(@babel/core@7.28.5)
+
+  '@babel/plugin-transform-for-of@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-function-name@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-compilation-targets': 7.28.6
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/traverse': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-literals@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-logical-assignment-operators@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-modules-commonjs@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-module-transforms': 7.28.6(@babel/core@7.28.5)
+      '@babel/helper-plugin-utils': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-named-capturing-groups-regex@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-create-regexp-features-plugin': 7.28.5(@babel/core@7.28.5)
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-nullish-coalescing-operator@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-numeric-separator@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-object-rest-spread@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-compilation-targets': 7.28.6
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/plugin-transform-destructuring': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.5)
+      '@babel/traverse': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-optional-catch-binding@7.28.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-optional-chaining@7.28.6(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/helper-module-imports': 7.27.1
-      '@babel/helper-validator-identifier': 7.27.1
-      '@babel/traverse': 7.28.4
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-optimise-call-expression@7.27.1':
+  '@babel/plugin-transform-parameters@7.27.7(@babel/core@7.28.5)':
     dependencies:
-      '@babel/types': 7.28.4
-
-  '@babel/helper-plugin-utils@7.27.1': {}
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
 
-  '@babel/helper-replace-supers@7.27.1(@babel/core@7.28.4)':
+  '@babel/plugin-transform-private-methods@7.28.6(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/helper-member-expression-to-functions': 7.27.1
-      '@babel/helper-optimise-call-expression': 7.27.1
-      '@babel/traverse': 7.28.4
+      '@babel/core': 7.28.5
+      '@babel/helper-create-class-features-plugin': 7.28.6(@babel/core@7.28.5)
+      '@babel/helper-plugin-utils': 7.28.6
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-skip-transparent-expression-wrappers@7.27.1':
+  '@babel/plugin-transform-private-property-in-object@7.28.6(@babel/core@7.28.5)':
     dependencies:
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/core': 7.28.5
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-create-class-features-plugin': 7.28.6(@babel/core@7.28.5)
+      '@babel/helper-plugin-utils': 7.28.6
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-split-export-declaration@7.24.7':
+  '@babel/plugin-transform-react-display-name@7.28.0(@babel/core@7.28.5)':
     dependencies:
-      '@babel/types': 7.28.4
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
 
-  '@babel/helper-string-parser@7.27.1': {}
-
-  '@babel/helper-validator-identifier@7.27.1': {}
+  '@babel/plugin-transform-react-jsx-development@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/plugin-transform-react-jsx': 7.28.6(@babel/core@7.28.5)
+    transitivePeerDependencies:
+      - supports-color
 
-  '@babel/helper-validator-option@7.27.1': {}
+  '@babel/plugin-transform-react-jsx-self@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
 
-  '@babel/helpers@7.28.4':
+  '@babel/plugin-transform-react-jsx-source@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/template': 7.27.2
-      '@babel/types': 7.28.4
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
 
-  '@babel/parser@7.28.4':
+  '@babel/plugin-transform-react-jsx@7.28.6(@babel/core@7.28.5)':
     dependencies:
-      '@babel/types': 7.28.4
+      '@babel/core': 7.28.5
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-module-imports': 7.28.6
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/plugin-syntax-jsx': 7.28.6(@babel/core@7.28.5)
+      '@babel/types': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
 
-  '@babel/plugin-syntax-jsx@7.27.1(@babel/core@7.28.4)':
+  '@babel/plugin-transform-react-pure-annotations@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-plugin-utils': 7.28.6
 
-  '@babel/plugin-syntax-typescript@7.27.1(@babel/core@7.28.4)':
+  '@babel/plugin-transform-regenerator@7.28.6(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
 
-  '@babel/plugin-transform-modules-commonjs@7.27.1(@babel/core@7.28.4)':
+  '@babel/plugin-transform-runtime@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.4)
-      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/helper-module-imports': 7.28.6
+      '@babel/helper-plugin-utils': 7.28.6
+      babel-plugin-polyfill-corejs2: 0.4.14(@babel/core@7.28.5)
+      babel-plugin-polyfill-corejs3: 0.13.0(@babel/core@7.28.5)
+      babel-plugin-polyfill-regenerator: 0.6.5(@babel/core@7.28.5)
+      semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-react-jsx-self@7.27.1(@babel/core@7.28.4)':
+  '@babel/plugin-transform-shorthand-properties@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/plugin-transform-spread@7.28.6(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
 
-  '@babel/plugin-transform-react-jsx-source@7.27.1(@babel/core@7.28.4)':
+  '@babel/plugin-transform-sticky-regex@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
 
-  '@babel/plugin-transform-typescript@7.28.0(@babel/core@7.28.4)':
+  '@babel/plugin-transform-typescript@7.28.6(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
-      '@babel/helper-create-class-features-plugin': 7.28.3(@babel/core@7.28.4)
-      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-create-class-features-plugin': 7.28.6(@babel/core@7.28.5)
+      '@babel/helper-plugin-utils': 7.28.6
       '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
-      '@babel/plugin-syntax-typescript': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-syntax-typescript': 7.28.6(@babel/core@7.28.5)
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/preset-typescript@7.27.1(@babel/core@7.28.4)':
+  '@babel/plugin-transform-unicode-regex@7.27.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-create-regexp-features-plugin': 7.28.5(@babel/core@7.28.5)
+      '@babel/helper-plugin-utils': 7.28.6
+
+  '@babel/preset-react@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
       '@babel/helper-validator-option': 7.27.1
-      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.4)
-      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.28.4)
-      '@babel/plugin-transform-typescript': 7.28.0(@babel/core@7.28.4)
+      '@babel/plugin-transform-react-display-name': 7.28.0(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx-development': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-pure-annotations': 7.27.1(@babel/core@7.28.5)
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/runtime@7.27.0':
+  '@babel/preset-typescript@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      regenerator-runtime: 0.14.1
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/helper-validator-option': 7.27.1
+      '@babel/plugin-syntax-jsx': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-modules-commonjs': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-typescript': 7.28.6(@babel/core@7.28.5)
+    transitivePeerDependencies:
+      - supports-color
 
   '@babel/runtime@7.28.4': {}
 
-  '@babel/template@7.27.2':
+  '@babel/template@7.28.6':
     dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/parser': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/code-frame': 7.28.6
+      '@babel/parser': 7.28.6
+      '@babel/types': 7.28.6
 
-  '@babel/traverse@7.28.4':
+  '@babel/traverse@7.28.6':
     dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/generator': 7.28.3
+      '@babel/code-frame': 7.28.6
+      '@babel/generator': 7.28.6
       '@babel/helper-globals': 7.28.0
-      '@babel/parser': 7.28.4
-      '@babel/template': 7.27.2
-      '@babel/types': 7.28.4
+      '@babel/parser': 7.28.6
+      '@babel/template': 7.28.6
+      '@babel/types': 7.28.6
       debug: 4.4.3
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/types@7.28.4':
+  '@babel/types@7.28.6':
     dependencies:
       '@babel/helper-string-parser': 7.27.1
-      '@babel/helper-validator-identifier': 7.27.1
+      '@babel/helper-validator-identifier': 7.28.5
 
-  '@better-auth/core@1.3.27':
+  '@better-auth/core@1.3.26':
     dependencies:
       better-call: 1.0.19
-      zod: 4.1.11
+      zod: 4.1.13
 
   '@better-auth/utils@0.3.0': {}
 
   '@better-fetch/fetch@1.1.18': {}
 
-  '@changesets/apply-release-plan@7.0.13':
+  '@changesets/apply-release-plan@7.0.14':
     dependencies:
-      '@changesets/config': 3.1.1
+      '@changesets/config': 3.1.2
       '@changesets/get-version-range-type': 0.4.0
       '@changesets/git': 3.0.4
       '@changesets/should-skip-package': 0.1.2
@@ -9163,23 +11643,23 @@ snapshots:
     dependencies:
       '@changesets/types': 6.1.0
 
-  '@changesets/cli@2.29.7(@types/node@24.7.0)':
+  '@changesets/cli@2.29.8(@types/node@24.7.0)':
     dependencies:
-      '@changesets/apply-release-plan': 7.0.13
+      '@changesets/apply-release-plan': 7.0.14
       '@changesets/assemble-release-plan': 6.0.9
       '@changesets/changelog-git': 0.2.1
-      '@changesets/config': 3.1.1
+      '@changesets/config': 3.1.2
       '@changesets/errors': 0.2.0
       '@changesets/get-dependents-graph': 2.1.3
-      '@changesets/get-release-plan': 4.0.13
+      '@changesets/get-release-plan': 4.0.14
       '@changesets/git': 3.0.4
       '@changesets/logger': 0.1.1
       '@changesets/pre': 2.0.2
-      '@changesets/read': 0.6.5
+      '@changesets/read': 0.6.6
       '@changesets/should-skip-package': 0.1.2
       '@changesets/types': 6.1.0
       '@changesets/write': 0.4.0
-      '@inquirer/external-editor': 1.0.1(@types/node@24.7.0)
+      '@inquirer/external-editor': 1.0.3(@types/node@24.7.0)
       '@manypkg/get-packages': 1.1.3
       ansi-colors: 4.1.3
       ci-info: 3.9.0
@@ -9196,7 +11676,7 @@ snapshots:
     transitivePeerDependencies:
       - '@types/node'
 
-  '@changesets/config@3.1.1':
+  '@changesets/config@3.1.2':
     dependencies:
       '@changesets/errors': 0.2.0
       '@changesets/get-dependents-graph': 2.1.3
@@ -9224,12 +11704,12 @@ snapshots:
     transitivePeerDependencies:
       - encoding
 
-  '@changesets/get-release-plan@4.0.13':
+  '@changesets/get-release-plan@4.0.14':
     dependencies:
       '@changesets/assemble-release-plan': 6.0.9
-      '@changesets/config': 3.1.1
+      '@changesets/config': 3.1.2
       '@changesets/pre': 2.0.2
-      '@changesets/read': 0.6.5
+      '@changesets/read': 0.6.6
       '@changesets/types': 6.1.0
       '@manypkg/get-packages': 1.1.3
 
@@ -9247,10 +11727,10 @@ snapshots:
     dependencies:
       picocolors: 1.1.1
 
-  '@changesets/parse@0.4.1':
+  '@changesets/parse@0.4.2':
     dependencies:
       '@changesets/types': 6.1.0
-      js-yaml: 3.14.1
+      js-yaml: 4.1.1
 
   '@changesets/pre@2.0.2':
     dependencies:
@@ -9259,11 +11739,11 @@ snapshots:
       '@manypkg/get-packages': 1.1.3
       fs-extra: 7.0.1
 
-  '@changesets/read@0.6.5':
+  '@changesets/read@0.6.6':
     dependencies:
       '@changesets/git': 3.0.4
       '@changesets/logger': 0.1.1
-      '@changesets/parse': 0.4.1
+      '@changesets/parse': 0.4.2
       '@changesets/types': 6.1.0
       fs-extra: 7.0.1
       p-filter: 2.1.0
@@ -9287,15 +11767,15 @@ snapshots:
 
   '@colors/colors@1.5.0': {}
 
-  '@commitlint/parse@19.8.1':
+  '@commitlint/parse@20.2.0':
     dependencies:
-      '@commitlint/types': 19.8.1
+      '@commitlint/types': 20.2.0
       conventional-changelog-angular: 7.0.0
       conventional-commits-parser: 5.0.0
 
-  '@commitlint/types@19.8.1':
+  '@commitlint/types@20.2.0':
     dependencies:
-      '@types/conventional-commits-parser': 5.0.1
+      '@types/conventional-commits-parser': 5.0.2
       chalk: 5.6.2
 
   '@csstools/color-helpers@5.1.0': {}
@@ -9316,27 +11796,25 @@ snapshots:
     dependencies:
       '@csstools/css-tokenizer': 3.0.4
 
-  '@csstools/css-syntax-patches-for-csstree@1.0.14(postcss@8.5.6)':
-    dependencies:
-      postcss: 8.5.6
+  '@csstools/css-syntax-patches-for-csstree@1.0.22': {}
 
   '@csstools/css-tokenizer@3.0.4': {}
 
   '@drizzle-team/brocli@0.10.2': {}
 
-  '@electric-sql/client@1.0.14':
+  '@electric-sql/client@1.3.1':
     dependencies:
       '@microsoft/fetch-event-source': 2.0.1
     optionalDependencies:
       '@rollup/rollup-darwin-arm64': 4.52.5
 
-  '@emnapi/core@1.5.0':
+  '@emnapi/core@1.7.1':
     dependencies:
       '@emnapi/wasi-threads': 1.1.0
       tslib: 2.8.1
     optional: true
 
-  '@emnapi/runtime@1.5.0':
+  '@emnapi/runtime@1.7.1':
     dependencies:
       tslib: 2.8.1
     optional: true
@@ -9362,6 +11840,9 @@ snapshots:
   '@esbuild/aix-ppc64@0.25.9':
     optional: true
 
+  '@esbuild/aix-ppc64@0.27.2':
+    optional: true
+
   '@esbuild/android-arm64@0.18.20':
     optional: true
 
@@ -9371,6 +11852,9 @@ snapshots:
   '@esbuild/android-arm64@0.25.9':
     optional: true
 
+  '@esbuild/android-arm64@0.27.2':
+    optional: true
+
   '@esbuild/android-arm@0.18.20':
     optional: true
 
@@ -9380,6 +11864,9 @@ snapshots:
   '@esbuild/android-arm@0.25.9':
     optional: true
 
+  '@esbuild/android-arm@0.27.2':
+    optional: true
+
   '@esbuild/android-x64@0.18.20':
     optional: true
 
@@ -9389,6 +11876,9 @@ snapshots:
   '@esbuild/android-x64@0.25.9':
     optional: true
 
+  '@esbuild/android-x64@0.27.2':
+    optional: true
+
   '@esbuild/darwin-arm64@0.18.20':
     optional: true
 
@@ -9398,6 +11888,9 @@ snapshots:
   '@esbuild/darwin-arm64@0.25.9':
     optional: true
 
+  '@esbuild/darwin-arm64@0.27.2':
+    optional: true
+
   '@esbuild/darwin-x64@0.18.20':
     optional: true
 
@@ -9407,6 +11900,9 @@ snapshots:
   '@esbuild/darwin-x64@0.25.9':
     optional: true
 
+  '@esbuild/darwin-x64@0.27.2':
+    optional: true
+
   '@esbuild/freebsd-arm64@0.18.20':
     optional: true
 
@@ -9416,6 +11912,9 @@ snapshots:
   '@esbuild/freebsd-arm64@0.25.9':
     optional: true
 
+  '@esbuild/freebsd-arm64@0.27.2':
+    optional: true
+
   '@esbuild/freebsd-x64@0.18.20':
     optional: true
 
@@ -9425,6 +11924,9 @@ snapshots:
   '@esbuild/freebsd-x64@0.25.9':
     optional: true
 
+  '@esbuild/freebsd-x64@0.27.2':
+    optional: true
+
   '@esbuild/linux-arm64@0.18.20':
     optional: true
 
@@ -9434,6 +11936,9 @@ snapshots:
   '@esbuild/linux-arm64@0.25.9':
     optional: true
 
+  '@esbuild/linux-arm64@0.27.2':
+    optional: true
+
   '@esbuild/linux-arm@0.18.20':
     optional: true
 
@@ -9443,6 +11948,9 @@ snapshots:
   '@esbuild/linux-arm@0.25.9':
     optional: true
 
+  '@esbuild/linux-arm@0.27.2':
+    optional: true
+
   '@esbuild/linux-ia32@0.18.20':
     optional: true
 
@@ -9452,6 +11960,9 @@ snapshots:
   '@esbuild/linux-ia32@0.25.9':
     optional: true
 
+  '@esbuild/linux-ia32@0.27.2':
+    optional: true
+
   '@esbuild/linux-loong64@0.18.20':
     optional: true
 
@@ -9461,6 +11972,9 @@ snapshots:
   '@esbuild/linux-loong64@0.25.9':
     optional: true
 
+  '@esbuild/linux-loong64@0.27.2':
+    optional: true
+
   '@esbuild/linux-mips64el@0.18.20':
     optional: true
 
@@ -9470,6 +11984,9 @@ snapshots:
   '@esbuild/linux-mips64el@0.25.9':
     optional: true
 
+  '@esbuild/linux-mips64el@0.27.2':
+    optional: true
+
   '@esbuild/linux-ppc64@0.18.20':
     optional: true
 
@@ -9479,6 +11996,9 @@ snapshots:
   '@esbuild/linux-ppc64@0.25.9':
     optional: true
 
+  '@esbuild/linux-ppc64@0.27.2':
+    optional: true
+
   '@esbuild/linux-riscv64@0.18.20':
     optional: true
 
@@ -9488,6 +12008,9 @@ snapshots:
   '@esbuild/linux-riscv64@0.25.9':
     optional: true
 
+  '@esbuild/linux-riscv64@0.27.2':
+    optional: true
+
   '@esbuild/linux-s390x@0.18.20':
     optional: true
 
@@ -9497,6 +12020,9 @@ snapshots:
   '@esbuild/linux-s390x@0.25.9':
     optional: true
 
+  '@esbuild/linux-s390x@0.27.2':
+    optional: true
+
   '@esbuild/linux-x64@0.18.20':
     optional: true
 
@@ -9506,12 +12032,18 @@ snapshots:
   '@esbuild/linux-x64@0.25.9':
     optional: true
 
+  '@esbuild/linux-x64@0.27.2':
+    optional: true
+
   '@esbuild/netbsd-arm64@0.25.11':
     optional: true
 
   '@esbuild/netbsd-arm64@0.25.9':
     optional: true
 
+  '@esbuild/netbsd-arm64@0.27.2':
+    optional: true
+
   '@esbuild/netbsd-x64@0.18.20':
     optional: true
 
@@ -9521,12 +12053,18 @@ snapshots:
   '@esbuild/netbsd-x64@0.25.9':
     optional: true
 
+  '@esbuild/netbsd-x64@0.27.2':
+    optional: true
+
   '@esbuild/openbsd-arm64@0.25.11':
     optional: true
 
   '@esbuild/openbsd-arm64@0.25.9':
     optional: true
 
+  '@esbuild/openbsd-arm64@0.27.2':
+    optional: true
+
   '@esbuild/openbsd-x64@0.18.20':
     optional: true
 
@@ -9536,12 +12074,18 @@ snapshots:
   '@esbuild/openbsd-x64@0.25.9':
     optional: true
 
+  '@esbuild/openbsd-x64@0.27.2':
+    optional: true
+
   '@esbuild/openharmony-arm64@0.25.11':
     optional: true
 
   '@esbuild/openharmony-arm64@0.25.9':
     optional: true
 
+  '@esbuild/openharmony-arm64@0.27.2':
+    optional: true
+
   '@esbuild/sunos-x64@0.18.20':
     optional: true
 
@@ -9551,6 +12095,9 @@ snapshots:
   '@esbuild/sunos-x64@0.25.9':
     optional: true
 
+  '@esbuild/sunos-x64@0.27.2':
+    optional: true
+
   '@esbuild/win32-arm64@0.18.20':
     optional: true
 
@@ -9560,6 +12107,9 @@ snapshots:
   '@esbuild/win32-arm64@0.25.9':
     optional: true
 
+  '@esbuild/win32-arm64@0.27.2':
+    optional: true
+
   '@esbuild/win32-ia32@0.18.20':
     optional: true
 
@@ -9569,6 +12119,9 @@ snapshots:
   '@esbuild/win32-ia32@0.25.9':
     optional: true
 
+  '@esbuild/win32-ia32@0.27.2':
+    optional: true
+
   '@esbuild/win32-x64@0.18.20':
     optional: true
 
@@ -9578,18 +12131,21 @@ snapshots:
   '@esbuild/win32-x64@0.25.9':
     optional: true
 
-  '@eslint-community/eslint-utils@4.9.0(eslint@9.38.0(jiti@2.6.0))':
+  '@esbuild/win32-x64@0.27.2':
+    optional: true
+
+  '@eslint-community/eslint-utils@4.9.0(eslint@9.39.2(jiti@2.6.1))':
     dependencies:
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
       eslint-visitor-keys: 3.4.3
 
   '@eslint-community/regexpp@4.12.1': {}
 
-  '@eslint/compat@1.4.0(eslint@9.38.0(jiti@2.6.0))':
+  '@eslint/compat@1.4.1(eslint@9.39.2(jiti@2.6.1))':
     dependencies:
-      '@eslint/core': 0.16.0
+      '@eslint/core': 0.17.0
     optionalDependencies:
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
 
   '@eslint/config-array@0.21.1':
     dependencies:
@@ -9599,11 +12155,11 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@eslint/config-helpers@0.4.1':
+  '@eslint/config-helpers@0.4.2':
     dependencies:
-      '@eslint/core': 0.16.0
+      '@eslint/core': 0.17.0
 
-  '@eslint/core@0.16.0':
+  '@eslint/core@0.17.0':
     dependencies:
       '@types/json-schema': 7.0.15
 
@@ -9615,21 +12171,295 @@ snapshots:
       globals: 14.0.0
       ignore: 5.3.2
       import-fresh: 3.3.1
-      js-yaml: 4.1.0
+      js-yaml: 4.1.1
       minimatch: 3.1.2
       strip-json-comments: 3.1.1
     transitivePeerDependencies:
       - supports-color
 
-  '@eslint/js@9.38.0': {}
+  '@eslint/js@9.39.2': {}
 
   '@eslint/object-schema@2.1.7': {}
 
-  '@eslint/plugin-kit@0.4.0':
+  '@eslint/plugin-kit@0.4.1':
     dependencies:
-      '@eslint/core': 0.16.0
+      '@eslint/core': 0.17.0
       levn: 0.4.1
 
+  '@exodus/bytes@1.7.0': {}
+
+  '@expo/cli@0.24.23(graphql@16.12.0)':
+    dependencies:
+      '@0no-co/graphql.web': 1.2.0(graphql@16.12.0)
+      '@babel/runtime': 7.28.4
+      '@expo/code-signing-certificates': 0.0.5
+      '@expo/config': 11.0.13
+      '@expo/config-plugins': 10.1.2
+      '@expo/devcert': 1.2.1
+      '@expo/env': 1.0.7
+      '@expo/image-utils': 0.7.6
+      '@expo/json-file': 9.1.5
+      '@expo/metro-config': 0.20.18
+      '@expo/osascript': 2.3.8
+      '@expo/package-manager': 1.9.9
+      '@expo/plist': 0.3.5
+      '@expo/prebuild-config': 9.0.12
+      '@expo/schema-utils': 0.1.8
+      '@expo/spawn-async': 1.7.2
+      '@expo/ws-tunnel': 1.0.6
+      '@expo/xcpretty': 4.3.2
+      '@react-native/dev-middleware': 0.79.6
+      '@urql/core': 5.2.0(graphql@16.12.0)
+      '@urql/exchange-retry': 1.3.2(@urql/core@5.2.0(graphql@16.12.0))
+      accepts: 1.3.8
+      arg: 5.0.2
+      better-opn: 3.0.2
+      bplist-creator: 0.1.0
+      bplist-parser: 0.3.2
+      chalk: 4.1.2
+      ci-info: 3.9.0
+      compression: 1.8.1
+      connect: 3.7.0
+      debug: 4.4.3
+      env-editor: 0.4.2
+      freeport-async: 2.0.0
+      getenv: 2.0.0
+      glob: 10.4.5
+      lan-network: 0.1.7
+      minimatch: 9.0.5
+      node-forge: 1.3.3
+      npm-package-arg: 11.0.3
+      ora: 3.4.0
+      picomatch: 3.0.1
+      pretty-bytes: 5.6.0
+      pretty-format: 29.7.0
+      progress: 2.0.3
+      prompts: 2.4.2
+      qrcode-terminal: 0.11.0
+      require-from-string: 2.0.2
+      requireg: 0.2.2
+      resolve: 1.22.10
+      resolve-from: 5.0.0
+      resolve.exports: 2.0.3
+      semver: 7.7.3
+      send: 0.19.0
+      slugify: 1.6.6
+      source-map-support: 0.5.21
+      stacktrace-parser: 0.1.11
+      structured-headers: 0.4.1
+      tar: 7.5.1
+      terminal-link: 2.1.1
+      undici: 6.23.0
+      wrap-ansi: 7.0.0
+      ws: 8.18.3
+    transitivePeerDependencies:
+      - bufferutil
+      - graphql
+      - supports-color
+      - utf-8-validate
+
+  '@expo/code-signing-certificates@0.0.5':
+    dependencies:
+      node-forge: 1.3.3
+      nullthrows: 1.1.1
+
+  '@expo/config-plugins@10.1.2':
+    dependencies:
+      '@expo/config-types': 53.0.5
+      '@expo/json-file': 9.1.5
+      '@expo/plist': 0.3.5
+      '@expo/sdk-runtime-versions': 1.0.0
+      chalk: 4.1.2
+      debug: 4.4.3
+      getenv: 2.0.0
+      glob: 10.4.5
+      resolve-from: 5.0.0
+      semver: 7.7.3
+      slash: 3.0.0
+      slugify: 1.6.6
+      xcode: 3.0.1
+      xml2js: 0.6.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@expo/config-types@53.0.5': {}
+
+  '@expo/config@11.0.13':
+    dependencies:
+      '@babel/code-frame': 7.10.4
+      '@expo/config-plugins': 10.1.2
+      '@expo/config-types': 53.0.5
+      '@expo/json-file': 9.1.5
+      deepmerge: 4.3.1
+      getenv: 2.0.0
+      glob: 10.4.5
+      require-from-string: 2.0.2
+      resolve-from: 5.0.0
+      resolve-workspace-root: 2.0.1
+      semver: 7.7.3
+      slugify: 1.6.6
+      sucrase: 3.35.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@expo/devcert@1.2.1':
+    dependencies:
+      '@expo/sudo-prompt': 9.3.2
+      debug: 3.2.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@expo/env@1.0.7':
+    dependencies:
+      chalk: 4.1.2
+      debug: 4.4.3
+      dotenv: 16.4.7
+      dotenv-expand: 11.0.7
+      getenv: 2.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@expo/fingerprint@0.13.4':
+    dependencies:
+      '@expo/spawn-async': 1.7.2
+      arg: 5.0.2
+      chalk: 4.1.2
+      debug: 4.4.3
+      find-up: 5.0.0
+      getenv: 2.0.0
+      glob: 10.4.5
+      ignore: 5.3.2
+      minimatch: 9.0.5
+      p-limit: 3.1.0
+      resolve-from: 5.0.0
+      semver: 7.7.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@expo/image-utils@0.7.6':
+    dependencies:
+      '@expo/spawn-async': 1.7.2
+      chalk: 4.1.2
+      getenv: 2.0.0
+      jimp-compact: 0.16.1
+      parse-png: 2.1.0
+      resolve-from: 5.0.0
+      semver: 7.7.3
+      temp-dir: 2.0.0
+      unique-string: 2.0.0
+
+  '@expo/json-file@10.0.8':
+    dependencies:
+      '@babel/code-frame': 7.10.4
+      json5: 2.2.3
+
+  '@expo/json-file@9.1.5':
+    dependencies:
+      '@babel/code-frame': 7.10.4
+      json5: 2.2.3
+
+  '@expo/metro-config@0.20.18':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.6
+      '@babel/parser': 7.28.6
+      '@babel/types': 7.28.6
+      '@expo/config': 11.0.13
+      '@expo/env': 1.0.7
+      '@expo/json-file': 9.1.5
+      '@expo/spawn-async': 1.7.2
+      chalk: 4.1.2
+      debug: 4.4.3
+      dotenv: 16.4.7
+      dotenv-expand: 11.0.7
+      getenv: 2.0.0
+      glob: 10.4.5
+      jsc-safe-url: 0.2.4
+      lightningcss: 1.27.0
+      minimatch: 9.0.5
+      postcss: 8.4.49
+      resolve-from: 5.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))':
+    dependencies:
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+
+  '@expo/osascript@2.3.8':
+    dependencies:
+      '@expo/spawn-async': 1.7.2
+      exec-async: 2.2.0
+
+  '@expo/package-manager@1.9.9':
+    dependencies:
+      '@expo/json-file': 10.0.8
+      '@expo/spawn-async': 1.7.2
+      chalk: 4.1.2
+      npm-package-arg: 11.0.3
+      ora: 3.4.0
+      resolve-workspace-root: 2.0.1
+
+  '@expo/plist@0.3.5':
+    dependencies:
+      '@xmldom/xmldom': 0.8.11
+      base64-js: 1.5.1
+      xmlbuilder: 15.1.1
+
+  '@expo/prebuild-config@9.0.12':
+    dependencies:
+      '@expo/config': 11.0.13
+      '@expo/config-plugins': 10.1.2
+      '@expo/config-types': 53.0.5
+      '@expo/image-utils': 0.7.6
+      '@expo/json-file': 9.1.5
+      '@react-native/normalize-colors': 0.79.6
+      debug: 4.4.3
+      resolve-from: 5.0.0
+      semver: 7.7.3
+      xml2js: 0.6.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@expo/schema-utils@0.1.8': {}
+
+  '@expo/sdk-runtime-versions@1.0.0': {}
+
+  '@expo/server@0.6.3':
+    dependencies:
+      abort-controller: 3.0.0
+      debug: 4.4.3
+      source-map-support: 0.5.21
+      undici: 7.16.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@expo/spawn-async@1.7.2':
+    dependencies:
+      cross-spawn: 7.0.6
+
+  '@expo/sudo-prompt@9.3.2': {}
+
+  '@expo/vector-icons@14.1.0(expo-font@13.3.2(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)':
+    dependencies:
+      expo-font: 13.3.2(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react@19.2.3)
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+
+  '@expo/ws-tunnel@1.0.6': {}
+
+  '@expo/xcpretty@4.3.2':
+    dependencies:
+      '@babel/code-frame': 7.10.4
+      chalk: 4.1.2
+      find-up: 5.0.0
+      js-yaml: 4.1.1
+
+  '@fast-check/vitest@0.2.4(vitest@3.2.4)':
+    dependencies:
+      fast-check: 3.23.2
+      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+
   '@firebase/ai@1.4.1(@firebase/app-types@0.9.3)(@firebase/app@0.13.2)':
     dependencies:
       '@firebase/app': 0.13.2
@@ -10021,7 +12851,7 @@ snapshots:
   '@inquirer/editor@4.2.18(@types/node@24.7.0)':
     dependencies:
       '@inquirer/core': 10.2.0(@types/node@24.7.0)
-      '@inquirer/external-editor': 1.0.1(@types/node@24.7.0)
+      '@inquirer/external-editor': 1.0.3(@types/node@24.7.0)
       '@inquirer/type': 3.0.8(@types/node@24.7.0)
     optionalDependencies:
       '@types/node': 24.7.0
@@ -10034,10 +12864,10 @@ snapshots:
     optionalDependencies:
       '@types/node': 24.7.0
 
-  '@inquirer/external-editor@1.0.1(@types/node@24.7.0)':
+  '@inquirer/external-editor@1.0.3(@types/node@24.7.0)':
     dependencies:
-      chardet: 2.1.0
-      iconv-lite: 0.6.3
+      chardet: 2.1.1
+      iconv-lite: 0.7.0
     optionalDependencies:
       '@types/node': 24.7.0
 
@@ -10130,8 +12960,71 @@ snapshots:
     dependencies:
       minipass: 7.1.2
 
+  '@isaacs/ttlcache@1.4.1': {}
+
+  '@istanbuljs/load-nyc-config@1.1.0':
+    dependencies:
+      camelcase: 5.3.1
+      find-up: 4.1.0
+      get-package-type: 0.1.0
+      js-yaml: 3.14.1
+      resolve-from: 5.0.0
+
   '@istanbuljs/schema@0.1.3': {}
 
+  '@jest/create-cache-key-function@29.7.0':
+    dependencies:
+      '@jest/types': 29.6.3
+
+  '@jest/environment@29.7.0':
+    dependencies:
+      '@jest/fake-timers': 29.7.0
+      '@jest/types': 29.6.3
+      '@types/node': 24.7.0
+      jest-mock: 29.7.0
+
+  '@jest/fake-timers@29.7.0':
+    dependencies:
+      '@jest/types': 29.6.3
+      '@sinonjs/fake-timers': 10.3.0
+      '@types/node': 24.7.0
+      jest-message-util: 29.7.0
+      jest-mock: 29.7.0
+      jest-util: 29.7.0
+
+  '@jest/schemas@29.6.3':
+    dependencies:
+      '@sinclair/typebox': 0.27.8
+
+  '@jest/transform@29.7.0':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@jest/types': 29.6.3
+      '@jridgewell/trace-mapping': 0.3.31
+      babel-plugin-istanbul: 6.1.1
+      chalk: 4.1.2
+      convert-source-map: 2.0.0
+      fast-json-stable-stringify: 2.1.0
+      graceful-fs: 4.2.11
+      jest-haste-map: 29.7.0
+      jest-regex-util: 29.6.3
+      jest-util: 29.7.0
+      micromatch: 4.0.8
+      pirates: 4.0.7
+      slash: 3.0.0
+      write-file-atomic: 4.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  '@jest/types@29.6.3':
+    dependencies:
+      '@jest/schemas': 29.6.3
+      '@types/istanbul-lib-coverage': 2.0.6
+      '@types/istanbul-reports': 3.0.4
+      '@types/node': 24.7.0
+      '@types/yargs': 17.0.35
+      chalk: 4.1.2
+
   '@jridgewell/gen-mapping@0.3.13':
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
@@ -10148,7 +13041,6 @@ snapshots:
     dependencies:
       '@jridgewell/gen-mapping': 0.3.13
       '@jridgewell/trace-mapping': 0.3.31
-    optional: true
 
   '@jridgewell/sourcemap-codec@1.5.5': {}
 
@@ -10249,9 +13141,10 @@ snapshots:
 
   '@microsoft/tsdoc@0.15.1': {}
 
-  '@modelcontextprotocol/sdk@1.17.3':
+  '@modelcontextprotocol/sdk@1.24.0(zod@4.1.13)':
     dependencies:
-      ajv: 6.12.6
+      ajv: 8.17.1
+      ajv-formats: 3.0.1(ajv@8.17.1)
       content-type: 1.0.5
       cors: 2.8.5
       cross-spawn: 7.0.6
@@ -10259,10 +13152,11 @@ snapshots:
       eventsource-parser: 3.0.6
       express: 5.1.0
       express-rate-limit: 7.5.1(express@5.1.0)
+      jose: 6.1.2
       pkce-challenge: 5.0.0
       raw-body: 3.0.1
-      zod: 3.25.76
-      zod-to-json-schema: 3.24.6(zod@3.25.76)
+      zod: 4.1.13
+      zod-to-json-schema: 3.25.0(zod@4.1.13)
     transitivePeerDependencies:
       - supports-color
 
@@ -10362,21 +13256,21 @@ snapshots:
 
   '@napi-rs/wasm-runtime@0.2.12':
     dependencies:
-      '@emnapi/core': 1.5.0
-      '@emnapi/runtime': 1.5.0
+      '@emnapi/core': 1.7.1
+      '@emnapi/runtime': 1.7.1
       '@tybys/wasm-util': 0.10.1
     optional: true
 
-  '@napi-rs/wasm-runtime@1.0.5':
+  '@napi-rs/wasm-runtime@1.1.0':
     dependencies:
-      '@emnapi/core': 1.5.0
-      '@emnapi/runtime': 1.5.0
+      '@emnapi/core': 1.7.1
+      '@emnapi/runtime': 1.7.1
       '@tybys/wasm-util': 0.10.1
     optional: true
 
-  '@noble/ciphers@2.0.0': {}
+  '@noble/ciphers@2.0.1': {}
 
-  '@noble/hashes@2.0.0': {}
+  '@noble/hashes@2.0.1': {}
 
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
@@ -10451,80 +13345,86 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@oozcitak/dom@1.15.10':
+  '@oozcitak/dom@2.0.2':
     dependencies:
-      '@oozcitak/infra': 1.0.8
-      '@oozcitak/url': 1.0.4
-      '@oozcitak/util': 8.3.8
+      '@oozcitak/infra': 2.0.2
+      '@oozcitak/url': 3.0.0
+      '@oozcitak/util': 10.0.0
 
-  '@oozcitak/infra@1.0.8':
+  '@oozcitak/infra@2.0.2':
     dependencies:
-      '@oozcitak/util': 8.3.8
+      '@oozcitak/util': 10.0.0
 
-  '@oozcitak/url@1.0.4':
+  '@oozcitak/url@3.0.0':
     dependencies:
-      '@oozcitak/infra': 1.0.8
-      '@oozcitak/util': 8.3.8
+      '@oozcitak/infra': 2.0.2
+      '@oozcitak/util': 10.0.0
+
+  '@oozcitak/util@10.0.0': {}
+
+  '@opentelemetry/api@1.9.0':
+    optional: true
 
-  '@oozcitak/util@8.3.8': {}
+  '@oxc-resolver/binding-android-arm-eabi@11.16.2':
+    optional: true
 
-  '@oxc-resolver/binding-android-arm-eabi@11.8.4':
+  '@oxc-resolver/binding-android-arm64@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-android-arm64@11.8.4':
+  '@oxc-resolver/binding-darwin-arm64@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-darwin-arm64@11.8.4':
+  '@oxc-resolver/binding-darwin-x64@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-darwin-x64@11.8.4':
+  '@oxc-resolver/binding-freebsd-x64@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-freebsd-x64@11.8.4':
+  '@oxc-resolver/binding-linux-arm-gnueabihf@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-arm-gnueabihf@11.8.4':
+  '@oxc-resolver/binding-linux-arm-musleabihf@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-arm-musleabihf@11.8.4':
+  '@oxc-resolver/binding-linux-arm64-gnu@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-arm64-gnu@11.8.4':
+  '@oxc-resolver/binding-linux-arm64-musl@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-arm64-musl@11.8.4':
+  '@oxc-resolver/binding-linux-ppc64-gnu@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-ppc64-gnu@11.8.4':
+  '@oxc-resolver/binding-linux-riscv64-gnu@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-riscv64-gnu@11.8.4':
+  '@oxc-resolver/binding-linux-riscv64-musl@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-riscv64-musl@11.8.4':
+  '@oxc-resolver/binding-linux-s390x-gnu@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-s390x-gnu@11.8.4':
+  '@oxc-resolver/binding-linux-x64-gnu@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-x64-gnu@11.8.4':
+  '@oxc-resolver/binding-linux-x64-musl@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-linux-x64-musl@11.8.4':
+  '@oxc-resolver/binding-openharmony-arm64@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-wasm32-wasi@11.8.4':
+  '@oxc-resolver/binding-wasm32-wasi@11.16.2':
     dependencies:
-      '@napi-rs/wasm-runtime': 1.0.5
+      '@napi-rs/wasm-runtime': 1.1.0
     optional: true
 
-  '@oxc-resolver/binding-win32-arm64-msvc@11.8.4':
+  '@oxc-resolver/binding-win32-arm64-msvc@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-win32-ia32-msvc@11.8.4':
+  '@oxc-resolver/binding-win32-ia32-msvc@11.16.2':
     optional: true
 
-  '@oxc-resolver/binding-win32-x64-msvc@11.8.4':
+  '@oxc-resolver/binding-win32-x64-msvc@11.16.2':
     optional: true
 
   '@parcel/watcher-android-arm64@2.5.1':
@@ -10588,39 +13488,102 @@ snapshots:
       '@parcel/watcher-win32-x64': 2.5.1
     optional: true
 
-  '@peculiar/asn1-android@2.5.0':
+  '@peculiar/asn1-android@2.6.0':
+    dependencies:
+      '@peculiar/asn1-schema': 2.6.0
+      asn1js: 3.0.6
+      tslib: 2.8.1
+
+  '@peculiar/asn1-cms@2.6.0':
+    dependencies:
+      '@peculiar/asn1-schema': 2.6.0
+      '@peculiar/asn1-x509': 2.6.0
+      '@peculiar/asn1-x509-attr': 2.6.0
+      asn1js: 3.0.6
+      tslib: 2.8.1
+
+  '@peculiar/asn1-csr@2.6.0':
+    dependencies:
+      '@peculiar/asn1-schema': 2.6.0
+      '@peculiar/asn1-x509': 2.6.0
+      asn1js: 3.0.6
+      tslib: 2.8.1
+
+  '@peculiar/asn1-ecc@2.6.0':
+    dependencies:
+      '@peculiar/asn1-schema': 2.6.0
+      '@peculiar/asn1-x509': 2.6.0
+      asn1js: 3.0.6
+      tslib: 2.8.1
+
+  '@peculiar/asn1-pfx@2.6.0':
+    dependencies:
+      '@peculiar/asn1-cms': 2.6.0
+      '@peculiar/asn1-pkcs8': 2.6.0
+      '@peculiar/asn1-rsa': 2.6.0
+      '@peculiar/asn1-schema': 2.6.0
+      asn1js: 3.0.6
+      tslib: 2.8.1
+
+  '@peculiar/asn1-pkcs8@2.6.0':
     dependencies:
-      '@peculiar/asn1-schema': 2.5.0
+      '@peculiar/asn1-schema': 2.6.0
+      '@peculiar/asn1-x509': 2.6.0
       asn1js: 3.0.6
       tslib: 2.8.1
 
-  '@peculiar/asn1-ecc@2.5.0':
+  '@peculiar/asn1-pkcs9@2.6.0':
     dependencies:
-      '@peculiar/asn1-schema': 2.5.0
-      '@peculiar/asn1-x509': 2.5.0
+      '@peculiar/asn1-cms': 2.6.0
+      '@peculiar/asn1-pfx': 2.6.0
+      '@peculiar/asn1-pkcs8': 2.6.0
+      '@peculiar/asn1-schema': 2.6.0
+      '@peculiar/asn1-x509': 2.6.0
+      '@peculiar/asn1-x509-attr': 2.6.0
       asn1js: 3.0.6
       tslib: 2.8.1
 
-  '@peculiar/asn1-rsa@2.5.0':
+  '@peculiar/asn1-rsa@2.6.0':
     dependencies:
-      '@peculiar/asn1-schema': 2.5.0
-      '@peculiar/asn1-x509': 2.5.0
+      '@peculiar/asn1-schema': 2.6.0
+      '@peculiar/asn1-x509': 2.6.0
       asn1js: 3.0.6
       tslib: 2.8.1
 
-  '@peculiar/asn1-schema@2.5.0':
+  '@peculiar/asn1-schema@2.6.0':
     dependencies:
       asn1js: 3.0.6
       pvtsutils: 1.3.6
       tslib: 2.8.1
 
-  '@peculiar/asn1-x509@2.5.0':
+  '@peculiar/asn1-x509-attr@2.6.0':
+    dependencies:
+      '@peculiar/asn1-schema': 2.6.0
+      '@peculiar/asn1-x509': 2.6.0
+      asn1js: 3.0.6
+      tslib: 2.8.1
+
+  '@peculiar/asn1-x509@2.6.0':
     dependencies:
-      '@peculiar/asn1-schema': 2.5.0
+      '@peculiar/asn1-schema': 2.6.0
       asn1js: 3.0.6
       pvtsutils: 1.3.6
       tslib: 2.8.1
 
+  '@peculiar/x509@1.14.2':
+    dependencies:
+      '@peculiar/asn1-cms': 2.6.0
+      '@peculiar/asn1-csr': 2.6.0
+      '@peculiar/asn1-ecc': 2.6.0
+      '@peculiar/asn1-pkcs9': 2.6.0
+      '@peculiar/asn1-rsa': 2.6.0
+      '@peculiar/asn1-schema': 2.6.0
+      '@peculiar/asn1-x509': 2.6.0
+      pvtsutils: 1.3.6
+      reflect-metadata: 0.2.2
+      tslib: 2.8.1
+      tsyringe: 4.10.0
+
   '@petamoriken/float16@3.9.3':
     optional: true
 
@@ -10629,6 +13592,21 @@ snapshots:
 
   '@pkgr/core@0.2.9': {}
 
+  '@polka/url@1.0.0-next.29': {}
+
+  '@powersync/common@1.44.0':
+    dependencies:
+      async-mutex: 0.5.0
+      event-iterator: 2.0.0
+
+  '@powersync/node@0.15.1(@powersync/common@1.44.0)':
+    dependencies:
+      '@powersync/common': 1.44.0
+      async-mutex: 0.5.0
+      bson: 6.10.4
+      comlink: 4.4.2
+      undici: 7.16.0
+
   '@protobufjs/aspromise@1.1.2': {}
 
   '@protobufjs/base64@1.1.2': {}
@@ -10654,12 +13632,215 @@ snapshots:
 
   '@publint/pack@0.1.2': {}
 
-  '@rolldown/pluginutils@1.0.0-beta.29': {}
+  '@radix-ui/react-compose-refs@1.1.2(@types/react@19.2.7)(react@19.2.3)':
+    dependencies:
+      react: 19.2.3
+    optionalDependencies:
+      '@types/react': 19.2.7
+
+  '@radix-ui/react-slot@1.2.0(@types/react@19.2.7)(react@19.2.3)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.7)(react@19.2.3)
+      react: 19.2.3
+    optionalDependencies:
+      '@types/react': 19.2.7
+
+  '@react-native-async-storage/async-storage@2.1.2(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))':
+    dependencies:
+      merge-options: 3.0.4
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+
+  '@react-native-community/netinfo@11.4.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))':
+    dependencies:
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+
+  '@react-native/assets-registry@0.79.6': {}
+
+  '@react-native/babel-plugin-codegen@0.79.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/traverse': 7.28.6
+      '@react-native/codegen': 0.79.6(@babel/core@7.28.5)
+    transitivePeerDependencies:
+      - '@babel/core'
+      - supports-color
+
+  '@react-native/babel-preset@0.79.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/plugin-proposal-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-export-default-from': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-transform-arrow-functions': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-async-generator-functions': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-async-to-generator': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-block-scoping': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-class-properties': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-classes': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-computed-properties': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-destructuring': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-flow-strip-types': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-for-of': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-function-name': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-literals': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-logical-assignment-operators': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-modules-commonjs': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-named-capturing-groups-regex': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-nullish-coalescing-operator': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-numeric-separator': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-object-rest-spread': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-optional-catch-binding': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-optional-chaining': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-methods': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-property-in-object': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-display-name': 7.28.0(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx-source': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-regenerator': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-runtime': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-shorthand-properties': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-spread': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-sticky-regex': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-typescript': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-unicode-regex': 7.27.1(@babel/core@7.28.5)
+      '@babel/template': 7.28.6
+      '@react-native/babel-plugin-codegen': 0.79.6(@babel/core@7.28.5)
+      babel-plugin-syntax-hermes-parser: 0.25.1
+      babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.28.5)
+      react-refresh: 0.14.2
+    transitivePeerDependencies:
+      - supports-color
+
+  '@react-native/codegen@0.79.6(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/parser': 7.28.6
+      glob: 7.2.3
+      hermes-parser: 0.25.1
+      invariant: 2.2.4
+      nullthrows: 1.1.1
+      yargs: 17.7.2
+
+  '@react-native/community-cli-plugin@0.79.6':
+    dependencies:
+      '@react-native/dev-middleware': 0.79.6
+      chalk: 4.1.2
+      debug: 2.6.9
+      invariant: 2.2.4
+      metro: 0.82.5
+      metro-config: 0.82.5
+      metro-core: 0.82.5
+      semver: 7.7.3
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  '@react-native/debugger-frontend@0.79.6': {}
+
+  '@react-native/dev-middleware@0.79.6':
+    dependencies:
+      '@isaacs/ttlcache': 1.4.1
+      '@react-native/debugger-frontend': 0.79.6
+      chrome-launcher: 0.15.2
+      chromium-edge-launcher: 0.2.0
+      connect: 3.7.0
+      debug: 2.6.9
+      invariant: 2.2.4
+      nullthrows: 1.1.1
+      open: 7.4.2
+      serve-static: 1.16.2
+      ws: 6.2.3
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  '@react-native/gradle-plugin@0.79.6': {}
+
+  '@react-native/js-polyfills@0.79.6': {}
+
+  '@react-native/normalize-colors@0.79.6': {}
+
+  '@react-native/virtualized-lists@0.79.6(@types/react@19.2.7)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)':
+    dependencies:
+      invariant: 2.2.4
+      nullthrows: 1.1.1
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+    optionalDependencies:
+      '@types/react': 19.2.7
+
+  '@react-navigation/bottom-tabs@7.9.1(@react-navigation/native@7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-safe-area-context@5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-screens@4.11.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)':
+    dependencies:
+      '@react-navigation/elements': 2.9.4(@react-navigation/native@7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-safe-area-context@5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      '@react-navigation/native': 7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      color: 4.2.3
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+      react-native-safe-area-context: 5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      react-native-screens: 4.11.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      sf-symbols-typescript: 2.2.0
+    transitivePeerDependencies:
+      - '@react-native-masked-view/masked-view'
+
+  '@react-navigation/core@7.13.7(react@19.2.3)':
+    dependencies:
+      '@react-navigation/routers': 7.5.3
+      escape-string-regexp: 4.0.0
+      fast-deep-equal: 3.1.3
+      nanoid: 3.3.11
+      query-string: 7.1.3
+      react: 19.2.3
+      react-is: 19.2.3
+      use-latest-callback: 0.2.6(react@19.2.3)
+      use-sync-external-store: 1.6.0(react@19.2.3)
+
+  '@react-navigation/elements@2.9.4(@react-navigation/native@7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-safe-area-context@5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)':
+    dependencies:
+      '@react-navigation/native': 7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      color: 4.2.3
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+      react-native-safe-area-context: 5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      use-latest-callback: 0.2.6(react@19.2.3)
+      use-sync-external-store: 1.6.0(react@19.2.3)
+
+  '@react-navigation/native-stack@7.9.1(@react-navigation/native@7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-safe-area-context@5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-screens@4.11.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)':
+    dependencies:
+      '@react-navigation/elements': 2.9.4(@react-navigation/native@7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-safe-area-context@5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      '@react-navigation/native': 7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      color: 4.2.3
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+      react-native-safe-area-context: 5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      react-native-screens: 4.11.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      sf-symbols-typescript: 2.2.0
+      warn-once: 0.1.1
+    transitivePeerDependencies:
+      - '@react-native-masked-view/masked-view'
+
+  '@react-navigation/native@7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)':
+    dependencies:
+      '@react-navigation/core': 7.13.7(react@19.2.3)
+      escape-string-regexp: 4.0.0
+      fast-deep-equal: 3.1.3
+      nanoid: 3.3.11
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+      use-latest-callback: 0.2.6(react@19.2.3)
 
-  '@rolldown/pluginutils@1.0.0-beta.38': {}
+  '@react-navigation/routers@7.5.3':
+    dependencies:
+      nanoid: 3.3.11
 
   '@rolldown/pluginutils@1.0.0-beta.40': {}
 
+  '@rolldown/pluginutils@1.0.0-beta.53': {}
+
   '@rollup/pluginutils@5.3.0(rollup@4.52.5)':
     dependencies:
       '@types/estree': 1.0.8
@@ -10834,10 +14015,10 @@ snapshots:
     transitivePeerDependencies:
       - '@types/node'
 
-  '@schematics/angular@20.3.6(chokidar@4.0.3)':
+  '@schematics/angular@20.3.13(chokidar@4.0.3)':
     dependencies:
-      '@angular-devkit/core': 20.3.6(chokidar@4.0.3)
-      '@angular-devkit/schematics': 20.3.6(chokidar@4.0.3)
+      '@angular-devkit/core': 20.3.13(chokidar@4.0.3)
+      '@angular-devkit/schematics': 20.3.13(chokidar@4.0.3)
       jsonc-parser: 3.3.1
     transitivePeerDependencies:
       - chokidar
@@ -10894,195 +14075,194 @@ snapshots:
       '@sigstore/core': 2.0.0
       '@sigstore/protobuf-specs': 0.4.3
 
-  '@simplewebauthn/browser@13.1.2': {}
+  '@simplewebauthn/browser@13.2.2': {}
 
-  '@simplewebauthn/server@13.1.2':
+  '@simplewebauthn/server@13.2.2':
     dependencies:
       '@hexagon/base64': 1.1.28
       '@levischuck/tiny-cbor': 0.2.11
-      '@peculiar/asn1-android': 2.5.0
-      '@peculiar/asn1-ecc': 2.5.0
-      '@peculiar/asn1-rsa': 2.5.0
-      '@peculiar/asn1-schema': 2.5.0
-      '@peculiar/asn1-x509': 2.5.0
+      '@peculiar/asn1-android': 2.6.0
+      '@peculiar/asn1-ecc': 2.6.0
+      '@peculiar/asn1-rsa': 2.6.0
+      '@peculiar/asn1-schema': 2.6.0
+      '@peculiar/asn1-x509': 2.6.0
+      '@peculiar/x509': 1.14.2
+
+  '@sinclair/typebox@0.27.8': {}
+
+  '@sinonjs/commons@3.0.1':
+    dependencies:
+      type-detect: 4.0.8
+
+  '@sinonjs/fake-timers@10.3.0':
+    dependencies:
+      '@sinonjs/commons': 3.0.1
 
   '@socket.io/component-emitter@3.1.2': {}
 
-  '@solid-devtools/debugger@0.28.1(solid-js@1.9.9)':
+  '@solid-devtools/debugger@0.28.1(solid-js@1.9.10)':
     dependencies:
       '@nothing-but/utils': 0.17.0
-      '@solid-devtools/shared': 0.20.0(solid-js@1.9.9)
-      '@solid-primitives/bounds': 0.1.3(solid-js@1.9.9)
-      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.9)
-      '@solid-primitives/keyboard': 1.3.3(solid-js@1.9.9)
-      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.9)
-      '@solid-primitives/scheduled': 1.5.2(solid-js@1.9.9)
-      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.9)
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
-
-  '@solid-devtools/logger@0.9.11(solid-js@1.9.9)':
+      '@solid-devtools/shared': 0.20.0(solid-js@1.9.10)
+      '@solid-primitives/bounds': 0.1.3(solid-js@1.9.10)
+      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.10)
+      '@solid-primitives/keyboard': 1.3.3(solid-js@1.9.10)
+      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.10)
+      '@solid-primitives/scheduled': 1.5.2(solid-js@1.9.10)
+      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.10)
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
+
+  '@solid-devtools/logger@0.9.11(solid-js@1.9.10)':
     dependencies:
       '@nothing-but/utils': 0.17.0
-      '@solid-devtools/debugger': 0.28.1(solid-js@1.9.9)
-      '@solid-devtools/shared': 0.20.0(solid-js@1.9.9)
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-devtools/debugger': 0.28.1(solid-js@1.9.10)
+      '@solid-devtools/shared': 0.20.0(solid-js@1.9.10)
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-devtools/shared@0.20.0(solid-js@1.9.9)':
+  '@solid-devtools/shared@0.20.0(solid-js@1.9.10)':
     dependencies:
       '@nothing-but/utils': 0.17.0
-      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.9)
-      '@solid-primitives/media': 2.3.3(solid-js@1.9.9)
-      '@solid-primitives/refs': 1.1.2(solid-js@1.9.9)
-      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.9)
-      '@solid-primitives/scheduled': 1.5.2(solid-js@1.9.9)
-      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.9)
-      '@solid-primitives/styles': 0.1.2(solid-js@1.9.9)
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.10)
+      '@solid-primitives/media': 2.3.3(solid-js@1.9.10)
+      '@solid-primitives/refs': 1.1.2(solid-js@1.9.10)
+      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.10)
+      '@solid-primitives/scheduled': 1.5.2(solid-js@1.9.10)
+      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.10)
+      '@solid-primitives/styles': 0.1.2(solid-js@1.9.10)
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/bounds@0.1.3(solid-js@1.9.9)':
+  '@solid-primitives/bounds@0.1.3(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.9)
-      '@solid-primitives/resize-observer': 2.1.3(solid-js@1.9.9)
-      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.9)
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.10)
+      '@solid-primitives/resize-observer': 2.1.3(solid-js@1.9.10)
+      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.10)
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/event-listener@2.4.3(solid-js@1.9.9)':
+  '@solid-primitives/event-listener@2.4.3(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/keyboard@1.3.3(solid-js@1.9.9)':
+  '@solid-primitives/keyboard@1.3.3(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.9)
-      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.9)
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.10)
+      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.10)
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/map@0.7.2(solid-js@1.9.9)':
+  '@solid-primitives/map@0.7.2(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/trigger': 1.2.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/trigger': 1.2.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/media@2.3.3(solid-js@1.9.9)':
+  '@solid-primitives/media@2.3.3(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.9)
-      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.9)
-      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.9)
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.10)
+      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.10)
+      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.10)
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/refs@1.1.2(solid-js@1.9.9)':
+  '@solid-primitives/refs@1.1.2(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/resize-observer@2.1.3(solid-js@1.9.9)':
+  '@solid-primitives/resize-observer@2.1.3(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.9)
-      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.9)
-      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.9)
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/event-listener': 2.4.3(solid-js@1.9.10)
+      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.10)
+      '@solid-primitives/static-store': 0.1.2(solid-js@1.9.10)
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/rootless@1.5.2(solid-js@1.9.9)':
+  '@solid-primitives/rootless@1.5.2(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/scheduled@1.5.2(solid-js@1.9.9)':
+  '@solid-primitives/scheduled@1.5.2(solid-js@1.9.10)':
     dependencies:
-      solid-js: 1.9.9
+      solid-js: 1.9.10
 
-  '@solid-primitives/static-store@0.1.2(solid-js@1.9.9)':
+  '@solid-primitives/static-store@0.1.2(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/styles@0.1.2(solid-js@1.9.9)':
+  '@solid-primitives/styles@0.1.2(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.9)
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/rootless': 1.5.2(solid-js@1.9.10)
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/trigger@1.2.2(solid-js@1.9.9)':
+  '@solid-primitives/trigger@1.2.2(solid-js@1.9.10)':
     dependencies:
-      '@solid-primitives/utils': 6.3.2(solid-js@1.9.9)
-      solid-js: 1.9.9
+      '@solid-primitives/utils': 6.3.2(solid-js@1.9.10)
+      solid-js: 1.9.10
 
-  '@solid-primitives/utils@6.3.2(solid-js@1.9.9)':
+  '@solid-primitives/utils@6.3.2(solid-js@1.9.10)':
     dependencies:
-      solid-js: 1.9.9
+      solid-js: 1.9.10
 
-  '@solidjs/meta@0.29.4(solid-js@1.9.9)':
+  '@solidjs/meta@0.29.4(solid-js@1.9.10)':
     dependencies:
-      solid-js: 1.9.9
+      solid-js: 1.9.10
 
-  '@solidjs/testing-library@0.8.10(solid-js@1.9.9)':
+  '@solidjs/testing-library@0.8.10(solid-js@1.9.10)':
     dependencies:
       '@testing-library/dom': 10.4.1
-      solid-js: 1.9.9
+      solid-js: 1.9.10
 
-  '@standard-schema/spec@1.0.0': {}
-
-  '@stylistic/eslint-plugin@4.4.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
-    dependencies:
-      '@typescript-eslint/utils': 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      eslint: 9.38.0(jiti@2.6.0)
-      eslint-visitor-keys: 4.2.1
-      espree: 10.4.0
-      estraverse: 5.3.0
-      picomatch: 4.0.3
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
+  '@standard-schema/spec@1.1.0': {}
 
-  '@stylistic/eslint-plugin@5.4.0(eslint@9.38.0(jiti@2.6.0))':
+  '@stylistic/eslint-plugin@5.4.0(eslint@9.39.2(jiti@2.6.1))':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0(jiti@2.6.0))
-      '@typescript-eslint/types': 8.46.1
-      eslint: 9.38.0(jiti@2.6.0)
+      '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.2(jiti@2.6.1))
+      '@typescript-eslint/types': 8.51.0
+      eslint: 9.39.2(jiti@2.6.1)
       eslint-visitor-keys: 4.2.1
       espree: 10.4.0
       estraverse: 5.3.0
       picomatch: 4.0.3
 
-  '@sveltejs/acorn-typescript@1.0.5(acorn@8.15.0)':
+  '@sveltejs/acorn-typescript@1.0.8(acorn@8.15.0)':
     dependencies:
       acorn: 8.15.0
 
-  '@sveltejs/package@2.5.4(svelte@5.41.0)(typescript@5.9.3)':
+  '@sveltejs/package@2.5.7(svelte@5.46.4)(typescript@5.9.3)':
     dependencies:
-      chokidar: 4.0.3
+      chokidar: 5.0.0
       kleur: 4.1.5
       sade: 1.8.1
       semver: 7.7.3
-      svelte: 5.41.0
-      svelte2tsx: 0.7.42(svelte@5.41.0)(typescript@5.9.3)
+      svelte: 5.46.4
+      svelte2tsx: 0.7.42(svelte@5.46.4)(typescript@5.9.3)
     transitivePeerDependencies:
       - typescript
 
-  '@sveltejs/vite-plugin-svelte-inspector@5.0.1(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.41.0)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(svelte@5.41.0)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@sveltejs/vite-plugin-svelte-inspector@5.0.1(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.4)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(svelte@5.46.4)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
     dependencies:
-      '@sveltejs/vite-plugin-svelte': 6.2.1(svelte@5.41.0)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      '@sveltejs/vite-plugin-svelte': 6.2.1(svelte@5.46.4)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       debug: 4.4.3
-      svelte: 5.41.0
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      svelte: 5.46.4
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
     transitivePeerDependencies:
       - supports-color
 
-  '@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.41.0)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.4)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
     dependencies:
-      '@sveltejs/vite-plugin-svelte-inspector': 5.0.1(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.41.0)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(svelte@5.41.0)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      '@sveltejs/vite-plugin-svelte-inspector': 5.0.1(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.4)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(svelte@5.46.4)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       debug: 4.4.3
       deepmerge: 4.3.1
-      magic-string: 0.30.19
-      svelte: 5.41.0
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vitefu: 1.1.1(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      magic-string: 0.30.21
+      svelte: 5.46.4
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+      vitefu: 1.1.1(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
     transitivePeerDependencies:
       - supports-color
 
@@ -11093,90 +14273,88 @@ snapshots:
     transitivePeerDependencies:
       - encoding
 
-  '@tailwindcss/node@4.1.14':
+  '@tailwindcss/node@4.1.18':
     dependencies:
       '@jridgewell/remapping': 2.3.5
       enhanced-resolve: 5.18.3
-      jiti: 2.6.0
-      lightningcss: 1.30.1
-      magic-string: 0.30.19
+      jiti: 2.6.1
+      lightningcss: 1.30.2
+      magic-string: 0.30.21
       source-map-js: 1.2.1
-      tailwindcss: 4.1.14
+      tailwindcss: 4.1.18
 
-  '@tailwindcss/oxide-android-arm64@4.1.14':
+  '@tailwindcss/oxide-android-arm64@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-darwin-arm64@4.1.14':
+  '@tailwindcss/oxide-darwin-arm64@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-darwin-x64@4.1.14':
+  '@tailwindcss/oxide-darwin-x64@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-freebsd-x64@4.1.14':
+  '@tailwindcss/oxide-freebsd-x64@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.14':
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-linux-arm64-gnu@4.1.14':
+  '@tailwindcss/oxide-linux-arm64-gnu@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-linux-arm64-musl@4.1.14':
+  '@tailwindcss/oxide-linux-arm64-musl@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-linux-x64-gnu@4.1.14':
+  '@tailwindcss/oxide-linux-x64-gnu@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-linux-x64-musl@4.1.14':
+  '@tailwindcss/oxide-linux-x64-musl@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-wasm32-wasi@4.1.14':
+  '@tailwindcss/oxide-wasm32-wasi@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-win32-arm64-msvc@4.1.14':
+  '@tailwindcss/oxide-win32-arm64-msvc@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide-win32-x64-msvc@4.1.14':
+  '@tailwindcss/oxide-win32-x64-msvc@4.1.18':
     optional: true
 
-  '@tailwindcss/oxide@4.1.14':
-    dependencies:
-      detect-libc: 2.0.4
-      tar: 7.5.1
+  '@tailwindcss/oxide@4.1.18':
     optionalDependencies:
-      '@tailwindcss/oxide-android-arm64': 4.1.14
-      '@tailwindcss/oxide-darwin-arm64': 4.1.14
-      '@tailwindcss/oxide-darwin-x64': 4.1.14
-      '@tailwindcss/oxide-freebsd-x64': 4.1.14
-      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.1.14
-      '@tailwindcss/oxide-linux-arm64-gnu': 4.1.14
-      '@tailwindcss/oxide-linux-arm64-musl': 4.1.14
-      '@tailwindcss/oxide-linux-x64-gnu': 4.1.14
-      '@tailwindcss/oxide-linux-x64-musl': 4.1.14
-      '@tailwindcss/oxide-wasm32-wasi': 4.1.14
-      '@tailwindcss/oxide-win32-arm64-msvc': 4.1.14
-      '@tailwindcss/oxide-win32-x64-msvc': 4.1.14
-
-  '@tailwindcss/vite@4.1.14(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
-    dependencies:
-      '@tailwindcss/node': 4.1.14
-      '@tailwindcss/oxide': 4.1.14
-      tailwindcss: 4.1.14
-      vite: 6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-
-  '@tailwindcss/vite@4.1.14(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
-    dependencies:
-      '@tailwindcss/node': 4.1.14
-      '@tailwindcss/oxide': 4.1.14
-      tailwindcss: 4.1.14
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-
-  '@tanstack/config@0.22.0(@types/node@24.7.0)(@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(rollup@4.52.5)(typescript@5.9.3)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
-    dependencies:
-      '@tanstack/eslint-config': 0.3.2(@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      '@tanstack/publish-config': 0.2.1
-      '@tanstack/typedoc-config': 0.3.0(typescript@5.9.3)
-      '@tanstack/vite-config': 0.4.0(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      '@tailwindcss/oxide-android-arm64': 4.1.18
+      '@tailwindcss/oxide-darwin-arm64': 4.1.18
+      '@tailwindcss/oxide-darwin-x64': 4.1.18
+      '@tailwindcss/oxide-freebsd-x64': 4.1.18
+      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.1.18
+      '@tailwindcss/oxide-linux-arm64-gnu': 4.1.18
+      '@tailwindcss/oxide-linux-arm64-musl': 4.1.18
+      '@tailwindcss/oxide-linux-x64-gnu': 4.1.18
+      '@tailwindcss/oxide-linux-x64-musl': 4.1.18
+      '@tailwindcss/oxide-wasm32-wasi': 4.1.18
+      '@tailwindcss/oxide-win32-arm64-msvc': 4.1.18
+      '@tailwindcss/oxide-win32-x64-msvc': 4.1.18
+
+  '@tailwindcss/postcss@4.1.18':
+    dependencies:
+      '@alloc/quick-lru': 5.2.0
+      '@tailwindcss/node': 4.1.18
+      '@tailwindcss/oxide': 4.1.18
+      postcss: 8.5.6
+      tailwindcss: 4.1.18
+
+  '@tailwindcss/vite@4.1.18(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
+    dependencies:
+      '@tailwindcss/node': 4.1.18
+      '@tailwindcss/oxide': 4.1.18
+      tailwindcss: 4.1.18
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+
+  '@tanstack/config@0.22.2(@types/node@24.7.0)(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(rollup@4.52.5)(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
+    dependencies:
+      '@tanstack/eslint-config': 0.3.3(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@tanstack/publish-config': 0.2.2
+      '@tanstack/typedoc-config': 0.3.2(typescript@5.9.3)
+      '@tanstack/vite-config': 0.4.1(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
     transitivePeerDependencies:
       - '@types/node'
       - '@typescript-eslint/utils'
@@ -11187,148 +14365,124 @@ snapshots:
       - typescript
       - vite
 
-  '@tanstack/directive-functions-plugin@1.133.9(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@tanstack/eslint-config@0.3.3(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/core': 7.28.4
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
-      '@tanstack/router-utils': 1.133.3
-      babel-dead-code-elimination: 1.0.10
-      pathe: 2.0.3
-      tiny-invariant: 1.3.3
-      vite: 6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-    transitivePeerDependencies:
-      - supports-color
-
-  '@tanstack/directive-functions-plugin@1.133.9(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
-    dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/core': 7.28.4
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
-      '@tanstack/router-utils': 1.133.3
-      babel-dead-code-elimination: 1.0.10
-      pathe: 2.0.3
-      tiny-invariant: 1.3.3
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      '@eslint/js': 9.39.2
+      '@stylistic/eslint-plugin': 5.4.0(eslint@9.39.2(jiti@2.6.1))
+      eslint-plugin-import-x: 4.16.1(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))
+      eslint-plugin-n: 17.23.1(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      globals: 16.5.0
+      typescript-eslint: 8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      vue-eslint-parser: 10.2.0(eslint@9.39.2(jiti@2.6.1))
     transitivePeerDependencies:
+      - '@typescript-eslint/utils'
+      - eslint
+      - eslint-import-resolver-node
       - supports-color
+      - typescript
 
-  '@tanstack/eslint-config@0.3.2(@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
+  '@tanstack/eslint-config@0.3.4(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
-      '@eslint/js': 9.38.0
-      '@stylistic/eslint-plugin': 5.4.0(eslint@9.38.0(jiti@2.6.0))
-      eslint-plugin-import-x: 4.16.1(@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))
-      eslint-plugin-n: 17.23.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      globals: 16.4.0
-      typescript-eslint: 8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      vue-eslint-parser: 10.2.0(eslint@9.38.0(jiti@2.6.0))
+      '@eslint/js': 9.39.2
+      '@stylistic/eslint-plugin': 5.4.0(eslint@9.39.2(jiti@2.6.1))
+      eslint: 9.39.2(jiti@2.6.1)
+      eslint-plugin-import-x: 4.16.1(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))
+      eslint-plugin-n: 17.23.1(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      globals: 16.5.0
+      typescript-eslint: 8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      vue-eslint-parser: 10.2.0(eslint@9.39.2(jiti@2.6.1))
     transitivePeerDependencies:
       - '@typescript-eslint/utils'
-      - eslint
       - eslint-import-resolver-node
       - supports-color
       - typescript
 
-  '@tanstack/history@1.133.3': {}
+  '@tanstack/history@1.141.0': {}
+
+  '@tanstack/pacer-lite@0.2.0': {}
 
-  '@tanstack/publish-config@0.2.1':
+  '@tanstack/publish-config@0.2.2':
     dependencies:
-      '@commitlint/parse': 19.8.1
+      '@commitlint/parse': 20.2.0
       jsonfile: 6.2.0
       semver: 7.7.3
-      simple-git: 3.28.0
+      simple-git: 3.30.0
     transitivePeerDependencies:
       - supports-color
 
-  '@tanstack/query-core@5.83.0': {}
+  '@tanstack/query-core@5.90.16': {}
 
-  '@tanstack/query-core@5.90.5': {}
-
-  '@tanstack/react-query@5.83.0(react@19.2.0)':
+  '@tanstack/react-query@5.90.16(react@19.2.3)':
     dependencies:
-      '@tanstack/query-core': 5.83.0
-      react: 19.2.0
+      '@tanstack/query-core': 5.90.16
+      react: 19.2.3
 
-  '@tanstack/react-router-devtools@1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(@tanstack/router-core@1.133.15)(@types/node@24.7.0)(csstype@3.1.3)(jiti@2.6.0)(lightningcss@1.30.1)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)(sass@1.90.0)(solid-js@1.9.9)(terser@5.44.0)(tiny-invariant@1.3.3)(tsx@4.20.6)(yaml@2.8.1)':
+  '@tanstack/react-router-devtools@1.144.0(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(@tanstack/router-core@1.144.0)(csstype@3.2.3)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)':
     dependencies:
-      '@tanstack/react-router': 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@tanstack/router-devtools-core': 1.133.15(@tanstack/router-core@1.133.15)(@types/node@24.7.0)(csstype@3.1.3)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(solid-js@1.9.9)(terser@5.44.0)(tiny-invariant@1.3.3)(tsx@4.20.6)(yaml@2.8.1)
-      react: 19.2.0
-      react-dom: 19.2.0(react@19.2.0)
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      '@tanstack/react-router': 1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@tanstack/router-devtools-core': 1.144.0(@tanstack/router-core@1.144.0)(csstype@3.2.3)(solid-js@1.9.10)
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
+    optionalDependencies:
+      '@tanstack/router-core': 1.144.0
     transitivePeerDependencies:
-      - '@tanstack/router-core'
-      - '@types/node'
       - csstype
-      - jiti
-      - less
-      - lightningcss
-      - sass
-      - sass-embedded
       - solid-js
-      - stylus
-      - sugarss
-      - terser
-      - tiny-invariant
-      - tsx
-      - yaml
 
-  '@tanstack/react-router-with-query@1.130.17(@tanstack/react-query@5.83.0(react@19.2.0))(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(@tanstack/router-core@1.133.15)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@tanstack/react-router-with-query@1.130.17(@tanstack/react-query@5.90.16(react@19.2.3))(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(@tanstack/router-core@1.144.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)':
     dependencies:
-      '@tanstack/react-query': 5.83.0(react@19.2.0)
-      '@tanstack/react-router': 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@tanstack/router-core': 1.133.15
-      react: 19.2.0
-      react-dom: 19.2.0(react@19.2.0)
+      '@tanstack/react-query': 5.90.16(react@19.2.3)
+      '@tanstack/react-router': 1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@tanstack/router-core': 1.144.0
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
 
-  '@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)':
     dependencies:
-      '@tanstack/history': 1.133.3
-      '@tanstack/react-store': 0.7.5(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@tanstack/router-core': 1.133.15
+      '@tanstack/history': 1.141.0
+      '@tanstack/react-store': 0.8.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@tanstack/router-core': 1.144.0
       isbot: 5.1.30
-      react: 19.2.0
-      react-dom: 19.2.0(react@19.2.0)
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
       tiny-invariant: 1.3.3
       tiny-warning: 1.0.3
 
-  '@tanstack/react-start-client@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@tanstack/react-start-client@1.145.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)':
     dependencies:
-      '@tanstack/react-router': 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/start-client-core': 1.133.15
-      react: 19.2.0
-      react-dom: 19.2.0(react@19.2.0)
+      '@tanstack/react-router': 1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/start-client-core': 1.145.0
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
       tiny-invariant: 1.3.3
       tiny-warning: 1.0.3
 
-  '@tanstack/react-start-server@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@tanstack/react-start-server@1.145.5(react-dom@19.2.3(react@19.2.3))(react@19.2.3)':
     dependencies:
-      '@tanstack/history': 1.133.3
-      '@tanstack/react-router': 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/start-client-core': 1.133.15
-      '@tanstack/start-server-core': 1.133.15
-      react: 19.2.0
-      react-dom: 19.2.0(react@19.2.0)
+      '@tanstack/history': 1.141.0
+      '@tanstack/react-router': 1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/start-client-core': 1.145.0
+      '@tanstack/start-server-core': 1.145.5
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
     transitivePeerDependencies:
       - crossws
 
-  '@tanstack/react-start@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@tanstack/react-start@1.145.5(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
     dependencies:
-      '@tanstack/react-router': 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@tanstack/react-start-client': 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@tanstack/react-start-server': 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@tanstack/router-utils': 1.133.3
-      '@tanstack/start-client-core': 1.133.15
-      '@tanstack/start-plugin-core': 1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      '@tanstack/start-server-core': 1.133.15
+      '@tanstack/react-router': 1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@tanstack/react-start-client': 1.145.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@tanstack/react-start-server': 1.145.5(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@tanstack/router-utils': 1.143.11
+      '@tanstack/start-client-core': 1.145.0
+      '@tanstack/start-plugin-core': 1.145.5(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      '@tanstack/start-server-core': 1.145.5
       pathe: 2.0.3
-      react: 19.2.0
-      react-dom: 19.2.0(react@19.2.0)
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
     transitivePeerDependencies:
       - '@rsbuild/core'
       - crossws
@@ -11336,111 +14490,74 @@ snapshots:
       - vite-plugin-solid
       - webpack
 
-  '@tanstack/react-store@0.7.5(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@tanstack/react-store@0.8.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)':
     dependencies:
-      '@tanstack/store': 0.7.5
-      react: 19.2.0
-      react-dom: 19.2.0(react@19.2.0)
-      use-sync-external-store: 1.6.0(react@19.2.0)
+      '@tanstack/store': 0.8.0
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
+      use-sync-external-store: 1.6.0(react@19.2.3)
 
-  '@tanstack/router-core@1.133.15':
+  '@tanstack/router-core@1.144.0':
     dependencies:
-      '@tanstack/history': 1.133.3
-      '@tanstack/store': 0.7.7
+      '@tanstack/history': 1.141.0
+      '@tanstack/store': 0.8.0
       cookie-es: 2.0.0
-      seroval: 1.3.2
-      seroval-plugins: 1.3.3(seroval@1.3.2)
+      seroval: 1.4.2
+      seroval-plugins: 1.4.0(seroval@1.4.2)
       tiny-invariant: 1.3.3
       tiny-warning: 1.0.3
 
-  '@tanstack/router-devtools-core@1.133.15(@tanstack/router-core@1.133.15)(@types/node@24.7.0)(csstype@3.1.3)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(solid-js@1.9.9)(terser@5.44.0)(tiny-invariant@1.3.3)(tsx@4.20.6)(yaml@2.8.1)':
+  '@tanstack/router-devtools-core@1.144.0(@tanstack/router-core@1.144.0)(csstype@3.2.3)(solid-js@1.9.10)':
     dependencies:
-      '@tanstack/router-core': 1.133.15
+      '@tanstack/router-core': 1.144.0
       clsx: 2.1.1
-      goober: 2.1.16(csstype@3.1.3)
-      solid-js: 1.9.9
+      goober: 2.1.16(csstype@3.2.3)
+      solid-js: 1.9.10
       tiny-invariant: 1.3.3
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
     optionalDependencies:
-      csstype: 3.1.3
-    transitivePeerDependencies:
-      - '@types/node'
-      - jiti
-      - less
-      - lightningcss
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - terser
-      - tsx
-      - yaml
+      csstype: 3.2.3
 
-  '@tanstack/router-generator@1.133.15':
+  '@tanstack/router-generator@1.145.4':
     dependencies:
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/router-utils': 1.133.3
-      '@tanstack/virtual-file-routes': 1.133.3
-      prettier: 3.6.2
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/router-utils': 1.143.11
+      '@tanstack/virtual-file-routes': 1.145.4
+      prettier: 3.7.4
       recast: 0.23.11
       source-map: 0.7.6
-      tsx: 4.20.6
-      zod: 3.25.76
-    transitivePeerDependencies:
-      - supports-color
-
-  '@tanstack/router-plugin@1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
-    dependencies:
-      '@babel/core': 7.28.4
-      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.4)
-      '@babel/plugin-syntax-typescript': 7.27.1(@babel/core@7.28.4)
-      '@babel/template': 7.27.2
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/router-generator': 1.133.15
-      '@tanstack/router-utils': 1.133.3
-      '@tanstack/virtual-file-routes': 1.133.3
-      babel-dead-code-elimination: 1.0.10
-      chokidar: 3.6.0
-      unplugin: 2.3.10
+      tsx: 4.21.0
       zod: 3.25.76
-    optionalDependencies:
-      '@tanstack/react-router': 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      vite: 6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vite-plugin-solid: 2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
     transitivePeerDependencies:
       - supports-color
 
-  '@tanstack/router-plugin@1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
-    dependencies:
-      '@babel/core': 7.28.4
-      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.4)
-      '@babel/plugin-syntax-typescript': 7.27.1(@babel/core@7.28.4)
-      '@babel/template': 7.27.2
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/router-generator': 1.133.15
-      '@tanstack/router-utils': 1.133.3
-      '@tanstack/virtual-file-routes': 1.133.3
-      babel-dead-code-elimination: 1.0.10
+  '@tanstack/router-plugin@1.145.4(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/plugin-syntax-jsx': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-syntax-typescript': 7.28.6(@babel/core@7.28.5)
+      '@babel/template': 7.28.6
+      '@babel/traverse': 7.28.6
+      '@babel/types': 7.28.6
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/router-generator': 1.145.4
+      '@tanstack/router-utils': 1.143.11
+      '@tanstack/virtual-file-routes': 1.145.4
+      babel-dead-code-elimination: 1.0.11
       chokidar: 3.6.0
       unplugin: 2.3.10
       zod: 3.25.76
     optionalDependencies:
-      '@tanstack/react-router': 1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vite-plugin-solid: 2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      '@tanstack/react-router': 1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+      vite-plugin-solid: 2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
     transitivePeerDependencies:
       - supports-color
 
-  '@tanstack/router-utils@1.133.3':
+  '@tanstack/router-utils@1.143.11':
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/generator': 7.28.3
-      '@babel/parser': 7.28.4
-      '@babel/preset-typescript': 7.27.1(@babel/core@7.28.4)
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.6
+      '@babel/parser': 7.28.6
       ansis: 4.1.0
       diff: 8.0.2
       pathe: 2.0.3
@@ -11448,83 +14565,51 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@tanstack/server-functions-plugin@1.133.11(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
-    dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/core': 7.28.4
-      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.4)
-      '@babel/plugin-syntax-typescript': 7.27.1(@babel/core@7.28.4)
-      '@babel/template': 7.27.2
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
-      '@tanstack/directive-functions-plugin': 1.133.9(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      babel-dead-code-elimination: 1.0.10
-      tiny-invariant: 1.3.3
-    transitivePeerDependencies:
-      - supports-color
-      - vite
-
-  '@tanstack/server-functions-plugin@1.133.11(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
-    dependencies:
-      '@babel/code-frame': 7.27.1
-      '@babel/core': 7.28.4
-      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.4)
-      '@babel/plugin-syntax-typescript': 7.27.1(@babel/core@7.28.4)
-      '@babel/template': 7.27.2
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
-      '@tanstack/directive-functions-plugin': 1.133.9(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      babel-dead-code-elimination: 1.0.10
-      tiny-invariant: 1.3.3
-    transitivePeerDependencies:
-      - supports-color
-      - vite
-
-  '@tanstack/solid-router@1.133.15(solid-js@1.9.9)':
+  '@tanstack/solid-router@1.144.0(solid-js@1.9.10)':
     dependencies:
-      '@solid-devtools/logger': 0.9.11(solid-js@1.9.9)
-      '@solid-primitives/refs': 1.1.2(solid-js@1.9.9)
-      '@solidjs/meta': 0.29.4(solid-js@1.9.9)
-      '@tanstack/history': 1.133.3
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/solid-store': 0.7.0(solid-js@1.9.9)
+      '@solid-devtools/logger': 0.9.11(solid-js@1.9.10)
+      '@solid-primitives/refs': 1.1.2(solid-js@1.9.10)
+      '@solidjs/meta': 0.29.4(solid-js@1.9.10)
+      '@tanstack/history': 1.141.0
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/solid-store': 0.8.0(solid-js@1.9.10)
       isbot: 5.1.30
-      solid-js: 1.9.9
+      solid-js: 1.9.10
       tiny-invariant: 1.3.3
       tiny-warning: 1.0.3
 
-  '@tanstack/solid-start-client@1.133.15(solid-js@1.9.9)':
+  '@tanstack/solid-start-client@1.145.0(solid-js@1.9.10)':
     dependencies:
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/solid-router': 1.133.15(solid-js@1.9.9)
-      '@tanstack/start-client-core': 1.133.15
-      solid-js: 1.9.9
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/solid-router': 1.144.0(solid-js@1.9.10)
+      '@tanstack/start-client-core': 1.145.0
+      solid-js: 1.9.10
       tiny-invariant: 1.3.3
       tiny-warning: 1.0.3
 
-  '@tanstack/solid-start-server@1.133.15(solid-js@1.9.9)':
+  '@tanstack/solid-start-server@1.145.5(solid-js@1.9.10)':
     dependencies:
-      '@solidjs/meta': 0.29.4(solid-js@1.9.9)
-      '@tanstack/history': 1.133.3
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/solid-router': 1.133.15(solid-js@1.9.9)
-      '@tanstack/start-client-core': 1.133.15
-      '@tanstack/start-server-core': 1.133.15
-      solid-js: 1.9.9
+      '@solidjs/meta': 0.29.4(solid-js@1.9.10)
+      '@tanstack/history': 1.141.0
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/solid-router': 1.144.0(solid-js@1.9.10)
+      '@tanstack/start-client-core': 1.145.0
+      '@tanstack/start-server-core': 1.145.5
+      solid-js: 1.9.10
     transitivePeerDependencies:
       - crossws
 
-  '@tanstack/solid-start@1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(solid-js@1.9.9)(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@tanstack/solid-start@1.145.5(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(solid-js@1.9.10)(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
     dependencies:
-      '@tanstack/solid-router': 1.133.15(solid-js@1.9.9)
-      '@tanstack/solid-start-client': 1.133.15(solid-js@1.9.9)
-      '@tanstack/solid-start-server': 1.133.15(solid-js@1.9.9)
-      '@tanstack/start-client-core': 1.133.15
-      '@tanstack/start-plugin-core': 1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      '@tanstack/start-server-core': 1.133.15
+      '@tanstack/solid-router': 1.144.0(solid-js@1.9.10)
+      '@tanstack/solid-start-client': 1.145.0(solid-js@1.9.10)
+      '@tanstack/solid-start-server': 1.145.5(solid-js@1.9.10)
+      '@tanstack/start-client-core': 1.145.0
+      '@tanstack/start-plugin-core': 1.145.5(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      '@tanstack/start-server-core': 1.145.5
       pathe: 2.0.3
-      solid-js: 1.9.9
-      vite: 6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      solid-js: 1.9.10
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
     transitivePeerDependencies:
       - '@rsbuild/core'
       - '@tanstack/react-router'
@@ -11533,74 +14618,44 @@ snapshots:
       - vite-plugin-solid
       - webpack
 
-  '@tanstack/solid-store@0.7.0(solid-js@1.9.9)':
+  '@tanstack/solid-store@0.8.0(solid-js@1.9.10)':
     dependencies:
-      '@tanstack/store': 0.7.0
-      solid-js: 1.9.9
+      '@tanstack/store': 0.8.0
+      solid-js: 1.9.10
 
-  '@tanstack/start-client-core@1.133.15':
+  '@tanstack/start-client-core@1.145.0':
     dependencies:
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/start-storage-context': 1.133.15
-      seroval: 1.3.2
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/start-fn-stubs': 1.143.8
+      '@tanstack/start-storage-context': 1.144.0
+      seroval: 1.4.2
       tiny-invariant: 1.3.3
       tiny-warning: 1.0.3
 
-  '@tanstack/start-plugin-core@1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
-    dependencies:
-      '@babel/code-frame': 7.26.2
-      '@babel/core': 7.28.4
-      '@babel/types': 7.28.4
-      '@rolldown/pluginutils': 1.0.0-beta.40
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/router-generator': 1.133.15
-      '@tanstack/router-plugin': 1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      '@tanstack/router-utils': 1.133.3
-      '@tanstack/server-functions-plugin': 1.133.11(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      '@tanstack/start-client-core': 1.133.15
-      '@tanstack/start-server-core': 1.133.15
-      babel-dead-code-elimination: 1.0.10
-      cheerio: 1.1.2
-      exsolve: 1.0.7
-      pathe: 2.0.3
-      srvx: 0.8.16
-      tinyglobby: 0.2.15
-      ufo: 1.6.1
-      vite: 6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vitefu: 1.1.1(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      xmlbuilder2: 3.1.1
-      zod: 3.25.76
-    transitivePeerDependencies:
-      - '@rsbuild/core'
-      - '@tanstack/react-router'
-      - crossws
-      - supports-color
-      - vite-plugin-solid
-      - webpack
+  '@tanstack/start-fn-stubs@1.143.8': {}
 
-  '@tanstack/start-plugin-core@1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@tanstack/start-plugin-core@1.145.5(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
     dependencies:
-      '@babel/code-frame': 7.26.2
-      '@babel/core': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/code-frame': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/types': 7.28.6
       '@rolldown/pluginutils': 1.0.0-beta.40
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/router-generator': 1.133.15
-      '@tanstack/router-plugin': 1.133.15(@tanstack/react-router@1.133.15(react-dom@19.2.0(react@19.2.0))(react@19.2.0))(vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)))(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      '@tanstack/router-utils': 1.133.3
-      '@tanstack/server-functions-plugin': 1.133.11(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      '@tanstack/start-client-core': 1.133.15
-      '@tanstack/start-server-core': 1.133.15
-      babel-dead-code-elimination: 1.0.10
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/router-generator': 1.145.4
+      '@tanstack/router-plugin': 1.145.4(@tanstack/react-router@1.144.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)))(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      '@tanstack/router-utils': 1.143.11
+      '@tanstack/start-client-core': 1.145.0
+      '@tanstack/start-server-core': 1.145.5
+      babel-dead-code-elimination: 1.0.11
       cheerio: 1.1.2
       exsolve: 1.0.7
       pathe: 2.0.3
-      srvx: 0.8.16
+      srvx: 0.10.1
       tinyglobby: 0.2.15
       ufo: 1.6.1
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vitefu: 1.1.1(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      xmlbuilder2: 3.1.1
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+      vitefu: 1.1.1(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      xmlbuilder2: 4.0.3
       zod: 3.25.76
     transitivePeerDependencies:
       - '@rsbuild/core'
@@ -11610,31 +14665,33 @@ snapshots:
       - vite-plugin-solid
       - webpack
 
-  '@tanstack/start-server-core@1.133.15':
+  '@tanstack/start-server-core@1.145.5':
     dependencies:
-      '@tanstack/history': 1.133.3
-      '@tanstack/router-core': 1.133.15
-      '@tanstack/start-client-core': 1.133.15
-      '@tanstack/start-storage-context': 1.133.15
-      h3-v2: h3@2.0.0-beta.4
-      seroval: 1.3.2
+      '@tanstack/history': 1.141.0
+      '@tanstack/router-core': 1.144.0
+      '@tanstack/start-client-core': 1.145.0
+      '@tanstack/start-storage-context': 1.144.0
+      h3-v2: h3@2.0.1-rc.7
+      seroval: 1.4.2
       tiny-invariant: 1.3.3
     transitivePeerDependencies:
       - crossws
 
-  '@tanstack/start-storage-context@1.133.15':
+  '@tanstack/start-storage-context@1.144.0':
     dependencies:
-      '@tanstack/router-core': 1.133.15
-
-  '@tanstack/store@0.7.0': {}
-
-  '@tanstack/store@0.7.5': {}
-
-  '@tanstack/store@0.7.7': {}
+      '@tanstack/router-core': 1.144.0
 
   '@tanstack/store@0.8.0': {}
 
-  '@tanstack/typedoc-config@0.3.0(typescript@5.9.3)':
+  '@tanstack/typedoc-config@0.3.2(typescript@5.9.3)':
+    dependencies:
+      typedoc: 0.28.14(typescript@5.9.3)
+      typedoc-plugin-frontmatter: 1.3.0(typedoc-plugin-markdown@4.9.0(typedoc@0.28.14(typescript@5.9.3)))
+      typedoc-plugin-markdown: 4.9.0(typedoc@0.28.14(typescript@5.9.3))
+    transitivePeerDependencies:
+      - typescript
+
+  '@tanstack/typedoc-config@0.3.3(typescript@5.9.3)':
     dependencies:
       typedoc: 0.28.14(typescript@5.9.3)
       typedoc-plugin-frontmatter: 1.3.0(typedoc-plugin-markdown@4.9.0(typedoc@0.28.14(typescript@5.9.3)))
@@ -11642,14 +14699,14 @@ snapshots:
     transitivePeerDependencies:
       - typescript
 
-  '@tanstack/virtual-file-routes@1.133.3': {}
+  '@tanstack/virtual-file-routes@1.145.4': {}
 
-  '@tanstack/vite-config@0.4.0(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@tanstack/vite-config@0.4.1(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
     dependencies:
       rollup-plugin-preserve-directives: 0.4.0(rollup@4.52.5)
-      vite-plugin-dts: 4.2.3(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      vite-plugin-externalize-deps: 0.10.0(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-      vite-tsconfig-paths: 5.1.4(typescript@5.9.3)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      vite-plugin-dts: 4.2.3(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      vite-plugin-externalize-deps: 0.10.0(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      vite-tsconfig-paths: 5.1.4(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
     transitivePeerDependencies:
       - '@types/node'
       - rollup
@@ -11657,9 +14714,22 @@ snapshots:
       - typescript
       - vite
 
+  '@tanstack/vite-config@0.4.3(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
+    dependencies:
+      rollup-plugin-preserve-directives: 0.4.0(rollup@4.52.5)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+      vite-plugin-dts: 4.2.3(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      vite-plugin-externalize-deps: 0.10.0(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+      vite-tsconfig-paths: 5.1.4(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
+    transitivePeerDependencies:
+      - '@types/node'
+      - rollup
+      - supports-color
+      - typescript
+
   '@testing-library/dom@10.4.1':
     dependencies:
-      '@babel/code-frame': 7.27.1
+      '@babel/code-frame': 7.28.6
       '@babel/runtime': 7.28.4
       '@types/aria-query': 5.0.4
       aria-query: 5.3.0
@@ -11677,22 +14747,22 @@ snapshots:
       picocolors: 1.1.1
       redent: 3.0.0
 
-  '@testing-library/react@16.3.0(@testing-library/dom@10.4.1)(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@testing-library/react@16.3.1(@testing-library/dom@10.4.1)(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)':
     dependencies:
       '@babel/runtime': 7.28.4
       '@testing-library/dom': 10.4.1
-      react: 19.2.0
-      react-dom: 19.2.0(react@19.2.0)
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
     optionalDependencies:
-      '@types/react': 19.2.2
-      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+      '@types/react': 19.2.7
+      '@types/react-dom': 19.2.3(@types/react@19.2.7)
 
-  '@trpc/client@11.6.0(@trpc/server@11.6.0(typescript@5.9.3))(typescript@5.9.3)':
+  '@trpc/client@11.8.1(@trpc/server@11.8.1(typescript@5.9.3))(typescript@5.9.3)':
     dependencies:
-      '@trpc/server': 11.6.0(typescript@5.9.3)
+      '@trpc/server': 11.8.1(typescript@5.9.3)
       typescript: 5.9.3
 
-  '@trpc/server@11.6.0(typescript@5.9.3)':
+  '@trpc/server@11.8.1(typescript@5.9.3)':
     dependencies:
       typescript: 5.9.3
 
@@ -11714,24 +14784,24 @@ snapshots:
 
   '@types/babel__core@7.20.5':
     dependencies:
-      '@babel/parser': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/parser': 7.28.6
+      '@babel/types': 7.28.6
       '@types/babel__generator': 7.27.0
       '@types/babel__template': 7.4.4
       '@types/babel__traverse': 7.28.0
 
   '@types/babel__generator@7.27.0':
     dependencies:
-      '@babel/types': 7.28.4
+      '@babel/types': 7.28.6
 
   '@types/babel__template@7.4.4':
     dependencies:
-      '@babel/parser': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/parser': 7.28.6
+      '@babel/types': 7.28.6
 
   '@types/babel__traverse@7.28.0':
     dependencies:
-      '@babel/types': 7.28.4
+      '@babel/types': 7.28.6
 
   '@types/body-parser@1.19.6':
     dependencies:
@@ -11750,7 +14820,7 @@ snapshots:
     dependencies:
       '@types/node': 24.7.0
 
-  '@types/conventional-commits-parser@5.0.1':
+  '@types/conventional-commits-parser@5.0.2':
     dependencies:
       '@types/node': 24.7.0
 
@@ -11766,13 +14836,6 @@ snapshots:
 
   '@types/estree@1.0.8': {}
 
-  '@types/express-serve-static-core@4.19.6':
-    dependencies:
-      '@types/node': 24.7.0
-      '@types/qs': 6.14.0
-      '@types/range-parser': 1.2.7
-      '@types/send': 0.17.5
-
   '@types/express-serve-static-core@5.0.7':
     dependencies:
       '@types/node': 24.7.0
@@ -11780,18 +14843,15 @@ snapshots:
       '@types/range-parser': 1.2.7
       '@types/send': 0.17.5
 
-  '@types/express@4.17.23':
+  '@types/express@5.0.5':
     dependencies:
       '@types/body-parser': 1.19.6
-      '@types/express-serve-static-core': 4.19.6
-      '@types/qs': 6.14.0
+      '@types/express-serve-static-core': 5.0.7
       '@types/serve-static': 1.15.8
 
-  '@types/express@5.0.3':
+  '@types/graceful-fs@4.1.9':
     dependencies:
-      '@types/body-parser': 1.19.6
-      '@types/express-serve-static-core': 5.0.7
-      '@types/serve-static': 1.15.8
+      '@types/node': 24.7.0
 
   '@types/hast@3.0.4':
     dependencies:
@@ -11799,7 +14859,17 @@ snapshots:
 
   '@types/http-errors@2.0.5': {}
 
-  '@types/jasmine@5.1.12': {}
+  '@types/istanbul-lib-coverage@2.0.6': {}
+
+  '@types/istanbul-lib-report@3.0.3':
+    dependencies:
+      '@types/istanbul-lib-coverage': 2.0.6
+
+  '@types/istanbul-reports@3.0.4':
+    dependencies:
+      '@types/istanbul-lib-report': 3.0.3
+
+  '@types/jasmine@5.1.13': {}
 
   '@types/json-schema@7.0.11': {}
 
@@ -11811,15 +14881,11 @@ snapshots:
 
   '@types/node@12.20.55': {}
 
-  '@types/node@22.18.1':
-    dependencies:
-      undici-types: 6.21.0
-
   '@types/node@24.7.0':
     dependencies:
       undici-types: 7.14.0
 
-  '@types/pg@8.15.5':
+  '@types/pg@8.16.0':
     dependencies:
       '@types/node': 24.7.0
       pg-protocol: 1.10.3
@@ -11829,13 +14895,13 @@ snapshots:
 
   '@types/range-parser@1.2.7': {}
 
-  '@types/react-dom@19.2.2(@types/react@19.2.2)':
+  '@types/react-dom@19.2.3(@types/react@19.2.7)':
     dependencies:
-      '@types/react': 19.2.2
+      '@types/react': 19.2.7
 
-  '@types/react@19.2.2':
+  '@types/react@19.2.7':
     dependencies:
-      csstype: 3.1.3
+      csstype: 3.2.3
 
   '@types/send@0.17.5':
     dependencies:
@@ -11848,10 +14914,12 @@ snapshots:
       '@types/node': 24.7.0
       '@types/send': 0.17.5
 
-  '@types/simple-peer@9.11.8':
+  '@types/simple-peer@9.11.9':
     dependencies:
       '@types/node': 24.7.0
 
+  '@types/stack-utils@2.0.3': {}
+
   '@types/unist@3.0.3': {}
 
   '@types/use-sync-external-store@1.5.0': {}
@@ -11866,190 +14934,194 @@ snapshots:
     dependencies:
       '@types/node': 24.7.0
 
-  '@typescript-eslint/eslint-plugin@8.44.1(@typescript-eslint/parser@8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
+  '@types/yargs-parser@21.0.3': {}
+
+  '@types/yargs@17.0.35':
+    dependencies:
+      '@types/yargs-parser': 21.0.3
+
+  '@typescript-eslint/eslint-plugin@8.47.0(@typescript-eslint/parser@8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
       '@eslint-community/regexpp': 4.12.1
-      '@typescript-eslint/parser': 8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      '@typescript-eslint/scope-manager': 8.44.1
-      '@typescript-eslint/type-utils': 8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      '@typescript-eslint/visitor-keys': 8.44.1
-      eslint: 9.38.0(jiti@2.6.0)
+      '@typescript-eslint/parser': 8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/scope-manager': 8.47.0
+      '@typescript-eslint/type-utils': 8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.47.0
+      eslint: 9.39.2(jiti@2.6.1)
       graphemer: 1.4.0
       ignore: 7.0.5
       natural-compare: 1.4.0
-      ts-api-utils: 2.1.0(typescript@5.9.3)
+      ts-api-utils: 2.3.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/eslint-plugin@8.46.1(@typescript-eslint/parser@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
+  '@typescript-eslint/eslint-plugin@8.51.0(@typescript-eslint/parser@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
       '@eslint-community/regexpp': 4.12.1
-      '@typescript-eslint/parser': 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      '@typescript-eslint/scope-manager': 8.46.1
-      '@typescript-eslint/type-utils': 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      '@typescript-eslint/visitor-keys': 8.46.1
-      eslint: 9.38.0(jiti@2.6.0)
-      graphemer: 1.4.0
+      '@typescript-eslint/parser': 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/scope-manager': 8.51.0
+      '@typescript-eslint/type-utils': 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.51.0
+      eslint: 9.39.2(jiti@2.6.1)
       ignore: 7.0.5
       natural-compare: 1.4.0
-      ts-api-utils: 2.1.0(typescript@5.9.3)
+      ts-api-utils: 2.3.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/parser@8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
+  '@typescript-eslint/parser@8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/scope-manager': 8.44.1
-      '@typescript-eslint/types': 8.44.1
-      '@typescript-eslint/typescript-estree': 8.44.1(typescript@5.9.3)
-      '@typescript-eslint/visitor-keys': 8.44.1
+      '@typescript-eslint/scope-manager': 8.47.0
+      '@typescript-eslint/types': 8.47.0
+      '@typescript-eslint/typescript-estree': 8.47.0(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.47.0
       debug: 4.4.3
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/parser@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
+  '@typescript-eslint/parser@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/scope-manager': 8.46.1
-      '@typescript-eslint/types': 8.46.1
-      '@typescript-eslint/typescript-estree': 8.46.1(typescript@5.9.3)
-      '@typescript-eslint/visitor-keys': 8.46.1
+      '@typescript-eslint/scope-manager': 8.51.0
+      '@typescript-eslint/types': 8.51.0
+      '@typescript-eslint/typescript-estree': 8.51.0(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.51.0
       debug: 4.4.3
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/project-service@8.44.1(typescript@5.9.3)':
+  '@typescript-eslint/project-service@8.47.0(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/tsconfig-utils': 8.46.1(typescript@5.9.3)
-      '@typescript-eslint/types': 8.46.1
+      '@typescript-eslint/tsconfig-utils': 8.51.0(typescript@5.9.3)
+      '@typescript-eslint/types': 8.51.0
       debug: 4.4.3
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/project-service@8.46.1(typescript@5.9.3)':
+  '@typescript-eslint/project-service@8.51.0(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/tsconfig-utils': 8.46.1(typescript@5.9.3)
-      '@typescript-eslint/types': 8.46.1
+      '@typescript-eslint/tsconfig-utils': 8.51.0(typescript@5.9.3)
+      '@typescript-eslint/types': 8.51.0
       debug: 4.4.3
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/scope-manager@8.44.1':
+  '@typescript-eslint/scope-manager@8.47.0':
     dependencies:
-      '@typescript-eslint/types': 8.44.1
-      '@typescript-eslint/visitor-keys': 8.44.1
+      '@typescript-eslint/types': 8.47.0
+      '@typescript-eslint/visitor-keys': 8.47.0
 
-  '@typescript-eslint/scope-manager@8.46.1':
+  '@typescript-eslint/scope-manager@8.51.0':
     dependencies:
-      '@typescript-eslint/types': 8.46.1
-      '@typescript-eslint/visitor-keys': 8.46.1
+      '@typescript-eslint/types': 8.51.0
+      '@typescript-eslint/visitor-keys': 8.51.0
 
-  '@typescript-eslint/tsconfig-utils@8.44.1(typescript@5.9.3)':
+  '@typescript-eslint/tsconfig-utils@8.47.0(typescript@5.9.3)':
     dependencies:
       typescript: 5.9.3
 
-  '@typescript-eslint/tsconfig-utils@8.46.1(typescript@5.9.3)':
+  '@typescript-eslint/tsconfig-utils@8.51.0(typescript@5.9.3)':
     dependencies:
       typescript: 5.9.3
 
-  '@typescript-eslint/type-utils@8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
+  '@typescript-eslint/type-utils@8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/types': 8.44.1
-      '@typescript-eslint/typescript-estree': 8.44.1(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+      '@typescript-eslint/types': 8.47.0
+      '@typescript-eslint/typescript-estree': 8.47.0(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       debug: 4.4.3
-      eslint: 9.38.0(jiti@2.6.0)
-      ts-api-utils: 2.1.0(typescript@5.9.3)
+      eslint: 9.39.2(jiti@2.6.1)
+      ts-api-utils: 2.3.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/type-utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
+  '@typescript-eslint/type-utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/types': 8.46.1
-      '@typescript-eslint/typescript-estree': 8.46.1(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+      '@typescript-eslint/types': 8.51.0
+      '@typescript-eslint/typescript-estree': 8.51.0(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       debug: 4.4.3
-      eslint: 9.38.0(jiti@2.6.0)
-      ts-api-utils: 2.1.0(typescript@5.9.3)
+      eslint: 9.39.2(jiti@2.6.1)
+      ts-api-utils: 2.3.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/types@8.44.1': {}
+  '@typescript-eslint/types@8.47.0': {}
 
-  '@typescript-eslint/types@8.46.1': {}
+  '@typescript-eslint/types@8.51.0': {}
 
-  '@typescript-eslint/typescript-estree@8.44.1(typescript@5.9.3)':
+  '@typescript-eslint/typescript-estree@8.47.0(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/project-service': 8.44.1(typescript@5.9.3)
-      '@typescript-eslint/tsconfig-utils': 8.44.1(typescript@5.9.3)
-      '@typescript-eslint/types': 8.44.1
-      '@typescript-eslint/visitor-keys': 8.44.1
+      '@typescript-eslint/project-service': 8.47.0(typescript@5.9.3)
+      '@typescript-eslint/tsconfig-utils': 8.47.0(typescript@5.9.3)
+      '@typescript-eslint/types': 8.47.0
+      '@typescript-eslint/visitor-keys': 8.47.0
       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)
+      ts-api-utils: 2.3.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/typescript-estree@8.46.1(typescript@5.9.3)':
+  '@typescript-eslint/typescript-estree@8.51.0(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
+      '@typescript-eslint/project-service': 8.51.0(typescript@5.9.3)
+      '@typescript-eslint/tsconfig-utils': 8.51.0(typescript@5.9.3)
+      '@typescript-eslint/types': 8.51.0
+      '@typescript-eslint/visitor-keys': 8.51.0
       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)
+      tinyglobby: 0.2.15
+      ts-api-utils: 2.3.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/utils@8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
+  '@typescript-eslint/utils@8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0(jiti@2.6.0))
-      '@typescript-eslint/scope-manager': 8.44.1
-      '@typescript-eslint/types': 8.44.1
-      '@typescript-eslint/typescript-estree': 8.44.1(typescript@5.9.3)
-      eslint: 9.38.0(jiti@2.6.0)
+      '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.2(jiti@2.6.1))
+      '@typescript-eslint/scope-manager': 8.47.0
+      '@typescript-eslint/types': 8.47.0
+      '@typescript-eslint/typescript-estree': 8.47.0(typescript@5.9.3)
+      eslint: 9.39.2(jiti@2.6.1)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)':
+  '@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0(jiti@2.6.0))
-      '@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.0)
+      '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.2(jiti@2.6.1))
+      '@typescript-eslint/scope-manager': 8.51.0
+      '@typescript-eslint/types': 8.51.0
+      '@typescript-eslint/typescript-estree': 8.51.0(typescript@5.9.3)
+      eslint: 9.39.2(jiti@2.6.1)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/visitor-keys@8.44.1':
+  '@typescript-eslint/visitor-keys@8.47.0':
     dependencies:
-      '@typescript-eslint/types': 8.44.1
+      '@typescript-eslint/types': 8.47.0
       eslint-visitor-keys: 4.2.1
 
-  '@typescript-eslint/visitor-keys@8.46.1':
+  '@typescript-eslint/visitor-keys@8.51.0':
     dependencies:
-      '@typescript-eslint/types': 8.46.1
+      '@typescript-eslint/types': 8.51.0
       eslint-visitor-keys: 4.2.1
 
   '@ungap/raw-json@0.4.4': {}
@@ -12113,41 +15185,41 @@ snapshots:
   '@unrs/resolver-binding-win32-x64-msvc@1.11.1':
     optional: true
 
-  '@vitejs/plugin-basic-ssl@2.1.0(vite@7.1.5(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@urql/core@5.2.0(graphql@16.12.0)':
     dependencies:
-      vite: 7.1.5(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      '@0no-co/graphql.web': 1.2.0(graphql@16.12.0)
+      wonka: 6.3.5
+    transitivePeerDependencies:
+      - graphql
 
-  '@vitejs/plugin-react@5.0.4(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@urql/exchange-retry@1.3.2(@urql/core@5.2.0(graphql@16.12.0))':
     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.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-    transitivePeerDependencies:
-      - supports-color
+      '@urql/core': 5.2.0(graphql@16.12.0)
+      wonka: 6.3.5
 
-  '@vitejs/plugin-react@5.0.4(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@vitejs/plugin-basic-ssl@2.1.0(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.21.0)(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
+      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.21.0)(yaml@2.8.1)
+
+  '@vitejs/plugin-react@5.1.2(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx-source': 7.27.1(@babel/core@7.28.5)
+      '@rolldown/pluginutils': 1.0.0-beta.53
       '@types/babel__core': 7.20.5
-      react-refresh: 0.17.0
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      react-refresh: 0.18.0
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
     transitivePeerDependencies:
       - supports-color
 
-  '@vitejs/plugin-vue@6.0.1(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))(vue@3.5.22(typescript@5.9.3))':
+  '@vitejs/plugin-vue@6.0.3(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))(vue@3.5.26(typescript@5.9.3))':
     dependencies:
-      '@rolldown/pluginutils': 1.0.0-beta.29
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vue: 3.5.22(typescript@5.9.3)
+      '@rolldown/pluginutils': 1.0.0-beta.53
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+      vue: 3.5.26(typescript@5.9.3)
 
-  '@vitest/coverage-istanbul@3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@vitest/coverage-istanbul@3.2.4(vitest@3.2.4)':
     dependencies:
       '@istanbuljs/schema': 0.1.3
       debug: 4.4.3
@@ -12159,7 +15231,7 @@ snapshots:
       magicast: 0.3.5
       test-exclude: 7.0.1
       tinyrainbow: 2.0.0
-      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -12171,13 +15243,13 @@ snapshots:
       chai: 5.3.3
       tinyrainbow: 2.0.0
 
-  '@vitest/mocker@3.2.4(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))':
+  '@vitest/mocker@3.2.4(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))':
     dependencies:
       '@vitest/spy': 3.2.4
       estree-walker: 3.0.3
-      magic-string: 0.30.19
+      magic-string: 0.30.21
     optionalDependencies:
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
 
   '@vitest/pretty-format@3.2.4':
     dependencies:
@@ -12192,13 +15264,24 @@ snapshots:
   '@vitest/snapshot@3.2.4':
     dependencies:
       '@vitest/pretty-format': 3.2.4
-      magic-string: 0.30.19
+      magic-string: 0.30.21
       pathe: 2.0.3
 
   '@vitest/spy@3.2.4':
     dependencies:
       tinyspy: 4.0.3
 
+  '@vitest/ui@3.2.4(vitest@3.2.4)':
+    dependencies:
+      '@vitest/utils': 3.2.4
+      fflate: 0.8.2
+      flatted: 3.3.3
+      pathe: 2.0.3
+      sirv: 3.0.2
+      tinyglobby: 0.2.15
+      tinyrainbow: 2.0.0
+      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+
   '@vitest/utils@3.2.4':
     dependencies:
       '@vitest/pretty-format': 3.2.4
@@ -12217,35 +15300,35 @@ snapshots:
       path-browserify: 1.0.1
       vscode-uri: 3.1.0
 
-  '@vue/compiler-core@3.5.22':
+  '@vue/compiler-core@3.5.26':
     dependencies:
-      '@babel/parser': 7.28.4
-      '@vue/shared': 3.5.22
-      entities: 4.5.0
+      '@babel/parser': 7.28.6
+      '@vue/shared': 3.5.26
+      entities: 7.0.0
       estree-walker: 2.0.2
       source-map-js: 1.2.1
 
-  '@vue/compiler-dom@3.5.22':
+  '@vue/compiler-dom@3.5.26':
     dependencies:
-      '@vue/compiler-core': 3.5.22
-      '@vue/shared': 3.5.22
+      '@vue/compiler-core': 3.5.26
+      '@vue/shared': 3.5.26
 
-  '@vue/compiler-sfc@3.5.22':
+  '@vue/compiler-sfc@3.5.26':
     dependencies:
-      '@babel/parser': 7.28.4
-      '@vue/compiler-core': 3.5.22
-      '@vue/compiler-dom': 3.5.22
-      '@vue/compiler-ssr': 3.5.22
-      '@vue/shared': 3.5.22
+      '@babel/parser': 7.28.6
+      '@vue/compiler-core': 3.5.26
+      '@vue/compiler-dom': 3.5.26
+      '@vue/compiler-ssr': 3.5.26
+      '@vue/shared': 3.5.26
       estree-walker: 2.0.2
-      magic-string: 0.30.19
+      magic-string: 0.30.21
       postcss: 8.5.6
       source-map-js: 1.2.1
 
-  '@vue/compiler-ssr@3.5.22':
+  '@vue/compiler-ssr@3.5.26':
     dependencies:
-      '@vue/compiler-dom': 3.5.22
-      '@vue/shared': 3.5.22
+      '@vue/compiler-dom': 3.5.26
+      '@vue/shared': 3.5.26
 
   '@vue/compiler-vue2@2.7.16':
     dependencies:
@@ -12255,9 +15338,9 @@ snapshots:
   '@vue/language-core@2.1.6(typescript@5.9.3)':
     dependencies:
       '@volar/language-core': 2.4.23
-      '@vue/compiler-dom': 3.5.22
+      '@vue/compiler-dom': 3.5.26
       '@vue/compiler-vue2': 2.7.16
-      '@vue/shared': 3.5.22
+      '@vue/shared': 3.5.26
       computeds: 0.0.1
       minimatch: 9.0.5
       muggle-string: 0.4.1
@@ -12265,29 +15348,31 @@ snapshots:
     optionalDependencies:
       typescript: 5.9.3
 
-  '@vue/reactivity@3.5.22':
+  '@vue/reactivity@3.5.26':
     dependencies:
-      '@vue/shared': 3.5.22
+      '@vue/shared': 3.5.26
 
-  '@vue/runtime-core@3.5.22':
+  '@vue/runtime-core@3.5.26':
     dependencies:
-      '@vue/reactivity': 3.5.22
-      '@vue/shared': 3.5.22
+      '@vue/reactivity': 3.5.26
+      '@vue/shared': 3.5.26
 
-  '@vue/runtime-dom@3.5.22':
+  '@vue/runtime-dom@3.5.26':
     dependencies:
-      '@vue/reactivity': 3.5.22
-      '@vue/runtime-core': 3.5.22
-      '@vue/shared': 3.5.22
-      csstype: 3.1.3
+      '@vue/reactivity': 3.5.26
+      '@vue/runtime-core': 3.5.26
+      '@vue/shared': 3.5.26
+      csstype: 3.2.3
 
-  '@vue/server-renderer@3.5.22(vue@3.5.22(typescript@5.9.3))':
+  '@vue/server-renderer@3.5.26(vue@3.5.26(typescript@5.9.3))':
     dependencies:
-      '@vue/compiler-ssr': 3.5.22
-      '@vue/shared': 3.5.22
-      vue: 3.5.22(typescript@5.9.3)
+      '@vue/compiler-ssr': 3.5.26
+      '@vue/shared': 3.5.26
+      vue: 3.5.26(typescript@5.9.3)
 
-  '@vue/shared@3.5.22': {}
+  '@vue/shared@3.5.26': {}
+
+  '@xmldom/xmldom@0.8.11': {}
 
   '@yarnpkg/lockfile@1.1.0': {}
 
@@ -12298,6 +15383,10 @@ snapshots:
 
   abbrev@3.0.1: {}
 
+  abort-controller@3.0.0:
+    dependencies:
+      event-target-shim: 5.0.1
+
   accepts@1.3.8:
     dependencies:
       mime-types: 2.1.35
@@ -12373,6 +15462,8 @@ snapshots:
       '@algolia/requester-fetch': 5.35.0
       '@algolia/requester-node-http': 5.35.0
 
+  anser@1.4.10: {}
+
   ansi-colors@4.1.3: {}
 
   ansi-escapes@4.3.2:
@@ -12383,10 +15474,16 @@ snapshots:
     dependencies:
       environment: 1.1.0
 
+  ansi-regex@4.1.1: {}
+
   ansi-regex@5.0.1: {}
 
   ansi-regex@6.2.2: {}
 
+  ansi-styles@3.2.1:
+    dependencies:
+      color-convert: 1.9.3
+
   ansi-styles@4.3.0:
     dependencies:
       color-convert: 2.0.1
@@ -12418,19 +15515,21 @@ snapshots:
 
   aria-query@5.3.2: {}
 
-  arktype@2.1.23:
+  arkregex@0.0.5:
+    dependencies:
+      '@ark/util': 0.56.0
+
+  arktype@2.1.29:
     dependencies:
-      '@ark/regex': 0.0.0
-      '@ark/schema': 0.50.0
-      '@ark/util': 0.50.0
+      '@ark/schema': 0.56.0
+      '@ark/util': 0.56.0
+      arkregex: 0.0.5
 
   array-buffer-byte-length@1.0.2:
     dependencies:
       call-bound: 1.0.4
       is-array-buffer: 3.0.5
 
-  array-flatten@1.1.1: {}
-
   array-ify@1.0.0: {}
 
   array-includes@3.1.9:
@@ -12491,10 +15590,12 @@ snapshots:
 
   as-typed@1.3.2: {}
 
+  asap@2.0.6: {}
+
   asn1js@3.0.6:
     dependencies:
       pvtsutils: 1.3.6
-      pvutils: 1.1.3
+      pvutils: 1.1.5
       tslib: 2.8.1
 
   assertion-error@2.0.1: {}
@@ -12505,15 +15606,11 @@ snapshots:
 
   async-function@1.0.0: {}
 
-  autoprefixer@10.4.21(postcss@8.5.6):
+  async-limiter@1.0.1: {}
+
+  async-mutex@0.5.0:
     dependencies:
-      browserslist: 4.25.4
-      caniuse-lite: 1.0.30001741
-      fraction.js: 4.3.7
-      normalize-range: 0.1.2
-      picocolors: 1.1.1
-      postcss: 8.5.6
-      postcss-value-parser: 4.2.0
+      tslib: 2.8.1
 
   available-typed-arrays@1.0.7:
     dependencies:
@@ -12521,31 +15618,149 @@ snapshots:
 
   axobject-query@4.1.0: {}
 
-  babel-dead-code-elimination@1.0.10:
+  babel-dead-code-elimination@1.0.11:
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/parser': 7.28.6
+      '@babel/traverse': 7.28.6
+      '@babel/types': 7.28.6
+    transitivePeerDependencies:
+      - supports-color
+
+  babel-jest@29.7.0(@babel/core@7.28.5):
+    dependencies:
+      '@babel/core': 7.28.5
+      '@jest/transform': 29.7.0
+      '@types/babel__core': 7.20.5
+      babel-plugin-istanbul: 6.1.1
+      babel-preset-jest: 29.6.3(@babel/core@7.28.5)
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      slash: 3.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  babel-plugin-istanbul@6.1.1:
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/parser': 7.28.4
-      '@babel/traverse': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/helper-plugin-utils': 7.28.6
+      '@istanbuljs/load-nyc-config': 1.1.0
+      '@istanbuljs/schema': 0.1.3
+      istanbul-lib-instrument: 5.2.1
+      test-exclude: 6.0.0
     transitivePeerDependencies:
       - supports-color
 
-  babel-plugin-jsx-dom-expressions@0.40.1(@babel/core@7.28.4):
+  babel-plugin-jest-hoist@29.6.3:
+    dependencies:
+      '@babel/template': 7.28.6
+      '@babel/types': 7.28.6
+      '@types/babel__core': 7.20.5
+      '@types/babel__traverse': 7.28.0
+
+  babel-plugin-jsx-dom-expressions@0.40.1(@babel/core@7.28.5):
     dependencies:
-      '@babel/core': 7.28.4
+      '@babel/core': 7.28.5
       '@babel/helper-module-imports': 7.18.6
-      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.4)
-      '@babel/types': 7.28.4
+      '@babel/plugin-syntax-jsx': 7.28.6(@babel/core@7.28.5)
+      '@babel/types': 7.28.6
       html-entities: 2.3.3
       parse5: 7.3.0
       validate-html-nesting: 1.2.3
 
-  babel-preset-solid@1.9.9(@babel/core@7.28.4)(solid-js@1.9.9):
+  babel-plugin-polyfill-corejs2@0.4.14(@babel/core@7.28.5):
+    dependencies:
+      '@babel/compat-data': 7.28.6
+      '@babel/core': 7.28.5
+      '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.28.5)
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
+  babel-plugin-polyfill-corejs3@0.13.0(@babel/core@7.28.5):
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.28.5)
+      core-js-compat: 3.47.0
+    transitivePeerDependencies:
+      - supports-color
+
+  babel-plugin-polyfill-regenerator@0.6.5(@babel/core@7.28.5):
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.28.5)
+    transitivePeerDependencies:
+      - supports-color
+
+  babel-plugin-react-native-web@0.19.13: {}
+
+  babel-plugin-syntax-hermes-parser@0.25.1:
+    dependencies:
+      hermes-parser: 0.25.1
+
+  babel-plugin-transform-flow-enums@0.0.2(@babel/core@7.28.5):
+    dependencies:
+      '@babel/plugin-syntax-flow': 7.28.6(@babel/core@7.28.5)
+    transitivePeerDependencies:
+      - '@babel/core'
+
+  babel-preset-current-node-syntax@1.2.0(@babel/core@7.28.5):
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.28.5)
+      '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.28.5)
+      '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.28.5)
+      '@babel/plugin-syntax-import-attributes': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.28.5)
+      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.28.5)
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.28.5)
+      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.28.5)
+      '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.28.5)
+
+  babel-preset-expo@13.2.4(@babel/core@7.28.5):
+    dependencies:
+      '@babel/helper-module-imports': 7.28.6
+      '@babel/plugin-proposal-decorators': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-proposal-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-syntax-export-default-from': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-export-namespace-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-flow-strip-types': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-modules-commonjs': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-object-rest-spread': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-methods': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-property-in-object': 7.28.6(@babel/core@7.28.5)
+      '@babel/plugin-transform-runtime': 7.28.5(@babel/core@7.28.5)
+      '@babel/preset-react': 7.28.5(@babel/core@7.28.5)
+      '@babel/preset-typescript': 7.28.5(@babel/core@7.28.5)
+      '@react-native/babel-preset': 0.79.6(@babel/core@7.28.5)
+      babel-plugin-react-native-web: 0.19.13
+      babel-plugin-syntax-hermes-parser: 0.25.1
+      babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.28.5)
+      debug: 4.4.3
+      react-refresh: 0.14.2
+      resolve-from: 5.0.0
+    transitivePeerDependencies:
+      - '@babel/core'
+      - supports-color
+
+  babel-preset-jest@29.6.3(@babel/core@7.28.5):
+    dependencies:
+      '@babel/core': 7.28.5
+      babel-plugin-jest-hoist: 29.6.3
+      babel-preset-current-node-syntax: 1.2.0(@babel/core@7.28.5)
+
+  babel-preset-solid@1.9.9(@babel/core@7.28.5)(solid-js@1.9.10):
     dependencies:
-      '@babel/core': 7.28.4
-      babel-plugin-jsx-dom-expressions: 0.40.1(@babel/core@7.28.4)
+      '@babel/core': 7.28.5
+      babel-plugin-jsx-dom-expressions: 0.40.1(@babel/core@7.28.5)
     optionalDependencies:
-      solid-js: 1.9.9
+      solid-js: 1.9.10
 
   balanced-match@1.0.2: {}
 
@@ -12553,6 +15768,8 @@ snapshots:
 
   base64id@2.0.0: {}
 
+  baseline-browser-mapping@2.8.29: {}
+
   beasties@0.3.5:
     dependencies:
       css-select: 6.0.0
@@ -12564,34 +15781,38 @@ snapshots:
       postcss: 8.5.6
       postcss-media-query-parser: 0.2.3
 
-  better-auth@1.3.27(react-dom@19.2.0(react@19.2.0))(react@19.2.0)(solid-js@1.9.9):
+  better-auth@1.3.26(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10):
     dependencies:
-      '@better-auth/core': 1.3.27
+      '@better-auth/core': 1.3.26
       '@better-auth/utils': 0.3.0
       '@better-fetch/fetch': 1.1.18
-      '@noble/ciphers': 2.0.0
-      '@noble/hashes': 2.0.0
-      '@simplewebauthn/browser': 13.1.2
-      '@simplewebauthn/server': 13.1.2
+      '@noble/ciphers': 2.0.1
+      '@noble/hashes': 2.0.1
+      '@simplewebauthn/browser': 13.2.2
+      '@simplewebauthn/server': 13.2.2
       better-call: 1.0.19
       defu: 6.1.4
-      jose: 6.1.0
-      kysely: 0.28.5
-      nanostores: 1.0.1
-      zod: 4.1.11
+      jose: 6.1.2
+      kysely: 0.28.8
+      nanostores: 1.1.0
+      zod: 4.1.13
     optionalDependencies:
-      react: 19.2.0
-      react-dom: 19.2.0(react@19.2.0)
-      solid-js: 1.9.9
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
+      solid-js: 1.9.10
 
   better-call@1.0.19:
     dependencies:
       '@better-auth/utils': 0.3.0
       '@better-fetch/fetch': 1.1.18
       rou3: 0.5.1
-      set-cookie-parser: 2.7.1
+      set-cookie-parser: 2.7.2
       uncrypto: 0.1.3
 
+  better-opn@3.0.2:
+    dependencies:
+      open: 8.4.2
+
   better-path-resolve@1.0.0:
     dependencies:
       is-windows: 1.0.2
@@ -12600,6 +15821,8 @@ snapshots:
     dependencies:
       require-from-string: 2.0.2
 
+  big-integer@1.6.52: {}
+
   binary-decision-diagram@3.2.0: {}
 
   binary-extensions@2.3.0: {}
@@ -12637,6 +15860,18 @@ snapshots:
 
   boolbase@1.0.0: {}
 
+  bplist-creator@0.1.0:
+    dependencies:
+      stream-buffers: 2.2.0
+
+  bplist-parser@0.3.1:
+    dependencies:
+      big-integer: 1.6.52
+
+  bplist-parser@0.3.2:
+    dependencies:
+      big-integer: 1.6.52
+
   brace-expansion@1.1.12:
     dependencies:
       balanced-match: 1.0.2
@@ -12650,24 +15885,34 @@ snapshots:
     dependencies:
       fill-range: 7.1.1
 
-  broadcast-channel@7.1.0:
+  broadcast-channel@7.2.0:
     dependencies:
-      '@babel/runtime': 7.27.0
-      oblivious-set: 1.4.0
+      '@babel/runtime': 7.28.4
+      oblivious-set: 2.0.0
       p-queue: 6.6.2
       unload: 2.4.1
 
-  browserslist@4.25.4:
+  browserslist@4.28.0:
     dependencies:
-      caniuse-lite: 1.0.30001741
-      electron-to-chromium: 1.5.215
-      node-releases: 2.0.20
-      update-browserslist-db: 1.1.3(browserslist@4.25.4)
+      baseline-browser-mapping: 2.8.29
+      caniuse-lite: 1.0.30001755
+      electron-to-chromium: 1.5.254
+      node-releases: 2.0.27
+      update-browserslist-db: 1.1.4(browserslist@4.28.0)
+
+  bser@2.1.1:
+    dependencies:
+      node-int64: 0.4.0
 
   bson@6.10.4: {}
 
   buffer-from@1.1.2: {}
 
+  buffer@5.7.1:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
   buffer@6.0.3:
     dependencies:
       base64-js: 1.5.1
@@ -12709,11 +15954,23 @@ snapshots:
       call-bind-apply-helpers: 1.0.2
       get-intrinsic: 1.3.0
 
+  caller-callsite@2.0.0:
+    dependencies:
+      callsites: 2.0.0
+
+  caller-path@2.0.0:
+    dependencies:
+      caller-callsite: 2.0.0
+
+  callsites@2.0.0: {}
+
   callsites@3.1.0: {}
 
-  camelcase-css@2.0.1: {}
+  camelcase@5.3.1: {}
+
+  camelcase@6.3.0: {}
 
-  caniuse-lite@1.0.30001741: {}
+  caniuse-lite@1.0.30001755: {}
 
   chai@5.3.3:
     dependencies:
@@ -12723,6 +15980,12 @@ snapshots:
       loupe: 3.2.1
       pathval: 2.0.1
 
+  chalk@2.4.2:
+    dependencies:
+      ansi-styles: 3.2.1
+      escape-string-regexp: 1.0.5
+      supports-color: 5.5.0
+
   chalk@4.1.2:
     dependencies:
       ansi-styles: 4.3.0
@@ -12730,7 +15993,7 @@ snapshots:
 
   chalk@5.6.2: {}
 
-  chardet@2.1.0: {}
+  chardet@2.1.1: {}
 
   check-error@2.1.1: {}
 
@@ -12773,12 +16036,42 @@ snapshots:
     dependencies:
       readdirp: 4.1.2
 
+  chokidar@5.0.0:
+    dependencies:
+      readdirp: 5.0.0
+
   chownr@2.0.0: {}
 
   chownr@3.0.0: {}
 
+  chrome-launcher@0.15.2:
+    dependencies:
+      '@types/node': 24.7.0
+      escape-string-regexp: 4.0.0
+      is-wsl: 2.2.0
+      lighthouse-logger: 1.4.2
+    transitivePeerDependencies:
+      - supports-color
+
+  chromium-edge-launcher@0.2.0:
+    dependencies:
+      '@types/node': 24.7.0
+      escape-string-regexp: 4.0.0
+      is-wsl: 2.2.0
+      lighthouse-logger: 1.4.2
+      mkdirp: 1.0.4
+      rimraf: 3.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  ci-info@2.0.0: {}
+
   ci-info@3.9.0: {}
 
+  cli-cursor@2.1.0:
+    dependencies:
+      restore-cursor: 2.0.0
+
   cli-cursor@5.0.0:
     dependencies:
       restore-cursor: 5.1.0
@@ -12792,6 +16085,8 @@ snapshots:
 
   cli-width@4.1.0: {}
 
+  client-only@0.0.1: {}
+
   cliui@7.0.4:
     dependencies:
       string-width: 4.2.3
@@ -12810,26 +16105,49 @@ snapshots:
       strip-ansi: 7.1.2
       wrap-ansi: 9.0.2
 
+  clone@1.0.4: {}
+
   clsx@2.1.1: {}
 
+  color-convert@1.9.3:
+    dependencies:
+      color-name: 1.1.3
+
   color-convert@2.0.1:
     dependencies:
       color-name: 1.1.4
 
+  color-name@1.1.3: {}
+
   color-name@1.1.4: {}
 
+  color-string@1.9.1:
+    dependencies:
+      color-name: 1.1.4
+      simple-swizzle: 0.2.4
+
+  color@4.2.3:
+    dependencies:
+      color-convert: 2.0.1
+      color-string: 1.9.1
+
   colorette@2.0.20: {}
 
+  comlink@4.4.2: {}
+
   commander@11.1.0:
     optional: true
 
+  commander@12.1.0: {}
+
   commander@13.1.0: {}
 
-  commander@2.20.3:
-    optional: true
+  commander@2.20.3: {}
 
   commander@4.1.1: {}
 
+  commander@7.2.0: {}
+
   comment-parser@1.4.1: {}
 
   common-tags@1.8.2: {}
@@ -12841,6 +16159,22 @@ snapshots:
 
   compare-versions@6.1.1: {}
 
+  compressible@2.0.18:
+    dependencies:
+      mime-db: 1.54.0
+
+  compression@1.8.1:
+    dependencies:
+      bytes: 3.1.2
+      compressible: 2.0.18
+      debug: 2.6.9
+      negotiator: 0.6.4
+      on-headers: 1.1.0
+      safe-buffer: 5.2.1
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
+
   computeds@0.0.1: {}
 
   concat-map@0.0.1: {}
@@ -12865,10 +16199,6 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  content-disposition@0.5.4:
-    dependencies:
-      safe-buffer: 5.2.1
-
   content-disposition@1.0.0:
     dependencies:
       safe-buffer: 5.2.1
@@ -12892,19 +16222,30 @@ snapshots:
 
   cookie-es@2.0.0: {}
 
-  cookie-signature@1.0.6: {}
-
   cookie-signature@1.2.2: {}
 
-  cookie@0.7.1: {}
-
   cookie@0.7.2: {}
 
+  copy-anything@4.0.5:
+    dependencies:
+      is-what: 5.5.0
+
+  core-js-compat@3.47.0:
+    dependencies:
+      browserslist: 4.28.0
+
   cors@2.8.5:
     dependencies:
       object-assign: 4.1.1
       vary: 1.1.2
 
+  cosmiconfig@5.2.1:
+    dependencies:
+      import-fresh: 2.0.0
+      is-directory: 0.3.1
+      js-yaml: 3.14.1
+      parse-json: 4.0.0
+
   cross-spawn@6.0.6:
     dependencies:
       nice-try: 1.0.5
@@ -12921,6 +16262,8 @@ snapshots:
 
   crypto-js@4.2.0: {}
 
+  crypto-random-string@2.0.0: {}
+
   css-select@5.2.2:
     dependencies:
       boolbase: 1.0.0
@@ -12948,17 +16291,13 @@ snapshots:
 
   css.escape@1.5.1: {}
 
-  cssesc@3.0.0: {}
-
-  cssstyle@5.3.1(postcss@8.5.6):
+  cssstyle@5.3.5:
     dependencies:
-      '@asamuzakjp/css-color': 4.0.5
-      '@csstools/css-syntax-patches-for-csstree': 1.0.14(postcss@8.5.6)
+      '@asamuzakjp/css-color': 4.1.1
+      '@csstools/css-syntax-patches-for-csstree': 1.0.22
       css-tree: 3.1.0
-    transitivePeerDependencies:
-      - postcss
 
-  csstype@3.1.3: {}
+  csstype@3.2.3: {}
 
   custom-event@1.0.1: {}
 
@@ -12997,6 +16336,10 @@ snapshots:
     dependencies:
       ms: 2.0.0
 
+  debug@3.2.7:
+    dependencies:
+      ms: 2.1.3
+
   debug@4.3.7:
     dependencies:
       ms: 2.1.3
@@ -13007,14 +16350,22 @@ snapshots:
 
   decimal.js@10.6.0: {}
 
+  decode-uri-component@0.2.2: {}
+
   dedent-js@1.0.1: {}
 
   deep-eql@5.0.2: {}
 
+  deep-extend@0.6.0: {}
+
   deep-is@0.1.4: {}
 
   deepmerge@4.3.1: {}
 
+  defaults@1.0.4:
+    dependencies:
+      clone: 1.0.4
+
   defekt@9.3.0: {}
 
   define-data-property@1.1.4:
@@ -13023,6 +16374,8 @@ snapshots:
       es-errors: 1.3.0
       gopd: 1.2.0
 
+  define-lazy-prop@2.0.0: {}
+
   define-properties@1.2.1:
     dependencies:
       define-data-property: 1.1.4
@@ -13039,25 +16392,22 @@ snapshots:
 
   detect-indent@6.1.0: {}
 
-  detect-libc@1.0.3:
-    optional: true
+  detect-libc@1.0.3: {}
 
   detect-libc@2.0.4: {}
 
+  devalue@5.6.2: {}
+
   dexie@4.0.10: {}
 
   di@0.0.1: {}
 
-  didyoumean@1.2.2: {}
-
   diff@8.0.2: {}
 
   dir-glob@3.0.1:
     dependencies:
       path-type: 4.0.0
 
-  dlv@1.1.3: {}
-
   doctrine@2.1.0:
     dependencies:
       esutils: 2.0.3
@@ -13095,11 +16445,17 @@ snapshots:
     dependencies:
       is-obj: 2.0.0
 
+  dotenv-expand@11.0.7:
+    dependencies:
+      dotenv: 16.6.1
+
+  dotenv@16.4.7: {}
+
   dotenv@16.6.1: {}
 
   dotenv@17.2.3: {}
 
-  drizzle-kit@0.31.5:
+  drizzle-kit@0.31.8:
     dependencies:
       '@drizzle-team/brocli': 0.10.2
       '@esbuild-kit/esm-loader': 2.6.5
@@ -13108,23 +16464,19 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  drizzle-orm@0.44.6(@types/pg@8.15.5)(gel@2.1.1)(kysely@0.28.5)(pg@8.16.3)(postgres@3.4.7):
+  drizzle-orm@0.45.1(@opentelemetry/api@1.9.0)(@types/pg@8.16.0)(gel@2.1.1)(kysely@0.28.8)(pg@8.16.3)(postgres@3.4.7):
     optionalDependencies:
-      '@types/pg': 8.15.5
+      '@opentelemetry/api': 1.9.0
+      '@types/pg': 8.16.0
       gel: 2.1.1
-      kysely: 0.28.5
+      kysely: 0.28.8
       pg: 8.16.3
       postgres: 3.4.7
 
-  drizzle-zod@0.8.3(drizzle-orm@0.44.6(@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.45.1(@opentelemetry/api@1.9.0)(@types/pg@8.16.0)(gel@2.1.1)(kysely@0.28.8)(pg@8.16.3)(postgres@3.4.7))(zod@4.1.13):
     dependencies:
-      drizzle-orm: 0.44.6(@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.6(@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.6(@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
+      drizzle-orm: 0.45.1(@opentelemetry/api@1.9.0)(@types/pg@8.16.0)(gel@2.1.1)(kysely@0.28.8)(pg@8.16.3)(postgres@3.4.7)
+      zod: 4.1.13
 
   dunder-proto@1.0.1:
     dependencies:
@@ -13136,7 +16488,7 @@ snapshots:
 
   ee-first@1.1.1: {}
 
-  electron-to-chromium@1.5.215: {}
+  electron-to-chromium@1.5.254: {}
 
   emoji-regex@10.5.0: {}
 
@@ -13201,6 +16553,10 @@ snapshots:
 
   entities@6.0.1: {}
 
+  entities@7.0.0: {}
+
+  env-editor@0.4.2: {}
+
   env-paths@2.2.1: {}
 
   env-paths@3.0.0:
@@ -13212,6 +16568,14 @@ snapshots:
 
   err-code@3.0.1: {}
 
+  error-ex@1.3.4:
+    dependencies:
+      is-arrayish: 0.2.1
+
+  error-stack-parser@2.1.4:
+    dependencies:
+      stackframe: 1.3.4
+
   es-abstract@1.24.0:
     dependencies:
       array-buffer-byte-length: 1.0.2
@@ -13405,20 +16769,53 @@ snapshots:
       '@esbuild/win32-ia32': 0.25.9
       '@esbuild/win32-x64': 0.25.9
 
+  esbuild@0.27.2:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.27.2
+      '@esbuild/android-arm': 0.27.2
+      '@esbuild/android-arm64': 0.27.2
+      '@esbuild/android-x64': 0.27.2
+      '@esbuild/darwin-arm64': 0.27.2
+      '@esbuild/darwin-x64': 0.27.2
+      '@esbuild/freebsd-arm64': 0.27.2
+      '@esbuild/freebsd-x64': 0.27.2
+      '@esbuild/linux-arm': 0.27.2
+      '@esbuild/linux-arm64': 0.27.2
+      '@esbuild/linux-ia32': 0.27.2
+      '@esbuild/linux-loong64': 0.27.2
+      '@esbuild/linux-mips64el': 0.27.2
+      '@esbuild/linux-ppc64': 0.27.2
+      '@esbuild/linux-riscv64': 0.27.2
+      '@esbuild/linux-s390x': 0.27.2
+      '@esbuild/linux-x64': 0.27.2
+      '@esbuild/netbsd-arm64': 0.27.2
+      '@esbuild/netbsd-x64': 0.27.2
+      '@esbuild/openbsd-arm64': 0.27.2
+      '@esbuild/openbsd-x64': 0.27.2
+      '@esbuild/openharmony-arm64': 0.27.2
+      '@esbuild/sunos-x64': 0.27.2
+      '@esbuild/win32-arm64': 0.27.2
+      '@esbuild/win32-ia32': 0.27.2
+      '@esbuild/win32-x64': 0.27.2
+
   escalade@3.2.0: {}
 
   escape-html@1.0.3: {}
 
+  escape-string-regexp@1.0.5: {}
+
+  escape-string-regexp@2.0.0: {}
+
   escape-string-regexp@4.0.0: {}
 
-  eslint-compat-utils@0.5.1(eslint@9.38.0(jiti@2.6.0)):
+  eslint-compat-utils@0.5.1(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
       semver: 7.7.3
 
-  eslint-config-prettier@10.1.8(eslint@9.38.0(jiti@2.6.0)):
+  eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
 
   eslint-import-context@0.1.9(unrs-resolver@1.11.1):
     dependencies:
@@ -13427,10 +16824,10 @@ snapshots:
     optionalDependencies:
       unrs-resolver: 1.11.1
 
-  eslint-import-resolver-typescript@4.4.4(eslint-plugin-import-x@4.16.1(@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0)))(eslint@9.38.0(jiti@2.6.0)):
+  eslint-import-resolver-typescript@4.4.4(eslint-plugin-import-x@4.16.1(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1)))(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
       debug: 4.4.3
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
       eslint-import-context: 0.1.9(unrs-resolver@1.11.1)
       get-tsconfig: 4.10.1
       is-bun-module: 2.0.0
@@ -13438,23 +16835,23 @@ snapshots:
       tinyglobby: 0.2.15
       unrs-resolver: 1.11.1
     optionalDependencies:
-      eslint-plugin-import-x: 4.16.1(@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))
+      eslint-plugin-import-x: 4.16.1(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))
     transitivePeerDependencies:
       - supports-color
 
-  eslint-plugin-es-x@7.8.0(eslint@9.38.0(jiti@2.6.0)):
+  eslint-plugin-es-x@7.8.0(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0(jiti@2.6.0))
+      '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.2(jiti@2.6.1))
       '@eslint-community/regexpp': 4.12.1
-      eslint: 9.38.0(jiti@2.6.0)
-      eslint-compat-utils: 0.5.1(eslint@9.38.0(jiti@2.6.0))
+      eslint: 9.39.2(jiti@2.6.1)
+      eslint-compat-utils: 0.5.1(eslint@9.39.2(jiti@2.6.1))
 
-  eslint-plugin-import-x@4.16.1(@typescript-eslint/utils@8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0)):
+  eslint-plugin-import-x@4.16.1(@typescript-eslint/utils@8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
-      '@typescript-eslint/types': 8.46.1
+      '@typescript-eslint/types': 8.51.0
       comment-parser: 1.4.1
       debug: 4.4.3
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
       eslint-import-context: 0.1.9(unrs-resolver@1.11.1)
       is-glob: 4.0.3
       minimatch: 10.0.3
@@ -13462,16 +16859,16 @@ snapshots:
       stable-hash-x: 0.2.0
       unrs-resolver: 1.11.1
     optionalDependencies:
-      '@typescript-eslint/utils': 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-plugin-n@17.23.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3):
+  eslint-plugin-n@17.23.1(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3):
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0(jiti@2.6.0))
+      '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.2(jiti@2.6.1))
       enhanced-resolve: 5.18.3
-      eslint: 9.38.0(jiti@2.6.0)
-      eslint-plugin-es-x: 7.8.0(eslint@9.38.0(jiti@2.6.0))
+      eslint: 9.39.2(jiti@2.6.1)
+      eslint-plugin-es-x: 7.8.0(eslint@9.39.2(jiti@2.6.1))
       get-tsconfig: 4.10.1
       globals: 15.15.0
       globrex: 0.1.2
@@ -13481,24 +16878,24 @@ snapshots:
     transitivePeerDependencies:
       - typescript
 
-  eslint-plugin-prettier@5.5.4(eslint-config-prettier@10.1.8(eslint@9.38.0(jiti@2.6.0)))(eslint@9.38.0(jiti@2.6.0))(prettier@3.6.2):
+  eslint-plugin-prettier@5.5.4(eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@2.6.1)))(eslint@9.39.2(jiti@2.6.1))(prettier@3.7.4):
     dependencies:
-      eslint: 9.38.0(jiti@2.6.0)
-      prettier: 3.6.2
+      eslint: 9.39.2(jiti@2.6.1)
+      prettier: 3.7.4
       prettier-linter-helpers: 1.0.0
       synckit: 0.11.11
     optionalDependencies:
-      eslint-config-prettier: 10.1.8(eslint@9.38.0(jiti@2.6.0))
+      eslint-config-prettier: 10.1.8(eslint@9.39.2(jiti@2.6.1))
 
-  eslint-plugin-react-hooks@5.2.0(eslint@9.38.0(jiti@2.6.0)):
+  eslint-plugin-react-hooks@5.2.0(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
 
-  eslint-plugin-react-refresh@0.4.24(eslint@9.38.0(jiti@2.6.0)):
+  eslint-plugin-react-refresh@0.4.26(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
 
-  eslint-plugin-react@7.37.5(eslint@9.38.0(jiti@2.6.0)):
+  eslint-plugin-react@7.37.5(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
       array-includes: 3.1.9
       array.prototype.findlast: 1.2.5
@@ -13506,7 +16903,7 @@ snapshots:
       array.prototype.tosorted: 1.1.4
       doctrine: 2.1.0
       es-iterator-helpers: 1.2.1
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
       estraverse: 5.3.0
       hasown: 2.0.2
       jsx-ast-utils: 3.3.5
@@ -13520,10 +16917,10 @@ snapshots:
       string.prototype.matchall: 4.0.12
       string.prototype.repeat: 1.0.0
 
-  eslint-plugin-solid@0.14.5(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3):
+  eslint-plugin-solid@0.14.5(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3):
     dependencies:
-      '@typescript-eslint/utils': 8.46.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      eslint: 9.38.0(jiti@2.6.0)
+      '@typescript-eslint/utils': 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      eslint: 9.39.2(jiti@2.6.1)
       estraverse: 5.3.0
       is-html: 2.0.0
       kebab-case: 1.0.2
@@ -13542,16 +16939,16 @@ snapshots:
 
   eslint-visitor-keys@4.2.1: {}
 
-  eslint@9.38.0(jiti@2.6.0):
+  eslint@9.39.2(jiti@2.6.1):
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0(jiti@2.6.0))
+      '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.2(jiti@2.6.1))
       '@eslint-community/regexpp': 4.12.1
       '@eslint/config-array': 0.21.1
-      '@eslint/config-helpers': 0.4.1
-      '@eslint/core': 0.16.0
+      '@eslint/config-helpers': 0.4.2
+      '@eslint/core': 0.17.0
       '@eslint/eslintrc': 3.3.1
-      '@eslint/js': 9.38.0
-      '@eslint/plugin-kit': 0.4.0
+      '@eslint/js': 9.39.2
+      '@eslint/plugin-kit': 0.4.1
       '@humanfs/node': 0.16.7
       '@humanwhocodes/module-importer': 1.0.1
       '@humanwhocodes/retry': 0.4.3
@@ -13579,7 +16976,7 @@ snapshots:
       natural-compare: 1.4.0
       optionator: 0.9.4
     optionalDependencies:
-      jiti: 2.6.0
+      jiti: 2.6.1
     transitivePeerDependencies:
       - supports-color
 
@@ -13597,7 +16994,7 @@ snapshots:
     dependencies:
       estraverse: 5.3.0
 
-  esrap@2.1.0:
+  esrap@2.2.1:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
 
@@ -13617,11 +17014,15 @@ snapshots:
 
   etag@1.8.1: {}
 
+  event-iterator@2.0.0: {}
+
   event-reduce-js@5.2.7:
     dependencies:
       array-push-at-sort-position: 4.0.1
       binary-decision-diagram: 3.2.0
 
+  event-target-shim@5.0.1: {}
+
   eventemitter3@4.0.7: {}
 
   eventemitter3@5.0.1: {}
@@ -13632,6 +17033,8 @@ snapshots:
     dependencies:
       eventsource-parser: 3.0.6
 
+  exec-async@2.2.0: {}
+
   execa@1.0.0:
     dependencies:
       cross-spawn: 6.0.6
@@ -13656,47 +17059,136 @@ snapshots:
 
   expect-type@1.2.2: {}
 
-  exponential-backoff@3.1.2: {}
+  expo-asset@11.1.7(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3):
+    dependencies:
+      '@expo/image-utils': 0.7.6
+      expo: 53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      expo-constants: 17.1.8(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+    transitivePeerDependencies:
+      - supports-color
 
-  express-rate-limit@7.5.1(express@5.1.0):
+  expo-constants@17.1.8(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)):
     dependencies:
-      express: 5.1.0
+      '@expo/config': 11.0.13
+      '@expo/env': 1.0.7
+      expo: 53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+    transitivePeerDependencies:
+      - supports-color
 
-  express@4.21.2:
+  expo-file-system@18.1.11(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)):
     dependencies:
-      accepts: 1.3.8
-      array-flatten: 1.1.1
-      body-parser: 1.20.3
-      content-disposition: 0.5.4
-      content-type: 1.0.5
-      cookie: 0.7.1
-      cookie-signature: 1.0.6
-      debug: 2.6.9
-      depd: 2.0.0
-      encodeurl: 2.0.0
-      escape-html: 1.0.3
-      etag: 1.8.1
-      finalhandler: 1.3.1
-      fresh: 0.5.2
-      http-errors: 2.0.0
-      merge-descriptors: 1.0.3
-      methods: 1.1.2
-      on-finished: 2.4.1
-      parseurl: 1.3.3
-      path-to-regexp: 0.1.12
-      proxy-addr: 2.0.7
-      qs: 6.13.0
-      range-parser: 1.2.1
-      safe-buffer: 5.2.1
-      send: 0.19.0
-      serve-static: 1.16.2
-      setprototypeof: 1.2.0
-      statuses: 2.0.1
-      type-is: 1.6.18
-      utils-merge: 1.0.1
-      vary: 1.1.2
+      expo: 53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+
+  expo-font@13.3.2(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react@19.2.3):
+    dependencies:
+      expo: 53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      fontfaceobserver: 2.3.0
+      react: 19.2.3
+
+  expo-keep-awake@14.1.4(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react@19.2.3):
+    dependencies:
+      expo: 53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      react: 19.2.3
+
+  expo-linking@7.1.7(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3):
+    dependencies:
+      expo-constants: 17.1.8(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      invariant: 2.2.4
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+    transitivePeerDependencies:
+      - expo
+      - supports-color
+
+  expo-modules-autolinking@2.1.14:
+    dependencies:
+      '@expo/spawn-async': 1.7.2
+      chalk: 4.1.2
+      commander: 7.2.0
+      find-up: 5.0.0
+      glob: 10.4.5
+      require-from-string: 2.0.2
+      resolve-from: 5.0.0
+
+  expo-modules-core@2.5.0:
+    dependencies:
+      invariant: 2.2.4
+
+  expo-router@5.1.10(4f28e76f0b81d75a7bbf5ddbb07ad280):
+    dependencies:
+      '@expo/metro-runtime': 5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      '@expo/schema-utils': 0.1.8
+      '@expo/server': 0.6.3
+      '@radix-ui/react-slot': 1.2.0(@types/react@19.2.7)(react@19.2.3)
+      '@react-navigation/bottom-tabs': 7.9.1(@react-navigation/native@7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-safe-area-context@5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-screens@4.11.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      '@react-navigation/native': 7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      '@react-navigation/native-stack': 7.9.1(@react-navigation/native@7.1.27(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-safe-area-context@5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native-screens@4.11.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      client-only: 0.0.1
+      expo: 53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      expo-constants: 17.1.8(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      expo-linking: 7.1.7(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      invariant: 2.2.4
+      react-fast-compare: 3.2.2
+      react-native-is-edge-to-edge: 1.2.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      react-native-safe-area-context: 5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      react-native-screens: 4.11.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      semver: 7.6.3
+      server-only: 0.0.1
+      shallowequal: 1.1.0
+    transitivePeerDependencies:
+      - '@react-native-masked-view/masked-view'
+      - '@types/react'
+      - react
+      - react-native
+      - supports-color
+
+  expo-status-bar@2.2.3(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3):
+    dependencies:
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+      react-native-edge-to-edge: 1.6.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      react-native-is-edge-to-edge: 1.2.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+
+  expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3):
+    dependencies:
+      '@babel/runtime': 7.28.4
+      '@expo/cli': 0.24.23(graphql@16.12.0)
+      '@expo/config': 11.0.13
+      '@expo/config-plugins': 10.1.2
+      '@expo/fingerprint': 0.13.4
+      '@expo/metro-config': 0.20.18
+      '@expo/vector-icons': 14.1.0(expo-font@13.3.2(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      babel-preset-expo: 13.2.4(@babel/core@7.28.5)
+      expo-asset: 11.1.7(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      expo-constants: 17.1.8(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      expo-file-system: 18.1.11(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
+      expo-font: 13.3.2(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react@19.2.3)
+      expo-keep-awake: 14.1.4(expo@53.0.25(@babel/core@7.28.5)(@expo/metro-runtime@5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)))(graphql@16.12.0)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3))(react@19.2.3)
+      expo-modules-autolinking: 2.1.14
+      expo-modules-core: 2.5.0
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+      react-native-edge-to-edge: 1.6.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      whatwg-url-without-unicode: 8.0.0-3
+    optionalDependencies:
+      '@expo/metro-runtime': 5.0.5(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))
     transitivePeerDependencies:
+      - '@babel/core'
+      - babel-plugin-react-compiler
+      - bufferutil
+      - graphql
       - supports-color
+      - utf-8-validate
+
+  exponential-backoff@3.1.2: {}
+
+  express-rate-limit@7.5.1(express@5.1.0):
+    dependencies:
+      express: 5.1.0
 
   express@5.1.0:
     dependencies:
@@ -13736,6 +17228,10 @@ snapshots:
 
   extendable-error@0.1.7: {}
 
+  fast-check@3.23.2:
+    dependencies:
+      pure-rand: 6.1.0
+
   fast-deep-equal@3.1.3: {}
 
   fast-diff@1.3.0: {}
@@ -13762,6 +17258,10 @@ snapshots:
     dependencies:
       websocket-driver: 0.7.4
 
+  fb-watchman@2.0.2:
+    dependencies:
+      bser: 2.1.1
+
   fd-package-json@2.0.0:
     dependencies:
       walk-up-path: 4.0.0
@@ -13770,7 +17270,7 @@ snapshots:
     optionalDependencies:
       picomatch: 4.0.3
 
-  fetchdts@0.1.7: {}
+  fflate@0.8.2: {}
 
   file-entry-cache@8.0.0:
     dependencies:
@@ -13780,6 +17280,8 @@ snapshots:
     dependencies:
       to-regex-range: 5.0.1
 
+  filter-obj@1.1.0: {}
+
   finalhandler@1.1.2:
     dependencies:
       debug: 2.6.9
@@ -13792,18 +17294,6 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  finalhandler@1.3.1:
-    dependencies:
-      debug: 2.6.9
-      encodeurl: 2.0.0
-      escape-html: 1.0.3
-      on-finished: 2.4.1
-      parseurl: 1.3.3
-      statuses: 2.0.1
-      unpipe: 1.0.0
-    transitivePeerDependencies:
-      - supports-color
-
   finalhandler@2.1.0:
     dependencies:
       debug: 4.4.3
@@ -13865,8 +17355,12 @@ snapshots:
 
   flatted@3.3.3: {}
 
+  flow-enums-runtime@0.0.6: {}
+
   follow-redirects@1.15.11: {}
 
+  fontfaceobserver@2.3.0: {}
+
   for-each@0.3.5:
     dependencies:
       is-callable: 1.2.7
@@ -13882,10 +17376,10 @@ snapshots:
 
   forwarded@0.2.0: {}
 
-  fraction.js@4.3.7: {}
-
   fractional-indexing@3.2.0: {}
 
+  freeport-async@2.0.0: {}
+
   fresh@0.5.2: {}
 
   fresh@2.0.0: {}
@@ -13976,6 +17470,8 @@ snapshots:
       hasown: 2.0.2
       math-intrinsics: 1.1.0
 
+  get-package-type@0.1.0: {}
+
   get-proto@1.0.1:
     dependencies:
       dunder-proto: 1.0.1
@@ -13997,6 +17493,8 @@ snapshots:
     dependencies:
       resolve-pkg-maps: 1.0.0
 
+  getenv@2.0.0: {}
+
   glob-parent@5.1.2:
     dependencies:
       is-glob: 4.0.3
@@ -14029,7 +17527,7 @@ snapshots:
 
   globals@15.15.0: {}
 
-  globals@16.4.0: {}
+  globals@16.5.0: {}
 
   globalthis@1.0.4:
     dependencies:
@@ -14047,9 +17545,9 @@ snapshots:
 
   globrex@0.1.2: {}
 
-  goober@2.1.16(csstype@3.1.3):
+  goober@2.1.16(csstype@3.2.3):
     dependencies:
-      csstype: 3.1.3
+      csstype: 3.2.3
 
   gopd@1.2.0: {}
 
@@ -14057,21 +17555,21 @@ snapshots:
 
   graphemer@1.4.0: {}
 
-  graphql-ws@5.16.2(graphql@15.10.1):
+  graphql-ws@5.16.2(graphql@16.12.0):
     dependencies:
-      graphql: 15.10.1
+      graphql: 16.12.0
 
-  graphql@15.10.1: {}
+  graphql@16.12.0: {}
 
-  h3@2.0.0-beta.4:
+  h3@2.0.1-rc.7:
     dependencies:
-      cookie-es: 2.0.0
-      fetchdts: 0.1.7
-      rou3: 0.7.8
-      srvx: 0.8.16
+      rou3: 0.7.12
+      srvx: 0.10.1
 
   has-bigints@1.1.0: {}
 
+  has-flag@3.0.0: {}
+
   has-flag@4.0.0: {}
 
   has-property-descriptors@1.0.2:
@@ -14094,17 +17592,35 @@ snapshots:
 
   he@1.2.0: {}
 
+  hermes-estree@0.25.1: {}
+
+  hermes-estree@0.29.1: {}
+
+  hermes-parser@0.25.1:
+    dependencies:
+      hermes-estree: 0.25.1
+
+  hermes-parser@0.29.1:
+    dependencies:
+      hermes-estree: 0.29.1
+
+  hosted-git-info@7.0.2:
+    dependencies:
+      lru-cache: 10.4.3
+
   hosted-git-info@8.1.0:
     dependencies:
       lru-cache: 10.4.3
 
   hosted-git-info@9.0.0:
     dependencies:
-      lru-cache: 11.2.2
+      lru-cache: 11.2.4
 
-  html-encoding-sniffer@4.0.0:
+  html-encoding-sniffer@6.0.0:
     dependencies:
-      whatwg-encoding: 3.1.1
+      '@exodus/bytes': 1.7.0
+    transitivePeerDependencies:
+      - '@exodus/crypto'
 
   html-entities@2.3.3: {}
 
@@ -14187,8 +17703,17 @@ snapshots:
 
   ignore@7.0.5: {}
 
+  image-size@1.2.1:
+    dependencies:
+      queue: 6.0.2
+
   immutable@5.1.3: {}
 
+  import-fresh@2.0.0:
+    dependencies:
+      caller-path: 2.0.0
+      resolve-from: 3.0.0
+
   import-fresh@3.3.1:
     dependencies:
       parent-module: 1.0.1
@@ -14207,6 +17732,8 @@ snapshots:
 
   inherits@2.0.4: {}
 
+  ini@1.3.8: {}
+
   ini@5.0.0: {}
 
   inline-style-parser@0.2.4: {}
@@ -14219,6 +17746,10 @@ snapshots:
 
   interpret@1.4.0: {}
 
+  invariant@2.2.4:
+    dependencies:
+      loose-envify: 1.4.0
+
   ip-address@10.0.1: {}
 
   ipaddr.js@1.9.1: {}
@@ -14234,6 +17765,10 @@ snapshots:
       call-bound: 1.0.4
       get-intrinsic: 1.3.0
 
+  is-arrayish@0.2.1: {}
+
+  is-arrayish@0.3.4: {}
+
   is-async-function@2.1.1:
     dependencies:
       async-function: 1.0.0
@@ -14276,6 +17811,10 @@ snapshots:
       call-bound: 1.0.4
       has-tostringtag: 1.0.2
 
+  is-directory@0.3.1: {}
+
+  is-docker@2.2.1: {}
+
   is-extglob@2.1.1: {}
 
   is-finalizationregistry@1.1.1:
@@ -14330,6 +17869,8 @@ snapshots:
 
   is-obj@2.0.0: {}
 
+  is-plain-obj@2.1.0: {}
+
   is-potential-custom-element-name@1.0.1: {}
 
   is-promise@4.0.0: {}
@@ -14397,8 +17938,14 @@ snapshots:
 
   is-what@4.1.16: {}
 
+  is-what@5.5.0: {}
+
   is-windows@1.0.2: {}
 
+  is-wsl@2.2.0:
+    dependencies:
+      is-docker: 2.2.1
+
   isarray@2.0.5: {}
 
   isbinaryfile@4.0.10: {}
@@ -14417,8 +17964,8 @@ snapshots:
 
   istanbul-lib-instrument@5.2.1:
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/parser': 7.28.4
+      '@babel/core': 7.28.5
+      '@babel/parser': 7.28.6
       '@istanbuljs/schema': 0.1.3
       istanbul-lib-coverage: 3.2.2
       semver: 6.3.1
@@ -14427,8 +17974,8 @@ snapshots:
 
   istanbul-lib-instrument@6.0.3:
     dependencies:
-      '@babel/core': 7.28.4
-      '@babel/parser': 7.28.4
+      '@babel/core': 7.28.5
+      '@babel/parser': 7.28.6
       '@istanbuljs/schema': 0.1.3
       istanbul-lib-coverage: 3.2.2
       semver: 7.7.3
@@ -14479,15 +18026,87 @@ snapshots:
 
   jasmine-core@4.6.1: {}
 
-  jasmine-core@5.12.0: {}
+  jasmine-core@5.13.0: {}
+
+  jest-environment-node@29.7.0:
+    dependencies:
+      '@jest/environment': 29.7.0
+      '@jest/fake-timers': 29.7.0
+      '@jest/types': 29.6.3
+      '@types/node': 24.7.0
+      jest-mock: 29.7.0
+      jest-util: 29.7.0
+
+  jest-get-type@29.6.3: {}
+
+  jest-haste-map@29.7.0:
+    dependencies:
+      '@jest/types': 29.6.3
+      '@types/graceful-fs': 4.1.9
+      '@types/node': 24.7.0
+      anymatch: 3.1.3
+      fb-watchman: 2.0.2
+      graceful-fs: 4.2.11
+      jest-regex-util: 29.6.3
+      jest-util: 29.7.0
+      jest-worker: 29.7.0
+      micromatch: 4.0.8
+      walker: 1.0.8
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  jest-message-util@29.7.0:
+    dependencies:
+      '@babel/code-frame': 7.28.6
+      '@jest/types': 29.6.3
+      '@types/stack-utils': 2.0.3
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      micromatch: 4.0.8
+      pretty-format: 29.7.0
+      slash: 3.0.0
+      stack-utils: 2.0.6
+
+  jest-mock@29.7.0:
+    dependencies:
+      '@jest/types': 29.6.3
+      '@types/node': 24.7.0
+      jest-util: 29.7.0
+
+  jest-regex-util@29.6.3: {}
+
+  jest-util@29.7.0:
+    dependencies:
+      '@jest/types': 29.6.3
+      '@types/node': 24.7.0
+      chalk: 4.1.2
+      ci-info: 3.9.0
+      graceful-fs: 4.2.11
+      picomatch: 2.3.1
+
+  jest-validate@29.7.0:
+    dependencies:
+      '@jest/types': 29.6.3
+      camelcase: 6.3.0
+      chalk: 4.1.2
+      jest-get-type: 29.6.3
+      leven: 3.1.0
+      pretty-format: 29.7.0
+
+  jest-worker@29.7.0:
+    dependencies:
+      '@types/node': 24.7.0
+      jest-util: 29.7.0
+      merge-stream: 2.0.0
+      supports-color: 8.1.1
 
-  jiti@1.21.7: {}
+  jimp-compact@0.16.1: {}
 
-  jiti@2.6.0: {}
+  jiti@2.6.1: {}
 
   jju@1.4.0: {}
 
-  jose@6.1.0: {}
+  jose@6.1.2: {}
 
   js-base64@3.7.8: {}
 
@@ -14500,35 +18119,37 @@ snapshots:
       argparse: 1.0.10
       esprima: 4.0.1
 
-  js-yaml@4.1.0:
+  js-yaml@4.1.1:
     dependencies:
       argparse: 2.0.1
 
-  jsdom@27.0.1(postcss@8.5.6):
+  jsc-safe-url@0.2.4: {}
+
+  jsdom@27.4.0:
     dependencies:
-      '@asamuzakjp/dom-selector': 6.7.2
-      cssstyle: 5.3.1(postcss@8.5.6)
+      '@acemir/cssom': 0.9.30
+      '@asamuzakjp/dom-selector': 6.7.6
+      '@exodus/bytes': 1.7.0
+      cssstyle: 5.3.5
       data-urls: 6.0.0
       decimal.js: 10.6.0
-      html-encoding-sniffer: 4.0.0
+      html-encoding-sniffer: 6.0.0
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
       is-potential-custom-element-name: 1.0.1
       parse5: 8.0.0
-      rrweb-cssom: 0.8.0
       saxes: 6.0.0
       symbol-tree: 3.2.4
       tough-cookie: 6.0.0
       w3c-xmlserializer: 5.0.0
       webidl-conversions: 8.0.0
-      whatwg-encoding: 3.1.1
       whatwg-mimetype: 4.0.0
       whatwg-url: 15.1.0
       ws: 8.18.3
       xml-name-validator: 5.0.0
     transitivePeerDependencies:
+      - '@exodus/crypto'
       - bufferutil
-      - postcss
       - supports-color
       - utf-8-validate
 
@@ -14536,6 +18157,8 @@ snapshots:
 
   json-buffer@3.0.1: {}
 
+  json-parse-better-errors@1.0.2: {}
+
   json-parse-even-better-errors@4.0.0: {}
 
   json-schema-traverse@0.4.1: {}
@@ -14588,9 +18211,9 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  karma-jasmine-html-reporter@2.1.0(jasmine-core@5.12.0)(karma-jasmine@5.1.0(karma@6.4.4))(karma@6.4.4):
+  karma-jasmine-html-reporter@2.1.0(jasmine-core@5.13.0)(karma-jasmine@5.1.0(karma@6.4.4))(karma@6.4.4):
     dependencies:
-      jasmine-core: 5.12.0
+      jasmine-core: 5.13.0
       karma: 6.4.4
       karma-jasmine: 5.1.0(karma@6.4.4)
 
@@ -14637,80 +18260,142 @@ snapshots:
     dependencies:
       json-buffer: 3.0.1
 
+  kleur@3.0.3: {}
+
   kleur@4.1.5: {}
 
-  knip@5.66.1(@types/node@24.7.0)(typescript@5.9.3):
+  knip@5.79.0(@types/node@24.7.0)(typescript@5.9.3):
     dependencies:
       '@nodelib/fs.walk': 1.2.8
       '@types/node': 24.7.0
       fast-glob: 3.3.3
       formatly: 0.3.0
-      jiti: 2.6.0
-      js-yaml: 4.1.0
+      jiti: 2.6.1
+      js-yaml: 4.1.1
       minimist: 1.2.8
-      oxc-resolver: 11.8.4
+      oxc-resolver: 11.16.2
       picocolors: 1.1.1
       picomatch: 4.0.3
-      smol-toml: 1.4.2
-      strip-json-comments: 5.0.2
+      smol-toml: 1.5.2
+      strip-json-comments: 5.0.3
       typescript: 5.9.3
-      zod: 4.1.11
+      zod: 4.1.13
 
   known-css-properties@0.30.0: {}
 
   kolorist@1.8.0: {}
 
-  kysely@0.28.5: {}
+  kysely@0.28.8: {}
+
+  lan-network@0.1.7: {}
+
+  leven@3.1.0: {}
 
   levn@0.4.1:
     dependencies:
       prelude-ls: 1.2.1
       type-check: 0.4.0
 
-  lightningcss-darwin-arm64@1.30.1:
+  lighthouse-logger@1.4.2:
+    dependencies:
+      debug: 2.6.9
+      marky: 1.3.0
+    transitivePeerDependencies:
+      - supports-color
+
+  lightningcss-android-arm64@1.30.2:
+    optional: true
+
+  lightningcss-darwin-arm64@1.27.0:
+    optional: true
+
+  lightningcss-darwin-arm64@1.30.2:
+    optional: true
+
+  lightningcss-darwin-x64@1.27.0:
+    optional: true
+
+  lightningcss-darwin-x64@1.30.2:
+    optional: true
+
+  lightningcss-freebsd-x64@1.27.0:
+    optional: true
+
+  lightningcss-freebsd-x64@1.30.2:
+    optional: true
+
+  lightningcss-linux-arm-gnueabihf@1.27.0:
     optional: true
 
-  lightningcss-darwin-x64@1.30.1:
+  lightningcss-linux-arm-gnueabihf@1.30.2:
     optional: true
 
-  lightningcss-freebsd-x64@1.30.1:
+  lightningcss-linux-arm64-gnu@1.27.0:
     optional: true
 
-  lightningcss-linux-arm-gnueabihf@1.30.1:
+  lightningcss-linux-arm64-gnu@1.30.2:
     optional: true
 
-  lightningcss-linux-arm64-gnu@1.30.1:
+  lightningcss-linux-arm64-musl@1.27.0:
     optional: true
 
-  lightningcss-linux-arm64-musl@1.30.1:
+  lightningcss-linux-arm64-musl@1.30.2:
     optional: true
 
-  lightningcss-linux-x64-gnu@1.30.1:
+  lightningcss-linux-x64-gnu@1.27.0:
     optional: true
 
-  lightningcss-linux-x64-musl@1.30.1:
+  lightningcss-linux-x64-gnu@1.30.2:
     optional: true
 
-  lightningcss-win32-arm64-msvc@1.30.1:
+  lightningcss-linux-x64-musl@1.27.0:
     optional: true
 
-  lightningcss-win32-x64-msvc@1.30.1:
+  lightningcss-linux-x64-musl@1.30.2:
     optional: true
 
-  lightningcss@1.30.1:
+  lightningcss-win32-arm64-msvc@1.27.0:
+    optional: true
+
+  lightningcss-win32-arm64-msvc@1.30.2:
+    optional: true
+
+  lightningcss-win32-x64-msvc@1.27.0:
+    optional: true
+
+  lightningcss-win32-x64-msvc@1.30.2:
+    optional: true
+
+  lightningcss@1.27.0:
+    dependencies:
+      detect-libc: 1.0.3
+    optionalDependencies:
+      lightningcss-darwin-arm64: 1.27.0
+      lightningcss-darwin-x64: 1.27.0
+      lightningcss-freebsd-x64: 1.27.0
+      lightningcss-linux-arm-gnueabihf: 1.27.0
+      lightningcss-linux-arm64-gnu: 1.27.0
+      lightningcss-linux-arm64-musl: 1.27.0
+      lightningcss-linux-x64-gnu: 1.27.0
+      lightningcss-linux-x64-musl: 1.27.0
+      lightningcss-win32-arm64-msvc: 1.27.0
+      lightningcss-win32-x64-msvc: 1.27.0
+
+  lightningcss@1.30.2:
     dependencies:
       detect-libc: 2.0.4
     optionalDependencies:
-      lightningcss-darwin-arm64: 1.30.1
-      lightningcss-darwin-x64: 1.30.1
-      lightningcss-freebsd-x64: 1.30.1
-      lightningcss-linux-arm-gnueabihf: 1.30.1
-      lightningcss-linux-arm64-gnu: 1.30.1
-      lightningcss-linux-arm64-musl: 1.30.1
-      lightningcss-linux-x64-gnu: 1.30.1
-      lightningcss-linux-x64-musl: 1.30.1
-      lightningcss-win32-arm64-msvc: 1.30.1
-      lightningcss-win32-x64-msvc: 1.30.1
+      lightningcss-android-arm64: 1.30.2
+      lightningcss-darwin-arm64: 1.30.2
+      lightningcss-darwin-x64: 1.30.2
+      lightningcss-freebsd-x64: 1.30.2
+      lightningcss-linux-arm-gnueabihf: 1.30.2
+      lightningcss-linux-arm64-gnu: 1.30.2
+      lightningcss-linux-arm64-musl: 1.30.2
+      lightningcss-linux-x64-gnu: 1.30.2
+      lightningcss-linux-x64-musl: 1.30.2
+      lightningcss-win32-arm64-msvc: 1.30.2
+      lightningcss-win32-x64-msvc: 1.30.2
 
   lilconfig@3.1.3: {}
 
@@ -14787,6 +18472,8 @@ snapshots:
 
   lodash.camelcase@4.3.0: {}
 
+  lodash.debounce@4.0.8: {}
+
   lodash.get@4.4.2: {}
 
   lodash.isequal@4.5.0: {}
@@ -14795,8 +18482,14 @@ snapshots:
 
   lodash.startcase@4.4.0: {}
 
+  lodash.throttle@4.1.1: {}
+
   lodash@4.17.21: {}
 
+  log-symbols@2.2.0:
+    dependencies:
+      chalk: 2.4.2
+
   log-symbols@6.0.0:
     dependencies:
       chalk: 5.6.2
@@ -14834,7 +18527,7 @@ snapshots:
 
   lru-cache@10.4.3: {}
 
-  lru-cache@11.2.2: {}
+  lru-cache@11.2.4: {}
 
   lru-cache@5.1.1:
     dependencies:
@@ -14852,14 +18545,14 @@ snapshots:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
 
-  magic-string@0.30.19:
+  magic-string@0.30.21:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
 
   magicast@0.3.5:
     dependencies:
-      '@babel/parser': 7.28.4
-      '@babel/types': 7.28.4
+      '@babel/parser': 7.28.6
+      '@babel/types': 7.28.6
       source-map-js: 1.2.1
 
   make-dir@4.0.0:
@@ -14882,6 +18575,10 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  makeerror@1.0.12:
+    dependencies:
+      tmpl: 1.0.5
+
   markdown-it@14.1.0:
     dependencies:
       argparse: 2.0.1
@@ -14891,12 +18588,14 @@ snapshots:
       punycode.js: 2.3.1
       uc.micro: 2.1.0
 
-  markdown-link-extractor@4.0.2:
+  markdown-link-extractor@4.0.3:
     dependencies:
       html-link-extractor: 1.0.5
-      marked: 12.0.2
+      marked: 17.0.1
+
+  marked@17.0.1: {}
 
-  marked@12.0.2: {}
+  marky@1.3.0: {}
 
   math-intrinsics@1.1.0: {}
 
@@ -14908,6 +18607,8 @@ snapshots:
 
   media-typer@1.1.0: {}
 
+  memoize-one@5.2.1: {}
+
   memory-pager@1.5.0: {}
 
   meow@12.1.1: {}
@@ -14916,15 +18617,190 @@ snapshots:
     dependencies:
       is-what: 4.1.16
 
-  merge-descriptors@1.0.3: {}
-
   merge-descriptors@2.0.0: {}
 
+  merge-options@3.0.4:
+    dependencies:
+      is-plain-obj: 2.1.0
+
   merge-stream@2.0.0: {}
 
   merge2@1.4.1: {}
 
-  methods@1.1.2: {}
+  metro-babel-transformer@0.82.5:
+    dependencies:
+      '@babel/core': 7.28.5
+      flow-enums-runtime: 0.0.6
+      hermes-parser: 0.29.1
+      nullthrows: 1.1.1
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-cache-key@0.82.5:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+
+  metro-cache@0.82.5:
+    dependencies:
+      exponential-backoff: 3.1.2
+      flow-enums-runtime: 0.0.6
+      https-proxy-agent: 7.0.6
+      metro-core: 0.82.5
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-config@0.82.5:
+    dependencies:
+      connect: 3.7.0
+      cosmiconfig: 5.2.1
+      flow-enums-runtime: 0.0.6
+      jest-validate: 29.7.0
+      metro: 0.82.5
+      metro-cache: 0.82.5
+      metro-core: 0.82.5
+      metro-runtime: 0.82.5
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  metro-core@0.82.5:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+      lodash.throttle: 4.1.1
+      metro-resolver: 0.82.5
+
+  metro-file-map@0.82.5:
+    dependencies:
+      debug: 4.4.3
+      fb-watchman: 2.0.2
+      flow-enums-runtime: 0.0.6
+      graceful-fs: 4.2.11
+      invariant: 2.2.4
+      jest-worker: 29.7.0
+      micromatch: 4.0.8
+      nullthrows: 1.1.1
+      walker: 1.0.8
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-minify-terser@0.82.5:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+      terser: 5.44.0
+
+  metro-resolver@0.82.5:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+
+  metro-runtime@0.82.5:
+    dependencies:
+      '@babel/runtime': 7.28.4
+      flow-enums-runtime: 0.0.6
+
+  metro-source-map@0.82.5:
+    dependencies:
+      '@babel/traverse': 7.28.6
+      '@babel/traverse--for-generate-function-map': '@babel/traverse@7.28.6'
+      '@babel/types': 7.28.6
+      flow-enums-runtime: 0.0.6
+      invariant: 2.2.4
+      metro-symbolicate: 0.82.5
+      nullthrows: 1.1.1
+      ob1: 0.82.5
+      source-map: 0.5.7
+      vlq: 1.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-symbolicate@0.82.5:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+      invariant: 2.2.4
+      metro-source-map: 0.82.5
+      nullthrows: 1.1.1
+      source-map: 0.5.7
+      vlq: 1.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-transform-plugins@0.82.5:
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.6
+      '@babel/template': 7.28.6
+      '@babel/traverse': 7.28.6
+      flow-enums-runtime: 0.0.6
+      nullthrows: 1.1.1
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-transform-worker@0.82.5:
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.6
+      '@babel/parser': 7.28.6
+      '@babel/types': 7.28.6
+      flow-enums-runtime: 0.0.6
+      metro: 0.82.5
+      metro-babel-transformer: 0.82.5
+      metro-cache: 0.82.5
+      metro-cache-key: 0.82.5
+      metro-minify-terser: 0.82.5
+      metro-source-map: 0.82.5
+      metro-transform-plugins: 0.82.5
+      nullthrows: 1.1.1
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  metro@0.82.5:
+    dependencies:
+      '@babel/code-frame': 7.28.6
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.6
+      '@babel/parser': 7.28.6
+      '@babel/template': 7.28.6
+      '@babel/traverse': 7.28.6
+      '@babel/types': 7.28.6
+      accepts: 1.3.8
+      chalk: 4.1.2
+      ci-info: 2.0.0
+      connect: 3.7.0
+      debug: 4.4.3
+      error-stack-parser: 2.1.4
+      flow-enums-runtime: 0.0.6
+      graceful-fs: 4.2.11
+      hermes-parser: 0.29.1
+      image-size: 1.2.1
+      invariant: 2.2.4
+      jest-worker: 29.7.0
+      jsc-safe-url: 0.2.4
+      lodash.throttle: 4.1.1
+      metro-babel-transformer: 0.82.5
+      metro-cache: 0.82.5
+      metro-cache-key: 0.82.5
+      metro-config: 0.82.5
+      metro-core: 0.82.5
+      metro-file-map: 0.82.5
+      metro-resolver: 0.82.5
+      metro-runtime: 0.82.5
+      metro-source-map: 0.82.5
+      metro-symbolicate: 0.82.5
+      metro-transform-plugins: 0.82.5
+      metro-transform-worker: 0.82.5
+      mime-types: 2.1.35
+      nullthrows: 1.1.1
+      serialize-error: 2.1.0
+      source-map: 0.5.7
+      throat: 5.0.0
+      ws: 7.5.10
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
 
   micromatch@4.0.8:
     dependencies:
@@ -14947,6 +18823,8 @@ snapshots:
 
   mime@2.6.0: {}
 
+  mimic-fn@1.2.0: {}
+
   mimic-fn@4.0.0: {}
 
   mimic-function@5.0.1: {}
@@ -15034,7 +18912,7 @@ snapshots:
       '@types/whatwg-url': 11.0.5
       whatwg-url: 14.2.0
 
-  mongodb@6.18.0(socks@2.8.7):
+  mongodb@6.21.0(socks@2.8.7):
     dependencies:
       '@mongodb-js/saslprep': 1.3.0
       bson: 6.10.4
@@ -15079,7 +18957,7 @@ snapshots:
 
   nanoid@3.3.11: {}
 
-  nanostores@1.0.1: {}
+  nanostores@1.1.0: {}
 
   napi-postinstall@0.3.3: {}
 
@@ -15091,8 +18969,12 @@ snapshots:
 
   negotiator@0.6.3: {}
 
+  negotiator@0.6.4: {}
+
   negotiator@1.0.0: {}
 
+  nested-error-stacks@2.0.1: {}
+
   nice-try@1.0.5: {}
 
   nkeys.js@1.1.0:
@@ -15116,6 +18998,8 @@ snapshots:
     optionalDependencies:
       encoding: 0.1.13
 
+  node-forge@1.3.3: {}
+
   node-gyp-build-optional-packages@5.2.2:
     dependencies:
       detect-libc: 2.0.4
@@ -15136,7 +19020,9 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  node-releases@2.0.20: {}
+  node-int64@0.4.0: {}
+
+  node-releases@2.0.27: {}
 
   nopt@8.1.0:
     dependencies:
@@ -15144,8 +19030,6 @@ snapshots:
 
   normalize-path@3.0.0: {}
 
-  normalize-range@0.1.2: {}
-
   npm-bundled@4.0.0:
     dependencies:
       npm-normalize-package-bin: 4.0.0
@@ -15156,6 +19040,13 @@ snapshots:
 
   npm-normalize-package-bin@4.0.0: {}
 
+  npm-package-arg@11.0.3:
+    dependencies:
+      hosted-git-info: 7.0.2
+      proc-log: 4.2.0
+      semver: 7.7.3
+      validate-npm-package-name: 5.0.1
+
   npm-package-arg@12.0.2:
     dependencies:
       hosted-git-info: 8.1.0
@@ -15206,9 +19097,13 @@ snapshots:
     dependencies:
       boolbase: 1.0.0
 
-  object-assign@4.1.1: {}
+  nullthrows@1.1.1: {}
+
+  ob1@0.82.5:
+    dependencies:
+      flow-enums-runtime: 0.0.6
 
-  object-hash@3.0.0: {}
+  object-assign@4.1.1: {}
 
   object-inspect@1.13.4: {}
 
@@ -15246,6 +19141,8 @@ snapshots:
 
   oblivious-set@1.4.0: {}
 
+  oblivious-set@2.0.0: {}
+
   on-finished@2.3.0:
     dependencies:
       ee-first: 1.1.1
@@ -15254,10 +19151,16 @@ snapshots:
     dependencies:
       ee-first: 1.1.1
 
+  on-headers@1.1.0: {}
+
   once@1.4.0:
     dependencies:
       wrappy: 1.0.2
 
+  onetime@2.0.1:
+    dependencies:
+      mimic-fn: 1.2.0
+
   onetime@6.0.0:
     dependencies:
       mimic-fn: 4.0.0
@@ -15266,6 +19169,17 @@ snapshots:
     dependencies:
       mimic-function: 5.0.1
 
+  open@7.4.2:
+    dependencies:
+      is-docker: 2.2.1
+      is-wsl: 2.2.0
+
+  open@8.4.2:
+    dependencies:
+      define-lazy-prop: 2.0.0
+      is-docker: 2.2.1
+      is-wsl: 2.2.0
+
   optionator@0.9.4:
     dependencies:
       deep-is: 0.1.4
@@ -15275,6 +19189,15 @@ snapshots:
       type-check: 0.4.0
       word-wrap: 1.2.5
 
+  ora@3.4.0:
+    dependencies:
+      chalk: 2.4.2
+      cli-cursor: 2.1.0
+      cli-spinners: 2.9.2
+      log-symbols: 2.2.0
+      strip-ansi: 5.2.0
+      wcwidth: 1.0.1
+
   ora@8.2.0:
     dependencies:
       chalk: 5.6.2
@@ -15298,29 +19221,30 @@ snapshots:
       object-keys: 1.1.1
       safe-push-apply: 1.0.0
 
-  oxc-resolver@11.8.4:
-    dependencies:
-      napi-postinstall: 0.3.3
+  oxc-resolver@11.16.2:
     optionalDependencies:
-      '@oxc-resolver/binding-android-arm-eabi': 11.8.4
-      '@oxc-resolver/binding-android-arm64': 11.8.4
-      '@oxc-resolver/binding-darwin-arm64': 11.8.4
-      '@oxc-resolver/binding-darwin-x64': 11.8.4
-      '@oxc-resolver/binding-freebsd-x64': 11.8.4
-      '@oxc-resolver/binding-linux-arm-gnueabihf': 11.8.4
-      '@oxc-resolver/binding-linux-arm-musleabihf': 11.8.4
-      '@oxc-resolver/binding-linux-arm64-gnu': 11.8.4
-      '@oxc-resolver/binding-linux-arm64-musl': 11.8.4
-      '@oxc-resolver/binding-linux-ppc64-gnu': 11.8.4
-      '@oxc-resolver/binding-linux-riscv64-gnu': 11.8.4
-      '@oxc-resolver/binding-linux-riscv64-musl': 11.8.4
-      '@oxc-resolver/binding-linux-s390x-gnu': 11.8.4
-      '@oxc-resolver/binding-linux-x64-gnu': 11.8.4
-      '@oxc-resolver/binding-linux-x64-musl': 11.8.4
-      '@oxc-resolver/binding-wasm32-wasi': 11.8.4
-      '@oxc-resolver/binding-win32-arm64-msvc': 11.8.4
-      '@oxc-resolver/binding-win32-ia32-msvc': 11.8.4
-      '@oxc-resolver/binding-win32-x64-msvc': 11.8.4
+      '@oxc-resolver/binding-android-arm-eabi': 11.16.2
+      '@oxc-resolver/binding-android-arm64': 11.16.2
+      '@oxc-resolver/binding-darwin-arm64': 11.16.2
+      '@oxc-resolver/binding-darwin-x64': 11.16.2
+      '@oxc-resolver/binding-freebsd-x64': 11.16.2
+      '@oxc-resolver/binding-linux-arm-gnueabihf': 11.16.2
+      '@oxc-resolver/binding-linux-arm-musleabihf': 11.16.2
+      '@oxc-resolver/binding-linux-arm64-gnu': 11.16.2
+      '@oxc-resolver/binding-linux-arm64-musl': 11.16.2
+      '@oxc-resolver/binding-linux-ppc64-gnu': 11.16.2
+      '@oxc-resolver/binding-linux-riscv64-gnu': 11.16.2
+      '@oxc-resolver/binding-linux-riscv64-musl': 11.16.2
+      '@oxc-resolver/binding-linux-s390x-gnu': 11.16.2
+      '@oxc-resolver/binding-linux-x64-gnu': 11.16.2
+      '@oxc-resolver/binding-linux-x64-musl': 11.16.2
+      '@oxc-resolver/binding-openharmony-arm64': 11.16.2
+      '@oxc-resolver/binding-wasm32-wasi': 11.16.2
+      '@oxc-resolver/binding-win32-arm64-msvc': 11.16.2
+      '@oxc-resolver/binding-win32-ia32-msvc': 11.16.2
+      '@oxc-resolver/binding-win32-x64-msvc': 11.16.2
+
+  p-defer@4.0.1: {}
 
   p-filter@2.1.0:
     dependencies:
@@ -15365,7 +19289,7 @@ snapshots:
     dependencies:
       quansync: 0.2.11
 
-  package-manager-detector@1.3.0: {}
+  package-manager-detector@1.6.0: {}
 
   pacote@21.0.0:
     dependencies:
@@ -15393,6 +19317,15 @@ snapshots:
     dependencies:
       callsites: 3.1.0
 
+  parse-json@4.0.0:
+    dependencies:
+      error-ex: 1.3.4
+      json-parse-better-errors: 1.0.2
+
+  parse-png@2.1.0:
+    dependencies:
+      pngjs: 3.4.0
+
   parse5-html-rewriting-stream@8.0.0:
     dependencies:
       entities: 6.0.1
@@ -15446,8 +19379,6 @@ snapshots:
       lru-cache: 10.4.3
       minipass: 7.1.2
 
-  path-to-regexp@0.1.12: {}
-
   path-to-regexp@8.3.0: {}
 
   path-type@4.0.0: {}
@@ -15495,12 +19426,12 @@ snapshots:
 
   picomatch@2.3.1: {}
 
+  picomatch@3.0.1: {}
+
   picomatch@4.0.3: {}
 
   pidtree@0.6.0: {}
 
-  pify@2.3.0: {}
-
   pify@4.0.1: {}
 
   pirates@4.0.7: {}
@@ -15517,40 +19448,23 @@ snapshots:
       mlly: 1.8.0
       pathe: 2.0.3
 
-  possible-typed-array-names@1.1.0: {}
-
-  postcss-import@15.1.0(postcss@8.5.6):
+  plist@3.1.0:
     dependencies:
-      postcss: 8.5.6
-      postcss-value-parser: 4.2.0
-      read-cache: 1.0.0
-      resolve: 1.22.10
+      '@xmldom/xmldom': 0.8.11
+      base64-js: 1.5.1
+      xmlbuilder: 15.1.1
 
-  postcss-js@4.0.1(postcss@8.5.6):
-    dependencies:
-      camelcase-css: 2.0.1
-      postcss: 8.5.6
+  pngjs@3.4.0: {}
 
-  postcss-load-config@4.0.2(postcss@8.5.6):
-    dependencies:
-      lilconfig: 3.1.3
-      yaml: 2.8.1
-    optionalDependencies:
-      postcss: 8.5.6
+  possible-typed-array-names@1.1.0: {}
 
   postcss-media-query-parser@0.2.3: {}
 
-  postcss-nested@6.2.0(postcss@8.5.6):
-    dependencies:
-      postcss: 8.5.6
-      postcss-selector-parser: 6.1.2
-
-  postcss-selector-parser@6.1.2:
+  postcss@8.4.49:
     dependencies:
-      cssesc: 3.0.0
-      util-deprecate: 1.0.2
-
-  postcss-value-parser@4.2.0: {}
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
 
   postcss@8.5.6:
     dependencies:
@@ -15578,21 +19492,42 @@ snapshots:
 
   prettier@2.8.8: {}
 
-  prettier@3.6.2: {}
+  prettier@3.7.4: {}
+
+  pretty-bytes@5.6.0: {}
 
   pretty-format@27.5.1:
     dependencies:
       ansi-regex: 5.0.1
       ansi-styles: 5.2.0
-      react-is: 17.0.2
+      react-is: 17.0.2
+
+  pretty-format@29.7.0:
+    dependencies:
+      '@jest/schemas': 29.6.3
+      ansi-styles: 5.2.0
+      react-is: 18.3.1
+
+  proc-log@4.2.0: {}
 
   proc-log@5.0.0: {}
 
+  progress@2.0.3: {}
+
   promise-retry@2.0.1:
     dependencies:
       err-code: 2.0.3
       retry: 0.12.0
 
+  promise@8.3.0:
+    dependencies:
+      asap: 2.0.6
+
+  prompts@2.4.2:
+    dependencies:
+      kleur: 3.0.3
+      sisteransi: 1.0.5
+
   prop-types@15.8.1:
     dependencies:
       loose-envify: 1.4.0
@@ -15619,10 +19554,10 @@ snapshots:
       forwarded: 0.2.0
       ipaddr.js: 1.9.1
 
-  publint@0.3.14:
+  publint@0.3.16:
     dependencies:
       '@publint/pack': 0.1.2
-      package-manager-detector: 1.3.0
+      package-manager-detector: 1.6.0
       picocolors: 1.1.1
       sade: 1.8.1
 
@@ -15637,14 +19572,18 @@ snapshots:
 
   punycode@2.3.1: {}
 
+  pure-rand@6.1.0: {}
+
   pvtsutils@1.3.6:
     dependencies:
       tslib: 2.8.1
 
-  pvutils@1.1.3: {}
+  pvutils@1.1.5: {}
 
   qjobs@1.2.0: {}
 
+  qrcode-terminal@0.11.0: {}
+
   qs@6.13.0:
     dependencies:
       side-channel: 1.1.0
@@ -15655,8 +19594,19 @@ snapshots:
 
   quansync@0.2.11: {}
 
+  query-string@7.1.3:
+    dependencies:
+      decode-uri-component: 0.2.2
+      filter-obj: 1.1.0
+      split-on-first: 1.1.0
+      strict-uri-encode: 2.0.0
+
   queue-microtask@1.2.3: {}
 
+  queue@6.0.2:
+    dependencies:
+      inherits: 2.0.4
+
   randombytes@2.1.0:
     dependencies:
       safe-buffer: 5.2.1
@@ -15677,22 +19627,116 @@ snapshots:
       iconv-lite: 0.7.0
       unpipe: 1.0.0
 
-  react-dom@19.2.0(react@19.2.0):
+  rc@1.2.8:
+    dependencies:
+      deep-extend: 0.6.0
+      ini: 1.3.8
+      minimist: 1.2.8
+      strip-json-comments: 2.0.1
+
+  react-devtools-core@6.1.5:
+    dependencies:
+      shell-quote: 1.8.3
+      ws: 7.5.10
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  react-dom@19.2.3(react@19.2.3):
     dependencies:
-      react: 19.2.0
+      react: 19.2.3
       scheduler: 0.27.0
 
+  react-fast-compare@3.2.2: {}
+
+  react-freeze@1.0.4(react@19.2.3):
+    dependencies:
+      react: 19.2.3
+
   react-is@16.13.1: {}
 
   react-is@17.0.2: {}
 
-  react-refresh@0.17.0: {}
+  react-is@18.3.1: {}
+
+  react-is@19.2.3: {}
+
+  react-native-edge-to-edge@1.6.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3):
+    dependencies:
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+
+  react-native-is-edge-to-edge@1.2.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3):
+    dependencies:
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+
+  react-native-safe-area-context@5.4.0(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3):
+    dependencies:
+      react: 19.2.3
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
 
-  react@19.2.0: {}
+  react-native-screens@4.11.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3):
+    dependencies:
+      react: 19.2.3
+      react-freeze: 1.0.4(react@19.2.3)
+      react-native: 0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3)
+      react-native-is-edge-to-edge: 1.2.1(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      warn-once: 0.1.1
 
-  read-cache@1.0.0:
+  react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3):
     dependencies:
-      pify: 2.3.0
+      '@jest/create-cache-key-function': 29.7.0
+      '@react-native/assets-registry': 0.79.6
+      '@react-native/codegen': 0.79.6(@babel/core@7.28.5)
+      '@react-native/community-cli-plugin': 0.79.6
+      '@react-native/gradle-plugin': 0.79.6
+      '@react-native/js-polyfills': 0.79.6
+      '@react-native/normalize-colors': 0.79.6
+      '@react-native/virtualized-lists': 0.79.6(@types/react@19.2.7)(react-native@0.79.6(@babel/core@7.28.5)(@types/react@19.2.7)(react@19.2.3))(react@19.2.3)
+      abort-controller: 3.0.0
+      anser: 1.4.10
+      ansi-regex: 5.0.1
+      babel-jest: 29.7.0(@babel/core@7.28.5)
+      babel-plugin-syntax-hermes-parser: 0.25.1
+      base64-js: 1.5.1
+      chalk: 4.1.2
+      commander: 12.1.0
+      event-target-shim: 5.0.1
+      flow-enums-runtime: 0.0.6
+      glob: 7.2.3
+      invariant: 2.2.4
+      jest-environment-node: 29.7.0
+      memoize-one: 5.2.1
+      metro-runtime: 0.82.5
+      metro-source-map: 0.82.5
+      nullthrows: 1.1.1
+      pretty-format: 29.7.0
+      promise: 8.3.0
+      react: 19.2.3
+      react-devtools-core: 6.1.5
+      react-refresh: 0.14.2
+      regenerator-runtime: 0.13.11
+      scheduler: 0.25.0
+      semver: 7.7.3
+      stacktrace-parser: 0.1.11
+      whatwg-fetch: 3.6.20
+      ws: 6.2.3
+      yargs: 17.7.2
+    optionalDependencies:
+      '@types/react': 19.2.7
+    transitivePeerDependencies:
+      - '@babel/core'
+      - '@react-native-community/cli'
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  react-refresh@0.14.2: {}
+
+  react-refresh@0.18.0: {}
+
+  react@19.2.3: {}
 
   read-yaml-file@1.1.0:
     dependencies:
@@ -15713,6 +19757,8 @@ snapshots:
 
   readdirp@4.1.2: {}
 
+  readdirp@5.0.0: {}
+
   recast@0.23.11:
     dependencies:
       ast-types: 0.16.1
@@ -15745,7 +19791,13 @@ snapshots:
       get-proto: 1.0.1
       which-builtin-type: 1.2.1
 
-  regenerator-runtime@0.14.1: {}
+  regenerate-unicode-properties@10.2.2:
+    dependencies:
+      regenerate: 1.4.2
+
+  regenerate@1.4.2: {}
+
+  regenerator-runtime@0.13.11: {}
 
   regexp.prototype.flags@1.5.4:
     dependencies:
@@ -15756,30 +19808,66 @@ snapshots:
       gopd: 1.2.0
       set-function-name: 2.0.2
 
+  regexpu-core@6.4.0:
+    dependencies:
+      regenerate: 1.4.2
+      regenerate-unicode-properties: 10.2.2
+      regjsgen: 0.8.0
+      regjsparser: 0.13.0
+      unicode-match-property-ecmascript: 2.0.0
+      unicode-match-property-value-ecmascript: 2.2.1
+
+  regjsgen@0.8.0: {}
+
+  regjsparser@0.13.0:
+    dependencies:
+      jsesc: 3.1.0
+
   require-directory@2.1.1: {}
 
   require-from-string@2.0.2: {}
 
+  requireg@0.2.2:
+    dependencies:
+      nested-error-stacks: 2.0.1
+      rc: 1.2.8
+      resolve: 1.7.1
+
   requires-port@1.0.0: {}
 
+  resolve-from@3.0.0: {}
+
   resolve-from@4.0.0: {}
 
   resolve-from@5.0.0: {}
 
   resolve-pkg-maps@1.0.0: {}
 
+  resolve-workspace-root@2.0.1: {}
+
+  resolve.exports@2.0.3: {}
+
   resolve@1.22.10:
     dependencies:
       is-core-module: 2.16.1
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
+  resolve@1.7.1:
+    dependencies:
+      path-parse: 1.0.7
+
   resolve@2.0.0-next.5:
     dependencies:
       is-core-module: 2.16.1
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
+  restore-cursor@2.0.0:
+    dependencies:
+      onetime: 2.0.1
+      signal-exit: 3.0.7
+
   restore-cursor@5.1.0:
     dependencies:
       onetime: 7.0.0
@@ -15798,7 +19886,7 @@ snapshots:
   rollup-plugin-preserve-directives@0.4.0(rollup@4.52.5):
     dependencies:
       '@rollup/pluginutils': 5.3.0(rollup@4.52.5)
-      magic-string: 0.30.19
+      magic-string: 0.30.21
       rollup: 4.52.5
 
   rollup@4.52.3:
@@ -15859,7 +19947,7 @@ snapshots:
 
   rou3@0.5.1: {}
 
-  rou3@0.7.8: {}
+  rou3@0.7.12: {}
 
   router@2.2.0:
     dependencies:
@@ -15871,39 +19959,37 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  rrweb-cssom@0.8.0: {}
-
   run-parallel@1.2.0:
     dependencies:
       queue-microtask: 1.2.3
 
-  rxdb@16.19.1(rxjs@7.8.2)(socks@2.8.7):
+  rxdb@16.21.1(rxjs@7.8.2)(socks@2.8.7):
     dependencies:
       '@babel/runtime': 7.28.4
       '@types/clone': 2.1.4
       '@types/cors': 2.8.19
-      '@types/express': 5.0.3
-      '@types/simple-peer': 9.11.8
+      '@types/express': 5.0.5
+      '@types/simple-peer': 9.11.9
       '@types/ws': 8.18.1
       ajv: 8.17.1
       ajv-formats: 3.0.1(ajv@8.17.1)
       array-push-at-sort-position: 4.0.1
       as-typed: 1.3.2
-      broadcast-channel: 7.1.0
+      broadcast-channel: 7.2.0
       crypto-js: 4.2.0
       custom-idle-queue: 4.1.0
       dexie: 4.0.10
       event-reduce-js: 5.2.7
       firebase: 11.10.0
       get-graphql-from-jsonschema: 8.1.0
-      graphql: 15.10.1
-      graphql-ws: 5.16.2(graphql@15.10.1)
+      graphql: 16.12.0
+      graphql-ws: 5.16.2(graphql@16.12.0)
       is-my-json-valid: 2.20.6
       isomorphic-ws: 5.0.0(ws@8.18.3)
       js-base64: 3.7.8
       jsonschema-key-compression: 1.7.0
       mingo: 6.5.6
-      mongodb: 6.18.0(socks@2.8.7)
+      mongodb: 6.21.0(socks@2.8.7)
       nats: 2.29.3
       oblivious-set: 1.4.0
       reconnecting-websocket: 4.4.0
@@ -15964,10 +20050,14 @@ snapshots:
     optionalDependencies:
       '@parcel/watcher': 2.5.1
 
+  sax@1.4.4: {}
+
   saxes@6.0.0:
     dependencies:
       xmlchars: 2.2.0
 
+  scheduler@0.25.0: {}
+
   scheduler@0.27.0: {}
 
   semver@5.7.2: {}
@@ -15978,6 +20068,8 @@ snapshots:
     dependencies:
       lru-cache: 6.0.0
 
+  semver@7.6.3: {}
+
   semver@7.7.2: {}
 
   semver@7.7.3: {}
@@ -16016,12 +20108,20 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  serialize-error@2.1.0: {}
+
   seroval-plugins@1.3.3(seroval@1.3.2):
     dependencies:
       seroval: 1.3.2
 
+  seroval-plugins@1.4.0(seroval@1.4.2):
+    dependencies:
+      seroval: 1.4.2
+
   seroval@1.3.2: {}
 
+  seroval@1.4.2: {}
+
   serve-static@1.16.2:
     dependencies:
       encodeurl: 2.0.0
@@ -16040,7 +20140,9 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  set-cookie-parser@2.7.1: {}
+  server-only@0.0.1: {}
+
+  set-cookie-parser@2.7.2: {}
 
   set-function-length@1.2.2:
     dependencies:
@@ -16066,6 +20168,10 @@ snapshots:
 
   setprototypeof@1.2.0: {}
 
+  sf-symbols-typescript@2.2.0: {}
+
+  shallowequal@1.1.0: {}
+
   shebang-command@1.2.0:
     dependencies:
       shebang-regex: 1.0.0
@@ -16087,32 +20193,40 @@ snapshots:
       interpret: 1.4.0
       rechoir: 0.6.2
 
-  sherif-darwin-arm64@1.6.1:
+  sherif-darwin-arm64@1.9.0:
     optional: true
 
-  sherif-darwin-x64@1.6.1:
+  sherif-darwin-x64@1.9.0:
     optional: true
 
-  sherif-linux-arm64@1.6.1:
+  sherif-linux-arm64-musl@1.9.0:
     optional: true
 
-  sherif-linux-x64@1.6.1:
+  sherif-linux-arm64@1.9.0:
     optional: true
 
-  sherif-windows-arm64@1.6.1:
+  sherif-linux-x64-musl@1.9.0:
     optional: true
 
-  sherif-windows-x64@1.6.1:
+  sherif-linux-x64@1.9.0:
     optional: true
 
-  sherif@1.6.1:
+  sherif-windows-arm64@1.9.0:
+    optional: true
+
+  sherif-windows-x64@1.9.0:
+    optional: true
+
+  sherif@1.9.0:
     optionalDependencies:
-      sherif-darwin-arm64: 1.6.1
-      sherif-darwin-x64: 1.6.1
-      sherif-linux-arm64: 1.6.1
-      sherif-linux-x64: 1.6.1
-      sherif-windows-arm64: 1.6.1
-      sherif-windows-x64: 1.6.1
+      sherif-darwin-arm64: 1.9.0
+      sherif-darwin-x64: 1.9.0
+      sherif-linux-arm64: 1.9.0
+      sherif-linux-arm64-musl: 1.9.0
+      sherif-linux-x64: 1.9.0
+      sherif-linux-x64-musl: 1.9.0
+      sherif-windows-arm64: 1.9.0
+      sherif-windows-x64: 1.9.0
 
   shx@0.4.0:
     dependencies:
@@ -16164,7 +20278,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  simple-git@3.28.0:
+  simple-git@3.30.0:
     dependencies:
       '@kwsites/file-exists': 1.1.1
       '@kwsites/promise-deferred': 1.1.1
@@ -16184,6 +20298,24 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  simple-plist@1.3.1:
+    dependencies:
+      bplist-creator: 0.1.0
+      bplist-parser: 0.3.1
+      plist: 3.1.0
+
+  simple-swizzle@0.2.4:
+    dependencies:
+      is-arrayish: 0.3.4
+
+  sirv@3.0.2:
+    dependencies:
+      '@polka/url': 1.0.0-next.29
+      mrmime: 2.0.1
+      totalist: 3.0.1
+
+  sisteransi@1.0.5: {}
+
   slash@3.0.0: {}
 
   slice-ansi@5.0.0:
@@ -16196,9 +20328,11 @@ snapshots:
       ansi-styles: 6.2.3
       is-fullwidth-code-point: 5.1.0
 
+  slugify@1.6.6: {}
+
   smart-buffer@4.2.0: {}
 
-  smol-toml@1.4.2: {}
+  smol-toml@1.5.2: {}
 
   socket.io-adapter@2.5.5:
     dependencies:
@@ -16243,18 +20377,18 @@ snapshots:
       ip-address: 10.0.1
       smart-buffer: 4.2.0
 
-  solid-js@1.9.9:
+  solid-js@1.9.10:
     dependencies:
-      csstype: 3.1.3
+      csstype: 3.2.3
       seroval: 1.3.2
       seroval-plugins: 1.3.3(seroval@1.3.2)
 
-  solid-refresh@0.6.3(solid-js@1.9.9):
+  solid-refresh@0.6.3(solid-js@1.9.10):
     dependencies:
-      '@babel/generator': 7.28.3
-      '@babel/helper-module-imports': 7.27.1
-      '@babel/types': 7.28.4
-      solid-js: 1.9.9
+      '@babel/generator': 7.28.6
+      '@babel/helper-module-imports': 7.28.6
+      '@babel/types': 7.28.6
+      solid-js: 1.9.10
     transitivePeerDependencies:
       - supports-color
 
@@ -16267,6 +20401,8 @@ snapshots:
       buffer-from: 1.1.2
       source-map: 0.6.1
 
+  source-map@0.5.7: {}
+
   source-map@0.6.1: {}
 
   source-map@0.7.6: {}
@@ -16294,11 +20430,13 @@ snapshots:
 
   spdx-license-ids@3.0.22: {}
 
+  split-on-first@1.1.0: {}
+
   split2@4.2.0: {}
 
   sprintf-js@1.0.3: {}
 
-  srvx@0.8.16: {}
+  srvx@0.10.1: {}
 
   ssri@12.0.0:
     dependencies:
@@ -16306,8 +20444,18 @@ snapshots:
 
   stable-hash-x@0.2.0: {}
 
+  stack-utils@2.0.6:
+    dependencies:
+      escape-string-regexp: 2.0.0
+
   stackback@0.0.2: {}
 
+  stackframe@1.3.4: {}
+
+  stacktrace-parser@0.1.11:
+    dependencies:
+      type-fest: 0.7.1
+
   statuses@1.5.0: {}
 
   statuses@2.0.1: {}
@@ -16323,6 +20471,8 @@ snapshots:
       es-errors: 1.3.0
       internal-slot: 1.1.0
 
+  stream-buffers@2.2.0: {}
+
   streamroller@3.1.5:
     dependencies:
       date-format: 4.0.14
@@ -16331,6 +20481,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  strict-uri-encode@2.0.0: {}
+
   string-argv@0.3.2: {}
 
   string-width@4.2.3:
@@ -16399,6 +20551,10 @@ snapshots:
     dependencies:
       safe-buffer: 5.2.1
 
+  strip-ansi@5.2.0:
+    dependencies:
+      ansi-regex: 4.1.1
+
   strip-ansi@6.0.1:
     dependencies:
       ansi-regex: 5.0.1
@@ -16417,14 +20573,18 @@ snapshots:
     dependencies:
       min-indent: 1.0.1
 
+  strip-json-comments@2.0.1: {}
+
   strip-json-comments@3.1.1: {}
 
-  strip-json-comments@5.0.2: {}
+  strip-json-comments@5.0.3: {}
 
   strip-literal@3.0.0:
     dependencies:
       js-tokens: 9.0.1
 
+  structured-headers@0.4.1: {}
+
   style-to-object@1.0.9:
     dependencies:
       inline-style-parser: 0.2.4
@@ -16439,6 +20599,14 @@ snapshots:
       pirates: 4.0.7
       ts-interface-checker: 0.1.13
 
+  superjson@2.2.6:
+    dependencies:
+      copy-anything: 4.0.5
+
+  supports-color@5.5.0:
+    dependencies:
+      has-flag: 3.0.0
+
   supports-color@7.2.0:
     dependencies:
       has-flag: 4.0.0
@@ -16447,42 +20615,48 @@ snapshots:
     dependencies:
       has-flag: 4.0.0
 
+  supports-hyperlinks@2.3.0:
+    dependencies:
+      has-flag: 4.0.0
+      supports-color: 7.2.0
+
   supports-preserve-symlinks-flag@1.0.0: {}
 
-  svelte-check@4.3.3(picomatch@4.0.3)(svelte@5.41.0)(typescript@5.9.3):
+  svelte-check@4.3.5(picomatch@4.0.3)(svelte@5.46.4)(typescript@5.9.3):
     dependencies:
       '@jridgewell/trace-mapping': 0.3.31
       chokidar: 4.0.3
       fdir: 6.5.0(picomatch@4.0.3)
       picocolors: 1.1.1
       sade: 1.8.1
-      svelte: 5.41.0
+      svelte: 5.46.4
       typescript: 5.9.3
     transitivePeerDependencies:
       - picomatch
 
-  svelte2tsx@0.7.42(svelte@5.41.0)(typescript@5.9.3):
+  svelte2tsx@0.7.42(svelte@5.46.4)(typescript@5.9.3):
     dependencies:
       dedent-js: 1.0.1
       pascal-case: 3.1.2
-      svelte: 5.41.0
+      svelte: 5.46.4
       typescript: 5.9.3
 
-  svelte@5.41.0:
+  svelte@5.46.4:
     dependencies:
       '@jridgewell/remapping': 2.3.5
       '@jridgewell/sourcemap-codec': 1.5.5
-      '@sveltejs/acorn-typescript': 1.0.5(acorn@8.15.0)
+      '@sveltejs/acorn-typescript': 1.0.8(acorn@8.15.0)
       '@types/estree': 1.0.8
       acorn: 8.15.0
       aria-query: 5.3.2
       axobject-query: 4.1.0
       clsx: 2.1.1
+      devalue: 5.6.2
       esm-env: 1.2.2
-      esrap: 2.1.0
+      esrap: 2.2.1
       is-reference: 3.0.3
       locate-character: 3.0.0
-      magic-string: 0.30.19
+      magic-string: 0.30.21
       zimmerframe: 1.1.4
 
   symbol-tree@3.2.4: {}
@@ -16491,34 +20665,9 @@ snapshots:
     dependencies:
       '@pkgr/core': 0.2.9
 
-  tailwindcss@3.4.18:
-    dependencies:
-      '@alloc/quick-lru': 5.2.0
-      arg: 5.0.2
-      chokidar: 3.6.0
-      didyoumean: 1.2.2
-      dlv: 1.1.3
-      fast-glob: 3.3.3
-      glob-parent: 6.0.2
-      is-glob: 4.0.3
-      jiti: 1.21.7
-      lilconfig: 3.1.3
-      micromatch: 4.0.8
-      normalize-path: 3.0.0
-      object-hash: 3.0.0
-      picocolors: 1.1.1
-      postcss: 8.5.6
-      postcss-import: 15.1.0(postcss@8.5.6)
-      postcss-js: 4.0.1(postcss@8.5.6)
-      postcss-load-config: 4.0.2(postcss@8.5.6)
-      postcss-nested: 6.2.0(postcss@8.5.6)
-      postcss-selector-parser: 6.1.2
-      resolve: 1.22.10
-      sucrase: 3.35.0
-    transitivePeerDependencies:
-      - ts-node
+  tailwind-merge@2.6.0: {}
 
-  tailwindcss@4.1.14: {}
+  tailwindcss@4.1.18: {}
 
   tapable@2.2.3: {}
 
@@ -16539,6 +20688,8 @@ snapshots:
       minizlib: 3.1.0
       yallist: 5.0.0
 
+  temp-dir@2.0.0: {}
+
   temporal-polyfill@0.3.0:
     dependencies:
       temporal-spec: 0.3.0
@@ -16547,13 +20698,23 @@ snapshots:
 
   term-size@2.2.1: {}
 
+  terminal-link@2.1.1:
+    dependencies:
+      ansi-escapes: 4.3.2
+      supports-hyperlinks: 2.3.0
+
   terser@5.44.0:
     dependencies:
       '@jridgewell/source-map': 0.3.11
       acorn: 8.15.0
       commander: 2.20.3
       source-map-support: 0.5.21
-    optional: true
+
+  test-exclude@6.0.0:
+    dependencies:
+      '@istanbuljs/schema': 0.1.3
+      glob: 7.2.3
+      minimatch: 3.1.2
 
   test-exclude@7.0.1:
     dependencies:
@@ -16571,6 +20732,8 @@ snapshots:
     dependencies:
       any-promise: 1.3.0
 
+  throat@5.0.0: {}
+
   through@2.3.8: {}
 
   tiny-invariant@1.3.3: {}
@@ -16605,12 +20768,16 @@ snapshots:
 
   tmp@0.2.5: {}
 
+  tmpl@1.0.5: {}
+
   to-regex-range@5.0.1:
     dependencies:
       is-number: 7.0.0
 
   toidentifier@1.0.1: {}
 
+  totalist@3.0.1: {}
+
   tough-cookie@6.0.0:
     dependencies:
       tldts: 7.0.16
@@ -16633,7 +20800,7 @@ snapshots:
 
   tree-kill@1.2.2: {}
 
-  ts-api-utils@2.1.0(typescript@5.9.3):
+  ts-api-utils@2.3.0(typescript@5.9.3):
     dependencies:
       typescript: 5.9.3
 
@@ -16648,15 +20815,21 @@ snapshots:
     optionalDependencies:
       typescript: 5.9.3
 
+  tslib@1.14.1: {}
+
   tslib@2.8.1: {}
 
-  tsx@4.20.6:
+  tsx@4.21.0:
     dependencies:
-      esbuild: 0.25.11
+      esbuild: 0.27.2
       get-tsconfig: 4.10.1
     optionalDependencies:
       fsevents: 2.3.3
 
+  tsyringe@4.10.0:
+    dependencies:
+      tslib: 1.14.1
+
   tuf-js@3.1.0:
     dependencies:
       '@tufjs/models': 3.0.1
@@ -16671,8 +20844,12 @@ snapshots:
     dependencies:
       prelude-ls: 1.2.1
 
+  type-detect@4.0.8: {}
+
   type-fest@0.21.3: {}
 
+  type-fest@0.7.1: {}
+
   type-is@1.6.18:
     dependencies:
       media-typer: 0.3.0
@@ -16735,21 +20912,19 @@ snapshots:
       typescript: 5.9.3
       yaml: 2.8.1
 
-  typescript-eslint@8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3):
+  typescript-eslint@8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3):
     dependencies:
-      '@typescript-eslint/eslint-plugin': 8.44.1(@typescript-eslint/parser@8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      '@typescript-eslint/parser': 8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      '@typescript-eslint/typescript-estree': 8.44.1(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.44.1(eslint@9.38.0(jiti@2.6.0))(typescript@5.9.3)
-      eslint: 9.38.0(jiti@2.6.0)
+      '@typescript-eslint/eslint-plugin': 8.47.0(@typescript-eslint/parser@8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/typescript-estree': 8.47.0(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.47.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      eslint: 9.39.2(jiti@2.6.1)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
   typescript@5.4.2: {}
 
-  typescript@5.8.3: {}
-
   typescript@5.9.3: {}
 
   ua-parser-js@0.7.41: {}
@@ -16767,12 +20942,23 @@ snapshots:
 
   uncrypto@0.1.3: {}
 
-  undici-types@6.21.0: {}
-
   undici-types@7.14.0: {}
 
+  undici@6.23.0: {}
+
   undici@7.16.0: {}
 
+  unicode-canonical-property-names-ecmascript@2.0.1: {}
+
+  unicode-match-property-ecmascript@2.0.0:
+    dependencies:
+      unicode-canonical-property-names-ecmascript: 2.0.1
+      unicode-property-aliases-ecmascript: 2.2.0
+
+  unicode-match-property-value-ecmascript@2.2.1: {}
+
+  unicode-property-aliases-ecmascript@2.2.0: {}
+
   unique-filename@4.0.0:
     dependencies:
       unique-slug: 5.0.0
@@ -16781,6 +20967,10 @@ snapshots:
     dependencies:
       imurmurhash: 0.1.4
 
+  unique-string@2.0.0:
+    dependencies:
+      crypto-random-string: 2.0.0
+
   universalify@0.1.2: {}
 
   universalify@2.0.1: {}
@@ -16820,9 +21010,9 @@ snapshots:
       '@unrs/resolver-binding-win32-ia32-msvc': 1.11.1
       '@unrs/resolver-binding-win32-x64-msvc': 1.11.1
 
-  update-browserslist-db@1.1.3(browserslist@4.25.4):
+  update-browserslist-db@1.1.4(browserslist@4.28.0):
     dependencies:
-      browserslist: 4.25.4
+      browserslist: 4.28.0
       escalade: 3.2.0
       picocolors: 1.1.1
 
@@ -16830,9 +21020,13 @@ snapshots:
     dependencies:
       punycode: 2.3.1
 
-  use-sync-external-store@1.6.0(react@19.2.0):
+  use-latest-callback@0.2.6(react@19.2.3):
+    dependencies:
+      react: 19.2.3
+
+  use-sync-external-store@1.6.0(react@19.2.3):
     dependencies:
-      react: 19.2.0
+      react: 19.2.3
 
   util-deprecate@1.0.2: {}
 
@@ -16848,6 +21042,8 @@ snapshots:
 
   uuid@13.0.0: {}
 
+  uuid@7.0.3: {}
+
   validate-html-nesting@1.2.3: {}
 
   validate-npm-package-license@3.0.4:
@@ -16855,19 +21051,21 @@ snapshots:
       spdx-correct: 3.2.0
       spdx-expression-parse: 3.0.1
 
+  validate-npm-package-name@5.0.1: {}
+
   validate-npm-package-name@6.0.2: {}
 
   validator@13.15.15: {}
 
   vary@1.1.2: {}
 
-  vite-node@3.2.4(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1):
+  vite-node@3.2.4(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1):
     dependencies:
       cac: 6.7.14
       debug: 4.4.3
       es-module-lexer: 1.7.0
       pathe: 2.0.3
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
     transitivePeerDependencies:
       - '@types/node'
       - jiti
@@ -16882,7 +21080,7 @@ snapshots:
       - tsx
       - yaml
 
-  vite-plugin-dts@4.2.3(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
+  vite-plugin-dts@4.2.3(@types/node@24.7.0)(rollup@4.52.5)(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)):
     dependencies:
       '@microsoft/api-extractor': 7.47.7(@types/node@24.7.0)
       '@rollup/pluginutils': 5.3.0(rollup@4.52.5)
@@ -16892,135 +21090,46 @@ snapshots:
       debug: 4.4.3
       kolorist: 1.8.0
       local-pkg: 0.5.1
-      magic-string: 0.30.19
+      magic-string: 0.30.21
       typescript: 5.9.3
     optionalDependencies:
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
     transitivePeerDependencies:
       - '@types/node'
       - rollup
       - supports-color
 
-  vite-plugin-externalize-deps@0.10.0(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
-    dependencies:
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-
-  vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
-    dependencies:
-      '@babel/core': 7.28.4
-      '@types/babel__core': 7.20.5
-      babel-preset-solid: 1.9.9(@babel/core@7.28.4)(solid-js@1.9.9)
-      merge-anything: 5.1.7
-      solid-js: 1.9.9
-      solid-refresh: 0.6.3(solid-js@1.9.9)
-      vite: 6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vitefu: 1.1.1(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-    optionalDependencies:
-      '@testing-library/jest-dom': 6.9.1
-    transitivePeerDependencies:
-      - supports-color
-
-  vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
+  vite-plugin-externalize-deps@0.10.0(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)):
     dependencies:
-      '@babel/core': 7.28.4
-      '@types/babel__core': 7.20.5
-      babel-preset-solid: 1.9.9(@babel/core@7.28.4)(solid-js@1.9.9)
-      merge-anything: 5.1.7
-      solid-js: 1.9.9
-      solid-refresh: 0.6.3(solid-js@1.9.9)
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vitefu: 1.1.1(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
-    optionalDependencies:
-      '@testing-library/jest-dom': 6.9.1
-    transitivePeerDependencies:
-      - supports-color
-    optional: true
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
 
-  vite-plugin-solid@2.11.9(@testing-library/jest-dom@6.9.1)(solid-js@1.9.9)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
+  vite-plugin-solid@2.11.10(@testing-library/jest-dom@6.9.1)(solid-js@1.9.10)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)):
     dependencies:
-      '@babel/core': 7.28.4
+      '@babel/core': 7.28.5
       '@types/babel__core': 7.20.5
-      babel-preset-solid: 1.9.9(@babel/core@7.28.4)(solid-js@1.9.9)
+      babel-preset-solid: 1.9.9(@babel/core@7.28.5)(solid-js@1.9.10)
       merge-anything: 5.1.7
-      solid-js: 1.9.9
-      solid-refresh: 0.6.3(solid-js@1.9.9)
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vitefu: 1.1.1(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      solid-js: 1.9.10
+      solid-refresh: 0.6.3(solid-js@1.9.10)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+      vitefu: 1.1.1(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
     optionalDependencies:
       '@testing-library/jest-dom': 6.9.1
     transitivePeerDependencies:
       - supports-color
 
-  vite-tsconfig-paths@5.1.4(typescript@5.9.3)(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
-    dependencies:
-      debug: 4.4.3
-      globrex: 0.1.2
-      tsconfck: 3.1.6(typescript@5.9.3)
-    optionalDependencies:
-      vite: 6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-
-  vite-tsconfig-paths@5.1.4(typescript@5.9.3)(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
-    dependencies:
-      debug: 4.4.3
-      globrex: 0.1.2
-      tsconfck: 3.1.6(typescript@5.9.3)
-    optionalDependencies:
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-
-  vite-tsconfig-paths@5.1.4(typescript@5.9.3)(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
+  vite-tsconfig-paths@5.1.4(typescript@5.9.3)(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)):
     dependencies:
       debug: 4.4.3
       globrex: 0.1.2
       tsconfck: 3.1.6(typescript@5.9.3)
     optionalDependencies:
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
     transitivePeerDependencies:
       - supports-color
       - typescript
 
-  vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1):
-    dependencies:
-      esbuild: 0.25.11
-      fdir: 6.5.0(picomatch@4.0.3)
-      picomatch: 4.0.3
-      postcss: 8.5.6
-      rollup: 4.52.5
-      tinyglobby: 0.2.15
-    optionalDependencies:
-      '@types/node': 22.18.1
-      fsevents: 2.3.3
-      jiti: 2.6.0
-      lightningcss: 1.30.1
-      sass: 1.90.0
-      terser: 5.44.0
-      tsx: 4.20.6
-      yaml: 2.8.1
-
-  vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1):
-    dependencies:
-      esbuild: 0.25.11
-      fdir: 6.5.0(picomatch@4.0.3)
-      picomatch: 4.0.3
-      postcss: 8.5.6
-      rollup: 4.52.5
-      tinyglobby: 0.2.15
-    optionalDependencies:
-      '@types/node': 24.7.0
-      fsevents: 2.3.3
-      jiti: 2.6.0
-      lightningcss: 1.30.1
-      sass: 1.90.0
-      terser: 5.44.0
-      tsx: 4.20.6
-      yaml: 2.8.1
-
-  vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1):
+  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.21.0)(yaml@2.8.1):
     dependencies:
       esbuild: 0.25.11
       fdir: 6.5.0(picomatch@4.0.3)
@@ -17031,16 +21140,16 @@ snapshots:
     optionalDependencies:
       '@types/node': 24.7.0
       fsevents: 2.3.3
-      jiti: 2.6.0
-      lightningcss: 1.30.1
+      jiti: 2.6.1
+      lightningcss: 1.30.2
       sass: 1.90.0
       terser: 5.44.0
-      tsx: 4.20.6
+      tsx: 4.21.0
       yaml: 2.8.1
 
-  vite@7.1.5(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1):
+  vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1):
     dependencies:
-      esbuild: 0.25.11
+      esbuild: 0.27.2
       fdir: 6.5.0(picomatch@4.0.3)
       picomatch: 4.0.3
       postcss: 8.5.6
@@ -17049,30 +21158,22 @@ snapshots:
     optionalDependencies:
       '@types/node': 24.7.0
       fsevents: 2.3.3
-      jiti: 2.6.0
-      lightningcss: 1.30.1
+      jiti: 2.6.1
+      lightningcss: 1.30.2
       sass: 1.90.0
       terser: 5.44.0
-      tsx: 4.20.6
+      tsx: 4.21.0
       yaml: 2.8.1
 
-  vitefu@1.1.1(vite@6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
-    optionalDependencies:
-      vite: 6.4.1(@types/node@22.18.1)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-
-  vitefu@1.1.1(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
-    optionalDependencies:
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-
-  vitefu@1.1.1(vite@7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)):
+  vitefu@1.1.1(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)):
     optionalDependencies:
-      vite: 7.1.11(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
 
-  vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(jiti@2.6.0)(jsdom@27.0.1(postcss@8.5.6))(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1):
+  vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.7.0)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1):
     dependencies:
       '@types/chai': 5.2.2
       '@vitest/expect': 3.2.4
-      '@vitest/mocker': 3.2.4(vite@6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
+      '@vitest/mocker': 3.2.4(vite@7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1))
       '@vitest/pretty-format': 3.2.4
       '@vitest/runner': 3.2.4
       '@vitest/snapshot': 3.2.4
@@ -17081,7 +21182,7 @@ snapshots:
       chai: 5.3.3
       debug: 4.4.3
       expect-type: 1.2.2
-      magic-string: 0.30.19
+      magic-string: 0.30.21
       pathe: 2.0.3
       picomatch: 4.0.3
       std-env: 3.9.0
@@ -17090,13 +21191,14 @@ snapshots:
       tinyglobby: 0.2.15
       tinypool: 1.1.1
       tinyrainbow: 2.0.0
-      vite: 6.4.1(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
-      vite-node: 3.2.4(@types/node@24.7.0)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.90.0)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1)
+      vite: 7.3.1(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
+      vite-node: 3.2.4(@types/node@24.7.0)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.90.0)(terser@5.44.0)(tsx@4.21.0)(yaml@2.8.1)
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/debug': 4.1.12
       '@types/node': 24.7.0
-      jsdom: 27.0.1(postcss@8.5.6)
+      '@vitest/ui': 3.2.4(vitest@3.2.4)
+      jsdom: 27.4.0
     transitivePeerDependencies:
       - jiti
       - less
@@ -17111,14 +21213,16 @@ snapshots:
       - tsx
       - yaml
 
+  vlq@1.0.1: {}
+
   void-elements@2.0.1: {}
 
   vscode-uri@3.1.0: {}
 
-  vue-eslint-parser@10.2.0(eslint@9.38.0(jiti@2.6.0)):
+  vue-eslint-parser@10.2.0(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
       debug: 4.4.3
-      eslint: 9.38.0(jiti@2.6.0)
+      eslint: 9.39.2(jiti@2.6.1)
       eslint-scope: 8.4.0
       eslint-visitor-keys: 4.2.1
       espree: 10.4.0
@@ -17127,13 +21231,13 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  vue@3.5.22(typescript@5.9.3):
+  vue@3.5.26(typescript@5.9.3):
     dependencies:
-      '@vue/compiler-dom': 3.5.22
-      '@vue/compiler-sfc': 3.5.22
-      '@vue/runtime-dom': 3.5.22
-      '@vue/server-renderer': 3.5.22(vue@3.5.22(typescript@5.9.3))
-      '@vue/shared': 3.5.22
+      '@vue/compiler-dom': 3.5.26
+      '@vue/compiler-sfc': 3.5.26
+      '@vue/runtime-dom': 3.5.26
+      '@vue/server-renderer': 3.5.26(vue@3.5.26(typescript@5.9.3))
+      '@vue/shared': 3.5.26
     optionalDependencies:
       typescript: 5.9.3
 
@@ -17143,11 +21247,21 @@ snapshots:
 
   walk-up-path@4.0.0: {}
 
+  walker@1.0.8:
+    dependencies:
+      makeerror: 1.0.12
+
+  warn-once@0.1.1: {}
+
   watchpack@2.4.4:
     dependencies:
       glob-to-regexp: 0.4.1
       graceful-fs: 4.2.11
 
+  wcwidth@1.0.1:
+    dependencies:
+      defaults: 1.0.4
+
   weak-lru-cache@1.2.2:
     optional: true
 
@@ -17157,6 +21271,8 @@ snapshots:
 
   webidl-conversions@3.0.1: {}
 
+  webidl-conversions@5.0.0: {}
+
   webidl-conversions@7.0.0: {}
 
   webidl-conversions@8.0.0: {}
@@ -17175,8 +21291,16 @@ snapshots:
     dependencies:
       iconv-lite: 0.6.3
 
+  whatwg-fetch@3.6.20: {}
+
   whatwg-mimetype@4.0.0: {}
 
+  whatwg-url-without-unicode@8.0.0-3:
+    dependencies:
+      buffer: 5.7.1
+      punycode: 2.3.1
+      webidl-conversions: 5.0.0
+
   whatwg-url@14.2.0:
     dependencies:
       tr46: 5.1.1
@@ -17255,6 +21379,8 @@ snapshots:
       siginfo: 2.0.0
       stackback: 0.0.2
 
+  wonka@6.3.5: {}
+
   word-wrap@1.2.5: {}
 
   wrap-ansi@6.2.0:
@@ -17283,18 +21409,43 @@ snapshots:
 
   wrappy@1.0.2: {}
 
+  write-file-atomic@4.0.2:
+    dependencies:
+      imurmurhash: 0.1.4
+      signal-exit: 3.0.7
+
+  ws@6.2.3:
+    dependencies:
+      async-limiter: 1.0.1
+
+  ws@7.5.10: {}
+
   ws@8.17.1: {}
 
   ws@8.18.3: {}
 
+  xcode@3.0.1:
+    dependencies:
+      simple-plist: 1.3.1
+      uuid: 7.0.3
+
   xml-name-validator@5.0.0: {}
 
-  xmlbuilder2@3.1.1:
+  xml2js@0.6.0:
     dependencies:
-      '@oozcitak/dom': 1.15.10
-      '@oozcitak/infra': 1.0.8
-      '@oozcitak/util': 8.3.8
-      js-yaml: 3.14.1
+      sax: 1.4.4
+      xmlbuilder: 11.0.1
+
+  xmlbuilder2@4.0.3:
+    dependencies:
+      '@oozcitak/dom': 2.0.2
+      '@oozcitak/infra': 2.0.2
+      '@oozcitak/util': 10.0.0
+      js-yaml: 4.1.1
+
+  xmlbuilder@11.0.1: {}
+
+  xmlbuilder@15.1.1: {}
 
   xmlchars@2.2.0: {}
 
@@ -17359,12 +21510,12 @@ snapshots:
 
   zimmerframe@1.1.4: {}
 
-  zod-to-json-schema@3.24.6(zod@3.25.76):
+  zod-to-json-schema@3.25.0(zod@4.1.13):
     dependencies:
-      zod: 3.25.76
+      zod: 4.1.13
 
   zod@3.25.76: {}
 
-  zod@4.1.11: {}
+  zod@4.1.13: {}
 
-  zone.js@0.15.1: {}
+  zone.js@0.16.0: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 78eca2b88..18dafa94f 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -4,4 +4,4 @@ preferWorkspacePackages: true
 
 packages:
   - packages/**
-  - examples/**
+  - examples/**/*
diff --git a/prettier.config.js b/prettier.config.js
new file mode 100644
index 000000000..2c53b10e3
--- /dev/null
+++ b/prettier.config.js
@@ -0,0 +1,10 @@
+// @ts-check
+
+/** @type {import('prettier').Config} */
+const config = {
+  semi: false,
+  singleQuote: true,
+  trailingComma: 'all',
+}
+
+export default config
diff --git a/scripts/generateDocs.ts b/scripts/generate-docs.ts
similarity index 70%
rename from scripts/generateDocs.ts
rename to scripts/generate-docs.ts
index 2d09a4a35..cbedd2a3c 100644
--- a/scripts/generateDocs.ts
+++ b/scripts/generate-docs.ts
@@ -1,8 +1,6 @@
-import { resolve } from "node:path"
-import { fileURLToPath } from "node:url"
-import { readFileSync, writeFileSync } from "node:fs"
-import { generateReferenceDocs } from "@tanstack/config/typedoc"
-import { glob } from "tinyglobby"
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { generateReferenceDocs } from '@tanstack/typedoc-config'
 
 const __dirname = fileURLToPath(new URL(`.`, import.meta.url))
 
@@ -21,7 +19,7 @@ await generateReferenceDocs({
       ],
       tsconfig: resolve(
         __dirname,
-        `../packages/electric-db-collection/tsconfig.docs.json`
+        `../packages/electric-db-collection/tsconfig.docs.json`,
       ),
       outputDir: resolve(__dirname, `../docs/reference/electric-db-collection`),
       exclude: [`packages/db/**/*`],
@@ -33,11 +31,38 @@ await generateReferenceDocs({
       ],
       tsconfig: resolve(
         __dirname,
-        `../packages/query-db-collection/tsconfig.docs.json`
+        `../packages/query-db-collection/tsconfig.docs.json`,
       ),
       outputDir: resolve(__dirname, `../docs/reference/query-db-collection`),
       exclude: [`packages/db/**/*`],
     },
+    {
+      name: `powersync-db-collection`,
+      entryPoints: [
+        resolve(__dirname, `../packages/powersync-db-collection/src/index.ts`),
+      ],
+      tsconfig: resolve(
+        __dirname,
+        `../packages/powersync-db-collection/tsconfig.docs.json`,
+      ),
+      outputDir: resolve(
+        __dirname,
+        `../docs/reference/powersync-db-collection`,
+      ),
+      exclude: [`packages/db/**/*`],
+    },
+    {
+      name: `rxdb-db-collection`,
+      entryPoints: [
+        resolve(__dirname, `../packages/rxdb-db-collection/src/index.ts`),
+      ],
+      tsconfig: resolve(
+        __dirname,
+        `../packages/rxdb-db-collection/tsconfig.docs.json`,
+      ),
+      outputDir: resolve(__dirname, `../docs/reference/rxdb-db-collection`),
+      exclude: [`packages/db/**/*`],
+    },
     {
       name: `react-db`,
       entryPoints: [resolve(__dirname, `../packages/react-db/src/index.ts`)],
@@ -66,11 +91,11 @@ await generateReferenceDocs({
       ],
       tsconfig: resolve(
         __dirname,
-        `../packages/trailbase-db-collection/tsconfig.docs.json`
+        `../packages/trailbase-db-collection/tsconfig.docs.json`,
       ),
       outputDir: resolve(
         __dirname,
-        `../docs/reference/trailbase-db-collection`
+        `../docs/reference/trailbase-db-collection`,
       ),
       exclude: [`packages/db/**/*`],
     },
@@ -91,32 +116,6 @@ await generateReferenceDocs({
   ],
 })
 
-// Find all markdown files matching the pattern
-const markdownFiles = [
-  ...(await glob(`docs/reference/**/*.md`)),
-  ...(await glob(`docs/framework/*/reference/**/*.md`)),
-]
-
-console.log(`Found ${markdownFiles.length} markdown files to process\n`)
-
-// Process each markdown file
-markdownFiles.forEach((file) => {
-  const content = readFileSync(file, `utf-8`)
-  let updatedContent = content
-  updatedContent = updatedContent.replaceAll(/\]\(\.\.\//gm, `](../../`)
-  // updatedContent = content.replaceAll(/\]\(\.\//gm, '](../')
-  updatedContent = updatedContent.replaceAll(
-    /\]\((?!https?:\/\/|\/\/|\/|\.\/|\.\.\/|#)([^)]+)\)/gm,
-    (match, p1) => `](../${p1})`
-  )
-
-  // Write the updated content back to the file
-  if (updatedContent !== content) {
-    writeFileSync(file, updatedContent, `utf-8`)
-    console.log(`Processed file: ${file}`)
-  }
-})
-
 console.log(`\n✅ All markdown files have been processed!`)
 
 process.exit(0)
diff --git a/scripts/update-example-deps.ts b/scripts/update-example-deps.ts
new file mode 100644
index 000000000..ff9b335ca
--- /dev/null
+++ b/scripts/update-example-deps.ts
@@ -0,0 +1,172 @@
+/**
+ * This script updates @tanstack/* dependencies in example packages
+ * to match the current versions in packages/*.
+ *
+ * It runs as part of `changeset:version` so that the "Version Packages" PR
+ * includes example dependency updates alongside package version bumps.
+ */
+
+import { readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = fileURLToPath(new URL(`.`, import.meta.url))
+const rootDir = resolve(__dirname, `..`)
+
+interface PackageJson {
+  name: string
+  version: string
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+}
+
+// Build a map of @tanstack package names to their current versions
+function getPackageVersions(): Map<string, string> {
+  const packagesDir = join(rootDir, `packages`)
+  const versions = new Map<string, string>()
+
+  for (const dir of readdirSync(packagesDir)) {
+    const packageJsonPath = join(packagesDir, dir, `package.json`)
+    try {
+      const stat = statSync(packageJsonPath)
+      if (!stat.isFile()) continue
+    } catch {
+      continue
+    }
+
+    try {
+      const packageJson: PackageJson = JSON.parse(
+        readFileSync(packageJsonPath, `utf-8`),
+      )
+      // Only include packages that have a name, version, and are @tanstack scoped
+      if (
+        packageJson.name.startsWith(`@tanstack/`) &&
+        packageJson.version &&
+        !packageJson.name.includes(`e2e`) // Skip e2e test packages
+      ) {
+        versions.set(packageJson.name, packageJson.version)
+      }
+    } catch {
+      console.warn(`Warning: Could not parse ${packageJsonPath}`)
+    }
+  }
+
+  return versions
+}
+
+// Find all package.json files in examples directory recursively
+function findExamplePackageJsons(dir: string): Array<string> {
+  const results: Array<string> = []
+
+  // Directories to skip (build artifacts, dependencies, etc.)
+  const skipDirs = new Set([
+    `node_modules`,
+    `.output`,
+    `dist`,
+    `build`,
+    `.next`,
+    `.nuxt`,
+  ])
+
+  for (const entry of readdirSync(dir)) {
+    const fullPath = join(dir, entry)
+
+    if (skipDirs.has(entry)) continue
+
+    try {
+      const stat = statSync(fullPath)
+      if (stat.isDirectory()) {
+        results.push(...findExamplePackageJsons(fullPath))
+      } else if (entry === `package.json`) {
+        results.push(fullPath)
+      }
+    } catch {
+      // Skip files we can't stat
+    }
+  }
+
+  return results
+}
+
+// Update dependencies in a package.json file
+function updateDependencies(
+  deps: Record<string, string> | undefined,
+  versions: Map<string, string>,
+): { updated: boolean; deps: Record<string, string> | undefined } {
+  if (!deps) return { updated: false, deps }
+
+  let updated = false
+  const newDeps = { ...deps }
+
+  for (const [name, currentVersion] of Object.entries(deps)) {
+    if (name.startsWith(`@tanstack/`) && versions.has(name)) {
+      const newVersion = `^${versions.get(name)}`
+      if (currentVersion !== newVersion) {
+        newDeps[name] = newVersion
+        updated = true
+      }
+    }
+  }
+
+  return { updated, deps: newDeps }
+}
+
+function main() {
+  console.log(`\n📦 Updating example dependencies...\n`)
+
+  const versions = getPackageVersions()
+  console.log(`Found ${versions.size} @tanstack packages:`)
+  for (const [name, version] of versions) {
+    console.log(`  ${name}: ${version}`)
+  }
+  console.log()
+
+  const examplesDir = join(rootDir, `examples`)
+  const examplePackageJsons = findExamplePackageJsons(examplesDir)
+
+  let totalUpdated = 0
+
+  for (const packageJsonPath of examplePackageJsons) {
+    const relativePath = packageJsonPath.replace(rootDir + `/`, ``)
+    const content = readFileSync(packageJsonPath, `utf-8`)
+    const packageJson: PackageJson = JSON.parse(content)
+
+    const depsResult = updateDependencies(packageJson.dependencies, versions)
+    const devDepsResult = updateDependencies(
+      packageJson.devDependencies,
+      versions,
+    )
+    const peerDepsResult = updateDependencies(
+      packageJson.peerDependencies,
+      versions,
+    )
+
+    if (depsResult.updated || devDepsResult.updated || peerDepsResult.updated) {
+      const updatedPackageJson = {
+        ...packageJson,
+        dependencies: depsResult.deps,
+        devDependencies: devDepsResult.deps,
+        peerDependencies: peerDepsResult.deps,
+      }
+
+      // Preserve original formatting by detecting indent
+      const indent = content.match(/^(\s+)"/m)?.[1] || `  `
+      writeFileSync(
+        packageJsonPath,
+        JSON.stringify(updatedPackageJson, null, indent) + `\n`,
+      )
+
+      console.log(`✅ Updated: ${relativePath}`)
+      totalUpdated++
+    }
+  }
+
+  if (totalUpdated === 0) {
+    console.log(`No example dependencies needed updating.`)
+  } else {
+    console.log(`\n✅ Updated ${totalUpdated} example package(s).\n`)
+  }
+}
+
+main()
diff --git a/scripts/verify-links.ts b/scripts/verify-links.ts
index 4efcb357c..8a1c40ddc 100644
--- a/scripts/verify-links.ts
+++ b/scripts/verify-links.ts
@@ -1,60 +1,60 @@
-import { existsSync, readFileSync, statSync } from "node:fs"
-import path, { resolve } from "node:path"
-import { glob } from "tinyglobby"
-// @ts-ignore - markdown-link-extractor is not typed
-import markdownLinkExtractor from "markdown-link-extractor"
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { extname, resolve } from 'node:path'
+import { glob } from 'tinyglobby'
+// @ts-ignore Could not find a declaration file for module 'markdown-link-extractor'.
+import markdownLinkExtractor from 'markdown-link-extractor'
+
+const errors: Array<{
+  file: string
+  link: string
+  resolvedPath: string
+  reason: string
+}> = []
 
 function isRelativeLink(link: string) {
   return (
-    link &&
-    !link.startsWith(`/`) &&
-    !link.startsWith(`http://`) &&
-    !link.startsWith(`https://`) &&
-    !link.startsWith(`//`) &&
-    !link.startsWith(`#`) &&
-    !link.startsWith(`mailto:`)
+    !link.startsWith('/') &&
+    !link.startsWith('http://') &&
+    !link.startsWith('https://') &&
+    !link.startsWith('//') &&
+    !link.startsWith('#') &&
+    !link.startsWith('mailto:')
   )
 }
 
-function normalizePath(p: string): string {
-  // Remove any trailing .md
-  p = p.replace(`${path.extname(p)}`, ``)
-  return p
+/** Remove any trailing .md */
+function stripExtension(p: string): string {
+  return p.replace(`${extname(p)}`, '')
 }
 
-function fileExistsForLink(
-  link: string,
-  markdownFile: string,
-  errors: Array<any>
-): boolean {
+function relativeLinkExists(link: string, file: string): boolean {
   // Remove hash if present
-  const filePart = link.split(`#`)[0]
+  const linkWithoutHash = link.split('#')[0]
   // If the link is empty after removing hash, it's not a file
-  if (!filePart) return false
+  if (!linkWithoutHash) return false
 
-  // Normalize the markdown file path
-  markdownFile = normalizePath(markdownFile)
-
-  // Normalize the path
-  const normalizedPath = normalizePath(filePart)
+  // Strip the file/link extensions
+  const filePath = stripExtension(file)
+  const linkPath = stripExtension(linkWithoutHash)
 
   // Resolve the path relative to the markdown file's directory
-  let absPath = resolve(markdownFile, normalizedPath)
+  // Nav up a level to simulate how links are resolved on the web
+  let absPath = resolve(filePath, '..', linkPath)
 
   // Ensure the resolved path is within /docs
-  const docsRoot = resolve(`docs`)
+  const docsRoot = resolve('docs')
   if (!absPath.startsWith(docsRoot)) {
     errors.push({
       link,
-      markdownFile,
+      file,
       resolvedPath: absPath,
-      reason: `navigates above /docs, invalid`,
+      reason: 'Path outside /docs',
     })
     return false
   }
 
   // Check if this is an example path
-  const isExample = absPath.includes(`/examples/`)
+  const isExample = absPath.includes('/examples/')
 
   let exists = false
 
@@ -62,13 +62,13 @@ function fileExistsForLink(
     // Transform /docs/framework/{framework}/examples/ to /examples/{framework}/
     absPath = absPath.replace(
       /\/docs\/framework\/([^/]+)\/examples\//,
-      `/examples/$1/`
+      '/examples/$1/',
     )
     // For examples, we want to check if the directory exists
     exists = existsSync(absPath) && statSync(absPath).isDirectory()
   } else {
     // For non-examples, we want to check if the .md file exists
-    if (!absPath.endsWith(`.md`)) {
+    if (!absPath.endsWith('.md')) {
       absPath = `${absPath}.md`
     }
     exists = existsSync(absPath)
@@ -77,42 +77,34 @@ function fileExistsForLink(
   if (!exists) {
     errors.push({
       link,
-      markdownFile,
+      file,
       resolvedPath: absPath,
-      reason: `not found`,
+      reason: 'Not found',
     })
   }
   return exists
 }
 
-async function findMarkdownLinks() {
+async function verifyMarkdownLinks() {
   // Find all markdown files in docs directory
-  const markdownFiles = await glob(`docs/**/*.md`, {
-    ignore: [`**/node_modules/**`],
+  const markdownFiles = await glob('docs/**/*.md', {
+    ignore: ['**/node_modules/**'],
   })
 
   console.log(`Found ${markdownFiles.length} markdown files\n`)
 
-  const errors: Array<any> = []
-
   // Process each file
   for (const file of markdownFiles) {
-    const content = readFileSync(file, `utf-8`)
-    const links: Array<any> = markdownLinkExtractor(content)
-
-    const filteredLinks = links.filter((link: any) => {
-      if (typeof link === `string`) {
-        return isRelativeLink(link)
-      } else if (link && typeof link.href === `string`) {
-        return isRelativeLink(link.href)
-      }
-      return false
+    const content = readFileSync(file, 'utf-8')
+    const links: Array<string> = markdownLinkExtractor(content)
+
+    const relativeLinks = links.filter((link: string) => {
+      return isRelativeLink(link)
     })
 
-    if (filteredLinks.length > 0) {
-      filteredLinks.forEach((link: any) => {
-        const href = typeof link === `string` ? link : link.href
-        fileExistsForLink(href, file, errors)
+    if (relativeLinks.length > 0) {
+      relativeLinks.forEach((link) => {
+        relativeLinkExists(link, file)
       })
     }
   }
@@ -121,13 +113,13 @@ async function findMarkdownLinks() {
     console.log(`\n❌ Found ${errors.length} broken links:`)
     errors.forEach((err) => {
       console.log(
-        `${err.link}\n  in:    ${err.markdownFile}\n  path:  ${err.resolvedPath}\n  why:   ${err.reason}\n`
+        `${err.file}\n  link:      ${err.link}\n  resolved:  ${err.resolvedPath}\n  why:       ${err.reason}\n`,
       )
     })
     process.exit(1)
   } else {
-    console.log(`\n✅ No broken links found!`)
+    console.log('\n✅ No broken links found!')
   }
 }
 
-findMarkdownLinks().catch(console.error)
+verifyMarkdownLinks().catch(console.error)
diff --git a/tsconfig.json b/tsconfig.json
index fcc600141..153171020 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -34,8 +34,8 @@
     "todo-app/**/*.tsx",
     "examples/**/*.ts",
     "examples/**/*.tsx",
-    "eslint.config.js",
-    "scripts/*.ts"
+    "*.config.*",
+    "scripts"
   ],
   "exclude": ["node_modules"]
 }