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

package/dist/index.mjs

@@ -1,1631 +1,4 @@
-import { S as WriteGuard, a as EVENT_ENCODING, b as postgresTableDefs, c as eventDimensions, i as DEFAULT_BUSY_TIMEOUT_MS, o as SCHEMA_VERSION, r as createStorageRepository, t as SqliteBackend, x as toPostgresSchema } from "./sqlite-DYExtbLo.mjs";
-import { _ as toJsonlArtifact, c as repairRequestHeaders, d as rowToMeta, f as scanRows, g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow, s as repairReadView } from "./log-DO69NQnn.mjs";
-import { n as SessionBranchRdbProvider, r as locateTurnEnd, t as SessionBranchRdb } from "./branch-Co6xlbi0.mjs";
-import { registerSessionImport } from "./import.mjs";
-import z from "@deepseek-ai/schemastery";
-import { randomUUID } from "node:crypto";
-import { Pool } from "pg";
-import { drizzle } from "drizzle-orm/node-postgres";
-import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionHandleClosedError, SessionPersistence, SessionPersistenceNotFoundError, SessionPersistenceRevision, SessionReadOnlyError, assertContiguous, assertVersion, materializeAppendBatch, materializeCreateHeader, validateStoredEvents } from "@deepseek-ai/dsh-session-persistence";
-import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
-import { sessionFormatLogFilename } from "@deepseek-ai/dsh-session-format";
-import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
-import { and, desc, eq, gte, sql } from "drizzle-orm";
-import { readdirSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { migrate } from "drizzle-orm/node-postgres/migrator";
-import { SessionQueryEngine, SessionQueryError } from "@deepseek-ai/dsh-session-query";
-import { StorageError, storageBackendServiceKey } from "@deepseek-ai/dsh-storage";
-import { Service } from "@deepseek-ai/cordis";
-//#region src/postgres.ts
-/** drizzle-kit 生成的迁移目录（随包根 drizzle/ 发布；src/dist 形态经相对 URL 统一解析）。 */
-const postgresMigrationsDir = fileURLToPath(new URL("../drizzle/postgres/", import.meta.url));
-var PostgresBackend = class PostgresBackend {
-	db;
-	options;
-	kind = "postgres";
-	storeIdentity;
-	tables;
-	/** storages 接管表访问层；句柄在 open()（含迁移）完成后解析。 */
-	storage;
-	opened;
-	resolveOpened;
-	rejectOpened;
-	/** 事务期间的连接覆盖：storage 写方法经它加入当前事务。 */
-	txOverride;
-	constructor(db, options) {
-		this.db = db;
-		this.options = options;
-		this.tables = toPostgresSchema(postgresTableDefs, this.options.schema ?? "public");
-		this.opened = new Promise((resolve, reject) => {
-			this.resolveOpened = resolve;
-			this.rejectOpened = reject;
-		});
-		this.opened.catch(() => {});
-		this.storage = createStorageRepository({
-			db: () => this.opened.then(() => this.txOverride ?? this.db),
-			writeAtomically: (fn) => this.db.transaction(async (tx) => {
-				const previous = this.txOverride;
-				this.txOverride = tx;
-				try {
-					return await fn();
-				} finally {
-					this.txOverride = previous;
-				}
-			}, { isolationLevel: "serializable" }),
-			tables: this.tables
-		});
-	}
-	async open() {
-		try {
-			await this.doOpen();
-			this.resolveOpened();
-		} catch (error) {
-			this.rejectOpened(error);
-			throw error;
-		}
-	}
-	async doOpen() {
-		const schema = this.options.schema ?? "public";
-		const qualifiedMeta = schema === "public" ? "t_schema_meta" : `"${schema}".t_schema_meta`;
-		if ((await this.db.execute(sql`SELECT to_regclass(${qualifiedMeta}) IS NOT NULL AS exists`)).rows[0]?.exists === true) {
-			if (await this.readMeta(this.db, "schema_version") === "2") await this.baselineV2();
-		}
-		await migrate(this.db, { migrationsFolder: postgresMigrationsDir });
-		const storeId = await this.db.transaction(async (tx) => {
-			await tx.insert(this.tables["t_persistence_state"]).values({
-				fSingleton: 1,
-				fStoreId: randomUUID()
-			}).onConflictDoNothing().execute();
-			const id = (await tx.select({ fStoreId: this.tables["t_persistence_state"].fStoreId }).from(this.tables["t_persistence_state"]).where(eq(this.tables["t_persistence_state"].fSingleton, 1)).execute())[0]?.fStoreId;
-			if (id === void 0 || id.length === 0) throw new Error("session database has no valid store identity");
-			return id;
-		});
-		this.storeIdentity = `${this.options.identityBase}:store:${storeId}`;
-	}
-	/** 标记 v2 baseline 已应用（迁移表 v1 结构：id/hash/created_at/name/applied_at）。 */
-	async baselineV2() {
-		const dir = readdirSync(postgresMigrationsDir).find((name) => name.endsWith("_v2_initial"));
-		if (dir === void 0) throw new Error("missing v2 baseline migration in drizzle/postgres");
-		await this.db.execute(sql`
-      CREATE SCHEMA IF NOT EXISTS drizzle
-    `);
-		await this.db.execute(sql`
-      CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
-        id SERIAL PRIMARY KEY,
-        hash text NOT NULL,
-        created_at bigint,
-        name text,
-        applied_at timestamp with time zone DEFAULT now()
-      )
-    `);
-		await this.db.execute(sql`INSERT INTO drizzle.__drizzle_migrations (hash, created_at, name) VALUES ('baseline', 0, ${dir})`);
-	}
-	async close() {
-		await this.options.close();
-	}
-	async getSession(id) {
-		return (await this.db.select().from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
-	}
-	async getEventRows(id, fromSequence) {
-		return (fromSequence === void 0 ? this.eventRows(this.db).where(eq(this.tables["t_session_events"].fSessionId, id)) : this.eventRows(this.db).where(and(eq(this.tables["t_session_events"].fSessionId, id), gte(this.tables["t_session_events"].fSequence, fromSequence)))).orderBy(this.tables["t_session_events"].fSequence).execute();
-	}
-	async listSessions() {
-		return this.db.select().from(this.tables["t_sessions"]).execute();
-	}
-	async transaction(fn) {
-		return this.db.transaction(async (tx) => fn(this.txFor(tx)));
-	}
-	txFor(tx) {
-		return {
-			upsertSession: (storage, incarnation) => this.upsertSession(tx, storage, incarnation),
-			getHead: (id) => this.getHead(tx, id),
-			getSeedLength: (id) => this.getSeedLength(tx, id),
-			updateSeedLength: (id, seedLength) => this.updateSeedLength(tx, id, seedLength),
-			insertEvents: (events) => this.insertEvents(tx, events),
-			insertBridges: (rows) => this.insertBridges(tx, rows),
-			updateHead: (id, headEventId, headSequence) => this.updateHead(tx, id, headEventId, headSequence),
-			bumpRevision: (id) => this.bumpRevision(tx, id),
-			refreshTitle: (id) => this.refreshTitle(tx, id),
-			deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
-			getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence)
-		};
-	}
-	async readMeta(exec, key) {
-		return (await exec.select({ fValue: this.tables["t_schema_meta"].fValue }).from(this.tables["t_schema_meta"]).where(eq(this.tables["t_schema_meta"].fKey, key)).execute())[0]?.fValue;
-	}
-	async upsertSession(exec, storage, incarnation) {
-		await exec.insert(this.tables["t_sessions"]).values(sessionInsertRow(storage, incarnation)).onConflictDoUpdate({
-			target: this.tables["t_sessions"].fSessionId,
-			set: sessionConflictRow(storage)
-		}).execute();
-	}
-	async getHead(exec, id) {
-		const head = (await exec.select({
-			fHeadEventId: this.tables["t_sessions"].fHeadEventId,
-			fHeadSequence: this.tables["t_sessions"].fHeadSequence
-		}).from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
-		/* v8 ignore next -- appendBatch/commitRepair always materialize the row before reading the head */
-		if (head === void 0) throw new Error(`session "${id}" has no materialized row`);
-		return head;
-	}
-	async getSeedLength(exec, id) {
-		const row = (await exec.select({ fSeedLength: this.tables["t_sessions"].fSeedLength }).from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
-		/* v8 ignore next -- rewind always materializes the row before reading the seed length */
-		if (row === void 0) throw new Error(`session "${id}" has no materialized row`);
-		return row.fSeedLength;
-	}
-	async updateSeedLength(exec, id, seedLength) {
-		await exec.update(this.tables["t_sessions"]).set({ fSeedLength: seedLength }).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
-	}
-	static INSERT_BATCH_ROWS = 1e3;
-	async insertEvents(exec, events) {
-		if (events.length === 0) return;
-		for (let i = 0; i < events.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_events"]).values(events.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((event) => ({ ...event }))).execute();
-	}
-	async insertBridges(exec, rows) {
-		if (rows.length === 0) return;
-		for (let i = 0; i < rows.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_session_events"]).values(rows.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((row) => ({ ...row }))).execute();
-	}
-	async updateHead(exec, id, headEventId, headSequence) {
-		await exec.update(this.tables["t_sessions"]).set({
-			fHeadEventId: headEventId,
-			fHeadSequence: headSequence
-		}).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
-	}
-	async bumpRevision(exec, id) {
-		await exec.update(this.tables["t_sessions"]).set({ fRevision: sql`${this.tables["t_sessions"].fRevision} + 1` }).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
-	}
-	/** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
-	async refreshTitle(exec, id) {
-		const bridges = this.tables["t_session_events"];
-		const entities = this.tables["t_events"];
-		const row = (await exec.select({
-			fSequence: bridges.fSequence,
-			fData: entities.fData
-		}).from(bridges).innerJoin(entities, eq(entities.fEventId, bridges.fEventId)).where(and(eq(bridges.fSessionId, id), eq(entities.fType, "session/title"))).orderBy(desc(bridges.fSequence)).limit(1).execute())[0];
-		const title = row === void 0 ? void 0 : titleOfEventData(row.fData);
-		await exec.update(this.tables["t_sessions"]).set({
-			fTitle: title ?? null,
-			fTitleSeq: title === void 0 ? null : row.fSequence
-		}).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
-	}
-	async deleteBridgeTail(exec, id, fromSequence) {
-		await exec.delete(this.tables["t_session_events"]).where(and(eq(this.tables["t_session_events"].fSessionId, id), gte(this.tables["t_session_events"].fSequence, fromSequence))).execute();
-	}
-	async getPrevBridge(exec, id, sequence) {
-		return (await exec.select({
-			fEventId: this.tables["t_session_events"].fEventId,
-			fSequence: this.tables["t_session_events"].fSequence
-		}).from(this.tables["t_session_events"]).where(and(eq(this.tables["t_session_events"].fSessionId, id), eq(this.tables["t_session_events"].fSequence, sequence))).execute())[0];
-	}
-	eventRows(exec) {
-		return exec.select({
-			fEventId: this.tables["t_session_events"].fEventId,
-			fSequence: this.tables["t_session_events"].fSequence,
-			fType: this.tables["t_events"].fType,
-			fKind: this.tables["t_events"].fKind,
-			fRole: this.tables["t_events"].fRole,
-			fName: this.tables["t_events"].fName,
-			fActionId: this.tables["t_events"].fActionId,
-			fCreatedAt: this.tables["t_events"].fCreatedAt,
-			fData: this.tables["t_events"].fData,
-			fSurfaceOp: this.tables["t_session_events"].fSurfaceOp
-		}).from(this.tables["t_session_events"]).innerJoin(this.tables["t_events"], eq(this.tables["t_session_events"].fEventId, this.tables["t_events"].fEventId));
-	}
-};
-//#endregion
-//#region src/session-query.ts
-var SessionQueryRdb = class extends SessionQueryEngine {
-	constructor(ctx, config = {}) {
-		super(ctx, config);
-	}
-	async searchSessions() {
-		throw searchDisabled();
-	}
-	async searchEvents() {
-		throw searchDisabled();
-	}
-};
-function searchDisabled() {
-	return new SessionQueryError("session search is disabled: this deployment serves session queries from the rdb backend without a full-text index", "SESSION_QUERY_SEARCH_DISABLED");
-}
-//#endregion
-//#region src/legacy.ts
-/** 重建 v0/v1/v2 物理 header 记录（RDB 行 → 物理 JSON 对象）。 */
-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
-	};
-}
-/** 重建一条 v0/v1/v2 物理事件记录（桥接行 + 事件行 → 物理 JSON 对象）。 */
-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) } : {}
-	};
-}
-/**
-* 把非当前格式（v0/v1/v2）行转换为当前逻辑事件与 header。
-* @param row - 会话行（f_version < SESSION_FORMAT_VERSION）。
-* @param eventRows - 已扫描保留的桥接行（稠密 seq，torn tail 已剔除）。
-* @returns 当前逻辑 header、继承前缀长度与事件。
-* @throws 迁移链拒绝（格式损坏 / 无法迁移）时原样抛出。
-*/
-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
-	};
-}
-/** 会话行是否携带非当前格式（f_version < SESSION_FORMAT_VERSION）数据。 */
-function isLegacyVersion(version) {
-	return version < SESSION_FORMAT_VERSION;
-}
-/**
-* 迁移链拒绝后，把旧格式行直接当**当前格式**事件视图采用。
-*
-* 旧写入器只在建会话时落一次 header version，之后跟随上游演进继续追加
-* 事件——同一个 log 因此可能是混合世代（v0 时代的行 + 新版本字段），不是
-* 任何单一已发布格式，严格迁移链必然拒绝。这些行的数据形状（消息包装、
-* 类型名）已经是当前格式，只需 header 版本归一到当前、按稠密 seq 读取；
-* 事件数据的补全与 surface 修复由读取视图修复（repairReadView）负责。
-*
-* 调用方须在此之后执行 `validateStoredEvents`：真正属于旧格式的类型
-* （`assistant/chunk` / `compact/*` 等）仍会被 fail-loud 拒绝。
-*
-* @param row - 会话行（f_version < SESSION_FORMAT_VERSION）。
-* @param eventRows - 该会话全部桥接行（按 f_sequence 升序）。
-* @returns 当前格式 header（version 归一到 SESSION_FORMAT_VERSION）、收缩后的
-*   继承前缀长度、稠密事件与可选 torn tail 起点。
-* @throws scanRows 的已提交区损坏错误（seq gap / 不可解析行）。
-*/
-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/storage-takeover/projection-cache.ts
-/**
-* 投影 checkpoint 服务（`ctx.sessionProjectionCache`）的 rdb 实现：替换上游
-* `@deepseek-ai/dsh-session-projection-cache` 插件，公开面与语义逐一对齐
-* （cachedSnapshot / cachedPredecessorTitle / hydratePrepared / write /
-* coldSnapshot，以及三个强制写点与计数/定时节流），持久层换成 session-rdb
-* 的语义专用表 `t_session_projcache` / `t_session_projcache_row`。
-*
-* 读方法是同步签名（session 列表在请求路径上直接调用），所以服务持有启动时
-* 从表中加载的内存 checkpoint 表；写先落库、后更新内存，保证读到的内存值
-* 磁盘上一定存在。
-*/
-/** 服务注册名（与上游插件一致，消费者经 `ctx.get` 解析）。 */
-const SESSION_PROJECTION_CACHE_SERVICE = "sessionProjectionCache";
-/** 只认 title 的前代提示（与上游一致）。 */
-const PREDECESSOR_TITLE_KEY = "title";
-/** rdb 持久化的投影 checkpoint 服务：同步驱动直读介质，异步驱动用写穿镜像支撑同步签名。 */
-var SessionProjectionCacheRdb = class extends Service {
-	static inject = ["sessionProjections", "sessions"];
-	/** 异步驱动（PostgreSQL）的同步读镜像：同步驱动（SQLite）直读介质，这里恒为空。 */
-	records = /* @__PURE__ */ new Map();
-	dirty = /* @__PURE__ */ new Map();
-	/** 读路径是否直读介质（`readProjcacheSync` 存在即同步驱动）。 */
-	directReads;
-	config;
-	repository;
-	ready;
-	/**
-	* 本类按 cordis class plugin 装载（`ctx.plugin(SessionProjectionCacheRdb, options)`）：
-	* `static inject` 等依赖就绪后构造，构造后框架调用 `[Service.init]` 安装写入
-	* 路径——直接 `new` 不会触发 init，写入路径会静默缺失。
-	* @param ctx - 插件上下文（已注入 sessionProjections 与 sessions）。
-	* @param options - 写节流 + storages 接管访问层 + 介质就绪信号。
-	*/
-	constructor(ctx, options) {
-		super(ctx, SESSION_PROJECTION_CACHE_SERVICE);
-		this.config = options;
-		this.repository = options.repository;
-		this.ready = options.ready;
-		this.directReads = options.repository.readProjcacheSync !== void 0;
-	}
-	/**
-	* Install the write path before the async medium wait: listeners must exist
-	* from plugin activation on, or sessions created while the medium settles
-	* lose their mandatory checkpoints. Only the async driver needs the startup
-	* mirror; the sync driver serves every read from the table.
-	*/
-	async [Service.init]() {
-		this.installWritePath();
-		await this.ready;
-		const pruned = await this.repository.pruneStaleProjcache();
-		if (pruned > 0) this.ctx.logger.info(`session projection cache: pruned stale snapshot(s) for ${String(pruned)} session(s)`);
-		if (!this.directReads) for (const entry of await this.repository.loadProjcache()) this.records.set(entry.sessionId, entry);
-	}
-	/** Read one session's stored record: straight from the medium, or from the async mirror. */
-	lookup(id) {
-		if (this.directReads) return this.repository.readProjcacheSync?.(id);
-		return this.records.get(id);
-	}
-	/**
-	* The stored record for one session, accepted only when its bound log
-	* identity matches `expected`. A session id names a slot, not a lifecycle:
-	* a recreated id or a persistence store swapped under a surviving cache
-	* must not let an old record seed state folded from an unrelated log.
-	* @param id - the session whose record is read.
-	* @param expected - the log identity the caller holds (live or stored header).
-	* @returns the identity-matching record, or `undefined` (absent or unrelated).
-	*/
-	recordFor(id, expected) {
-		const record = this.lookup(id);
-		if (record === void 0) return void 0;
-		return identityMatches(record.identity, expected) ? record : void 0;
-	}
-	/**
-	* The cached projection cut for one stored (cold) or live header.
-	* @param meta - authoritative Session header.
-	* @param inheritedEventCount - exact inherited cut completing the lifecycle identity.
-	* @param keys - optional projection keys required by the caller's audience.
-	* @returns the cut (`asOfSeq` = lowest served-row watermark), or `undefined`
-	*   when no usable row exists for this lifecycle.
-	*/
-	cachedSnapshot(meta, inheritedEventCount, keys) {
-		const record = this.recordFor(meta.id, identityOf(meta, inheritedEventCount));
-		const snapshot = record === void 0 ? void 0 : this.viewRecord(record, keys);
-		return this.withDirectTitle(meta.id, keys, snapshot);
-	}
-	/**
-	* 标题是会话数据本身（`t_sessions.f_title`，由 rdb 写路径与 rewind 维护）：
-	* checkpoint 行里没有 title 时直接取该列，列表消费不依赖缓存行是否存在。
-	*/
-	withDirectTitle(id, keys, snapshot) {
-		if (keys !== void 0 && !keys.includes(PREDECESSOR_TITLE_KEY)) return snapshot;
-		if (snapshot?.values[PREDECESSOR_TITLE_KEY] !== void 0) return snapshot;
-		const direct = this.repository.readSessionTitleSync?.(id);
-		if (direct === void 0) return snapshot;
-		const values = {
-			...snapshot?.values,
-			[PREDECESSOR_TITLE_KEY]: direct.title
-		};
-		return {
-			asOfSeq: snapshot === void 0 ? direct.seq : Math.min(snapshot.asOfSeq, direct.seq),
-			values
-		};
-	}
-	/**
-	* Read only a predecessor checkpoint's title as a zero-I/O listing hint.
-	* @param meta - authoritative listed Session header.
-	* @param inheritedEventCount - exact inherited cut completing the lifecycle identity.
-	* @returns a title-only checkpoint view with `asOfSeq: -1`, or `undefined`
-	*   when the record is current, newer, unrelated, missing, or incompatible
-	*   with the title unit.
-	*/
-	cachedPredecessorTitle(meta, inheritedEventCount) {
-		const expected = identityOf(meta, inheritedEventCount);
-		const record = this.lookup(meta.id);
-		if (record === void 0 || !predecessorIdentityMatches(record.identity, expected)) return;
-		const title = this.viewRecord(record, [PREDECESSOR_TITLE_KEY]);
-		return title === void 0 ? void 0 : {
-			...title,
-			asOfSeq: -1
-		};
-	}
-	/** View selected wire rows and bind them to their lowest served watermark. */
-	viewRecord(record, keys) {
-		const values = this.ctx.sessionProjections.viewCheckpoint(record.rows, keys);
-		const servedKeys = Object.keys(values);
-		if (servedKeys.length === 0) return void 0;
-		const firstKey = servedKeys[0];
-		let asOfSeq = record.rows[firstKey].seq;
-		for (const key of servedKeys.slice(1)) {
-			const row = record.rows[key];
-			if (row.seq < asOfSeq) asOfSeq = row.seq;
-		}
-		return {
-			asOfSeq,
-			values
-		};
-	}
-	/**
-	* Hydrate projection cells for an already-prepared Session without another
-	* persistence read. The cache seeds matching rows; the supplied exact log
-	* advances every unit to the observation cut. No checkpoint is written
-	* because the logical observation may contain recovery events not yet durable.
-	* @param session - exact unpublished Session retained by persistence.
-	* @param events - exact logical event prefix represented by the observation.
-	* @returns all projection values at the event cut.
-	*/
-	hydratePrepared(session, events) {
-		const record = this.recordFor(session.id, identityOf(session.header, session.inheritedEventCount));
-		if (record === void 0) return this.ctx.sessionProjections.hydrate(session, {}, events, SessionLogOffset(0));
-		try {
-			return this.ctx.sessionProjections.hydrate(session, record.rows, events, SessionLogOffset(0));
-		} catch {
-			return this.ctx.sessionProjections.hydrate(session, {}, events, SessionLogOffset(0));
-		}
-	}
-	/**
-	* Durably checkpoint one live session NOW (all mandatory points call this).
-	* NOT fail-soft — callers on the fail-soft paths contain it.
-	* @param session - the live session to checkpoint.
-	* @returns resolution after durability.
-	*/
-	async write(session) {
-		const rows = this.ctx.sessionProjections.checkpoint(session);
-		this.markClean(session);
-		if (this.ctx.sessions.get(session.id) === session) await this.ctx.sessions.flush(session);
-		await this.put(session.id, identityOf(session.header, session.inheritedEventCount), rows);
-	}
-	/**
-	* Cold-read one session's projections from its complete log. Each unit is
-	* seeded from the identity-checked cached rows and the refreshed checkpoint
-	* is written back (fail-soft, fire-and-forget).
-	* @param meta - the stored session header (identity witness).
-	* @param inheritedEventCount - exact inherited prefix length for projection initialization and identity.
-	* @param events - the session's complete log, in seq order.
-	* @returns the projection cut at the log end.
-	*/
-	coldSnapshot(meta, inheritedEventCount, events) {
-		const identity = identityOf(meta, inheritedEventCount);
-		const restored = this.ctx.sessionProjections.restore(this.recordFor(meta.id, identity)?.rows ?? {}, events, SessionLogOffset(0), meta, inheritedEventCount);
-		this.put(meta.id, identity, restored.checkpoint).catch((error) => {
-			this.ctx.logger.warn(`session projection cache: cold-read write-back for "${meta.id}" failed (cache stays stale): ${String(error)}`);
-		});
-		return restored.snapshot;
-	}
-	installWritePath() {
-		this.ctx.on("session/event", (session, event) => {
-			if (event.type === "turn/end") {
-				this.flushSoft(session, "turn/end");
-				return;
-			}
-			const state = this.dirty.get(session) ?? {
-				pending: 0,
-				timer: void 0
-			};
-			this.dirty.set(session, state);
-			state.pending += 1;
-			if (state.pending >= this.config.writeEveryEvents) {
-				this.flushSoft(session, "count threshold");
-				return;
-			}
-			state.timer ??= setTimeout(() => {
-				this.flushSoft(session, "interval");
-			}, this.config.writeIntervalMs);
-		});
-		this.ctx.on("session/created", (session) => {
-			this.flushSoft(session, "create");
-		});
-		this.ctx.on("session/disposed", (session) => {
-			this.flushSoft(session, "detach");
-			this.markClean(session);
-			this.dirty.delete(session);
-		});
-		this.ctx.effect(() => () => {
-			for (const state of this.dirty.values()) if (state.timer !== void 0) clearTimeout(state.timer);
-			this.dirty.clear();
-		}, "sessionProjectionCacheRdb.timers");
-	}
-	/** One fail-soft durable checkpoint. */
-	async flushSoft(session, trigger) {
-		try {
-			await this.write(session);
-		} catch (error) {
-			this.ctx.logger.warn(`session projection cache: ${trigger} write for "${session.id}" failed (cache stays stale): ${String(error)}`);
-		}
-	}
-	/** Reset one session's dirty bookkeeping (its checkpoint is being written). */
-	markClean(session) {
-		const state = this.dirty.get(session);
-		if (state === void 0) return;
-		state.pending = 0;
-		if (state.timer !== void 0) {
-			clearTimeout(state.timer);
-			state.timer = void 0;
-		}
-	}
-	/** Replace one session's stored record with its log identity and a detached snapshot of `rows`. */
-	async put(id, identity, rows) {
-		const detached = detachJson(rows);
-		await this.repository.putProjcache(id, detached);
-		if (!this.directReads) this.records.set(id, {
-			sessionId: id,
-			identity,
-			rows: detached
-		});
-	}
-};
-/** Detach one checkpoint from live unit state, refusing non-lossless JSON. */
-function detachJson(rows) {
-	let text;
-	try {
-		text = JSON.stringify(rows);
-	} catch (error) {
-		throw new TypeError(`projection checkpoint is not losslessly JSON-serializable: ${String(error)}`, { cause: error });
-	}
-	if (text === void 0) throw new TypeError("projection checkpoint is not losslessly JSON-serializable");
-	return JSON.parse(text);
-}
-/** Project a header onto the identity fields a record is bound to. */
-function identityOf(header, inheritedEventCount) {
-	const cut = SessionLogOffset(inheritedEventCount);
-	if (!header.isSeeded && cut !== 0) throw new Error("unseeded projection-cache identity inherited event count must be 0");
-	return {
-		formatVersion: header.version,
-		createdAt: header.createdAt,
-		...header.cwd === void 0 ? {} : { cwd: header.cwd },
-		isSeeded: header.isSeeded,
-		inheritedEventCount: cut
-	};
-}
-/**
-* Whether a stored record's bound identity names the caller's lifecycle.
-* An absent format generation cannot prove the fold semantics and never
-* matches. Once the format matches, absent lineage fields (records admitted
-* via compatible versions predate them) read as the unseeded lineage.
-*/
-function identityMatches(stored, expected) {
-	return stored.formatVersion === expected.formatVersion && lifecycleIdentityMatches(stored, expected);
-}
-/** Match one predecessor cache record to the authoritative listed lifecycle. */
-function predecessorIdentityMatches(stored, expected) {
-	return (stored.formatVersion === void 0 || stored.formatVersion < expected.formatVersion) && lifecycleIdentityMatches(stored, expected);
-}
-/** Match the format-independent fields that distinguish one Session lifecycle. */
-function lifecycleIdentityMatches(stored, expected) {
-	return stored.createdAt === expected.createdAt && stored.cwd === expected.cwd && (stored.isSeeded ?? false) === expected.isSeeded && (stored.inheritedEventCount ?? 0) === expected.inheritedEventCount;
-}
-//#endregion
-//#region src/storage-takeover/storage-backend.ts
-/**
-* storages 接管：注册在 storage hub 上的 `rdb` KV 后端。它把 workspace 域
-* （上游 single 布局：一张 `workspaces` 表 + global 单例）映射到 session-rdb
-* 的语义专用表，与事件日志同库同连接；域层（`ctx.storageDomain`）通过
-* `routes` 把 `workspace` 域路由到本后端。
-*
-* 本后端只服务已知域的专用表：未知 unit 名 fail loud，而不是静默落到通用
-* 存储——表结构是显式维护的（见 docs/schema.md）。
-*/
-/** 本后端唯一服务的域：上游 `workspaceDomainSpec`（v2，single 布局）。 */
-const WORKSPACE_UNIT = "workspace";
-const WORKSPACE_TABLE = "workspaces";
-/** 只服务 workspace 域的 KV 后端。 */
-var RdbStorageBackend = class {
-	repository;
-	kv = { open: (descriptor) => this.openUnit(descriptor) };
-	/** 已打开（或打开中）的 unit；重复 open 是调用方 bug。 */
-	open = /* @__PURE__ */ new Map();
-	closed = false;
-	/**
-	* @param repository - storages 接管表访问层（与事件日志同介质）。
-	*/
-	constructor(repository) {
-		this.repository = repository;
-	}
-	async openUnit(descriptor) {
-		if (this.closed) throw new StorageError("closed", "rdb storage backend is closed");
-		if (descriptor.name !== WORKSPACE_UNIT) throw new Error(`rdb storage backend serves only the '${WORKSPACE_UNIT}' domain (requested '${descriptor.name}')`);
-		if (!descriptor.tables.includes(WORKSPACE_TABLE) || descriptor.hasGlobal !== true) throw new Error(`rdb storage backend expects the '${WORKSPACE_UNIT}' domain shape (table '${WORKSPACE_TABLE}' plus a global slot)`);
-		if (descriptor.layout !== void 0 && descriptor.layout !== "single") throw new Error(`rdb storage backend serves only the 'single' layout (domain '${descriptor.name}' declares '${descriptor.layout}')`);
-		if (this.open.has(descriptor.name)) throw new Error(`kv unit '${descriptor.name}' is already open (double-open is a caller bug)`);
-		const unit = new WorkspaceKvUnit(this.repository, descriptor);
-		this.open.set(descriptor.name, unit);
-		try {
-			const stored = await this.repository.readUnitVersion(descriptor.name);
-			if (stored === void 0) await this.repository.insertUnitVersion(descriptor.name, descriptor.version);
-			else if (stored !== descriptor.version) throw new StorageError("version-mismatch", `kv unit '${descriptor.name}' is stamped version ${stored} on the medium, incompatible with descriptor version ${descriptor.version}`);
-		} catch (error) {
-			this.open.delete(descriptor.name);
-			throw error;
-		}
-		unit.onClose(() => {
-			this.open.delete(descriptor.name);
-		});
-		return unit;
-	}
-	/**
-	* Release the backend. New writes are rejected immediately; already-queued
-	* unit writes drain first (upstream backend contract). The medium (the
-	* session database) belongs to the owning session-rdb plugin, so closing
-	* open units here does not close it.
-	* @returns resolution after every open unit drained.
-	*/
-	async close() {
-		this.closed = true;
-		const units = [...this.open.values()];
-		this.open.clear();
-		await Promise.all(units.map((unit) => unit.close()));
-	}
-};
-/** workspace 域的 KV unit：每个原语一条 SQL 语句，值形状与上游记录一致。 */
-var WorkspaceKvUnit = class {
-	repository;
-	descriptor;
-	closed = false;
-	/** 在途写操作：close 先拒绝新写，再 drain 它们（不丢已受理的写）。 */
-	inflight = /* @__PURE__ */ new Set();
-	onClosed;
-	constructor(repository, descriptor) {
-		this.repository = repository;
-		this.descriptor = descriptor;
-	}
-	/** Install the name-release callback after the backend registered this unit. */
-	onClose(release) {
-		this.onClosed = release;
-	}
-	async loadAll() {
-		this.assertOpen();
-		const records = Object.create(null);
-		for (const { id, record } of await this.repository.listWorkspaces()) records[id] = record;
-		const state = await this.repository.readWorkspaceState();
-		return {
-			tables: { [WORKSPACE_TABLE]: records },
-			global: state
-		};
-	}
-	async putRecord(table, key, value) {
-		this.assertOpen();
-		this.assertTable(table);
-		await this.track(this.repository.putWorkspace(key, workspaceRecordOf(value)));
-	}
-	async deleteRecord(table, key) {
-		this.assertOpen();
-		this.assertTable(table);
-		await this.track(this.repository.deleteWorkspace(key));
-	}
-	async setGlobal(value) {
-		this.assertOpen();
-		await this.track(this.repository.writeWorkspaceState(workspaceStateOf(value)));
-	}
-	async close() {
-		if (this.closed) return;
-		this.closed = true;
-		while (this.inflight.size > 0) await Promise.allSettled(this.inflight);
-		this.onClosed?.();
-	}
-	/** Register one accepted write so close can drain it. */
-	async track(operation) {
-		const settled = operation.then(() => void 0, () => void 0);
-		this.inflight.add(settled);
-		try {
-			await operation;
-		} finally {
-			this.inflight.delete(settled);
-		}
-	}
-	assertOpen() {
-		if (this.closed) throw new StorageError("closed", `kv unit '${this.descriptor.name}' is closed`);
-	}
-	assertTable(table) {
-		if (table !== WORKSPACE_TABLE) throw new Error(`unit '${this.descriptor.name}' does not declare table '${table}'`);
-	}
-};
-/** Narrow one opaque KV record to the workspace record the domain shipped. */
-function workspaceRecordOf(value) {
-	const record = value;
-	if (typeof record !== "object" || record === null || typeof record.path !== "string" || typeof record.title !== "string" || !Array.isArray(record.sessionIds) || typeof record.createdAt !== "string" || typeof record.updatedAt !== "string") throw new TypeError("workspace record does not match the stored shape");
-	return {
-		path: record.path,
-		title: record.title,
-		sessionIds: record.sessionIds.map((id) => id),
-		createdAt: record.createdAt,
-		updatedAt: record.updatedAt
-	};
-}
-/** Narrow one opaque KV global to the workspace registry state the domain shipped. */
-function workspaceStateOf(value) {
-	const state = value;
-	if (typeof state !== "object" || state === null || typeof state.initialized !== "boolean" || !Array.isArray(state.workspaceIds) || !Array.isArray(state.archivedSessionIds)) throw new TypeError("workspace registry state does not match the stored shape");
-	return {
-		initialized: state.initialized,
-		workspaceIds: state.workspaceIds.map((id) => id),
-		archivedSessionIds: state.archivedSessionIds.map((id) => id),
-		...state.pendingMutation === void 0 ? {} : { pendingMutation: state.pendingMutation }
-	};
-}
-//#endregion
-//#region src/storage-takeover/index.ts
-/**
-* Install the storages takeover on the session-rdb plugin context.
-* @param ctx - session-rdb plugin context.
-* @param options - repository and projection-cache throttle parameters.
-*/
-function installStorageTakeover(ctx, options) {
-	ctx.inject(["storage"], (storageCtx) => {
-		const backend = new RdbStorageBackend(options.repository);
-		storageCtx.effect(() => {
-			const unregister = storageCtx.storage.backend.register("rdb", backend);
-			return async () => {
-				unregister();
-				await backend.close();
-			};
-		}, "session-rdb.storageBackend");
-		storageCtx.provide(storageBackendServiceKey("rdb"), backend);
-	});
-	ctx.plugin(SessionProjectionCacheRdb, {
-		...options.projectionCache,
-		repository: options.repository,
-		ready: options.ready
-	});
-}
-//#endregion
-//#region src/index.ts
-/** 投影缓存默认写节流（与上游 base 装配的部署值一致）。 */
-const DEFAULT_PROJECTION_WRITE_EVERY_EVENTS = 200;
-const DEFAULT_PROJECTION_WRITE_INTERVAL_MS = 5e3;
-/** 会话级写所有权与 live 路由簿记。 */
-var RdbBackendTracker = class {
-	name;
-	/** 每个 id 的活跃 write handle；`null` 表示 claim 构造中。 */
-	writers = /* @__PURE__ */ new Map();
-	pending = /* @__PURE__ */ new Map();
-	openHandles = /* @__PURE__ */ new Set();
-	counter = 0;
-	constructor(name) {
-		this.name = name;
-	}
-	registerCreated(header, inheritedEventCount) {
-		if (this.writers.has(header.id)) throw new SessionAlreadyExistsError(header.id);
-		this.writers.set(header.id, null);
-		this.pending.set(header.id, {
-			header,
-			revision: SessionPersistenceRevision(`memory:${this.name}:${++this.counter}`),
-			inheritedEventCount,
-			cursor: 0,
-			everAppended: false
-		});
-	}
-	/** 更新 pending 的 cursor / everAppended（handle append 后同步）。 */
-	updatePending(id, cursor, everAppended) {
-		const entry = this.pending.get(id);
-		if (entry === void 0) return;
-		this.pending.set(id, {
-			...entry,
-			cursor,
-			everAppended
-		});
-	}
-	claimWrite(id) {
-		if (this.writers.has(id)) throw new SessionAlreadyOwnedError(id);
-		this.writers.set(id, null);
-	}
-	releaseClaim(id) {
-		this.writers.delete(id);
-	}
-	pendingOf(id) {
-		return this.pending.get(id);
-	}
-	hasPending(id) {
-		return this.pending.has(id);
-	}
-	pendingEntries() {
-		return this.pending.entries();
-	}
-	materialized(id) {
-		this.pending.delete(id);
-	}
-	adopt(handle) {
-		this.openHandles.add(handle);
-		if (handle.access === "write") this.writers.set(handle.id, handle);
-		return handle;
-	}
-	release(handle, materialized) {
-		this.openHandles.delete(handle);
-		if (handle.access !== "write") return;
-		this.writers.delete(handle.id);
-		if (!materialized) this.pending.delete(handle.id);
-	}
-	writerOf(id) {
-		const writer = this.writers.get(id);
-		return writer === null ? void 0 : writer;
-	}
-	async flushAll() {
-		const errors = [];
-		for (const writer of this.writers.values()) {
-			if (writer === null) continue;
-			try {
-				await writer.drainLive();
-				await writer.flush();
-			} catch (error) {
-				if (error instanceof SessionHandleClosedError) continue;
-				errors.push(error);
-			}
-		}
-		if (errors.length > 0) throw new AggregateError(errors, `${this.name} flush failed`);
-	}
-	async closeAll() {
-		const errors = [];
-		for (const handle of this.openHandles) try {
-			await handle.close();
-		} catch (error) {
-			errors.push(error);
-		}
-		if (errors.length > 0) throw new AggregateError(errors, `${this.name} dispose failed`);
-	}
-};
-/** 一个打开会话的存储句柄：read / append / flush / close。 */
-var RdbSessionHandle = class RdbSessionHandle {
-	persistence;
-	id;
-	header;
-	access;
-	state;
-	chain = Promise.resolve();
-	closing;
-	/** 稠密 next-seq（输入空间计数，与旧版 coordinator cursor 同语义）。 */
-	cursor;
-	materialized;
-	/** live 路由缓冲（上游 seq 事件，drain 时过滤 delta 后重编号稠密）。 */
-	buffered = [];
-	batchTimer;
-	drainPaused = false;
-	draining;
-	/** write open 时发现的 torn tail 起点（append 前先截断）。 */
-	tornTruncateTo;
-	/** 是否调用过 append（即使全 delta 未落库）——close 时保留 pending。 */
-	everAppended = false;
-	constructor(persistence, id, header, access, state) {
-		this.persistence = persistence;
-		this.id = id;
-		this.header = header;
-		this.access = access;
-		this.state = state;
-		this.cursor = state.cursor;
-		this.materialized = state.materialized;
-		this.tornTruncateTo = state.tornTruncateTo;
-	}
-	get inheritedEventCount() {
-		return this.state.inheritedEventCount;
-	}
-	/** 输入空间 cursor（下一个待落库的上游 seq）。 */
-	get cursorValue() {
-		return this.cursor;
-	}
-	async read(offset = 0, length = Number.MAX_SAFE_INTEGER, options) {
-		this.assertOpen("read");
-		if (!Number.isSafeInteger(offset) || offset < 0) throw new TypeError(`read offset must be a non-negative safe integer, got ${String(offset)}`);
-		if (!Number.isSafeInteger(length) || length < 0) throw new TypeError(`read length must be a non-negative safe integer, got ${String(length)}`);
-		options?.signal?.throwIfAborted();
-		const log = await this.persistence.readLog(this.id, {}, options?.signal);
-		if (log === void 0) {
-			if (this.persistence.tracker.hasPending(this.id)) return {
-				eventState: "detached",
-				events: []
-			};
-			throw new SessionPersistenceNotFoundError(this.id);
-		}
-		repairReadView(log.events);
-		return {
-			eventState: "detached",
-			events: log.events.slice(offset, offset + length)
-		};
-	}
-	async append(events, options) {
-		this.assertOpen("append");
-		const batch = materializeAppendBatch(events);
-		return this.run("append", async () => {
-			options?.signal?.throwIfAborted();
-			if (this.access !== "write") throw new SessionReadOnlyError(this.id, "append");
-			if (batch.length === 0) return;
-			this.everAppended = true;
-			assertContiguous(this.id, batch, this.cursor);
-			await this.persistence.appendBatch(this.header, this.state.inheritedEventCount, batch, this.tornTruncateTo);
-			this.tornTruncateTo = void 0;
-			this.cursor += batch.length;
-			this.materialized = true;
-			this.persistence.tracker.updatePending(this.id, this.cursor, true);
-		});
-	}
-	async flush(options) {
-		return this.run("flush", async () => {
-			options?.signal?.throwIfAborted();
-			if (this.access !== "write") throw new SessionReadOnlyError(this.id, "flush");
-			if (this.materialized) return;
-			await this.persistence.materializeEmpty(this.header, this.state.inheritedEventCount);
-			this.materialized = true;
-		});
-	}
-	close() {
-		return this.closing ??= (async () => {
-			let drainFailure;
-			for (;;) {
-				try {
-					await this.drainLive();
-				} catch (error) {
-					drainFailure = error;
-					break;
-				}
-				await this.chain;
-				if (this.buffered.length === 0) break;
-			}
-			await this.chain;
-			const failures = [];
-			if (drainFailure !== void 0) failures.push(drainFailure instanceof Error ? drainFailure : new Error(JSON.stringify(drainFailure)));
-			this.persistence.tracker.release(this, this.materialized || this.everAppended);
-			if (failures.length > 1) throw new AggregateError(failures, `session "${this.id}": close failed to drain`);
-			if (failures[0] !== void 0) throw failures[0];
-		})();
-	}
-	[Symbol.asyncDispose]() {
-		return this.close();
-	}
-	/** live 路由：缓冲一个已发布事件（持久化自有副本），并启动批量窗口。 */
-	enqueueLive(event, reportBackgroundFailure) {
-		this.buffered.push(structuredClone(event));
-		if (this.batchTimer !== void 0 || this.drainPaused) return;
-		this.batchTimer = setTimeout(() => {
-			this.batchTimer = void 0;
-			this.drainLive().catch(reportBackgroundFailure);
-		}, RdbSessionHandle.LIVE_WRITE_BATCH_MAX_DELAY_MS);
-	}
-	/** rewind 截断后对齐 handle 的稠密 cursor 与继承前缀（DB 已截断）。 */
-	resetAfterRewind(cursor, inheritedEventCount) {
-		this.cursor = cursor;
-		if (inheritedEventCount !== void 0) this.state.inheritedEventCount = SessionLogOffset(inheritedEventCount);
-	}
-	/** 排空 live 缓冲（过滤 delta + 重编号稠密 + append）。 */
-	drainLive() {
-		return this.draining ??= this.drainBuffered().finally(() => {
-			this.draining = void 0;
-		});
-	}
-	async drainBuffered() {
-		if (this.batchTimer !== void 0) {
-			clearTimeout(this.batchTimer);
-			this.batchTimer = void 0;
-		}
-		this.drainPaused = false;
-		while (this.buffered.length > 0) await this.enqueueChain(async () => {
-			const batch = this.buffered.splice(0);
-			try {
-				const fresh = batch.filter((event) => event.seq >= this.cursor);
-				if (fresh.length === 0) return;
-				for (const [index, event] of fresh.entries()) if (event.seq !== this.cursor + index) throw new Error(`append seq mismatch for "${this.id}": expected ${this.cursor + index} at index ${index}, got ${event.seq}`);
-				await this.persistence.appendBatch(this.header, this.state.inheritedEventCount, fresh, this.tornTruncateTo);
-				this.tornTruncateTo = void 0;
-				this.cursor += fresh.length;
-				this.materialized = true;
-			} catch (error) {
-				this.buffered = batch.concat(this.buffered);
-				this.drainPaused = true;
-				throw error;
-			}
-		});
-	}
-	enqueueChain(op) {
-		const next = this.chain.then(op);
-		this.chain = next.catch(() => {});
-		return next;
-	}
-	async run(operation, op) {
-		this.assertOpen(operation);
-		return this.enqueueChain(async () => {
-			this.assertOpen(operation);
-			return op();
-		});
-	}
-	assertOpen(operation) {
-		if (this.closing !== void 0) throw new SessionHandleClosedError(this.id, operation);
-	}
-	static LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
-};
-var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersistence {
-	config;
-	static inject = ["sessions", "settings"];
-	static Config = z.union([z.object({
-		type: z.const("sqlite"),
-		path: z.string().required(),
-		journalMode: z.union([
-			"wal",
-			"delete",
-			"truncate",
-			"persist"
-		]).default("wal"),
-		busyTimeout: z.number().step(1).min(0).default(DEFAULT_BUSY_TIMEOUT_MS),
-		projectionCache: z.object({
-			writeEveryEvents: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS),
-			writeIntervalMs: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS)
-		}).default({
-			writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
-			writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
-		})
-	}), z.object({
-		type: z.const("postgres"),
-		connectionString: z.string().required(),
-		schema: z.string().default("public"),
-		projectionCache: z.object({
-			writeEveryEvents: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS),
-			writeIntervalMs: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS)
-		}).default({
-			writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
-			writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
-		})
-	})]);
-	static settingsNs = "session-rdb";
-	name = "session-rdb";
-	tracker = new RdbBackendTracker(this.name);
-	backend;
-	storeIdentity;
-	ready;
-	writeGuard = new WriteGuard();
-	reuseEventIds = /* @__PURE__ */ new Map();
-	/** live 路由：session/created 后 handle 就绪前的缓冲。 */
-	liveBuffers = /* @__PURE__ */ new Map();
-	liveReady = /* @__PURE__ */ new Map();
-	constructor(ctx, config, injectedBackend) {
-		let resolved = config;
-		const settings = ctx.reflect.get("settings");
-		if (settings !== void 0) {
-			const scope = settings.register(SessionPersistenceRdb.settingsNs, SessionPersistenceRdb.Config, { base: config });
-			resolved = scope.get();
-			scope.watch(() => {
-				ctx.logger.warn("session-rdb: settings changed; restart to apply the new configuration");
-			});
-		}
-		super(ctx);
-		this.config = config;
-		this.config = resolved;
-		this.backend = injectedBackend ?? createBackend(resolved);
-		this.ready = this.init();
-		this.installLiveRouting(ctx);
-		new SessionBranchRdb(this.ctx);
-		this.ctx.plugin(SessionQueryRdb, {});
-		registerSessionImport(this.ctx, this);
-		installStorageTakeover(this.ctx, {
-			repository: this.backend.storage,
-			ready: this.ready,
-			projectionCache: {
-				writeEveryEvents: this.config.projectionCache?.writeEveryEvents ?? DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
-				writeIntervalMs: this.config.projectionCache?.writeIntervalMs ?? DEFAULT_PROJECTION_WRITE_INTERVAL_MS
-			}
-		});
-	}
-	async init() {
-		await this.backend.open();
-		this.storeIdentity = this.backend.storeIdentity;
-	}
-	async create(header, options) {
-		options?.signal?.throwIfAborted();
-		const snapshot = materializeCreateHeader(header);
-		if (snapshot.isSeeded && options?.inheritedEventCount === void 0) throw new TypeError("seeded session metadata requires an inherited event count");
-		const inheritedEventCount = SessionLogOffset(options?.inheritedEventCount ?? 0);
-		if (!snapshot.isSeeded && inheritedEventCount !== 0) throw new TypeError("unseeded session metadata inherited event count must be 0");
-		await this.ready;
-		options?.signal?.throwIfAborted();
-		if (this.tracker.hasPending(snapshot.id) || await this.backend.getSession(snapshot.id) !== void 0) throw new SessionAlreadyExistsError(snapshot.id);
-		this.tracker.registerCreated(snapshot, inheritedEventCount);
-		return this.tracker.adopt(new RdbSessionHandle(this, snapshot.id, snapshot, "write", {
-			cursor: 0,
-			materialized: false,
-			inheritedEventCount
-		}));
-	}
-	async open(id, access, options) {
-		options?.signal?.throwIfAborted();
-		await this.ready;
-		options?.signal?.throwIfAborted();
-		const pending = this.tracker.pendingOf(id);
-		if (access === "read") {
-			if (pending !== void 0) return this.tracker.adopt(new RdbSessionHandle(this, id, pending.header, "read", {
-				cursor: 0,
-				materialized: false,
-				inheritedEventCount: pending.inheritedEventCount
-			}));
-			const log = await this.readLog(id, {}, options?.signal);
-			if (log === void 0) throw new SessionPersistenceNotFoundError(id);
-			repairReadView(log.events);
-			validateStoredEvents(log.meta, log.events);
-			return this.tracker.adopt(new RdbSessionHandle(this, id, log.meta, "read", {
-				cursor: log.events.length,
-				materialized: true,
-				inheritedEventCount: SessionLogOffset(log.inheritedEventCount)
-			}));
-		}
-		this.tracker.claimWrite(id);
-		try {
-			if (pending !== void 0) return this.tracker.adopt(new RdbSessionHandle(this, id, pending.header, "write", {
-				cursor: pending.cursor,
-				materialized: false,
-				inheritedEventCount: pending.inheritedEventCount
-			}));
-			const log = await this.readLog(id, {}, options?.signal);
-			if (log === void 0) throw new SessionPersistenceNotFoundError(id);
-			repairReadView(log.events);
-			validateStoredEvents(log.meta, log.events);
-			if (log.migrated && log.events.length !== log.storedCount) await this.rewriteMigratedLog(id, log);
-			this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
-			return this.tracker.adopt(new RdbSessionHandle(this, id, log.meta, "write", {
-				cursor: log.events.length,
-				materialized: true,
-				inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
-				...log.tornFrom !== void 0 ? { tornTruncateTo: log.tornFrom } : {}
-			}));
-		} catch (error) {
-			this.tracker.releaseClaim(id);
-			throw error;
-		}
-	}
-	flush() {
-		return this.tracker.flushAll();
-	}
-	async stat(id, options) {
-		options?.signal?.throwIfAborted();
-		await this.ready;
-		options?.signal?.throwIfAborted();
-		const pending = this.tracker.pendingOf(id);
-		if (pending !== void 0) return {
-			header: pending.header,
-			revision: pending.revision
-		};
-		const row = await this.backend.getSession(id);
-		if (row === void 0) return void 0;
-		return {
-			header: rowToMeta(row),
-			revision: this.rowRevision(row)
-		};
-	}
-	async list(options) {
-		const signal = options?.signal;
-		const snapshots = [];
-		const listed = /* @__PURE__ */ new Set();
-		for (const [id, pending] of this.tracker.pendingEntries()) {
-			snapshots.push({
-				header: pending.header,
-				revision: pending.revision
-			});
-			listed.add(id);
-		}
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const rows = await this.backend.listSessions();
-		signal?.throwIfAborted();
-		for (const row of rows) {
-			if (listed.has(row.fSessionId)) continue;
-			snapshots.push({
-				header: rowToMeta(row),
-				revision: this.rowRevision(row)
-			});
-		}
-		return snapshots;
-	}
-	/** 导出当前世代的 jsonl artifact，视图只读不落库。 */
-	async readRaw(id, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const log = await this.readLog(id, {}, signal);
-		if (log === void 0) return void 0;
-		repairReadView(log.events);
-		const inheritedEventCount = Math.min(log.inheritedEventCount, log.events.length);
-		return {
-			meta: log.meta,
-			inheritedEventCount,
-			filename: sessionFormatLogFilename(SESSION_FORMAT_VERSION),
-			content: toJsonlArtifact(log.meta, inheritedEventCount, log.events)
-		};
-	}
-	/** 空会话 materialize（flush 的持久化屏障）。 */
-	async materializeEmpty(meta, inheritedEventCount) {
-		await this.ready;
-		await this.backend.transaction(async (tx) => {
-			await tx.upsertSession({
-				meta,
-				inheritedEventCount
-			}, randomUUID());
-			await tx.bumpRevision(meta.id);
-		});
-		this.tracker.materialized(meta.id);
-		this.writeGuard.confirmHead(meta.id, -1);
-	}
-	/** 原样 append 落库（handle 已校验 contiguity；torn tail 先截断）。
-	*  与上游 JSONL 一致：ignorable 事件原样存储，不做过滤。写路径校验当前
-	*  格式形状（fail-closed）：未知类型（非 ignorable）与非法消息形状拒绝入库；
-	*  非当前格式（v0/v1/v2）数据只在读取时经 legacy 转换链动态转换，不落新库。 */
-	async appendBatch(meta, inheritedEventCount, events, tornTruncateTo) {
-		await this.ready;
-		if (events.length === 0) return false;
-		validateStoredEvents(meta, [...events]);
-		const reuse = this.reuseEventIds.get(meta.id);
-		if (reuse !== void 0) this.reuseEventIds.delete(meta.id);
-		let confirmedHead = -1;
-		await this.backend.transaction(async (tx) => {
-			if (tornTruncateTo !== void 0) {
-				await tx.deleteBridgeTail(meta.id, tornTruncateTo);
-				const prev = await tx.getPrevBridge(meta.id, tornTruncateTo - 1);
-				if (prev === void 0) await tx.updateHead(meta.id, "", -1);
-				else await tx.updateHead(meta.id, prev.fEventId, prev.fSequence);
-			}
-			await tx.upsertSession({
-				meta,
-				inheritedEventCount
-			}, randomUUID());
-			const head = await tx.getHead(meta.id);
-			this.writeGuard.assertNoConcurrentWriter(meta.id, head.fHeadSequence);
-			const { headEventId, headSequence } = await appendEventTail(tx, meta, events, {
-				parentId: head.fHeadEventId,
-				nextSeq: head.fHeadSequence + 1
-			}, reuse);
-			await tx.updateHead(meta.id, headEventId, headSequence);
-			await tx.bumpRevision(meta.id);
-			confirmedHead = headSequence;
-		});
-		this.writeGuard.confirmHead(meta.id, confirmedHead);
-		this.tracker.materialized(meta.id);
-		return true;
-	}
-	/** 读取一个会话的稠密 log（含 torn tail 检测，不含修复改写）。 */
-	async readLog(id, options = {}, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const row = await this.backend.getSession(id);
-		if (row === void 0) return void 0;
-		const meta = rowToMeta(row);
-		const eventRows = options.fromSeq === void 0 ? await this.backend.getEventRows(id) : await this.backend.getEventRows(id, options.fromSeq);
-		signal?.throwIfAborted();
-		if (isLegacyVersion(row.fVersion)) try {
-			const converted = convertLegacyRows(row, eventRows);
-			return {
-				meta: converted.meta,
-				inheritedEventCount: converted.inheritedEventCount,
-				events: converted.events,
-				incarnation: row.fIncarnation,
-				revision: row.fRevision,
-				storedCount: eventRows.length,
-				migrated: true
-			};
-		} catch (error) {
-			this.ctx.logger.warn(`session-rdb: session "${id}" is not a single released format; adopting its stored rows as current-format data (${error instanceof Error ? error.message : String(error)})`);
-			const adopted = adoptLegacyRows(row, eventRows);
-			return {
-				meta: adopted.meta,
-				inheritedEventCount: adopted.inheritedEventCount,
-				events: adopted.events,
-				incarnation: row.fIncarnation,
-				revision: row.fRevision,
-				storedCount: eventRows.length,
-				migrated: false,
-				...adopted.tornFrom !== void 0 ? { tornFrom: adopted.tornFrom } : {}
-			};
-		}
-		const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0);
-		return {
-			meta,
-			inheritedEventCount: row.fSeedLength ?? 0,
-			events: preserved,
-			incarnation: row.fIncarnation,
-			revision: row.fRevision,
-			storedCount: eventRows.length,
-			migrated: false,
-			...tornFrom !== void 0 ? { tornFrom } : {}
-		};
-	}
-	/**
-	* 把迁移链读出的当前格式视图整体落库（非当前格式会话写打开时的一次性迁移）。
-	*
-	* 迁移链会生成/合并事件（end-seed / attempt / chunk 合并），事件 seq 空间
-	* 与存储桥接行数不再相等；写路径以存储 head 为锚点重编号，二者不一致会让
-	* append 撞上已有行。这里在同一事务内删光本会话桥接行、按迁移视图重建
-	* （新事件行，完整信封），并更新 head 与 revision；旧事件行保留（可能被
-	* fork 子会话引用，孤儿由惰性 GC 处理）。
-	*/
-	async rewriteMigratedLog(id, log) {
-		await this.backend.transaction(async (tx) => {
-			await tx.deleteBridgeTail(id, 0);
-			await tx.upsertSession({
-				meta: log.meta,
-				inheritedEventCount: SessionLogOffset(log.inheritedEventCount)
-			}, randomUUID());
-			const { headEventId, headSequence } = await appendEventTail(tx, log.meta, log.events, {
-				parentId: "",
-				nextSeq: 0
-			});
-			await tx.updateHead(id, headEventId, headSequence);
-			await tx.bumpRevision(id);
-		});
-	}
-	async listSnapshots(signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const snapshots = [];
-		const listed = /* @__PURE__ */ new Set();
-		for (const [id, pending] of this.tracker.pendingEntries()) {
-			snapshots.push({
-				header: pending.header,
-				revision: pending.revision,
-				inheritedEventCount: pending.inheritedEventCount
-			});
-			listed.add(id);
-		}
-		const rows = await this.backend.listSessions();
-		signal?.throwIfAborted();
-		for (const row of rows) {
-			if (listed.has(row.fSessionId)) continue;
-			snapshots.push({
-				header: rowToMeta(row),
-				revision: this.rowRevision(row),
-				inheritedEventCount: row.fSeedLength ?? 0
-			});
-		}
-		return snapshots;
-	}
-	async readStoredRevision(id, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const row = await this.backend.getSession(id);
-		if (row === void 0) return void 0;
-		return this.rowRevision(row);
-	}
-	/** 便捷：create + append + close（测试与导入路径共用）。 */
-	async createAndAppend(header, events, inheritedEventCount) {
-		const handle = await this.create(header, inheritedEventCount === void 0 ? void 0 : { inheritedEventCount: SessionLogOffset(inheritedEventCount) });
-		try {
-			if (events.length > 0) await handle.append(events);
-		} finally {
-			await handle.close();
-		}
-	}
-	/** 便捷：open(read) + read 全量 + close。 */
-	async load(id, signal) {
-		const handle = await this.open(id, "read", signal === void 0 ? void 0 : { signal });
-		try {
-			const { events } = await handle.read(0, void 0, signal === void 0 ? void 0 : { signal });
-			const row = await this.backend.getSession(id);
-			if (row === void 0) throw new SessionPersistenceNotFoundError(id);
-			if (isLegacyVersion(row.fVersion)) return {
-				meta: handle.header,
-				inheritedEventCount: handle.inheritedEventCount,
-				events
-			};
-			return {
-				meta: rowToMeta(row),
-				inheritedEventCount: SessionLogOffset(row.fSeedLength ?? 0),
-				events
-			};
-		} finally {
-			await handle.close();
-		}
-	}
-	/** 便捷：open(write) + append + close。 */
-	async append(id, events) {
-		const handle = await this.open(id, "write");
-		try {
-			await handle.append(events);
-		} finally {
-			await handle.close();
-		}
-	}
-	/** 便捷：readFrom（稠密后缀）。 */
-	async readFrom(id, fromSeq, signal) {
-		const log = await this.readLog(id, { fromSeq }, signal);
-		if (log === void 0) throw new SessionPersistenceNotFoundError(id);
-		return {
-			meta: log.meta,
-			inheritedEventCount: log.inheritedEventCount,
-			events: log.events
-		};
-	}
-	async close() {
-		await this.ready;
-		await this.backend.close();
-	}
-	registerReuseEventIds(childId, map) {
-		this.reuseEventIds.set(childId, new Map(map));
-	}
-	internals() {
-		return {
-			backend: this.backend,
-			writeGuard: this.writeGuard,
-			create: (meta, inheritedEventCount) => this.create(meta, inheritedEventCount === void 0 ? void 0 : { inheritedEventCount: SessionLogOffset(inheritedEventCount) }),
-			append: (id, events) => this.append(id, events),
-			load: (id) => this.load(id),
-			inspect: (id, signal) => this.load(id, signal),
-			readFrom: (id, fromSeq, signal) => this.readFrom(id, fromSeq, signal),
-			listSnapshots: (signal) => this.listSnapshots(signal),
-			readStoredRevision: (id, signal) => this.readStoredRevision(id, signal),
-			registerReuseEventIds: (childId, map) => this.registerReuseEventIds(childId, map)
-		};
-	}
-	rowRevision(row) {
-		return SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`);
-	}
-	installLiveRouting(ctx) {
-		ctx.on("session/created", (session) => {
-			this.liveBuffers.set(session.id, []);
-			const ready = this.ensureLiveHandle(session);
-			this.liveReady.set(session.id, ready);
-			ready.catch((error) => {
-				ctx.logger.warn(`session-rdb: live session "${session.id}" persistence init failed: ${String(error)}`);
-			});
-		});
-		for (const session of ctx.sessions.list()) {
-			this.liveBuffers.set(session.id, []);
-			const ready = this.ensureLiveHandle(session);
-			this.liveReady.set(session.id, ready);
-			ready.catch((error) => {
-				ctx.logger.warn(`session-rdb: live session "${session.id}" persistence init failed: ${String(error)}`);
-			});
-		}
-		ctx.on("session/event", (session, event) => {
-			const handle = this.tracker.writerOf(session.id);
-			if (handle !== void 0) {
-				handle.enqueueLive(event, (error) => {
-					ctx.logger.warn(`session-rdb: background write for session "${session.id}" failed (buffered events retained): ${String(error)}`);
-				});
-				return;
-			}
-			this.liveBuffers.get(session.id)?.push(structuredClone(event));
-		});
-		ctx.on("session/flush", (session) => {
-			const handle = this.tracker.writerOf(session.id);
-			if (handle === void 0) {
-				const ready = this.liveReady.get(session.id);
-				if (ready === void 0) return void 0;
-				return ready.then(() => {
-					const settled = this.tracker.writerOf(session.id);
-					if (settled === void 0) return void 0;
-					return settled.drainLive().then(() => settled.flush());
-				});
-			}
-			return handle.drainLive().then(() => handle.flush());
-		});
-		ctx.on("session/disposed", (session) => {
-			const ready = this.liveReady.get(session.id);
-			this.liveBuffers.delete(session.id);
-			this.liveReady.delete(session.id);
-			const closeHandle = () => {
-				const handle = this.tracker.writerOf(session.id);
-				if (handle === void 0) return;
-				handle.close().catch((error) => {
-					ctx.logger.warn(`session-rdb: final drain for session "${session.id}" failed: ${String(error)}`);
-				});
-			};
-			if (ready === void 0) {
-				closeHandle();
-				return;
-			}
-			ready.then(closeHandle, closeHandle);
-		});
-		ctx.effect(() => async () => {
-			await Promise.allSettled(this.liveReady.values());
-			await this.tracker.closeAll();
-			await this.close();
-		}, `${this.name} open handles`);
-	}
-	/** session/created 后为 live 会话建立 write handle（create 或 adopt）。 */
-	async ensureLiveHandle(session) {
-		const id = session.header.id;
-		if (this.tracker.writerOf(id) !== void 0) return;
-		await this.ready;
-		const stored = await this.readLog(id, {});
-		let handle;
-		if (stored === void 0) {
-			handle = await this.create(session.header, { inheritedEventCount: session.inheritedEventCount });
-			const seed = session.snapshotEvents();
-			if (seed.length > 0) await handle.append(seed);
-		} else {
-			if (stored.meta.cwd !== session.header.cwd) throw new Error(`session "${id}" is already persisted at a different cwd (persisted: ${String(stored.meta.cwd)}, live: ${String(session.header.cwd)}) (id collision)`);
-			if (stored.inheritedEventCount !== session.inheritedEventCount) throw new Error(`session "${id}" is already persisted with a different inherited event count (id collision)`);
-			assertVersion(stored.meta);
-			repairReadView(stored.events);
-			const seed = session.snapshotEvents();
-			if (!seedCoversPrefix(seed, stored.events)) throw new Error(`session "${id}" already has a persisted log on disk that does not match this live session (id collision)`);
-			handle = await this.open(id, "write");
-			const suffix = seed.slice(stored.events.length);
-			if (suffix.length > 0) await handle.append(suffix);
-		}
-		const buffered = this.liveBuffers.get(id);
-		if (buffered !== void 0 && buffered.length > 0) {
-			this.liveBuffers.set(id, []);
-			for (const event of buffered) handle.enqueueLive(event, () => {});
-		}
-	}
-};
-function seedCoversPrefix(seed, prefix) {
-	return prefix.length <= seed.length && prefix.every((event, index) => {
-		const seedEvent = seed[index];
-		return seedEvent !== void 0 && JSON.stringify(seedEvent) === JSON.stringify(event);
-	});
-}
-function createBackend(config) {
-	if (config.type === "sqlite") return new SqliteBackend({
-		path: config.path,
-		journalMode: config.journalMode ?? "wal",
-		busyTimeout: config.busyTimeout ?? 5e3
-	});
-	const pool = new Pool({ connectionString: config.connectionString });
-	pool.on("error", () => {});
-	return new PostgresBackend(drizzle({ client: pool }), {
-		identityBase: [
-			"postgres",
-			pool.options.host ?? "localhost",
-			String(pool.options.port ?? 5432),
-			pool.options.database ?? "",
-			config.schema ?? "public"
-		].join(":"),
-		schema: config.schema ?? "public",
-		close: () => pool.end()
-	});
-}
-async function appendEventTail(tx, meta, events, anchor, reuse) {
-	let parentId = anchor.parentId;
-	let nextSeq = anchor.nextSeq;
-	const eventRows = [];
-	const bridgeRows = [];
-	for (const event of events) {
-		const reusedId = reuse?.get(event.seq);
-		const eventId = reusedId ?? randomUUID();
-		if (reusedId === void 0) {
-			const { kind, role, name, actionId } = eventDimensions(event);
-			const { data, surfaceOp: _surfaceOp, sourceEventSeqs: _sourceEventSeqs, ...envelope } = event;
-			eventRows.push({
-				fEventId: eventId,
-				fParentId: parentId,
-				fType: event.type,
-				fKind: kind,
-				fRole: role,
-				fName: name,
-				fActionId: actionId,
-				fEncoding: EVENT_ENCODING,
-				fData: JSON.stringify({
-					...envelope,
-					data
-				}),
-				fCreatedAt: event.time
-			});
-		}
-		const surfaceOp = event.surfaceOp === void 0 ? null : JSON.stringify(event.surfaceOp);
-		bridgeRows.push({
-			fSessionId: meta.id,
-			fEventId: eventId,
-			fSequence: nextSeq,
-			fSurfaceOp: surfaceOp
-		});
-		parentId = eventId;
-		nextSeq++;
-	}
-	if (eventRows.length > 0) await tx.insertEvents(eventRows);
-	await tx.insertBridges(bridgeRows);
-	if (events.some((event) => event.type === "session/title")) await tx.refreshTitle(meta.id);
-	return {
-		headEventId: parentId,
-		headSequence: nextSeq - 1
-	};
-}
-//#endregion
-export { SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, locateTurnEnd };
+import { o as SCHEMA_VERSION } from "./sqlite-fpvm5Dzs.mjs";
+import { n as SessionPersistenceRdb, t as SessionDeletionError } from "./src-CWTWV7vx.mjs";
+import { n as SessionBranchRdbProvider, r as locateTurnEnd, t as SessionBranchRdb } from "./branch-5JzX9rUq.mjs";
+export { SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionDeletionError, SessionPersistenceRdb, SessionPersistenceRdb as default, locateTurnEnd };