@morlay/session-rdb 0.1.9 → 0.1.10-alpha.2

package/src/write-path.ts

@@ -0,0 +1,286 @@
+import { randomUUID } from "node:crypto";
+import {
+  SessionLogOffset,
+  type SessionEvent,
+  type SurfaceEventType,
+  type SessionHeader,
+  type SessionId,
+} from "@deepseek-ai/dsh-session";
+import { validateStoredEvents } from "@deepseek-ai/dsh-session-persistence";
+import type { Backend, BackendTx, EventInsert } from "./backend.ts";
+import type { WriteGuard } from "./write-guard.ts";
+import type { RdbBackendTracker } from "./handles.ts";
+import { EVENT_ENCODING } from "./version.ts";
+import { eventDimensions } from "./event-shape.ts";
+import { usageRowOf, type EventUsageRow } from "./log/usage-row.ts";
+import { sealOwnEvents } from "./log/repair.ts";
+import { sessionCountBuckets, sessionUsageBuckets } from "./stats-fold.ts";
+
+function maxEventTime(events: readonly { readonly time?: number }[]): number | undefined {
+  let max: number | undefined;
+  for (const event of events) {
+    const time = event.time;
+    if (typeof time !== "number") continue;
+    if (max === undefined || time > max) max = time;
+  }
+  return max;
+}
+
+function describeError(error: unknown): string {
+  return error instanceof Error ? error.message : "unknown error";
+}
+
+export interface WritePathDeps {
+  readonly ready: Promise<void>;
+  backend(): Backend;
+  readonly tracker: RdbBackendTracker;
+  readonly writeGuard: WriteGuard;
+  readonly reuseEventIds: Map<SessionId, Map<number, string>>;
+  readonly logger: { warn(message: string): void };
+  readLog(id: SessionId): Promise<
+    | { meta: SessionHeader; inheritedEventCount: number; events: SessionEvent[] }
+    | undefined
+  >;
+}
+
+/**
+ * 写侧：空会话物化、批量追加、统计旁路累加与重算、迁移后重写。
+ *
+ * 事务边界都在这里；`session-store.ts` 只负责装配与契约转发。
+ */
+export function createWritePath(deps: WritePathDeps) {
+  return {
+    async materializeEmpty(
+    meta: SessionHeader,
+    inheritedEventCount: SessionLogOffset,
+  ): Promise<void> {
+    await deps.ready;
+    await deps.backend().transaction(async (tx) => {
+      await tx.upsertSession({ meta, inheritedEventCount }, randomUUID());
+      await tx.bumpRevision(meta.id);
+    });
+    deps.tracker.materialized(meta.id);
+    deps.writeGuard.confirmHead(meta.id, -1);
+  },
+
+    async appendBatch(
+    meta: SessionHeader,
+    inheritedEventCount: SessionLogOffset,
+    events: readonly SessionEvent[],
+    tornTruncateTo?: number,
+  ): Promise<boolean> {
+    await deps.ready;
+    if (events.length === 0) return false;
+
+    // 本仓库自造的事件类型落库前补上 `ignorable` 信封：不补的话上游那道校验连写入都拒。
+    sealOwnEvents(events);
+    validateStoredEvents(meta, [...events]);
+
+    const reuse = deps.reuseEventIds.get(meta.id);
+    let confirmedHead = -1;
+    // 本批用量行由 `appendEventTail` 折好；事务成功后旁路据此累加 token 汇总表。
+    let usageRows: EventUsageRow[] = [];
+    await deps.backend().transaction(async (tx) => {
+      if (tornTruncateTo !== undefined) {
+        await tx.deleteBridgeTail(meta.id, tornTruncateTo);
+        const prev = await tx.getPrevBridge(meta.id, tornTruncateTo - 1);
+        if (prev === undefined) {
+          await tx.updateHead(meta.id, "", -1);
+        } else {
+          await tx.updateHead(meta.id, prev.fEventId, prev.fSequence);
+        }
+      }
+      await tx.upsertSession({ meta, inheritedEventCount }, randomUUID());
+      const head = await tx.getHead(meta.id);
+
+      deps.writeGuard.assertNoConcurrentWriter(meta.id, head.fHeadSequence);
+      const appended = await appendEventTail(
+        tx,
+        meta,
+        events,
+        { parentId: head.fHeadEventId, nextSeq: head.fHeadSequence + 1 },
+        reuse,
+      );
+      usageRows = appended.usageRows;
+      await tx.updateHeadAndRevision(
+        meta.id,
+        appended.headEventId,
+        appended.headSequence,
+        maxEventTime(events),
+      );
+      confirmedHead = appended.headSequence;
+    });
+    // 事务**成功之后**才丢掉复用映射：失败（并发写者校验、唯一键冲突等）时这份映射还没被消费，
+    // 重试同一个 append 还要靠它复用父会话的事件行——提前删掉会让前缀事件行被重新插入一遍。
+    if (reuse !== undefined) deps.reuseEventIds.delete(meta.id);
+
+    deps.writeGuard.confirmHead(meta.id, confirmedHead);
+    deps.tracker.materialized(meta.id);
+    await this.recordSessionStats(meta.id, events, usageRows);
+    return true;
+  },
+
+
+    async recordSessionStats(
+    id: SessionId,
+    events: readonly SessionEvent[],
+    usageRows: readonly EventUsageRow[],
+  ): Promise<void> {
+    const usageBuckets = sessionUsageBuckets(usageRows);
+    if (usageBuckets.length > 0) {
+      try {
+        await deps.backend().incrementSessionUsage(id, usageBuckets);
+      } catch (error: unknown) {
+        deps.logger.warn(
+          `session-rdb: token usage for "${id}" not updated (${describeError(error)})`,
+        );
+      }
+    }
+    const countBuckets = sessionCountBuckets(events);
+    if (countBuckets.length > 0) {
+      try {
+        await deps.backend().incrementSessionCounts(id, countBuckets);
+      } catch (error: unknown) {
+        deps.logger.warn(
+          `session-rdb: activity counts for "${id}" not updated (${describeError(error)})`,
+        );
+      }
+    }
+  },
+
+  // 重算一个会话的两张汇总表（旧日志重写后；best-effort，同 `recordSessionStats`）——
+  // fork 与 rewind 都不动统计。
+    async rebuildSessionStats(id: SessionId): Promise<void> {
+    await deps.ready;
+    try {
+      await deps.backend().rebuildSessionStats(id);
+    } catch (error: unknown) {
+      deps.logger.warn(
+        `session-rdb: session stats for "${id}" not rebuilt (${describeError(error)})`,
+      );
+    }
+  },
+
+  // 重算这些用量行的引用标记（会话删除 / 日志重写之后：消失的引用要让孤儿行退出统计）。
+    async refreshEventUsageFlags(eventIds: readonly string[]): Promise<void> {
+    const unique = [...new Set(eventIds)];
+    if (unique.length === 0) return;
+    try {
+      await deps.backend().refreshEventUsageFlags(unique);
+    } catch (error: unknown) {
+      deps.logger.warn(
+        `session-rdb: usage reference flags not refreshed (${describeError(error)})`,
+      );
+    }
+  },
+
+  // 会话删除时清掉它的汇总行（引用标记由调用方在拿到被删事件后一并重算）。
+    async dropSessionStats(id: SessionId): Promise<void> {
+    try {
+      await deps.backend().deleteSessionStats(id);
+    } catch (error: unknown) {
+      deps.logger.warn(
+        `session-rdb: session stats for "${id}" not deleted (${describeError(error)})`,
+      );
+    }
+  },
+
+    async rewriteMigratedLog(
+    id: SessionId,
+    log: { meta: SessionHeader; inheritedEventCount: number; events: SessionEvent[] },
+  ): Promise<void> {
+    let removed: readonly string[] = [];
+    await deps.backend().transaction(async (tx) => {
+      // 重写会删光该会话的桥接行再重建，先做并发写者校验（与 `appendBatch` 同一个理由）：否则另一实例在
+      // open 前 / 期间提交的事件会被静默丢掉；调用方刚读过这份日志，guard 没有该会话时记下当前磁盘 head。
+      const head = await tx.getHead(id);
+      if (!deps.writeGuard.has(id)) deps.writeGuard.confirmHead(id, head.fHeadSequence);
+      deps.writeGuard.assertNoConcurrentWriter(id, head.fHeadSequence);
+      removed = await tx.deleteBridgeTail(id, 0);
+      await tx.upsertSession(
+        { meta: log.meta, inheritedEventCount: SessionLogOffset(log.inheritedEventCount) },
+        randomUUID(),
+      );
+      const appended = await appendEventTail(tx, log.meta, log.events, {
+        parentId: "",
+        nextSeq: 0,
+      });
+      await tx.updateHead(id, appended.headEventId, appended.headSequence);
+      await tx.bumpRevision(id, maxEventTime(log.events));
+    });
+    // 重写换了事件行：被删掉的那批成了孤儿（引用标记要落回 0），本会话汇总按新事件重算。
+    await this.rebuildSessionStats(id);
+    await this.refreshEventUsageFlags(removed);
+  },
+
+  };
+}
+
+async function appendEventTail(
+  tx: BackendTx,
+  meta: SessionHeader,
+  events: readonly SessionEvent[],
+  anchor: { parentId: string; nextSeq: number },
+  reuse?: ReadonlyMap<number, string>,
+): Promise<{ headEventId: string; headSequence: number; usageRows: EventUsageRow[] }> {
+  let parentId = anchor.parentId;
+  let nextSeq = anchor.nextSeq;
+
+  const eventRows: EventInsert[] = [];
+  const usageRows: EventUsageRow[] = [];
+  const bridgeRows: Array<{
+    fSessionId: SessionId;
+    fEventId: string;
+    fSequence: number;
+    fSurfaceOp: string | null;
+  }> = [];
+  for (const event of events) {
+    const reusedId = reuse?.get(event.seq);
+    const eventId = reusedId ?? randomUUID();
+    if (reusedId === undefined) {
+      const { kind, role, name, actionId } = eventDimensions(event);
+
+      const raw = event as SessionEvent & {
+        ignorable?: unknown;
+        surfaceOp?: unknown;
+        sourceEventSeqs?: unknown;
+      };
+      const { data, surfaceOp: _surfaceOp, sourceEventSeqs: _sourceEventSeqs, ...envelope } = raw;
+      const row: EventInsert = {
+        fEventId: eventId,
+        fParentId: parentId,
+        fType: event.type,
+        fKind: kind,
+        fRole: role,
+        fName: name,
+        fActionId: actionId,
+        fEncoding: EVENT_ENCODING,
+        fData: JSON.stringify({ ...envelope, data }),
+        fCreatedAt: event.time,
+      };
+      eventRows.push(row);
+      // 用量行在这里一次折好（读侧维度一起物化），后端只负责插入，事务后旁路再据此累加汇总表。
+      const usageRow = usageRowOf(row, meta.origin === "subagent");
+      if (usageRow !== undefined) usageRows.push(usageRow);
+    }
+    const surfaceOp =
+      (event as SessionEvent<SurfaceEventType>).surfaceOp === undefined
+        ? null
+        : JSON.stringify((event as SessionEvent<SurfaceEventType>).surfaceOp);
+    bridgeRows.push({
+      fSessionId: meta.id,
+      fEventId: eventId,
+      fSequence: nextSeq,
+      fSurfaceOp: surfaceOp,
+    });
+    parentId = eventId;
+    nextSeq++;
+  }
+  if (eventRows.length > 0) await tx.insertEvents(eventRows, usageRows);
+  await tx.insertBridges(bridgeRows);
+
+  if (events.some((event) => (event.type as string) === "session/title")) {
+    await tx.refreshTitle(meta.id);
+  }
+  return { headEventId: parentId, headSequence: nextSeq - 1, usageRows };
+}

