Method backfillFully

src/db/wal-valve.ts:226–258

* With the writer parked on the returned promise, loop passive passes until * one reports the entire WAL backfilled (typically the second: the first * drains the pass that was already running against a stale snapshot). Gives * up after a bounded number of passes — e.g. a reader pinning the

()

   * because unbounded WAL growth degrades; a wedged writer never recovers.
   */
  private async backfillFully(): Promise<void> {
    for (let i = 0; i < MAX_PAUSED_BACKFILL_PASSES; i++) {
      if (this.inflight) await this.inflight; // fold in the stale in-flight pass first
      const res = await this.db.checkpointWalPassive();
      if (!res) return; // checkpoint machinery unavailable — don't spin
      this.log(`backfill pass ${i + 1}: busy=${res.busy} log=${res.log} checkpointed=${res.checkpointed} wal=${this.mb(this.db.getWalSizeBytes())}`);
      if (res.busy === 0 && res.log === res.checkpointed) {
        // Backfill complete AND we are at a parked barrier (backfillFully only
        // runs under a writer pause): the no-reader window is guaranteed, so
        // chop the FILE too — a fully-backfilled WAL otherwise keeps growing
        // whenever commits land while pool readers hold marks (§7a.1: 22GB
        // on-disk at kernel scale despite backfills). A racing reader turns
        // this into a no-op (busy=1); the passive result above still stands.
        const trunc = await this.db.checkpointWalTruncate();
        if (trunc) this.log(`truncate: busy=${trunc.busy} wal=${this.mb(this.db.getWalSizeBytes())}`);
        this.sizeAtLastFullBackfill = this.db.getWalSizeBytes();
        this.consecutiveGiveUps = 0;
        this.futileUntil = 0;
        return;
      }
    }
    this.consecutiveGiveUps++;
    if (this.consecutiveGiveUps >= 2) {
      this.futileUntil = Date.now() + 60_000;
    }
    const msg = `backfill gave up after ${MAX_PAUSED_BACKFILL_PASSES} passes (streak ${this.consecutiveGiveUps}${this.futileUntil ? ', parking disabled 60s' : ''}) — a reader is pinning the WAL`;
    this.log(msg);
    // Give-ups are rare and load-bearing for §7a.1-class diagnosis — surface
    // them on any timing-instrumented run, not just valve-debug ones.
    if (process.env.CODEGRAPH_SYNTH_TIMINGS && !process.env.CODEGRAPH_WAL_VALVE_DEBUG) {
      console.error(`[wal-valve] ${msg}`);
    }
  }

  private fire(): void {
    this.log(`fire: wal=${this.mb(this.db.getWalSizeBytes())} baseline=${this.mb(this.sizeAtLastFullBackfill)}`);