perf(dom): List.each monotonic-append reconcile fast path (#171)

[stefvw93]

Closes #171 (residual of #168).

What

The most common list mutation is a pure append: the new snapshot is the previous order, unchanged and in order, plus new keys at the tail. After the Loom scheduler (#170) conflated queued snapshots, each surviving reconcile still paid the full O(n log n) diff+LIS walk over the whole list for an append (the #168 residual).

reconcileList now detects a pure suffix append and takes a fast path:

• Trigger (after projectKeys, so the KR1 duplicate guard still runs first): prev.order.length > 0 && keys.length > prev.order.length && prev.order.every((k, i) => Equal.equals(keys[i], k)).
• Because projectKeys proved every key globally unique, a matching prefix guarantees the tail keys are new — no extra membership check.
• appendListTail reuses the prefix records in place (untouched DOM + scopes), renders only the appended tail, inserts it in one pass before the region end marker, and extends prev.records.
• Skips the prevIndex build, drop-set walk, and LIS.

The returned ListState is identical to the general path, so every MR/KR/SC/ID/ER invariant holds and later reconciles are unaffected. Guarded to a non-empty previous order (the empty/mount case stays on the general path). No public API changed.

Testing the optimization, not just correctness

The append fast path is DOM-op-identical to the general path (for a suffix append the general LIS keeps the whole prefix and inserts only the tail), so equivalence tests alone cannot detect the fast path being removed. A dedicated insertion-signature guard closes that gap: the fast path inserts every tail range before the single region end marker (one distinct anchor), while the general path anchors each new item to the next (K distinct anchors). Asserting a single distinct anchor is a genuine red→green signal — verified by disabling the fast path and watching exactly that assertion fail while the equivalence tests stay green.

Tests

• list-append-fast-path.test.ts (jsdom): AP1/AP2 append core, AP3 record-state parity, AP4 non-append fallthrough (mid-insert / reorder / remove / prefix-mismatch), AP5 tail-dup → RenderError (KR1), AP6 subscription preservation, plus the single-anchor fast-path-engaged guard.
• perf-list-backlog.browser.test.ts (Chromium): AP7 — appending K=100 rows to N=5,000 in one emission inserts only the K tail ranges (≤ K×3, one anchor), moves no existing row, preserves prefix node identity, under a generous cap.

Validation

All four gates green locally: vp run check, vp run test (803), vp run test:browser (70), vp run test:types (149 tests / 251 assertions).

Docs

list.specs.md amendment + new list-append-fast-path.specs.md (ACs AP1–AP7). No user-facing docs change (internal optimization, no public API).

Note on Feature A

This branches off main independently of the sibling first-emission mount fast path (#178, PR #180). The two are disjoint by design (this one's prev.order.length > 0 guard excludes the empty/mount case), so they compose cleanly at merge.

🤖 Generated with Claude Code