Method storeResult

src/extraction/index.ts:1708–1774

(filePath: string, content: string, stats: fs.Stats, result: ExtractionResult)

    const commitYield = createYielder();

    const storeResult = async (filePath: string, content: string, stats: fs.Stats, result: ExtractionResult): Promise<void> => {
      processed++;

      // WAL hard-cap backstop: between files (never mid-transaction), pause
      // the store until the off-thread checkpoint catches up. Resolves to
      // null in the normal case — a single size check, no cost.
      const bp = walBackpressure?.();
      if (bp) await bp;

      // Kernel deferred-decode results carry table sizes in kernelCounts
      // (their object arrays are empty — decode happens at the store).
      const nodeCount = result.kernelCounts?.nodes ?? result.nodes.length;
      const edgeCount = result.kernelCounts?.edges ?? result.edges.length;

      // Store: on the writer thread when active (fresh DB — bundles applied
      // in the same file order this chain dispatches them), else on the main
      // thread (SQLite connections are per-thread).
      if (nodeCount > 0 || result.errors.length === 0) {
        const language = detectLanguage(filePath, content, overrides);
        if (storeWriter) {
          if (result.kernelBuffers) {
            // Buffers go to the writer as-is; the worker decodes + finalizes.
            // The main thread's only per-file work stays O(1) + the content hash.
            storeWriter.send({
              kernel: true,
              filePath,
              language,
              buffers: result.kernelBuffers,
              file: this.buildFileRecord(filePath, content, language, stats, nodeCount, result.errors),
            });
          } else {
            storeWriter.send(this.buildFreshStoreBundle(filePath, content, language, stats, result));
          }
          await storeWriter.waitBelow(STORE_WRITER_WINDOW);
        } else {
          const materialized = materializeKernelResult(result, filePath, language);
          await this.storeExtractionResult(filePath, content, language, stats, materialized, commitYield);
        }
      }

      if (result.errors.length > 0) {
        for (const err of result.errors) {
          if (!err.filePath) err.filePath = filePath;
        }
        errors.push(...result.errors);
      }

      if (nodeCount > 0) {
        filesIndexed++;
        totalNodes += nodeCount;
        totalEdges += edgeCount;
      } else if (result.errors.some((e) => e.severity === 'error')) {
        filesErrored++;
      } else {
        // Files with no symbols but no errors (yaml, twig, properties) are
        // tracked at the file level — count them as indexed so the CLI doesn't
        // misleadingly report "No files found to index".
        const lang = detectLanguage(filePath, content, overrides);