@morlay/session-rdb 0.0.20 → 0.0.21-alpha.1

package/dist/{branch-Co6xlbi0.mjs → branch-5JzX9rUq.mjs}

@@ -1,8 +1,76 @@
-import { d as rowToMeta } from "./log-DO69NQnn.mjs";
+import { c as repairRequestHeaders, d as rowToMeta, f as scanRows } from "./log-CnYct2Dv.mjs";
 import { randomUUID } from "node:crypto";
 import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
-import { SessionBranch, SessionBranchError, balanceRewindPrefix, buildTimeline } from "@morlay/session-branch";
+import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
+import { SessionBranch, SessionBranchError, balanceRewindPrefix, buildTimeline, 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
+	};
+	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) } : {}
+	};
+}
+function convertLegacyRows(row, eventRows) {
+	const restore = sessionFormatCatalog.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);
+	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) {
@@ -33,6 +101,15 @@ function renumber(events, offset) {
 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;
@@ -44,12 +121,7 @@ function truncateLiveSession(session, newLength) {
 	s.derived = [];
 	s.derivedNodes = 0;
 	s.derivedGeneration = 0;
-	s.surfaceManager._state = {
-		nodes: [],
-		replaceGeneration: 0
-	};
-	s.surfaceManager._lastProcessedSeq = s.surfaceManager.baseSeq - 1;
-	s.surfaceManager._pendingPlan = void 0;
+	resetSurfaceManager(s.surfaceManager);
 }
 function replaceLiveSessionLog(session, events) {
 	const s = session;
@@ -63,12 +135,7 @@ function replaceLiveSessionLog(session, events) {
 	s.derived = [];
 	s.derivedNodes = 0;
 	s.derivedGeneration = 0;
-	s.surfaceManager._state = {
-		nodes: [],
-		replaceGeneration: 0
-	};
-	s.surfaceManager._lastProcessedSeq = s.surfaceManager.baseSeq - 1;
-	s.surfaceManager._pendingPlan = void 0;
+	resetSurfaceManager(s.surfaceManager);
 }
 var SessionBranchRdbProvider = class {
 	persistence;
@@ -104,7 +171,8 @@ var SessionBranchRdbProvider = class {
 		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 = source.events.slice(0, boundary + 1);
+		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,
@@ -140,18 +208,26 @@ var SessionBranchRdbProvider = class {
 		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 raw = live === void 0 ? await this.persistence.readLog(id, {}, signal) : void 0;
-		if (live === void 0 && raw === void 0) throw new SessionBranchError(`session "${id}" not found`, "SESSION_NOT_FOUND");
-		const inspection = live === void 0 ? void 0 : await this.persistence.internals().inspect(id, signal);
-		const events = live === void 0 ? raw.events : inspection.events;
-		const meta = live === void 0 ? raw.meta : inspection.meta;
-		const boundaryEvent = events[toBoundary];
-		if (toBoundary === -1) {} else if (boundaryEvent === void 0) throw new SessionBranchError(`rewind boundary ${toBoundary} does not exist in session "${id}"`, "INVALID_BOUNDARY");
-		else if (boundaryEvent.type !== "turn/end" && boundaryEvent.type !== "user/message") throw new SessionBranchError(`rewind boundary ${toBoundary} is not a turn/end or user/message (${boundaryEvent.type})`, "INVALID_BOUNDARY");
-		const rawKeepLength = toBoundary === -1 ? 0 : boundaryEvent.type === "turn/end" ? toBoundary + 1 : toBoundary;
-		const kept = balanceRewindPrefix(events.slice(0, rawKeepLength));
-		const keepLength = kept.length;
 		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();
@@ -177,6 +253,7 @@ var SessionBranchRdbProvider = class {
 		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;
@@ -192,33 +269,25 @@ var SessionBranchRdbProvider = class {
 		} else await this.refreshProjectionCache({
 			id,
 			header: meta,
-			inheritedEventCount: SessionLogOffset(raw.inheritedEventCount),
-			snapshotEvents: () => kept
+			inheritedEventCount: SessionLogOffset(newSeedLength ?? row.fSeedLength ?? 0),
+			headSeq: keepLength - 1,
+			snapshotEvents: () => []
 		});
-		const row = await internals.backend.getSession(id);
-		if (row === void 0) return {
-			header: {
-				version: SESSION_FORMAT_VERSION,
-				id,
-				createdAt: meta.createdAt,
-				...meta.cwd !== void 0 ? { cwd: meta.cwd } : {},
-				...meta.parentSession !== void 0 ? { parentSession: meta.parentSession } : {},
-				isSeeded: meta.isSeeded,
-				...meta.origin !== void 0 ? { origin: meta.origin } : {},
-				...meta.delegationDepth !== void 0 ? { delegationDepth: meta.delegationDepth } : {},
-				...meta.agentPreset !== void 0 ? { agentPreset: meta.agentPreset } : {}
-			},
-			revision: await internals.readStoredRevision(id) ?? await this.persistence.readStoredRevision(id)
-		};
 		return {
 			header: rowToMeta(row),
 			revision: await internals.readStoredRevision(id)
 		};
 	}
-	/**
-	* 让持久化投影检查点跟随截断后的 log（见 {@link LiveSessionHooks.refreshProjectionCache}）。
-	* 缓存是派生数据：刷新失败只让缓存多滞后一轮，不能让 rewind 失败。
-	*/
+	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 {
@@ -228,24 +297,66 @@ var SessionBranchRdbProvider = class {
 };
 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),
-		resetProjections: (session) => {
-			const registry = this.ctx.get("sessionProjections");
-			if (registry?.registrations === void 0) return;
-			for (const registration of registry.registrations.values()) registration.cells.delete(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)}`);
@@ -276,4 +387,4 @@ var SessionBranchRdb = class extends SessionBranch {
 	}
 };
 //#endregion
-export { truncateLiveSession as a, replaceLiveSessionLog as i, SessionBranchRdbProvider as n, locateTurnEnd as r, SessionBranchRdb as t };
+export { truncateLiveSession as a, isLegacyVersion as c, replaceLiveSessionLog as i, SessionBranchRdbProvider as n, adoptLegacyRows as o, locateTurnEnd as r, convertLegacyRows as s, SessionBranchRdb as t };

package/dist/deletion.d.mts

@@ -0,0 +1,7 @@
+import { u as SessionPersistenceRdb } from "./backend-DpdtxYpz.mjs";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/deletion.d.ts
+declare const SESSION_DELETE_PATH = "/api/session.delete";
+declare function registerSessionDeletion(ctx: Context, persistence: SessionPersistenceRdb): void;
+//#endregion
+export { SESSION_DELETE_PATH, registerSessionDeletion };

package/dist/deletion.mjs

@@ -0,0 +1,2 @@
+import { i as registerSessionDeletion, r as SESSION_DELETE_PATH } from "./src-CWTWV7vx.mjs";
+export { SESSION_DELETE_PATH, registerSessionDeletion };