@morlay/session-rdb 0.0.11 → 0.0.12

package/lib/index.mjs

@@ -1,2176 +0,0 @@
-import "@deepseek-ai/cordis";
-import z from "@deepseek-ai/schemastery";
-import { settingsNamespace } from "@deepseek-ai/dsh-settings";
-import { randomUUID } from "node:crypto";
-import { Pool } from "pg";
-import { drizzle } from "drizzle-orm/node-postgres";
-import { PersistenceCoordinator, SessionPersistence, SessionPersistenceRevision } from "@deepseek-ai/dsh-session-persistence";
-import { and, desc, eq, gte, inArray, sql } from "drizzle-orm";
-import { check, index, integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
-import { bigint, check as check$1, index as index$1, integer as integer$1, pgTable, serial, text as text$1, unique as unique$1 } from "drizzle-orm/pg-core";
-import { statSync } from "node:fs";
-import { mkdir, open } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { drizzle as drizzle$1 } from "drizzle-orm/node-sqlite";
-import { SESSION_FORMAT_VERSION } from "@deepseek-ai/dsh-session";
-import { SessionBranch, SessionBranchError, balanceRewindPrefix, buildTimeline } from "@morlay/session-branch";
-//#region src/log.ts
-/**
-* Reconstruct the {@link SessionHeader} from a `t_sessions` row.
-* @param row - the `t_sessions` table row.
-* @returns the header, `NULL` columns mapped to omitted optional fields.
-*/
-function rowToMeta(row) {
-	if (!Number.isSafeInteger(row.fCreatedAt) || row.fCreatedAt < 0) throw new Error("stored session createdAt must be a non-negative safe integer");
-	return {
-		version: row.fVersion,
-		id: row.fSessionId,
-		createdAt: row.fCreatedAt,
-		...row.fCwd !== null ? { cwd: row.fCwd } : {},
-		...row.fParentSession !== null ? { parentSession: row.fParentSession } : {},
-		...row.fSeedLength !== null ? { seedLength: row.fSeedLength } : {},
-		...row.fOrigin !== null ? { origin: row.fOrigin } : {},
-		...row.fDelegationDepth === null ? {} : { delegationDepth: row.fDelegationDepth }
-	};
-}
-/**
-* `t_sessions` 的 INSERT 列值：`SessionHeader` 的持久化字段 + 初始 head 游标
-* （空事件 id、seq -1）+ materialization identity（`f_incarnation`）+ revision 0。
-* 方言无关的纯映射——SQLite 与 PostgreSQL 后端的 `upsertSession` 共用，列名
-* 与 `src/entities/sessions.ts` 对齐（改一处即两方言生效）。`f_id` serial 由
-* 数据库生成，不在映射内。
-*/
-function sessionInsertRow(meta, incarnation) {
-	return {
-		fSessionId: meta.id,
-		fHeadEventId: "",
-		fHeadSequence: -1,
-		fVersion: meta.version,
-		fCreatedAt: meta.createdAt,
-		fCwd: meta.cwd ?? null,
-		fParentSession: meta.parentSession ?? null,
-		fSeedLength: meta.seedLength ?? null,
-		fOrigin: meta.origin ?? null,
-		fDelegationDepth: meta.delegationDepth ?? null,
-		fIncarnation: incarnation,
-		fRevision: 0
-	};
-}
-/**
-* `t_sessions` 的 ON CONFLICT 更新列值：只刷新 header 列，保留 head 游标
-* （`f_head_event_id`/`f_head_sequence`）与 materialization identity
-* （`f_incarnation`/`f_revision`）。方言无关，两后端共用（见
-* {@link sessionInsertRow}）。
-*/
-function sessionConflictRow(meta) {
-	return {
-		fVersion: meta.version,
-		fCreatedAt: meta.createdAt,
-		fCwd: meta.cwd ?? null,
-		fParentSession: meta.parentSession ?? null,
-		fSeedLength: meta.seedLength ?? null,
-		fOrigin: meta.origin ?? null,
-		fDelegationDepth: meta.delegationDepth ?? null
-	};
-}
-/**
-* Remap a stored {@link SurfaceOp} from upstream seqs to persisted seqs. An
-* `append` op carries no seqs; a positional `replace`'s `start`/`end` name
-* surface nodes by UPSTREAM seq and must follow {@link SessionEvent.sourceEventSeqs}
-* through the same upstream→persisted map when delta filtering re-numbered the
-* log — otherwise the replacement range is looked up against DENSE seqs and the
-* surface fold rejects the log ("start seq N not found in surface").
-* @param op - the stored surface op.
-* @param remap - upstream→persisted seq mapping (identity when absent).
-* @returns the remapped surface op.
-*/
-function remapSurfaceOp(op, remap) {
-	if (op === "append") return op;
-	return {
-		op: "replace",
-		start: remap(op.start),
-		end: remap(op.end)
-	};
-}
-/**
-* The compact metering events (`compaction/summary`, `compaction/prune`) carry the
-* token-meter's shadow-price claim in `data.shadowedRange`: the inclusive
-* surface-node seqs of the range the IMMEDIATELY following surface `replace`
-* shadows. The range names surface nodes by UPSTREAM seq, so it must follow
-* the replace's `surfaceOp` through the same upstream→persisted map — the
-* fold compares claim and replacement ranges for exact equality, and an
-* un-remapped claim (upstream) next to a remapped replacement range (dense)
-* makes replay fail loud ("token surface: replace ... has no adjacent shadow
-* price").
-* @param range - the stored shadowed range (upstream seqs).
-* @param remap - upstream→persisted seq mapping (identity when absent).
-* @returns the remapped shadowed range.
-*/
-function remapShadowedRange(range, remap) {
-	return {
-		start: remap(range.start),
-		end: remap(range.end)
-	};
-}
-/**
-* Reconstruct a {@link SessionEvent} from a joined row. The emitted event
-* carries the DENSE persisted seq (`row.fSequence`); `sourceEventSeqs` entries,
-* a positional `replace` {@link SurfaceOp}'s range, and the compact metering
-* events' `shadowedRange` are resolved onto persisted seqs through `seqMap`
-* when the log was delta-filtered.
-*
-* Coordinate resolution is "the stored f_sequence wins, when it is a valid
-* earlier reference": after resume the upstream live log IS the dense log,
-* so events written since (checkpoint replaces, provenance) cite DENSE seqs.
-* A cited seq that exists in the dense space, precedes this event, and is
-* either a SURFACE node or has no upstream counterpart is kept as-is. A seq
-* outside the dense space (or a dense seq that is a non-surface event with an
-* upstream counterpart — an upstream-cited seq that happens to collide with a
-* later dense seq) is treated as an UPSTREAM reference and remapped through
-* the upstream→persisted map, again only when the result precedes this event.
-* Anything else is unresolvable and dropped (never kept verbatim — after
-* rewind re-uses the upstream space, keeping an upstream value would mix
-* coordinates and fail the Session seed validation).
-* @param row - the joined `t_session_events` + `t_events` row.
-* @param seqMap - upstream→persisted seq map (optional).
-* @param denseTypeMap - every persisted f_sequence → event type for the
-*   session (optional; always passed together with `seqMap`).
-* @returns the reconstructed event; throws when a JSON column fails to parse
-*   ({@link scanRows} treats that as a hole, not corruption, in the tail).
-*/
-function rowToEvent(row, seqMap, denseTypeMap) {
-	const remap = (seq) => resolveProvenanceSeq(seq, row.fSequence, seqMap, denseTypeMap) ?? seq;
-	const strictRemap = (seq) => resolveProvenanceSeq(seq, row.fSequence, seqMap, denseTypeMap);
-	const surfaceFields = {
-		...row.fSourceEventSeqs !== null ? (() => {
-			const refs = remapProvenance(JSON.parse(row.fSourceEventSeqs), strictRemap);
-			return refs.length > 0 ? { sourceEventSeqs: refs } : {};
-		})() : {},
-		...row.fSurfaceOp !== null ? { surfaceOp: remapSurfaceOp(JSON.parse(row.fSurfaceOp), remap) } : {}
-	};
-	const data = JSON.parse(row.fData);
-	if (row.fKind === "compaction/summary" || row.fKind === "compaction/prune") {
-		const metering = data;
-		if (metering.shadowedRange !== void 0) metering.shadowedRange = remapShadowedRange(metering.shadowedRange, remap);
-	}
-	return {
-		type: row.fKind,
-		seq: row.fSequence,
-		time: row.fCreatedAt,
-		data,
-		...surfaceFields
-	};
-}
-/**
-* Resolve one cited seq onto the DENSE persisted seq space.
-*
-* "The stored f_sequence wins, when it is a valid earlier reference": after
-* resume the upstream live log IS the dense log, so events written since
-* (checkpoint replaces, provenance) cite DENSE seqs. A cited seq that exists
-* in the dense space, precedes `eventSeq`, and is either a SURFACE node or has
-* no upstream counterpart is kept as-is. A seq outside the dense space (or a
-* dense seq that is a non-surface event with an upstream counterpart — an
-* upstream-cited seq that happens to collide with a later dense seq) is
-* treated as an UPSTREAM reference and remapped through the upstream→persisted
-* map, again only when the result precedes `eventSeq`. Anything else is
-* unresolvable (`undefined`): provenance entries are dropped rather than kept
-* verbatim, because after rewind re-uses the upstream space an upstream value
-* would mix coordinates and fail the Session seed validation.
-* @param seq - the cited seq (upstream or dense).
-* @param eventSeq - the citing event's dense seq.
-* @param seqMap - upstream→persisted seq map (optional).
-* @param denseTypeMap - every persisted f_sequence → event type (optional;
-*   always passed together with `seqMap`).
-* @returns the dense seq to cite, or undefined when unresolvable.
-*/
-function resolveProvenanceSeq(seq, eventSeq, seqMap, denseTypeMap) {
-	if (seqMap === void 0 && denseTypeMap === void 0) return seq;
-	const kind = denseTypeMap?.get(seq);
-	if (kind !== void 0 && seq < eventSeq && (SURFACE_EVENT_TYPES.has(kind) || !seqMap?.has(seq))) return seq;
-	const dense = seqMap?.get(seq);
-	if (dense !== void 0 && dense < eventSeq) return dense;
-}
-/**
-* Build the upstream→persisted seq map for one session's persisted events
-* (only meaningful when delta filtering re-numbered the log).
-*
-* A session re-opened by resume (or forked) persists the seed segment and the
-* new segment in ONE log: the seed rows keep the PARENT session's upstream seqs
-* while the resumed rows carry the child session's own upstream seqs, which
-* renumber from the seed boundary and therefore OVERLAP the parent space. The
-* FIRST mapping wins so a seed-segment event's provenance reference resolves to
-* the seed-space row it actually derived from (rows are ordered by persisted
-* seq, so the seed segment always precedes the resumed one); the resumed
-* segment's references are unique within their own space unless they point at a
-* shared value, which only the parent could have produced first.
-* @param rows - one session's seq rows (upstream + persisted), ordered by seq
-*   ascending (only the two seq columns are needed).
-* @returns map from `f_original_seq` to `f_sequence` (first occurrence wins).
-*/
-function buildSeqMap(rows) {
-	const map = /* @__PURE__ */ new Map();
-	for (const row of rows) if (!map.has(row.fOriginalSeq)) map.set(row.fOriginalSeq, row.fSequence);
-	return map;
-}
-/**
-* Normalize a stored provenance list into the persisted seq space.
-*
-* `sourceEventSeqs` references events by UPSTREAM seq; on read each entry is
-* remapped to the DENSE persisted seq through the upstream→persisted map. An
-* entry whose event never got a persisted row (a dropped delta) or no longer
-* has one cannot be remapped. Keeping such an entry verbatim would mix
-* upstream and dense coordinates in one list — after rewind re-uses the
-* upstream seq space, a stale reference can even collide with a live dense
-* seq — which the upstream Session seed validation rejects (duplicates /
-* non-monotonic / "must reference earlier events"). Unmappable entries are
-* dropped. Because the upstream space is reused, the remapped entries can
-* also arrive out of order or duplicated; the result is sorted and
-* de-duplicated so it is strictly increasing, as the upstream provenance
-* contract requires. The output's SET (the only thing surface-replace
-* shadowing checks) is unchanged by normalization.
-* @param refs - the event's `sourceEventSeqs` (upstream seqs).
-* @param remap - upstream→persisted seq mapping; undefined for an entry
-*   whose event has no persisted row.
-* @returns the normalized, strictly increasing persisted seqs (possibly empty).
-*/
-function remapProvenance(refs, remap) {
-	const mapped = [];
-	for (const ref of refs) {
-		const dense = remap(ref);
-		if (dense !== void 0) mapped.push(dense);
-	}
-	mapped.sort((a, b) => a - b);
-	const result = [];
-	for (const seq of mapped) if (result.length === 0 || result[result.length - 1] !== seq) result.push(seq);
-	return result;
-}
-/**
-* The event types that produce model-visible surface nodes (mirror of the
-* upstream `SURFACE_EVENT_TYPES`); only these can appear in a replace's
-* shadowed range, so only their seqs may be merged into provenance.
-*/
-const SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
-	"user/message",
-	"assistant/message",
-	"tool/result"
-]);
-/**
-* Make a surface `replace` event's provenance cover its replacement range.
-*
-* The upstream Session seed validation requires a replace's `sourceEventSeqs`
-* to include every surface node it shadows (`assertProvenance`'s shadowed
-* check). Rewind re-uses the upstream seq space: a replace that survives a
-* truncation (e.g. a checkpoint `user/message` before the new boundary) has
-* its range remapped onto DENSE seqs, while its provenance references were
-* written in upstream seqs — references to rows rewind deleted are dropped on
-* read, so the surviving provenance no longer covers the range's dense nodes.
-* Merging every persisted SURFACE node seq inside the (dense) range into the
-* provenance makes the log loadable again; extra references are legal
-* provenance and never affect the fold (the fold consumes only the surfaceOp
-* range). Only events the map could resolve exist in the dense range, so the
-* merged list is strictly increasing after sort/dedup.
-* @param events - a session's dense event list (contiguous seqs), read in
-*   full; mutated in place.
-*/
-function normalizeSurfaceReplaceProvenance(events) {
-	for (const event of events) {
-		const raw = event;
-		const op = raw.surfaceOp;
-		if (typeof op !== "object" || op === null || op.op !== "replace") continue;
-		const { start, end } = op;
-		const refs = new Set(raw.sourceEventSeqs ?? []);
-		for (const candidate of events) if (candidate.seq >= start && candidate.seq <= end && SURFACE_EVENT_TYPES.has(candidate.type)) refs.add(candidate.seq);
-		raw.sourceEventSeqs = [...refs].sort((a, b) => a - b);
-	}
-}
-/**
-* Prune `sourceEventSeqs` references that cannot be remapped on read.
-*
-* `sourceEventSeqs` references events by UPSTREAM seq; on read the references
-* are remapped to the DENSE persisted seq through {@link buildSeqMap}. A
-* reference whose event never got a persisted row (a dropped delta, or a seq
-* that never existed) has no map entry and would replay as a `source >=
-* current seq` provenance violation, so the write path prunes it. A fully
-* pruned list is stored as null (no provenance) by the serializer.
-*
-* The `keep` predicate is the CALLER's view of resolvability: the write path
-* knows which upstream seqs THIS INSTANCE dropped (`WriteGuard.pruneRefs` —
-* per-instance knowledge, which must not prune references to rows another
-* instance persisted, e.g. a resume seed segment), while the one-shot repair
-* script knows which upstream seqs exist on DISK (full-database view). The
-* filter itself is shared so the rule lives in one place.
-* @param refs - the event's `sourceEventSeqs` (upstream seqs).
-* @param keep - true for a seq whose referenced event is resolvable.
-* @returns the pruned list.
-*/
-function pruneSourceEventSeqs(refs, keep) {
-	return refs.filter(keep);
-}
-/**
-* Find the preserved prefix of ordered event rows. Fully written rows in an
-* interrupted final turn remain in the prefix. The first unparsable row or seq
-* gap after the last `turn/end` marks a tolerated torn tail; the same hole in
-* the committed region rejects.
-*
-* @param rows - one session's event rows, ordered by persisted seq ascending.
-* @param base - the persisted seq the first row is expected to carry; `0` for
-*   a whole log, the requested `fromSeq` for a suffix read (`loadStoredFrom`).
-* @param seqMap - upstream→persisted seq map forwarded to {@link rowToEvent}.
-* @param denseTypeMap - every persisted f_sequence → type, forwarded to
-*   {@link rowToEvent} (kept together with `seqMap`).
-* @returns the preserved event prefix, plus `tornFrom` — the persisted seq the
-*   physical delete starts at — when a torn tail exists.
-*/
-function scanRows(rows, base = 0, seqMap, denseTypeMap) {
-	const parsed = rows.map((row) => {
-		try {
-			return {
-				ok: true,
-				event: rowToEvent(row, seqMap, denseTypeMap)
-			};
-		} catch {
-			return { ok: false };
-		}
-	});
-	let lastTurnEnd = -1;
-	for (let i = parsed.length - 1; i >= 0; i--) if (parsed[i]?.ok && rows[i]?.fKind === "turn/end") {
-		lastTurnEnd = i;
-		break;
-	}
-	const preserved = [];
-	for (let i = 0; i < rows.length; i++) {
-		const p = parsed[i];
-		if (!p?.ok || p.event === void 0) {
-			if (i <= lastTurnEnd) throw new Error(`corrupt session log: unparsable committed event at seq ${rows[i]?.fSequence}`);
-			break;
-		}
-		if (p.event.seq !== base + i) {
-			if (i <= lastTurnEnd) throw new Error(`corrupt session log: seq gap in committed region (expected ${base + i}, got ${p.event.seq})`);
-			break;
-		}
-		preserved.push(p.event);
-	}
-	return preserved.length < rows.length ? {
-		preserved,
-		tornFrom: base + preserved.length
-	} : { preserved };
-}
-//#endregion
-//#region src/write-guard.ts
-/**
-* The write-authority state machine for one backend instance. Not part of the
-* {@link Backend} seam: it guards the orchestration layer's own invariants and
-* lives entirely in memory.
-*/
-var WriteGuard = class {
-	/**
-	* Last CONFIRMED dense head per session — the head this instance itself
-	* wrote or observed via `loadStored`. `-1` records a confirmed absence (no
-	* row). `undefined` (absent from the map) means this instance never read or
-	* wrote the session.
-	*/
-	headSeqs = /* @__PURE__ */ new Map();
-	/**
-	* Upstream seqs of delta events dropped per session. Mirrors `headSeqs` in
-	* shape: the concurrent-writer guarantee limits each session to one writer,
-	* so this instance is the only authority for its dropped seqs.
-	*/
-	filteredSeqs = /* @__PURE__ */ new Map();
-	/**
-	* Record a head this instance actually observed or wrote.
-	* @param id - the session id.
-	* @param head - the confirmed dense head, or `-1` for a confirmed absence
-	*   (a fresh session this instance has read about — a later append to a
-	*   session that meanwhile got a row must reject).
-	*/
-	confirmHead(id, head) {
-		this.headSeqs.set(id, head);
-	}
-	/**
-	* Fail loud when the on-disk head no longer matches this instance's last
-	* confirmed head for the session. `undefined` (never read/written here) is
-	* only acceptable for a session with NO row: a row written by someone else
-	* means this instance's coordinator cursor is not the log's authority.
-	* @param id - the session id.
-	* @param storedHead - the on-disk head cursor, read inside the append
-	*   transaction before any re-numbering happens.
-	*/
-	assertNoConcurrentWriter(id, storedHead) {
-		const known = this.headSeqs.get(id);
-		if (known === void 0) {
-			if (storedHead !== -1) throw new Error(`session "${id}" has a persisted log this instance has not read; another writer may own it — load the session first`);
-			return;
-		}
-		if (known !== storedHead) throw new Error(`session "${id}" was modified by another writer (stored head ${storedHead}, this instance last confirmed head ${known}); concurrent writers on one session are not supported`);
-	}
-	/**
-	* Record the upstream seqs of events dropped for a session (delta events and
-	* ignorable events), so a later batch's `assistant/message` can prune
-	* `sourceEventSeqs` references to events that never got a persisted row.
-	* @param id - the session id.
-	* @param seqs - the dropped events' upstream seqs (pure-delta batches included).
-	*/
-	noteDropped(id, seqs) {
-		const known = this.filteredSeqs.get(id) ?? /* @__PURE__ */ new Set();
-		for (const seq of seqs) known.add(seq);
-		this.filteredSeqs.set(id, known);
-	}
-	/**
-	* Prune `sourceEventSeqs` references that hit this session's dropped-delta
-	* seq set. `undefined`-like state (no dropped seqs recorded for the session)
-	* leaves the list untouched, matching the write path's "no known drops →
-	* keep verbatim" semantics (repair closers, which never carry provenance,
-	* call through the identity path).
-	*
-	* The predicate is THIS INSTANCE's view (see
-	* {@link pruneSourceEventSeqs}): only seqs it knows were dropped are
-	* pruned — references to rows persisted by another instance (e.g. a resume
-	* seed segment) must survive, so the disk-wide view used by the one-shot
-	* repair script is not applicable here.
-	* @param id - the session id.
-	* @param refs - the event's `sourceEventSeqs` (upstream seqs).
-	* @returns the pruned list; identical content when nothing was dropped.
-	*/
-	pruneRefs(id, refs) {
-		const dropped = this.filteredSeqs.get(id);
-		if (dropped === void 0 || dropped.size === 0) return [...refs];
-		return pruneSourceEventSeqs(refs, (seq) => !dropped.has(seq));
-	}
-};
-//#endregion
-//#region src/entities/types.ts
-/** 把物理列名转成 drizzle 表对象的属性名（`f_session_id` → `fSessionId`）。 */
-function toProperty(name) {
-	return name.replace(/_([a-z])/g, (_match, char) => char.toUpperCase());
-}
-//#endregion
-//#region src/adapters/to-sqlite.ts
-/**
-* 从方言无关的表描述生成 SQLite 的 drizzle `sqliteTable` 对象。查询的类型
-* 安全由调用方的手写行接口（`backend.ts` 的 `SessionRow` / `EventRow` /
-* `EventInsert`）与显式投影兜底——drizzle 无法从运行时构建的列映射保留
-* 精确的列类型。
-*
-* @module @morlay/session-rdb/entities/to-sqlite
-*/
-function buildColumn$1(c, tables) {
-	let col;
-	switch (c.type) {
-		case "text":
-			col = text(c.name);
-			break;
-		case "serial":
-			col = integer(c.name).primaryKey({ autoIncrement: true });
-			break;
-		case "integer":
-		case "bigint": {
-			const built = integer(c.name);
-			col = c.primaryKey ? built.primaryKey() : built;
-			break;
-		}
-	}
-	if (c.notNull) col = col.notNull();
-	if (c.default !== void 0) col = col.default(c.default);
-	if (c.unique) col = col.unique();
-	if (c.references) {
-		const { table, column, onDelete } = c.references;
-		col = col.references(() => tables[table][toProperty(column)], { onDelete });
-	}
-	return col;
-}
-/** 由表描述构建 SQLite drizzle 表对象（按传入顺序；外键目标须先构建）。 */
-function toSqliteSchema(defs) {
-	const tables = {};
-	for (const def of defs) {
-		const columns = {};
-		for (const c of def.columns) columns[toProperty(c.name)] = buildColumn$1(c, tables);
-		const extra = (self) => [
-			...(def.checks ?? []).map((c) => check(c.name, sql.raw(c.expression))),
-			...(def.uniques ?? []).map((u) => unique(u.name).on(...u.columns.map((name) => self[toProperty(name)]))),
-			...(def.indexes ?? []).map((i) => index(i.name).on(...i.columns.map((name) => self[toProperty(name)])))
-		];
-		tables[def.name] = sqliteTable(def.name, columns, extra);
-	}
-	return tables;
-}
-//#endregion
-//#region src/adapters/to-postgres.ts
-/**
-* 从方言无关的表描述生成 PostgreSQL 的 drizzle `pgTable` 对象。查询的类型
-* 安全由调用方的手写行接口与显式投影兜底（同 `to-sqlite.ts`）。
-*
-* @module @morlay/session-rdb/entities/to-postgres
-*/
-function buildColumn(c, tables) {
-	let col;
-	switch (c.type) {
-		case "text":
-			col = text$1(c.name);
-			break;
-		case "serial":
-			col = serial(c.name).primaryKey();
-			break;
-		case "integer": {
-			const built = integer$1(c.name);
-			col = c.primaryKey ? built.primaryKey() : built;
-			break;
-		}
-		case "bigint": {
-			const built = bigint(c.name, { mode: "number" });
-			col = c.primaryKey ? built.primaryKey() : built;
-			break;
-		}
-	}
-	if (c.notNull) col = col.notNull();
-	if (c.default !== void 0) col = col.default(c.default);
-	if (c.unique) col = col.unique();
-	if (c.references) {
-		const { table, column, onDelete } = c.references;
-		col = col.references(() => tables[table][toProperty(column)], { onDelete });
-	}
-	return col;
-}
-/** 由表描述构建 PostgreSQL drizzle 表对象（按传入顺序；外键目标须先构建）。 */
-function toPostgresSchema(defs) {
-	const tables = {};
-	for (const def of defs) {
-		const columns = {};
-		for (const c of def.columns) columns[toProperty(c.name)] = buildColumn(c, tables);
-		const extra = (self) => [
-			...(def.checks ?? []).map((c) => check$1(c.name, sql.raw(c.expression))),
-			...(def.uniques ?? []).map((u) => unique$1(u.name).on(...u.columns.map((name) => self[toProperty(name)]))),
-			...(def.indexes ?? []).map((i) => index$1(i.name).on(...i.columns.map((name) => self[toProperty(name)])))
-		];
-		tables[def.name] = pgTable(def.name, columns, extra);
-	}
-	return tables;
-}
-//#endregion
-//#region src/adapters/ddl.ts
-function sqlType(dialect, type) {
-	switch (type) {
-		case "serial": return dialect === "sqlite" ? "INTEGER" : "SERIAL";
-		case "integer": return "INTEGER";
-		case "bigint": return dialect === "sqlite" ? "INTEGER" : "BIGINT";
-		case "text": return "TEXT";
-	}
-}
-function literal(value) {
-	return typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : String(value);
-}
-function quote(name) {
-	return `"${name}"`;
-}
-function columnSql(dialect, c) {
-	let sql = `${quote(c.name)} ${sqlType(dialect, c.type)}`;
-	if (c.primaryKey) sql += " PRIMARY KEY";
-	if (c.type === "serial" && dialect === "sqlite") sql += " AUTOINCREMENT";
-	if (c.notNull) sql += " NOT NULL";
-	if (c.default !== void 0) sql += ` DEFAULT ${literal(c.default)}`;
-	if (c.unique) sql += " UNIQUE";
-	if (c.references) {
-		sql += ` REFERENCES ${quote(c.references.table)}(${quote(c.references.column)})`;
-		if (c.references.onDelete) sql += ` ON DELETE ${c.references.onDelete.toUpperCase()}`;
-	}
-	return sql;
-}
-/** 一张表的 `CREATE TABLE IF NOT EXISTS`（表级约束内联在列清单末尾）。 */
-function createTableSql(dialect, def) {
-	const parts = def.columns.map((c) => columnSql(dialect, c));
-	for (const ck of def.checks ?? []) parts.push(`CHECK (${ck.expression})`);
-	for (const u of def.uniques ?? []) parts.push(`UNIQUE (${u.columns.map(quote).join(", ")})`);
-	const strict = dialect === "sqlite" ? " STRICT" : "";
-	return `CREATE TABLE IF NOT EXISTS ${quote(def.name)} (\n  ${parts.join(",\n  ")}\n)${strict}`;
-}
-/** 一张表的独立索引语句（两方言索引 DDL 相同，无需 dialect 参数）。 */
-function createIndexSql(def, name) {
-	const idx = def.indexes?.find((i) => i.name === name);
-	if (idx === void 0) throw new Error(`unknown index "${name}" on table "${def.name}"`);
-	return `CREATE INDEX IF NOT EXISTS ${quote(idx.name)} ON ${quote(def.name)}(${idx.columns.map(quote).join(", ")})`;
-}
-/** 一组表的全部建表语句（每表一条 CREATE TABLE + 每条索引）。 */
-function createTablesSql(dialect, defs) {
-	const statements = [];
-	for (const def of defs) {
-		statements.push(createTableSql(dialect, def));
-		for (const idx of def.indexes ?? []) statements.push(createIndexSql(def, idx.name));
-	}
-	return statements;
-}
-//#endregion
-//#region src/entities/persistence-state.ts
-/**
-* `t_persistence_state` — 单例 store 身份行。`f_singleton` 上的 CHECK 把表
-* 钉死为一行（`f_singleton = 1`）。
-*/
-const persistenceState = {
-	name: "t_persistence_state",
-	columns: [{
-		name: "f_singleton",
-		type: "integer",
-		primaryKey: true
-	}, {
-		name: "f_store_id",
-		type: "text",
-		notNull: true
-	}],
-	checks: [{
-		name: "ck_persistence_state_singleton",
-		expression: "f_singleton = 1"
-	}]
-};
-//#endregion
-//#region src/entities/schema-meta.ts
-/**
-* `t_schema_meta` — PostgreSQL 的 schema 版本 / 应用身份载体（SQLite 用
-* `PRAGMA user_version` / `application_id`，PG 无等价 pragma）。键值表：
-* `schema_version` 与 `application_id` 两行在首次初始化时写入。
-* 仅 PostgreSQL 后端使用。
-*/
-const schemaMeta = {
-	name: "t_schema_meta",
-	columns: [{
-		name: "f_key",
-		type: "text",
-		primaryKey: true
-	}, {
-		name: "f_value",
-		type: "text",
-		notNull: true
-	}]
-};
-//#endregion
-//#region src/entities/sessions.ts
-/**
-* `t_sessions` — 会话元数据（`SessionHeader` 列）+ playpen 风格 head 游标
-* （`f_head_event_id` / `f_head_sequence`，事务内维护，append 时提供 parent
-* 链与下一个 seq）。行的存在即 materialized 信号。
-*/
-const sessions = {
-	name: "t_sessions",
-	columns: [
-		{
-			name: "f_id",
-			type: "serial",
-			primaryKey: true
-		},
-		{
-			name: "f_session_id",
-			type: "text",
-			notNull: true,
-			unique: true
-		},
-		{
-			name: "f_head_event_id",
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		{
-			name: "f_head_sequence",
-			type: "integer",
-			notNull: true,
-			default: -1
-		},
-		{
-			name: "f_version",
-			type: "integer",
-			notNull: true
-		},
-		{
-			name: "f_created_at",
-			type: "bigint",
-			notNull: true
-		},
-		{
-			name: "f_cwd",
-			type: "text"
-		},
-		{
-			name: "f_parent_session",
-			type: "text"
-		},
-		{
-			name: "f_seed_length",
-			type: "integer"
-		},
-		{
-			name: "f_origin",
-			type: "text"
-		},
-		{
-			name: "f_delegation_depth",
-			type: "integer"
-		},
-		{
-			name: "f_incarnation",
-			type: "text",
-			notNull: true
-		},
-		{
-			name: "f_revision",
-			type: "integer",
-			notNull: true
-		}
-	]
-};
-//#endregion
-//#region src/entities/events.ts
-/**
-* `t_events` — 全局可寻址的持久化事件实体：`f_event_id`（UUID 唯一）、
-* `f_parent_id`（事件链，空串为 root）、`f_kind`（= 上游 `type`）、
-* `f_role` / `f_name` / `f_action_id`（playpen 事件维度）、`f_encoding`
-* （`json`）、`f_data`（JSON 文本）、`f_created_at`（= `time`）、
-* `f_original_seq`（上游 seq）以及 surface 元数据列（JSON 文本或 NULL）。
-*/
-const events = {
-	name: "t_events",
-	columns: [
-		{
-			name: "f_id",
-			type: "serial",
-			primaryKey: true
-		},
-		{
-			name: "f_event_id",
-			type: "text",
-			notNull: true,
-			unique: true
-		},
-		{
-			name: "f_parent_id",
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		{
-			name: "f_kind",
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		{
-			name: "f_role",
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		{
-			name: "f_name",
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		{
-			name: "f_action_id",
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		{
-			name: "f_encoding",
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		{
-			name: "f_data",
-			type: "text",
-			notNull: true
-		},
-		{
-			name: "f_created_at",
-			type: "bigint",
-			notNull: true,
-			default: 0
-		},
-		{
-			name: "f_original_seq",
-			type: "integer",
-			notNull: true
-		},
-		{
-			name: "f_source_event_seqs",
-			type: "text"
-		},
-		{
-			name: "f_surface_op",
-			type: "text"
-		}
-	]
-};
-//#endregion
-//#region src/entities/session-events.ts
-/**
-* `t_session_events` — 会话↔事件桥接表。`(f_session_id, f_sequence)` 唯一且
-* 有序，会话 log 按稠密 seq 读取；删除 torn tail 只删桥接行（事件实体作为
-* 全局行保留）。
-*/
-const sessionEvents = {
-	name: "t_session_events",
-	columns: [
-		{
-			name: "f_id",
-			type: "serial",
-			primaryKey: true
-		},
-		{
-			name: "f_session_id",
-			type: "text",
-			notNull: true,
-			references: {
-				table: "t_sessions",
-				column: "f_session_id",
-				onDelete: "cascade"
-			}
-		},
-		{
-			name: "f_event_id",
-			type: "text",
-			notNull: true,
-			references: {
-				table: "t_events",
-				column: "f_event_id",
-				onDelete: "cascade"
-			}
-		},
-		{
-			name: "f_sequence",
-			type: "integer",
-			notNull: true
-		}
-	],
-	uniques: [{
-		name: "uq_session_events_session_sequence",
-		columns: ["f_session_id", "f_sequence"]
-	}]
-};
-//#endregion
-//#region src/entities/index.ts
-/**
-* 实体纯定义：每张表一个文件，方言无关的表描述（列 / 约束 / 索引 / 外键）。
-* 具体后端的 drizzle 表对象与建表 DDL 由 `src/adapters/` 从这里转化生成。
-*
-* @module @morlay/session-rdb/entities
-*/
-/** SQLite 后端使用的表（不含 pg 专用的 `t_schema_meta`）。 */
-const sqliteTableDefs = [
-	persistenceState,
-	sessions,
-	events,
-	sessionEvents
-];
-/** PostgreSQL 后端使用的表。 */
-const postgresTableDefs = [
-	persistenceState,
-	schemaMeta,
-	sessions,
-	events,
-	sessionEvents
-];
-//#endregion
-//#region src/schema.ts
-/**
-* The on-disk schema version. Bumped only on a breaking change to the table
-* layout; orthogonal to a session's own `version` (which versions the EVENT
-* vocabulary, stored per session in the `t_sessions` row).
-*/
-const SCHEMA_VERSION = 1;
-/** SQLite application id protecting unrelated databases from persistence writes. */
-const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
-/**
-* Event types whose CONTENT is not persisted: the backend drops these rows
-* entirely and re-numbers the surviving events to a dense persisted seq.
-* Mirrors the persistence proposal's "ephemeral events never enter the
-* canonical log" split.
-*/
-const EPHEMERAL_EVENT_TYPES = ["assistant/chunk"];
-/** `t_events.f_encoding` value: JSON text. Future compression would switch this per row. */
-const EVENT_ENCODING = "json";
-/**
-* SQLite drizzle tables derived from the single entity definitions in
-* `src/entities/`. The runtime column objects are authoritative; TS type
-* safety of queries is carried by the hand-written row interfaces in
-* `backend.ts` (drizzle cannot infer precise column types from a runtime-built
-* column map, so the table handles are deliberately loose).
-*/
-const sqliteTables = toSqliteSchema(sqliteTableDefs);
-/** `t_persistence_state` — the singleton row holding the store identity. */
-const tPersistenceState = sqliteTables["t_persistence_state"];
-/** `t_sessions` — the out-of-log metadata plus the playpen-style head cursor. */
-const tSessions = sqliteTables["t_sessions"];
-/** `t_events` — the globally addressable persisted event entity. */
-const tEvents = sqliteTables["t_events"];
-/** `t_session_events` — the session↔event bridge. */
-const tSessionEvents = sqliteTables["t_session_events"];
-/**
-* How long a connection waits for a contended write lock before failing with
-* `SQLITE_BUSY`. SQLite's default is 0 (fail immediately): with two processes
-* sharing one database (a second `dsh` instance on the same `sessions.sqlite`),
-* every append that meets an in-flight commit would fail and that process's
-* session would silently lose its tail. A nonzero wait makes the contention
-* window a queue instead of a loss.
-*/
-const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
-/**
-* Whether an event type is ephemeral (its content must not be persisted).
-* @param type - the upstream `SessionEvent.type`.
-* @returns true for delta events the backend drops at write time.
-*/
-function isEphemeralType(type) {
-	return EPHEMERAL_EVENT_TYPES.includes(type);
-}
-/**
-* Whether an event must be persisted. An event is dropped at write time when
-* its type is ephemeral (content not persisted) OR the writer marked it
-* `ignorable` — the envelope contract promises loss of an ignorable event
-* cannot affect reconstruction, so it never enters the canonical log (the
-* upstream seq is still recorded for provenance pruning, exactly like a
-* dropped delta). `session-branch/version` is a branch-layer lineage fact
-* carried as an ignorable seed event: it stays in the LIVE log but is NOT
-* persisted here — the branch provider persists it in its own version table
-* (`t_branch_versions`), keeping canonical-log semantics intact.
-*/
-function isPersistedEvent(event) {
-	return !isEphemeralType(event.type) && event.ignorable !== true;
-}
-/**
-* Map a persisted event onto the playpen event dimensions. `f_kind` is the
-* upstream type; `f_role`/`f_name`/`f_action_id` are the playpen classification
-* columns. Unknown (plugin-merged) event types keep the playpen defaults so a
-* future extension can classify them without a schema change.
-* @param event - the event to classify (never an ephemeral type at write time).
-* @returns the role, name, and action-id column values.
-*/
-function eventDimensions(event) {
-	switch (event.type) {
-		case "turn/start":
-		case "turn/end":
-		case "step/start":
-		case "step/end":
-		case "session/end-seed": return {
-			role: "turn",
-			name: "",
-			actionId: ""
-		};
-		case "user/message":
-		case "request/header":
-		case "request/context": return {
-			role: "user",
-			name: "",
-			actionId: ""
-		};
-		case "assistant/message": return {
-			role: "model",
-			name: "",
-			actionId: ""
-		};
-		case "tool/call": return {
-			role: "function",
-			name: event.data.name,
-			actionId: event.data.callId
-		};
-		case "tool/result": return {
-			role: "function",
-			name: "",
-			actionId: (event.data.message?.content[0])?.toolCallId ?? ""
-		};
-		case "todo/write": return {
-			role: "state",
-			name: "todos",
-			actionId: ""
-		};
-		default: return {
-			role: "",
-			name: "",
-			actionId: ""
-		};
-	}
-}
-//#endregion
-//#region src/sqlite.ts
-/**
-* SQLite 存储后端：在 `node:sqlite` `DatabaseSync` 之上实现 {@link Backend}。
-* drizzle 经 `drizzle-orm/node-sqlite` 驱动包装，查询语义与 PostgreSQL 后端
-* 共用同一套 {@link BackendTx} 原语。数据库打开/建表/schema 版本与身份校验
-* （{@link openDatabase}）也归本模块所有——`SqliteBackend` 的实现不跨文件。
-*
-* 事务：SQLite 单连接，`BEGIN IMMEDIATE` 提前获取写锁（受 `busy_timeout`
-* pragma 排队保护）；`COMMIT`/`ROLLBACK` 之后同一连接继续服务普通查询。
-* @module @morlay/session-rdb/sqlite
-*/
-/**
-* Process-wide SQLite write-transaction queues, keyed by database path.
-* SQLite allows exactly one writer, and the async transaction callback (see
-* {@link SqliteBackend.transaction}) must never overlap another connection's
-* `BEGIN IMMEDIATE` inside this process: the second, synchronous BEGIN would
-* busy-wait on the lock and freeze the event loop, so the lock holder could
-* never commit (deadlock until busy_timeout). Serializing per PATH removes the
-* gap entirely.
-*
-* The queue is per path, not global: two backends on DIFFERENT files have no
-* lock to contend for, so serializing them would be pure waste. Two instances
-* sharing one file (the supported multi-process deployment) still share one
-* queue, preserving the deadlock guarantee. `:memory:` databases are distinct
-* per connection but share the key — serializing them is harmless (tests).
-*/
-const sqliteTxQueues = /* @__PURE__ */ new Map();
-/** Run `fn` behind the write-transaction queue for one database path. */
-function enqueueSqliteTx(path, fn) {
-	const run = (sqliteTxQueues.get(path) ?? Promise.resolve()).then(fn);
-	sqliteTxQueues.set(path, run.then(() => void 0, () => void 0));
-	return run;
-}
-/**
-* Exclusively create a missing database file with owner-only permissions.
-* Existing files retain their modes, and errors other than `EEXIST` propagate.
-* `DatabaseSync` reopens by path, so this does not protect confidentiality or
-* integrity when another principal can replace the database entry in its parent
-* directory.
-*/
-async function createDatabaseFile(path) {
-	try {
-		await (await open(path, "wx", 384)).close();
-	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
-	}
-}
-/**
-* Open the database and apply its schema and pragmas. An empty database with a
-* zero `user_version` is initialized at {@link SCHEMA_VERSION}; a nonempty
-* unversioned database and every other non-current version reject rather than
-* being migrated in place.
-* @param path - the SQLite database file to open (created when absent).
-* @param journalMode - validated journal pragma.
-* @param busyTimeout - milliseconds to wait for a contended write lock before
-*   failing with `SQLITE_BUSY`; `0` fails immediately (SQLite's default).
-* @returns the open handle with pragmas applied and all tables ensured.
-*/
-function openDatabase(path, journalMode, busyTimeout = DEFAULT_BUSY_TIMEOUT_MS) {
-	const db = new DatabaseSync(path);
-	try {
-		configureDatabase(db, path, journalMode, busyTimeout);
-		return db;
-	} catch (error) {
-		db.close();
-		throw error;
-	}
-}
-function configureDatabase(db, path, journalMode, busyTimeout) {
-	db.exec("PRAGMA foreign_keys = ON");
-	db.exec(`PRAGMA busy_timeout = ${busyTimeout}`);
-	drizzle$1({ client: db }).transaction((tx) => {
-		const { user_version: onDisk } = tx.get(sql`PRAGMA user_version`);
-		const { application_id: applicationId } = tx.get(sql`PRAGMA application_id`);
-		const { count: userObjectCount } = tx.get(sql`SELECT COUNT(*) AS count FROM sqlite_schema WHERE name NOT GLOB 'sqlite_*'`);
-		if (onDisk === 0 && (applicationId !== 0 || userObjectCount > 0)) throw new Error(`session database at "${path}" has an unversioned schema or application identity`);
-		if (onDisk !== 0 && onDisk !== 1) throw new Error(`session database at "${path}" has schema version ${onDisk}, incompatible with this build (1)`);
-		if (onDisk === 1 && applicationId !== 1146308688) throw new Error(`session database at "${path}" has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
-		for (const statement of createTablesSql("sqlite", sqliteTableDefs)) tx.run(sql.raw(statement));
-		tx.insert(tPersistenceState).values({
-			fSingleton: 1,
-			fStoreId: randomUUID()
-		}).onConflictDoNothing().run();
-		if (onDisk === 0) {
-			tx.run(sql.raw(`PRAGMA application_id = ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`));
-			tx.run(sql.raw(`PRAGMA user_version = 1`));
-		}
-	}, { behavior: "immediate" });
-	db.exec(`PRAGMA journal_mode = ${journalMode.toUpperCase()}`);
-}
-/**
-* SQLite 存储后端。打开时创建目录/文件（owner-only）、应用 pragma 与 DDL、
-* 校验 schema 版本/应用身份并读取 store id。
-*/
-var SqliteBackend = class {
-	options;
-	kind = "sqlite";
-	storeIdentity;
-	/** The resolved database path (queue key); set by {@link open}. */
-	dbPath = "";
-	db;
-	constructor(options) {
-		this.options = options;
-	}
-	async open() {
-		const actual = this.options.path === ":memory:" ? this.options.path : resolve(this.options.path);
-		this.dbPath = actual;
-		if (actual !== ":memory:") {
-			await mkdir(dirname(actual), {
-				recursive: true,
-				mode: 448
-			});
-			await createDatabaseFile(actual);
-		}
-		await enqueueSqliteTx(actual, async () => {
-			this.db = drizzle$1({ client: openDatabase(actual, this.options.journalMode, this.options.busyTimeout) });
-		});
-		try {
-			const row = this.db.select({ fStoreId: tPersistenceState.fStoreId }).from(tPersistenceState).where(eq(tPersistenceState.fSingleton, 1)).get();
-			/* v8 ignore next -- openDatabase inserts the singleton before returning. */
-			if (row === void 0) throw new Error(`session database at "${actual}" has no store identity`);
-			if (row.fStoreId.length === 0) throw new Error(`session database at "${actual}" has no valid store identity`);
-			if (actual !== ":memory:") {
-				const identity = statSync(actual, { bigint: true });
-				this.storeIdentity = `file:${identity.dev}:${identity.ino}:${identity.birthtimeNs}:store:${row.fStoreId}`;
-			} else this.storeIdentity = `memory:store:${row.fStoreId}`;
-		} catch (error) {
-			this.db.$client.close();
-			throw error;
-		}
-	}
-	async close() {
-		if (this.db === void 0) return;
-		this.db.$client.close();
-	}
-	async getSession(id) {
-		return this.db.select().from(tSessions).where(eq(tSessions.fSessionId, id)).get();
-	}
-	async getSeqMapRows(id) {
-		return this.eventRows().where(eq(tSessionEvents.fSessionId, id)).all();
-	}
-	async getEventRows(id, fromSequence) {
-		return (fromSequence === void 0 ? this.eventRows().where(eq(tSessionEvents.fSessionId, id)) : this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence)))).orderBy(tSessionEvents.fSequence).all();
-	}
-	async listSessions() {
-		return this.db.select().from(tSessions).all();
-	}
-	async transaction(fn) {
-		return enqueueSqliteTx(this.dbPath, async () => {
-			this.db.$client.exec("BEGIN IMMEDIATE");
-			try {
-				const result = await fn(this.tx);
-				this.db.$client.exec("COMMIT");
-				return result;
-			} catch (error) {
-				/* v8 ignore start */
-				try {
-					this.db.$client.exec("ROLLBACK");
-				} catch {}
-				throw error;
-			}
-		});
-	}
-	/**
-	* SQLite is a single connection: after `BEGIN IMMEDIATE` every query on the
-	* same handle is inside the transaction, so the tx primitives are the same
-	* row primitives used by the non-transactional reads.
-	*/
-	tx = {
-		upsertSession: (meta, incarnation) => this.upsertSession(meta, incarnation),
-		getHead: (id) => this.getHead(id),
-		insertEvents: (events) => this.insertEvents(events),
-		insertBridges: (rows) => this.insertBridges(rows),
-		updateHead: (id, headEventId, headSequence) => this.updateHead(id, headEventId, headSequence),
-		bumpRevision: (id) => this.bumpRevision(id),
-		deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(id, fromSequence),
-		getPrevBridge: (id, sequence) => this.getPrevBridge(id, sequence),
-		getLastBridge: (id) => this.getLastBridge(id),
-		updateEventFields: (id, sequence, fields) => this.updateEventFields(id, sequence, fields)
-	};
-	async upsertSession(meta, incarnation) {
-		this.db.insert(tSessions).values(sessionInsertRow(meta, incarnation)).onConflictDoUpdate({
-			target: tSessions.fSessionId,
-			set: sessionConflictRow(meta)
-		}).run();
-	}
-	async getHead(id) {
-		const head = this.db.select({
-			fHeadEventId: tSessions.fHeadEventId,
-			fHeadSequence: tSessions.fHeadSequence
-		}).from(tSessions).where(eq(tSessions.fSessionId, id)).get();
-		/* 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 insertEvents(events) {
-		if (events.length === 0) return;
-		this.db.insert(tEvents).values(events.map((event) => ({ ...event }))).run();
-	}
-	async insertBridges(rows) {
-		if (rows.length === 0) return;
-		this.db.insert(tSessionEvents).values(rows.map((row) => ({ ...row }))).run();
-	}
-	async updateHead(id, headEventId, headSequence) {
-		this.db.update(tSessions).set({
-			fHeadEventId: headEventId,
-			fHeadSequence: headSequence
-		}).where(eq(tSessions.fSessionId, id)).run();
-	}
-	async bumpRevision(id) {
-		this.db.update(tSessions).set({ fRevision: sql`${tSessions.fRevision} + 1` }).where(eq(tSessions.fSessionId, id)).run();
-	}
-	async deleteBridgeTail(id, fromSequence) {
-		this.db.delete(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence))).run();
-	}
-	async getPrevBridge(id, sequence) {
-		return this.db.select({
-			fEventId: tSessionEvents.fEventId,
-			fSequence: tSessionEvents.fSequence
-		}).from(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get();
-	}
-	async getLastBridge(id) {
-		return this.db.select({
-			fEventId: tSessionEvents.fEventId,
-			fSequence: tSessionEvents.fSequence
-		}).from(tSessionEvents).where(eq(tSessionEvents.fSessionId, id)).orderBy(desc(tSessionEvents.fSequence)).limit(1).get();
-	}
-	/** The joined event-row projection shared by whole-log and suffix reads. */
-	eventRows() {
-		return this.db.select({
-			fSequence: tSessionEvents.fSequence,
-			fOriginalSeq: tEvents.fOriginalSeq,
-			fKind: tEvents.fKind,
-			fCreatedAt: tEvents.fCreatedAt,
-			fData: tEvents.fData,
-			fSourceEventSeqs: tEvents.fSourceEventSeqs,
-			fSurfaceOp: tEvents.fSurfaceOp
-		}).from(tSessionEvents).innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId));
-	}
-	async updateEventFields(id, sequence, fields) {
-		const eventIds = this.db.select({ fEventId: tSessionEvents.fEventId }).from(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence)));
-		this.db.update(tEvents).set({
-			...fields.fSourceEventSeqs === void 0 ? {} : { fSourceEventSeqs: fields.fSourceEventSeqs },
-			...fields.fSurfaceOp === void 0 ? {} : { fSurfaceOp: fields.fSurfaceOp },
-			...fields.fData === void 0 ? {} : { fData: fields.fData }
-		}).where(inArray(tEvents.fEventId, eventIds)).run();
-	}
-};
-//#endregion
-//#region src/postgres.ts
-/**
-* PostgreSQL 存储后端：在 drizzle 的 PG async 驱动之上实现 {@link Backend}。
-* 驱动（`drizzle-orm/node-postgres` 生产 / `drizzle-orm/pglite` 测试）在构造
-* 时注入，因此本模块不依赖具体 PG 客户端包。
-*
-* 与 SQLite 的差异（方言事实，非行为差异）：
-* - `f_created_at` 用 `BIGINT`（毫秒时间戳超出 PG `INTEGER` 的 int32 范围）；
-* - schema 版本/应用身份校验用 `t_schema_meta` 键值表代替 SQLite 的
-*   `PRAGMA user_version` / `application_id`（PG 无等价 pragma）；
-* - 事务用 drizzle 的异步 `db.transaction`（PG 无 `BEGIN IMMEDIATE`，写锁靠
-*   `busy_timeout` 之外的数据库行锁/唯一约束兜底）。
-* @module @morlay/session-rdb/postgres
-*/
-/**
-* PostgreSQL drizzle tables derived from the single entity definitions in
-* `src/entities/` (type safety carried by the hand-written row interfaces in
-* `backend.ts`, same as the SQLite side).
-*/
-const pgTables = toPostgresSchema(postgresTableDefs);
-/** `t_persistence_state` — the singleton row holding the store identity. */
-const pgPersistenceState = pgTables["t_persistence_state"];
-/** `t_schema_meta` — PG's schema-version / application-identity key-value store. */
-const pgSchemaMeta = pgTables["t_schema_meta"];
-/** `t_sessions` — the out-of-log metadata plus the playpen-style head cursor. */
-const pgSessions = pgTables["t_sessions"];
-/** `t_events` — the globally addressable persisted event entity. */
-const pgEvents = pgTables["t_events"];
-/** `t_session_events` — the session↔event bridge. */
-const pgSessionEvents = pgTables["t_session_events"];
-/**
-* PostgreSQL 存储后端。构造时注入 drizzle PG 实例；{@link open} 建表并做
-* schema 版本/应用身份校验（`t_schema_meta`，替代 SQLite 的 PRAGMA）。
-*/
-var PostgresBackend = class {
-	db;
-	options;
-	kind = "postgres";
-	storeIdentity;
-	constructor(db, options) {
-		this.db = db;
-		this.options = options;
-	}
-	async open() {
-		const storeId = await this.db.transaction(async (tx) => {
-			const metaExists = (await tx.execute(sql`SELECT to_regclass('t_schema_meta') IS NOT NULL AS exists`)).rows[0]?.exists === true;
-			for (const statement of createTablesSql("postgres", postgresTableDefs)) await tx.execute(sql.raw(statement));
-			if (!metaExists) await tx.insert(pgSchemaMeta).values([{
-				fKey: "schema_version",
-				fValue: String(1)
-			}, {
-				fKey: "application_id",
-				fValue: String(SESSION_PERSISTENCE_SQLITE_APPLICATION_ID)
-			}]).execute();
-			const version = await this.readMeta(tx, "schema_version");
-			const applicationId = await this.readMeta(tx, "application_id");
-			if (version === void 0 || applicationId === void 0) throw new Error("session database has an unversioned schema or application identity");
-			if (Number(version) !== 1) throw new Error(`session database has schema version ${version}, incompatible with this build (1)`);
-			if (Number(applicationId) !== 1146308688) throw new Error(`session database has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
-			await tx.insert(pgPersistenceState).values({
-				fSingleton: 1,
-				fStoreId: randomUUID()
-			}).onConflictDoNothing().execute();
-			const storeId = (await tx.select({ fStoreId: pgPersistenceState.fStoreId }).from(pgPersistenceState).where(eq(pgPersistenceState.fSingleton, 1)).execute())[0]?.fStoreId;
-			if (storeId === void 0 || storeId.length === 0) throw new Error("session database has no valid store identity");
-			return storeId;
-		});
-		this.storeIdentity = `${this.options.identityBase}:store:${storeId}`;
-	}
-	async close() {
-		await this.options.close();
-	}
-	async getSession(id) {
-		return (await this.db.select().from(pgSessions).where(eq(pgSessions.fSessionId, id)).execute())[0];
-	}
-	async getSeqMapRows(id) {
-		return this.eventRows(this.db).where(eq(pgSessionEvents.fSessionId, id)).execute();
-	}
-	async getEventRows(id, fromSequence) {
-		return (fromSequence === void 0 ? this.eventRows(this.db).where(eq(pgSessionEvents.fSessionId, id)) : this.eventRows(this.db).where(and(eq(pgSessionEvents.fSessionId, id), gte(pgSessionEvents.fSequence, fromSequence)))).orderBy(pgSessionEvents.fSequence).execute();
-	}
-	async listSessions() {
-		return this.db.select().from(pgSessions).execute();
-	}
-	async transaction(fn) {
-		return this.db.transaction(async (tx) => fn(this.txFor(tx)));
-	}
-	/** Bind the {@link BackendTx} primitives to one drizzle PG transaction handle. */
-	txFor(tx) {
-		return {
-			upsertSession: (meta, incarnation) => this.upsertSession(tx, meta, incarnation),
-			getHead: (id) => this.getHead(tx, id),
-			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),
-			deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
-			getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence),
-			getLastBridge: (id) => this.getLastBridge(tx, id),
-			updateEventFields: (id, sequence, fields) => this.updateEventFields(tx, id, sequence, fields)
-		};
-	}
-	async readMeta(exec, key) {
-		return (await exec.select({ fValue: pgSchemaMeta.fValue }).from(pgSchemaMeta).where(eq(pgSchemaMeta.fKey, key)).execute())[0]?.fValue;
-	}
-	async upsertSession(exec, meta, incarnation) {
-		await exec.insert(pgSessions).values(sessionInsertRow(meta, incarnation)).onConflictDoUpdate({
-			target: pgSessions.fSessionId,
-			set: sessionConflictRow(meta)
-		}).execute();
-	}
-	async getHead(exec, id) {
-		const head = (await exec.select({
-			fHeadEventId: pgSessions.fHeadEventId,
-			fHeadSequence: pgSessions.fHeadSequence
-		}).from(pgSessions).where(eq(pgSessions.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 insertEvents(exec, events) {
-		if (events.length === 0) return;
-		await exec.insert(pgEvents).values(events.map((event) => ({ ...event }))).execute();
-	}
-	async insertBridges(exec, rows) {
-		if (rows.length === 0) return;
-		await exec.insert(pgSessionEvents).values(rows.map((row) => ({ ...row }))).execute();
-	}
-	async updateHead(exec, id, headEventId, headSequence) {
-		await exec.update(pgSessions).set({
-			fHeadEventId: headEventId,
-			fHeadSequence: headSequence
-		}).where(eq(pgSessions.fSessionId, id)).execute();
-	}
-	async bumpRevision(exec, id) {
-		await exec.update(pgSessions).set({ fRevision: sql`${pgSessions.fRevision} + 1` }).where(eq(pgSessions.fSessionId, id)).execute();
-	}
-	async deleteBridgeTail(exec, id, fromSequence) {
-		await exec.delete(pgSessionEvents).where(and(eq(pgSessionEvents.fSessionId, id), gte(pgSessionEvents.fSequence, fromSequence))).execute();
-	}
-	async getPrevBridge(exec, id, sequence) {
-		return (await exec.select({
-			fEventId: pgSessionEvents.fEventId,
-			fSequence: pgSessionEvents.fSequence
-		}).from(pgSessionEvents).where(and(eq(pgSessionEvents.fSessionId, id), eq(pgSessionEvents.fSequence, sequence))).execute())[0];
-	}
-	async getLastBridge(exec, id) {
-		return (await exec.select({
-			fEventId: pgSessionEvents.fEventId,
-			fSequence: pgSessionEvents.fSequence
-		}).from(pgSessionEvents).where(eq(pgSessionEvents.fSessionId, id)).orderBy(desc(pgSessionEvents.fSequence)).limit(1).execute())[0];
-	}
-	/** The joined event-row projection shared by whole-log and suffix reads. */
-	eventRows(exec) {
-		return exec.select({
-			fSequence: pgSessionEvents.fSequence,
-			fOriginalSeq: pgEvents.fOriginalSeq,
-			fKind: pgEvents.fKind,
-			fCreatedAt: pgEvents.fCreatedAt,
-			fData: pgEvents.fData,
-			fSourceEventSeqs: pgEvents.fSourceEventSeqs,
-			fSurfaceOp: pgEvents.fSurfaceOp
-		}).from(pgSessionEvents).innerJoin(pgEvents, eq(pgSessionEvents.fEventId, pgEvents.fEventId));
-	}
-	async updateEventFields(exec, id, sequence, fields) {
-		const eventIds = exec.select({ fEventId: pgSessionEvents.fEventId }).from(pgSessionEvents).where(and(eq(pgSessionEvents.fSessionId, id), eq(pgSessionEvents.fSequence, sequence)));
-		await exec.update(pgEvents).set({
-			...fields.fSourceEventSeqs === void 0 ? {} : { fSourceEventSeqs: fields.fSourceEventSeqs },
-			...fields.fSurfaceOp === void 0 ? {} : { fSurfaceOp: fields.fSurfaceOp },
-			...fields.fData === void 0 ? {} : { fData: fields.fData }
-		}).where(inArray(pgEvents.fEventId, eventIds)).execute();
-	}
-};
-//#endregion
-//#region src/branch.ts
-/**
-* RDB 的「额外 provider 抽象」实现：在 `@morlay/session-rdb`
-* 既有 `PersistenceBackend`（append-only 面）之上，实现
-* `@morlay/session-branch` 的 `SessionBranchProvider`（分支面：rewind /
-* forkFrom / readBranchPrefix），并发布 `ctx.sessionBranch` 服务
-* （`SessionBranchRdb extends SessionBranch`）——使本包成为 rewind /
-* retry / fork 的持久化闭环。
-*
-* 关键设计（不改上游代码）：
-*
-* - `forkFrom` 走**标准 coordinator 路径**（`create` + `append`）：派生是纯
-*   append（新 id / parentSession / seedLength），上游 `PersistenceCoordinator`
-*   天然支持；seed 前缀按新会话 log 重新编号（保序重编号，`sourceEventSeqs`
-*   的相对序不变，`source < seq` 校验成立）。
-* - `rewind` 是上游没有的原语（`PersistenceCoordinator` 只有 append-only +
-*   torn-tail 修复），因此直接操作本后端的 `Backend` 事务（DELETE 尾部 +
-*   head 游标回退 + revision bump），随后**重新 load 同步 coordinator 状态**
-*   （revision 变化使 `isPreparedSourceCurrent` 失效 → 重新 adopt →
-*   `state.cursor` 与新尾部一致）并更新 `WriteGuard` 确认 head。
-* - 独占条件：无 live owner（`ctx.sessions.get(id) === undefined`）。prepared
-*   reservation 无法从公开 API 查询，rewind 通过 revision 变化使其自然失效。
-*
-* @module @morlay/session-rdb/branch
-*/
-/**
-* 定位 `atSeq` 锚定的闭合 `turn/end` 边界 seq。见
-* {@link SessionBranchProvider.readBranchPrefix} 的锚定语义说明。
-* @param events - 完整（或前缀）事件列表，seq 连续。
-* @param atSeq - 锚定 seq（inclusive）；省略取最后闭合轮次。
-* @param mode - `"after"`（默认）或 `"before"`。
-* @returns 边界事件 seq；`"before"` 模式下 atSeq 之前无闭合轮次时返回 -1
-*   （空前缀）。
-*/
-function locateTurnEnd(events, atSeq, mode = "after") {
-	const ends = events.filter((event) => event.type === "turn/end").map((event) => event.seq);
-	if (atSeq === void 0) {
-		const last = ends.at(-1);
-		if (last === void 0) throw new SessionBranchError("session has no closed turn", "OPEN_TURN");
-		return last;
-	}
-	if (mode === "before") {
-		let boundary = -1;
-		for (const seq of ends) if (seq < atSeq) boundary = seq;
-		else break;
-		return boundary;
-	}
-	const firstAfter = ends.find((seq) => seq >= atSeq);
-	if (firstAfter !== void 0) return firstAfter;
-	const lastStart = [...events].reverse().find((event) => event.type === "turn/start");
-	if (lastStart !== void 0 && lastStart.seq <= atSeq) throw new SessionBranchError(`anchor ${atSeq} lies inside an open turn`, "OPEN_TURN");
-	const last = ends.at(-1);
-	if (last === void 0) throw new SessionBranchError("session has no closed turn", "OPEN_TURN");
-	return last;
-}
-/** 按新会话 log 重新编号：保序重编号，`sourceEventSeqs` 相对序不变。 */
-function renumber(events, offset) {
-	return events.map((event, index) => ({
-		...event,
-		seq: offset + index
-	}));
-}
-/** 派生会话 id（后端 mint 策略，与 apiproxy `session-<uuid>` 一致）。 */
-function mintSessionId() {
-	return `session-${randomUUID()}`;
-}
-/**
-* 截断 live 会话的内存 log 并重置全部派生缓存。上游 `Session` 的
-* `log`/`surfaceManager`/`headerFold`/`contextFold`/`derived` 都是增量缓存：
-* 截断 `log` 后必须同步重置，否则下一次 append 会基于陈旧状态校验/投影。
-* 字段名取编译后产物（`@deepseek-ai/dsh-session` lib），并对
-* `SurfaceManager`（持有同一 `log` 数组引用）做全量重折叠复位——
-* `_lastProcessedSeq = baseSeq - 1` 使下次访问重新 fold 整个截断后 log。
-*/
-function truncateLiveSession(session, newLength) {
-	const s = session;
-	s.log.length = newLength;
-	s.eventsSnapshot = void 0;
-	s.headerFold = void 0;
-	s.headerFoldSeq = 0;
-	s.contextFold = void 0;
-	s.contextFoldSeq = 0;
-	s.derived = [];
-	s.derivedNodes = 0;
-	s.derivedGeneration = 0;
-	s.surfaceManager._state = {
-		nodes: [],
-		replaceGeneration: 0
-	};
-	s.surfaceManager._lastProcessedSeq = s.surfaceManager.baseSeq - 1;
-	s.surfaceManager._pendingPlan = void 0;
-}
-/**
-* RDB 分支数据层实现（`SessionBranchProvider`）。与 `SessionPersistenceRdb`
-* 共享同一数据库连接（`Backend`）与 coordinator 写路径。
-*/
-var SessionBranchRdbProvider = class {
-	persistence;
-	live;
-	name = "session-rdb";
-	constructor(persistence, live = {
-		getSession: () => void 0,
-		getAgent: () => void 0,
-		flush: async () => true,
-		setCoordinatorCursor: () => {},
-		setCoordinatorState: () => {}
-	}) {
-		this.persistence = persistence;
-		this.live = live;
-	}
-	async readBranchPrefix(id, atSeq, mode = "after", signal) {
-		const { events } = await this.readRawEvents(id, signal);
-		const boundary = locateTurnEnd(events, atSeq, mode);
-		return {
-			seq: boundary,
-			events: events.slice(0, boundary + 1)
-		};
-	}
-	/**
-	* 读取会话的**原始**事件（不含 coordinator 补记的合成 closers）。
-	*
-	* `persistence.inspect` 走 coordinator 的 `prepareCore`，会给未闭合 log
-	* 补 `interruptedTurnClosers`（合成 step/end + turn/end）——对普通读取
-	* （客户端历史）这是正确的逻辑视图，但对分支编排是误导：未闭合轮次被
-	* closers 掩盖成闭合，编辑未闭合轮次的 user 消息会走错边界。这里用
-	* `loadStored`（backend hook，scanRows 只做 torn-tail 切割、不补 closers）
-	* 读原始事件，使未闭合状态真实可见。
-	*/
-	async readRawEvents(id, signal) {
-		const stored = await this.persistence.loadStored(id, signal);
-		if (stored === void 0) throw new SessionBranchError(`session "${id}" not found`, "SESSION_NOT_FOUND");
-		return {
-			meta: stored.meta,
-			events: stored.events
-		};
-	}
-	async forkFrom(sourceId, options = {}, signal) {
-		signal?.throwIfAborted();
-		const { atSeq, anchorMode = "after", seedSuffix = [], childSessionId, meta = {} } = options;
-		const source = await this.persistence.inspect(sourceId, signal);
-		const boundary = locateTurnEnd(source.events, atSeq, anchorMode);
-		const prefix = source.events.slice(0, boundary + 1);
-		const childId = childSessionId ?? mintSessionId();
-		const childMeta = {
-			version: SESSION_FORMAT_VERSION,
-			id: childId,
-			createdAt: meta.createdAt ?? Date.now(),
-			...meta.cwd !== void 0 ? { cwd: meta.cwd } : source.meta.cwd !== void 0 ? { cwd: source.meta.cwd } : {},
-			parentSession: sourceId,
-			seedLength: prefix.length,
-			...meta.agentPreset !== void 0 ? { agentPreset: meta.agentPreset } : source.meta.agentPreset !== void 0 ? { agentPreset: source.meta.agentPreset } : {},
-			...meta.origin !== void 0 ? { origin: meta.origin } : {},
-			...meta.delegationDepth !== void 0 ? { delegationDepth: meta.delegationDepth } : {}
-		};
-		const seed = [...renumber(prefix, 0), ...renumber(seedSuffix, prefix.length)];
-		await this.persistence.create(childMeta);
-		if (seed.length > 0) await this.persistence.append(childId, seed);
-		return childId;
-	}
-	async rewind(id, toBoundary, signal) {
-		signal?.throwIfAborted();
-		if (!Number.isSafeInteger(toBoundary) || toBoundary < -1) throw new SessionBranchError(`rewind boundary must be a non-negative safe integer, got ${toBoundary}`, "INVALID_BOUNDARY");
-		const live = this.live.getSession(id);
-		if (live !== void 0) await this.live.flush(live);
-		const raw = live === void 0 ? await this.readRawEvents(id, signal) : void 0;
-		const inspection = live === void 0 ? void 0 : await this.persistence.inspect(id, signal);
-		const events = live === void 0 ? raw.events : inspection.events;
-		const meta = live === void 0 ? raw.meta : inspection.meta;
-		const boundaryEvent = events[toBoundary];
-		if (toBoundary === -1) {} else if (boundaryEvent === void 0) throw new SessionBranchError(`rewind boundary ${toBoundary} does not exist in session "${id}"`, "INVALID_BOUNDARY");
-		else if (boundaryEvent.type !== "turn/end" && boundaryEvent.type !== "user/message") throw new SessionBranchError(`rewind boundary ${toBoundary} is not a turn/end or user/message (${boundaryEvent.type})`, "INVALID_BOUNDARY");
-		const rawKeepLength = toBoundary === -1 ? 0 : boundaryEvent.type === "turn/end" ? toBoundary + 1 : toBoundary;
-		const keepLength = balanceRewindPrefix(events.slice(0, rawKeepLength)).length;
-		const internals = this.persistence.internals();
-		const denseBoundary = live === void 0 ? keepLength - 1 : events.slice(0, keepLength).filter(isPersistedEvent).length - 1;
-		await internals.backend.transaction(async (tx) => {
-			signal?.throwIfAborted();
-			const head = await tx.getHead(id);
-			if (denseBoundary > head.fHeadSequence) throw new SessionBranchError(`rewind boundary ${toBoundary} is beyond the stored head ${head.fHeadSequence}`, "INVALID_BOUNDARY");
-			if (denseBoundary < head.fHeadSequence) {
-				await tx.deleteBridgeTail(id, denseBoundary + 1);
-				const prev = denseBoundary === -1 ? void 0 : await tx.getPrevBridge(id, denseBoundary);
-				if (prev === void 0) await tx.updateHead(id, "", -1);
-				else await tx.updateHead(id, prev.fEventId, prev.fSequence);
-			}
-			await tx.bumpRevision(id);
-		});
-		internals.writeGuard.confirmHead(id, denseBoundary);
-		if (live !== void 0) {
-			truncateLiveSession(live, keepLength);
-			const agent = this.live.getAgent(id);
-			if (agent !== void 0) {
-				agent.requestHeaderLogged = false;
-				const lastTurn = live.events.findLast((e) => e.type === "turn/start")?.data.turn ?? 0;
-				const phase = agent.phase;
-				if (phase !== void 0) phase.lastTurn = lastTurn;
-			}
-			this.live.setCoordinatorCursor(id, keepLength);
-		} else if (boundaryEvent?.type === "user/message") this.live.setCoordinatorState(id, keepLength, meta);
-		else await this.persistence.load(id);
-		const row = await internals.backend.getSession(id);
-		if (row === void 0) return {
-			header: {
-				version: SESSION_FORMAT_VERSION,
-				id,
-				createdAt: meta.createdAt,
-				...meta.cwd !== void 0 ? { cwd: meta.cwd } : {},
-				...meta.parentSession !== void 0 ? { parentSession: meta.parentSession } : {},
-				...meta.seedLength !== void 0 ? { seedLength: meta.seedLength } : {},
-				...meta.origin !== void 0 ? { origin: meta.origin } : {},
-				...meta.delegationDepth !== void 0 ? { delegationDepth: meta.delegationDepth } : {},
-				...meta.agentPreset !== void 0 ? { agentPreset: meta.agentPreset } : {}
-			},
-			revision: await internals.readStoredRevision(id) ?? await this.persistence.readStoredRevision(id)
-		};
-		return {
-			header: rowToMeta(row),
-			revision: await internals.readStoredRevision(id)
-		};
-	}
-};
-/**
-* RDB 的 `ctx.sessionBranch` 服务：组合 {@link SessionBranchRdbProvider} 的
-* 数据层原语与共享版本树投影。插件把本类注册为 `sessionBranch` 服务后，
-* 编排层即可通过统一服务面完成 rewind / retry / fork。
-*/
-var SessionBranchRdb = class extends SessionBranch {
-	static inject = ["sessionPersistence", "sessions"];
-	constructor(ctx) {
-		super(ctx);
-	}
-	provider = new SessionBranchRdbProvider(this.ctx.sessionPersistence, {
-		getSession: (id) => this.ctx.sessions.get(id),
-		getAgent: (id) => {
-			return this.ctx.get("agents")?.get(id);
-		},
-		flush: (session) => this.ctx.sessions.flush(session),
-		setCoordinatorCursor: (id, cursor) => {
-			const state = this.ctx.sessionPersistence.coordinator?.states?.get(id);
-			if (state !== void 0) state.cursor = cursor;
-		},
-		setCoordinatorState: (id, cursor, meta) => {
-			const states = this.ctx.sessionPersistence.coordinator?.states;
-			if (states === void 0) return;
-			const state = states.get(id);
-			if (state !== void 0) state.cursor = cursor;
-			else states.set(id, {
-				meta,
-				cursor,
-				materialized: true
-			});
-		}
-	});
-	readBranchPrefix(id, atSeq, mode, signal) {
-		return this.provider.readBranchPrefix(id, atSeq, mode, signal);
-	}
-	/**
-	* 读取会话的**原始**事件（不含 coordinator 补记的合成 closers）。
-	* 编排层用它识别未闭合轮次（inspect 会把未闭合 log 补成闭合）。
-	*/
-	readRawEvents(id, signal) {
-		return this.provider.readRawEvents(id, signal);
-	}
-	forkFrom(sourceId, options, signal) {
-		return this.provider.forkFrom(sourceId, options, signal);
-	}
-	rewind(id, toBoundary, signal) {
-		return this.provider.rewind(id, toBoundary, signal);
-	}
-	/**
-	* 清洗一个 session 的 surface/provenance 坐标到稠密空间（持久化层透传）。
-	* 旧数据（rewind 前写入）的 sourceEventSeqs / surfaceOp / shadowedRange
-	* 是上游坐标,读取时每次都要对齐;清洗一次性写回稠密坐标,之后读取无需
-	* 对齐。返回实际变更的事件数。
-	*/
-	cleanseSession(sessionId, signal) {
-		return this.ctx.sessionPersistence.cleanseSession(sessionId, signal);
-	}
-	/**
-	* 同步 live 会话的 coordinator 内存 cursor，跳过 ignorable 占位事件。
-	* 编排层在 rewind 后把 ignorable 版本效果 push 进 live log（不发布、不
-	* 进缓冲）——它占用一个上游 seq，但 coordinator 的 cursor（rewind 设到
-	* 截断后长度）看不见它；不跳过的话，flush 的 `appendLiveBatch` 会以
-	* `e.seq >= cursor` 过滤掉 cursor 之前的事件（manualTurn 永远不落盘），
-	* 或 `appendCore` 的 seq 连续性校验错位。这里把 cursor 从当前值起跳过
-	* 连续的 ignorable 事件，对齐到下一个待持久化事件的 seq。
-	*/
-	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.events[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.events.slice(fromSeq);
-			return (await persistence.readFrom(id, fromSeq, s)).events;
-		};
-		return buildTimeline(snapshots, readOwnEvents, sessionId, signal);
-	}
-};
-//#endregion
-//#region src/index.ts
-/**
-* The persistence backend. Load as a plugin; it registers as
-* `ctx.sessionPersistence` and (via the coordinator) installs the write-path
-* listeners. Its torn-tail marker is the persisted seq to delete from.
-*
-* Configuration resolution: `$DSH_HOME/settings.yaml` 的
-* `session-rdb` namespace（settings 服务）覆盖 cordis 层 entry
-* config，见 {@link installSettingsSection}。
-*/
-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)
-	}), z.object({
-		type: z.const("postgres"),
-		connectionString: z.string().required()
-	})]);
-	/** settings namespace：`$DSH_HOME/settings.yaml` 的 `session-rdb` section。 */
-	static settingsNs = settingsNamespace("session-rdb");
-	/**
-	* Backend label for the coordinator's dispose diagnostics. Intentionally
-	* shadows cordis `Service.name` (set to `'sessionPersistence'` by the base);
-	* see the JSONL backend for why this does not affect service resolution.
-	*/
-	name = "session-rdb";
-	/** One RDB database holds every session; there is no per-session raw artifact. */
-	supportsRawArtifacts = false;
-	backend;
-	storeIdentity;
-	ready;
-	coordinator;
-	/**
-	* Write-authority state: the confirmed dense head per session (concurrent-
-	* writer detection) and the dropped delta seqs per session (provenance
-	* pruning). See {@link WriteGuard} for the timing contract.
-	*/
-	writeGuard = new WriteGuard();
-	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.coordinator = new PersistenceCoordinator(this.ctx, this);
-		new SessionBranchRdb(this.ctx);
-	}
-	async init() {
-		await this.backend.open();
-		this.storeIdentity = this.backend.storeIdentity;
-	}
-	/** The backend has one database, not an independent local artifact per session. */
-	locate(_meta) {}
-	create(meta) {
-		return this.coordinator.create(meta);
-	}
-	append(id, events) {
-		return this.coordinator.append(id, events);
-	}
-	load(id) {
-		return this.coordinator.load(id);
-	}
-	inspect(id, signal) {
-		return this.coordinator.inspect(id, signal);
-	}
-	readFrom(id, fromSeq, signal) {
-		return this.coordinator.readFrom(id, fromSeq, signal);
-	}
-	/** Read a stored prefix by id (ids are globally unique — no scope to scan). */
-	loadStored(id, signal) {
-		return this.readPrefix(id, signal);
-	}
-	/**
-	* Seek-capable suffix read: the backend selects `f_sequence >= fromSeq`
-	* directly, so the read scales with the suffix, not the log. Provenance
-	* remapping still needs every row's upstream seq, so a lightweight
-	* two-column map is read alongside. Torn rows past the preserved region are
-	* dropped, never repaired (non-mutating read).
-	*/
-	async loadStoredFrom(id, fromSeq, signal) {
-		const log = await this.readLog(id, { fromSeq }, signal);
-		if (log === void 0) return void 0;
-		return {
-			meta: log.meta,
-			events: log.events
-		};
-	}
-	/**
-	* Read a session's row + ordered events into a {@link StoredPrefix}. The
-	* torn-tail marker is the persisted seq from which a never-committed tail
-	* must be deleted (`scanRows` already returns it as `number | undefined`).
-	* Records the confirmed dense head (or confirmed absence) so a later
-	* `appendBatch` can detect a second writer that advanced the log.
-	*/
-	async readPrefix(id, signal) {
-		const log = await this.readLog(id, {}, signal);
-		if (log === void 0) {
-			this.writeGuard.confirmHead(id, -1);
-			return;
-		}
-		this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
-		normalizeSurfaceReplaceProvenance(log.events);
-		return {
-			meta: log.meta,
-			events: log.events,
-			revision: SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${log.incarnation}:revision:${log.revision}`),
-			...log.tornFrom !== void 0 ? { tornMarker: log.tornFrom } : {}
-		};
-	}
-	/**
-	* Read the current source-qualified revision for one stored session without
-	* loading its event log. Returns `undefined` when the identity is absent.
-	* The representation matches {@link loadStored}'s `revision` and
-	* {@link listSnapshots} — the coordinator compares them with `===`.
-	*/
-	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 SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`);
-	}
-	/**
-	* Shared read pipeline: session row → meta, event rows → preserved prefix.
-	* A whole-log read (`fromSeq` absent) builds the seq map from the same rows;
-	* a suffix read keeps the backend's lightweight two-column seq-map source so
-	* the query still scales with the suffix, not the log.
-	*/
-	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);
-		let eventRows;
-		let seqMap;
-		let denseTypeMap;
-		if (options.fromSeq === void 0) {
-			eventRows = await this.backend.getEventRows(id);
-			seqMap = buildSeqMap(eventRows);
-			denseTypeMap = new Map(eventRows.map((r) => [r.fSequence, r.fKind]));
-		} else {
-			eventRows = await this.backend.getEventRows(id, options.fromSeq);
-			const seqRows = await this.backend.getSeqMapRows(id);
-			seqMap = buildSeqMap(seqRows);
-			denseTypeMap = new Map(seqRows.map((r) => [r.fSequence, r.fKind]));
-		}
-		signal?.throwIfAborted();
-		const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0, seqMap, denseTypeMap);
-		return {
-			meta,
-			events: preserved,
-			incarnation: row.fIncarnation,
-			revision: row.fRevision,
-			...tornFrom !== void 0 ? { tornFrom } : {}
-		};
-	}
-	/**
-	* Durably append a batch in ONE transaction: materialize the sessions row (if
-	* lazy) and INSERT every persisted event (plus its bridge row), or roll back
-	* entirely. Delta events and events the writer marked `ignorable` are dropped
-	* and the surviving events are re-numbered densely from the session's head
-	* cursor; a batch that contains only dropped events is a no-op (no row
-	* materialization, no revision bump). Dropped events' upstream seqs are
-	* recorded per session so a later batch's surface provenance can prune
-	* references to them (see {@link surfaceBindings}).
-	* The transaction is the atomicity + durability boundary, so a mid-batch
-	* failure (a UNIQUE violation on a duplicated seq) leaves the stored log
-	* untouched.
-	*
-	* SQLite acquires the write lock up front (`BEGIN IMMEDIATE`, queued behind
-	* `busy_timeout`); PostgreSQL relies on the transaction's row locks and the
-	* `UNIQUE (f_session_id, f_sequence)` constraint to reject a colliding batch.
-	* Either way {@link assertNoConcurrentWriter} rejects a second writer before
-	* re-numbering — a session has exactly one writer per log, and a second
-	* writer fails loud instead of corrupting the log.
-	*
-	* The row upsert runs UNCONDITIONALLY, not only when `!isMaterialized`: a
-	* delta-only batch leaves the coordinator's materialized flag true while no
-	* row exists, so the flag cannot be trusted as the row's existence signal.
-	* The upsert keeps an existing row's head cursor (only header columns are
-	* refreshed on conflict), so a fresh row still starts at the initial head.
-	*/
-	async appendBatch(meta, events, _isMaterialized) {
-		await this.ready;
-		const droppedSeqs = /* @__PURE__ */ new Set();
-		for (const event of events) if (!isPersistedEvent(event)) droppedSeqs.add(event.seq);
-		if (droppedSeqs.size > 0) this.writeGuard.noteDropped(meta.id, droppedSeqs);
-		const persisted = events.filter(isPersistedEvent);
-		if (persisted.length === 0) return;
-		let confirmedHead = -1;
-		await this.backend.transaction(async (tx) => {
-			await tx.upsertSession(meta, randomUUID());
-			const head = await tx.getHead(meta.id);
-			this.writeGuard.assertNoConcurrentWriter(meta.id, head.fHeadSequence);
-			const { headEventId, headSequence } = await appendEventTail(tx, meta, persisted, {
-				parentId: head.fHeadEventId,
-				nextSeq: head.fHeadSequence + 1
-			}, (refs) => this.writeGuard.pruneRefs(meta.id, refs));
-			await tx.updateHead(meta.id, headEventId, headSequence);
-			await tx.bumpRevision(meta.id);
-			confirmedHead = headSequence;
-		});
-		this.writeGuard.confirmHead(meta.id, confirmedHead);
-	}
-	/**
-	* Make a crash repair durable in ONE transaction: DELETE the torn tail (from
-	* `tornMarker`), rewind the head cursor to the last surviving event, INSERT
-	* the synthetic `closers`, and bump the revision once. After COMMIT the
-	* stored rows == the balanced log.
-	*/
-	async commitRepair(meta, tornMarker, closers) {
-		await this.ready;
-		const persistedClosers = closers.filter(isPersistedEvent);
-		if (tornMarker === void 0 && persistedClosers.length === 0) return;
-		await this.backend.transaction(async (tx) => {
-			if (tornMarker !== void 0) {
-				await tx.deleteBridgeTail(meta.id, tornMarker);
-				const prev = await tx.getPrevBridge(meta.id, tornMarker - 1);
-				if (prev === void 0) await tx.updateHead(meta.id, "", -1);
-				else await tx.updateHead(meta.id, prev.fEventId, prev.fSequence);
-			}
-			if (persistedClosers.length > 0) {
-				const last = await tx.getLastBridge(meta.id);
-				const { headEventId, headSequence } = await appendEventTail(tx, meta, persistedClosers, {
-					parentId: last?.fEventId ?? "",
-					nextSeq: (last?.fSequence ?? -1) + 1
-				});
-				await tx.updateHead(meta.id, headEventId, headSequence);
-			}
-			await tx.bumpRevision(meta.id);
-		});
-		const row = await this.backend.getSession(meta.id);
-		this.writeGuard.confirmHead(meta.id, row?.fHeadSequence ?? -1);
-	}
-	/**
-	* 一次性清洗一个 session 的 surface/provenance 坐标到稠密空间并写回。
-	*
-	* 旧数据（rewind 前的代码写入）的 `sourceEventSeqs`、`surfaceOp` replace
-	* range 与 compaction `shadowedRange` 是上游坐标，读取时每次都要做坐标
-	* 解析对齐；清洗用与读取完全相同的解析（稠密优先 + 上游映射 + 剪枝 +
-	* replace provenance 补全）把它们重写为稠密坐标，之后读取无需再对齐
-	* （对已清洗数据解析恒为恒等）。torn tail 片段不参与（读取路径也不会
-	* 保留它们）。返回实际变更的事件数。
-	*/
-	async cleanseSession(id, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const eventRows = await this.backend.getEventRows(id);
-		if (eventRows.length === 0) return { changed: 0 };
-		const { preserved } = scanRows(eventRows, 0, buildSeqMap(eventRows), new Map(eventRows.map((r) => [r.fSequence, r.fKind])));
-		normalizeSurfaceReplaceProvenance(preserved);
-		const bySeq = new Map(preserved.map((event) => [event.seq, event]));
-		const updates = [];
-		for (const row of eventRows) {
-			const event = bySeq.get(row.fSequence);
-			if (event === void 0) continue;
-			const surface = event;
-			const newSeqs = surface.sourceEventSeqs === void 0 ? null : JSON.stringify(surface.sourceEventSeqs);
-			const newOp = surface.surfaceOp === void 0 ? null : JSON.stringify(surface.surfaceOp);
-			const fields = {};
-			if (newSeqs !== row.fSourceEventSeqs) fields.fSourceEventSeqs = newSeqs;
-			if (newOp !== row.fSurfaceOp) fields.fSurfaceOp = newOp;
-			if (row.fKind === "compaction/summary" || row.fKind === "compaction/prune") {
-				const storedData = JSON.parse(row.fData);
-				const newData = event.data;
-				if (JSON.stringify(storedData.shadowedRange) !== JSON.stringify(newData.shadowedRange)) fields.fData = JSON.stringify(event.data);
-			}
-			if (Object.keys(fields).length > 0) updates.push({
-				fSequence: row.fSequence,
-				...fields
-			});
-		}
-		if (updates.length === 0) return { changed: 0 };
-		await this.backend.transaction(async (tx) => {
-			for (const update of updates) await tx.updateEventFields(id, update.fSequence, {
-				...update.fSourceEventSeqs === void 0 ? {} : { fSourceEventSeqs: update.fSourceEventSeqs },
-				...update.fSurfaceOp === void 0 ? {} : { fSurfaceOp: update.fSurfaceOp },
-				...update.fData === void 0 ? {} : { fData: update.fData }
-			});
-		});
-		return { changed: updates.length };
-	}
-	/** List all materialized sessions' metadata (every row is a materialized session). */
-	async list(signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const rows = await this.backend.listSessions();
-		signal?.throwIfAborted();
-		return rows.map(rowToMeta);
-	}
-	/** List metadata with a source-qualified monotonic revision per session. */
-	async listSnapshots(signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const rows = await this.backend.listSessions();
-		signal?.throwIfAborted();
-		return rows.map((row) => ({
-			header: rowToMeta(row),
-			revision: SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`)
-		}));
-	}
-	/** Close the database connection (awaited by the coordinator's dispose, post-drain). */
-	async close() {
-		await this.ready;
-		await this.backend.close();
-	}
-	/**
-	* 同包分支 provider 的内部访问面（rewind / forkFrom 共享后端与写路径）。
-	* @internal 仅供 `SessionBranchRdbProvider` 使用；不是公开 API。
-	*/
-	internals() {
-		return {
-			backend: this.backend,
-			writeGuard: this.writeGuard,
-			create: (meta) => this.create(meta),
-			append: (id, events) => this.append(id, events),
-			load: (id) => this.load(id),
-			inspect: (id, signal) => this.inspect(id, signal),
-			readFrom: (id, fromSeq, signal) => this.readFrom(id, fromSeq, signal),
-			listSnapshots: (signal) => this.listSnapshots(signal),
-			readStoredRevision: (id, signal) => this.readStoredRevision(id, signal)
-		};
-	}
-};
-/**
-* Build the configured backend. The PostgreSQL arm creates the `node-postgres`
-* pool here (its identity base comes from the parsed pool options); tests
-* inject a drizzle PG instance directly via {@link PostgresBackend}.
-*/
-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 ?? ""
-		].join(":"),
-		close: () => pool.end()
-	});
-}
-/**
-* Serialize an event's surface-metadata fields for SQL binding. Both fields are
-* nullable TEXT columns — null when the event has no surface metadata (non-surface
-* events, events written before surface support).
-*
-* `sourceEventSeqs` references events by UPSTREAM seq. Delta events dropped at
-* write time never get a persisted row, so a reference to one can never be
-* remapped on read — keeping it verbatim produces a `source >= current seq`
-* provenance violation when the log is replayed as a session seed. The write
-* path therefore prunes references through {@link WriteGuard.pruneRefs}; a
-* fully pruned list is stored as null (no provenance).
-* @param event - the event to serialize.
-* @param prune - prunes references to dropped deltas before binding. Defaults
-*   to identity (e.g. repair closers, which never carry provenance).
-*/
-function surfaceBindings(event, prune = (refs) => refs) {
-	const se = event;
-	const sourceSeqs = se.sourceEventSeqs === void 0 ? void 0 : prune(se.sourceEventSeqs);
-	return [sourceSeqs !== void 0 && sourceSeqs.length > 0 ? JSON.stringify(sourceSeqs) : null, se.surfaceOp !== void 0 ? JSON.stringify(se.surfaceOp) : null];
-}
-/**
-* Durably append one batch of persisted events to a session's tail inside the
-* enclosing transaction: mint each event's row (parent chain + playpen
-* dimensions + surface-metadata columns) and its bridge row, land both as ONE
-* multi-row INSERT each (N events are 2 statements instead of 2N), and return
-* the resulting head cursor.
-*
-* The anchor is the caller's responsibility: a normal append starts from the
-* head cursor (`head.fHeadEventId` / `head.fHeadSequence + 1`), while
-* crash-repair closers start from the ACTUAL tail row (the head cursor can lag
-* a hand-written torn tail). Both callers then persist the returned cursor via
-* {@link BackendTx.updateHead}.
-* @param tx - the enclosing transaction.
-* @param meta - the session being written (`meta.id` drives the bridge rows).
-* @param events - persisted events to append (callers already filtered out
-*   ephemeral/ignorable events; non-empty).
-* @param anchor - the parent event id to chain from and the next dense seq.
-* @param prune - forwarded to {@link surfaceBindings}; defaults to identity
-*   (repair closers never carry provenance).
-* @returns the new head cursor (last event id + its dense seq).
-*/
-async function appendEventTail(tx, meta, events, anchor, prune = (refs) => refs) {
-	let parentId = anchor.parentId;
-	let nextSeq = anchor.nextSeq;
-	const eventRows = [];
-	const bridgeRows = [];
-	for (const event of events) {
-		const eventId = randomUUID();
-		const { role, name, actionId } = eventDimensions(event);
-		const [surfaceSeqs, surfaceOp] = surfaceBindings(event, prune);
-		eventRows.push({
-			fEventId: eventId,
-			fParentId: parentId,
-			fKind: event.type,
-			fRole: role,
-			fName: name,
-			fActionId: actionId,
-			fEncoding: EVENT_ENCODING,
-			fData: JSON.stringify(event.data),
-			fCreatedAt: event.time,
-			fOriginalSeq: event.seq,
-			fSourceEventSeqs: surfaceSeqs,
-			fSurfaceOp: surfaceOp
-		});
-		bridgeRows.push({
-			fSessionId: meta.id,
-			fEventId: eventId,
-			fSequence: nextSeq
-		});
-		parentId = eventId;
-		nextSeq++;
-	}
-	await tx.insertEvents(eventRows);
-	await tx.insertBridges(bridgeRows);
-	return {
-		headEventId: parentId,
-		headSequence: nextSeq - 1
-	};
-}
-//#endregion
-export { EPHEMERAL_EVENT_TYPES, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, locateTurnEnd };
-
-//# sourceMappingURL=index.mjs.map