Fix potential infinite loops in graph execution and data loading

Add iteration safeguards to prevent infinite loops that can occur
when using Electric with large datasets and ORDER BY/LIMIT queries:

1. `maybeRunGraph` while loop (collection-config-builder.ts):
   - Can loop infinitely when data loading triggers graph updates
   - Happens when WHERE filters out most data, causing dataNeeded() > 0
   - Loading more data triggers updates that get filtered out
   - Added 10,000 iteration limit with error logging

2. `requestLimitedSnapshot` while loop (subscription.ts):
   - Can loop if index iteration has issues
   - Added 10,000 iteration limit with error logging
   - Removed unused `insertedKeys` tracking

3. `D2.run()` while loop (d2.ts):
   - Can loop infinitely on circular data flow bugs
   - Added 100,000 iteration limit with error logging

The safeguards log errors to help debug the root cause while
preventing the app from freezing.

Author: claude

packages/db-ivm/src/d2.ts

@@ -57,7 +57,22 @@ export class D2 implements ID2 {
   }
 
   run(): void {
+    // Safety limit to prevent infinite loops in case of circular data flow
+    // or other bugs that cause operators to perpetually produce output.
+    // For legitimate pipelines, data should flow through in finite steps.
+    const MAX_RUN_ITERATIONS = 100000
+    let iterations = 0
+
     while (this.pendingWork()) {
+      iterations++
+      if (iterations > MAX_RUN_ITERATIONS) {
+        console.error(
+          `[D2 Graph] Execution exceeded ${MAX_RUN_ITERATIONS} iterations. ` +
+            `This may indicate an infinite loop in the dataflow graph. ` +
+            `Breaking out to prevent app freeze.`,
+        )
+        break
+      }
       this.step()
     }
   }

packages/db/src/collection/subscription.ts

@@ -502,8 +502,23 @@ export class CollectionSubscription
         ? compileExpression(new PropRef(orderByExpression.path), true)
         : null
 
+    // Safety limit to prevent infinite loops if the index iteration or filtering
+    // logic has issues. The loop should naturally terminate when the index is
+    // exhausted, but this provides a backstop. 10000 iterations is generous
+    // for any legitimate use case.
+    const MAX_SNAPSHOT_ITERATIONS = 10000
+    let snapshotIterations = 0
+
     while (valuesNeeded() > 0 && !collectionExhausted()) {
-      const insertedKeys = new Set<string | number>() // Track keys we add to `changes` in this iteration
+      snapshotIterations++
+      if (snapshotIterations > MAX_SNAPSHOT_ITERATIONS) {
+        console.error(
+          `[TanStack DB] requestLimitedSnapshot exceeded ${MAX_SNAPSHOT_ITERATIONS} iterations. ` +
+            `This may indicate an infinite loop in index iteration or filtering. ` +
+            `Breaking out to prevent app freeze. Collection: ${this.collection.id}`,
+        )
+        break
+      }
 
       for (const key of keys) {
         const value = this.collection.get(key)!
@@ -515,7 +530,6 @@ export class CollectionSubscription
         // 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)

packages/db/src/query/live/collection-config-builder.ts

@@ -336,7 +336,27 @@ export class CollectionConfigBuilder<
 
       // Always run the graph if subscribed (eager execution)
       if (syncState.subscribedToAllCollections) {
+        // Safety limit to prevent infinite loops when data loading and graph processing
+        // create a feedback cycle. This can happen when:
+        // 1. OrderBy/limit queries filter out most data, causing dataNeeded() > 0
+        // 2. Loading more data triggers updates that get filtered out
+        // 3. The cycle continues indefinitely
+        // 10000 iterations is generous for legitimate use cases but prevents hangs.
+        const MAX_GRAPH_ITERATIONS = 10000
+        let iterations = 0
+
         while (syncState.graph.pendingWork()) {
+          iterations++
+          if (iterations > MAX_GRAPH_ITERATIONS) {
+            console.error(
+              `[TanStack DB] Graph execution exceeded ${MAX_GRAPH_ITERATIONS} iterations. ` +
+                `This may indicate an infinite loop caused by data loading triggering ` +
+                `continuous graph updates. Breaking out of the loop to prevent app freeze. ` +
+                `Query ID: ${this.id}`,
+            )
+            break
+          }
+
           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