@deepseek-ai/dsh-api-session-controller 0.1.2-alpha.2 → 0.1.2-alpha.4

package/lib/types/client/sessions/session.js

@@ -1,5 +1,6 @@
 // Sessions remain resident after creation so their open Remote sources keep running off-screen.
 import { randomUUID } from '@deepseek-ai/dsh-util-crypto';
+import { SessionLogOffset, SessionSeq } from '@deepseek-ai/dsh-session/types';
 import { SessionEventStream } from "../transport.js";
 import { MutableSessionEventSource } from "../contract/events.js";
 import { Notifier } from "./notifier.js";
@@ -7,8 +8,16 @@ import { isRemoteFailure } from '@deepseek-ai/dsh-api-gateway/client';
 import { ProjectionValueStore } from "./projection-store.js";
 import { resolvedClientTimeZone } from "../time-zone.js";
 import { SessionQueueMirror } from "./queue-mirror.js";
+function projectionsBaseline(value) {
+    return {
+        ...value,
+        asOfSeq: value.asOfSeq === -1 ? -1 : SessionSeq(value.asOfSeq),
+    };
+}
 /** Messages requested per history page. */
 export const PAGE_MESSAGES = 50;
+/** Messages requested per page while a turn jump loops backwards (fewer, larger round trips). */
+export const JUMP_PAGE_MESSAGES = 200;
 /**
  * Owns a session's event window, lifecycle state, and observable
  * snapshot. React bindings remain outside this data layer. Features see only
@@ -20,7 +29,7 @@ export class Session {
     remote;
     options;
     // ---- Window and derived state (all private; the snapshot is the only read API) ----
-    baseSeq = 0;
+    baseSeq = SessionLogOffset(0);
     hasMore = false;
     openState = 'cold';
     openError = null;
@@ -29,6 +38,10 @@ export class Session {
      *  passes drop all writes once the generation moves on. */
     openGeneration = 0;
     loadingOlder = false;
+    /** Shared low-water target of the running jump loop; null when no jump is paging. */
+    jumpTargetSeq = null;
+    /** The running jump loop's completion, shared by retargeting callers. */
+    jumpPromise = null;
     /** Authoritative stream-only inbox snapshot; pending work never hits history. */
     queueMirror = new SessionQueueMirror();
     running = false;
