Rebuild: end-to-end fixes — spool accounting, keep-alive frames, resume point, overlapped worker

End to end (workstation, recent a.b.boneless ranges from the spool): a 2M
range in 10–12 s, 166k–202k headers/s per worker process (edge:bench on
one core: 215k).

- Prefetcher: spooled_at was set against a total counted from the range's
  resume point, which shrinks as the worker advances: the last chunks were
  never fetched and the worker waited. Now counted against the whole
  range, only new chunks counted, and leased ranges are always checked
  against the files. Planned ranges ahead are bounded (it had spooled ever
  more); the spool size is measured every 30 s (a stat per file).
- The stream sends an empty frame every 20 s while waiting for a chunk
  (Node's fetch gave up on a quiet body after 5 minutes).
- A range taken over midway: the first batch starts at the resume point
  (it started at the range's start and was refused).
- edge:node inflates the next chunk on the thread pool while indexing the
  current one, and doesn't wait for a post before indexing on (posts stay
  in order; a failed post stops the range).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

commands/edge_node.ts

@@ -1,10 +1,12 @@
 import { BaseCommand, flags } from '@adonisjs/core/ace'
 import type { CommandOptions } from '@adonisjs/core/types/ace'
 import { setTimeout as sleep } from 'node:timers/promises'
-import { gzipSync, unzipSync } from 'node:zlib'
-import { RangeIndexer, decodeFrames, toWire, type EdgeBatch, type Lease } from '#lib/edge/index'
+import { promisify } from 'node:util'
+import { gzipSync, unzip } from 'node:zlib'
+import { RangeIndexer, decodeFrames, isKeepalive, toWire, type EdgeBatch, type Lease } from '#lib/edge/index'
 
 const IDLE_MS = 30_000
+const unzipAsync = promisify(unzip)
 const RETRIES = 8
 
 class LeaseLost extends Error {}
@@ -66,31 +68,54 @@ export default class EdgeNode extends BaseCommand {
   private async runRange(api: Api, lease: Lease) {
     const { range, rules } = lease
     const started = Date.now()
-    const indexer = new RangeIndexer({ group: range.group, start: range.start, end: range.end, rules })
+    const indexer = new RangeIndexer({ group: range.group, start: range.start, end: range.end, resumeAt: range.next, rules })
     const totals = { headers: 0, releases: 0, candidates: 0, bytes: 0, postMs: 0 }
     let chunks = 0
-    const post = async (batch: EdgeBatch) => {
-      const at = Date.now()
-      const stored = await api.batch(range.id, batch)
-      totals.postMs += Date.now() - at
-      totals.bytes += stored.bytes
-      totals.headers += batch.headers
-      totals.releases += stored.releases
-      totals.candidates += stored.candidates
+    let reachedEnd = false
+    // Posts go in order, but the worker indexes on meanwhile (a post took 1–16 s; LOG.md 2026-10-09).
+    let posting: Promise<void> = Promise.resolve()
+    const post = (batch: EdgeBatch) => {
+      const previous = posting
+      posting = (async () => {
+        await previous
+        const at = Date.now()
+        const stored = await api.batch(range.id, batch)
+        totals.postMs += Date.now() - at
+        totals.bytes += stored.bytes
+        totals.headers += batch.headers
+        totals.releases += stored.releases
+        totals.candidates += stored.candidates
+      })()
+      // A failed post stops the range at the next chunk (a lost lease: nothing more will be stored).
+      posting.catch((error) => (postError ??= error))
+    }
+    let postError: Error | null = null
+    const handle = async (chunk: { to: number; text: Promise<Buffer> }) => {
+      if (postError) throw postError
+      indexer.addText((await chunk.text).toString('utf8'), chunk.to + 1)
+      chunks++
+      reachedEnd = chunk.to >= range.end
+      if (reachedEnd) indexer.finish()
+      if (reachedEnd || chunks % this.batchChunks === 0) post(indexer.take())
     }
     try {
+      // Inflating runs on a thread-pool thread: the next chunk inflates while this one is indexed.
+      let pending: { to: number; text: Promise<Buffer> } | null = null
       for await (const frame of decodeFrames(await api.stream(range.id))) {
-        indexer.addText(unzipSync(frame.data).toString('utf8'), frame.to + 1)
-        chunks++
-        const last = frame.to >= range.end
-        if (last) indexer.finish()
-        if (last || chunks % this.batchChunks === 0) await post(indexer.take())
-        if (this.stopping && !last) {
-          // Back to the queue; the next worker resumes at the last batch.
-          if (chunks % this.batchChunks !== 0) this.logger.info(`Range ${range.id}: giving it back (${chunks % this.batchChunks} chunks since the last batch are read again).`)
-          await api.call(range.id, 'release')
-          return
-        }
+        if (isKeepalive(frame)) continue
+        const next = { to: frame.to, text: unzipAsync(frame.data) }
+        next.text.catch(() => {})
+        if (pending) await handle(pending)
+        pending = next
+        if (this.stopping) break
+      }
+      if (pending && !this.stopping) await handle(pending)
+      await posting
+      if (!reachedEnd) {
+        // Stopping: back to the queue; the next worker resumes at the last stored batch.
+        this.logger.info(`Range ${range.id}: giving it back.`)
+        await api.call(range.id, 'release')
+        return
       }
       await api.call(range.id, 'finish')
       const seconds = (Date.now() - started) / 1000
@@ -100,6 +125,7 @@ export default class EdgeNode extends BaseCommand {
           `posted ${(totals.bytes / 1e6).toFixed(1)} MB in ${(totals.postMs / 1000).toFixed(1)} s.`
       )
     } catch (error: any) {
+      await posting.catch(() => {})
       if (error instanceof LeaseLost) {
         this.logger.warning(`Range ${range.id}: ${error.message}`)
         return