@sema-agent/server 7.137.0 → 7.139.0

package/dist/plugins/permission-rule-store-sql.js

@@ -3,8 +3,8 @@ import { z } from "zod";
 import { applyTombstones, assertDeleteDeltaCarriesNoAdd, assertRedemptionNotQuarantined, assertWriteDeltaScopeDurable, foldDelta, isValidDurableScope, parseRuleText, readRowBehavior, screenRuleSyncState, PERMISSION_RULE_WRITER, RULE_ADD_ORIGINS, RULE_APPROVAL_KINDS, RULE_APPROVAL_RECORD_SCHEMA, RULE_APPROVAL_STATES, RULE_BEHAVIORS, RULE_SYNC_DROP_CODES, EDITED_RULE_BREADTH_WARNING_CODES, PERSISTED_RULE_MATCHES, EMPTY_DURABLE_RULE_PARTITION, PERMISSION_RULES_LATER_GRAMMAR_CODE, SESSION_RULES_GRAMMAR, readRuleGrammarStamp, readRuleOwner, principalNameOf, readRuleOffer2, } from "@sema-agent/core";
 import { dialectProtocolJsonEncoder, sqlDbNowMs, SQL_DB_NOW_MS } from "./sql-driver.js";
 import { isMissingColumnError } from "./sql-errors.js";
+import { describeProbedTableDrift } from "./schema-drift-sentence.js";
 import { canonicalJsonStringify } from "@sema-agent/core";
-import { isPersistedRuleTool } from "../permission-rule-vocab.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, jsonColumnText, readJsonObjectColumn, SqlJsonColumnError } from "./sql-json-column.js";
 import { redactSecrets } from "../trace/redact.js";
