@sema-agent/server 7.140.0 → 7.142.0

package/dist/plugins/local-session-store.d.ts

@@ -1,23 +1,81 @@
-import { FileSessionRepo, type AcquiredSession, type SessionHead, type SessionStore, type SessionRepo, type SessionTreeEntry } from "@sema-agent/core";
-import type { SessionRunClaimSource, SessionRunRollupSource, SessionSummary } from "./store-contracts.js";
+import { FileSessionRepo, type AcquiredSession, type PlacedSessionRow, type SessionHead, type SessionPlacementRecord, type SessionStore, type SessionRepo, type SessionMetadata, type SessionTreeEntry, type StoreDurability } from "@sema-agent/core";
+import { type OwnerlessClaim } from "../delegated-session-owner.js";
+import { type PlacementAcquireOpts } from "./session-placement.js";
+import { z } from "zod";
+import { StoreBootRefusalError, type SessionRunClaimSource, type SessionRunRollupSource, type SessionSummary } from "./store-contracts.js";
 import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
+import { type LocalArchiveKeptStamped, type LocalArchiveUnreadable } from "./one-time-migrations.js";
 import { type Logger } from "../observability/logger.js";
 import { type SessionFace } from "../session-incarnation.js";
+import { type ExecutionLane } from "../execution-lane-caps.js";
 import { type ExecutionPlacementSeat, type LocalPlacementBackfillSeat } from "../execution-placement.js";
 import { type ForkTarget, type ForkToOutcome } from "./session-fork.js";
 import { type InstructionSourceBaseline } from "../instruction-source-notice.js";
 import type { SessionWorkspace } from "../session-workspace.js";
 import { type StagedCommitOptions, type StagingHandle, type SyncRelation } from "../session-sync-kernel.js";
 /**
- * local 车道会话存档的**唯一 repo 出口**:本仓里每一只读 `<root>/sessions/*.jsonl` 的 `FileSessionRepo` 都从这里取(`LocalSessionStore` 的底座与会话视图口
- * 窗口 `local-session-window.ts#LocalSessionWindow.wake` 的读旁路),所以坏记录的披露座只有这一份接线 —— 修前视图口自建一只不带座的 repo,同一份坏档在这里读到有计数 / 探针,
- * 在视图口读到一个字都没有。座 = F 类 `server.session-repo.corrupt-record-skipped`(会话存档里读不出的记录丢的是可用性:历史少一截 / 列表少一行,不开任何门;
- * 计数单位 = 一条被跳过的记录,逐命中探针行,warn 每进程一次),外加会话打开作用域的计数腿(`noteReplayInSessionOpenScope`:只在 `openSessionForItself`
- * 的作用域里才记,作用域外 —— 列表 / 导出 / 视图口 —— 是空操作,那些读只进运维面)。
+ * 对象形一格的形(本店是它唯一的写者,形属主就在这里):不收别的键 —— 一只不认得某一位的读者(回滚到的上一版)对带着那一位的格整只严格拒,
+ * 而不是把它读丢(边档是严格读,见 `SidecarMap.strict`)。
+ */
+export declare const SESSION_META_CELL_OBJECT: z.ZodObject<{
+    incarnation: z.ZodString;
+    owner: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    execution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        role: z.ZodLiteral<"writer">;
+        lane: z.ZodCustom<ExecutionLane, ExecutionLane>;
+    }, z.core.$strict>, z.ZodObject<{
+        role: z.ZodLiteral<"mirror">;
+    }, z.core.$strict>], "role">>;
+    forkKey: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    forkedFrom: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * local 车道会话存档的**唯一 repo 出口**:本仓里每一只读 `<root>/sessions/*.jsonl` 的 `FileSessionRepo` 都从这里取(`LocalSessionStore` 的底座;会话视图窗不再自开 repo,
+ * 它的元数据与日志都由店交出 —— `local-session-window.ts`),所以坏记录的披露座只有这一份接线。座 = F 类 `server.session-repo.corrupt-record-skipped`(会话存档里读不出的记录丢的是可用性:
+ * 历史少一截 / 列表少一行,不开任何门;计数单位 = 一条被跳过的记录,逐命中探针行,warn 每进程一次),外加两条作用域腿:会话打开作用域(`noteReplayInSessionOpenScope`:
+ * 只在 `openSessionForItself` 的作用域里才记)与一次性迁移 M33 的整档读作用域({@link noteReplayInArchiveRewriteRead});作用域外 —— 列表 / 导出 / 视图 —— 两条腿都是空操作,那些读只进运维面。
  */
 export declare function createLocalSessionRepo(root: string): FileSessionRepo;
+/** 快照目录名(数据根下;本店自有的目录与格式)。常设拒启臂 {@link assertNoArchiveSnapshots} 读它,所以它活得比 M33 的码久。 */
+export declare const LOCAL_ARCHIVE_SNAPSHOT_DIR = "session-archive-m33";
+/**
+ * 数据根下的快照目录非空 ⇒ 拒启(起服对账一族的 local 腿;机读码 `config.local_archive_snapshot_present`)。快照是一次性迁移 M33 改写一只存档之前留下的那只会话的
+ * 对话副本:它在,就说明那一次改写被打断了 —— 存档可能已经删掉、内容只在快照里;而会话删除碰不到它(删除权残留)。M33 窗内起服先消化每一只(恢复先行),
+ * 消化不了的点名拒启;M33 删码之后只剩这一臂。属 {@link StoreBootRefusalError} 族:起服降级臂不吞它。
+ */
+export declare class LocalArchiveSnapshotsPresentError extends StoreBootRefusalError {
+    readonly dir: string;
+    readonly names: readonly string[];
+    readonly code = "config.local_archive_snapshot_present";
+    constructor(dir: string, names: readonly string[], detail?: string);
+}
+/**
+ * **常设拒启臂**(无窗;M33 删码后仍在):快照目录非空 ⇒ {@link LocalArchiveSnapshotsPresentError}。只读一个目录在不在、有没有东西;
+ * 目录在而读不了(权限 / I/O)⇒ 同一只拒(判不出里面有没有快照 —— fail-closed,不让起服降级臂把它读成「这台机器存不了盘」)。
+ */
+export declare function assertNoArchiveSnapshots(dir: string): void;
+export interface LocalArchiveMigrationReading {
+    /** 补了行事实(建档时刻 / 谱系)的格数(含为盘上有存档而没有格的会话新建的格)。 */
+    readonly rowFactsBackfilled: number;
+    /** 由带戳改写成匿名的存档数。 */
+    readonly anonymized: number;
+    /** 留着带戳的存档(点名 + 原因)。 */
+    readonly keptStamped: readonly LocalArchiveKeptStamped[];
+    /** 边档里有格、存档头读不出的会话(点名)。 */
+    readonly unreadable: readonly LocalArchiveUnreadable[];
+    /** 本进程起服以来消化掉的快照记录数(恢复先行)。 */
+    readonly snapshotsRecovered: number;
+}
 /** 本店包的 repo:core `SessionRepo` 且答头读(`headOf` —— 叶子出自它;core 7.55.0 起 `FileSessionRepo` / `InMemorySessionRepo` 都答)。 */
 export type HeadReadingSessionRepo = SessionRepo & Required<Pick<SessionRepo, "headOf">>;
