@morlay/session-rdb 0.0.12 → 0.0.13

package/dist/artifact.d.mts

@@ -0,0 +1,64 @@
+import { b as EventRow, x as SessionRow } from "./schema-CFXZURX7.mjs";
+import { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, expandProvenanceFromStorage, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport } from "./import.mjs";
+import { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
+import { SessionEvent, SessionHeader, SurfaceOp } from "@deepseek-ai/dsh-session";
+//#region src/log.d.ts
+declare function rowToMeta(row: SessionRow): SessionHeader;
+declare function sessionInsertRow(storage: SessionStorageMetadata, incarnation: string): {
+  fSessionId: string;
+  fHeadEventId: string;
+  fHeadSequence: number;
+  fVersion: number;
+  fCreatedAt: number;
+  fCwd: string | null;
+  fParentSession: string | null;
+  fSeedLength: number | null;
+  fOrigin: string | null;
+  fDelegationDepth: number | null;
+  fIncarnation: string;
+  fRevision: number;
+};
+declare function sessionConflictRow(storage: SessionStorageMetadata): {
+  fVersion: number;
+  fCreatedAt: number;
+  fCwd: string | null;
+  fParentSession: string | null;
+  fSeedLength: number | null;
+  fOrigin: string | null;
+  fDelegationDepth: number | null;
+};
+declare function remapSurfaceOp(op: SurfaceOp, remap: (seq: number) => number): SurfaceOp;
+declare function remapShadowedRange(range: {
+  start: number;
+  end: number;
+}, remap: (seq: number) => number): {
+  start: number;
+  end: number;
+};
+declare function rowToEvent(row: EventRow, seqMap: ReadonlyMap<number, number>): SessionEvent;
+declare function buildSeqMap(rows: readonly Pick<EventRow, "fSequence" | "fOriginalSeq">[]): Map<number, number>;
+declare function recomputeReplaceProvenance(events: SessionEvent[]): void;
+declare function findSurfaceRepairs(events: readonly SessionEvent[]): {
+  degradeToAppend: Set<number>;
+  addAppendMarker: Set<number>;
+  clearSurfaceOp: Set<number>;
+};
+declare function repairSurfaceOps(events: SessionEvent[]): void;
+/**
+ * 定位无法从空状态增量重放的 agent/inbox/spliced 事件（孤儿操作）。
+ *
+ * 上游 Inbox 每次构造都从会话起点重放全部 inbox splice，失败即拒绝整个
+ * 会话（resume / 编辑重放不可用）。rewind 截断历史轮次后若残留 splice 引用
+ * 已被截断的排队消息（插入被删、消费保留，或反之），重放时越界或重复——
+ * 无法独立重放。
+ */
+declare function orphanInboxSpliceSeqs(events: readonly SessionEvent[]): Set<number>;
+/** 内存修复：把孤儿 inbox splice 改写为 no-op（调用方负责持久化）。 */
+declare function repairOrphanInboxSplices(events: SessionEvent[]): void;
+declare function scanRows(rows: readonly EventRow[], base?: number, seqMap?: ReadonlyMap<number, number>): {
+  preserved: SessionEvent[];
+  tornFrom?: number;
+};
+declare function toJsonlArtifact(meta: SessionHeader, inheritedEventCount: number, events: readonly SessionEvent[]): string;
+//#endregion
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, buildSeqMap, expandProvenanceFromStorage, findSurfaceRepairs, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, remapShadowedRange, remapSurfaceOp, repairOrphanInboxSplices, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, toJsonlArtifact };

package/dist/artifact.mjs

@@ -0,0 +1,3 @@
+import { A as toJsonlArtifact, C as repairOrphanInboxSplices, D as scanRows, E as rowToMeta, O as sessionConflictRow, S as remapSurfaceOp, T as rowToEvent, _ as buildSeqMap, b as recomputeReplaceProvenance, k as sessionInsertRow, v as findSurfaceRepairs, w as repairSurfaceOps, x as remapShadowedRange, y as orphanInboxSpliceSeqs } from "./schema-B-8G4lWc.mjs";
+import { a as parseJsonlArtifact, i as parseImportZip, n as SESSION_LOG_ARTIFACT_FILENAME, o as persistImport, r as expandProvenanceFromStorage, s as registerSessionImport, t as SESSION_IMPORT_PATH } from "./import-D2vUnUZe.mjs";
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, buildSeqMap, expandProvenanceFromStorage, findSurfaceRepairs, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, remapShadowedRange, remapSurfaceOp, repairOrphanInboxSplices, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, toJsonlArtifact };

