fix: duplicate alias in sibling includes silently breaks nested children

When two sibling includes in .select() used the same alias (e.g.,
{ i: issues } and { i: tags }), nested child collections silently
produced empty results. The root cause was that all includes aliases
were flattened into a single namespace — sharing one D2 graph input
and one subscription, so the second sibling's collection data
overwrote the first.

Fix: give each includes subquery its own independent D2 input.
- extractCollectionAliases no longer traverses into IncludesSubquery
  nodes, keeping collectionByAlias scoped to the top-level query.
- compileQuery accepts a createInput factory; when processing includes,
  each child gets fresh inputs for its source aliases via
  collectAllSourceAliases + createInput().
- compileBasePipeline merges the new inputs into inputsCache and
  compiledAliasToCollectionId under unique keys (__inc_N_alias),
  so each gets its own subscription feeding the correct collection.

Author: ibirrer

packages/db/src/query/compiler/index.ts

@@ -141,6 +141,11 @@ export function compileQuery(
   // For includes: parent key stream to inner-join with this query's FROM
   parentKeyStream?: KeyedStream,
   childCorrelationField?: PropRef,
+  // Factory to create fresh D2 inputs for includes subquery aliases.
+  // Each includes subquery gets its own input to avoid alias collisions
+  // between siblings (e.g., two siblings both using alias "i").
+  // The factory also handles registering the input for subscription.
+  createInput?: (alias: string, collectionId: string) => KeyedStream,
 ): CompilationResult {
   // Check if the original raw query has already been compiled
   const cachedResult = cache.get(rawQuery)
@@ -391,10 +396,20 @@ export function compileQuery(
             }
           : subquery.query
 
+      // Create fresh D2 inputs for the child query's source aliases so that
+      // sibling includes using the same alias letter get independent streams.
+      const childAllInputs = { ...allInputs }
+      if (createInput) {
+        const childSourceAliases = collectAllSourceAliases(childQuery)
+        for (const [alias, collectionId] of childSourceAliases) {
+          childAllInputs[alias] = createInput(alias, collectionId)
+        }
+      }
+
       // Recursively compile child query WITH the parent key stream
       const childResult = compileQuery(
         childQuery,
-        allInputs,
+        childAllInputs,
         collections,
         subscriptions,
         callbacks,
@@ -405,12 +420,9 @@ export function compileQuery(
         queryMapping,
         parentKeys,
         subquery.childCorrelationField,
+        createInput,
       )
 
-      // Merge child's alias metadata into parent's
-      Object.assign(aliasToCollectionId, childResult.aliasToCollectionId)
-      Object.assign(aliasRemapping, childResult.aliasRemapping)
-
       includesResults.push({
         pipeline: childResult.pipeline,
         fieldName: subquery.fieldName,
@@ -741,6 +753,36 @@ function collectDirectCollectionAliases(query: QueryIR): Set<string> {
   return aliases
 }
 
+/**
+ * Collects ALL source aliases (FROM + JOINs) from a query tree, recursively
+ * following FROM/JOIN subqueries but NOT includes subqueries.
+ * Returns a map of alias → collectionId for all collection refs found.
+ */
+function collectAllSourceAliases(query: QueryIR): Map<string, string> {
+  const result = new Map<string, string>()
+
+  function walkFrom(from: CollectionRef | QueryRef) {
+    if (from.type === `collectionRef`) {
+      result.set(from.alias, from.collection.id)
+    } else if (from.type === `queryRef`) {
+      walkQuery(from.query)
+    }
+  }
+
+  function walkQuery(q: QueryIR) {
+    walkFrom(q.from)
+    if (q.join) {
+      for (const join of q.join) {
+        walkFrom(join.from)
+      }
+    }
+    // Do NOT walk includes in select — they get their own inputs
+  }
+
+  walkQuery(query)
+  return result
+}
+
 /**
  * Validates the structure of a query and its subqueries.
  * Checks that subqueries don't reuse collection aliases from parent queries.

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

@@ -680,6 +680,9 @@ export class CollectionConfigBuilder<
       ]),
     )
 
+    let includesCounter = 0
+    const includesAliases: Record<string, string> = {}
+
     const compilation = compileQuery(
       this.query,
       this.inputsCache as Record<string, KeyedStream>,
@@ -691,12 +694,26 @@ export class CollectionConfigBuilder<
       (windowFn: (options: WindowOptions) => void) => {
         this.windowFn = windowFn
       },
+      undefined, // cache
+      undefined, // queryMapping
+      undefined, // parentKeyStream
+      undefined, // childCorrelationField
+      // Factory for includes: creates a fresh D2 input per alias and registers
+      // it for subscription under a unique key to avoid sibling alias collisions.
+      (alias, collectionId) => {
+        const uniqueKey = `__inc_${includesCounter++}_${alias}`
+        const input = this.graphCache!.newInput<any>()
+        ;(this.inputsCache as Record<string, any>)[uniqueKey] = input
+        includesAliases[uniqueKey] = collectionId
+        return input
+      },
     )
 
     this.pipelineCache = compilation.pipeline
     this.sourceWhereClausesCache = compilation.sourceWhereClauses
     this.compiledAliasToCollectionId = compilation.aliasToCollectionId
     this.includesCache = compilation.includes
+    Object.assign(this.compiledAliasToCollectionId, includesAliases)
 
     // Defensive check: verify all compiled aliases have corresponding inputs
     // This should never happen since all aliases come from user declarations,

packages/db/src/query/live/utils.ts

@@ -142,8 +142,9 @@ export function extractCollectionAliases(
       if (typeof key === `string` && key.startsWith(`__SPREAD_SENTINEL__`)) {
         continue
       }
+      // Skip includes — their aliases are scoped independently via separate D2 inputs
       if (value instanceof IncludesSubquery) {
-        traverse(value.query)
+        continue
       } else if (isNestedSelectObject(value)) {
         traverseSelect(value)
       }

packages/db/tests/query/includes.test.ts

@@ -4061,4 +4061,79 @@ describe(`includes subqueries`, () => {
       ])
     })
   })
+
+  describe(`duplicate alias in sibling includes`, () => {
+    type Tag = {
+      id: number
+      projectId: number
+      label: string
+    }
+
+    const sampleTags: Array<Tag> = [
+      { id: 1, projectId: 1, label: `urgent` },
+      { id: 2, projectId: 1, label: `frontend` },
+      { id: 3, projectId: 2, label: `backend` },
+    ]
+
+    function createTagsCollection() {
+      return createCollection(
+        mockSyncCollectionOptions<Tag>({
+          id: `includes-tags`,
+          getKey: (t) => t.id,
+          initialData: sampleTags,
+        }),
+      )
+    }
+
+    it(`same alias in sibling includes does not break nested children`, async () => {
+      // Tags uses alias "i" — same as issues. Each sibling gets its own
+      // independent D2 input, so nested comments are still populated.
+      const tags = createTagsCollection()
+
+      const collection = createLiveQueryCollection((q) =>
+        q.from({ p: projects }).select(({ p }) => ({
+          id: p.id,
+          name: p.name,
+          issues: q
+            .from({ i: issues })
+            .where(({ i }) => eq(i.projectId, p.id))
+            .select(({ i }) => ({
+              id: i.id,
+              title: i.title,
+              comments: q
+                .from({ c: comments })
+                .where(({ c }) => eq(c.issueId, i.id))
+                .select(({ c }) => ({
+                  id: c.id,
+                  body: c.body,
+                })),
+            })),
+          tags: q
+            .from({ i: tags }) // same alias "i" as issues
+            .where(({ i }) => eq(i.projectId, p.id))
+            .select(({ i }) => ({
+              id: i.id,
+              label: i.label,
+            })),
+        })),
+      )
+
+      await collection.preload()
+
+      const alpha = collection.get(1) as any
+
+      // Tags should be populated
+      expect(childItems(alpha.tags)).toEqual([
+        { id: 1, label: `urgent` },
+        { id: 2, label: `frontend` },
+      ])
+
+      // Nested comments should also be populated despite the duplicate alias "i"
+      const issue10 = alpha.issues.get(10)
+      expect(childItems(issue10.comments)).toEqual([
+        { id: 100, body: `Looks bad` },
+        { id: 101, body: `Fixed it` },
+      ])
+    })
+  })
 })