fix(db): coalesce layout publications and cover ordered includes children

Addresses Kyle's review of the order-only-move handling:

1. A commit containing both an ordinary value update and an order-only move
   published twice: commit() emitted the row batch and then the separate layout
   event fired redundantly. Replace hasOrderOnlyMove with
   needsLayoutOnlyPublication, which fires the layout event only when the commit
   published nothing else (any real insert/delete/value-changed update already
   notifies subscribers, who re-read the re-sorted collection).

2. Ordered child collections produced by includes did not reorder on an
   order-only child move:
   - The child accumulate replaced value on the insert side but left the
     retracted orderByIndex, so the child collection re-sorted against a stale
     index. Update orderByIndex on insert and capture the retract side (both the
     single-level and nested-includes accumulate blocks).
   - The child flush committed without a layout-only publication when the
     projected child value was unchanged. Publish one through the same
     mechanism (emitLayoutChange) when the child commit published nothing else.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: kevin-dp

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

@@ -822,11 +822,10 @@ export class CollectionConfigBuilder<
         // `commit()` emits nothing even though `.values()`/`.entries()` are now
         // re-sorted. Publish an explicit layout-change notification so ordered
         // consumers re-read — a first-class signal, not a forged row `update`.
-        if (hasOrderOnlyMove(changesToApply)) {
-          const changesManager = (config.collection as any)._changes as {
-            emitLayoutChangeEvent: () => void
-          }
-          changesManager.emitLayoutChangeEvent()
+        // Only when the commit published nothing else: any real row change
+        // already notifies subscribers, who re-read the re-sorted collection.
+        if (needsLayoutOnlyPublication(changesToApply)) {
+          emitLayoutChange(config.collection)
         }
       }
       pendingChanges = new Map()
@@ -910,9 +909,14 @@ export class CollectionConfigBuilder<
 
             if (multiplicity < 0) {
               existing.deletes += Math.abs(multiplicity)
+              existing.previousValue = childResult
+              existing.previousOrderByIndex = _orderByIndex
             } else if (multiplicity > 0) {
               existing.inserts += multiplicity
               existing.value = childResult
+              if (_orderByIndex !== undefined) {
+                existing.orderByIndex = _orderByIndex
+              }
             }
 
             byChild.set(childKey, existing)
@@ -1337,9 +1341,14 @@ function setupNestedPipelines(
 
           if (multiplicity < 0) {
             existing.deletes += Math.abs(multiplicity)
+            existing.previousValue = childResult
+            existing.previousOrderByIndex = _orderByIndex
           } else if (multiplicity > 0) {
             existing.inserts += multiplicity
             existing.value = childResult
+            if (_orderByIndex !== undefined) {
+              existing.orderByIndex = _orderByIndex
+            }
           }
 
           byChild.set(childKey, existing)
@@ -2002,6 +2011,13 @@ function flushIncludesState(
             }
           }
           entry.syncMethods.commit()
+          // Same order-only-move handling as the parent flush: a child row that
+          // moved without a value change is swallowed by the value-diff, so
+          // publish a layout-only notification when the child commit published
+          // nothing else.
+          if (needsLayoutOnlyPublication(childChanges)) {
+            emitLayoutChange(entry.syncMethods.collection)
+          }
         }
 
         // Update routing index for nested includes
@@ -2349,25 +2365,46 @@ function accumulateChanges<T>(
 }
 
 /**
- * Detect whether any accumulated change is an "order-only move": a row that was
- * updated in place (both retracted and re-inserted) whose `orderByIndex` moved
- * but whose projected value is deep-equal to before. The collection's value-diff
- * emits nothing for these, so the flush must publish a layout notification.
- * Rows whose value actually changed are ignored — they emit a normal `update`.
+ * Decide whether a flush needs a standalone layout-change publication.
+ *
+ * An "order-only move" — a row updated in place whose `orderByIndex` moved but
+ * whose projected value is deep-equal to before — is swallowed by the value-diff
+ * and needs an explicit layout notification. But that notification is only
+ * needed when the same `commit()` published nothing else: any real change
+ * (insert, delete, or a value-changed update) already notifies subscribers, who
+ * re-read the re-sorted collection, so a second layout event would be redundant.
+ *
+ * Returns true iff there is at least one order-only move AND no change that the
+ * commit itself publishes.
  */
-function hasOrderOnlyMove<T>(
+function needsLayoutOnlyPublication<T>(
   changesToApply: Map<unknown, Changes<T>>,
 ): boolean {
+  let layoutMoved = false
+  let commitPublishes = false
   for (const changes of changesToApply.values()) {
-    if (
-      changes.inserts > 0 &&
-      changes.deletes > 0 &&
-      changes.orderByIndex !== changes.previousOrderByIndex &&
-      changes.previousValue !== undefined &&
-      deepEquals(changes.previousValue, changes.value)
+    const isUpdate = changes.inserts > 0 && changes.deletes > 0
+    if (!isUpdate) {
+      // A net insert or delete always publishes a row change.
+      commitPublishes = true
+    } else if (
+      changes.previousValue === undefined ||
+      !deepEquals(changes.previousValue, changes.value)
     ) {
-      return true
+      // In-place update whose value changed — publishes a normal `update`.
+      commitPublishes = true
+    } else if (changes.orderByIndex !== changes.previousOrderByIndex) {
+      // Value unchanged, position moved — swallowed by the value-diff.
+      layoutMoved = true
     }
   }
-  return false
+  return layoutMoved && !commitPublishes
+}
+
+/** Emit a layout-only change notification on a live-query collection. */
+function emitLayoutChange(collection: Collection<any, any, any>): void {
+  const changesManager = (collection as any)._changes as {
+    emitLayoutChangeEvent: () => void
+  }
+  changesManager.emitLayoutChangeEvent()
 }