Lease lanes for the tail, a mixed lease order, coordinator:status, the edge end to end

A group now has two lease lanes (migration 6600): `history` works the ranges the bounds hand out, `tail` the tail
planner's, each with its own holder, window, snapshot and takeover redo, so a thread on the tail never wades
through a group's history and a held group's tail isn't stuck behind it. The edge puts `--tail-threads`
(EDGE_TAIL_THREADS, 1 of 2+ by default) of its threads on the tail lane; the group routes take `?lane=`. The
lease order within a lane alternates the group with the most planned articles and the longest unheld one. The
takeover redo puts back only the lane's ranges the window did after the snapshot, and a group whose last range
is held by a holder gone quiet can be taken over.

`coordinator:status` prints the catalog's room, the ranges by band, the last hour's rates, the held groups with
their snapshots and the phase-2 backlogs. `tests/e2e` runs the real edge-node binary against the node API: the
corpus-fill race, a failed stream and the restart that restores the snapshot, a restart without the snapshot
file, a takeover (STREAM_CHUNK_WAIT_MINUTES is a setting now). CI builds the binary before the tests.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

tests/e2e/helpers/edge.ts

@@ -0,0 +1,149 @@
+import { spawn } from 'node:child_process'
+import { access } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { deflateSync } from 'node:zlib'
+import env from '#start/env'
+
+export const GROUP = 'alt.binaries.e2e'
+
+/** The edge worker binary: EDGE_NODE_BIN, else the release or debug build under edge/target. */
+export async function edgeBinary(): Promise<string> {
+  const candidates = [
+    process.env.EDGE_NODE_BIN,
+    'edge/target/release/edge-node',
+    'edge/target/debug/edge-node',
+  ]
+    .filter((c): c is string => !!c)
+    .map((c) => resolve(c))
+  for (const path of candidates) {
+    try {
+      await access(path)
+      return path
+    } catch {}
+  }
+  throw new Error(
+    `No edge-node binary (looked at ${candidates.join(', ')}): build it with "cargo build --release --manifest-path edge/Cargo.toml --bin edge-node", or set EDGE_NODE_BIN`
+  )
+}
+
+/** The test server's address for the worker (tests/bootstrap.ts starts it on HOST:PORT). */
+export function coordinatorUrl(): string {
+  const host = env.get('HOST', 'localhost')
+  return `http://${host === '0.0.0.0' ? '127.0.0.1' : host}:${env.get('PORT', 3333)}`
+}
+
+export interface EdgeRun {
+  exit: Promise<{ code: number | null; signal: string | null }>
+  lines: string[]
+  kill: () => void
+}
+
+/**
+ * The real edge worker against the test server: one thread on the history lane, one group, a batch per chunk
+ * (100 articles in these tests), a snapshot after every range.
+ */
+export async function startEdge(token: string, args: string[] = []): Promise<EdgeRun> {
+  const bin = await edgeBinary()
+  // The test server first (tests/bootstrap.ts starts it for this suite): a worker that can't connect retries for
+  // minutes before it says so.
+  const probe = await fetch(`${coordinatorUrl()}/api/v1/node/lease`, { method: 'POST' }).catch(
+    (e) => e as Error
+  )
+  if (probe instanceof Error || probe.status !== 401)
+    throw new Error(
+      `The test server doesn't answer at ${coordinatorUrl()}: ${probe instanceof Error ? probe.message : `HTTP ${probe.status}`}`
+    )
+  const child = spawn(
+    bin,
+    [
+      '--threads',
+      '1',
+      '--tail-threads',
+      '0',
+      '--groups',
+      '1',
+      '--batch-articles',
+      '100',
+      '--snapshot-minutes',
+      '0',
+      ...args,
+    ],
+    {
+      env: { ...process.env, COORDINATOR_URL: coordinatorUrl(), NODE_TOKEN: token },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }
+  )
+  const lines: string[] = []
+  let rest = ''
+  const collect = (chunk: Buffer) => {
+    rest += chunk.toString('utf8')
+    const parts = rest.split('\n')
+    rest = parts.pop() ?? ''
+    lines.push(...parts)
+  }
+  child.stdout.on('data', collect)
+  child.stderr.on('data', collect)
+  const exit = new Promise<{ code: number | null; signal: string | null }>((done) => {
+    child.on('exit', (code, signal) => {
+      if (rest) lines.push(rest)
+      done({ code, signal })
+    })
+  })
+  return { exit, lines, kill: () => child.kill('SIGKILL') }
+}
+
+/** Runs the worker to its end (at most `timeoutMs`), its log lines and exit code. */
+export async function runEdge(token: string, args: string[] = [], timeoutMs = 60_000) {
+  const run = await startEdge(token, args)
+  const timer = setTimeout(() => run.kill(), timeoutMs)
+  const result = await run.exit
+  clearTimeout(timer)
+  return { ...result, lines: run.lines }
+}
+
+/** Polls `condition` every 100 ms until it holds or `timeoutMs` passed (then throws). */
+export async function waitFor(what: string, condition: () => Promise<boolean>, timeoutMs = 30_000) {
+  const until = Date.now() + timeoutMs
+  while (Date.now() < until) {
+    if (await condition()) return
+    await new Promise((r) => setTimeout(r, 100))
+  }
+  throw new Error(`Timed out waiting for ${what}`)
+}
+
+const BASE_MS = Date.UTC(2026, 9, 5, 10)
+
+/** A file name without digits (a number sequence would make an album of a poster's files): letters from `k`. */
+export function nameOf(k: number): string {
+  let s = ''
+  let n = k
+  do {
+    s = String.fromCharCode(97 + (n % 26)) + s
+    n = Math.floor(n / 26)
+  } while (n > 0)
+  return `Set.${s}.mkv`
+}
+
+/**
+ * The overview lines of articles `from`..`to`, one an hour from 2026-10-05: article 1 is a one-part file, and from 2
+ * on each even article is part 1 of a two-part file whose part 2 is the next (odd) article — so a file spans every
+ * chunk boundary at an even `to` (100 and 101, 200 and 201: the window has to carry it). Dates an hour apart make
+ * the posting frontier move a day every 24 articles, so the window closes on files as it goes.
+ */
+export function overviewLines(from: number, to: number): string[] {
+  const lines: string[] = []
+  for (let n = from; n <= to; n++) {
+    const date = new Date(BASE_MS + n * 3600_000).toUTCString().replace(' GMT', ' +0000')
+    const [name, part] =
+      n === 1 ? [nameOf(1), '(1/1)'] : n % 2 === 0 ? [nameOf(n), '(1/2)'] : [nameOf(n - 1), '(2/2)']
+    lines.push(
+      `${n}\t"${name}" yEnc ${part}\tposter <p@x>\t${date}\t<a${n}@e2e>\t\t700000\t5000\tXref: news.example ${GROUP}:${n}`
+    )
+  }
+  return lines
+}
+
+/** One XOVER chunk as the news server sends it (deflated). */
+export function overviewChunk(from: number, to: number): Buffer {
+  return deflateSync(Buffer.from(overviewLines(from, to).join('\r\n') + '\r\n'))
+}