package/dist/import-D2vUnUZe.mjs

@@ -0,0 +1,438 @@
+import { E as rowToMeta, l as isPersistedEvent } from "./schema-B-8G4lWc.mjs";
+import { randomUUID } from "node:crypto";
+import { SESSION_FORMAT_VERSION, SessionLogOffset, decodeSeqRanges, decodeStorageRecord } from "@deepseek-ai/dsh-session";
+import { SessionBranch, SessionBranchError, balanceRewindPrefix, buildTimeline } from "@morlay/session-branch";
+import { unzipSync } from "fflate";
+//#region src/branch.ts
+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 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;
+	s.surfaceManager._state = {
+		nodes: [],
+		replaceGeneration: 0
+	};
+	s.surfaceManager._lastProcessedSeq = s.surfaceManager.baseSeq - 1;
+	s.surfaceManager._pendingPlan = void 0;
+}
+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;
+	s.surfaceManager._state = {
+		nodes: [],
+		replaceGeneration: 0
+	};
+	s.surfaceManager._lastProcessedSeq = s.surfaceManager.baseSeq - 1;
+	s.surfaceManager._pendingPlan = void 0;
+}
+var SessionBranchRdbProvider = class {
+	persistence;
+	live;
+	name = "session-rdb";
+	constructor(persistence, live = {
+		getSession: () => void 0,
+		getAgent: () => void 0,
+		flush: async () => true,
+		setCoordinatorCursor: () => {},
+		setCoordinatorState: () => {},
+		setCoordinatorSeedLength: () => {}
+	}) {
+		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.loadStored(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.inspect(sourceId, signal);
+		const boundary = locateTurnEnd(source.events, atSeq, anchorMode);
+		const prefix = source.events.slice(0, boundary + 1);
+		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.fOriginalSeq, 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);
+		await this.persistence.create(childMeta, prefix.length);
+		if (seed.length > 0) await this.persistence.append(childId, seed);
+		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 raw = live === void 0 ? await this.readRawEvents(id, signal) : void 0;
+		const inspection = live === void 0 ? void 0 : await this.persistence.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 keepLength = balanceRewindPrefix(events.slice(0, rawKeepLength)).length;
+		const internals = this.persistence.internals();
+		const denseBoundary = live === void 0 ? keepLength - 1 : events.slice(0, keepLength).filter(isPersistedEvent).length - 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.bumpRevision(id);
+			return shrunk;
+		});
+		if (newSeedLength !== null) this.live.setCoordinatorSeedLength(id, newSeedLength);
+		internals.writeGuard.confirmHead(id, denseBoundary);
+		if (live !== void 0) {
+			truncateLiveSession(live, keepLength);
+			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;
+			}
+			this.live.setCoordinatorCursor(id, keepLength);
+		} else if (boundaryEvent?.type === "user/message") this.live.setCoordinatorState(id, keepLength, meta);
+		else await this.persistence.load(id);
+		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)
+		};
+	}
+};
+var SessionBranchRdb = class extends SessionBranch {
+	static inject = ["sessionPersistence", "sessions"];
+	constructor(ctx) {
+		super(ctx);
+	}
+	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),
+		setCoordinatorCursor: (id, cursor) => {
+			const state = this.ctx.sessionPersistence.coordinator?.states?.get(id);
+			if (state !== void 0) state.cursor = cursor;
+		},
+		setCoordinatorState: (id, cursor, meta) => {
+			const states = this.ctx.sessionPersistence.coordinator?.states;
+			if (states === void 0) return;
+			const state = states.get(id);
+			if (state !== void 0) state.cursor = cursor;
+			else states.set(id, {
+				meta,
+				cursor,
+				materialized: true
+			});
+		},
+		setCoordinatorSeedLength: (id, seedLength) => {
+			const state = this.ctx.sessionPersistence.coordinator?.states?.get(id);
+			if (state?.storage !== void 0 && state.storage.inheritedEventCount > seedLength) state.storage = {
+				...state.storage,
+				inheritedEventCount: seedLength
+			};
+		}
+	});
+	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);
+	}
+	syncLiveCursor(sessionId) {
+		const live = this.ctx.sessions.get(sessionId);
+		if (live === void 0) return;
+		const state = this.ctx.sessionPersistence.coordinator?.states?.get(sessionId);
+		if (state === void 0) return;
+		let cursor = state.cursor;
+		while (live.snapshotEvents()[cursor]?.ignorable === true) cursor += 1;
+		state.cursor = cursor;
+	}
+	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.readFrom(id, fromSeq, s)).events;
+		};
+		return buildTimeline(snapshots, readOwnEvents, sessionId, signal);
+	}
+};
+//#endregion
+//#region src/import.ts
+const SESSION_LOG_ARTIFACT_FILENAME = "session.jsonl";
+const SESSION_IMPORT_PATH = "/api/session.import";
+const MAX_IMPORT_ZIP_BYTES = 67108864;
+function expandProvenanceFromStorage(parsed) {
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new TypeError("imported session records must be objects");
+	const record = parsed;
+	if (record.sourceEventSeqs === void 0) return parsed;
+	if (!Number.isSafeInteger(record.seq) || record.seq < 0) throw new TypeError("imported session event seq must be a non-negative safe integer");
+	return {
+		...record,
+		sourceEventSeqs: decodeSeqRanges(record.sourceEventSeqs, record.seq + 1)
+	};
+}
+function parseJsonlArtifact(content) {
+	const lines = content.split("\n");
+	if (lines.length === 0 || lines[0] === "") throw new Error("imported session log is empty");
+	let header;
+	try {
+		header = JSON.parse(lines[0]);
+	} catch {
+		throw new Error("imported session log has an unparsable header line");
+	}
+	if (typeof header !== "object" || header === null || header["type"] !== "session" || typeof header["id"] !== "string" || typeof header["version"] !== "number" || !Number.isSafeInteger(header["createdAt"]) || header["createdAt"] < 0) throw new Error("imported session log has an invalid header line");
+	const seedLength = header["seedLength"];
+	if (seedLength !== void 0 && (!Number.isSafeInteger(seedLength) || seedLength < 0)) throw new Error("imported session log has an invalid seedLength");
+	const events = [];
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i];
+		if (line === void 0 || line === "") continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			throw new Error(`imported session log has an unparsable event line at ${i}`);
+		}
+		for (const event of decodeStorageRecord(expandProvenanceFromStorage(parsed))) events.push(event);
+	}
+	for (let i = 0; i < events.length; i++) if (events[i].seq !== i) throw new Error(`imported session log seq gap at ${i} (got ${events[i].seq}); import requires a dense log`);
+	const origin = header["origin"];
+	const delegationDepth = header["delegationDepth"];
+	const inheritedEventCount = Math.min(seedLength ?? 0, events.length);
+	return {
+		meta: {
+			version: header["version"],
+			id: header["id"],
+			createdAt: header["createdAt"],
+			...typeof header["cwd"] === "string" ? { cwd: header["cwd"] } : {},
+			...typeof header["parentSession"] === "string" ? { parentSession: header["parentSession"] } : {},
+			isSeeded: seedLength !== void 0,
+			...origin === "subagent" ? { origin } : {},
+			...Number.isSafeInteger(delegationDepth) && delegationDepth > 0 ? { delegationDepth } : {},
+			...typeof header["agentPreset"] === "string" ? { agentPreset: header["agentPreset"] } : {}
+		},
+		inheritedEventCount: SessionLogOffset(inheritedEventCount),
+		events
+	};
+}
+function parseImportZip(zip) {
+	let entries;
+	try {
+		entries = unzipSync(zip);
+	} catch {
+		throw new Error("imported zip is not a valid ZIP archive");
+	}
+	const artifact = entries[SESSION_LOG_ARTIFACT_FILENAME];
+	if (artifact === void 0) throw new Error(`imported zip is missing ${SESSION_LOG_ARTIFACT_FILENAME}`);
+	return parseJsonlArtifact(new TextDecoder().decode(artifact));
+}
+async function persistImport(persistence, branch, imported, targetId, sessions) {
+	const id = targetId ?? `session-${randomUUID()}`;
+	if (targetId !== void 0) {
+		if (branch === void 0) throw new Error("sessionBranch service is unavailable");
+		await branch.rewind(targetId, -1);
+	} else await persistence.create({
+		...imported.meta,
+		id
+	}, imported.inheritedEventCount);
+	if (imported.events.length > 0) await persistence.append(id, imported.events);
+	if (targetId !== void 0) {
+		const live = sessions?.get(targetId);
+		if (live !== void 0) replaceLiveSessionLog(live, imported.events);
+	}
+	return id;
+}
+function registerSessionImport(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_IMPORT_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				const body = Buffer.concat(chunks);
+				let envelope;
+				try {
+					envelope = JSON.parse(body.toString("utf8"));
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				if (typeof envelope.zip !== "string" || envelope.zip === "") {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "missing zip field" }));
+					return;
+				}
+				if (envelope.sessionId !== void 0 && (typeof envelope.sessionId !== "string" || envelope.sessionId === "")) {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "sessionId must be a non-empty string" }));
+					return;
+				}
+				let zip;
+				try {
+					zip = Buffer.from(envelope.zip, "base64");
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "zip field is not valid base64" }));
+					return;
+				}
+				if (zip.byteLength > MAX_IMPORT_ZIP_BYTES) {
+					res.writeHead(413, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "imported zip exceeds the size limit" }));
+					return;
+				}
+				let imported;
+				try {
+					imported = parseImportZip(zip);
+				} catch (error) {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "imported zip is invalid" }));
+					return;
+				}
+				const targetId = typeof envelope.sessionId === "string" ? envelope.sessionId : void 0;
+				const branch = webCtx.get("sessionBranch");
+				try {
+					const sessions = webCtx.get("sessions");
+					const id = await persistImport(persistence, branch, imported, targetId, sessions);
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify({ sessionId: id }));
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					if (targetId !== void 0 && /not found/i.test(message)) {
+						res.writeHead(404, { "content-type": "application/json" });
+						res.end(JSON.stringify({ error: `session "${targetId}" not found` }));
+						return;
+					}
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "import failed" }));
+					return;
+				}
+			}
+		}), `session-rdb: ${SESSION_IMPORT_PATH} route`);
+	});
+}
+//#endregion
+export { parseJsonlArtifact as a, SessionBranchRdb as c, parseImportZip as i, SessionBranchRdbProvider as l, SESSION_LOG_ARTIFACT_FILENAME as n, persistImport as o, expandProvenanceFromStorage as r, registerSessionImport as s, SESSION_IMPORT_PATH as t, locateTurnEnd as u };

