edge-bench-rs: a library for the worker; rules from the lease; the wire format

- src/lib.rs: the indexing modules as a library, for edge-bench-rs and
  the coming edge-node worker.
- Rules as a lease brings them (priorities, dropped signatures and
  tools, per-article parts, sample share, executables) instead of
  DEFAULT_RULES hard-coded; RangeIndexer takes them and a resume point.
- Fragments carry everything the TypeScript Fragment has (poster,
  subject, groups, release): the server stores them for the merger.
- wire.rs: a batch as toWire makes it (camelCase JSON, payloads in
  base64). edge-bench-rs --wire writes it; check.ts --wire compares it
  with toWire of the TypeScript batch: identical on models-a and
  ath-2013.

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

tools/edge-bench-rs/check.ts

@@ -4,13 +4,16 @@
  * payload decoded with lib/chunks), samples, probe candidates, rule counts,
  * fragments and batch boundaries.
  *
- *   node --import=@poppinss/ts-exec tools/edge-bench-rs/check.ts <dir> <dump.jsonl> [--batch-chunks 10] [--idle 5]
+ *   node --import=@poppinss/ts-exec tools/edge-bench-rs/check.ts <dir> <dump.jsonl> [--wire batches.jsonl] [--batch-chunks 10] [--idle 5]
+ *
+ * With --wire (edge-bench-rs --wire): also each batch as the Rust worker
+ * posts it, against toWire of the TypeScript batch, field by field.
  */
 import { readFile, readdir } from 'node:fs/promises'
 import { join } from 'node:path'
 import { unzipSync } from 'node:zlib'
 import { isDeepStrictEqual } from 'node:util'
-import { RangeIndexer, type EdgeBatch } from '#lib/edge/index'
+import { RangeIndexer, toWire, type EdgeBatch } from '#lib/edge/index'
 import { DEFAULT_RULES, type Rules } from '#lib/rules/index'
 import { decodeChunk } from '#lib/chunks/index'
 
@@ -97,4 +100,40 @@ for (const kind of Object.keys(keyOf)) {
   }
 }
 console.log(`payload bytes: ${payloadBytes.ts} TypeScript, ${payloadBytes.rs} Rust`)
+
+const wireIndex = process.argv.indexOf('--wire')
+if (wireIndex !== -1) {
+  // Order within a batch doesn't count; payloads by what they decode to.
+  const by = (f: (x: any) => string) => (a: any, b: any) => (f(a) < f(b) ? -1 : f(a) > f(b) ? 1 : 0)
+  const normal = (w: any) => ({
+    ...w,
+    releases: w.releases.map((r: any) => ({ ...r, payload: sortFiles(decodeChunk(Buffer.from(r.payload, 'base64'))) })).sort(by((r) => `${r.key} ${r.upload}`)),
+    samples: w.samples.map((r: any) => ({ ...r, payload: sortFiles(decodeChunk(Buffer.from(r.payload, 'base64'))) })).sort(by((r) => `${r.key} ${r.upload}`)),
+    candidates: [...w.candidates].sort(by((c) => JSON.stringify(c))),
+    counts: [...w.counts].sort(by((c) => `${c.rule} ${c.key}`)),
+    fragments: [...w.fragments].sort(by((f) => `${f.fileKey} ${f.segments[0]?.[1]}`)),
+  })
+  const rust = (await readFile(process.argv[wireIndex + 1], 'utf8')).split('\n').filter(Boolean).map((l) => normal(JSON.parse(l)))
+  const typescript = batches.map((b) => normal(JSON.parse(JSON.stringify(toWire(b)))))
+  let wireSame = rust.length === typescript.length
+  const firstDiff = (x: any, y: any, path: string): string | null => {
+    if (isDeepStrictEqual(x, y)) return null
+    if (typeof x !== 'object' || typeof y !== 'object' || x === null || y === null) return `${path}: ${JSON.stringify(x)?.slice(0, 120)} vs ${JSON.stringify(y)?.slice(0, 120)}`
+    for (const k of new Set([...Object.keys(x), ...Object.keys(y)])) {
+      const d = firstDiff(x[k], y[k], `${path}.${k}`)
+      if (d) return d
+    }
+    return path
+  }
+  for (let i = 0; i < Math.max(rust.length, typescript.length); i++) {
+    const d = firstDiff(typescript[i], rust[i], `batch ${i}`)
+    if (d) {
+      wireSame = false
+      console.log(`DIFF wire: ${d}`)
+      break
+    }
+  }
+  if (wireSame) console.log(`same wire batches: ${typescript.length} TypeScript, ${rust.length} Rust`)
+  failed ||= !wireSame
+}
 process.exit(failed ? 1 : 0)