@morlay/session-rdb 0.0.14 → 0.0.16-alpha.0

package/README.md

@@ -1,9 +1,9 @@
 # @morlay/session-rdb
 
-RDB（SQLite / PostgreSQL）持久会话后端（`ctx.sessionPersistence`）：通过 drizzle
-实现 `PersistenceBackend<number>`，复用上游 `PersistenceCoordinator` 与契约测试套件，
-支持配置选择 SQLite 或 PostgreSQL 后端。设计细节（表结构、delta 过滤、并发写、
-方言差异、仓库结构）见 [docs/design.md](docs/design.md)。
+RDB（SQLite / PostgreSQL）持久会话后端（`ctx.sessionPersistence`）：实现上游
+`SessionHandle` 模型（`create`/`open`/`flush`/`stat`/`list`），支持配置选择
+SQLite 或 PostgreSQL 后端。设计细节（表结构、原样存储、并发写、方言差异、
+仓库结构）见 [docs/design.md](docs/design.md)。
 
 ## 配置
 
@@ -59,18 +59,16 @@ type Config =
 provider 抽象并**随插件自动注册 `ctx.sessionBranch`**（`SessionBranchRdb`），
 在不修改上游代码的前提下提供 `rewind / retry / fork` 的持久化闭环：
 
-- **`forkFrom`**：走标准 coordinator 路径（`create` + `append`）从闭合边界
+- **`forkFrom`**：走标准 handle 路径（`create` + `append`）从闭合边界
   派生新会话（纯 append，`parentSession` / `seedLength` lineage）；
 - **`rewind`**：直接操作后端事务截断到闭合边界（DELETE 尾部 + head 回退 +
-  revision bump），随后重新 `load` 同步 coordinator 状态，并更新并发写
-  检测 head；**支持 live 会话**（`ctx.sessions` 有 owner 时同样就地工作：
-  先 flush write-behind 缓冲 → 截断 RDB → 截断 live 内存 log 并复位
-  surface/header/context/derived 派生缓存 → 重置 agent 请求头标记 →
-  同步 coordinator cursor；不调用 `load`——live 时 load 会先 flush 撤销
-  截断）；
+  revision bump），并更新并发写检测 head；**支持 live 会话**（`ctx.sessions`
+  有 owner 时同样就地工作：先 flush write-behind 缓冲 → 截断 RDB → 截断
+  live 内存 log 并复位 surface/header/context/derived 派生缓存 → 重置 agent
+  请求头标记 → 对齐 handle cursor；不调用 `load`——live 时 load 会先 flush
+  撤销截断）；
 - **`timeline`**：`parentSession` + `seedLength` 版本树投影（live 会话含
-  版本效果；cold 会话因版本事件携带 `ignorable` 不进 canonical log 而只有
-  lineage 骨架）。
+  版本效果；cold 会话版本事件原样落库，效果详情可恢复）。
 
 上层编排（edit / reroll / retry / rewind / fork 完整功能）由
 `@morlay/ui-conversation-message-actions` 提供，或直接在 `ctx.sessionBranch` /

package/dist/artifact.d.mts

