@floegence/floeterm-terminal-web 0.16.6 → 0.17.0

package/dist/semantic/HistoryViewportController.js

@@ -6,7 +6,8 @@ function emitSemanticDebugTrace(event) {
 }
 // History is owned by a single terminal session. Keep the budget local to the
 // controller so one busy session cannot evict another session's history.
-const MAX_SESSION_HISTORY_CACHE_BYTES = 4 * 1024 * 1024;
+const MAX_SESSION_HISTORY_CACHE_BYTES = 32 * 1024 * 1024;
+const MAX_PAGE_HISTORY_CACHE_BYTES = 128 * 1024 * 1024;
 const HISTORY_WINDOW_CACHE_TARGET_BYTES = Math.floor(MAX_SESSION_HISTORY_CACHE_BYTES * 0.85);
 const HISTORY_WINDOW_BASE_MULTIPLIER = 10;
 const HISTORY_WINDOW_FAST_MULTIPLIER = 20;
@@ -15,6 +16,9 @@ const HISTORY_SCROLL_BURST_GAP_MS = 250;
 const HISTORY_SCROLL_BURST_DECAY_MS = 500;
 const HISTORY_SCROLL_BURST_VIEWPORTS = 2;
 const HISTORY_WINDOW_FORWARD_BIAS = 0.7;
