Method resolvePoolSize

src/resolution/resolver-pool.ts:86–109

* Pool size from CPU headroom, memory headroom, and the explicit override. * Pure — every input injected — so the whole matrix is unit-testable. * * CPU term: `availableParallelism` (cpuset/affinity-honest — `os.cpus()` * enumerates the host's CPUs and sized SIX workers inside a 2-CPU cp

(opts: {
    explicit?: string;
    availableParallelism: number;
    memoryBudget: number;
    dbSizeBytes: number;
  })

   * cost — callers get null and stay sequential.
   */
  static resolvePoolSize(opts: {
    explicit?: string;
    availableParallelism: number;
    memoryBudget: number;
    dbSizeBytes: number;
  }): number | null {
    if (opts.explicit !== undefined && opts.explicit !== '') {
      const n = Number.parseInt(opts.explicit, 10);
      if (Number.isFinite(n)) {
        if (n <= 0) return null;
        return Math.min(n, 16);
      }
    }
    // No floor: at ap=2 the pool LOSES to sequential outright — measured on
    // the kernel-scale 2-cpuset envelope: resolution 853s sequential vs
    // 1,150s pooled-6-on-2 (§7a.1), and synthesis is Amdahl-bound by its
    // dominant pass (cFnPtrEdges 306s of 358s) so pooling it bought nothing.
    // ap−1 < 2 ⇒ sequential is the fast path, not a fallback.
    const cpuCap = Math.min(opts.availableParallelism - 1, 6);
    const perWorker = Math.min(Math.max(opts.dbSizeBytes * 0.2, 256 * 1024 * 1024), 1.5 * 1024 * 1024 * 1024);
    const memCap = Math.floor((opts.memoryBudget * 0.7) / perWorker);
    const size = Math.min(cpuCap, memCap);
    return size >= 2 ? size : null;
  }

  /**
   * Create a pool when the compiled worker exists (absent when running from