@@ -125,6 +138,9 @@ export class Session {
         const requestId = randomUUID();
         this.pendingSubmissions = [...this.pendingSubmissions, {
                 requestId,
+                placement: this.running
+                    ? input.mode === 'steer' ? 'steering' : 'queued'
+                    : 'transcript',
                 time: Date.now(),
                 text: input.text,
                 images: input.images,
@@ -247,9 +263,11 @@ export class Session {
      */
     async rename(title) {
         const result = await this.remote.session.rename({ sessionId: this.sessionId, title });
-        if (result.ok)
-            this.projections.apply('title', result.value.title, result.value.seq);
-        return result;
+        if (!result.ok)
+            return result;
+        const seq = SessionSeq(result.value.seq);
+        this.projections.apply('title', result.value.title, seq);
+        return { ok: true, value: { title: result.value.title, seq } };
     }
     /**
      * Execute one slash-command line against this session's agent — pure
@@ -300,6 +318,58 @@ export class Session {
             this.notifier.markDirty();
         }
     }
+    /** Jump loader: page backwards until the window covers seq (see ISession.loadThrough). */
+    loadThrough(seq) {
+        if (this.openState !== 'open' || !this.hasMore || this.baseSeq <= seq)
+            return Promise.resolve();
+        if (this.jumpPromise !== null) {
+            // Retarget the running loop to the lowest requested seq.
+            this.jumpTargetSeq = SessionSeq(Math.min(this.jumpTargetSeq ?? seq, seq));
+            return this.jumpPromise;
+        }
+        // A plain single-page pull owns the busy flag; the jump does not queue
+        // behind it (the caller retries once it settles) and must leave no
+        // target behind — only the loop's finally clears that field, and no
+        // loop starts here.
+        if (this.loadingOlder)
+            return Promise.resolve();
+        this.jumpTargetSeq = seq;
+        this.loadingOlder = true;
+        this.notifier.markDirty();
+        // Stale-pass guard (the doOpen pattern): a resync mid-loop replaces the
+        // stream generation; this pass then stops instead of paging the new
+        // generation toward its old target.
+        const generation = this.openGeneration;
+        this.jumpPromise = (async () => {
+            try {
+                while (this.hasMore && this.jumpTargetSeq !== null && this.baseSeq > this.jumpTargetSeq) {
+                    if (generation !== this.openGeneration)
+                        return;
+                    const events = this.events;
+                    if (events === undefined)
+                        return;
+                    const before = this.baseSeq;
+                    await events.prepend({ beforeSeq: this.baseSeq, maxMessages: JUMP_PAGE_MESSAGES });
+                    // No-progress guard: an empty or dropped page that still claims more
+                    // history must end the loop, not spin it.
+                    if (this.baseSeq >= before)
+                        return;
+                }
+            }
+            catch (error) {
+                if (!isRemoteFailure(error)) {
+                    console.error('[session-controller] loadThrough failed:', error);
+                }
+            }
+            finally {
+                this.jumpTargetSeq = null;
+                this.jumpPromise = null;
+                this.loadingOlder = false;
+                this.notifier.markDirty();
+            }
+        })();
+        return this.jumpPromise;
+    }
     /** Rebuild an opened history source after address replacement.
      *  Invalidates any in-flight open first; queue state belongs to the independently
      *  reconnecting control stream and remains untouched. */
@@ -313,7 +383,7 @@ export class Session {
         this.openPromise = null;
         this.openState = 'cold';
         this.openError = null;
-        this.baseSeq = 0;
+        this.baseSeq = SessionLogOffset(0);
         this.notifier.markDirty();
         await this.open();
     }
@@ -483,7 +553,7 @@ export class Session {
     acceptEventChange(change) {
         switch (change.type) {
             case 'replace':
-                this.installWindow(change.entries, change.hasMore, change.page.projections);
+                this.installWindow(change.entries, change.hasMore, change.page.projections === undefined ? undefined : projectionsBaseline(change.page.projections));
                 return;
             case 'prepend':
                 this.prependWindow(change.entries, change.hasMore);
@@ -495,7 +565,7 @@ export class Session {
     }
     /** Replace the complete contiguous window and apply page-owned projection metadata. */
     installWindow(entries, hasMore, projections) {
-        this.baseSeq = entries[0]?.event.seq ?? 0;
+        this.baseSeq = SessionLogOffset(entries[0]?.event.seq ?? 0);
         this.hasMore = hasMore;
         if (entries.some(entry => entry.event.type === 'turn/start'))
             this.firstPromptPendingTurn = false;
@@ -508,7 +578,7 @@ export class Session {
     }
     /** Prepend one stream-validated history page. */
     prependWindow(entries, hasMore) {
-        this.baseSeq = entries[0]?.event.seq ?? this.baseSeq;
+        this.baseSeq = entries[0] === undefined ? this.baseSeq : SessionLogOffset(entries[0].event.seq);
         this.hasMore = hasMore;
         this.eventSource.prepend(entries, hasMore);
     }

package/lib/types/commands.js

@@ -53,8 +53,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { randomUUID } from 'node:crypto';
 import { brandString } from '@deepseek-ai/dsh-brand';
-import { AttachmentError, admitEncodedImages } from '@deepseek-ai/dsh-attachment';
+import { AttachmentError, admitPromptContent } from '@deepseek-ai/dsh-attachment';
 import { ReasoningEffortId, createUserMessage, freezeMessage, } from '@deepseek-ai/dsh-llm';
+import { SessionLogOffset, SessionSeq } from '@deepseek-ai/dsh-session';
 import { SessionQueryError } from '@deepseek-ai/dsh-session-query';
 import { SessionTitleInvalidError } from '@deepseek-ai/dsh-session-title';
 import { canonicalClientTimeZone } from '@deepseek-ai/dsh-util-time';
@@ -182,9 +183,12 @@ export class SessionCommandController {
     async fork(request) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            if (request.atSeq !== undefined
-                && (!Number.isInteger(request.atSeq) || request.atSeq < 0)) {
-                throw new RemoteError('gateway/bad-request', 'atSeq must be a non-negative integer', {});
+            let atSeq;
+            try {
+                atSeq = request.atSeq === undefined ? undefined : SessionSeq(request.atSeq);
+            }
+            catch {
+                throw new RemoteError('gateway/bad-request', 'atSeq must be a non-negative safe integer', {});
             }
             let observed;
             try {
@@ -201,7 +205,6 @@ export class SessionCommandController {
             }
             const source = __addDisposableResource(env_1, observed, false);
             const lastSeq = source.events.at(-1)?.seq ?? -1;
-            const atSeq = request.atSeq;
             const anchoredBoundary = atSeq === undefined
                 ? undefined
                 : source.events.find(event => event.type === 'turn/end' && event.seq >= atSeq);
@@ -214,9 +217,10 @@ export class SessionCommandController {
                     ? `session "${request.sessionId}" has not completed the turn containing event ${String(atSeq)}`
                     : `session "${request.sessionId}" has no completed turn to fork from`, { sessionId: request.sessionId });
             }
-            let cut = boundary.seq + 1;
-            while (cut < source.events.length && source.events[cut]?.type !== 'turn/start')
-                cut++;
+            let cut = SessionLogOffset(boundary.seq + 1);
+            while (cut < source.events.length && source.events[cut]?.type !== 'turn/start') {
+                cut = SessionLogOffset(cut + 1);
+            }
             let workspace;
             try {
                 workspace = await this.forkWorkspace(source.header);
@@ -231,10 +235,11 @@ export class SessionCommandController {
                 await this.ctx.agents.create({
                     sessionId: childId,
                     seed: source.events.slice(0, cut),
+                    inheritedEventCount: cut,
                     meta: {
                         ...(source.header.cwd === undefined ? {} : { cwd: source.header.cwd }),
                         parentSession: source.header.id,
-                        seedLength: cut,
+                        isSeeded: true,
                         ...(composition.agentPreset === undefined
                             ? {}
                             : { agentPreset: composition.agentPreset }),
@@ -296,7 +301,7 @@ export class SessionCommandController {
                         throw new RemoteError('session/attachment-invalid', `Model "${current.model}" does not support image input.`, { reason: 'MODEL_DOES_NOT_SUPPORT_IMAGES' });
                     }
                 }
-                const content = await durablePromptContent(this.ctx, request.content);
+                const content = await admitPromptContent(this.ctx.attachments, request.content);
                 const message = createUserMessage({ content, source });
                 if (request.mode === 'steer')
                     agent.steer(message);
@@ -438,7 +443,7 @@ export class SessionCommandController {
     async readSessionState(sessionId) {
         const attached = this.ctx.sessions.get(sessionId);
         if (attached !== undefined) {
-            return { id: attached.id, header: attached.header, events: [...attached.events] };
+            return { id: attached.id, header: attached.header, events: attached.snapshotEvents() };
         }
         const inspected = await inspectApiSession(this.ctx, sessionId);
         return { id: inspected.meta.id, header: inspected.meta, events: inspected.events };
@@ -457,17 +462,6 @@ export class SessionCommandController {
         return undefined;
     }
 }
-async function durablePromptContent(ctx, content) {
-    if (content.every(part => part.type === 'text')) {
-        return content.map(part => ({ type: 'text', text: part.text }));
-    }
-    const refs = await admitEncodedImages(ctx.attachments, content.filter(part => part.type === 'image'));
-    let next = 0;
-    return content.map(part => part.type === 'text'
-        ? { type: 'text', text: part.text }
-        // admitEncodedImages returns one reference per image part in order.
-        : { type: 'image', attachment: refs[next++] });
-}
 function imageBlockIn(content, match) {
     if (!Array.isArray(content))
         return undefined;

package/lib/types/history.js

@@ -52,7 +52,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Deque } from '@deepseek-ai/dsh-deque';
-import { isAppendSurfaceEvent } from '@deepseek-ai/dsh-session';
+import { isAppendSurfaceEvent, SessionLogOffset, SessionSeq, } from '@deepseek-ai/dsh-session';
 import { isChunkRow, packChunkRuns } from '@deepseek-ai/dsh-session/chunk-rows';
 import { SessionQueryError } from '@deepseek-ai/dsh-session-query';
 import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
@@ -86,18 +86,24 @@ export class SessionHistoryController {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             validatePageRequest(request);
+            const throughSeq = request.throughSeq === -1
+                ? -1
+                : SessionSeq(request.throughSeq);
+            const beforeSeq = request.beforeSeq === undefined
+                ? undefined
+                : SessionLogOffset(request.beforeSeq);
             const source = __addDisposableResource(env_1, await this.sourceFor(request.address, signal, false), false);
             signal.throwIfAborted();
             const sourceLog = source.events;
             const sourceCursor = sourceLog.at(-1)?.seq ?? -1;
-            if (request.throughSeq > sourceCursor) {
-                throw new RemoteError('gateway/bad-request', `session page through seq ${String(request.throughSeq)} is past cursor ${String(sourceCursor)}`, {});
+            if (throughSeq > sourceCursor) {
+                throw new RemoteError('gateway/bad-request', `session page through seq ${String(throughSeq)} is past cursor ${String(sourceCursor)}`, {});
             }
             /* v8 ignore next -- Session and persistence validation guarantee a dense zero-based event prefix. */
-            if (request.throughSeq >= 0 && sourceLog[request.throughSeq]?.seq !== request.throughSeq) {
-                throw new RemoteError('gateway/internal', `session log does not contain through seq ${String(request.throughSeq)}`, {});
+            if (throughSeq >= 0 && sourceLog[throughSeq]?.seq !== throughSeq) {
+                throw new RemoteError('gateway/internal', `session log does not contain through seq ${String(throughSeq)}`, {});
             }
-            const page = paginate(sourceLog, request.beforeSeq, request.maxMessages ?? DEFAULT_MAX_MESSAGES, request.throughSeq);
+            const page = paginate(sourceLog, beforeSeq, request.maxMessages ?? DEFAULT_MAX_MESSAGES, throughSeq);
             const records = pageRecords(page.events);
             return {
                 records,
@@ -148,9 +154,9 @@ export class SessionHistoryController {
             // Constructor seed events have no session/event notification. Normally
             // only the end-seed suffix is new; if persistence advanced after the
             // opening observation, replay everything beyond that snapshot cursor.
-            const suffix = session.events.slice(snapshotCursor === undefined
+            const suffix = session.snapshotEvents(snapshotCursor === undefined
                 ? session.firstLiveSeq
-                : snapshotCursor + 1);
+                : SessionLogOffset(snapshotCursor + 1));
             for (let index = suffix.length - 1; index >= 0; index -= 1) {
                 buffered.pushFront(suffix[index]);
             }
@@ -169,7 +175,7 @@ export class SessionHistoryController {
                 const page = paginate(events, undefined, request.maxMessages ?? DEFAULT_MAX_MESSAGES);
                 yield {
                     type: 'snapshot',
-                    header: source.header,
+                    header: wireHeader(source.header, source.inheritedEventCount),
                     cursor,
                     records: pageRecords(page.events),
                     hasMore: page.hasMore,
@@ -187,19 +193,20 @@ export class SessionHistoryController {
                         throw error;
                     }
                 }
-                let nextSeq = cursor + 1;
+                let nextOffset = SessionLogOffset(cursor + 1);
                 while (!follower.closed && !signal.aborted) {
                     const item = buffered.popFront();
                     if (item === undefined) {
                         await new Promise((resolve) => { wake = resolve; });
                         continue;
                     }
-                    if (item.seq < nextSeq)
+                    const expectedSeq = SessionSeq(nextOffset);
+                    if (item.seq < expectedSeq)
                         continue;
-                    if (item.seq !== nextSeq) {
-                        throw new RemoteError('gateway/internal', `session event stream skipped seq ${String(nextSeq)}`, {});
+                    if (item.seq !== expectedSeq) {
+                        throw new RemoteError('gateway/internal', `session event stream skipped seq ${String(expectedSeq)}`, {});
                     }
-                    nextSeq++;
+                    nextOffset = SessionLogOffset(nextOffset + 1);
                     yield entryFor(item);
                 }
             }
@@ -230,7 +237,7 @@ export class SessionHistoryController {
                 rejectNotFound(address);
             }
             try {
-                validateAddress(address, observation.header, observation.projections);
+                validateAddress(address, observation.header, observation.inheritedEventCount, observation.projections);
             }
             catch (error) {
                 observation[Symbol.dispose]();
@@ -254,11 +261,15 @@ function projectionBlock(snapshot) {
     };
 }
 function validatePageRequest(request) {
-    if (!Number.isSafeInteger(request.throughSeq) || request.throughSeq < -1) {
+    if (!Number.isSafeInteger(request.throughSeq)
+        || request.throughSeq < -1
+        || Object.is(request.throughSeq, -0)) {
         throw new RemoteError('gateway/bad-request', 'throughSeq must be an integer greater than or equal to -1', {});
     }
     if (request.beforeSeq !== undefined
-        && (!Number.isSafeInteger(request.beforeSeq) || request.beforeSeq < 0)) {
+        && (!Number.isSafeInteger(request.beforeSeq)
+            || request.beforeSeq < 0
+            || Object.is(request.beforeSeq, -0))) {
         throw new RemoteError('gateway/bad-request', 'beforeSeq must be a non-negative safe integer', {});
     }
     if (request.maxMessages !== undefined
@@ -275,7 +286,7 @@ function validateFollowRequest(request) {
 function addressId(address) {
     return address.kind === 'session' ? address.sessionId : address.childSessionId;
 }
-function validateAddress(address, header, projections) {
+function validateAddress(address, header, inheritedEventCount, projections) {
     if (address.kind === 'session') {
         if (header.origin === 'subagent') {
             throw new RemoteError('session/agent-busy', 'subagent Sessions require their durable parent address', {
@@ -297,7 +308,7 @@ function validateAddress(address, header, projections) {
             reason: 'corrupt',
         });
     }
-    if (identity === undefined || identity.seq < (header.seedLength ?? 0)) {
+    if (identity === undefined || identity.seq < inheritedEventCount) {
         throw new RemoteError('subagent/catalog-diagnostic', 'subagent descriptor is unavailable', {
             parentSessionId: address.parentSessionId,
             childSessionId: address.childSessionId,
@@ -320,9 +331,9 @@ function rejectNotFound(address) {
     });
 }
 function paginate(events, beforeSeq, maxMessages, throughSeq = events.at(-1)?.seq ?? -1) {
-    const end = Math.min(throughSeq + 1, beforeSeq ?? throughSeq + 1);
+    const end = SessionLogOffset(Math.min(throughSeq + 1, beforeSeq ?? throughSeq + 1));
     let count = 0;
-    let cut = 0;
+    let cut = SessionLogOffset(0);
     for (let index = end - 1; index >= 0; index--) {
         const event = events[index];
         if (!MESSAGE_TYPES.has(event.type) || !isAppendSurfaceEvent(event))
@@ -331,16 +342,26 @@ function paginate(events, beforeSeq, maxMessages, throughSeq = events.at(-1)?.se
         const sources = event.sourceEventSeqs;
         let groupStart = event.seq;
         if (sources !== undefined) {
-            for (const source of sources)
-                groupStart = Math.min(groupStart, source);
+            for (const source of sources) {
+                if (source < groupStart)
+                    groupStart = source;
+            }
         }
         if (count >= maxMessages) {
-            cut = groupStart;
+            cut = SessionLogOffset(groupStart);
             break;
         }
     }
     return { events: events.slice(cut, end), hasMore: cut > 0 };
 }
+/** Translate logical Session metadata to the unchanged v0 browser wire. */
+function wireHeader(header, inheritedEventCount) {
+    const { isSeeded, ...wire } = header;
+    return {
+        ...wire,
+        ...isSeeded ? { seedLength: inheritedEventCount } : {},
+    };
+}
 function entryFor(event) {
     return {
         type: 'event',

package/lib/types/index.d.ts

@@ -1,7 +1,8 @@
 /** Session Remote owner: cold reads, explicit Agent commands, and live control state. */
 import { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
-import type { SessionEvent, SessionHeader, SessionId } from '@deepseek-ai/dsh-session';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import type { SessionInspection } from '@deepseek-ai/dsh-session-persistence';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { type ApiSessionAgentResult } from './agent.ts';
 import { buildModelCatalog } from './catalog.ts';
@@ -60,10 +61,7 @@ export declare class SessionController extends TypertRemoteService {
      * @param signal - optional caller cancellation for persistence reads.
      * @returns the current attached state or persisted header and event prefix.
      */
-    inspect(sessionId: SessionId, signal?: AbortSignal): Promise<{
-        meta: SessionHeader;
-        events: SessionEvent[];
-    }>;
+    inspect(sessionId: SessionId, signal?: AbortSignal): Promise<SessionInspection>;
     /**
      * Read all visible Session rows without resuming an Agent.
      * @param _request - reserved empty list request.

package/lib/types/index.js

@@ -266,7 +266,11 @@ let SessionController = (() => {
         inspect(sessionId, signal) {
             const attached = this.ctx.sessions.get(sessionId);
             if (attached !== undefined) {
-                return Promise.resolve({ meta: attached.header, events: [...attached.events] });
+                return Promise.resolve({
+                    meta: attached.header,
+                    inheritedEventCount: attached.inheritedEventCount,
+                    events: attached.snapshotEvents(),
+                });
             }
             return inspectApiSession(this.ctx, sessionId, signal);
         }

package/lib/types/list.js

@@ -52,6 +52,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { stat } from 'node:fs/promises';
+import { SessionLogOffset } from '@deepseek-ai/dsh-session';
 import { SessionQueryError } from '@deepseek-ai/dsh-session-query';
 import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
 import { z } from 'zod';
@@ -362,7 +363,9 @@ export class ApiSessionList {
     projectionsFor(header, session) {
         try {
             const block = session === undefined
-                ? this.ctx.get('sessionProjectionCache')?.cachedSnapshot(header)
+                ? header.isSeeded
+                    ? undefined
+                    : this.ctx.get('sessionProjectionCache')?.cachedSnapshot(header, SessionLogOffset(0))
                 : this.ctx.sessionProjections.cachedSnapshot(session);
             return block !== undefined && Object.keys(block.values).length > 0
                 ? {

package/lib/types/types.d.ts

@@ -4,7 +4,7 @@ import type { Branded } from '@deepseek-ai/dsh-brand';
 import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
 import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
 import type { ChunkRow } from '@deepseek-ai/dsh-session/chunk-rows';
-import type { SessionHeader, SessionId, SurfaceOp } from '@deepseek-ai/dsh-session/types';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { SessionProjectionMap } from '@deepseek-ai/dsh-session-projection/types';
 import type { JobId } from '@deepseek-ai/dsh-jobs/brand';
 import type { JsonValue } from '@deepseek-ai/dsh-util-values';
@@ -358,6 +358,25 @@ export interface SessionEventEntry {
     readonly type: 'event';
     readonly event: SessionWireEvent;
 }
+/** v0-compatible Session metadata carried on the browser wire. */
+export interface SessionWireHeader {
+    readonly version: number;
+    readonly id: SessionId;
+    readonly createdAt: number;
+    readonly cwd?: string;
+    readonly parentSession?: SessionId;
+    /** Exact inherited prefix length; absent for an unseeded Session. */
+    readonly seedLength?: number;
+    readonly origin?: 'subagent';
+    readonly delegationDepth?: number;
+    readonly agentPreset?: string;
+}
+/** Browser wire form of one Session surface operation. */
+export type SessionWireSurfaceOp = 'append' | {
+    readonly op: 'replace';
+    readonly start: number;
+    readonly end: number;
+};
 /** Event-shaped wire representation of one packed chunk row. */
 export type ChunkRowEvent = {
     [Kind in ChunkRow['type']]: {
@@ -384,7 +403,7 @@ export interface SessionWireEvent {
     readonly data: JsonValue;
     readonly ignorable?: true;
     readonly sourceEventSeqs?: number[];
-    readonly surfaceOp?: SurfaceOp;
+    readonly surfaceOp?: SessionWireSurfaceOp;
 }
 /** One message-aligned backwards-history request. */
 export interface SessionPageRequest {
@@ -407,7 +426,7 @@ export interface SessionPage {
 /** Complete opening window followed by ordered events appended after its cursor. */
 export type SessionFollowFrame = {
     readonly type: 'snapshot';
-    readonly header: SessionHeader;
+    readonly header: SessionWireHeader;
     readonly cursor: number;
     readonly records: readonly SessionHistoryRecord[];
     readonly hasMore: boolean;