package/dist/import.d.mts

@@ -0,0 +1,24 @@
+import { n as SessionPersistenceRdb } from "./index-uUvn6gYp.mjs";
+import { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
+import { Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/import.d.ts
+declare const SESSION_LOG_ARTIFACT_FILENAME = "session.jsonl";
+declare const SESSION_IMPORT_PATH = "/api/session.import";
+declare function expandProvenanceFromStorage(parsed: unknown): unknown;
+declare function parseJsonlArtifact(content: string): SessionStorageMetadata & {
+  events: SessionEvent[];
+};
+declare function parseImportZip(zip: Uint8Array): SessionStorageMetadata & {
+  events: SessionEvent[];
+};
+declare function persistImport(persistence: SessionPersistenceRdb, branch: {
+  rewind(id: SessionId, toBoundary: number): Promise<unknown>;
+} | undefined, imported: SessionStorageMetadata & {
+  events: SessionEvent[];
+}, targetId?: SessionId, sessions?: {
+  get(id: SessionId): Session | undefined;
+}): Promise<SessionId>;
+declare function registerSessionImport(ctx: Context, persistence: SessionPersistenceRdb): void;
+//#endregion
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, expandProvenanceFromStorage, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport };

package/dist/import.mjs

@@ -0,0 +1,2 @@
+import { a as parseJsonlArtifact, i as parseImportZip, n as SESSION_LOG_ARTIFACT_FILENAME, o as persistImport, r as expandProvenanceFromStorage, s as registerSessionImport, t as SESSION_IMPORT_PATH } from "./import-D2vUnUZe.mjs";
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, expandProvenanceFromStorage, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport };

