@sema-agent/server 7.146.0 → 7.148.0

package/dist/stores-sql/session-policy-store-sql.js

@@ -5,6 +5,7 @@ import { decodeJsonColumn, isJsonColumnBodyProblem, jsonColumnText } from "../pl
 import { pgHasUnstorable } from "../plugins/pg-safe-json.js";
 import { mysqlDriver, pgDriver } from "../plugins/sql-driver.js";
 import { isDupKeyError, retryOnDeadlock } from "../plugins/sql-errors.js";
+import { createLogger } from "../observability/logger.js";
 export const policyKeyFor = (sessionId, principal) => createHash("sha256").update(JSON.stringify([sessionId, principal ?? null])).digest("hex");
 const policyKey = policyKeyFor;
 const RULES = SESSION_RULES_COLUMN.name;
@@ -50,16 +51,47 @@ function readRowCounters(r, where) {
     return { rev, gen };
 }
 const SEALED_MARK_REV = Number.MAX_SAFE_INTEGER;
-const SEALED_EVENT = "session_policy_erase_sealed_keys";
+export const SEALED_EVENT = "session_policy_erase_sealed_keys";
 const NO_SEALED_KEYS = [];
 function sealedKeyError(sessionId, what) {
     return new SessionPolicyError("corrupt", `session rules for session ${JSON.stringify(sessionId)}: ${what} is sealed — an erase removed a row whose counters were unreadable (session_policy_rev_mark.rev = ${SEALED_MARK_REV}), so its rule state is unknown; refusing rather than serve it as "no rules" until an operator unseals it (USAGE §9.11)`);
 }
