@morlay/session-rdb 0.0.15 → 0.0.16-alpha.1

package/dist/index-GdKkSSb-.d.mts

@@ -0,0 +1,239 @@
+import { a as JournalMode, g as Backend, h as WriteGuard } from "./schema-COK7-wRV.mjs";
+import z from "@deepseek-ai/schemastery";
+import { SessionAccess, SessionHandle, SessionHandleAppendOptions, SessionHandleFlushOptions, SessionHandleReadOptions, SessionHandleReadResult, SessionPersistence, SessionPersistenceCreateOptions, SessionPersistenceListOptions, SessionPersistenceOpenOptions, SessionPersistenceRevision, SessionPersistenceSnapshot, SessionPersistenceStatOptions } from "@deepseek-ai/dsh-session-persistence";
+import { Session, SessionEvent, SessionHeader, SessionId, SessionLogOffset } from "@deepseek-ai/dsh-session";
+import { BranchAnchorMode, BranchBoundary, ForkFromOptions, SessionBranch, SessionBranchProvider } from "@morlay/session-branch";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/branch.d.ts
+declare function locateTurnEnd(events: readonly SessionEvent[], atSeq?: number, mode?: BranchAnchorMode): number;
+interface LiveSessionHooks {
+  getSession(id: SessionId): Session | undefined;
+  getAgent(id: SessionId): LiveAgentLike | undefined;
+  flush(session: Session): Promise<boolean>;
+}
+interface LiveAgentLike {
+  session: Session;
+  requestHeaderLogged?: boolean;
+}
+declare class SessionBranchRdbProvider implements SessionBranchProvider {
+  private readonly persistence;
+  private readonly live;
+  readonly name = "session-rdb";
+  constructor(persistence: SessionPersistenceRdb, live?: LiveSessionHooks);
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
+  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    events: readonly SessionEvent[];
+  }>;
+  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
+}
+declare class SessionBranchRdb extends SessionBranch {
+  static inject: string[];
+  constructor(ctx: import("@deepseek-ai/cordis").Context);
+  private readonly provider;
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
+  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    events: readonly SessionEvent[];
+  }>;
+  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
+  timeline(sessionId: SessionId, signal?: AbortSignal): Promise<import("@morlay/session-branch").BranchTimeline>;
+}
+//#endregion
+//#region src/index.d.ts
+interface SessionPersistenceRdbInternals {
+  readonly backend: Backend;
+  readonly writeGuard: WriteGuard;
+  create(meta: SessionHeader, inheritedEventCount?: number): Promise<SessionHandle>;
+  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+  load(id: SessionId): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  inspect(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: readonly SessionEvent[];
+  }>;
+  listSnapshots(signal?: AbortSignal): Promise<SessionPersistenceSnapshot[]>;
+  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionPersistenceRevision | undefined>;
+  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
+}
+type Config = {
+  type: "sqlite";
+  path: string;
+  journalMode?: JournalMode;
+  busyTimeout?: number;
+} | {
+  type: "postgres";
+  connectionString: string;
+  schema?: string;
+};
+/** 一个已创建但未 materialize 的会话（本进程可见，其他进程不可见）。 */
+interface PendingSession {
+  readonly header: SessionHeader;
+  readonly revision: SessionPersistenceRevision;
+  readonly inheritedEventCount: SessionLogOffset;
+  /** 输入空间 cursor（全 delta 批次也推进）。 */
+  readonly cursor: number;
+  /** 是否调用过 append（close 时保留 pending）。 */
+  readonly everAppended: boolean;
+}
+/** 会话级写所有权与 live 路由簿记。 */
+declare class RdbBackendTracker {
+  private readonly name;
+  /** 每个 id 的活跃 write handle；`null` 表示 claim 构造中。 */
+  private readonly writers;
+  private readonly pending;
+  private readonly openHandles;
+  private counter;
+  constructor(name: string);
+  registerCreated(header: SessionHeader, inheritedEventCount: SessionLogOffset): void;
+  /** 更新 pending 的 cursor / everAppended（handle append 后同步）。 */
+  updatePending(id: SessionId, cursor: number, everAppended: boolean): void;
+  claimWrite(id: SessionId): void;
+  releaseClaim(id: SessionId): void;
+  pendingOf(id: SessionId): PendingSession | undefined;
+  hasPending(id: SessionId): boolean;
+  pendingEntries(): IterableIterator<[SessionId, PendingSession]>;
+  materialized(id: SessionId): void;
+  adopt(handle: RdbSessionHandle): RdbSessionHandle;
+  release(handle: RdbSessionHandle, materialized: boolean): void;
+  writerOf(id: SessionId): RdbSessionHandle | undefined;
+  flushAll(): Promise<void>;
+  closeAll(): Promise<void>;
+}
+/** 一个打开会话的存储句柄：read / append / flush / close。 */
+declare class RdbSessionHandle implements SessionHandle {
+  private readonly persistence;
+  readonly id: SessionId;
+  readonly header: SessionHeader;
+  readonly access: SessionAccess;
+  private readonly state;
+  private chain;
+  private closing;
+  /** 稠密 next-seq（输入空间计数，与旧版 coordinator cursor 同语义）。 */
+  private cursor;
+  private materialized;
+  /** live 路由缓冲（上游 seq 事件，drain 时过滤 delta 后重编号稠密）。 */
+  private buffered;
+  private batchTimer;
+  private drainPaused;
+  private draining;
+  /** write open 时发现的 torn tail 起点（append 前先截断）。 */
+  private tornTruncateTo;
+  /** 是否调用过 append（即使全 delta 未落库）——close 时保留 pending。 */
+  private everAppended;
+  constructor(persistence: SessionPersistenceRdb, id: SessionId, header: SessionHeader, access: SessionAccess, state: {
+    cursor: number;
+    materialized: boolean;
+    inheritedEventCount: SessionLogOffset;
+    tornTruncateTo?: number;
+  });
+  get inheritedEventCount(): SessionLogOffset;
+  /** 输入空间 cursor（下一个待落库的上游 seq）。 */
+  get cursorValue(): number;
+  read(offset?: number, length?: number, options?: SessionHandleReadOptions): Promise<SessionHandleReadResult>;
+  append(events: readonly SessionEvent[], options?: SessionHandleAppendOptions): Promise<void>;
+  flush(options?: SessionHandleFlushOptions): Promise<void>;
+  close(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+  /** live 路由：缓冲一个已发布事件（持久化自有副本），并启动批量窗口。 */
+  enqueueLive(event: SessionEvent, reportBackgroundFailure: (error: unknown) => void): void;
+  /** rewind 截断后对齐 handle 的稠密 cursor 与继承前缀（DB 已截断）。 */
+  resetAfterRewind(cursor: number, inheritedEventCount?: number): void;
+  /** 排空 live 缓冲（过滤 delta + 重编号稠密 + append）。 */
+  drainLive(): Promise<void>;
+  private drainBuffered;
+  private enqueueChain;
+  private run;
+  private assertOpen;
+  static readonly LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
+}
+declare class SessionPersistenceRdb extends SessionPersistence {
+  config: Config;
+  static inject: string[];
+  static Config: z<Config>;
+  static readonly settingsNs = "session-rdb";
+  readonly name = "session-rdb";
+  readonly tracker: RdbBackendTracker;
+  private readonly backend;
+  private storeIdentity;
+  private readonly ready;
+  private readonly writeGuard;
+  private readonly reuseEventIds;
+  /** live 路由：session/created 后 handle 就绪前的缓冲。 */
+  private readonly liveBuffers;
+  private readonly liveReady;
+  constructor(ctx: Context, config: Config, injectedBackend?: Backend);
+  private init;
+  create(header: SessionHeader, options?: SessionPersistenceCreateOptions): Promise<SessionHandle>;
+  open(id: SessionId, access: SessionAccess, options?: SessionPersistenceOpenOptions): Promise<SessionHandle>;
+  flush(): Promise<void>;
+  stat(id: SessionId, options?: SessionPersistenceStatOptions): Promise<SessionPersistenceSnapshot | undefined>;
+  list(options?: SessionPersistenceListOptions): Promise<readonly SessionPersistenceSnapshot[]>;
+  /** 导出 artifact（jsonl v2 文本），视图只读不落库。 */
+  readRaw(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    filename: string;
+    content: string;
+  } | undefined>;
+  /** 空会话 materialize（flush 的持久化屏障）。 */
+  materializeEmpty(meta: SessionHeader, inheritedEventCount: SessionLogOffset): Promise<void>;
+  /** 原样 append 落库（handle 已校验 contiguity；torn tail 先截断）。
+   *  与上游 JSONL 一致：ignorable 事件原样存储，不做过滤。写路径校验 v2
+   *  形状（fail-closed）：未知类型（非 ignorable）与非法消息形状拒绝入库；
+   *  旧格式（v0/v1）数据只在读取时经 legacy 转换链动态转换，不落新库。 */
+  appendBatch(meta: SessionHeader, inheritedEventCount: SessionLogOffset, events: readonly SessionEvent[], tornTruncateTo?: number): Promise<boolean>;
+  /** 读取一个会话的稠密 log（含 torn tail 检测，不含修复改写）。 */
+  readLog(id: SessionId, options?: {
+    fromSeq?: number;
+  }, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: SessionEvent[];
+    tornFrom?: number;
+    incarnation: string;
+    revision: number;
+    /** 存储桥接行数（迁移链可能生成/合并事件，与 `events.length` 不同）。 */
+    storedCount: number;
+    /** 是否经上游迁移链转换（v0/v1 → 当前格式）。 */
+    migrated: boolean;
+  } | undefined>;
+  /**
+   * 把迁移链读出的 v2 视图整体落库（旧格式会话写打开时的一次性迁移）。
+   *
+   * 迁移链会生成/合并事件（end-seed / attempt / chunk 合并），事件 seq 空间
+   * 与存储桥接行数不再相等；写路径以存储 head 为锚点重编号，二者不一致会让
+   * append 撞上已有行。这里在同一事务内删光本会话桥接行、按迁移视图重建
+   * （新事件行，完整信封），并更新 head 与 revision；旧事件行保留（可能被
+   * fork 子会话引用，孤儿由惰性 GC 处理）。
+   */
+  private rewriteMigratedLog;
+  listSnapshots(signal?: AbortSignal): Promise<Array<SessionPersistenceSnapshot & {
+    inheritedEventCount: number;
+  }>>;
+  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<SessionPersistenceRevision | undefined>;
+  /** 便捷：create + append + close（测试与导入路径共用）。 */
+  createAndAppend(header: SessionHeader, events: readonly SessionEvent[], inheritedEventCount?: number): Promise<void>;
+  /** 便捷：open(read) + read 全量 + close。 */
+  load(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  /** 便捷：open(write) + append + close。 */
+  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+  /** 便捷：readFrom（稠密后缀）。 */
+  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: readonly SessionEvent[];
+  }>;
+  close(): Promise<void>;
+  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
+  internals(): SessionPersistenceRdbInternals;
+  private rowRevision;
+  private installLiveRouting;
+  /** session/created 后为 live 会话建立 write handle（create 或 adopt）。 */
+  private ensureLiveHandle;
+}
+//#endregion
+export { SessionBranchRdbProvider as a, SessionBranchRdb as i, SessionPersistenceRdb as n, locateTurnEnd as o, SessionPersistenceRdbInternals as r, Config as t };

package/dist/index.d.mts

@@ -1,3 +1,3 @@
-import { n as EPHEMERAL_EVENT_TYPES, s as SCHEMA_VERSION } from "./schema-CFXZURX7.mjs";
-import { a as SessionBranchRdbProvider, i as SessionBranchRdb, n as SessionPersistenceRdb, o as locateTurnEnd, r as SessionPersistenceRdbInternals, t as Config } from "./index-uUvn6gYp.mjs";
-export { Config, EPHEMERAL_EVENT_TYPES, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, SessionPersistenceRdbInternals, locateTurnEnd };
+import { o as SCHEMA_VERSION } from "./schema-COK7-wRV.mjs";
+import { a as SessionBranchRdbProvider, i as SessionBranchRdb, n as SessionPersistenceRdb, o as locateTurnEnd, r as SessionPersistenceRdbInternals, t as Config } from "./index-GdKkSSb-.mjs";
+export { Config, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, SessionPersistenceRdbInternals, locateTurnEnd };