···162162 snapshot={snap}
163163 {dataset}
164164 frozenList={result.frozen}
165165+ parentIndex={result.parentIndex}
165166 byteLog={result.byteLog}
166167 emitOutput={result.emitOutput}
167168 {mode}
···202203 stream-order (preorder MST traversal) by the root's emit plan, after the root is
203204 frozen. The dashed marker on byte_log shows the next frame the emit plan reads — its
204205 non-monotonic motion is exactly the random access that buffering avoids.
206206+ </p>
207207+ <p>
208208+ Between byte_log and the output strip, <em>subtree spans</em> grow as the algorithm
209209+ runs: each frozen subtree's emit_plan covers a contiguous range of byte_log positions
210210+ (from its earliest contributing record up to the node's own frame), so we can draw it
211211+ as a bar the moment it freezes. Smaller L0 spans get folded into wider L1 spans when
212212+ their parent freezes, eventually rolling up into a single root span covering the
213213+ entire byte_log — at that point the smaller spans dim away, since they've been
214214+ absorbed into the final plan.
215215+ </p>
216216+ <p>
217217+ During the emit phase, the root bracket — the final plan — is walked linearly.
218218+ The amber playhead on the output strip is the linear scan position. For each step,
219219+ the plan tells us which byte_log entry to fetch: a dashed line drops from the
220220+ byte_log frame down to the root bracket at the same x, showing the plan→byte_log
221221+ fetch. The byte_log indicator jumps non-monotonically (random access) while the
222222+ output playhead advances linearly (linear write).
205223 </p>
206224 {/if}
207225 </footer>