+export async function eraseSessionPolicyRowsOn(conn, dialect, sessionIds) {
+    if (sessionIds.length === 0)
+        return NO_SEALED_KEYS;
+    const q = (mysql, pg) => (dialect === "mysql" ? mysql : pg);
+    const idHoles = sessionIds.map((_, i) => (dialect === "mysql" ? "?" : `$${i + 1}`)).join(",");
+    const { rows } = await conn.query(`SELECT policy_key, session_id, rev, gen FROM session_policy WHERE session_id IN (${idHoles}) ORDER BY policy_key FOR UPDATE`, [...sessionIds]);
+    if (rows.length === 0)
+        return NO_SEALED_KEYS;
+    const now = new Date();
+    const keys = rows.map((r) => String(r.policy_key));
+    const params = [];
+    const sealedKeys = [];
+    const tuples = rows.map((r) => {
+        const sessionId = String(r.session_id);
+        const counters = readRowCounters(r, `for session ${JSON.stringify(sessionId)} (erase)`);
+        const readable = !("problem" in counters) && isStoredCounter(counters.gen + 1, 0);
+        if (!readable)
+            sealedKeys.push({ policyKey: String(r.policy_key), rev: String(r.rev), gen: String(r.gen) });
+        params.push(String(r.policy_key), sessionId, readable ? counters.rev : SEALED_MARK_REV, readable ? counters.gen + 1 : 0, now);
+        const base = params.length - 5;
+        return dialect === "mysql" ? "(?,?,?,?,?)" : `($${base + 1},$${base + 2},$${base + 3},$${base + 4},$${base + 5})`;
+    });
+    await conn.query(q(`INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
+        " ON DUPLICATE KEY UPDATE rev = GREATEST(session_policy_rev_mark.rev, VALUES(rev)), gen = GREATEST(session_policy_rev_mark.gen + 1, VALUES(gen)), erased_at = VALUES(erased_at)", `INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
+        " ON CONFLICT (policy_key) DO UPDATE SET rev = GREATEST(session_policy_rev_mark.rev, EXCLUDED.rev), gen = GREATEST(session_policy_rev_mark.gen + 1, EXCLUDED.gen), erased_at = EXCLUDED.erased_at"), params);
+    const holes = keys.map((_, i) => (dialect === "mysql" ? "?" : `$${i + 1}`)).join(",");
+    await conn.query(`DELETE FROM session_policy WHERE policy_key IN (${holes})`, keys);
+    return sealedKeys;
+}
 export class SqlSessionPolicyStore {
     db;
+    countClientWrite;
     logger;
-    constructor(db, logger) {
+    constructor(db, countClientWrite, logger) {
         this.db = db;
+        this.countClientWrite = countClientWrite;
         this.logger = logger;
     }
     q(mysql, pg) {
@@ -94,6 +126,7 @@ export class SqlSessionPolicyStore {
     async putRules(sessionId, principal, rules, opts) {
         const key = policyKey(sessionId, principal);
         return this.retrying(() => this.tx(async (conn) => {
+            const root = await conn.query(this.q("SELECT session_id FROM session_meta WHERE session_id = ? FOR UPDATE", "SELECT session_id FROM session_meta WHERE session_id = $1 FOR UPDATE"), [sessionId]);
             const { rows } = await conn.query(this.q(`SELECT ${jsonColumnText("mysql", RULES)}, rev, gen FROM session_policy WHERE policy_key = ? FOR UPDATE`, `SELECT ${jsonColumnText("pg", RULES)}, rev, gen FROM session_policy WHERE policy_key = $1 FOR UPDATE`), [key]);
             const prior = rows[0] ? rowToStored(rows[0], `for session ${JSON.stringify(sessionId)} (pre-write snapshot)`) : undefined;
             const priorRev = prior?.rev ?? 0;
@@ -115,6 +148,8 @@ export class SqlSessionPolicyStore {
             if (!isStoredCounter(nextRev, 1) || !isStoredCounter(nextGen, 0)) {
                 throw new SessionPolicyError("corrupt", `session rules for session ${JSON.stringify(sessionId)}: the next stamp (rev ${nextRev}, gen ${nextGen}) would leave the safe-integer range this store reads back — refusing before writing a row nothing could read`);
             }
+            if (root.rows.length > 0)
+                await this.countClientWrite(conn, this.db.dialect, sessionId);
             const json = JSON.stringify(clean);
             const now = new Date();
             if (prior) {
@@ -132,30 +167,7 @@ export class SqlSessionPolicyStore {
         return retryOnDeadlock(this.db.dialect, attempt, (e) => this.isDupKey(e));
     }
     async deleteBySession(sessionId) {
-        const sealed = await this.retrying(() => this.tx(async (conn) => {
-            const { rows } = await conn.query(this.q("SELECT policy_key, rev, gen FROM session_policy WHERE session_id = ? ORDER BY policy_key FOR UPDATE", "SELECT policy_key, rev, gen FROM session_policy WHERE session_id = $1 ORDER BY policy_key FOR UPDATE"), [sessionId]);
-            if (rows.length === 0)
-                return NO_SEALED_KEYS;
-            const now = new Date();
-            const keys = rows.map((r) => String(r.policy_key));
-            const params = [];
-            const sealedKeys = [];
-            const tuples = rows.map((r) => {
-                const counters = readRowCounters(r, `for session ${JSON.stringify(sessionId)} (erase)`);
-                const readable = !("problem" in counters) && isStoredCounter(counters.gen + 1, 0);
-                if (!readable)
-                    sealedKeys.push({ policyKey: String(r.policy_key), rev: String(r.rev), gen: String(r.gen) });
-                params.push(String(r.policy_key), sessionId, readable ? counters.rev : SEALED_MARK_REV, readable ? counters.gen + 1 : 0, now);
-                const base = params.length - 5;
-                return this.db.dialect === "mysql" ? "(?,?,?,?,?)" : `($${base + 1},$${base + 2},$${base + 3},$${base + 4},$${base + 5})`;
-            });
-            await conn.query(this.q(`INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
-                " ON DUPLICATE KEY UPDATE rev = GREATEST(session_policy_rev_mark.rev, VALUES(rev)), gen = GREATEST(session_policy_rev_mark.gen + 1, VALUES(gen)), erased_at = VALUES(erased_at)", `INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
-                " ON CONFLICT (policy_key) DO UPDATE SET rev = GREATEST(session_policy_rev_mark.rev, EXCLUDED.rev), gen = GREATEST(session_policy_rev_mark.gen + 1, EXCLUDED.gen), erased_at = EXCLUDED.erased_at"), params);
-            const holes = keys.map((_, i) => (this.db.dialect === "mysql" ? "?" : `$${i + 1}`)).join(",");
-            await conn.query(`DELETE FROM session_policy WHERE policy_key IN (${holes})`, keys);
-            return sealedKeys;
-        }));
+        const sealed = await this.retrying(() => this.tx((conn) => eraseSessionPolicyRowsOn(conn, this.db.dialect, [sessionId])));
         if (sealed.length > 0)
             this.discloseSealed(sessionId, sealed);
     }
@@ -165,15 +177,11 @@ export class SqlSessionPolicyStore {
             keys,
             note: "these rows' counters were unreadable, so the erase could not end their lineage: each key now carries a sealed rev mark and answers every read and write with SessionPolicyError corrupt until an operator unseals its session_policy_rev_mark row in place (USAGE §9.11)",
         };
-        if (this.logger === undefined) {
-            console.warn(`[session-policy] ${SEALED_EVENT}`, fields);
-            return;
-        }
         try {
             this.logger.warn(SEALED_EVENT, fields);
         }
-        catch (err) {
-            console.warn(`[session-policy] ${SEALED_EVENT} — the injected logger threw (${err instanceof Error ? err.message : String(err)})`, fields);
+        catch {
+            createLogger().warn(SEALED_EVENT, fields);
         }
     }
     async tx(fn) {
@@ -198,13 +206,13 @@ export class SqlSessionPolicyStore {
     }
 }
 export class TiDBSessionPolicyStore extends SqlSessionPolicyStore {
-    constructor(pool, logger) {
-        super(mysqlDriver(pool), logger);
+    constructor(pool, countClientWrite, logger) {
+        super(mysqlDriver(pool), countClientWrite, logger);
     }
 }
 export class PgSessionPolicyStore extends SqlSessionPolicyStore {
-    constructor(pool, logger) {
-        super(pgDriver(pool), logger);
+    constructor(pool, countClientWrite, logger) {
+        super(pgDriver(pool), countClientWrite, logger);
     }
 }
 //# sourceMappingURL=session-policy-store-sql.js.map

package/dist/stores-sql/session-write-hooks.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 会话店的**事务内钩**(部署在店的写事务里参与的唯一一扇门)—— 店写的是引擎座表(`session_meta` / `session_event`),部署记在会话上的格与认领住部署自己的表;
+ * 跨两边的「同一事务」只经这里:店锁住根 `session_meta` 行之后、写之前,把**本事务的语句面**交给部署,部署读自己的认领、写自己的格,答放行或拒。
+ *
+ * ## 形 = 引擎 SQL 店包的钩表(`@sema-agent/core-stores-sql` 的 `SqlTransactionHooks.session.beforeCommit`)
+ * {@link SessionWriteHooks.beforeCommit} 与包里那一只同名、同调用时刻(根行锁住之后、写之前)、同语句面(本事务连接的 `query`)、同写闭集
+ * (`import` / `delete` / `retention-delete`;本服务另加 `erase`)。本仓还不依赖那只包 ⇒ 型在这里声明;店随包搬家时改从包根取型。与包的形只差一处,是向引擎的请托:
+ * 拒的载荷 —— 包里是一句话(`{ refuse: string }`),这里是部署的具名错误(`{ refuse: Error }`):导入 / 删除的调用方按错误的型答各自的 wire 码
+ * (409 `session_active` / `conflict.session_writer`),一句话答不出。
+ *
+ * ## 同事务两句,不是同一句 UPDATE
+ * 认领(`task_active`)与部署格住的表都不是根行所在的表 ⇒ 一句 UPDATE 里拿不到「锁住根行 + 当前读别的表」:PG 读已提交下子查询读的是语句快照、
+ * 不对别的表的行加锁,也不在 EvalPlanQual 里复判它们。所以是**两句**:店先 `FOR UPDATE` 锁根行(删除 / 重登记 / 改属主都要先拿这把锁),
+ * 再在**同一连接**上交出语句面,部署用新语句锁定读(PG 新快照、TiDB 当前读)。钩里的写随店的事务提交或回滚(店拒、或任何一步抛,一起撤)。
+ *
+ * ## 键控 fork(服务扩展,包里没有)
+ * 调用方给目标 id 与键的 fork(`forkTo`)是本服务的扩展:键是部署格,在建目标行的同一事务里由 {@link SessionWriteHooks.keyedFork} 记下;撞上已在的目标时
+ * 读它的属主与键。包随店搬家时这一组是向引擎的请托(带目标 id 与键的 fork,或钩表多一组)。
+ */
+/** 店交给钩的语句面:本事务自己的连接(与包的 `SqlStatementFace` 同形:`query` 答行 + 受影响行数)。 */
+export interface SessionTxStatements {
+    query(sql: string, params?: unknown[]): Promise<{
+        readonly rows: ReadonlyArray<Readonly<Record<string, unknown>>>;
+        readonly affected: number;
+    }>;
+}
+/**
+ * 改动会话树根的写(闭集;前三个词与包同一组,`erase` 是本服务的扩展 —— 向引擎的请托同上):
+ *  · `import` —— 导入写口(整段新建、整段换装、暂存提交)落定这一行:根行已被本事务锁住 / 占下;
+ *  · `delete` —— 不经删除协调器的删一行(提交出口的条件撤回):根行已被本事务锁住;
+ *  · `retention-delete` —— 留存删除一棵会话树的根(留存座的事务;根行已锁);
+ *  · `erase` —— 删净一只在删会话(执行器 `stores-sql/retention-store-sql.ts` 的 `eraseSession`,删除协调器的执行体):这一行必须处于 `token` 那一次删除的在删态
+ *    (会话三态 活 → 在删 → 没了,围栏在 `plugins/session-store-sql.ts` 的删除面);根行已被本事务锁住。
+ */
+export type SessionWrite = {
+    readonly op: "import" | "delete" | "retention-delete";
+    readonly rootSessionId: string;
+} | {
+    readonly op: "erase";
+    readonly rootSessionId: string;
+    readonly token: string;
+};
+/** 钩的答案:放行,或拒(店回滚、一个字节不写、原样抛这只错)。 */
+export type SessionWriteVerdict = "proceed" | {
+    readonly refuse: Error;
+};
+/** 键控 fork 撞上已在的目标时,那一行的属主与 fork 键(一次读;`undefined` = 行不在)。 */
+export interface ForkTargetReading {
+    readonly owner: string | null;
+    readonly forkKey: string | null;
+}
+/** 部署交给会话店的钩表(组合座装配)。 */
+export interface SessionWriteHooks {
+    /** 根行锁住之后、写之前调(同一事务、同一连接)。 */
+    beforeCommit(txn: SessionTxStatements, write: SessionWrite): Promise<SessionWriteVerdict>;
+    /** 键控 fork(服务扩展):`record` 在建目标行的同一事务里记下键(目标行是本事务刚插下的);`targetOf` = 撞上已在的目标时那一行的属主与键。 */
+    readonly keyedFork: {
+        record(txn: SessionTxStatements, fork: {
+            readonly rootSessionId: string;
+            readonly forkKey: string;
+        }): Promise<void>;
+        targetOf(sessionId: string): Promise<ForkTargetReading | undefined>;
+    };
+}
+//# sourceMappingURL=session-write-hooks.d.ts.map

package/dist/stores-sql/session-write-hooks.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-write-hooks.js.map

package/dist/{plugins → stores-sql}/tidb-session-storage.d.ts

@@ -1,11 +1,11 @@
-import { BaseSessionStorage, type SessionMetadata, type SessionTreeEntry, type SessionWriteOptions } from "@sema-agent/core";
+import { type SessionMetadata, type SessionTreeEntry, type SessionWriteOptions } from "@sema-agent/core";
 import type { Pool } from "mysql2/promise";
+import { WindowedSessionStorage } from "./windowed-session-storage.js";
 export declare const SESSION_EVENT_LATEST_BY_TYPE_SQL: {
     readonly floor: `SELECT /*+ USE_INDEX(session_event, idx_session_event_type) */ ${string} FROM session_event WHERE session_id = ? AND type = 'compaction' ORDER BY seq DESC LIMIT 1`;
-    readonly epochAnchor: `SELECT /*+ USE_INDEX(session_event, idx_session_event_type) */ seq, ${string} FROM session_event WHERE session_id = ? AND seq < ? AND type IN ('prompt_epoch','compaction') ORDER BY seq DESC LIMIT 100`;
 };
 /**
- * TiDB-backed {@link BaseSessionStorage} — the durable L1 event log for one session.
+ * TiDB-backed session storage — the durable L1 event log for one session (the window view and its reads: {@link WindowedSessionStorage}).
  *
  * - `appendEntry` / `setLeafId` persist under an **atomic compare-and-set on `leaf_id`** (core's F2
  *   optimistic-lock seam): the conditional UPDATE's only predicate is `leaf_id <=> ?`, so a write lands
@@ -14,22 +14,23 @@ export declare const SESSION_EVENT_LATEST_BY_TYPE_SQL: {
  *   `isSessionConflict`), with the `(session_id, seq)` primary key as the backstop for a racing writer
  *   that grabbed the same seq. ([ref] 件2 更正:`leaf_seq` **不是**判据 —— 它是无条件的 `SET leaf_seq =
  *   leaf_seq + 1` 计数器,在同一事务内重读出来给事件铸 `seq`,从不进 WHERE。)
- * - The in-memory base tree is the wake-time snapshot; every write is also mirrored into it so the
- *   live harness keeps reading a consistent view. Wake is **bounded** to `[floor .. leaf]` (F3,
+ * - The window (core's in-memory storage, composed) is the wake-time snapshot; every write lands here first and is then
+ *   recorded into it so the live harness keeps reading a consistent view. Wake is **bounded** to `[floor .. leaf]` (F3,
  *   core 1.6.0 branch-floor seam); older history is covered by the last compaction's summary.
  */
-export declare class TiDBSessionStorage extends BaseSessionStorage {
+export declare class TiDBSessionStorage extends WindowedSessionStorage {
     private readonly pool;
     private readonly sessionId;
     private readonly floorSeq;
     constructor(pool: Pool, sessionId: string, metadata: SessionMetadata, entries: SessionTreeEntry[], leafId: string | null, floorEntryId?: string | null, floorSeq?: number);
     /**
-     * [ref] S3 [ref] pull seam — `SessionStorage.getEpochAnchor?()`: the nearest prompt-epoch carrier BELOW the
+     * [ref] S3 [ref] pull seam — `SessionStorage.getEpochAnchor?()`: the nearest prompt-epoch carrier on the branch BELOW the
      * bounded-wake floor, AS STORED (engine 7.52.0: `Promise<unknown>`; the engine reads the record, a retired shape
      * included). The engine's `Session.getPromptEpoch()` asks for it only when the in-window branch walk finds no carrier
      * (a rewind/resumeAt cut inside the kept tail; compactions without a restatement). The one reading of every windowed
-     * storage (both SQL twins, the local leg's view window) is {@link scanEpochAnchor}; this backend supplies its page query
-     * (keyset-paged to exhaustion) and decodes its own rows.
+     * storage (both SQL twins, the local leg's view window) is {@link scanEpochAnchor} — it walks the floor entry's parent
+     * chain, not the row order; this backend supplies the twins' page ({@link epochAnchorPageSql}, keyset-paged to
+     * exhaustion) and decodes its own carrier rows.
      */
     getEpochAnchor(): Promise<unknown>;
     /**
@@ -43,21 +44,19 @@ export declare class TiDBSessionStorage extends BaseSessionStorage {
      * helper trims a FULL-loaded path in memory, whereas we compute the floor seq first and only `SELECT
      * seq >= floorSeq` — so the head never leaves cold storage. Our sessions are LINEAR (no fork), so
      * seq-order == root→leaf path-order and our `seq >= floorSeq` tail is byte-identical to
-     * `boundedTail(path).tail`; the resulting floored `BaseSessionStorage.buildContext()` matches a
+     * `boundedTail(path).tail`; the resulting floored window's `buildContext()` matches a
      * full-tree wake (core's `session-floor.test.ts`). If branching is ever added, switch to `boundedTail`.
      */
     static wake(pool: Pool, sessionId: string): Promise<TiDBSessionStorage | null>;
     /** The bounded-window floor = last compaction's firstKeptEntryId (and its seq). */
     private static computeFloor;
-    /** Sub-floor lookups (e.g. a label target) aren't in the loaded tail — fall back to the durable log. */
-    getEntry(id: string): Promise<SessionTreeEntry | undefined>;
-    appendEntry(entry: SessionTreeEntry, opts?: SessionWriteOptions): Promise<void>;
-    setLeafId(leafId: string | null, opts?: SessionWriteOptions): Promise<void>;
+    /** Sub-floor lookups (e.g. a label target) aren't in the loaded tail — read the durable log. */
+    protected readBelowFloor(id: string): Promise<SessionTreeEntry | undefined>;
     /**
      * Atomically: CAS the meta leaf (+bump leaf_seq), then append the event at the new seq.
      * The `(session_id, seq)` primary key is the backstop — a racing writer that grabbed the same
      * seq makes our INSERT fail with a duplicate-key, which we translate to a conflict too.
      */
-    private persist;
+    protected persist(entry: SessionTreeEntry, opts?: SessionWriteOptions): Promise<void>;
 }
 //# sourceMappingURL=tidb-session-storage.d.ts.map

package/dist/{plugins → stores-sql}/tidb-session-storage.js

@@ -1,36 +1,36 @@
 import { emitLeafAdvance } from "../session-leaf-bus.js";
-import { BaseSessionStorage, SessionError, leafIdAfterEntry, } from "@sema-agent/core";
-import { toIso } from "./sql-row-helpers.js";
-import { isMysqlDupKeyError } from "./sql-errors.js";
-import { PLACEMENT_SELECT_COLUMNS, placementFromRow } from "./session-placement.js";
+import { SessionError, leafIdAfterEntry, } from "@sema-agent/core";
+import { toIso } from "../plugins/sql-row-helpers.js";
+import { isMysqlDupKeyError } from "../plugins/sql-errors.js";
+import { PLACEMENT_SELECT_COLUMNS, placementFromRow } from "../plugins/session-placement.js";
 import { decodeSessionEventPayload } from "./session-event-payload.js";
-import { scanEpochAnchor } from "./session-epoch-anchor.js";
-import { jsonColumnText } from "./sql-json-column.js";
-import { incarnationFromCell } from "../session-incarnation.js";
+import { epochAnchorPageSql, epochFloorOf, scanEpochAnchor, sqlEpochAnchorRowOf } from "../plugins/session-epoch-anchor.js";
+import { jsonColumnText } from "../plugins/sql-json-column.js";
+import { forkLineageOfRow, incarnationFromCell } from "../session-incarnation.js";
+import { WindowedSessionStorage } from "./windowed-session-storage.js";
 const SESSION_EVENT_BY_TYPE_HINT = "/*+ USE_INDEX(session_event, idx_session_event_type) */";
 export const SESSION_EVENT_LATEST_BY_TYPE_SQL = {
     floor: `SELECT ${SESSION_EVENT_BY_TYPE_HINT} ${jsonColumnText("mysql", "payload")} FROM session_event WHERE session_id = ? AND type = 'compaction' ORDER BY seq DESC LIMIT 1`,
-    epochAnchor: `SELECT ${SESSION_EVENT_BY_TYPE_HINT} seq, ${jsonColumnText("mysql", "payload")} FROM session_event WHERE session_id = ? AND seq < ? AND type IN ('prompt_epoch','compaction') ORDER BY seq DESC LIMIT 100`,
 };
 const isDupKey = isMysqlDupKeyError;
-export class TiDBSessionStorage extends BaseSessionStorage {
+export class TiDBSessionStorage extends WindowedSessionStorage {
     pool;
     sessionId;
     floorSeq;
     constructor(pool, sessionId, metadata, entries, leafId, floorEntryId = null, floorSeq = 0) {
-        super(metadata, entries, leafId, { floorEntryId });
+        super(metadata, entries, leafId, floorEntryId);
         this.pool = pool;
         this.sessionId = sessionId;
         this.floorSeq = floorSeq;
     }
     async getEpochAnchor() {
-        return scanEpochAnchor(this.floorSeq, async (beforeSeq) => {
-            const [rows] = await this.pool.query(SESSION_EVENT_LATEST_BY_TYPE_SQL.epochAnchor, [this.sessionId, beforeSeq]);
-            return rows.map((r) => ({ seq: r.seq, payload: r.payload }));
+        return scanEpochAnchor(epochFloorOf(this.floorSeq, await this.windowFloorEntry()), async (beforeSeq) => {
+            const [rows] = await this.pool.query(epochAnchorPageSql("mysql"), [this.sessionId, beforeSeq]);
+            return rows.map(sqlEpochAnchorRowOf);
         }, (row) => decodeSessionEventPayload(row.payload, this.sessionId, row.seq));
     }
     static async wake(pool, sessionId) {
-        const [metaRows] = await pool.query(`SELECT created_at, leaf_id, leaf_seq, incarnation, ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = ?`, [sessionId]);
+        const [metaRows] = await pool.query(`SELECT created_at, leaf_id, leaf_seq, incarnation, ${PLACEMENT_SELECT_COLUMNS}, forked_from, forked_from_incarnation FROM session_meta WHERE session_id = ?`, [sessionId]);
         const meta = metaRows[0];
         if (!meta)
             return null;
@@ -38,7 +38,13 @@ export class TiDBSessionStorage extends BaseSessionStorage {
         const [eventRows] = await pool.query(`SELECT seq, ${jsonColumnText("mysql", "payload")} FROM session_event WHERE session_id = ? AND seq >= ? ORDER BY seq ASC`, [sessionId, floorSeq]);
         const entries = eventRows.map((r) => decodeSessionEventPayload(r.payload, sessionId, r.seq));
         const placement = placementFromRow(meta);
-        const metadata = { id: sessionId, createdAt: toIso(meta.created_at), incarnation: incarnationFromCell(sessionId, meta.incarnation), ...(placement !== undefined ? { placement } : {}) };
+        const metadata = {
+            id: sessionId,
+            createdAt: toIso(meta.created_at),
+            incarnation: incarnationFromCell(sessionId, meta.incarnation),
+            ...(placement !== undefined ? { placement } : {}),
+            ...forkLineageOfRow(sessionId, meta.forked_from, meta.forked_from_incarnation),
+        };
         return new TiDBSessionStorage(pool, sessionId, metadata, entries, meta.leaf_id ?? null, floorEntryId, floorSeq);
     }
     static async computeFloor(pool, sessionId) {
@@ -54,24 +60,12 @@ export class TiDBSessionStorage extends BaseSessionStorage {
             return { floorEntryId: null, floorSeq: 0 };
         return { floorEntryId: fk, floorSeq: Number(seqRows[0].seq) };
     }
-    async getEntry(id) {
-        const inMem = await super.getEntry(id);
-        if (inMem)
-            return inMem;
+    async readBelowFloor(id) {
         const [rows] = await this.pool.query(`SELECT ${jsonColumnText("mysql", "payload")} FROM session_event WHERE session_id = ? AND entry_id = ?`, [this.sessionId, id]);
         if (rows[0] === undefined)
             return undefined;
         return decodeSessionEventPayload(rows[0].payload, this.sessionId, id);
     }
-    async appendEntry(entry, opts) {
-        await this.persist(entry, opts);
-        this.recordEntry(entry);
-    }
-    async setLeafId(leafId, opts) {
-        const leafEntry = this.createLeafEntry(leafId);
-        await this.persist(leafEntry, opts);
-        this.recordEntry(leafEntry);
-    }
     async persist(entry, opts) {
         const newLeaf = leafIdAfterEntry(entry);
         const conditional = opts !== undefined && opts.expectedLeafId !== undefined;