+/** repo 记 placement 的两只读口(core `FileSessionRepo` 有;`InMemorySessionRepo` 不记 placement,两只都没有)。同在或同缺。 */
+type PlacementRecordingRepo = Pick<FileSessionRepo, "placementOf" | "listPlaced">;
+/** 本店的部署声明(装配方给,core `TtlSessionStore` 同名两格):会话耐久(未 placed 的会话)与委派分区的声明。 */
+export interface LocalSessionStoreDeclaration {
+    readonly durability?: StoreDurability;
+    readonly placements?: NonNullable<SessionStore["placements"]>;
+}
 export declare class LocalSessionStore implements SessionStore {
     private readonly repo;
     private readonly runs;
@@ -26,8 +84,39 @@ export declare class LocalSessionStore implements SessionStore {
      *  **正确行为**不是缺口(要留存治理先上 DB 后端;设计稿 §1「不做清单」逐字)。缺席也会被读成 none,
      *  显式写出来是文档义务:沉默表达不出「我核对过我的介质就是删不了」。 */
     readonly retention: import("@sema-agent/core").RetentionDeclaration;
+    /**
+     * core `SessionStore.durability` —— 未 placed 的会话活不活过重启。**装配方声明**(`LocalBackend` 用文件 repo 构造时给 `"durable"`):店读不出 repo 是否持久,
+     * 由接 repo 的一方说(core 声明律)。缺席 ⇒ core 读作 `process-local`。声明 `durable` 而没有数据根(边档不落盘 ⇒ 属主与化身重启即失)⇒ 构造即拒。
+     */
+    readonly durability?: StoreDurability;
+    /**
+     * core `SessionStore.placements` —— 本店懂委派分区、分区里的会话是这个耐久度(六条义务,文件头注)。装配方声明(值与 core `FileStorageBackend` 同);
+     * repo 记不了 placement(没有 `placementOf` / `listPlaced`)或没有数据根 ⇒ 构造即拒(那句声明是谎)。缺席 = 不懂分区:带 placement 的 acquire 合法地当普通会话建。
+     */
+    readonly placements?: NonNullable<SessionStore["placements"]>;
+    /** 一只会话存档行头上的 placement 元组(`undefined` = 普通会话或无此存档;读不出 ⇒ 拒)。repo 记 placement 时在,透传 repo 的同名读口。 */
+    readonly placementOf?: (sessionId: string) => Promise<SessionPlacementRecord | undefined>;
+    /** 委派分区的自有枚举(联合收割的分区腿输入;透传 repo 的同名读口,年龄 = 存档的修改时刻)。repo 记 placement 时在。 */
+    readonly listPlaced?: (kind: "subagent", opts?: {
+        olderThanMs?: number;
+        scope?: string;
+    }) => Promise<PlacedSessionRow[]>;
+    /**
+     * 委派继承律的认领口(`delegated-session-owner.ts`;停驻挂点对宿主无主子代行的认领):这只会话的那一位住客(判断时读到的化身)仍无主、且是 placed 行 ⇒ 写 `owner`,
+     * 返回是否写成。与 `placementOf` 同在或同缺(`delegatedOwnerHostOf`)。随一次性迁移 M23 的窗同删(登记表 M23 行)。
+     */
+    readonly claimOwnerless?: OwnerlessClaim;
+    /** placement 的唯一读法(repo 的 `placementOf`;repo 不记 placement ⇒ 恒答缺席 —— 那种 repo 里没有 placed 行)。 */
+    private readonly recordedPlacementOf;
     /** In-flight acquisitions keyed by id, so concurrent acquire(sameId) in one process share one (mirrors TiDBSessionStore). */
     private readonly pending;
+    /**
+     * 本进程里删行已经开始的会话 id(删除与 placed 行的 release 都在 {@link dropRowHeld} 第一步登记)。锁外读者的补铸({@link cellOfPresent}:格缺而存档在 ⇒ 当作
+     * 7.104.0 之前写下的会话补一格)对登记过的 id 不铸 —— 删行的那一笔与存档的删除不是同一笔(placed 行存档最后删,存档行头是重试判别位),两笔之间盘上正是
+     * 「格缺而存档在」那一形;锁外的读若照旧补铸,存档随后删掉就留下一只没有存档的格(读作一只无主会话,再 release 也清不掉)。删行一开始,这一行对读者就不在了;
+     * 中途失败、存档还在 ⇒ 读者读作不在,重发收完。进程内只增(一只删掉的会话一个 id);补铸只对格缺的存档起作用,所以同 id 再建(登记 / 导入 / 建会话都自己铸格)不受影响。
+     */
+    private readonly rowsDropped;
     /** Last-activity marker (touch) for ordering — the keyset sort key for {@link listSessions}. PERSISTED to a JSON
      *  sidecar under {@link dataDir} (when given) so the /resume picker's newest-first order SURVIVES a service restart:
      *  without persistence the map starts EMPTY on boot and every session degrades to `createdAt` ordering (the picker
@@ -81,7 +170,7 @@ export declare class LocalSessionStore implements SessionStore {
      * 盘上有会话而边档里没有它那一格 ⇒ 第一次读补铸一格只有化身的(属主没有事实可写)并落盘。严格读(读不出 ⇒ 整只拒,见 `SidecarMap.strict`)。
      */
     private readonly meta;
-    /** 认领行(`session_owner_claimed`)的出口 —— 一次性迁移 M10 的认领臂专用(窗口见 `plugins/one-time-migrations.ts` 登记表)。 */
+    /** 认领行(`session_owner_claimed`,一次性迁移 M10 的认领臂,窗口见 `plugins/one-time-migrations.ts` 登记表)与委派孤行 warn(`delegated_session_owner_orphaned`)的出口。 */
     private readonly log;
     /**
      * 按会话的写锁(表见 {@link SESSION_WRITE_LOCKS_BY_ROOT})—— 会话行两位的**每一笔**写(用户的行格写原语:判 → 边档草稿 → 落盘 → 发布;自动标题器的
@@ -105,17 +194,22 @@ export declare class LocalSessionStore implements SessionStore {
      * `place` 就是席的 `place`。
      */
     readonly executionPlacementBackfill: LocalPlacementBackfillSeat;
+    /** 数据根(`resolve()` 之后;内存部署 = `undefined`)—— 一次性迁移 M33 的快照目录住在它下面(窗口见 `plugins/one-time-migrations.ts` 登记表)。 */
+    private readonly dataRoot;
+    /** 一次性迁移 M33:本进程起服以来消化掉的快照记录数(恢复先行那一步累加,迁移读数交出时清零)。 */
+    private archiveSnapshotsSettled;
     /** @param repo     the core SessionRepo this store projects into the §0.5 SessionStore shape.
      *  @param runs     the run store whose per-session projection is the ONLY source of a row's `runCount` / `lastStatus` / `lastRunId` /
      *                  `lastTaskRunId` (LocalBackend passes its `FileRunStore`). Required — a run-less local session store does not exist.
      *  @param dataDir  the SAME data dir the file-backed repo persists under (LocalBackend passes `fileBackend.root`).
      *                  When given, lastActivity is persisted to `<dataDir>/session-last-activity.json` so it survives a
      *                  restart (the file-backed deployment); omit it for the in-memory deployment (nothing survives).
-     *  @param opts.log the `session_owner_claimed` line's sink (LocalBackend passes a logger at the deployment's LOG_LEVEL;
-     *                  absent ⇒ an info-level JSON-line logger — a claim is never silent). */
-    constructor(repo: HeadReadingSessionRepo, runs: SessionRunRollupSource & SessionRunClaimSource, dataDir?: string, opts?: {
-        log?: Pick<Logger, "info">;
-    });
+     *  @param opts.log the `session_owner_claimed` / `delegated_session_owner_orphaned` lines' sink (LocalBackend passes a logger at the deployment's
+     *                  LOG_LEVEL; absent ⇒ an info-level JSON-line logger — a claim or an orphaned delegated row is never silent).
+     *  @param opts.durability / opts.placements the deployment's declaration ({@link LocalSessionStoreDeclaration}; see the two fields). */
+    constructor(repo: HeadReadingSessionRepo & Partial<PlacementRecordingRepo>, runs: SessionRunRollupSource & SessionRunClaimSource, dataDir?: string, opts?: {
+        log?: Pick<Logger, "info" | "warn">;
+    } & LocalSessionStoreDeclaration);
     /**
      * 这一格此刻是不是 `forking`(fork 创建的格 {@link isForkCreatedCell} ∧ 存档不在)。存档在不在只问 repo 的唯一探针 {@link probeArchive} 的「不在」—— **只问有没有**:存档在而用不了(会话头读不出 / 截断)
      * 是「在」,内容读不读得出归真正读内容的那一读(门之后、体之前读一次叶子,读不出 ⇒ `corrupt_session`)。所以带键的会话与不带键的会话在执行席上同形,坏档照样能被换装修好
@@ -170,6 +264,20 @@ export declare class LocalSessionStore implements SessionStore {
      * {@link metaRead} / {@link forkingRead} 收下它、点名跳过,不上抛。只问有没有的 {@link forkingRead} 把 `corrupt_session` / `invalid_session` 读作「在」(存档找到了),`storage` 不替它答。
      */
     private probeArchive;
+    /**
+     * 委派分区的**唯一一读**(存档行头上的元组,repo 的 `placementOf`;文件头注):placed · 普通 · 读不出。repo 只吞「不在」,别的故障原样抛 ⇒ 这里收成
+     * {@link UnusableArchive}(词同 {@link archiveFaultWord}),由读者决定上抛还是按普通行答。
+     */
+    private placementProbe;
+    /**
+     * 改写面与执行席的读法({@link placementProbe} 的一形):placed ⇒ 那份元组;普通 ⇒ `undefined`;行头读不出(`corrupt_session` / `invalid_session`)⇒ `undefined` —— 没有可读的
+     * placement 记录,这一行按普通行答,内容读不读得出归真正读内容的那一读(坏档照样换得掉,与 forking 探针同一条规矩);说不出(`storage`)⇒ 抛那只故障。
+     */
+    private placedRecordOf;
+    /** {@link placedRecordOf} 的是非形。 */
+    private isPlacedRow;
+    /** 删除与认领的读法({@link placementProbe} 的另一形):读不出的任何一形 ⇒ 抛那只故障(说不准是不是 placed 行,就不删、不写)。 */
+    private placedRecordOrThrow;
     /** 盘上有没有一份**读得出**的这只会话的存档(补铸 / 登记 / 导入的落点判 / fork 目标这些要对存档动手的读者用):用不了的存档照旧上抛它的故障。 */
     private existsInRepo;
     /**
@@ -203,10 +311,20 @@ export declare class LocalSessionStore implements SessionStore {
      */
     headOf(sessionId: string): Promise<SessionHead | undefined>;
     /**
-     * 三条 acquire 腿(无 id 建 / 按 id 打开 / 按 id 首建)交出会话的唯一一处:住客 = 这只会话那一格({@link cellOfPresent} —— 刚建或刚在写锁里
-     * 打开,就是在盘上的证明,不再回 repo 探一次),经活住客的唯一投影(`sessionFaceFromRow`)解码,挂到交出的会话上({@link occupiedBy})。
+     * 引擎仓存档的头(core `SessionRepo.headOf`:日志首记录与尾,不重放)—— 本店读存档头的**唯一**一处。存档头在本店只有两种读法:叶子(读内容的人要的那一格)
+     * 与行代号(换装 / 一次性迁移的 `expect.row`、迁移判「有没有、读不读得出」);属主 / 建档时刻 / 谱系从不从这里读(规则一,行事实只住边档)。
+     */
+    private archiveHeadOf;
+    /**
+     * 三条 acquire 腿(无 id 建 / 按 id 打开 / 按 id 首建)交出会话的唯一一处:行事实 = 这只会话那一格({@link cellOfPresent} —— 刚建或刚在写锁里
+     * 打开,就是在盘上的证明,不再回 repo 探一次),经唯一投影 {@link rowMetadataOf}(活住客解码、建档时刻、谱系)挂到交出的会话上({@link occupiedBy})。
      */
     private handOut;
+    /**
+     * 按 id 读一只会话的元数据(会话视图窗的元数据口,`local-session-window.ts`):行事实经与交出的会话**同一只**投影 {@link rowMetadataOf} 取自那一格(读口 {@link metaOf}:
+     * 格缺而存档在 ⇒ 补铸;存档读不出 ⇒ 抛那只故障)。`undefined` = 无此会话。窗只读日志内容,不自开 repo、不读存档头。
+     */
+    sessionMetadataOf(sessionId: string): Promise<SessionMetadata | undefined>;
     /** Cheap pre-LLM probe (local twin). The map write needs no session_meta row, so there is
      *  no "none" (register-lag) dimension here — two states only. */
     probeTitle(sessionId: string): Promise<"none" | "untitled" | "titled">;
@@ -231,8 +349,9 @@ export declare class LocalSessionStore implements SessionStore {
     writeSessionRowCells(sessionId: string, cells: SessionRowPatch, how: ReplaySessionRowWrite): Promise<ReplaySessionRowWriteOutcome<SessionSummary>>;
     /**
      * 写原语锁住的那一行(调用方持这只会话的写锁并已 {@link loadRowSidecars}):会话元数据那一格(属主 `owner ?? null` —— 与头读、列表行同读;化身经
-     * `incarnationFromCell` 的 `absent` 读法;执行位 `mirror`)+ 列表面上有它(会话仓里有;`forking` 中间态的存档不在 ⇒ 不在列表上)+ 两只边档的格。
-     * 没有那一格或不在列表面上 ⇒ `undefined`(没有行)。local 没有委派分区行。
+     * `incarnationFromCell` 的 `absent` 读法;执行位 `mirror`)+ 行集里有它({@link rowHeaderOf};`forking` 中间态的存档不在 ⇒ 不在列表上)+ 两只边档的格。
+     * 没有那一格或不在列表面上 ⇒ `undefined`(没有行)。委派分区行(placed)不上列表面(repo 的 `list()` 按存档行头排除,义务 2;行头读不出的行没有可读的 placement 记录、
+     * 按普通行读 —— 文件头注那一条)⇒ `placed: false` 是列表面那一判的投影,不是另一读。存档读不出的行照样是一行(行格住在边档,写得了;HTTP 改名口的坏档判据排在本原语之前)。
      */
     private lockedRowOf;
     /** 两只边档上这只会话的可写格(已发布的值;缺键 = 缺省)。调用方先 {@link loadRowSidecars}。 */
@@ -242,10 +361,35 @@ export declare class LocalSessionStore implements SessionStore {
     /** 应答行(锁内另读):列表行同一只合成 + 读到它时那一格上的住客。不在列表面上 / 没有那一格 ⇒ `undefined`。 */
     private listRowOf;
     /** ONE session's list row — {@link listSessions}' projection ({@link summaryOf}, the same synthesis) for one id;
-     *  `undefined` = not a row of the list face (not in the session repo). */
+     *  `undefined` = not a row of the list face ({@link rowHeaders}). */
     sessionSummaryOf(sessionId: string): Promise<SessionSummary | undefined>;
-    /** 会话仓里这只会话的列表元数据(列表面上的行 = `repo.list()` 里的一项)。 */
-    private listedMeta;
+    /**
+     * 本店的**行集** —— 唯一的会话枚举(列表 {@link listSessions}、一次性迁移 M33 的步 1 读它;按 id 读的 {@link rowHeaderOf} 是同一只判据的一只 id 形):
+     *  · 引擎仓的列表(core `repo.list()`:存档**行头**读得出、非 placed)—— 行头读得出的行;
+     *  · ∪ 会话元数据边档里有格、不在引擎仓列表里的 id,经 {@link headerUnreadableRowOf}:存档头读了抛、且不是 placed 行 ⇒ 行头读不出的行(带那只故障);
+     *    不抛(存档不在:fork 中间态 / 删除中;或读间新建)/ placed 行(行头读得出,repo 的 `listPlaced` 认得它,尾部再坏也不上列表面)⇒ 不是行集里的行。
+     * 边档里没有格、存档头又读不出的会话(7.104.0 之前写下、此后从没被读过)没有一格可读的行事实 —— 属主读不出 ⇒ 不进行集(fail-closed,与归属门同读:
+     * {@link metaOf} 判不了它在不在 ⇒ 整只拒);运维面由 core 列表的披露座与起服 warn 点名它。
+     * 「行头读不读得出」(行集,M33 回填行事实问的就是它)与「叶子读不读得出」(列表行的 `unreadable`,{@link listedRowOf})是两件事、各一只读法。
+     */
+    private rowHeaders;
+    /**
+     * 行集里的这一行({@link rowHeaders} 的按 id 一形:同一只判据,只判这一只 id 的行 —— 别的会话读不出不改它的答)。`undefined` = 不是行集里的行。
+     * ⚠️ 如实:取它的行头仍经引擎仓列表(`repo.list()` 读一遍各会话的头),所以别的会话的头坏了,这一次读照旧为它报一次读坏披露;按 id 直读不在本形里。
+     */
+    private rowHeaderOf;
+    /** 不在引擎仓列表里、边档有格的一只 id:存档头读了抛、且不是 placed 行 ⇒ 行头读不出的那一行;否则 `undefined`(见 {@link rowHeaders})。 */
+    private headerUnreadableRowOf;
+    /**
+     * 委派分区行的 id 集的读者(repo 记 placement ⇒ 它的 `listPlaced`,行头那一读;不记 ⇒ 空集 —— 那种 repo 里没有 placed 行)。惰性、一次读:只在有一只 id 的存档头读抛、
+     * 要分「行头读不出」与「行头读得出的 placed 行尾部坏了」时才读。
+     */
+    private createPlacedIdsReader;
+    /**
+     * 列表面上的一行的内容那一半 = 头读的**叶子**那一读({@link archiveHeadOf},与 {@link headOf} 的叶子同一读):行头读不出 ⇒ 读不出(那只故障);行头读得出 ⇒ 再读叶子,
+     * 抛 ⇒ 读不出(尾部 I/O 故障之类:行头好、头读照样抛);否则读得出。所以行上的 `unreadable` 与头读、读口对同一只会话的答复同读。
+     */
+    private listedRowOf;
     /** [ref] —— 换源通告的基线读(local 孪生;三态读法与 SQL 两孪生的 `session_meta.instruction_source` 同一只编解码)。 */
     readInstructionSource(sessionId: string): Promise<InstructionSourceBaseline>;
     /**
@@ -299,9 +443,9 @@ export declare class LocalSessionStore implements SessionStore {
     /** `which` 点名是哪一只边档([ref] 起有三只 —— 此前这句恒写 lastActivity,title 边档的失败也被报成「recency 降级」)。
      *  节流仍是本实例一只。 */
     private warnSidecar;
-    acquire(sessionId?: string, opts?: {
-        requireExisting?: boolean;
-    }): Promise<AcquiredSession>;
+    acquire(sessionId?: string, opts?: PlacementAcquireOpts): Promise<AcquiredSession>;
+    /** 这次 acquire 要落的 placement:只有声明了分区的店才收(未声明 ⇒ `undefined`,会话就是普通会话 —— core `SessionStore.placements` 缺席的读法)。 */
+    private declaredPlacement;
     private load;
     /** 为这只会话打开它自己的存档,锁内一形(调用方持这只会话的写锁,见 {@link load})。[ref]:这是「为这只会话打开它自己的存档」的那一次
      *  (引擎 prepare 的 acquire)⇒ 包在打开作用域里:这次回放跳过了记录 ⇒ 打开成功后铸一帧 `session.records_skipped` 投给这只会话(唯一铸点
@@ -309,6 +453,15 @@ export declare class LocalSessionStore implements SessionStore {
      *  写下的会话)时,这次打开就是补铸的证明({@link handOut})。GUARD(open 腿):打开一只已存在的会话**不写属主** —— 记下的属主(含「登记为
      *  无主」)一个字节不动,没被记下的也不在这里替它记成无主:打开不是一个属主事实(7.119.0 前这一腿把「不知道」记成进程内存里的 null,重启即失)。 */
     private openForItselfHeld;
+    /**
+     * 带 placement 的按 id 首建(锁内一形,调用方持这只会话的写锁、已判过存档不在且不是 fork 创建的格)。写序 = **判别位先落**:先建存档(引擎文件 repo 把元组写进行头、
+     * 首写不可变),再写会话元数据那一格(化身新铸;属主按委派继承律 —— 根会话的属主,根行不在取父,都不在 ⇒ 孤行哨兵 + 一行 warn;读法与次序只住在
+     * `delegated-session-owner.ts` 的 `createPlacedSessionRow`,三只店同调)。崩在两笔之间 = 存档在而格缺 = 一只 placed 行、属主从没被记下(读作无主;
+     * 这形只在 fleet 调用方可读,停驻挂点的认领口 {@link claimOwnerless} 按委派律补上)。
+     * 格已在而存档不在(登记先落了格、存档还没建 —— 一只普通会话的行)⇒ `placement_refused`(SQL 孪生:登记过的行在,带 placement 的建读回缺席元组,同一判)。
+     * 建后读回准入(镜像方向):别的进程(同一数据根上的 run-local 腿)在这一刻抢先建了同 id 的存档 ⇒ repo 返回的是那一只 ⇒ 元组缺席 / 异组 ⇒ 响亮拒。
+     */
+    private createPlacedHeld;
     /**
      * Idempotently record a session's owner — never overwrites a RECORDED owner (incl. a recorded `null`, "registered ownerless";
      * mirrors TiDBSessionStore.register's first-write rule). TiDB parity: register INSERTs a session_meta row so the session EXISTS
@@ -323,8 +476,19 @@ export declare class LocalSessionStore implements SessionStore {
      */
     register(sessionId: string, owner: string | null): Promise<void>;
     touch(sessionId: string): Promise<void>;
-    /** Durable history is retained by the repo; just drop the in-flight cache entry (mirrors TiDBSessionStore.release). */
+    /**
+     * 普通会话:durable 史留在 repo,只丢 in-flight 那一格(义务 3,与 SQL 孪生同)。
+     * 🔴 义务 4 —— **placed 会话:release 是真删除**(联合收割先删 agent 行、赢了才调这里终结转录)。判据 = 存档行头上的元组(冷启动后照样成立);
+     * 读不出 ⇒ 上抛、一个字节不删(说不准是不是 placed 行;吞掉 = 收割腿数一条「已终结」而字节还在)。删序 = **判别位最后删**:四只行边档与新近 → 元数据格 → 存档最后
+     * —— 崩在中途,存档(连同它的元组)还在,重发的 release 与分区收割腿都还认得它、收得完;反过来先删存档,剩下的边档就没人认领了。
+     * 整段在这只会话的写锁里(与删除 / 换装 / 登记同一把)。
+     */
     release(sessionId: string): Promise<void>;
+    /**
+     * 委派继承律的认领口(锁内 CAS):placed 行、那一格的化身 = `incarnation`、属主无主(记下的 `null` 或从没被记下)⇒ 写 `owner`、返回 true;任何一条不符 ⇒ false、零写
+     * (SQL 孪生的 `CLAIM_OWNERLESS_PLACED_SQL` 同四个条件)。placement 读不出 ⇒ 上抛(不写)。
+     */
+    private claimOwnerlessPlaced;
     /**
      * P0.5 variant-2 (E16, clay 2026-06-26) — enumerate the caller's sessions (CC /resume picker) from the SESSION
      * abstraction (`repo.list()`), keyset-paginated newest-first by last activity. Session IDENTITY comes from the
@@ -333,7 +497,7 @@ export declare class LocalSessionStore implements SessionStore {
      *   - `owner`           — the session's persisted session-meta cell (null when ownerless / never recorded). A
      *                          single-user local deployment runs REQUIRE_PRINCIPAL=off; the route already owner-gates
      *                          at the HTTP layer.
-     *   - `firstActivityAt` — the session's `createdAt` (repo metadata).
+     *   - `firstActivityAt` — the row's `createdAt` (the session-meta cell — the SQL twins' `session_meta.created_at`; the archive header's copy is not read).
      *   - `lastActivityAt`  — the touch marker (falls back to `createdAt`); the keyset sort key.
      *   - `objectivePreview`— the last USER-text entry, synthesized from the session tree (no run ledger).
      *   - `runCount`/`lastStatus`/`lastRunId`/`lastTaskRunId` — [ref]:read from the run store handed in (`runs`; the TiDB
@@ -342,6 +506,10 @@ export declare class LocalSessionStore implements SessionStore {
      *                          `lastTaskRunId` = that run's `result.runId`). One call per list (not per row); a session with no
      *                          run row ⇒ `0 / "" / null` (TiDB's null→"" mapping); a run-store read failure throws (never `0 / ""`).
      *
+     *   - `unreadable`      — present-iff the row's head leaf cannot be read ({@link listedRowOf}: the archive header, or the tail the head read
+     *                          scans): the row's facts above still come from its session-meta cell; `objectivePreview` is null; the marker's
+     *                          `errorCode` is what the session's own reads answer.
+     *
      * Keyset matches the contract: STRICTLY older than the cursor, ties broken by id DESC; `limit` is honored after
      * the in-memory sort. Cheap (a local single-user store holds few sessions). Errors reading one session's entries
      * degrade that row's preview to null rather than failing the whole list.
@@ -390,8 +558,9 @@ export declare class LocalSessionStore implements SessionStore {
      * **fork 续写的店契约**(local 一形;规则与结果闭集在 `session-fork.ts`,SQL 孪生同义):
      *  · **两把写锁**:按 id 字典序依次取源与目标的写锁(锁不可重入;同 id 只取一把)—— 同 id 的每个写者(删除 / 登记 / 导入 / 按 id 首建 / 别的 fork)都在目标那把锁里,
      *    core `repo.fork` 的改名覆盖写只在锁内被调;
-     *  · **源先判**:源存档不在 ⇒ `null`(源被删之后的同键重试答「源不在」);属主读在拷贝之前(源锁持到拷贝落定)—— 唯一读法 `forkOwnerOf`;
-     *  · **唯一创建点 = 格先、存档后**:锁内「目标格不在 ∧ 目标存档不在」才写目标格(带 fork 键;新住客,执行位 absent),再交 core `repo.fork` 写存档。
+     *  · **源先判**:源存档不在 ⇒ `null`(源被删之后的同键重试答「源不在」);源存档带属主戳 ⇒ {@link StampedSessionArchiveError}(零写);属主读在拷贝之前(源锁持到拷贝落定)—— 唯一读法 `forkOwnerOf`;
+     *  · **唯一创建点 = 格先、存档后**:锁内「目标格不在 ∧ 目标存档不在」才写目标格(带 fork 键;新住客,执行位 absent;建档时刻与谱系 `forkedFrom` = 源 id 同一笔写),再交 core `repo.fork` 写存档
+     *    (不交属主 —— 引擎仓匿名;子存档的属主格抄自源存档,源匿名 ⇒ 子匿名)。
      *    崩在两步之间 = fork 创建的格而存档不在 = `forking`:普通取用一律 {@link SessionForkInProgressError};同键重试在两把锁内补拷存档、答 `replayed`。
      *    拷贝抛错(不是崩溃)⇒ 撤掉刚写的目标格再上抛(撤不掉 ⇒ 留下的就是 `forking`,与崩在中间同形);
      *  · **撞已在** ⇒ 按目标格的属主与 fork 键分类({@link classifyForkTarget})。
@@ -422,20 +591,21 @@ export declare class LocalSessionStore implements SessionStore {
     /**
      * 2c session-sync — IMPORT a verbatim entry log into a **new** session `sessionId`(`owner` = 鉴权过的导入者)。按接口句(`importEntries` 只建新会话;改写既有会话走
      * {@link replaceEntries} / 暂存提交),SQL 孪生同判(占行不成 ⇒ 拒):id 上已有行(或格缺而存档在)⇒ `conflict`,一个字节不写;新行的属主 = 导入者、铸一只化身、
-     * 执行位 mirror。属主在本店的属主格上判(会话元数据那一格是本店唯一的属主真源;本店建的存档在引擎仓里不带属主戳 —— `register` 只 `repo.create({ id })` ——
-     * 引擎仓的属主比较替这一格答不了)。整段在这只会话的写锁里,写序见 {@link importHeld}。
+     * 执行位 mirror、建档时刻 = 此刻。属主在本店的属主格上判(会话元数据那一格是本店唯一的属主真源;本店交给引擎仓的写一律匿名 —— 规则一 —— 引擎仓的属主比较替这一格答不了)。
+     * 整段在这只会话的写锁里,写序见 {@link importHeld}。
      */
     importEntries(sessionId: string, owner: string | null, entries: SessionTreeEntry[]): Promise<void>;
     /**
      * 2c session-sync (§7/§8) — IDEMPOTENT REPLACE,按接口句(`SessionStorage.replaceEntries`:先清这只会话既有的对话日志,再导入 `entries`)。
      * 与 {@link importEntries} 同一个入口、同一只写序,只差落点(行不在,或行上的属主就是导入者)与内容那一半(先清内容存档再导入,见 {@link importHeld} ③)——
-     * 所以一只会话头读不出的存档也换得掉;存档是重建的那一只,建档时刻 = 换装时刻(SQL 孪生 replace 重插行、`created_at` 重记,同义)。行的四只边档原样。
+     * 所以一只会话头读不出的存档也换得掉;存档是重建的那一只(匿名),行原样:属主重戳为导入者,化身、建档时刻、谱系与四只边档照带(行事实不住在存档上 ——
+     * 重建存档不移动它们)。
      */
     replaceEntries(sessionId: string, owner: string | null, entries: SessionTreeEntry[]): Promise<void>;
     /**
      * 换装三条写腿(公开 {@link importEntries} / {@link replaceEntries} 与暂存提交 {@link commitStagedImport})的**同一个入口**:调用方给的属主先过
      * {@link importerOwnerOf}(主体名或 `null`;否则 `TypeError`,什么都没读、一个字节没写),再进这只会话的写锁 —— 锁里的写体只见判过的那一个值,
-     * 写进行的属主就是它。引擎导入口的属主判管不到这一格:换装交给引擎的是存档自己的戳(见 {@link importHeld} ③),不是调用方的属主。
+     * 写进行的属主就是它。引擎导入口的属主判管不到这一格:换装交给引擎的属主恒缺席(匿名,见 {@link importHeld} ③),不是调用方的属主。
      */
     private withImportLock;
     /**
@@ -443,12 +613,12 @@ export declare class LocalSessionStore implements SessionStore {
      *  ① 只读、零写:引擎闸 `validateEntriesForImport`(坏包 ⇒ `invalid_session`)· 本处写者 ⇒ {@link SessionWriterPresentError} · `forking` ⇒
      *    {@link SessionForkInProgressError} · 不是这个写口的门判过的行 ⇒ {@link importRowRefused}(判据 {@link importMayLand},按写口带来的 {@link ImportLanding};
      *    这条路径上唯一一次判属主);
-     *  ② 行先:{@link landImportCell}(属主重戳为导入者、化身与 fork 键沿用或新铸、执行位 mirror);
-     *  ③ 内容,按写口的动词(唯一读法在下面这一只 switch;这里不读那一格、不判属主,只换**内容**):
-     *    · `create` / `judged`(导入):原地换锁里读到的那一份存档的日志(没有存档 ⇒ 导入新建一只),存档的元数据整只留着(其中的建档时刻是列表行的
-     *      firstActivityAt,与 SQL 孪生留在行上的 `created_at` 同义)。存档上的属主戳不是本店的事实(本店建的存档一律不带戳,存量存档可能带着此前导入者的戳),
-     *      只是引擎仓原地换的条件:按那一份存档自己的戳导入,并以它为 `expect`(戳 + 存档的令牌)—— 读与写之间它换了一代 ⇒ 引擎仓拒 `conflict`。
-     *      读存档、校验、存档判与写在引擎仓里是一步,抛在哪一处内容都一个字节没动 ⇒ 撤回 ②({@link withdrawImportCell}:行原样,SQL 孪生的事务回滚同义)再原样上抛;
+     *  ② 行先:{@link landImportCell}(属主重戳为导入者、化身与 fork 键沿用或新铸、执行位 mirror;建档时刻与谱系照带,新行写此刻);
+     *  ③ 内容,按写口的动词(唯一读法在下面这一只 switch;这里不读那一格、不判属主,只换**内容**;交给引擎仓的属主恒缺席 —— 规则一):
+     *    · `create` / `judged`(导入):原地换锁里读到的那一份存档的日志(没有存档 ⇒ 导入新建一只,匿名),以锁里读到的存档头为 `expect.row`(**行代号**:
+     *      读与写之间存档换了一代 ⇒ 引擎仓拒 `conflict`;它判不出同一代里的追加)。匿名导入只换匿名存档的日志 —— 仍带属主戳的存档(更早的版本写下、一次性迁移 M33
+     *      改写不了的,或跳版升上来的)本店先以具名拒 `StampedSessionArchiveError` 答(与 fork 同一只;引擎导入律同样会拒,本店不重写、不绕,只让拒带对的出路)。
+     *      读存档、校验、存档判与写在引擎仓里是一步,抛在哪一处内容都一个字节没动 ⇒ 撤回 ②({@link withdrawImportCell}:行原样 —— 净零写,SQL 孪生的事务回滚同义)再原样上抛;
      *    · `replace`(接口句「先清既有对话日志,再导入」):先清掉内容存档(不带 `expect` —— 带了就得先读它的头,读不出的存档就清不掉),再导入一只新存档。
      *      清不可撤:清过之后导入再抛(I/O 故障),内容就没了,行留 ② 落下的 mirror(只读方向,下次推送补齐)—— 已发版本的 replace 同形(删后导入)。
      *      带 fork 键的行(fork 建出的目标)留下的是「mirror、键仍在、存档不在」:不读作 `forking`({@link isForkCreatedCell}:fork 创建点写下的格执行位恒缺,② 落下 mirror 之后它就不再是那一形),
@@ -457,6 +627,11 @@ export declare class LocalSessionStore implements SessionStore {
      * 崩在 ②③ 之间 = 格已是 mirror、内容旧或空 = 只读方向,下次推送补齐(SQL 孪生在一个事务里写行与内容,没有这个中间态)。
      */
     private importHeld;
+    /**
+     * 改写面的分区判(调用方持这只会话的写锁):placed 行 ⇒ `placement_refused`(import 面 409 `conflict.session_placed`,`session-error-wire.ts`),一个字节不写。
+     * 读法 = {@link isPlacedRow}(行头读不出 ⇒ 按普通行答,坏档照样换得掉;说不出 ⇒ 抛)。
+     */
+    private assertNotPlacedHeld;
     /**
      * ① 的属主 / 住客条件:这一行此刻是不是这个写口的门判过的行({@link ImportLanding};一次读、零写 —— 格缺时「行在不在」只问存档的唯一探针
      * {@link existsInRepo},不补铸那一格)。属主比的是头读的读法 `owner ?? null`(从没被记下 = 无主;格缺而存档在 = 从没被记下),比较器是删除门的那一只
@@ -467,8 +642,8 @@ export declare class LocalSessionStore implements SessionStore {
     /**
      * ② 推送落下的那一格 —— 三个导入写口与暂存提交「内容相同、日志不动」那一支都经这**一处**(调用方持写锁、① 已判过):属主重戳为导入者;
      * 化身与 fork 键经 {@link carriedRowCells}(三只店同一句)读那一格自己 —— 行在 ⇒ 沿用(同一行 = 同一位住客,属主重戳与否不改这一判),刚建 ⇒ 新铸、不带键;
-     * 执行位 = mirror(导入落下的是「写者在别处」;SQL 孪生的提交点同一句写)。只写这一格:四只行边档与新近不在这里。
-     * 交回写之前的那一格(`undefined` = 原本没有),③ 撤回用。
+     * 执行位 = mirror(导入落下的是「写者在别处」;SQL 孪生的提交点同一句写)。**在 `before` 上改这三位**,别的位(建档时刻、谱系)照带;刚建的行建档时刻 = 此刻。
+     * 只写这一格:四只行边档与新近不在这里。交回写之前的那一格(`undefined` = 原本没有),③ 撤回用。
      */
     private landImportCell;
     /**
@@ -516,9 +691,55 @@ export declare class LocalSessionStore implements SessionStore {
      * [ref]:化身随那一格消失(同 id 重登记铸新的 —— 那就是下一位住客)。
      */
     private deleteSessionHeld;
+    /**
+     * 删一只会话的**行**(调用方持这只会话的写锁)—— 删除与 placed 的 release 两处共用这一只,存档的删除由两位各自排在前或后:
+     * ⓪ 登记「删行已开始」(锁外读者从此不补铸,见 {@link rowsDropped});① 四只行边档(标题 / 置顶 / 指令来源 / 工作区),落不了盘 ⇒ 抛(留下的那一格会在重启后
+     * 挂到同 id 的下一位身上);② 新近标记:先把盘上那一份读进来再删(冷起服后的第一笔就是删 ⇒ 删的若是空表,随后那次落盘会把盘上那一笔并回去),防抖落盘;
+     * ③ 属主 + 化身那一格**最后**删,落不了盘 ⇒ 抛(留下的格会让删掉的会话重启后「还在」;边档任一只先抛时那一格还在 ⇒ 重发照样走得进来、收敛)。
+     */
+    private dropRowHeld;
+    /**
+     * 引擎文件仓的存档目录(`<数据根>/sessions`,`FileSessionRepo` 的布局)fsync 一次,失败即抛 —— M33 在删快照之前确知新写的存档目录项在盘上
+     * (引擎的导入只尽力 fsync 目录,吞掉失败)。只有 M33 用;目录不在 ⇒ 抛(布局变了就响亮,不静默跳过屏障)。
+     */
+    private syncArchiveDirectory;
+    /** 快照目录(数据根下;内存部署 ⇒ `undefined`:没有持久存档,迁移零动作)。 */
+    private archiveSnapshotDir;
+    /**
+     * **步 0 · 恢复先行**(起服、先于一切请求与本条其余步骤;`LocalBackend.ensureSchema` 调,`migrateLocalArchives` 开头再调一次 —— 幂等):快照目录里的每一份记录 ——
+     *  · 存档不在(崩在删之后、导入之前)⇒ 用记录匿名导入补回、行上缺的事实从记录补、删记录;
+     *  · 存档在且匿名(崩在导入之后、删记录之前)⇒ 补行上缺的事实、删记录;
+     *  · 存档在、带戳、行代号 = 记录里那一代(崩在删之前)⇒ 删记录(这只存档在步 3 重做);
+     *  · 别的组合 / 记录读不出 / 补回抛 ⇒ 拒启({@link LocalArchiveSnapshotsPresentError},点名会话、路径与原因)。
+     * `atomicWriteFile` 留下的 `.tmp`(改名没发生 = 记录从没写成 ⇒ 那一次什么都还没删)直接删。消化完,常设臂 {@link assertNoArchiveSnapshots}:目录必空 ⇒ 服务开始之前快照与服务从不并存。
+     * 交回这一次消化掉的记录数。
+     */
+    settleArchiveSnapshots(): Promise<number>;
+    /** 消化一份快照记录(步 0 的一条;拒 ⇒ {@link LocalArchiveSnapshotsPresentError},记录原样留着)。 */
+    private settleArchiveSnapshot;
+    /** 把行事实补进那一格(格缺 ⇒ 铸一格;已有的位一个不动)并落盘。 */
+    private fillRowFacts;
+    /**
+     * 一次性迁移 M33 的 local 腿(`LocalBackend.runOneTimeMigrations` 调;起服、先于任何请求;窗内每次起服都跑,第二次起零命中):
+     *  0. 恢复先行({@link settleArchiveSnapshots},幂等);
+     *  1. **枚举**(行集 `rowHeaders`):id 全集 = 引擎仓的列表(读得出头的存档)∪ 边档全部键;只在边档里的、头读抛且不是 placed 行(行头读得出)的 ⇒ 计 unreadable(步 3 整档读抛的同计)。两边都不在的读不出存档(列表跳过它、边档里没它的格)
+     *     对本店与引擎同样不可见,不计;
+     *  2. **行回填**:列表里每一只存档 —— 格缺 ⇒ 建一格(化身新铸、属主「从没被记下」,与补铸同义);格缺建档时刻 ⇒ 写存档头的;格缺谱系而存档头有 ⇒ 写它。只写行(边档的一次提交),
+     *     然后一道**落盘屏障**(边档文件与目录各 fsync)—— 在这之前不碰任何存档;
+     *  3. **存档归一**(每只头上带属主戳的存档,在它的会话写锁里):a 整档一次读(读时跳过了记录 ⇒ 留着,计 kept `records_skipped`:重写会抹掉盘上那几行读不出的字节)→
+     *     b 先验(引擎导入闸,带 `preserveActorAssertions`:同部署迁移,发言者归属不剥)—— 抛 ⇒ kept `invalid`;验后的日志与原日志不逐条相等(引擎导入会改写内容)⇒ kept `normalizes`;
+     *     两种都原样不动 —— 迁移**从不改内容** → c 快照记录经 core `atomicWriteFile`(tmp → fsync → rename → fsync 目录)→ d 以这一代为条件删存档 → e 匿名导入(缺行 ⇒ 新存档,
+     *     引擎自己 fsync)→ f 删记录。
+     * 屏障(本店自做、失败即抛;core 的 `atomicWriteFile` 与引擎导入只尽力 fsync 目录):c 之后快照目录、e 之后存档目录、f 之后快照目录各 fsync 一次。
+     * 保证分档:进程崩在任一步 ⇒ 不丢(下一次起服步 0 消化);掉电 ⇒ 在兑现 fsync 的文件系统上不丢。d / e / 屏障抛 ⇒ 原样上抛(起服拒;下一次起服步 0 消化)。
+     */
+    migrateLocalArchives(): Promise<LocalArchiveMigrationReading>;
+    /** 步 3 的一只(调用方持这只会话的写锁)。 */
+    private anonymizeArchiveHeld;
     get size(): number;
     /** Graceful shutdown: AWAIT the final sidecar write (bug C) so a restart doesn't lose the last debounced-but-unwritten
      *  touch. Cancels any queued debounce, then awaits a flush (which chains after any in-flight write and merges disk). */
     dispose(): Promise<void>;
 }
+export {};
 //# sourceMappingURL=local-session-store.d.ts.map