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

package/src/invariant.ts

@@ -1,4 +1,3 @@
-/* jscpd:ignore-start */
 import type { Context } from "@deepseek-ai/cordis";
 import type { InvariantInstaller } from "@deepseek-ai/dsh-invariants";
 
@@ -12,4 +11,3 @@ const install: InvariantInstaller = () => {};
 
 export const apply = (ctx: Context): Promise<() => void> =>
   Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
-/* jscpd:ignore-end */

package/src/legacy.ts

@@ -0,0 +1,110 @@
+// 旧格式（v0/v1）历史数据读取转换：RDB 行 → v0/v1 物理记录 → 上游迁移链 →
+// v2 逻辑事件。RDB 写路径从不持久化 sourceEventSeqs（读取时重计算），且
+// delta（assistant/chunk）落盘被过滤——v1→v2 迁移对无 chunk 引用的
+// assistant/message 走「无 pending 直接 emit」路径，生成 stream: [] 的 v2 事件。
+
+import {
+  SESSION_FORMAT_VERSION,
+  type SessionEvent,
+  type SessionHeader,
+  type SessionId,
+} from "@deepseek-ai/dsh-session";
+import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
+import type { EventRow, SessionRow } from "./backend.ts";
+import { rowToMeta, scanRows } from "./log.ts";
+
+/** 重建 v0/v1 物理 header 记录（RDB 行 → 物理 JSON 对象）。 */
+function physicalHeader(row: SessionRow): Record<string, unknown> {
+  return {
+    type: "session",
+    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 } : {}),
+    delegationDepth: row.fDelegationDepth ?? 0,
+  };
+}
+
+/** 重建一条 v0/v1 物理事件记录（桥接行 + 事件行 → 物理 JSON 对象）。 */
+function physicalEvent(row: EventRow): Record<string, unknown> {
+  return {
+    type: row.fType,
+    seq: row.fSequence,
+    time: row.fCreatedAt,
+    data: JSON.parse(row.fData) as unknown,
+    ...(row.fSurfaceOp !== null ? { surfaceOp: JSON.parse(row.fSurfaceOp) as unknown } : {}),
+  };
+}
+
+/**
+ * 把旧格式（v0/v1）行转换为 v2 逻辑事件与 header。
+ * @param row - 会话行（f_version < 2）。
+ * @param eventRows - 已扫描保留的桥接行（稠密 seq，torn tail 已剔除）。
+ * @returns v2 逻辑 header、继承前缀长度与事件。
+ * @throws 迁移链拒绝（格式损坏 / 无法迁移）时原样抛出。
+ */
+export function convertLegacyRows(
+  row: SessionRow,
+  eventRows: readonly EventRow[],
+): { meta: SessionHeader; inheritedEventCount: number; events: SessionEvent[] } {
+  const restore = sessionFormatCatalog.createRestore(physicalHeader(row), {
+    recovery: "strict",
+    validation: "transformed",
+  });
+  for (const eventRow of eventRows) {
+    restore.decodeRow(physicalEvent(eventRow));
+  }
+  const artifact = restore.finish();
+  return {
+    meta: artifact.header as unknown as SessionHeader,
+    inheritedEventCount: artifact.inheritedEventCount,
+    events: artifact.events as unknown as SessionEvent[],
+  };
+}
+
+/** 会话行是否携带旧格式（v0/v1）数据。 */
+export function isLegacyVersion(version: number): boolean {
+  return version < 2;
+}
+
+/**
+ * 迁移链拒绝后，把旧格式行直接当**当前格式**事件视图采用。
+ *
+ * 旧写入器只在建会话时落一次 header version，之后跟随上游演进继续追加
+ * 事件——同一个 log 因此可能是混合世代（v0 时代的行 + 新版本字段），不是
+ * 任何单一已发布格式，严格迁移链必然拒绝。这些行的数据形状（消息包装、
+ * 类型名）已经是当前格式，只需 header 版本归一到当前、按稠密 seq 读取；
+ * 事件数据的补全与 surface 修复由读取视图修复（repairReadView）负责。
+ *
+ * 调用方须在此之后执行 `validateStoredEvents`：真正属于旧格式的类型
+ * （`assistant/chunk` / `compact/*` 等）仍会被 fail-loud 拒绝。
+ *
+ * @param row - 会话行（f_version < 2）。
+ * @param eventRows - 该会话全部桥接行（按 f_sequence 升序）。
+ * @returns 当前格式 header（version 归一到 SESSION_FORMAT_VERSION）、收缩后的
+ *   继承前缀长度、稠密事件与可选 torn tail 起点。
+ * @throws scanRows 的已提交区损坏错误（seq gap / 不可解析行）。
+ */
+export function adoptLegacyRows(
+  row: SessionRow,
+  eventRows: readonly EventRow[],
+): {
+  meta: SessionHeader;
+  inheritedEventCount: number;
+  events: SessionEvent[];
+  tornFrom?: number;
+} {
+  const { preserved, tornFrom } = scanRows(eventRows, 0);
+  return {
+    meta: { ...rowToMeta(row), version: SESSION_FORMAT_VERSION },
+    // 继承前缀不得超过事件数（历史 rewind 未收缩的损坏样式），上游 load 判损坏。
+    inheritedEventCount: Math.min(row.fSeedLength ?? 0, preserved.length),
+    events: preserved,
+    ...(tornFrom !== undefined ? { tornFrom } : {}),
+  };
+}
+
+export type { SessionId };

