PrivaterungsPrivate ReadonlynPrivate ReadonlypathPrivate ReadonlygeometryPrivate ReadonlyslicePrivate ReadonlyplannerPrivate ReadonlyenergyPrivateloadedPrivatepayloadPrivateloadedPrivatelastPrivateinitialPrivatelastPrivatedisposedPrivateresetPrivateconcatPrivatelevelsPrivatepayloadsPrivaterestoredPrivateretryPrivaterestoredPrivatemetadataPrivatelookaheadPrivate ReadonlylookaheadPrivatereadPrivatescrubPrivateframePrivateladderThe rung loaders (empty once disposed) — for the monitor adapter; do not mutate.
Whether more rungs remain to load for the current view.
Whether the most recently streamed rung was fully cache-resident.
Cumulative energy fraction e(k) of the loaded prefix (null without
energy stamps, 0 before any rung loads) — read at commit time for the
display gate's energy-threshold upgrade release.
Measured footprint of the loaded ladder for the sweep residency budget.
Rung count is the LOGICAL depth, not loadedLODs.length (1 once folded).
The node's monitor metrics, from its levels' summed counters.
Two fields are the ladder's, not the levels': memoryUsed adds the
memoized cumulative payload, and visibleElements is the current ladder's
element count. A level's own counter refreshes only when that level
queries, so after a SliceCache restore or a pass pinned short of the
loaded depth the deeper levels still hold an earlier slice's count — a sum
would report elements that are not on screen.
Discard the rungs the current pass appended, restoring the prefix it
started from, so a failed commit's retry re-attempts the SAME prefix
(see pass-rollback.ts).
Rungs discarded (0 when the pass appended none).
Stream the ladder for viewState (see the module notes for one pass).
Optionalsession: UpdateSessionOptionalsignal: AbortSignalOptionalresidencyAllowanceBytes: numberPredicted-view warm-up (dispatchPredictivePrefetch): warm the COARSE rung
of viewState — what the next pass's first commit reads.
Optionalsignal: AbortSignalprefetchChunks over a whole current → predicted transition.
PrivaterecordRecord the pass directives FIRST (a pause re-trigger reuses the view).
PrivatesyncBring the ladder to viewState: enter it when it differs from the last
view, else adopt a determinant-equal metadata refresh (the fresh
dimensions reference keeps later compares on the reference fast path).
True when a restored FULL ladder makes the pass a no-op.
PrivateenterPrivaterestoreRestore a cached ladder for viewState (or reset); true when it is FULL.
PrivatestreamThe streaming loop (see the module notes, step 3).
PrivateloadLoad and append rung level; true when the policy stops the loop after it.
PrivateloadLoad one rung for viewState (timed as additive:<kind>:level:<n>).
PrivatestartStart a pinned pass's rungs concurrently, coarsest first, each under its OWN child of the pass signal so the remainder can be cancelled without cancelling the pass. A rung the loop never awaits must not surface as an unhandled rejection, so each gets a no-op handler; the loop still awaits — and rethrows — the original.
PrivatediscardCancel every pinned rung the loop did not commit and drop what its accumulator already decoded: the brake refused those bytes. Committed rungs keep their reads; every child is detached from the pass signal.
PrivatestoreStore the ladder after a pass (full always; prefixes under a budget or pin).
PrivatestorePrivatetornTrue once this pass was aborted or the loader disposed.
Optionalsignal: AbortSignalPrivateconcatenateConcatenate the retained payloads, memoized on (reset generation, logical rung count), stamping the prefix-lineage parent (the previous same-generation memo) and, for a result built from a restored snapshot alone, its slice-cache origin. The rungs' pooled decode buffers are released once copied; only the cumulative payload is retained.
Optionalsession: UpdateSessionPrivatesameThe memoized concat when it belongs to the current reset generation.
PrivatereleaseRelease the loaded rungs' pooled decode buffers once their payloads are copied.
PrivatelogPrivatelogPer-pass summary, at verbose: a pass runs on every view tick.
PrivatereportPrivatewarmPrivatewarmRequest rung level's spatial index at REFINEMENT priority (B6): a finer
rung of something on screen queues behind every demand read but no longer
waits for the rung before it to finish. Idempotent.
PrivatescheduleThe signal-linked speculative lookahead of the next rung(s): free navigation only — a playback / pinned pass's next pass is a DIFFERENT slice, so this slice's next rung would never be read (measured pure waste) — and never for a superseded pass.
OptionalupdateSignal: AbortSignalPrivatelookaheadThe lookahead controller for this view (the lookahead-signal contract):
speculative, aborted on view change and dispose, AND linked to the update
that scheduled it. Reused across refinement passes of one view while live;
replaced once a superseded update aborted it. null when that update is
already aborted.
OptionalupdateSignal: AbortSignalPrivatestartPrivatereadPredictive read-ahead for a scrub (B5): after a pass for a view reached by moving a hidden-dimension slice, warm rung 0 of the neighbouring slices (one step either way along each moved axis), so the next drag step's first commit is a cache hit. Speculative priority, aborted by the next view change; free navigation only (playback has the SlicePrefetcher) and once per view. Each neighbour gets its own controller, so the step that lands on one keeps its read (see cancelSpeculation).
OptionalupdateSignal: AbortSignalPrivatecancelAbort the speculative reads of the view being left. A read-ahead of
exactly keepFor (the view being entered) is KEPT: until the new pass's
rung-0 read joins it, the warm is the only waiter on its chunk fetches,
and aborting it there would cancel the shared fetch and force a refetch.
OptionalkeepFor: ViewState
Speculative ±1-slice read-ahead of rung 0 (B5), one controller per neighbour slice. A view change aborts every one EXCEPT the slice it moved onto: that warm is what the new pass's rung-0 reads join.