@@ -1,7 +1,7 @@
-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 { v as EventRow, y as SessionRow } from "./schema-COK7-wRV.mjs";
+import { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport } from "./import.mjs";
 import { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
-import { SessionEvent, SessionHeader, SurfaceOp } from "@deepseek-ai/dsh-session";
+import { SessionEvent, SessionHeader } from "@deepseek-ai/dsh-session";
 //#region src/log.d.ts
 declare function rowToMeta(row: SessionRow): SessionHeader;
 declare function sessionInsertRow(storage: SessionStorageMetadata, incarnation: string): {
@@ -27,17 +27,7 @@ declare function sessionConflictRow(storage: SessionStorageMetadata): {
   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 remapShadowedSeqs(seqs: readonly number[], remap: (seq: number) => number): 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 rowToEvent(row: EventRow): SessionEvent;
 /**
  * 读取时重计算 replace 的 sourceEventSeqs（sourceEventSeqs 不落库）。
  *
@@ -68,10 +58,10 @@ declare function repairSurfaceOps(events: SessionEvent[]): void;
 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>): {
+declare function scanRows(rows: readonly EventRow[], base?: 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, remapShadowedSeqs, remapSurfaceOp, repairOrphanInboxSplices, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, toJsonlArtifact };
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, repairOrphanInboxSplices, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, toJsonlArtifact };

package/dist/artifact.mjs

@@ -1,3 +1,3 @@
-import { A as sessionInsertRow, C as remapSurfaceOp, D as rowToMeta, E as rowToEvent, O as scanRows, S as remapShadowedSeqs, T as repairSurfaceOps, _ as buildSeqMap, b as recomputeReplaceProvenance, j as toJsonlArtifact, k as sessionConflictRow, v as findSurfaceRepairs, w as repairOrphanInboxSplices, x as remapShadowedRange, y as orphanInboxSpliceSeqs } from "./schema-BfPVmr1X.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-B-tf5vQn.mjs";
-export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, buildSeqMap, expandProvenanceFromStorage, findSurfaceRepairs, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, remapShadowedRange, remapShadowedSeqs, remapSurfaceOp, repairOrphanInboxSplices, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, toJsonlArtifact };
+import { a as repairSurfaceOps, c as scanRows, d as toJsonlArtifact, i as repairOrphanInboxSplices, l as sessionConflictRow, n as orphanInboxSpliceSeqs, o as rowToEvent, r as recomputeReplaceProvenance, s as rowToMeta, t as findSurfaceRepairs, u as sessionInsertRow } from "./log-DTJsxMud.mjs";
+import { a as persistImport, i as parseJsonlArtifact, n as SESSION_LOG_ARTIFACT_FILENAME, o as registerSessionImport, r as parseImportZip, t as SESSION_IMPORT_PATH } from "./import-CKrzjXVB.mjs";
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, repairOrphanInboxSplices, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, toJsonlArtifact };

package/dist/{import-B-tf5vQn.mjs → import-CKrzjXVB.mjs}

@@ -1,6 +1,7 @@
-import { D as rowToMeta, l as isPersistedEvent } from "./schema-BfPVmr1X.mjs";
+import { s as rowToMeta } from "./log-DTJsxMud.mjs";
 import { randomUUID } from "node:crypto";
-import { SESSION_FORMAT_VERSION, SessionLogOffset, decodeSeqRanges, decodeStorageRecord } from "@deepseek-ai/dsh-session";
+import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
+import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
 import { SessionBranch, SessionBranchError, balanceRewindPrefix, buildTimeline } from "@morlay/session-branch";
 import { unzipSync } from "fflate";
 //#region src/branch.ts
@@ -78,10 +79,7 @@ var SessionBranchRdbProvider = class {
 	constructor(persistence, live = {
 		getSession: () => void 0,
 		getAgent: () => void 0,
-		flush: async () => true,
-		setCoordinatorCursor: () => {},
-		setCoordinatorState: () => {},
-		setCoordinatorSeedLength: () => {}
+		flush: async () => true
 	}) {
 		this.persistence = persistence;
 		this.live = live;
@@ -95,7 +93,7 @@ var SessionBranchRdbProvider = class {
 		};
 	}
 	async readRawEvents(id, signal) {
-		const stored = await this.persistence.loadStored(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,
@@ -105,7 +103,8 @@ var SessionBranchRdbProvider = class {
 	async forkFrom(sourceId, options = {}, signal) {
 		signal?.throwIfAborted();
 		const { atSeq, anchorMode = "after", seedSuffix = [], childSessionId, meta = {} } = options;
-		const source = await this.persistence.inspect(sourceId, signal);
+		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 childId = childSessionId ?? mintSessionId();
@@ -123,15 +122,19 @@ var SessionBranchRdbProvider = class {
 		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 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);
-		await this.persistence.create(childMeta, prefix.length);
-		if (seed.length > 0) await this.persistence.append(childId, seed);
+		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) {
@@ -140,7 +143,7 @@ var SessionBranchRdbProvider = class {
 		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 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];
@@ -149,7 +152,7 @@ var SessionBranchRdbProvider = class {
 		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 denseBoundary = keepLength - 1;
 		const newSeedLength = await internals.backend.transaction(async (tx) => {
 			signal?.throwIfAborted();
 			const head = await tx.getHead(id);
@@ -169,7 +172,6 @@ var SessionBranchRdbProvider = class {
 			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);
@@ -180,9 +182,9 @@ var SessionBranchRdbProvider = class {
 				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 handle = this.persistence.tracker.writerOf(id);
+			if (handle !== void 0) handle.resetAfterRewind(keepLength, newSeedLength === null ? void 0 : newSeedLength);
+		}
 		const row = await internals.backend.getSession(id);
 		if (row === void 0) return {
 			header: {
@@ -214,29 +216,7 @@ var SessionBranchRdb = class extends SessionBranch {
 		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
-			};
-		}
+		flush: (session) => this.ctx.sessions.flush(session)
 	});
 	readBranchPrefix(id, atSeq, mode, signal) {
 		return this.provider.readBranchPrefix(id, atSeq, mode, signal);
@@ -250,22 +230,13 @@ var SessionBranchRdb = class extends SessionBranch {
 	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 (await persistence.internals().readFrom(id, fromSeq, s)).events;
 		};
 		return buildTimeline(snapshots, readOwnEvents, sessionId, signal);
 	}
@@ -275,16 +246,6 @@ var SessionBranchRdb = class extends SessionBranch {
 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");
@@ -294,10 +255,15 @@ function parseJsonlArtifact(content) {
 	} 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 = [];
+	let restore;
+	try {
+		restore = sessionFormatCatalog.createRestore(header, {
+			recovery: "strict",
+			validation: "transformed"
+		});
+	} catch (error) {
+		throw new Error(`imported session log has an invalid header line: ${error instanceof Error ? error.message : String(error)}`);
+	}
 	for (let i = 1; i < lines.length; i++) {
 		const line = lines[i];
 		if (line === void 0 || line === "") continue;
@@ -307,23 +273,33 @@ function parseJsonlArtifact(content) {
 		} catch {
 			throw new Error(`imported session log has an unparsable event line at ${i}`);
 		}
-		for (const event of decodeStorageRecord(expandProvenanceFromStorage(parsed))) events.push(event);
+		try {
+			restore.decodeRow(parsed);
+		} catch (error) {
+			throw new Error(`imported session log has an invalid event line at ${i}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	let artifact;
+	try {
+		artifact = restore.finish();
+	} catch (error) {
+		throw new Error(`imported session log is incomplete: ${error instanceof Error ? error.message : String(error)}`);
 	}
+	const meta = artifact.header;
+	const events = artifact.events;
 	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);
+	const inheritedEventCount = Math.min(artifact.inheritedEventCount, 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"] } : {}
+			version: SESSION_FORMAT_VERSION,
+			id: meta.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 }
 		},
 		inheritedEventCount: SessionLogOffset(inheritedEventCount),
 		events
@@ -345,11 +321,25 @@ async function persistImport(persistence, branch, imported, targetId, sessions)
 	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);
+		const liveHandle = persistence.tracker.writerOf(targetId);
+		if (liveHandle !== void 0) {
+			if (imported.events.length > 0) await liveHandle.append(imported.events);
+		} else {
+			const handle = await persistence.open(targetId, "write");
+			try {
+				if (imported.events.length > 0) await handle.append(imported.events);
+			} finally {
+				await handle.close();
+			}
+		}
+	} else {
+		const handle = await persistence.create({
+			...imported.meta,
+			id
+		}, { inheritedEventCount: imported.inheritedEventCount });
+		if (imported.events.length > 0) await handle.append(imported.events);
+		await handle.close();
+	}
 	if (targetId !== void 0) {
 		const live = sessions?.get(targetId);
 		if (live !== void 0) replaceLiveSessionLog(live, imported.events);
@@ -435,4 +425,4 @@ function registerSessionImport(ctx, persistence) {
 	});
 }
 //#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 };
+export { persistImport as a, SessionBranchRdbProvider as c, parseJsonlArtifact as i, locateTurnEnd as l, SESSION_LOG_ARTIFACT_FILENAME as n, registerSessionImport as o, parseImportZip as r, SessionBranchRdb as s, SESSION_IMPORT_PATH as t };

package/dist/import.d.mts

@@ -1,11 +1,10 @@
-import { n as SessionPersistenceRdb } from "./index-uUvn6gYp.mjs";
+import { n as SessionPersistenceRdb } from "./index-CgGDHQSK.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[];
 };
@@ -21,4 +20,4 @@ declare function persistImport(persistence: SessionPersistenceRdb, branch: {
 }): Promise<SessionId>;
 declare function registerSessionImport(ctx: Context, persistence: SessionPersistenceRdb): void;
 //#endregion
-export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, expandProvenanceFromStorage, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport };
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport };

package/dist/import.mjs

@@ -1,2 +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-B-tf5vQn.mjs";
-export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, expandProvenanceFromStorage, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport };
+import { a as persistImport, i as parseJsonlArtifact, n as SESSION_LOG_ARTIFACT_FILENAME, o as registerSessionImport, r as parseImportZip, t as SESSION_IMPORT_PATH } from "./import-CKrzjXVB.mjs";
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport };

package/dist/index-CgGDHQSK.d.mts

@@ -0,0 +1,225 @@
+import { a as JournalMode, g as Backend, h as WriteGuard } from "./schema-COK7-wRV.mjs";
+import z from "@deepseek-ai/schemastery";
+import { SessionAccess, SessionHandle, SessionHandleAppendOptions, SessionHandleFlushOptions, SessionHandleReadOptions, SessionHandleReadResult, SessionPersistence, SessionPersistenceCreateOptions, SessionPersistenceListOptions, SessionPersistenceOpenOptions, SessionPersistenceRevision, SessionPersistenceSnapshot, SessionPersistenceStatOptions } from "@deepseek-ai/dsh-session-persistence";
+import { Session, SessionEvent, SessionHeader, SessionId, SessionLogOffset } 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>;
+}
+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>;
+  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<SessionHandle>;
+  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<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: readonly SessionEvent[];
+  }>;
+  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;
+};
+/** 一个已创建但未 materialize 的会话（本进程可见，其他进程不可见）。 */
+interface PendingSession {
+  readonly header: SessionHeader;
+  readonly revision: SessionPersistenceRevision;
+  readonly inheritedEventCount: SessionLogOffset;
+  /** 输入空间 cursor（全 delta 批次也推进）。 */
+  readonly cursor: number;
+  /** 是否调用过 append（close 时保留 pending）。 */
+  readonly everAppended: boolean;
+}
+/** 会话级写所有权与 live 路由簿记。 */
+declare class RdbBackendTracker {
+  private readonly name;
+  /** 每个 id 的活跃 write handle；`null` 表示 claim 构造中。 */
+  private readonly writers;
+  private readonly pending;
+  private readonly openHandles;
+  private counter;
+  constructor(name: string);
+  registerCreated(header: SessionHeader, inheritedEventCount: SessionLogOffset): void;
+  /** 更新 pending 的 cursor / everAppended（handle append 后同步）。 */
+  updatePending(id: SessionId, cursor: number, everAppended: boolean): void;
+  claimWrite(id: SessionId): void;
+  releaseClaim(id: SessionId): void;
+  pendingOf(id: SessionId): PendingSession | undefined;
+  hasPending(id: SessionId): boolean;
+  pendingEntries(): IterableIterator<[SessionId, PendingSession]>;
+  materialized(id: SessionId): void;
+  adopt(handle: RdbSessionHandle): RdbSessionHandle;
+  release(handle: RdbSessionHandle, materialized: boolean): void;
+  writerOf(id: SessionId): RdbSessionHandle | undefined;
+  flushAll(): Promise<void>;
+  closeAll(): Promise<void>;
+}
+/** 一个打开会话的存储句柄：read / append / flush / close。 */
+declare class RdbSessionHandle implements SessionHandle {
+  private readonly persistence;
+  readonly id: SessionId;
+  readonly header: SessionHeader;
+  readonly access: SessionAccess;
+  private readonly state;
+  private chain;
+  private closing;
+  /** 稠密 next-seq（输入空间计数，与旧版 coordinator cursor 同语义）。 */
+  private cursor;
+  private materialized;
+  /** live 路由缓冲（上游 seq 事件，drain 时过滤 delta 后重编号稠密）。 */
+  private buffered;
+  private batchTimer;
+  private drainPaused;
+  private draining;
+  /** write open 时发现的 torn tail 起点（append 前先截断）。 */
+  private tornTruncateTo;
+  /** 是否调用过 append（即使全 delta 未落库）——close 时保留 pending。 */
+  private everAppended;
+  constructor(persistence: SessionPersistenceRdb, id: SessionId, header: SessionHeader, access: SessionAccess, state: {
+    cursor: number;
+    materialized: boolean;
+    inheritedEventCount: SessionLogOffset;
+    tornTruncateTo?: number;
+  });
+  get inheritedEventCount(): SessionLogOffset;
+  /** 输入空间 cursor（下一个待落库的上游 seq）。 */
+  get cursorValue(): number;
+  read(offset?: number, length?: number, options?: SessionHandleReadOptions): Promise<SessionHandleReadResult>;
+  append(events: readonly SessionEvent[], options?: SessionHandleAppendOptions): Promise<void>;
+  flush(options?: SessionHandleFlushOptions): Promise<void>;
+  close(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+  /** live 路由：缓冲一个已发布事件（持久化自有副本），并启动批量窗口。 */
+  enqueueLive(event: SessionEvent, reportBackgroundFailure: (error: unknown) => void): void;
+  /** rewind 截断后对齐 handle 的稠密 cursor 与继承前缀（DB 已截断）。 */
+  resetAfterRewind(cursor: number, inheritedEventCount?: number): void;
+  /** 排空 live 缓冲（过滤 delta + 重编号稠密 + append）。 */
+  drainLive(): Promise<void>;
+  private drainBuffered;
+  private enqueueChain;
+  private run;
+  private assertOpen;
+  static readonly LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
+}
+declare class SessionPersistenceRdb extends SessionPersistence {
+  config: Config;
+  static inject: string[];
+  static Config: z<Config>;
+  static readonly settingsNs = "session-rdb";
+  readonly name = "session-rdb";
+  readonly tracker: RdbBackendTracker;
+  private readonly backend;
+  private storeIdentity;
+  private readonly ready;
+  private readonly writeGuard;
+  private readonly reuseEventIds;
+  /** live 路由：session/created 后 handle 就绪前的缓冲。 */
+  private readonly liveBuffers;
+  private readonly liveReady;
+  constructor(ctx: Context, config: Config, injectedBackend?: Backend);
+  private init;
+  create(header: SessionHeader, options?: SessionPersistenceCreateOptions): Promise<SessionHandle>;
+  open(id: SessionId, access: SessionAccess, options?: SessionPersistenceOpenOptions): Promise<SessionHandle>;
+  flush(): Promise<void>;
+  stat(id: SessionId, options?: SessionPersistenceStatOptions): Promise<SessionPersistenceSnapshot | undefined>;
+  list(options?: SessionPersistenceListOptions): Promise<readonly SessionPersistenceSnapshot[]>;
+  /** 导出 artifact（jsonl v2 文本），视图只读不落库。 */
+  readRaw(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    filename: string;
+    content: string;
+  } | undefined>;
+  /** 空会话 materialize（flush 的持久化屏障）。 */
+  materializeEmpty(meta: SessionHeader, inheritedEventCount: SessionLogOffset): Promise<void>;
+  /** 原样 append 落库（handle 已校验 contiguity；torn tail 先截断）。
+   *  与上游 JSONL 一致：ignorable 事件原样存储，不做过滤。写路径校验 v2
+   *  形状（fail-closed）：未知类型（非 ignorable）与非法消息形状拒绝入库；
+   *  旧格式（v0/v1）数据只在读取时经 legacy 转换链动态转换，不落新库。 */
+  appendBatch(meta: SessionHeader, inheritedEventCount: SessionLogOffset, events: readonly SessionEvent[], tornTruncateTo?: number): Promise<boolean>;
+  /** 读取一个会话的稠密 log（含 torn tail 检测，不含修复改写）。 */
+  readLog(id: SessionId, options?: {
+    fromSeq?: number;
+  }, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: SessionEvent[];
+    tornFrom?: number;
+    incarnation: string;
+    revision: number;
+  } | undefined>;
+  listSnapshots(signal?: AbortSignal): Promise<Array<SessionPersistenceSnapshot & {
+    inheritedEventCount: number;
+  }>>;
+  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<SessionPersistenceRevision | undefined>;
+  /** 便捷：create + append + close（测试与导入路径共用）。 */
+  createAndAppend(header: SessionHeader, events: readonly SessionEvent[], inheritedEventCount?: number): Promise<void>;
+  /** 便捷：open(read) + read 全量 + close。 */
+  load(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  /** 便捷：open(write) + append + close。 */
+  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+  /** 便捷：readFrom（稠密后缀）。 */
+  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: readonly SessionEvent[];
+  }>;
+  close(): Promise<void>;
+  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
+  internals(): SessionPersistenceRdbInternals;
+  private rowRevision;
+  private installLiveRouting;
+  /** session/created 后为 live 会话建立 write handle（create 或 adopt）。 */
+  private ensureLiveHandle;
+}
+//#endregion
+export { SessionBranchRdbProvider as a, SessionBranchRdb as i, SessionPersistenceRdb as n, locateTurnEnd as o, SessionPersistenceRdbInternals as r, Config as t };

package/dist/index.d.mts

@@ -1,3 +1,3 @@
-import { n as EPHEMERAL_EVENT_TYPES, s as SCHEMA_VERSION } from "./schema-CFXZURX7.mjs";
-import { a as SessionBranchRdbProvider, i as SessionBranchRdb, n as SessionPersistenceRdb, o as locateTurnEnd, r as SessionPersistenceRdbInternals, t as Config } from "./index-uUvn6gYp.mjs";
-export { Config, EPHEMERAL_EVENT_TYPES, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, SessionPersistenceRdbInternals, locateTurnEnd };
+import { o as SCHEMA_VERSION } from "./schema-COK7-wRV.mjs";
+import { a as SessionBranchRdbProvider, i as SessionBranchRdb, n as SessionPersistenceRdb, o as locateTurnEnd, r as SessionPersistenceRdbInternals, t as Config } from "./index-CgGDHQSK.mjs";
+export { Config, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, SessionPersistenceRdbInternals, locateTurnEnd };