package/src/log.ts

@@ -1,5 +1,6 @@
 import type { SessionEvent, SessionHeader, SessionId, SurfaceOp } from "@deepseek-ai/dsh-session";
-import { SessionSeq, encodeSeqRanges, packChunkRuns } from "@deepseek-ai/dsh-session";
+import type { SessionFormatEvent, SessionFormatHeader } from "@deepseek-ai/dsh-session-format";
+import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
 import type { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
 import type { EventRow, SessionRow } from "./backend.ts";
 
@@ -8,7 +9,7 @@ export function rowToMeta(row: SessionRow): SessionHeader {
     throw new Error("stored session createdAt must be a non-negative safe integer");
   }
   return {
-    version: row.fVersion,
+    version: row.fVersion as SessionHeader["version"],
     id: row.fSessionId as SessionId,
     createdAt: row.fCreatedAt,
     ...(row.fCwd !== null ? { cwd: row.fCwd } : {}),
@@ -74,77 +75,38 @@ export function sessionConflictRow(storage: SessionStorageMetadata): {
   };
 }
 
-export function remapSurfaceOp(op: SurfaceOp, remap: (seq: number) => number): SurfaceOp {
-  if (op === "append") return op;
-  return {
-    op: "replace",
-    start: SessionSeq(remap(op.start)),
-    end: SessionSeq(remap(op.end)),
-  };
-}
-
-export function remapShadowedRange(
-  range: { start: number; end: number },
-  remap: (seq: number) => number,
-): { start: number; end: number } {
-  return { start: remap(range.start), end: remap(range.end) };
-}
-
-export function remapShadowedSeqs(
-  seqs: readonly number[],
-  seqMap: ReadonlyMap<number, number>,
-): number[] {
-  // 未持久化的引用（分支裁剪等）直接丢弃：恒等回退会留下陈旧的上游 seq，
-  // 稠密坐标通常被压缩，它可能大于 replace 事件的稠密 seq，上游
-  // assertProvenance 会以 "must reference earlier events" 拒绝整个会话。
-  return seqs.flatMap((seq) => {
-    const dense = seqMap.get(seq);
-    return dense === undefined ? [] : [dense];
-  });
-}
-
-export function rowToEvent(row: EventRow, seqMap: ReadonlyMap<number, number>): SessionEvent {
-  const remap = (seq: number): number => seqMap.get(seq) ?? seq;
-  const surfaceOp =
-    row.fSurfaceOp !== null
-      ? remapSurfaceOp(JSON.parse(row.fSurfaceOp) as SurfaceOp, remap)
-      : undefined;
-  const data = JSON.parse(row.fData) as SessionEvent["data"];
-  // compaction 事件的 shadowedRange / shadowedSeqs 是插件合并字段，经结构化
-  // 视图重映射到稠密坐标。shadowedSeqs 是权威的被遮蔽节点列表（range 只是
-  // 首尾边界对，压缩竞态下可能漏掉并发落地的节点），replace 的 provenance
-  // 重计算依赖它，必须与 range 同空间。
-  if (row.fType === "compaction/summary" || row.fType === "compaction/prune") {
-    const metering = data as unknown as {
-      shadowedRange?: { start: number; end: number };
-      shadowedSeqs?: number[];
-    };
-    if (metering.shadowedRange !== undefined) {
-      metering.shadowedRange = remapShadowedRange(metering.shadowedRange, remap);
-    }
-    if (metering.shadowedSeqs !== undefined) {
-      metering.shadowedSeqs = remapShadowedSeqs(metering.shadowedSeqs, seqMap);
-    }
+export function rowToEvent(row: EventRow): SessionEvent {
+  const surfaceOp = row.fSurfaceOp !== null ? (JSON.parse(row.fSurfaceOp) as SurfaceOp) : undefined;
+  const record = JSON.parse(row.fData) as unknown;
+  // fData 形状判别：新写入的完整事件（含 ignorable 信封，与 JSONL 每行
+  // 同构）vs 旧 v2 库的纯 data 部分。完整事件必有 type/seq/time/data 四键。
+  const full =
+    typeof record === "object" &&
+    record !== null &&
+    !Array.isArray(record) &&
+    typeof (record as Record<string, unknown>)["type"] === "string" &&
+    typeof (record as Record<string, unknown>)["seq"] === "number" &&
+    typeof (record as Record<string, unknown>)["time"] === "number" &&
+    "data" in (record as Record<string, unknown>);
+  if (full) {
+    // seq/time 以桥接行/事件列为权威（rewind 截断后仍稠密连续）；
+    // surfaceOp 走桥接行列，sourceEventSeqs 不落库（读取时重计算）。
+    return {
+      ...(record as SessionEvent),
+      seq: row.fSequence,
+      time: row.fCreatedAt,
+      ...(surfaceOp === undefined ? {} : { surfaceOp }),
+    } as SessionEvent;
   }
   return {
     type: row.fType as SessionEvent["type"],
     seq: row.fSequence,
     time: row.fCreatedAt,
-    data,
+    data: record as SessionEvent["data"],
     ...(surfaceOp === undefined ? {} : { surfaceOp }),
   } as SessionEvent;
 }
 
-export function buildSeqMap(
-  rows: readonly Pick<EventRow, "fSequence" | "fOriginalSeq">[],
-): Map<number, number> {
-  const map = new Map<number, number>();
-  for (const row of rows) {
-    if (!map.has(row.fOriginalSeq)) map.set(row.fOriginalSeq, row.fSequence);
-  }
-  return map;
-}
-
 const SURFACE_EVENT_TYPES = new Set(["user/message", "assistant/message", "tool/result"]);
 
 const METERING_EVENT_TYPES = new Set(["compaction/summary", "compaction/prune"]);
@@ -249,12 +211,15 @@ export function findSurfaceRepairs(events: readonly SessionEvent[]): {
   degradeToAppend: Set<number>;
   addAppendMarker: Set<number>;
   clearSurfaceOp: Set<number>;
+  clampEnd: Map<number, number>;
 } {
   const nodes: number[] = [];
   const degradeToAppend = new Set<number>();
   const addAppendMarker = new Set<number>();
   const clearSurfaceOp = new Set<number>();
-  for (const event of events) {
+  const clampEnd = new Map<number, number>();
+  for (let index = 0; index < events.length; index++) {
+    const event = events[index]!;
     const raw = event as SessionEvent & { surfaceOp?: unknown };
     const op = raw.surfaceOp;
     if (op === undefined) {
@@ -285,7 +250,16 @@ export function findSurfaceRepairs(events: readonly SessionEvent[]): {
       isEventSeqLike(start) &&
       isEventSeqLike(end);
     const startIdx = shapeOk ? nodes.indexOf(start as number) : -1;
-    const endIdx = shapeOk ? nodes.indexOf(end as number) : -1;
+    let endIdx = shapeOk ? nodes.indexOf(end as number) : -1;
+    // 旧写入器重编号事件后，存储的 range 端点可能落在旧坐标空间：end 不在
+    // 当前 surface 中，但紧邻 metering 事件的 shadowedSeqs 仍给出被遮蔽
+    // 节点数量。按数量从 start 起夹取到当前 surface 的同长区间，保住压缩
+    // 语义（否则只能降级 append，被压缩历史全部回到派生历史）。
+    let clamped: number | undefined;
+    if (shapeOk && startIdx !== -1 && endIdx === -1) {
+      clamped = clampReplaceEnd(events, index, nodes, startIdx);
+      if (clamped !== undefined) endIdx = nodes.indexOf(clamped);
+    }
     const rangeOk = shapeOk && startIdx !== -1 && endIdx !== -1 && startIdx <= endIdx;
     let rewriteOk = true;
     if (rangeOk && event.type === "tool/result") {
@@ -303,9 +277,31 @@ export function findSurfaceRepairs(events: readonly SessionEvent[]): {
       nodes.push(event.seq);
       continue;
     }
+    if (clamped !== undefined) clampEnd.set(event.seq, clamped);
     nodes.splice(startIdx, endIdx - startIdx + 1, event.seq);
   }
-  return { degradeToAppend, addAppendMarker, clearSurfaceOp };
+  return { degradeToAppend, addAppendMarker, clearSurfaceOp, clampEnd };
+}
+
+/**
+ * 夹取一个 end 落在旧坐标空间的 replace 的结尾。
+ *
+ * 仅当 replace 紧邻一个 metering 事件且其 `shadowedSeqs` 是权威数量时成立；
+ * 夹取点是从 `start` 起的第 `shadowedSeqs.length` 个当前 surface 节点（不足
+ * 则取当前 surface 末尾）。无法夹取（start 也不在当前 surface）时返回
+ * `undefined`，由调用方降级为 append。
+ */
+function clampReplaceEnd(
+  events: readonly SessionEvent[],
+  index: number,
+  nodes: readonly number[],
+  startIdx: number,
+): number | undefined {
+  const metering = index > 0 ? events[index - 1] : undefined;
+  if (metering === undefined || !METERING_EVENT_TYPES.has(metering.type)) return undefined;
+  const shadowedSeqs = (metering.data as unknown as { shadowedSeqs?: unknown }).shadowedSeqs;
+  if (!Array.isArray(shadowedSeqs) || shadowedSeqs.length === 0) return undefined;
+  return nodes[Math.min(startIdx + shadowedSeqs.length - 1, nodes.length - 1)];
 }
 
 export function repairSurfaceOps(events: SessionEvent[]): void {
@@ -313,14 +309,19 @@ export function repairSurfaceOps(events: SessionEvent[]): void {
   if (
     repairs.degradeToAppend.size === 0 &&
     repairs.addAppendMarker.size === 0 &&
-    repairs.clearSurfaceOp.size === 0
+    repairs.clearSurfaceOp.size === 0 &&
+    repairs.clampEnd.size === 0
   ) {
     return;
   }
   for (const event of events) {
     const raw = event as SessionEvent & { surfaceOp?: unknown };
+    const clamped = repairs.clampEnd.get(event.seq);
     if (repairs.degradeToAppend.has(event.seq)) {
       raw.surfaceOp = "append";
+    } else if (clamped !== undefined) {
+      const op = raw.surfaceOp as { start: number };
+      raw.surfaceOp = { op: "replace", start: op.start, end: clamped };
     } else if (repairs.addAppendMarker.has(event.seq)) {
       raw.surfaceOp = "append";
     } else if (repairs.clearSurfaceOp.has(event.seq)) {
@@ -329,6 +330,65 @@ export function repairSurfaceOps(events: SessionEvent[]): void {
   }
 }
 
+/**
+ * 读取时补全 assistant 结算字段：旧写入器不落库 `stream`（v2 才把流式记录
+ * 嵌入消息），读回时缺失即补空数组——上游 seed 校验要求 turn/step/stream
+ * 三者齐备，缺失会让整个会话加载失败。
+ */
+export function repairAssistantSettlement(events: SessionEvent[]): void {
+  for (const event of events) {
+    if (event.type !== "assistant/message" && event.type !== "assistant/attempt") continue;
+    const data = event.data as unknown as Record<string, unknown>;
+    if (!Array.isArray(data["stream"])) data["stream"] = [];
+  }
+}
+
+/**
+ * 把紧邻 replace 的 metering 事件的 `shadowedRange` / `shadowedSeqs` 对齐到
+ * replace 最终的稠密 range。
+ *
+ * 旧写入器重编号事件后，metering 与 replace 一起落在旧坐标空间：二者数值
+ * 相等但与当前 surface 无关。夹取（或 range 本身已落在稠密空间而 metering
+ * 仍是旧值）后二者不再相等，而上游 token-meter 契约要求紧邻的 metering
+ * range 与 replace range 完全一致（否则报 no adjacent shadow price）。range
+ * 已一致时不改写——当前写入器保证一致，shadowedSeqs 的额外并发节点因此
+ * 原样保留。
+ */
+export function syncMeteringRanges(events: SessionEvent[]): void {
+  for (let i = 1; i < events.length; i++) {
+    const metering = events[i - 1]!;
+    if (!METERING_EVENT_TYPES.has(metering.type)) continue;
+    const event = events[i]!;
+    const op = (event as SessionEvent & { surfaceOp?: unknown }).surfaceOp;
+    if (typeof op !== "object" || op === null || (op as { op?: string }).op !== "replace") continue;
+    const { start, end } = op as { start: number; end: number };
+    const data = metering.data as unknown as {
+      shadowedRange?: { start: number; end: number };
+      shadowedSeqs?: number[];
+    };
+    if (data.shadowedRange?.start === start && data.shadowedRange.end === end) continue;
+    data.shadowedRange = { start, end };
+    data.shadowedSeqs = events
+      .filter(
+        (candidate) =>
+          candidate.seq >= start && candidate.seq <= end && SURFACE_EVENT_TYPES.has(candidate.type),
+      )
+      .map((candidate) => candidate.seq);
+  }
+}
+
+/**
+ * 读取视图修复总入口：结算字段补全 → surface 语义修复 → metering 对齐 →
+ * provenance 重算 → 孤儿 inbox splice 改写。全部只作用于内存视图，不落库。
+ */
+export function repairReadView(events: SessionEvent[]): void {
+  repairAssistantSettlement(events);
+  repairSurfaceOps(events);
+  syncMeteringRanges(events);
+  recomputeReplaceProvenance(events);
+  repairOrphanInboxSplices(events);
+}
+
 interface InboxSpliceLike {
   target?: unknown;
   start?: unknown;
@@ -418,7 +478,6 @@ export function repairOrphanInboxSplices(events: SessionEvent[]): void {
 export function scanRows(
   rows: readonly EventRow[],
   base = 0,
-  seqMap: ReadonlyMap<number, number> = new Map(),
 ): { preserved: SessionEvent[]; tornFrom?: number } {
   // Pass 1：解析每行 data；JSON 非法的行是洞（seq/type 列即使在 data 损坏
   // 时也存在）。
@@ -428,7 +487,7 @@ export function scanRows(
   }
   const parsed: Parsed[] = rows.map((row) => {
     try {
-      return { ok: true, event: rowToEvent(row, seqMap) };
+      return { ok: true, event: rowToEvent(row) };
     } catch {
       return { ok: false };
     }
@@ -471,32 +530,25 @@ export function scanRows(
     : { preserved };
 }
 
-function toStorageRecord(record: import("@deepseek-ai/dsh-session").StorageRecord): unknown {
-  const withSeqs = record as import("@deepseek-ai/dsh-session").StorageRecord & {
-    sourceEventSeqs?: unknown;
-  };
-  if (withSeqs.sourceEventSeqs === undefined) return record;
-  return { ...record, sourceEventSeqs: encodeSeqRanges(withSeqs.sourceEventSeqs as never) };
-}
-
 export function toJsonlArtifact(
   meta: SessionHeader,
   inheritedEventCount: number,
   events: readonly SessionEvent[],
 ): string {
-  const header = {
-    type: "session",
-    version: meta.version,
-    id: meta.id,
-    createdAt: meta.createdAt,
-    ...(meta.cwd === undefined ? {} : { cwd: meta.cwd }),
-    ...(meta.parentSession === undefined ? {} : { parentSession: meta.parentSession }),
-    ...(meta.isSeeded ? { seedLength: inheritedEventCount } : {}),
-    ...(meta.origin === undefined ? {} : { origin: meta.origin }),
-    delegationDepth: meta.delegationDepth ?? 0,
-    ...(meta.agentPreset === undefined ? {} : { agentPreset: meta.agentPreset }),
-  };
+  const header = sessionFormatCatalog.encodeCurrentHeader(
+    {
+      ...meta,
+      delegationDepth: meta.delegationDepth ?? 0,
+    } as unknown as SessionFormatHeader,
+    inheritedEventCount,
+  );
   const lines = [JSON.stringify(header)];
-  for (const record of packChunkRuns(events)) lines.push(JSON.stringify(toStorageRecord(record)));
+  for (const event of events) {
+    lines.push(
+      JSON.stringify(
+        sessionFormatCatalog.encodeCurrentEvent(event as unknown as SessionFormatEvent),
+      ),
+    );
+  }
   return lines.join("\n");
 }