@morlay/session-rdb 0.0.19 → 0.0.21-alpha.0

package/dist/branch-5JzX9rUq.mjs

@@ -0,0 +1,390 @@
+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 { 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) {
+		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 sourceRows = await internals.backend.getEventRows(sourceId);
+		const sourceEventIds = new Map(sourceRows.map((row) => [row.fSequence, row.fEventId]));
+		const reuse = /* @__PURE__ */ new Map();
+		for (const event of prefix) {
+			const eventId = sourceEventIds.get(event.seq);
+			if (eventId !== void 0) reuse.set(event.seq, eventId);
+		}
+		internals.registerReuseEventIds(childId, reuse);
+		const handle = await this.persistence.create(childMeta, { inheritedEventCount: SessionLogOffset(prefix.length) });
+		try {
+			if (seed.length > 0) await handle.append(seed);
+		} finally {
+			await handle.close();
+		}
+		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);
+	}
+	async timeline(sessionId, signal) {
+		const persistence = this.ctx.sessionPersistence;
+		const snapshots = await persistence.listSnapshots(signal);
+		const readOwnEvents = async (id, fromSeq, s) => {
+			const live = this.ctx.sessions.get(id);
+			if (live !== void 0) return live.snapshotEvents().slice(fromSeq);
+			return (await persistence.internals().readFrom(id, fromSeq, s)).events;
+		};
+		return buildTimeline(snapshots, readOwnEvents, sessionId, signal);
+	}
+};
+//#endregion
+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 };