+const HISTORY_PREFETCH_DELAY_MS = 500;
+const HISTORY_PREFETCH_SCREENS = 100;
+const HISTORY_PREFETCH_FRONT_SCREENS = 80;
 export class HistoryViewportController {
     constructor(options) {
         this.options = options;
@@ -40,6 +44,13 @@ export class HistoryViewportController {
         this.scrollBurstRows = 0;
         this.scrollBurstAt = 0;
         this.estimatedHistoryRowBytes = 0;
+        this.pendingProjection = false;
+        this.skeletonSequence = 0;
+        this.nextRequestID = 0;
+        this.prefetchTimer = null;
+        this.prefetchAbort = null;
+        this.prefetchTask = null;
+        HistoryViewportController.instances.add(this);
         this.requestFrame = options.requestAnimationFrame
             ?? globalThis.requestAnimationFrame?.bind(globalThis)
             ?? (callback => globalThis.setTimeout(() => callback(performance.now()), 0));
@@ -51,14 +62,22 @@ export class HistoryViewportController {
     apply(presentation) {
         if (this.disposed)
             return;
-        const invalidated = this.latest !== null && ((this.latest.state.contentEpoch ?? 0) !== (presentation.state.contentEpoch ?? 0)
-            || this.latest.geometry.generation !== presentation.geometry.generation
-            || this.latest.geometry.cols !== presentation.geometry.cols
-            || this.latest.geometry.rows !== presentation.geometry.rows);
+        const previous = this.latest;
+        const invalidated = previous !== null && ((previous.state.contentEpoch ?? 0) !== (presentation.state.contentEpoch ?? 0)
+            || previous.geometry.generation !== presentation.geometry.generation
+            || previous.geometry.cols !== presentation.geometry.cols
+            || previous.geometry.rows !== presentation.geometry.rows
+            || (previous.frame.history.historyEpoch !== undefined
+                && presentation.frame.history.historyEpoch !== undefined
+                && previous.frame.history.historyEpoch !== presentation.frame.history.historyEpoch));
         this.latest = presentation;
         this.options.renderer.apply(presentation);
-        if (invalidated)
+        if (invalidated) {
             this.resetHistory(true);
+        }
+        else if (previous) {
+            this.remapActiveHistory(previous);
+        }
         this.emitState();
     }
     scrollByRows(deltaRows) {
@@ -109,6 +128,7 @@ export class HistoryViewportController {
         // Invalidate any history request that was started before returning to the
         // live frontier. Its response must never re-enter the visible surface.
         this.epoch += 1;
+        this.cancelPrefetch();
         this.desiredOffset = null;
         this.preferExactViewport = false;
         this.visible = null;
@@ -121,6 +141,7 @@ export class HistoryViewportController {
         if (!this.latest || this.disposed || !Number.isFinite(offset))
             return;
         const target = clamp(Math.trunc(offset), 0, this.latest.frame.history.screenStartOffset);
+        this.cancelPrefetch();
         const current = this.currentIntentOffset();
         this.recordScrollIntent(target - current);
         emitSemanticDebugTrace({ kind: 'history-cache-check', at: performance.now(), target,
@@ -142,18 +163,22 @@ export class HistoryViewportController {
         const frontierWindow = this.frontier;
         if (frontierWindow && this.isReusableWindow(frontierWindow, target, this.latest.geometry.rows)) {
             this.desiredOffset = null;
-            this.display(sliceHistoryWindow(frontierWindow, target, this.latest.geometry.rows));
+            this.display(this.sliceWindow(frontierWindow, target, this.latest.geometry.rows));
             return;
         }
         const window = this.findCachedWindow(target, this.latest.geometry.rows);
         if (window) {
             this.desiredOffset = null;
             this.putCache(window);
-            this.display(sliceHistoryWindow(window, target, this.latest.geometry.rows));
+            this.display(this.sliceWindow(window, target, this.latest.geometry.rows));
             return;
         }
         this.desiredOffset = target;
         this.error = null;
+        // Project a geometry-stable placeholder before the first remote byte
+        // arrives. This keeps the wheel gesture visible in the same animation
+        // frame instead of leaving the old viewport on screen during the RTT.
+        this.projectPending(target);
         this.startLane();
         this.emitState();
     }
@@ -247,6 +272,8 @@ export class HistoryViewportController {
             return;
         this.disposed = true;
         this.epoch += 1;
+        this.cancelPrefetch();
+        HistoryViewportController.instances.delete(this);
         if (this.wheelFrame !== null)
             this.cancelFrame(this.wheelFrame);
         this.wheelFrame = null;
@@ -295,7 +322,7 @@ export class HistoryViewportController {
                         this.desiredOffset = null;
                     }
                     this.putCache(cachedWindow);
-                    const viewport = sliceHistoryWindow(cachedWindow, target, this.latest.geometry.rows);
+                    const viewport = this.sliceWindow(cachedWindow, target, this.latest.geometry.rows);
                     if (isCurrentTarget || this.shouldDisplayIntermediate(viewport.offset, desiredOffset)) {
                         this.display(viewport);
                     }
@@ -310,7 +337,7 @@ export class HistoryViewportController {
                 if (isCurrentTarget) {
                     this.desiredOffset = null;
                 }
-                if (isCurrentTarget || this.shouldDisplayIntermediate(viewport.offset, desiredOffset)) {
+                if (isCurrentTarget || (!this.pendingProjection && this.shouldDisplayIntermediate(viewport.offset, desiredOffset))) {
                     this.display(viewport);
                 }
             }
@@ -343,7 +370,6 @@ export class HistoryViewportController {
             throw new Error('terminal history requires a live Presentation');
         const rows = this.latest.geometry.rows;
         const totalRows = this.latest.frame.history.totalRows;
-        const revision = this.latest.frame.history.revision;
         const preferExactViewport = this.preferExactViewport;
         // A large wheel delta needs one exact target request, but must not poison
         // the rest of the session. Subsequent small deltas should use a reusable
@@ -354,9 +380,9 @@ export class HistoryViewportController {
             return this.fetchExactFromBoundary(target, rows);
         const cachedWindow = this.findCachedWindow(target, rows);
         if (cachedWindow)
-            return sliceHistoryWindow(cachedWindow, target, rows);
+            return this.sliceWindow(cachedWindow, target, rows);
         let frontier = this.frontier;
-        if (frontier && (frontier.revision !== revision || frontier.totalRows !== totalRows)) {
+        if (frontier && !this.isCompatibleWindow(frontier)) {
             this.frontier = null;
             frontier = null;
         }
@@ -365,7 +391,7 @@ export class HistoryViewportController {
         }
         if (frontier.window !== true)
             return frontier;
-        return sliceHistoryWindow(frontier, target, rows);
+        return this.sliceWindow(frontier, target, rows);
     }
     async fetchExactFromBoundary(target, rows) {
         // A boundary request already supports exact targeting in one RPC and
@@ -440,7 +466,7 @@ export class HistoryViewportController {
             // project the nearest viewport that is actually present in this atomic
             // snapshot instead of issuing a directionally invalid anchored request.
             const nearest = clamp(target, current.offset, current.offset + current.rows - rows);
-            return sliceHistoryWindow(current, nearest, rows);
+            return this.sliceWindow(current, nearest, rows);
         }
         if (!current)
             throw new Error('terminal history window is unavailable');
@@ -539,14 +565,58 @@ export class HistoryViewportController {
         this.scrollBurstAt = now;
     }
     windowCovers(window, target, rows) {
-        return target >= window.offset && target + rows <= window.offset + window.rows;
+        return this.windowCoversOrdinal(window, target, rows);
+    }
+    windowCoversOrdinal(window, target, rows) {
+        const targetOrdinal = this.offsetToOrdinal(target);
+        if (targetOrdinal === null || window.firstRowOrdinal === undefined) {
+            return target >= window.offset && target + rows <= window.offset + window.rows;
+        }
+        const windowStart = window.firstRowOrdinal + window.offset;
+        return targetOrdinal >= windowStart && targetOrdinal + rows <= windowStart + window.rows;
+    }
+    offsetToOrdinal(offset) {
+        const latest = this.latest?.frame.history;
+        if (!latest || latest.firstRowOrdinal === undefined)
+            return null;
+        return latest.firstRowOrdinal + offset;
+    }
+    sliceWindow(window, target, rows) {
+        const remapped = remapViewportOffset(window, target, this.latest);
+        if (!remapped) {
+            throw new SemanticHistoryError('snapshot_superseded', 'semantic history window no longer covers its target ordinal');
+        }
+        return sliceHistoryWindow(remapped, target, rows);
+    }
+    remapActiveHistory(previous) {
+        if (!this.latest)
+            return;
+        const previousHistory = previous.frame.history;
+        const currentHistory = this.latest.frame.history;
+        if (previousHistory.historyEpoch === undefined || currentHistory.historyEpoch === undefined
+            || previousHistory.firstRowOrdinal === undefined || currentHistory.firstRowOrdinal === undefined
+            || previousHistory.historyEpoch !== currentHistory.historyEpoch)
+            return;
+        const previousFirstRowOrdinal = previousHistory.firstRowOrdinal;
+        const currentFirstRowOrdinal = currentHistory.firstRowOrdinal;
+        const remapOffset = (offset) => clamp(previousFirstRowOrdinal + offset - currentFirstRowOrdinal, 0, currentHistory.screenStartOffset);
+        if (this.desiredOffset !== null)
+            this.desiredOffset = remapOffset(this.desiredOffset);
+        if (!this.visible)
+            return;
+        const target = remapOffset(this.visible.offset);
+        const remapped = remapViewportOffset(this.visible, target, this.latest);
+        if (remapped)
+            this.visible = remapped;
     }
     display(viewport) {
         this.visible = viewport;
+        this.pendingProjection = false;
         this.error = null;
         this.putCache(viewport);
         this.projectFrame(viewport.frame);
         this.evictCache();
+        this.schedulePrefetch();
         this.emitState();
     }
     cacheViewport(viewport) {
@@ -560,6 +630,15 @@ export class HistoryViewportController {
         }
         this.options.renderer.project(frame);
     }
+    projectPending(target) {
+        if (!this.latest)
+            return;
+        this.pendingProjection = true;
+        const pending = createPendingViewport(this.latest, target, this.transportGeneration ?? 1, ++this.skeletonSequence);
+        this.visible = pending;
+        emitSemanticDebugTrace({ kind: 'history-pending', at: performance.now(), target });
+        this.projectFrame(pending.frame);
+    }
     evictCache() {
         for (;;) {
             const candidates = [...this.cache.entries()]
@@ -576,6 +655,109 @@ export class HistoryViewportController {
         emitSemanticDebugTrace({ kind: 'history-cache-state', at: performance.now(),
             cacheEntries: this.cache.size, cacheBytes: this.cacheBytes,
             cacheExtraBytes: this.cacheExtraBytes() });
+        HistoryViewportController.evictGlobalCaches();
+    }
+    static evictGlobalCaches() {
+        const extraBytes = () => [...HistoryViewportController.instances]
+            .reduce((sum, controller) => sum + controller.cacheExtraBytes(), 0);
+        while (extraBytes() > MAX_PAGE_HISTORY_CACHE_BYTES) {
+            let oldest = null;
+            let oldestTouched = Number.POSITIVE_INFINITY;
+            for (const controller of HistoryViewportController.instances) {
+                const touched = controller.oldestExtraTouched();
+                if (touched < oldestTouched) {
+                    oldestTouched = touched;
+                    oldest = controller;
+                }
+            }
+            if (!oldest || !Number.isFinite(oldestTouched))
+                break;
+            oldest.removeOldestExtra();
+        }
+    }
+    oldestExtraTouched() {
+        let oldest = Number.POSITIVE_INFINITY;
+        for (const item of this.cache.values()) {
+            if (item.viewport !== this.visible)
+                oldest = Math.min(oldest, item.touched);
+        }
+        return oldest;
+    }
+    removeOldestExtra() {
+        let key = null;
+        let touched = Number.POSITIVE_INFINITY;
+        for (const [entryKey, item] of this.cache.entries()) {
+            if (item.viewport !== this.visible && item.touched < touched) {
+                key = entryKey;
+                touched = item.touched;
+            }
+        }
+        if (key !== null)
+            this.removeCacheEntry(key);
+    }
+    schedulePrefetch() {
+        if (this.disposed || !this.frontier || this.frontier.window !== true)
+            return;
+        if (this.prefetchTimer !== null)
+            clearTimeout(this.prefetchTimer);
+        const epoch = this.epoch;
+        this.prefetchTimer = setTimeout(() => {
+            this.prefetchTimer = null;
+            void this.runPrefetch(epoch);
+        }, HISTORY_PREFETCH_DELAY_MS);
+    }
+    cancelPrefetch() {
+        if (this.prefetchTimer !== null)
+            clearTimeout(this.prefetchTimer);
+        this.prefetchTimer = null;
+        this.prefetchAbort?.abort();
+        this.prefetchAbort = null;
+        this.prefetchTask = null;
+    }
+    async runPrefetch(epoch) {
+        const current = this.frontier;
+        const latest = this.latest;
+        if (this.disposed || epoch !== this.epoch || !latest || !current || current.window !== true)
+            return;
+        const rows = latest.geometry.rows;
+        const direction = this.scrollDirection || -1;
+        const totalRows = latest.frame.history.totalRows;
+        const windowRows = Math.min(totalRows, HISTORY_WINDOW_MAX_ROWS, Math.max(rows, rows * HISTORY_PREFETCH_SCREENS));
+        const frontRows = rows * HISTORY_PREFETCH_FRONT_SCREENS;
+        const target = clamp(current.offset + (direction < 0 ? -frontRows : frontRows), 0, Math.max(0, totalRows - rows));
+        const windowStart = this.windowStart(target, rows, windowRows, direction);
+        const abort = new AbortController();
+        this.prefetchAbort = abort;
+        const requestID = `prefetch-${++this.nextRequestID}`;
+        this.prefetchTask = runSemanticHistoryRequest(async () => validateHistoryWindow(await this.options.request({
+            requestId: requestID,
+            priority: 'prefetch',
+            signal: abort.signal,
+            lane: 'viewport',
+            direction: windowStart < current.offset ? 'backward' : 'forward',
+            anchor: current.anchor,
+            snapshotId: current.snapshotId,
+            offset: current.offset,
+            targetOffset: windowStart,
+            viewportRows: windowRows,
+            windowRows,
+        })), { priority: 'prefetch', signal: abort.signal }).then(next => {
+            if (this.disposed || epoch !== this.epoch || abort.signal.aborted)
+                return;
+            this.assertTransportGeneration(next);
+            this.acceptLineage(next);
+            this.frontier = next;
+            this.cacheWindow(next);
+        }).catch(error => {
+            if (!abort.signal.aborted) {
+                emitSemanticDebugTrace({ kind: 'history-prefetch-error', at: performance.now(), error });
+            }
+        }).finally(() => {
+            if (this.prefetchAbort === abort)
+                this.prefetchAbort = null;
+            this.prefetchTask = null;
+        });
+        await this.prefetchTask;
     }
     cacheExtraBytes() {
         return [...this.cache.values()]
@@ -584,6 +766,7 @@ export class HistoryViewportController {
     }
     isCompatible(viewport) {
         return Boolean(this.latest
+            && historyIdentityCompatible(viewport, this.latest)
             && viewport.contentEpoch === (this.latest.state.contentEpoch ?? 0)
             && viewport.geometryGeneration === this.latest.geometry.generation
             && (this.transportGeneration === null || viewport.transportGeneration === this.transportGeneration)
@@ -596,12 +779,12 @@ export class HistoryViewportController {
     isReusableViewport(viewport) {
         return Boolean(this.latest
             && this.isCompatible(viewport)
-            && viewport.totalRows === this.latest.frame.history.totalRows
-            && viewport.revision === this.latest.frame.history.revision);
+            && historyViewportRangeCompatible(viewport, this.latest));
     }
     isCompatibleWindow(viewport) {
         return Boolean(this.latest
             && viewport.window === true
+            && historyIdentityCompatible(viewport, this.latest)
             && viewport.contentEpoch === (this.latest.state.contentEpoch ?? 0)
             && viewport.geometryGeneration === this.latest.geometry.generation
             && (this.transportGeneration === null || viewport.transportGeneration === this.transportGeneration)
@@ -613,9 +796,9 @@ export class HistoryViewportController {
     isReusableWindow(viewport, target, rows) {
         return Boolean(this.latest
             && this.isCompatibleWindow(viewport)
-            && viewport.totalRows === this.latest.frame.history.totalRows
+            && historyViewportRangeCompatible(viewport, this.latest)
             && this.windowCovers(viewport, target, rows)
-            && viewport.revision === this.latest.frame.history.revision);
+            && viewport.revision <= this.latest.frame.history.revision);
     }
     assertTransportGeneration(viewport) {
         if (this.transportGeneration === null) {
@@ -628,9 +811,11 @@ export class HistoryViewportController {
     }
     resetHistory(projectLatest, error = null) {
         this.epoch += 1;
+        this.cancelPrefetch();
         this.clearCache();
         this.frontier = null;
         this.visible = null;
+        this.pendingProjection = false;
         this.desiredOffset = null;
         this.preferExactViewport = false;
         this.scrollDirection = 0;
@@ -645,7 +830,7 @@ export class HistoryViewportController {
         this.emitState();
     }
     shouldDisplayIntermediate(target, desiredOffset) {
-        if (desiredOffset === null || this.visible === null)
+        if (this.pendingProjection || desiredOffset === null || this.visible === null)
             return false;
         const currentOffset = this.visible.offset;
         const minimum = Math.min(currentOffset, desiredOffset);
@@ -655,8 +840,11 @@ export class HistoryViewportController {
     }
     findCachedViewport(offset) {
         for (const item of this.cache.values()) {
-            if (item.viewport.offset === offset && this.isReusableViewport(item.viewport))
-                return item.viewport;
+            if (!this.isReusableViewport(item.viewport))
+                continue;
+            const remapped = remapViewportOffset(item.viewport, offset, this.latest);
+            if (remapped)
+                return remapped;
         }
         return null;
     }
@@ -669,7 +857,7 @@ export class HistoryViewportController {
                 && (!candidate || item.touched > candidate.touched))
                 candidate = item;
         }
-        return candidate?.viewport ?? null;
+        return candidate ? remapViewportOffset(candidate.viewport, offset, this.latest) : null;
     }
     cacheWindow(viewport) {
         if (viewport.window !== true)
@@ -738,9 +926,152 @@ export class HistoryViewportController {
         this.options.onState?.(this.getState());
     }
 }
+HistoryViewportController.instances = new Set();
 function clamp(value, minimum, maximum) {
     return Math.max(minimum, Math.min(maximum, value));
 }
+function historyIdentityCompatible(viewport, latest) {
+    const current = latest.frame.history;
+    if (viewport.historyEpoch === undefined || current.historyEpoch === undefined
+        || viewport.firstRowOrdinal === undefined || current.firstRowOrdinal === undefined) {
+        return true;
+    }
+    if (viewport.historyEpoch !== current.historyEpoch)
+        return false;
+    const start = viewport.firstRowOrdinal + viewport.offset;
+    const latestStart = current.firstRowOrdinal;
+    const latestEnd = latestStart + current.totalRows;
+    return start >= latestStart && start + viewport.rows <= latestEnd;
+}
+function historyViewportRangeCompatible(viewport, latest) {
+    const current = latest.frame.history;
+    if (viewport.firstRowOrdinal === undefined || current.firstRowOrdinal === undefined) {
+        return viewport.offset + viewport.rows <= current.totalRows && viewport.totalRows <= current.totalRows;
+    }
+    const start = viewport.firstRowOrdinal + viewport.offset;
+    const end = start + viewport.rows;
+    const latestStart = current.firstRowOrdinal;
+    return start >= latestStart && end <= latestStart + current.totalRows;
+}
+function remapViewportOffset(viewport, targetOffset, latest) {
+    if (!latest)
+        return null;
+    const current = latest.frame.history;
+    if (viewport.historyEpoch !== undefined && current.historyEpoch !== undefined
+        && viewport.firstRowOrdinal !== undefined && current.firstRowOrdinal !== undefined) {
+        const sourceOrdinal = viewport.firstRowOrdinal + viewport.offset;
+        const targetOrdinal = current.firstRowOrdinal + targetOffset;
+        if (viewport.window === true) {
+            const windowStart = viewport.firstRowOrdinal + viewport.offset;
+            if (targetOrdinal < windowStart || targetOrdinal + latest.geometry.rows > windowStart + viewport.rows)
+                return null;
+            const remappedOffset = windowStart - current.firstRowOrdinal;
+            if (remappedOffset === viewport.offset
+                && viewport.firstRowOrdinal === current.firstRowOrdinal
+                && viewport.totalRows === current.totalRows)
+                return viewport;
+            const remapped = {
+                ...viewport,
+                offset: remappedOffset,
+                totalRows: current.totalRows,
+                screenStartOffset: current.totalRows - viewport.rows,
+                firstRowOrdinal: current.firstRowOrdinal,
+                screenStartRowOrdinal: current.firstRowOrdinal + current.totalRows - viewport.rows,
+                frame: {
+                    ...viewport.frame,
+                    history: {
+                        ...viewport.frame.history,
+                        totalRows: current.totalRows,
+                        screenStartOffset: current.totalRows - viewport.rows,
+                        firstRowOrdinal: current.firstRowOrdinal,
+                        screenStartRowOrdinal: current.firstRowOrdinal + current.totalRows - viewport.rows,
+                    },
+                },
+            };
+            return remapped;
+        }
+        if (sourceOrdinal !== targetOrdinal)
+            return null;
+        if (viewport.offset === targetOffset
+            && viewport.firstRowOrdinal === current.firstRowOrdinal
+            && viewport.totalRows === current.totalRows)
+            return viewport;
+        return {
+            ...viewport,
+            offset: targetOffset,
+            totalRows: current.totalRows,
+            screenStartOffset: current.totalRows - viewport.rows,
+            firstRowOrdinal: current.firstRowOrdinal,
+            screenStartRowOrdinal: current.firstRowOrdinal + current.totalRows - viewport.rows,
+            frame: {
+                ...viewport.frame,
+                history: {
+                    ...viewport.frame.history,
+                    totalRows: current.totalRows,
+                    screenStartOffset: current.totalRows - viewport.rows,
+                    firstRowOrdinal: current.firstRowOrdinal,
+                    screenStartRowOrdinal: current.firstRowOrdinal + current.totalRows - viewport.rows,
+                },
+            },
+        };
+    }
+    if (viewport.window === true)
+        return viewport;
+    if (viewport.offset !== targetOffset)
+        return null;
+    return viewport;
+}
+function createPendingViewport(presentation, offset, transportGeneration, sequence) {
+    const source = presentation.frame;
+    const totalRows = source.history.totalRows;
+    const rows = source.height;
+    const marker = `pending-${sequence}`;
+    const skeletonRow = Array.from({ length: source.width }, () => ({
+        text: '',
+        width: 1,
+    }));
+    const frame = {
+        ...source,
+        rows: Array.from({ length: rows }, () => ({ cells: skeletonRow.map(cell => ({ ...cell })) })),
+        cursor: { ...source.cursor, visible: false },
+        history: {
+            revision: source.history.revision,
+            totalRows,
+            screenStartOffset: totalRows - rows,
+            historyEpoch: source.history.historyEpoch,
+            firstRowOrdinal: source.history.firstRowOrdinal,
+            screenStartRowOrdinal: source.history.firstRowOrdinal === undefined
+                ? source.history.screenStartRowOrdinal
+                : source.history.firstRowOrdinal + totalRows - rows,
+            pending: true,
+            pendingOffset: offset,
+        },
+        graphics: { generation: source.graphics.generation, images: [], placements: [] },
+    };
+    return {
+        snapshotId: marker,
+        lane: 'viewport',
+        revision: source.history.revision,
+        transportGeneration,
+        contentEpoch: presentation.state.contentEpoch ?? 0,
+        geometryGeneration: presentation.geometry.generation,
+        cols: source.width,
+        rows,
+        anchor: marker,
+        firstAvailable: marker,
+        lastAvailable: marker,
+        screenStart: marker,
+        offset,
+        totalRows,
+        screenStartOffset: totalRows - rows,
+        historyEpoch: source.history.historyEpoch,
+        firstRowOrdinal: source.history.firstRowOrdinal,
+        screenStartRowOrdinal: source.history.screenStartRowOrdinal,
+        hasPrevious: offset > 0,
+        hasNext: offset < totalRows - rows,
+        frame,
+    };
+}
 function isLegacyBoundaryTargetRejection(cause) {
     if (!(cause instanceof Error))
         return false;
@@ -804,6 +1135,11 @@ function sliceHistoryWindow(window, offset, rows) {
             revision: window.revision,
             totalRows: window.totalRows,
             screenStartOffset: window.totalRows - rows,
+            historyEpoch: window.historyEpoch,
+            firstRowOrdinal: window.firstRowOrdinal,
+            screenStartRowOrdinal: window.firstRowOrdinal === undefined
+                ? window.screenStartRowOrdinal
+                : window.firstRowOrdinal + window.totalRows - rows,
         },
         graphics: { ...frame.graphics, placements },
     };
@@ -823,6 +1159,11 @@ function sliceHistoryWindow(window, offset, rows) {
         offset,
         totalRows: window.totalRows,
         screenStartOffset,
+        historyEpoch: window.historyEpoch,
+        firstRowOrdinal: window.firstRowOrdinal,
+        screenStartRowOrdinal: window.firstRowOrdinal === undefined
+            ? window.screenStartRowOrdinal
+            : window.firstRowOrdinal + screenStartOffset,
         hasPrevious: offset > 0,
         hasNext: offset < screenStartOffset,
         frame: slicedFrame,