Method getAmbientDeclarationPathsAmong

src/db/queries.ts:2074–2125

* Which of `filePaths` are AMBIENT DECLARATION files — they declare nothing * but types, and nothing in the index depends on them (CG-28). A hand-written * ambient `.d.ts` of global shims, a vendored typings file, module * augmentation: reachable only by name, structurally attached to nothi

(filePaths: Iterable<string>)

   * candidate list, so this is a partial-index probe over a handful of paths.
   */
  getAmbientDeclarationPathsAmong(filePaths: Iterable<string>): Set<string> {
    const unique = [...new Set(filePaths)];
    const found = new Set<string>();
    if (unique.length === 0) return found;

    for (let i = 0; i < unique.length; i += SQLITE_PARAM_CHUNK_SIZE) {
      const chunk = unique.slice(i, i + SQLITE_PARAM_CHUNK_SIZE);
      const placeholders = chunk.map(() => '?').join(',');
      // `file`/`import`/`export`/`parameter` are structural bookkeeping, not
      // things the file declares, so they neither qualify nor disqualify.
      const rows = this.db
        .prepare(`
          SELECT file_path,
                 SUM(CASE WHEN kind NOT IN ('file','import','export','parameter')
                          THEN 1 ELSE 0 END) AS declared,
                 SUM(CASE WHEN kind IN ('interface','type_alias','enum','enum_member','namespace')
                          THEN 1 ELSE 0 END) AS typeDeclared
          FROM nodes
          WHERE file_path IN (${placeholders})
          GROUP BY file_path
        `)
        .all(...chunk) as Array<{ file_path: string; declared: number; typeDeclared: number }>;
      let candidates = rows
        .filter((r) => r.declared > 0 && r.declared === r.typeDeclared)
        .map((r) => r.file_path);
      if (candidates.length === 0) continue;

      const disqualify = (sql: string): void => {
        if (candidates.length === 0) return;
        const hit = new Set(
          (this.db
            .prepare(sql.replace('$IN$', candidates.map(() => '?').join(',')))
            .all(...candidates) as Array<{ file_path: string }>).map((r) => r.file_path),
        );
        candidates = candidates.filter((p) => !hit.has(p));
      };
      // (3) originates behaviour
      disqualify(`
        SELECT DISTINCT n.file_path AS file_path
        FROM edges e JOIN nodes n ON n.id = e.source
        WHERE e.kind IN ('calls','instantiates') AND n.file_path IN ($IN$)
      `);
      // (4) something outside the file depends on it
      disqualify(`
        SELECT DISTINCT t.file_path AS file_path
        FROM edges e JOIN nodes t ON t.id = e.target JOIN nodes s ON s.id = e.source
        WHERE t.file_path IN ($IN$) AND s.file_path <> t.file_path
      `);
      for (const path of candidates) found.add(path);
    }
    return found;
  }

  /**
   * A reusable `(path) => boolean` ambient-declaration test over a bounded