package/dist/index-uUvn6gYp.d.mts

@@ -0,0 +1,111 @@
+import { _ as WriteGuard, o as JournalMode, v as Backend } from "./schema-CFXZURX7.mjs";
+import z from "@deepseek-ai/schemastery";
+import { PersistenceBackend, SessionLocation, SessionPersistence, SessionPersistenceRevision, SessionPersistenceSnapshot, SessionStorageMetadata, StoredPrefix, StoredSuffix } from "@deepseek-ai/dsh-session-persistence";
+import { Session, SessionEvent, SessionHeader, SessionId } from "@deepseek-ai/dsh-session";
+import { BranchAnchorMode, BranchBoundary, ForkFromOptions, SessionBranch, SessionBranchProvider } from "@morlay/session-branch";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/branch.d.ts
+declare function locateTurnEnd(events: readonly SessionEvent[], atSeq?: number, mode?: BranchAnchorMode): number;
+interface LiveSessionHooks {
+  getSession(id: SessionId): Session | undefined;
+  getAgent(id: SessionId): LiveAgentLike | undefined;
+  flush(session: Session): Promise<boolean>;
+  setCoordinatorCursor(id: SessionId, cursor: number): void;
+  setCoordinatorState(id: SessionId, cursor: number, meta: SessionHeader): void;
+  setCoordinatorSeedLength(id: SessionId, seedLength: number): void;
+}
+interface LiveAgentLike {
+  session: Session;
+  requestHeaderLogged?: boolean;
+}
+declare class SessionBranchRdbProvider implements SessionBranchProvider {
+  private readonly persistence;
+  private readonly live;
+  readonly name = "session-rdb";
+  constructor(persistence: SessionPersistenceRdb, live?: LiveSessionHooks);
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
+  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    events: readonly SessionEvent[];
+  }>;
+  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
+}
+declare class SessionBranchRdb extends SessionBranch {
+  static inject: string[];
+  constructor(ctx: import("@deepseek-ai/cordis").Context);
+  private readonly provider;
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
+  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    events: readonly SessionEvent[];
+  }>;
+  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
+  syncLiveCursor(sessionId: SessionId): void;
+  timeline(sessionId: SessionId, signal?: AbortSignal): Promise<import("@morlay/session-branch").BranchTimeline>;
+}
+//#endregion
+//#region src/index.d.ts
+interface SessionPersistenceRdbInternals {
+  readonly backend: Backend;
+  readonly writeGuard: WriteGuard;
+  create(meta: SessionHeader, inheritedEventCount?: number): Promise<void>;
+  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+  load(id: SessionId): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  inspect(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionEventSuffix>;
+  listSnapshots(signal?: AbortSignal): Promise<SessionPersistenceSnapshot[]>;
+  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionPersistenceRevision | undefined>;
+  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
+}
+type Config = {
+  type: "sqlite";
+  path: string;
+  journalMode?: JournalMode;
+  busyTimeout?: number;
+} | {
+  type: "postgres";
+  connectionString: string;
+  schema?: string;
+};
+declare class SessionPersistenceRdb extends SessionPersistence implements PersistenceBackend<number> {
+  config: Config;
+  static inject: string[];
+  static Config: z<Config>;
+  static readonly settingsNs = "session-rdb";
+  readonly name = "session-rdb";
+  readonly supportsRawArtifacts = true;
+  readRaw(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionRawArtifact | undefined>;
+  private readonly backend;
+  private storeIdentity;
+  private readonly ready;
+  private readonly coordinator;
+  private readonly writeGuard;
+  private readonly reuseEventIds;
+  constructor(ctx: Context, config: Config, injectedBackend?: Backend);
+  private init;
+  locate(_meta: SessionHeader): SessionLocation | undefined;
+  create(meta: SessionHeader, inheritedEventCount?: number): Promise<void>;
+  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+  load(id: SessionId): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  inspect(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionEventSuffix>;
+  borrowSession(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").BorrowedSessionSource>;
+  loadStored(id: SessionId, signal?: AbortSignal): Promise<StoredPrefix<number> | undefined>;
+  loadStoredFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<StoredSuffix | undefined>;
+  private readPrefix;
+  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<SessionPersistenceRevision | undefined>;
+  private readLog;
+  appendBatch(storage: SessionStorageMetadata, events: readonly SessionEvent[], _isMaterialized: boolean): Promise<void>;
+  commitRepair(storage: SessionStorageMetadata, tornMarker: number | undefined, closers: readonly SessionEvent[]): Promise<void>;
+  list(signal?: AbortSignal): Promise<SessionHeader[]>;
+  listSnapshots(signal?: AbortSignal): Promise<Array<SessionPersistenceSnapshot & {
+    inheritedEventCount: number;
+  }>>;
+  close(): Promise<void>;
+  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
+  internals(): SessionPersistenceRdbInternals;
+}
+//#endregion
+export { SessionBranchRdbProvider as a, SessionBranchRdb as i, SessionPersistenceRdb as n, locateTurnEnd as o, SessionPersistenceRdbInternals as r, Config as t };