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

@@ -112,6 +112,18 @@ export interface CompilationResult {
 
   /** Child pipelines for includes subqueries */
   includes?: Array<IncludesCompilationResult>
+
+  /**
+   * D2 inputs created for includes subquery aliases during compilation.
+   * Each includes subquery gets its own independent D2 input, even if sibling
+   * subqueries use the same alias letter. Keyed by a unique internal alias
+   * (e.g., `__inc_0_i`), with the corresponding collection ID.
+   */
+  includesInputs?: Array<{
+    uniqueKey: string
+    input: KeyedStream
+    collectionId: string
+  }>
 }
 
 /**
@@ -141,6 +153,10 @@ 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").
+  createInput?: () => KeyedStream,
 ): CompilationResult {
   // Check if the original raw query has already been compiled
   const cachedResult = cache.get(rawQuery)
@@ -316,6 +332,10 @@ export function compileQuery(
   // This must happen AFTER WHERE (so parent pipeline is filtered) but BEFORE processSelect
   // (so IncludesSubquery nodes are stripped before select compilation).
   const includesResults: Array<IncludesCompilationResult> = []
+  const includesInputEntries: NonNullable<
+    CompilationResult[`includesInputs`]
+  > = []
+  let includesInputCounter = 0
   const includesRoutingFns: Array<{
     fieldName: string
     getRouting: (nsRow: any) => {
@@ -391,10 +411,23 @@ 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) {
+          const uniqueKey = `__inc_${includesInputCounter++}_${alias}`
+          const freshInput = createInput()
+          childAllInputs[alias] = freshInput
+          includesInputEntries.push({ uniqueKey, input: freshInput, collectionId })
+        }
+      }
+
       // Recursively compile child query WITH the parent key stream
       const childResult = compileQuery(
         childQuery,
-        allInputs,
+        childAllInputs,
         collections,
         subscriptions,
         callbacks,
@@ -405,11 +438,13 @@ 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)
+      // Collect includes inputs from nested levels (grandchild includes etc.)
+      if (childResult.includesInputs) {
+        includesInputEntries.push(...childResult.includesInputs)
+      }
 
       includesResults.push({
         pipeline: childResult.pipeline,
@@ -710,6 +745,8 @@ export function compileQuery(
     aliasToCollectionId,
     aliasRemapping,
     includes: includesResults.length > 0 ? includesResults : undefined,
+    includesInputs:
+      includesInputEntries.length > 0 ? includesInputEntries : undefined,
   }
   cache.set(rawQuery, compilationResult)
 
@@ -741,6 +778,38 @@ 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

@@ -691,13 +691,28 @@ export class CollectionConfigBuilder<
       (windowFn: (options: WindowOptions) => void) => {
         this.windowFn = windowFn
       },
+      undefined, // cache
+      undefined, // queryMapping
+      undefined, // parentKeyStream
+      undefined, // childCorrelationField
+      () => this.graphCache!.newInput<any>(), // createInput factory for includes
     )
 
     this.pipelineCache = compilation.pipeline
     this.sourceWhereClausesCache = compilation.sourceWhereClauses
     this.compiledAliasToCollectionId = compilation.aliasToCollectionId
     this.includesCache = compilation.includes
 
+    // Merge includes inputs into the top-level input and alias maps.
+    // Each includes subquery gets its own D2 input under a unique key,
+    // ensuring sibling subqueries with the same alias don't collide.
+    if (compilation.includesInputs) {
+      for (const { uniqueKey, input, collectionId } of compilation.includesInputs) {
+        ;(this.inputsCache as Record<string, any>)[uniqueKey] = input
+        this.compiledAliasToCollectionId[uniqueKey] = collectionId
+      }
+    }
+
     // Defensive check: verify all compiled aliases have corresponding inputs
     // This should never happen since all aliases come from user declarations,
     // but catch it early if the assumption is violated in the future.

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

@@ -142,8 +142,12 @@ export function extractCollectionAliases(
       if (typeof key === `string` && key.startsWith(`__SPREAD_SENTINEL__`)) {
         continue
       }
+      // Do NOT traverse into IncludesSubquery nodes — their aliases are scoped
+      // independently and handled via separate D2 inputs created during compilation.
+      // Traversing here would flatten sibling aliases into a single namespace,
+      // causing collisions when siblings use the same alias letter.
       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` },
+      ])
+    })
+  })
 })