@@ -31,7 +31,7 @@ const PersistedRuleRowSchema = z
     .object({
     behavior: z.string().optional(),
     rule: z.string(),
-    tool: z.string().min(1).refine(isPersistedRuleTool, { message: "not a tool the persisted-rule grammar speaks for" }),
+    tool: z.string().min(1),
     match: z.enum(PERSISTED_RULE_MATCHES),
     command: z.string(),
     scope: DurableRuleScopeSchema,
@@ -145,8 +145,8 @@ export const TIDB_PERMISSION_RULE_STATEMENTS = [
     -- version:**数据格式版本**(= core \`RuleApprovalRecord.schema\`,本形恒 4 —— core 7.9.0 #625 由 3 升,
     -- 代码里的单点是 RULE_APPROVAL_RECORD_SCHEMA;OCC 守卫另在 rev,两轴禁混,schema-naming 门③ 白名单
     -- 登记)。读侧对非 4 的行(含上一形的 3)交还 design/375 §4.5 的
-    -- StaleRuleApprovalRecord 信封(identity 键 only)—— 本仓 SCHEMA POLICY 是删表重建,重建后的表
-    -- 不该有这种行,这一臂是「未来再换形」的防御位,绝不静默 widen 成一条本形担保不了的记录。
+    -- StaleRuleApprovalRecord 信封(identity 键 only)—— 这一臂是「未来再换形」的防御位,
+    -- 绝不静默 widen 成一条本形担保不了的记录。
     version INT NOT NULL,
     -- offers_json:core \`RuleOffer2[]\`(design/375 §4.1)—— 按 index 引用 candidates 的 OPTION 结构,
     -- **绝不存规则文本副本**(显示三元组由 core \`ruleOffersOfRecord\` 从候选文本投影;存副本=造一个
@@ -241,13 +241,11 @@ export async function assertPermissionRuleApprovalSchema(query, dialect) {
             `#340 card-edit columns (command / edited_json) and the design/375 record-form columns ` +
             `(version / offers_json / selected_offer): the approval record now stores its OPTION structure and the ` +
             `chosen offer, and the store refuses to read rows whose record-form version it cannot vouch for. ` +
-            `This repository ships no ` +
-            `ALTER TABLE migrations, so the table must be recreated: run \`DROP TABLE ${PERMISSION_RULE_APPROVAL_TABLE};\` on the ` +
-            `${dialect === "pg" ? "PostgreSQL" : "MySQL-protocol"} backend and restart — the schema is recreated at boot. ` +
-            `The cost is bounded: this table holds pending/settled approval RECORDS (the audit trail of who said yes to which ` +
-            `rule), not the rules themselves — persisted rules live in ${PERMISSION_RULE_TABLE} and are untouched. Dropping it ` +
-            `loses in-flight CC-import previews (re-runnable) and the historical record trail. ` +
-            `Underlying probe error: ${err instanceof Error ? err.message : String(err)}`);
+            `This table holds pending/settled approval RECORDS (the audit trail of who said yes to which ` +
+            `rule), not the rules themselves — persisted rules live in ${PERMISSION_RULE_TABLE} and are untouched; ` +
+            `an in-place ALTER keeps the record trail.\n` +
+            `Underlying probe error: ${err instanceof Error ? err.message : String(err)}\n\n` +
+            (await describeProbedTableDrift(query, dialect, [PERMISSION_RULE_APPROVAL_TABLE])));
     }
 }
 export async function assertPermissionRuleTicketSchema(query, dialect) {
@@ -261,12 +259,10 @@ export async function assertPermissionRuleTicketSchema(query, dialect) {
             `the #265 A7 three-state redemption columns (MINTED → CLAIMED → SETTLED, the claim generation that fences a superseded ` +
             `claimant, and the lane binding that keeps cc-import and local-import tickets from being interchangeable): without them a ` +
             `local-import ticket can be claimed but never settled, so a redemption that already wrote rules to the store answers its ` +
-            `owner with a retry-later it can never satisfy. This repository ships no ALTER TABLE migrations, so the table must be recreated: run ` +
-            `\`DROP TABLE ${PERMISSION_RULE_TICKET_TABLE};\` on the ${dialect === "pg" ? "PostgreSQL" : "MySQL-protocol"} backend and ` +
-            `restart — the schema is recreated at boot. The cost is bounded and small: this table holds minute-TTL single-use import ` +
-            `tickets (a governance transient that dies on expiry), so dropping it only makes anyone mid-preview re-run prepare; ` +
-            `persisted rules live in ${PERMISSION_RULE_TABLE} and are untouched. ` +
-            `Underlying probe error: ${err instanceof Error ? err.message : String(err)}`);
+            `owner with a retry-later it can never satisfy. This table holds minute-TTL single-use import ` +
+            `tickets (a governance transient that dies on expiry); persisted rules live in ${PERMISSION_RULE_TABLE} and are untouched.\n` +
+            `Underlying probe error: ${err instanceof Error ? err.message : String(err)}\n\n` +
+            (await describeProbedTableDrift(query, dialect, [PERMISSION_RULE_TICKET_TABLE])));
     }
 }
 export const PERMISSION_RULE_INDEXES = [
@@ -387,6 +383,19 @@ function decodeBucketRow(ownerKey, row) {
     const rules = rulesRaw.map((r) => ({ ...r, behavior: readBucketRowBehavior(r.behavior, "rule row", ownerKey) }));
     const tombstones = tombstonesRaw.map((t) => ({ ...t, behavior: readBucketRowBehavior(t.behavior, "tombstone", ownerKey) }));
     const quarantined = quarantinedRaw.map((q) => ({ ...q, behavior: readBucketRowBehavior(q.behavior, "quarantined row", ownerKey) }));
+    refuseRowsTheValidatorRefuses(ownerKey, rules, tombstones);
+    return {
+        actor: String(row.actor ?? ""),
+        counter: Number(row.counter ?? 0),
+        rev: Number(row.rev ?? 0),
+        rules,
+        tombstones,
+        quarantined,
+        ...(observedVector !== undefined ? { observedVector } : {}),
+        ...(grammar !== undefined ? { grammar } : {}),
+    };
+}
+function refuseRowsTheValidatorRefuses(ownerKey, rules, tombstones) {
     const badTombstone = tombstones.find((t) => {
         const parsed = parseRuleText(t.rule, t.behavior);
         return "reject" in parsed || parsed.rule.rule !== t.rule;
@@ -394,21 +403,11 @@ function decodeBucketRow(ownerKey, row) {
     if (badTombstone !== undefined) {
         throw new BucketRefusedError(`permission_rule bucket ${ownerKey} carries a tombstone whose rule text the single validator refuses or does not spell canonically`, `(${badTombstone.rule}) — refusing the whole bucket rather than keeping a rule alive under a tombstone that can never match it`);
     }
-    const screened = screenRuleSyncState({ rules, tombstones });
+    const screened = screenRuleSyncState({ rules: [...rules], tombstones: [...tombstones] });
     if (screened.rejected.length > 0) {
         const names = screened.rejected.map((r) => `${r.rule}(${r.reason})`).join(", ");
         throw new BucketRefusedError(`permission_rule bucket ${ownerKey} carries rows the single validator refuses`, `[${names}] — refusing the whole bucket rather than authorizing a rule whose text and matcher metadata disagree`);
     }
-    return {
-        actor: String(row.actor ?? ""),
-        counter: Number(row.counter ?? 0),
-        rev: Number(row.rev ?? 0),
-        rules,
-        tombstones,
-        quarantined,
-        ...(observedVector !== undefined ? { observedVector } : {}),
-        ...(grammar !== undefined ? { grammar } : {}),
-    };
 }
 function fencedCasWhere(dialect, firstPlaceholder, ownerKey, cas) {
     const ph = (offset) => (dialect === "tidb" ? "?" : `$${firstPlaceholder + offset}`);
@@ -422,6 +421,12 @@ async function writeBucket(exec, dialect, ownerKey, cur, next, nowMs) {
     if (!writable.success) {
         throw new Error(`refusing to write a permission_rule bucket this backend could not read back: ${writable.error.message}`);
     }
+    try {
+        refuseRowsTheValidatorRefuses(ownerKey, next.rules, next.tombstones);
+    }
+    catch (e) {
+        throw new Error(`refusing to write a permission_rule bucket this backend could not read back: ${e.message}`);
+    }
     const body = { rules: next.rules, tombstones: next.tombstones, quarantined: cur.quarantined, ...(cur.observedVector !== undefined ? { observedVector: cur.observedVector } : {}) };
     const enc = dialectProtocolJsonEncoder(dialect);
     const where = fencedCasWhere(dialect, 7, ownerKey, { column: "rev", expected: cur.rev });
@@ -529,7 +534,7 @@ class SqlDurableRulePartition {
         },
         apply: async (delta, opts) => {
             if (delta.kind === "sync-join") {
-                throw new Error("the SQL permission-rule backend does not implement the sync-join landing pipeline (core's applySyncJoin is not on the package's public export face); " +
+                throw new Error("the SQL permission-rule backend does not implement the sync-join landing arm; " +
                     "no sync client is wired in this deployment, so this arm has no caller — see permission-rule-store-sql.ts header");
             }
             assertWriteDeltaScopeDurable(delta);

package/dist/plugins/pg-pool.d.ts

@@ -10,9 +10,13 @@
  * (run-store + checkpoint); the remaining tidb-* tables are added as their PG stores land (tracked).
  *
  * ─────────────────────────────── SCHEMA POLICY (clay 裁 2026-07-26) ───────────────────────────────
- * THIS CODE IS THE SINGLE SOURCE OF TRUTH for the PG schema. The stack is not yet in production and runs
- * against a single local operator's database, so a schema change is DROP-AND-RECREATE (drop the database,
- * boot, `ensurePgSchema` rebuilds it) — NOT an in-place migration.
+ * THIS CODE IS THE SINGLE SOURCE OF TRUTH for the PG schema, and there is NO in-place migration seam in this statement array: a database that
+ * lags behind the code is refused at boot with the exact `ALTER TABLE … ADD COLUMN …` statements printed, and the
+ * deployer runs them themselves: the column-set check and its refusal never alter a database. The only DDL this
+ * process runs by itself on a table that already exists is idempotent index creation (`ensureIndex`: indexes only,
+ * never a column) and the registered one-time migrations (each has a window and a registry row in
+ * `one-time-migrations.ts`) — adding / changing / renaming a column or dropping a table is done by those migrations
+ * and by nothing else.
  *
  * Consequence, and it is a hard rule: **do NOT add new `ALTER TABLE` seams here.** Every column / default /
  * constraint change is folded into its own `CREATE TABLE`, and this array stays pure `CREATE TABLE` +

package/dist/plugins/pg-session-storage.d.ts

@@ -1,19 +1,22 @@
 import { BaseSessionStorage, type AcquiredSession, type PlacedSessionRow, type SessionHead, type SessionMetadata, type SessionPlacementRecord, type SessionStore, type SessionTreeEntry, type SessionWriteOptions } from "@sema-agent/core";
 import type { Pool, PoolClient } from "pg";
 import type { SessionSummary } from "./store-contracts.js";
-import { type SessionRowPatch } from "../session-row.js";
+import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import { type OrphanOwnerLog } from "../delegated-session-owner.js";
 import { type StagingHandle } from "../session-sync-kernel.js";
 import { type InstructionSourceBaseline } from "../instruction-source-notice.js";
-import { type SessionFace } from "../session-incarnation.js";
+import type { SessionWorkspace } from "../session-workspace.js";
+import type { RetentionDeclaration } from "@sema-agent/core";
 import { type IndexSpec } from "./ensure-index.js";
+import { type ForkTarget, type ForkToOutcome } from "./session-fork.js";
+import { type ExecutionPlacementSeat } from "../execution-placement.js";
 /**
  * PG-dialect DDL for the L1 session log, translated from tidb-pool.ts SCHEMA_STATEMENTS:
  * JSON→JSONB, DATETIME(3)→TIMESTAMPTZ(3), inline `KEY`/`UNIQUE KEY`→separate CREATE INDEX (UNIQUE for uq_session_event_entry).
  *
- * SCHEMA POLICY: see the header of pg-pool.ts — the code is the single source of truth, schema changes are
- * drop-and-recreate, and NO new `ALTER TABLE` seams are added here; fold into the CREATE instead.
+ * SCHEMA POLICY: see the header of pg-pool.ts — the code is the single source of truth, there is no in-place
+ * migration, and NO new `ALTER TABLE` seams are added here; fold into the CREATE instead.
  */
 export declare const PG_SESSION_SCHEMA: string[];
 /** [ref]:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensureSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
@@ -55,8 +58,8 @@ export declare class PgSessionStorage extends BaseSessionStorage {
  */
 export declare class PgSessionStore implements SessionStore {
     private readonly pool;
-    /** [ref] 车1:托管留存声明(TiDB 孪生同格)。读法见 `retention-store-sql.ts` 的 {@link MANAGED_RETENTION}。 */
-    readonly retention: import("@sema-agent/core").RetentionDeclaration;
+    /** 托管留存声明 = 装配交给它的词(TiDB 孪生同格)。读法见 `retention-store-sql.ts` 的 {@link MANAGED_RETENTION}。 */
+    readonly retention: RetentionDeclaration;
     /** [ref] C18(core 5.48.0 [ref]):placement 声明(TiDB 孪生同格,义务逐条见
      *  `src/plugins/session-placement.ts` 顶注)。 */
     readonly placements: {
@@ -68,8 +71,13 @@ export declare class PgSessionStore implements SessionStore {
     private readonly pending;
     /** 委派子代孤行那一行 warn 的去处(TiDB 孪生同格)。 */
     private readonly log;
+    /** 执行席(TiDB 孪生同格;实现与语句的唯一属主 = `execution-placement-sql.ts`,本店只交自己的池)。 */
+    readonly executionPlacement: ExecutionPlacementSeat;
+    /** 本店的池包成的 SqlDriver(TiDB 孪生同格):执行席与会话行格写原语的事务都经它借连接。 */
+    private readonly db;
     constructor(pool: Pool, opts?: {
         readonly log?: OrphanOwnerLog;
+        readonly retention?: RetentionDeclaration;
     });
     acquire(sessionId?: string, opts?: PlacementAcquireOpts): Promise<AcquiredSession>;
     private load;
@@ -118,13 +126,14 @@ export declare class PgSessionStore implements SessionStore {
     }): Promise<SessionSummary[]>;
     /** @see TiDBSessionStore.sessionSummaryOf — the PG twin (same projection, run-preview subqueries scoped to the id). */
     sessionSummaryOf(sessionId: string): Promise<SessionSummary | undefined>;
-    /** @see TiDBSessionStore.patchSessionMeta — the PG twin (the only writer of a user-set title / pin; the UPDATE and the read-back
-     *  both conditioned on the verified occupant's incarnation; `updated_at` untouched). The read-back is a second statement, not a
-     *  `RETURNING` CTE: the outer SELECT of a data-modifying CTE reads the pre-UPDATE snapshot of `session_meta`. */
-    patchSessionMeta(sessionId: string, patch: SessionRowPatch, face: SessionFace): Promise<SessionSummary | undefined>;
-    /** @see TiDBSessionStore.selectSummaries — the PG twin. `where` already carries `$n` placeholders numbered over `params`;
+    /** @see TiDBSessionStore.listRowOf — the PG twin. */
+    private listRowOf;
+    /** @see TiDBSessionStore.writeSessionRowCells — the PG twin (the same SQL half, `session-row-sql.ts`; only the statement text differs). */
+    writeSessionRowCells(sessionId: string, cells: SessionRowPatch, how: ClientSessionRowWrite): Promise<SessionRowWriteOutcome<SessionSummary>>;
+    writeSessionRowCells(sessionId: string, cells: SessionRowPatch, how: ReplaySessionRowWrite): Promise<ReplaySessionRowWriteOutcome<SessionSummary>>;
+    /** @see TiDBSessionStore.selectListRows — the PG twin. `where` already carries `$n` placeholders numbered over `params`;
      *  the run scope and the LIMIT take the next numbers (PG binds by number, so text order does not matter). */
-    private selectSummaries;
+    private selectListRows;
     /** @see TiDBSessionStore.probeTitle — the PG twin. */
     probeTitle(sessionId: string): Promise<"none" | "untitled" | "titled">;
     /** @see TiDBSessionStore.setTitleIfNull — the PG twin (the auto-titler's NULL-only write). */
@@ -135,9 +144,18 @@ export declare class PgSessionStore implements SessionStore {
      *  `query_timeout` rejects AND pg-pool destroys that client, so a lock-stuck baseline write does not keep a pooled
      *  connection). */
     recordInstructionSource(sessionId: string, expected: InstructionSourceBaseline, source: string | null): Promise<void>;
-    /** @see TiDBSessionStore.fork — copy the WHOLE durable history (full session_event log, compaction floor bypassed,
-     *  NOT wake's bounded tail) to a NEW uuidv7 session, re-seq dense from 0, ids/parents verbatim, owner=caller. */
+    /** @see TiDBSessionStore.readSessionWorkspace — the PG twin (same projection-as-text, same cell owner). */
+    readSessionWorkspace(sessionId: string): Promise<SessionWorkspace | undefined>;
+    /** @see TiDBSessionStore.recordSessionWorkspace — the PG twin (whole-cell overwrite fenced to the occupant; `pgSafeJsonStringify` + `::jsonb`, like every PG JSON write;
+     *  the general query surface — the pool-wide `DB_QUERY_TIMEOUT_MS` server-side `statement_timeout` bounds it, no per-call client timer). */
+    recordSessionWorkspace(sessionId: string, incarnation: string, workspace: SessionWorkspace): Promise<void>;
+    /** @see TiDBSessionStore.fork — core 契约 `fork(sourceId, owner?)` = {@link forkTo} 的投影(新铸 uuidv7 目标,`forkByFreshId`;三店同一只)。 */
     fork(sourceId: string, owner?: string | null): Promise<string | null>;
+    /** @see TiDBSessionStore.forkTo — fork 续写的店契约(PG 孪生逐字同义):目标行 meta 先、主键排他;撞已在 ⇒ 回滚后在新视图读目标按属主与 fork 键分类;
+     *  读不到 ⇒ 整笔重跑一次,再不行 ⇒ {@link ForkTargetUnsettledError}。 */
+    forkTo(sourceId: string, owner: string | null, target: ForkTarget): Promise<ForkToOutcome | null>;
+    /** @see TiDBSessionStore.forkToOnce — 一次尝试(PG 孪生):拷**整份**持久日志(压缩地板绕过,不是 wake 的有界尾),seq 从 0 重铸稠密,id / 父 / 载荷原样。 */
+    private forkToOnce;
     /** @see TiDBSessionStore.exportEntries — 2c session-sync EXPORT: the FULL durable session_event log (compaction floor
      *  bypassed, NOT wake's tail) as `SessionTreeEntry[]`, oldest-first, verbatim. null if the source is unknown. */
     exportEntries(sessionId: string): Promise<SessionTreeEntry[] | null>;
@@ -155,18 +173,19 @@ export declare class PgSessionStore implements SessionStore {
         batchSize?: number;
     }): Promise<AsyncIterable<SessionTreeEntry> | null>;
     /** @see TiDBSessionStore.importEntries — 2c session-sync IMPORT: core `validateEntriesForImport` gate FIRST (fail-closed),
-     *  then persist its verbatim output (re-seq dense from 0, ids/parents/payload/ts unchanged) in ONE txn with
-     *  session_meta LAST as the commit point; owner = the RE-STAMPED authenticated principal (never the bundle's). */
+     *  then persist its verbatim output (re-seq dense from 0, ids/parents/payload/ts unchanged) in ONE txn, **lock-or-create, meta first**
+     *  (读写序律:占行 → 锁行判是不是本次占下的 → 锁定读认领 → 事件);owner = the RE-STAMPED authenticated principal (never the bundle's). */
     importEntries(sessionId: string, owner: string | null, entries: SessionTreeEntry[]): Promise<void>;
     /** @see TiDBSessionStore.replaceEntries — 2c (§7/§8) IDEMPOTENT REPLACE: core `validateEntriesForImport` gate FIRST
-     *  (fail-closed), then DELETE events + the owner-guarded meta delete (`owner IS NOT DISTINCT FROM $n` = the PG `<=>`,
-     *  defense-in-depth), then re-insert via the SHARED body (entries + session_meta LAST as the commit point), ALL in
+     *  (fail-closed), then the owner-guarded meta delete (`owner IS NOT DISTINCT FROM $n` = the PG `<=>`, defense-in-depth), then the
+     *  SHARED body (session_meta first, the in-txn claim read, then the old events out and the new ones in), ALL in
      *  ONE txn. Safe to run OVER an existing session (fast-forward / §8 retry) — unlike importEntries' fresh-only INSERT. */
     replaceEntries(sessionId: string, owner: string | null, entries: SessionTreeEntry[]): Promise<void>;
-    /** @see TiDBSessionStore.insertValidatedLog — shared insert half of importEntries / replaceEntries (ONE source, no
-     *  drift): entries re-seq dense from 0 (ids/parents/payload/ts verbatim), THEN session_meta LAST as the commit point.
+    /** @see TiDBSessionStore.writeImportedLog — the shared write half of importEntries / replaceEntries (ONE source, no drift):
+     *  session_meta FIRST (create = occupy the row, an existing one ⇒ refused; replace = plain INSERT after the caller's owner-guarded
+     *  delete), the in-txn claim read on THIS connection (读写序律), then the entries re-seq dense from 0 (ids/parents/payload/ts verbatim).
      *  Runs inside the caller's open txn (`conn` already in BEGIN); the caller owns COMMIT/ROLLBACK + the validate gate. */
-    private insertValidatedLog;
+    private writeImportedLog;
     /** @see TiDBSessionStore.beginImportStaging — 2c P1d-β PUSH staging: stream batches into the shadow id
      *  `${realSessionId}#stg-${token}` (route-minted token), then commit (atomic swap) / abort. */
     beginImportStaging(realSessionId: string, token: string): StagingHandle;
@@ -180,7 +199,7 @@ export declare class PgSessionStore implements SessionStore {
     sweepStagingSessions(): Promise<number>;
     /** @see TiDBSessionStore.deleteSession — purge session_meta + session_event; idempotent (false if absent).
      *  Owner-guarded on session_meta.owner (`IS NOT DISTINCT FROM` = the PG `<=>`); the event purge is gated on the
-     *  owner-matched meta delete (session_event has no owner column). */
+     *  owner-matched meta delete (session_event has no owner column). A live run claim read inside the txn ⇒ `SessionActiveRunError`. */
     deleteSession(sessionId: string, owner: string | null): Promise<boolean>;
     get size(): number;
     dispose(): void;