Beagle SCM

DIFF-019: whole-file hunk render dies hunk.render: out full on big files — fixed 64KB cap IN C, small base silently TRUNCATES

Input

Context

Hit 2026-07-30 reviewing //GET-056b: jab diff verbs/get/get.js (82KB file, sizable edit) throws JS exception: Error: hunk.render: out full, exit 1, zero output — the change is unreviewable via the UI. Bare jab diff (hunk-only render) handles the same edit fine, exit 0; scoped jab diff shared/weave.js (12KB) renders fine. The scoped branch renders the WHOLE file with changes highlighted (DIFF-003), so the render buffer scales with file size, not edit size.

• Same "out full" no-grow class as DIFF-010 (fold path, DONE) — this is the RENDER stage, hunk.render, which DIFF-010 left untouched; C caps noted there: dog/WEAVE.c WEAVE_FULL_HUNK_MAX.
• Adjacent: DIFF-015 (a fold error masked AS "out full" erases a file silently) — here the throw is loud, but it kills the whole view instead of degrading.
• Repro preserved: worktree //GET-056b at base ///be/#543269d6 with the staged GET-056b edit to verbs/get/get.js.

Goals

• Whole-file render of a large file renders fully AND completely — no throw, no silent line drops.
• If the render still cannot fit, degrade to hunk-only output with a loud warning — never exit 1 with nothing, never exit 0 with truncation.
• Repro tests: (a) ~100KB edited file renders non-empty, exit 0; (b) tiny-base/big-target renders ALL added lines (the truncation case).

Constraints

• The cap is IN C, not at the JS call site (BRO-042 worker, pty-verified 2026-07-30): HUNKu8sFeedLineBased (jab/dog/HUNK.c:1309) assembles the unified body in its OWN heap side buffers with hard-coded caps — u8bAllocate(body, 1<<16) (64KB) and 4KB each for dels/adds/oldb/newb (:1355-1360). The caller's into never nears its limit: a 64MB JS out buffer still throws (probed), so JS-side grow-and-replay CANNOT cure it.
• Error shape: u8bFeed into a full side buffer returns SNOROOM; the jab binding stringifies EVERY non-OK as hunk.render: out full (same masking as DIFF-015).
• WORSE, silent data loss: the region feeds into dels/adds (u8bFeed1(dels,'-'), u8bFeed(dels,ob) … ~:1377-1414) are BARE, not call(u8bFeed…) — all-or-nothing feeds whose refusal is dropped, so once a 4KB region buffer fills mid-region the remaining lines vanish and the render exits 0 (measured: 66 of 1530 + lines on a tiny-base/big-target). Exactly the unchecked-feed hazard meta/abc.mkd §slices forbids.
• Fix belongs in libdog: grow or size-to-content the five side buffers (BASS a_carve/gauge per ABC policy, not a bigger fixed cap) AND make every region feed checked so a genuine overflow refuses loudly instead of truncating.
• Same-file sibling: DIFF-016's HUNK.c lockstep twin (bro_classify_lines bit-26 provenance + washes) is also libdog-todo — one libdog pass should take both.
• Also confirmed: mush/conflict-marker bytes are token-legal to JST — parseability is NOT the trigger, size is; the tokenizer-failure path is already covered by DIFF-015's ext-"" refold (BRO-042 DONT).
• Grow-and-replay preferred over a bigger fixed cap (a bump just moves the cliff, per DIFF-010). Pty driver + fixtures preserved in //BRO-042/scratch/ (click.py, measure.js, wt/wt2).

WIP

TODOs

• repro test with a ~100KB file
• grow-on-full at the hunk.render caller
• degrade-loudly fallback if over hard cap

Outcome

• Fixed in //DIFF-019-jab (base ///jab/#e5367428), staged: dog/HUNK.c, dog/test/HUNK.c. Not landed.
• Strategy: content-sizing over grow — one pass counts lines + longest line, the five side buffers become exact-bound BASS a_carve scratch (frees gone, dies at the binding's bass bracket); EVERY feed checked call(u8bFeed…) so real overflow refuses loudly for the JS grow-on-full to catch.
• Second silent-drop found and fixed: hunk_flush_region's 4096-entry pairing arrays dropped overflow lines — an oversized region now emits its raw -/+ runs whole, skipping only the cosmetic pairing.
• Before/after: 82KB scoped diff out full exit 1 → full 1542-line render exit 0 (orchestrator-replayed independently: 1534 lines, exit 0); 3→1530-line diff 72/1530 + lines → 1530/1530.
• dog/test/HUNK.c lb(b) regolded to the new contract + new leg (c) (>4KB region, 1200 + lines); C ctest 106/106; JS diff+patch+status 59/59 with the new binary incl. 12-large-fold-grow.
• Suggested commit: DIFF-019: content-size hunk render buffers, checked feeds
• JS side fixed in //DIFF-019-be (base ///be/#fb1fb19c), staged: views/diff/diff.js (per-record grow-and-replay renderRecord, seed max(64KB, 4x record) double to 256MB cap; over-cap → loud stderr warning + windowed emitDiff re-fold, exit 0; all records render before any emit so a degrade never appends to a partial body), new test/diff/22-large-scoped-full-render (both Goal legs). Not landed.
• Verified (orchestrator-replayed): new case + diff 20/20 with the //DIFF-019-jab binary; worker's full run diff+patch+status+commit+bro 83/83; 94KB scoped diff exit 0, 1500/1500 lines both signs; forced 16KB cap degrades loudly, exit 0.
• Suggested commit (be side): DIFF-019: grow-on-full hunk render, degrade to windowed hunks
• Follow-ups NOT taken here: big-file diff is quadratic UPSTREAM of the render — probed every-line-changed 0.5MB→2.1MB (4x) is 15x slower and BARE windowed diff is as slow as scoped, so the cost is the shared fold/diff stage (Myers-family O(N*D), D≈N on a rewrite), not the view; view/bro.js:785/:848 still render into fixed buffers (same class); a fallback render over the cap still throws (implausible: 256MB vs the 4MB source cap).