package/dist/branch-DbFW3rJX.mjs

@@ -1,391 +0,0 @@
-import { d as repairRequestHeaders, h as scanRows, i as normalizeToCurrentShape, m as rowToMeta } from "./log-DYxdjJ-l.mjs";
-import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
-import { createSessionFormatCatalogWithChildren } from "@deepseek-ai/dsh-session-format-catalog";
-import { randomUUID } from "node:crypto";
-import { SessionBranch, SessionBranchError, balanceRewindPrefix, rewindKeepLength } from "@morlay/session-branch";
-//#region src/legacy.ts
-function physicalHeader(row) {
-	const common = {
-		type: "session",
-		version: row.fVersion,
-		id: row.fSessionId,
-		createdAt: row.fCreatedAt,
-		...row.fCwd !== null ? { cwd: row.fCwd } : {},
-		...row.fParentSession !== null ? { parentSession: row.fParentSession } : {},
-		...row.fOrigin !== null ? { origin: row.fOrigin } : {},
-		delegationDepth: row.fDelegationDepth ?? 0,
-		...row.fAgentPreset !== null ? { agentPreset: row.fAgentPreset } : {}
-	};
-	return row.fVersion < 2 ? {
-		...common,
-		...row.fSeedLength !== null ? { seedLength: row.fSeedLength } : {}
-	} : {
-		...common,
-		isSeeded: row.fSeedLength !== null
-	};
-}
-function physicalEvent(row) {
-	const stored = JSON.parse(row.fData);
-	const full = typeof stored === "object" && stored !== null && !Array.isArray(stored) && typeof stored["type"] === "string" && "data" in stored;
-	return {
-		type: row.fType,
-		seq: row.fSequence,
-		time: row.fCreatedAt,
-		data: full ? stored["data"] : stored,
-		...row.fSurfaceOp !== null ? { surfaceOp: JSON.parse(row.fSurfaceOp) } : {}
-	};
-}
-const restoreCatalog = createSessionFormatCatalogWithChildren([]);
-function convertLegacyRows(row, eventRows) {
-	const restore = restoreCatalog.createRestore(physicalHeader(row), {
-		recovery: "strict",
-		validation: "transformed"
-	});
-	for (const eventRow of eventRows) restore.decodeRow(physicalEvent(eventRow));
-	const artifact = restore.finish();
-	return {
-		meta: artifact.header,
-		inheritedEventCount: artifact.inheritedEventCount,
-		events: artifact.events
-	};
-}
-function isLegacyVersion(version) {
-	return version < SESSION_FORMAT_VERSION;
-}
-function adoptLegacyRows(row, eventRows) {
-	const { preserved, tornFrom } = scanRows(eventRows, 0);
-	repairRequestHeaders(preserved);
-	normalizeToCurrentShape(preserved);
-	return {
-		meta: {
-			...rowToMeta(row),
-			version: SESSION_FORMAT_VERSION
-		},
-		inheritedEventCount: Math.min(row.fSeedLength ?? 0, preserved.length),
-		events: preserved,
-		...tornFrom !== void 0 ? { tornFrom } : {}
-	};
-}
-//#endregion
-//#region src/branch.ts
-function assertRewindBoundary(id, toBoundary, boundaryType, head) {
-	if (toBoundary === -1) return;
-	if (toBoundary > head) throw new SessionBranchError(`rewind boundary ${toBoundary} is beyond the stored head ${head}`, "INVALID_BOUNDARY");
-	if (boundaryType === void 0) throw new SessionBranchError(`rewind boundary ${toBoundary} does not exist in session "${id}"`, "INVALID_BOUNDARY");
-	if (boundaryType !== "turn/end" && boundaryType !== "user/message") throw new SessionBranchError(`rewind boundary ${toBoundary} is not a turn/end or user/message (${boundaryType})`, "INVALID_BOUNDARY");
-}
-function locateTurnEnd(events, atSeq, mode = "after") {
-	const ends = events.filter((event) => event.type === "turn/end").map((event) => event.seq);
-	if (atSeq === void 0) {
-		const last = ends.at(-1);
-		if (last === void 0) throw new SessionBranchError("session has no closed turn", "OPEN_TURN");
-		return last;
-	}
-	if (mode === "before") {
-		let boundary = -1;
-		for (const seq of ends) if (seq < atSeq) boundary = seq;
-		else break;
-		return boundary;
-	}
-	const firstAfter = ends.find((seq) => seq >= atSeq);
-	if (firstAfter !== void 0) return firstAfter;
-	const lastStart = [...events].reverse().find((event) => event.type === "turn/start");
-	if (lastStart !== void 0 && lastStart.seq <= atSeq) throw new SessionBranchError(`anchor ${atSeq} lies inside an open turn`, "OPEN_TURN");
-	const last = ends.at(-1);
-	if (last === void 0) throw new SessionBranchError("session has no closed turn", "OPEN_TURN");
-	return last;
-}
-function renumber(events, offset) {
-	return events.map((event, index) => ({
-		...event,
-		seq: offset + index
-	}));
-}
-function mintSessionId() {
-	return `session-${randomUUID()}`;
-}
-function resetSurfaceManager(surfaceManager) {
-	const state = surfaceManager._state;
-	state.nodes = [];
-	state.replaceGeneration = 0;
-	state.contentGeneration = 0;
-	state.projectedMessages = /* @__PURE__ */ new Map();
-	surfaceManager._lastProcessedSeq = surfaceManager.baseSeq - 1;
-	surfaceManager._pendingPlan = void 0;
-}
-function truncateLiveSession(session, newLength) {
-	const s = session;
-	s.log.length = newLength;
-	s.eventsSnapshot = void 0;
-	s.headerFold = void 0;
-	s.headerFoldSeq = 0;
-	s.contextFold = void 0;
-	s.contextFoldSeq = 0;
-	s.derived = [];
-	s.derivedNodes = 0;
-	s.derivedGeneration = 0;
-	resetSurfaceManager(s.surfaceManager);
-}
-function replaceLiveSessionLog(session, events) {
-	const s = session;
-	s.log.length = 0;
-	s.log.push(...events);
-	s.eventsSnapshot = void 0;
-	s.headerFold = void 0;
-	s.headerFoldSeq = 0;
-	s.contextFold = void 0;
-	s.contextFoldSeq = 0;
-	s.derived = [];
-	s.derivedNodes = 0;
-	s.derivedGeneration = 0;
-	resetSurfaceManager(s.surfaceManager);
-}
-var SessionBranchRdbProvider = class {
-	persistence;
-	live;
-	name = "session-rdb";
-	constructor(persistence, live = {
-		getSession: () => void 0,
-		getAgent: () => void 0,
-		flush: async () => true
-	}) {
-		this.persistence = persistence;
-		this.live = live;
-	}
-	async readBranchPrefix(id, atSeq, mode = "after", signal) {
-		const { events } = await this.readRawEvents(id, signal);
-		const boundary = locateTurnEnd(events, atSeq, mode);
-		return {
-			seq: boundary,
-			events: events.slice(0, boundary + 1)
-		};
-	}
-	async readRawEvents(id, signal) {
-		const stored = await this.persistence.readLog(id, {}, signal);
-		if (stored === void 0) throw new SessionBranchError(`session "${id}" not found`, "SESSION_NOT_FOUND");
-		return {
-			meta: stored.meta,
-			events: stored.events
-		};
-	}
-	async forkFrom(sourceId, options = {}, signal) {
-		signal?.throwIfAborted();
-		const { atSeq, anchorMode = "after", seedSuffix = [], childSessionId, meta = {} } = options;
-		const source = await this.persistence.readLog(sourceId, {}, signal);
-		if (source === void 0) throw new SessionBranchError(`session "${sourceId}" not found`, "SESSION_NOT_FOUND");
-		const boundary = locateTurnEnd(source.events, atSeq, anchorMode);
-		const prefix = balanceRewindPrefix(source.events.slice(0, boundary + 1));
-		if (prefix.length <= boundary) this.live.warn?.(`session-rdb: fork "${sourceId}" dropped ${boundary + 1 - prefix.length} trailing event(s) from seq ${prefix.length} to keep the seed's step pairs balanced`);
-		const childId = childSessionId ?? mintSessionId();
-		const childMeta = {
-			version: SESSION_FORMAT_VERSION,
-			id: childId,
-			createdAt: meta.createdAt ?? Date.now(),
-			...meta.cwd !== void 0 ? { cwd: meta.cwd } : source.meta.cwd !== void 0 ? { cwd: source.meta.cwd } : {},
-			parentSession: sourceId,
-			isSeeded: true,
-			...meta.agentPreset !== void 0 ? { agentPreset: meta.agentPreset } : source.meta.agentPreset !== void 0 ? { agentPreset: source.meta.agentPreset } : {},
-			...meta.origin !== void 0 ? { origin: meta.origin } : {},
-			...meta.delegationDepth !== void 0 ? { delegationDepth: meta.delegationDepth } : {}
-		};
-		const seed = [...renumber(prefix, 0), ...renumber(seedSuffix, prefix.length)];
-		const internals = this.persistence.internals();
-		const reusable = !source.migrated && source.events.length === source.storedCount;
-		const reuse = /* @__PURE__ */ new Map();
-		if (reusable) {
-			const sourceRows = await internals.backend.getEventRows(sourceId);
-			const sourceEventIds = new Map(sourceRows.map((row) => [row.fSequence, row.fEventId]));
-			for (const event of prefix) {
-				const eventId = sourceEventIds.get(event.seq);
-				if (eventId !== void 0) reuse.set(event.seq, eventId);
-			}
-		} else if (prefix.length > 0) this.live.warn?.(`session-rdb: fork "${sourceId}" copies event rows instead of reusing them — its read view comes from a migration, so stored seqs need not line up`);
-		internals.registerReuseEventIds(childId, reuse);
-		try {
-			const handle = await this.persistence.create(childMeta, { inheritedEventCount: SessionLogOffset(prefix.length) });
-			try {
-				if (seed.length > 0) await handle.append(seed);
-			} finally {
-				await handle.close();
-			}
-		} catch (error) {
-			internals.dropReuseEventIds(childId);
-			throw error;
-		}
-		return childId;
-	}
-	async rewind(id, toBoundary, signal) {
-		signal?.throwIfAborted();
-		if (!Number.isSafeInteger(toBoundary) || toBoundary < -1) throw new SessionBranchError(`rewind boundary must be a non-negative safe integer, got ${toBoundary}`, "INVALID_BOUNDARY");
-		const live = this.live.getSession(id);
-		if (live !== void 0) await this.live.flush(live);
-		const internals = this.persistence.internals();
-		const row = await internals.backend.getSession(id);
-		if (row === void 0) throw new SessionBranchError(`session "${id}" not found`, "SESSION_NOT_FOUND");
-		const meta = rowToMeta(row);
-		let rawKeepLength;
-		let kept;
-		if (isLegacyVersion(row.fVersion)) {
-			const log = await this.persistence.readLog(id, {}, signal);
-			if (log === void 0) throw new SessionBranchError(`session "${id}" not found`, "SESSION_NOT_FOUND");
-			const boundaryType = log.events[toBoundary]?.type;
-			assertRewindBoundary(id, toBoundary, boundaryType, log.events.length - 1);
-			rawKeepLength = toBoundary === -1 ? 0 : boundaryType === "turn/end" ? toBoundary + 1 : toBoundary;
-			kept = balanceRewindPrefix(log.events.slice(0, rawKeepLength));
-		} else {
-			const boundaryType = toBoundary === -1 ? void 0 : await internals.backend.getEventTypeAt(id, toBoundary);
-			assertRewindBoundary(id, toBoundary, boundaryType, row.fHeadSequence);
-			rawKeepLength = toBoundary === -1 ? 0 : boundaryType === "turn/end" ? toBoundary + 1 : toBoundary;
-		}
-		const keepLength = kept === void 0 ? await this.rewindKeepLength(id, rawKeepLength, internals.backend) : kept.length;
-		if (keepLength < rawKeepLength) this.live.warn?.(`session-rdb: rewind "${id}" dropped ${rawKeepLength - keepLength} trailing event(s) from seq ${keepLength} to keep the retained prefix's step pairs balanced`);
-		const denseBoundary = keepLength - 1;
-		const newSeedLength = await internals.backend.transaction(async (tx) => {
-			signal?.throwIfAborted();
-			const head = await tx.getHead(id);
-			if (denseBoundary > head.fHeadSequence) throw new SessionBranchError(`rewind boundary ${toBoundary} is beyond the stored head ${head.fHeadSequence}`, "INVALID_BOUNDARY");
-			if (denseBoundary < head.fHeadSequence) {
-				await tx.deleteBridgeTail(id, denseBoundary + 1);
-				const prev = denseBoundary === -1 ? void 0 : await tx.getPrevBridge(id, denseBoundary);
-				if (prev === void 0) await tx.updateHead(id, "", -1);
-				else await tx.updateHead(id, prev.fEventId, prev.fSequence);
-			}
-			const storedSeedLength = await tx.getSeedLength(id);
-			let shrunk = storedSeedLength;
-			if (storedSeedLength !== null && storedSeedLength > denseBoundary + 1) {
-				await tx.updateSeedLength(id, denseBoundary + 1);
-				shrunk = denseBoundary + 1;
-			}
-			await tx.refreshTitle(id);
-			await tx.bumpRevision(id);
-			return shrunk;
-		});
-		internals.writeGuard.confirmHead(id, denseBoundary);
-		if (live !== void 0) {
-			truncateLiveSession(live, keepLength);
-			this.live.resetProjections?.(live);
-			this.live.resetTokenMeter?.(live);
-			const agent = this.live.getAgent(id);
-			if (agent !== void 0) {
-				agent.requestHeaderLogged = false;
-				const lastTurn = live.snapshotEvents().findLast((e) => e.type === "turn/start")?.data.turn ?? 0;
-				const phase = agent.phase;
-				if (phase !== void 0) phase.lastTurn = lastTurn;
-			}
-			const handle = this.persistence.tracker.writerOf(id);
-			if (handle !== void 0) handle.resetAfterRewind(keepLength, newSeedLength === null ? void 0 : newSeedLength);
-			agent?.inbox?.clear();
-			await this.live.flush(live);
-			await this.refreshProjectionCache(live);
-		} else await this.refreshProjectionCache({
-			id,
-			header: meta,
-			inheritedEventCount: SessionLogOffset(newSeedLength ?? row.fSeedLength ?? 0),
-			headSeq: keepLength - 1,
-			snapshotEvents: () => []
-		});
-		return {
-			header: rowToMeta(row),
-			revision: await internals.readStoredRevision(id)
-		};
-	}
-	async rewindKeepLength(id, rawKeepLength, backend) {
-		if (rawKeepLength === 0) return 0;
-		let limit = 64;
-		for (;;) {
-			const types = [...await backend.getEventTypesBefore(id, rawKeepLength, limit)].reverse().map((row) => row.fType);
-			const windowStart = rawKeepLength - types.length;
-			if (types.includes("turn/end") || windowStart === 0 || types.length >= rawKeepLength) return rewindKeepLength(types, rawKeepLength);
-			limit *= 4;
-		}
-	}
-	async refreshProjectionCache(session) {
-		if (this.live.refreshProjectionCache === void 0) return;
-		try {
-			await this.live.refreshProjectionCache(session);
-		} catch {}
-	}
-};
-var SessionBranchRdb = class extends SessionBranch {
-	static inject = ["sessionPersistence", "sessions"];
-	warned = /* @__PURE__ */ new Set();
-	constructor(ctx) {
-		super(ctx);
-	}
-	resetLiveDerivedState(session) {
-		this.resetProjectionCells(session);
-		this.resetTokenMeterFold(session);
-	}
-	warnOnce(key, message) {
-		if (this.warned.has(key)) return;
-		this.warned.add(key);
-		this.ctx.logger.warn(message);
-	}
-	resetProjectionCells(session) {
-		const registrations = this.ctx.get("sessionProjections")?.registrations;
-		if (!(registrations instanceof Map)) {
-			this.warnOnce("sessionProjections.registrations", `session-rdb: ctx.sessionProjections.registrations is not a Map (upstream field shape changed); rewind leaves the projection cell caches of "${session.id}" stale, so replayed events can be skipped`);
-			return;
-		}
-		for (const registration of registrations.values()) {
-			const cells = registration?.cells;
-			if (!(cells instanceof WeakMap)) {
-				this.warnOnce("sessionProjections.cells", `session-rdb: ctx.sessionProjections registration cells are not a WeakMap (upstream field shape changed); rewind leaves the projection cell caches of "${session.id}" stale, so replayed events can be skipped`);
-				continue;
-			}
-			cells.delete(session);
-		}
-	}
-	resetTokenMeterFold(session) {
-		const meter = this.ctx.get("tokenMeter");
-		if (meter === void 0) {
-			this.warnOnce("tokenMeter", `session-rdb: ctx.tokenMeter is not mounted; after rewind the token-meter fold watermark of "${session.id}" may stay stale, so compaction can report "step/end ... has no matching step/start event"`);
-			return;
-		}
-		const states = meter.states;
-		if (!(states instanceof WeakMap)) {
-			this.warnOnce("tokenMeter.states", `session-rdb: ctx.tokenMeter.states is not a WeakMap (upstream field shape changed); after rewind the token-meter fold watermark of "${session.id}" may stay stale, so compaction can report "step/end ... has no matching step/start event"`);
-			return;
-		}
-		states.delete(session);
-	}
-	provider = new SessionBranchRdbProvider(this.ctx.sessionPersistence, {
-		getSession: (id) => this.ctx.sessions.get(id),
-		getAgent: (id) => {
-			return this.ctx.get("agents")?.get(id);
-		},
-		flush: (session) => this.ctx.sessions.flush(session),
-		warn: (message) => {
-			this.ctx.logger.warn(message);
-		},
-		resetProjections: (session) => this.resetProjectionCells(session),
-		resetTokenMeter: (session) => this.resetTokenMeterFold(session),
-		refreshProjectionCache: async (session) => {
-			const cache = this.ctx.get("sessionProjectionCache");
-			if (cache === void 0) return;
-			try {
-				if (session.headSeq !== void 0 && cache.truncateTo !== void 0) {
-					await cache.truncateTo(session.header, session.inheritedEventCount, session.headSeq);
-					return;
-				}
-				await cache.write(session);
-			} catch (error) {
-				this.ctx.logger.warn(`session-rdb: projection cache refresh after rewind for "${session.id}" failed (cache stays stale): ${String(error)}`);
-			}
-		}
-	});
-	readBranchPrefix(id, atSeq, mode, signal) {
-		return this.provider.readBranchPrefix(id, atSeq, mode, signal);
-	}
-	readRawEvents(id, signal) {
-		return this.provider.readRawEvents(id, signal);
-	}
-	forkFrom(sourceId, options, signal) {
-		return this.provider.forkFrom(sourceId, options, signal);
-	}
-	rewind(id, toBoundary, signal) {
-		return this.provider.rewind(id, toBoundary, signal);
-	}
-};
-//#endregion
-export { truncateLiveSession as a, isLegacyVersion as c, replaceLiveSessionLog as i, restoreCatalog as l, SessionBranchRdbProvider as n, adoptLegacyRows as o, locateTurnEnd as r, convertLegacyRows as s, SessionBranchRdb as t };