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

package/dist/branch-CG1PUlO6.mjs

@@ -0,0 +1,833 @@
+import { a as rowToMeta, i as rowToEvent, t as scanRows } from "./export-CfJQjQfr.mjs";
+import { SESSION_FORMAT_VERSION, SessionLogOffset, SessionSeq } 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";
+// src/log/repair.ts
+const SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"system/message",
+	"developer/message",
+	"user/message",
+	"assistant/message",
+	"tool/result"
+]);
+const METERING_EVENT_TYPES = /* @__PURE__ */ new Set(["compaction/summary", "compaction/prune"]);
+function surfaceSeqIndex(events) {
+	const seqs = [];
+	for (const event of events) if (SURFACE_EVENT_TYPES.has(event.type)) seqs.push(event.seq);
+	return seqs;
+}
+function surfaceSeqsInRange(seqs, startSeq, endSeq) {
+	let low = 0;
+	let high = seqs.length;
+	while (low < high) {
+		const mid = low + high >> 1;
+		if (seqs[mid] < startSeq) low = mid + 1;
+		else high = mid;
+	}
+	const from = low;
+	high = seqs.length;
+	while (low < high) {
+		const mid = low + high >> 1;
+		if (seqs[mid] <= endSeq) low = mid + 1;
+		else high = mid;
+	}
+	return seqs.slice(from, low);
+}
+function recomputeReplaceProvenance(events) {
+	const seqs = surfaceSeqIndex(events);
+	for (let i = 0; i < events.length; i++) {
+		const raw = events[i];
+		const op = raw.surfaceOp;
+		if (typeof op !== "object" || op === null || op.op !== "replace") continue;
+		const { startSeq, endSeq } = op;
+		const metering = i > 0 ? events[i - 1] : void 0;
+		const meteringData = metering !== void 0 && METERING_EVENT_TYPES.has(metering.type) ? metering.data : void 0;
+		if (meteringData?.shadowedSeqs !== void 0) {
+			raw.sourceEventSeqs = meteringData.shadowedSeqs;
+			continue;
+		}
+		raw.sourceEventSeqs = surfaceSeqsInRange(seqs, startSeq, endSeq);
+	}
+}
+function isEventSeqLike(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0);
+}
+function isDeepEqualJson(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((item, i) => isDeepEqualJson(item, b[i]));
+	}
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	const aKeys = Object.keys(a);
+	const bRecord = b;
+	if (aKeys.length !== Object.keys(bRecord).length) return false;
+	return aKeys.every((key) => Object.hasOwn(bRecord, key) && isDeepEqualJson(a[key], bRecord[key]));
+}
+function toolResultRewriteContentOnly(original, replacement) {
+	const originalData = original.data;
+	const replacementData = replacement.data;
+	const originalMessage = originalData["message"];
+	const replacementMessage = replacementData["message"];
+	if (!Array.isArray(originalMessage?.content) || !Array.isArray(replacementMessage?.content)) return false;
+	const rest = (data, message) => ({
+		...data,
+		message: {
+			...message,
+			content: null
+		}
+	});
+	return isDeepEqualJson(rest(originalData, originalMessage), rest(replacementData, replacementMessage));
+}
+function findSurfaceRepairs(events) {
+	const nodes = [];
+	const degradeToAppend = /* @__PURE__ */ new Set();
+	const addAppendMarker = /* @__PURE__ */ new Set();
+	const clearSurfaceOp = /* @__PURE__ */ new Set();
+	const clampEnd = /* @__PURE__ */ new Map();
+	for (let index = 0; index < events.length; index++) {
+		const event = events[index];
+		const op = event.surfaceOp;
+		if (op === void 0) {
+			if (SURFACE_EVENT_TYPES.has(event.type)) {
+				addAppendMarker.add(event.seq);
+				nodes.push(event.seq);
+			}
+			continue;
+		}
+		if (op === "append") {
+			if (SURFACE_EVENT_TYPES.has(event.type)) nodes.push(event.seq);
+			else clearSurfaceOp.add(event.seq);
+			continue;
+		}
+		if (!SURFACE_EVENT_TYPES.has(event.type)) {
+			clearSurfaceOp.add(event.seq);
+			continue;
+		}
+		const replace = typeof op === "object" && op !== null && !Array.isArray(op) ? op : void 0;
+		const start = replace?.["startSeq"];
+		const end = replace?.["endSeq"];
+		const shapeOk = replace !== void 0 && replace["op"] === "replace" && isEventSeqLike(start) && isEventSeqLike(end);
+		const startIdx = shapeOk ? nodes.indexOf(start) : -1;
+		let endIdx = shapeOk ? nodes.indexOf(end) : -1;
+		let clamped;
+		if (shapeOk && startIdx !== -1 && endIdx === -1) {
+			clamped = clampReplaceEnd(events, index, nodes, startIdx);
+			if (clamped !== void 0) endIdx = nodes.indexOf(clamped);
+		}
+		const rangeOk = shapeOk && startIdx !== -1 && endIdx !== -1 && startIdx <= endIdx;
+		const provenanceOk = event.type !== "assistant/message";
+		let rewriteOk = true;
+		if (rangeOk && event.type === "tool/result") {
+			const shadowed = nodes.slice(startIdx, endIdx + 1);
+			if (shadowed.length !== 1) rewriteOk = false;
+			else {
+				const original = events[shadowed[0]];
+				rewriteOk = original?.type === "tool/result" && toolResultRewriteContentOnly(original, event);
+			}
+		}
+		if (!rangeOk || !rewriteOk || !provenanceOk) {
+			degradeToAppend.add(event.seq);
+			nodes.push(event.seq);
+			continue;
+		}
+		if (clamped !== void 0) clampEnd.set(event.seq, clamped);
+		nodes.splice(startIdx, endIdx - startIdx + 1, event.seq);
+	}
+	return {
+		degradeToAppend,
+		addAppendMarker,
+		clearSurfaceOp,
+		clampEnd
+	};
+}
+function clampReplaceEnd(events, index, nodes, startIdx) {
+	const metering = index > 0 ? events[index - 1] : void 0;
+	if (metering === void 0 || !METERING_EVENT_TYPES.has(metering.type)) return void 0;
+	const shadowedSeqs = metering.data.shadowedSeqs;
+	if (!Array.isArray(shadowedSeqs) || shadowedSeqs.length === 0) return void 0;
+	return nodes[Math.min(startIdx + shadowedSeqs.length - 1, nodes.length - 1)];
+}
+function repairSurfaceOps(events) {
+	const repairs = findSurfaceRepairs(events);
+	if (repairs.degradeToAppend.size === 0 && repairs.addAppendMarker.size === 0 && repairs.clearSurfaceOp.size === 0 && repairs.clampEnd.size === 0) return;
+	for (const event of events) {
+		const raw = event;
+		const clamped = repairs.clampEnd.get(event.seq);
+		if (repairs.degradeToAppend.has(event.seq)) raw.surfaceOp = "append";
+		else if (clamped !== void 0) {
+			const op = raw.surfaceOp;
+			raw.surfaceOp = {
+				op: "replace",
+				startSeq: SessionSeq(op.startSeq),
+				endSeq: SessionSeq(clamped)
+			};
+		} else if (repairs.addAppendMarker.has(event.seq)) raw.surfaceOp = "append";
+		else if (repairs.clearSurfaceOp.has(event.seq)) delete raw.surfaceOp;
+	}
+}
+function repairAssistantSettlement(events) {
+	for (const event of events) {
+		if (event.type !== "assistant/message" && event.type !== "assistant/attempt") continue;
+		const data = event.data;
+		if (!Array.isArray(data["stream"])) data["stream"] = [];
+	}
+}
+function repairRequestHeaders(events) {
+	for (const event of events) {
+		if (event.type !== "request/header") continue;
+		const header = event.data["header"];
+		if (typeof header !== "object" || header === null || Array.isArray(header)) continue;
+		const record = header;
+		delete record["system"];
+		if (Array.isArray(record["tools"]) && record["tools"].length === 0) delete record["tools"];
+		const defaults = record["adapterDefaults"];
+		if (typeof defaults === "object" && defaults !== null && !Array.isArray(defaults) && Object.keys(defaults).length === 0) delete record["adapterDefaults"];
+	}
+}
+function syncMeteringRanges(events) {
+	const seqs = surfaceSeqIndex(events);
+	for (let i = 1; i < events.length; i++) {
+		const metering = events[i - 1];
+		if (!METERING_EVENT_TYPES.has(metering.type)) continue;
+		const op = events[i].surfaceOp;
+		if (typeof op !== "object" || op === null || op.op !== "replace") continue;
+		const { startSeq, endSeq } = op;
+		const data = metering.data;
+		if (data.shadowedRange?.start === startSeq && data.shadowedRange.end === endSeq) continue;
+		data.shadowedRange = {
+			start: startSeq,
+			end: endSeq
+		};
+		data.shadowedSeqs = surfaceSeqsInRange(seqs, startSeq, endSeq);
+	}
+}
+const PTC_EVENT_RENAMES = {
+	"tool/code-dispatch-start": "tool/ptc-dispatch-start",
+	"tool/code-dispatch": "tool/ptc-dispatch"
+};
+function renamePtcMessageSource(message) {
+	if (typeof message !== "object" || message === null || Array.isArray(message)) return message;
+	const record = message;
+	const source = record["source"];
+	if (typeof source !== "object" || source === null || Array.isArray(source)) return message;
+	const sourceRecord = source;
+	if (sourceRecord["kind"] !== "plugin" || sourceRecord["plugin"] !== "tools-code-mode") return message;
+	return {
+		...record,
+		source: {
+			...sourceRecord,
+			plugin: "tools-ptc"
+		}
+	};
+}
+function renameLegacyPtcEvents(events) {
+	for (let index = 0; index < events.length; index++) {
+		const event = events[index];
+		const renamedType = PTC_EVENT_RENAMES[event.type];
+		if (renamedType !== void 0) {
+			events[index] = {
+				...event,
+				type: renamedType
+			};
+			continue;
+		}
+		if (event.type === "agent-preset/selected") {
+			const data = event.data;
+			if (data["agentPreset"] === "code") events[index] = {
+				...event,
+				data: {
+					...data,
+					agentPreset: "ptc"
+				}
+			};
+			continue;
+		}
+		if (event.type === "user/message") {
+			const renamed = renamePtcMessageSource(event.data);
+			if (renamed !== event.data) events[index] = {
+				...event,
+				data: renamed
+			};
+			continue;
+		}
+		if (event.type === "agent/inbox/spliced" || event.type === "session/title-llm-request") {
+			const data = event.data;
+			const key = event.type === "agent/inbox/spliced" ? "inserted" : "messages";
+			const list = data[key];
+			if (!Array.isArray(list)) continue;
+			const renamed = list.map(renamePtcMessageSource);
+			if (renamed.some((message, position) => message !== list[position])) events[index] = {
+				...event,
+				data: {
+					...data,
+					[key]: renamed
+				}
+			};
+		}
+	}
+}
+function normalizeToCurrentShape(events) {
+	for (const event of events) {
+		const type = event.type;
+		if (OWN_EVENT_TYPES.has(type)) {
+			event.ignorable = true;
+			continue;
+		}
+		if (type === "system/message") {
+			const message = event.data["message"];
+			liftSystemMessageSource(message);
+			continue;
+		}
+		if (type === "tool/result") {
+			const message = event.data["message"];
+			liftToolResultMessage(message);
+		}
+	}
+}
+function liftSystemMessageSource(message) {
+	if (typeof message !== "object" || message === null) return;
+	const record = message;
+	const source = record["source"];
+	if (typeof source !== "object" || source === null) return;
+	if (source["kind"] !== "plugin") return;
+	record["source"] = { kind: "system-prompt" };
+}
+function liftToolResultMessage(message) {
+	if (typeof message !== "object" || message === null) return;
+	const record = message;
+	if (record["role"] === "tool" && typeof record["toolCallId"] === "string") return;
+	const source = record["source"];
+	const block = Array.isArray(record["content"]) ? record["content"][0] : void 0;
+	if (typeof block !== "object" || block === null) return;
+	const lifted = block;
+	const callId = lifted["toolCallId"] ?? source?.["callId"];
+	if (typeof callId !== "string") return;
+	record["role"] = "tool";
+	record["toolCallId"] = callId;
+	record["content"] = Array.isArray(lifted["content"]) ? lifted["content"] : [];
+	if (typeof lifted["isError"] === "boolean") record["isError"] = lifted["isError"];
+	record["source"] = {
+		kind: "tool",
+		callId
+	};
+}
+function sealOwnEvents(events) {
+	for (const event of events) if (OWN_EVENT_TYPES.has(event.type)) event.ignorable = true;
+}
+const OWN_EVENT_TYPES = /* @__PURE__ */ new Set(["session-branch/version", "session-mode/selected"]);
+function needsShapeAdoption(events) {
+	for (const event of events) {
+		const type = event.type;
+		if (OWN_EVENT_TYPES.has(type)) return true;
+		if (type === "system/message") {
+			if ((event.data["message"]?.["source"])?.["kind"] === "plugin") return true;
+			continue;
+		}
+		if (type === "tool/result") {
+			const message = event.data["message"];
+			if (message !== void 0 && message["role"] !== "tool") return true;
+		}
+	}
+	return false;
+}
+function repairReadView(events) {
+	repairAssistantSettlement(events);
+	repairRequestHeaders(events);
+	renameLegacyPtcEvents(events);
+	repairSurfaceOps(events);
+	syncMeteringRanges(events);
+	recomputeReplaceProvenance(events);
+	repairOrphanInboxSplices(events);
+}
+function orphanInboxSpliceSeqs(events) {
+	const inbox = {
+		"next-turn": [],
+		"next-step": []
+	};
+	const orphan = /* @__PURE__ */ new Set();
+	for (const raw of events) {
+		const event = raw;
+		if (event.type !== "agent/inbox/spliced") continue;
+		const { target, start, removedCount, inserted } = event.data;
+		const list = typeof target === "string" ? inbox[target] : void 0;
+		if (list === void 0) {
+			orphan.add(event.seq);
+			continue;
+		}
+		const removed = removedCount ?? 0;
+		const parsedInserted = (inserted ?? []).map((m) => ({ id: typeof m.id === "string" ? m.id : "" }));
+		if (!Number.isSafeInteger(start) || start < 0 || start > list.length || !Number.isSafeInteger(removed) || removed < 0 || start + removed > list.length) {
+			orphan.add(event.seq);
+			continue;
+		}
+		const candidate = [
+			...list.slice(0, start),
+			...parsedInserted,
+			...list.slice(start + removed)
+		];
+		const other = (target === "next-turn" ? inbox["next-step"] : inbox["next-turn"]) ?? [];
+		const seen = /* @__PURE__ */ new Set();
+		let dup = false;
+		for (const m of [...candidate, ...other]) {
+			if (m.id === "") continue;
+			if (seen.has(m.id)) {
+				dup = true;
+				break;
+			}
+			seen.add(m.id);
+		}
+		if (dup) {
+			orphan.add(event.seq);
+			continue;
+		}
+		list.splice(start, removed, ...parsedInserted);
+	}
+	return orphan;
+}
+function repairOrphanInboxSplices(events) {
+	const orphan = orphanInboxSpliceSeqs(events);
+	if (orphan.size === 0) return;
+	for (const event of events) {
+		if (!orphan.has(event.seq)) continue;
+		const target = event.data.target;
+		event.data = {
+			...typeof target === "string" ? { target } : { target: "next-turn" },
+			start: 0,
+			removedCount: 0,
+			inserted: []
+		};
+	}
+}
+// 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 } : {}
+	};
+}
+// src/branch/semantics.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()}`;
+}
+// src/branch/index.ts
+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;
+}
+/**
+* 会话**当前内存 log** 的快照（复制一份）。用于"需要完整序列"的操作（首次落库的 seed、rewind / fork 的历史），
+* 不走已弃用的同步历史读 `snapshotEvents()`——那三个读口上游已声明「新调用禁止」，而这里要的是当前内存里
+* 那份完整日志，不是按需分页的历史。
+* @param session - 会话。
+* @returns 事件副本（调用方可以自由遍历）。
+*/
+function liveEventsOf(session) {
+	return [...session.log];
+}
+/** @returns 截断后日志里最后一个 `turn/start` 的 turn 号（没有则 0）。 */
+function truncateLiveSession(session, newLength) {
+	const s = session;
+	const lastTurn = s.log.slice(0, newLength).findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
+	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);
+	return lastTurn;
+}
+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 {
+	port;
+	live;
+	name = "session-rdb";
+	constructor(port, live = {
+		getSession: () => void 0,
+		getAgent: () => void 0,
+		flush: async () => true
+	}) {
+		this.port = port;
+		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.port.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.port.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)];
+		await this.port.ready;
+		const reusable = !source.migrated && source.events.length === source.storedCount;
+		const reuse = /* @__PURE__ */ new Map();
+		if (reusable) {
+			const sourceRows = await this.port.eventRows(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`);
+		this.port.registerReuseEventIds(childId, reuse);
+		try {
+			const handle = await this.port.create(childMeta, { inheritedEventCount: SessionLogOffset(prefix.length) });
+			try {
+				if (seed.length > 0) await handle.append(seed);
+			} finally {
+				await handle.close();
+			}
+		} catch (error) {
+			this.port.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);
+		await this.port.ready;
+		const row = await this.port.sessionRow(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.port.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 this.port.eventTypeAt(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) : 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 this.port.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");
+			let nextHead;
+			if (denseBoundary < head.fHeadSequence) {
+				await tx.deleteBridgeTail(id, denseBoundary + 1);
+				const prev = denseBoundary === -1 ? void 0 : await tx.getPrevBridge(id, denseBoundary);
+				nextHead = prev === void 0 ? {
+					fEventId: "",
+					fSequence: -1
+				} : {
+					fEventId: prev.fEventId,
+					fSequence: 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);
+			if (nextHead === void 0) await tx.bumpRevision(id);
+			else await tx.updateHeadAndRevision(id, nextHead.fEventId, nextHead.fSequence);
+			return shrunk;
+		});
+		this.port.confirmHead(id, denseBoundary);
+		if (live !== void 0) {
+			const liveLength = live.log.length;
+			let lastTurn;
+			if (liveLength < keepLength) {
+				const prefix = kept ?? (await this.port.eventRows(id)).map(rowToEvent).filter((event) => event.seq <= denseBoundary);
+				replaceLiveSessionLog(live, prefix);
+				lastTurn = prefix.findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
+			} else lastTurn = 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 phase = agent.phase;
+				if (phase !== void 0) phase.lastTurn = lastTurn;
+			}
+			this.port.resetWriterAfterRewind(id, keepLength, newSeedLength === null ? void 0 : newSeedLength);
+			agent?.inbox?.clear();
+			try {
+				await this.live.flush(live);
+			} catch (error) {
+				this.live.warn?.(`session-rdb: flush after rewind for "${id}" failed (the stored log is already truncated; live buffers may lag): ${describeError(error)}`);
+			}
+			await this.refreshProjectionCache({
+				id: live.id,
+				header: live.header,
+				inheritedEventCount: live.inheritedEventCount,
+				headSeq: keepLength - 1,
+				snapshotEvents: () => live.snapshotEvents()
+			});
+		} else await this.refreshProjectionCache({
+			id,
+			header: meta,
+			inheritedEventCount: SessionLogOffset(newSeedLength ?? row.fSeedLength ?? 0),
+			headSeq: keepLength - 1,
+			snapshotEvents: () => []
+		});
+		return {
+			header: rowToMeta(row),
+			revision: await this.port.readStoredRevision(id)
+		};
+	}
+	async rewindKeepLength(id, rawKeepLength) {
+		if (rawKeepLength === 0) return 0;
+		let limit = 64;
+		for (;;) {
+			const types = [...await this.port.eventTypesBefore(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.branchPort(), {
+		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;
+			if (session.snapshotEvents().length === 0 && session.headSeq !== void 0 && cache.truncateTo !== void 0) {
+				try {
+					await cache.truncateTo(session.header, session.inheritedEventCount, session.headSeq);
+				} catch (error) {
+					this.ctx.logger.warn(`session-rdb: projection cache truncate after rewind for "${session.id}" failed: ${describeError(error)}`);
+				}
+				return;
+			}
+			try {
+				await cache.write(session);
+			} catch (error) {
+				if (session.headSeq !== void 0 && cache.truncateTo !== void 0) try {
+					await cache.truncateTo(session.header, session.inheritedEventCount, session.headSeq);
+				} catch (fallbackError) {
+					this.ctx.logger.warn(`session-rdb: projection cache truncate fallback after rewind for "${session.id}" failed: ${describeError(fallbackError)}`);
+				}
+				this.ctx.logger.warn(`session-rdb: projection cache rebuild after rewind for "${session.id}" failed (fell back to truncating the cache at the new head): ${describeError(error)}\n${error instanceof Error ? error.stack ?? "" : ""}`);
+			}
+		}
+	});
+	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);
+	}
+};
+function describeError(error) {
+	return error instanceof Error ? error.message : "unknown error";
+}
+export { sealOwnEvents as C, repairSurfaceOps as S, renameLegacyPtcEvents as _, truncateLiveSession as a, repairReadView as b, convertLegacyRows as c, OWN_EVENT_TYPES as d, findSurfaceRepairs as f, recomputeReplaceProvenance as g, orphanInboxSpliceSeqs as h, replaceLiveSessionLog as i, isLegacyVersion as l, normalizeToCurrentShape as m, SessionBranchRdbProvider as n, locateTurnEnd as o, needsShapeAdoption as p, liveEventsOf as r, adoptLegacyRows as s, SessionBranchRdb as t, restoreCatalog as u, repairAssistantSettlement as v, syncMeteringRanges as w, repairRequestHeaders as x, repairOrphanInboxSplices as y };