@michengai/dsh-archive-manager 1.1.6 → 1.1.7

package/lib/host-install.js

@@ -1,6 +1,6 @@
 import { bindArchiveManagerRemote, installArchiveWorkspace, tolerateStaleFileUploadResolver } from "./workspace.js";
 import { installArchiveProjectionCache, installArchiveProjectionCacheGuards } from "./projcache.js";
-const inject = ["workspaceRegistry", "sessionProjectionCache", "typert"];
+const inject = ["workspaceRegistry", "sessionProjectionCache", "sessionPersistence", "typert"];
 async function apply(ctx) {
   tolerateStaleFileUploadResolver(ctx);
   const registry = ctx.workspaceRegistry;
@@ -23,9 +23,9 @@ async function apply(ctx) {
   };
   try {
     try {
-      uninstallCache = await installArchiveProjectionCache(cache);
+      uninstallCache = await installArchiveProjectionCache(cache, Reflect.get(ctx, "sessionPersistence"));
     } catch (error) {
-      ctx.logger?.warn?.(`archive-manager: projection cache overlay skipped: ${String(error)}`);
+      ctx.logger?.warn?.(`archive-manager: projection cache handoff skipped: ${String(error)}`);
       uninstallCache = installArchiveProjectionCacheGuards(cache);
     }
     unbindRemote = bindArchiveManagerRemote(ctx);

package/lib/projcache.js

@@ -151,156 +151,146 @@ function normalizeLegacyRecord(record) {
   checkpointRecord.parse(normalized);
   return normalized;
 }
-async function importMissingRecords(ctx, target, records, label) {
+function sameIdentity(left, right) {
+  return left.createdAt === right.createdAt && left.cwd === right.cwd && left.formatVersion === right.formatVersion && (left.isSeeded ?? false) === (right.isSeeded ?? false) && (left.inheritedEventCount ?? 0) === (right.inheritedEventCount ?? 0);
+}
+function mergeCheckpoint(current, incoming) {
+  if (current !== void 0 && incoming.identity.formatVersion === void 0 && current.identity.formatVersion !== void 0 && current.identity.createdAt === incoming.identity.createdAt && current.identity.cwd === incoming.identity.cwd && (current.identity.isSeeded ?? false) === (incoming.identity.isSeeded ?? false)) return current;
+  if (current === void 0 || !sameIdentity(current.identity, incoming.identity)) return incoming;
+  const rows = { ...current.rows };
+  let changed = false;
+  for (const [key, row] of Object.entries(incoming.rows)) {
+    const previous = rows[key];
+    if (previous === void 0 || previous.ver === row.ver && previous.seq < row.seq) {
+      rows[key] = row;
+      changed = true;
+    }
+  }
+  return changed ? { identity: current.identity, rows } : current;
+}
+async function importPreviousProjectionCache(ctx, target, persistence, guards) {
+  if (persistence === void 0) return 0;
+  const sources = [
+    await readLegacySafeRecords(ctx, safeProjectionCacheDomainSpec, "archive-manager current"),
+    await readLegacySafeRecords(ctx, legacySafeV2ProjectionCacheDomainSpec, "archive-manager v2"),
+    // 逐记录后端会把不同版本当缺行，打开成功也须单独读取 v1。
+    await readLegacySafeRecords(ctx, legacySafeProjectionCacheDomainSpec, "archive-manager v1")
+  ];
   let imported = 0;
-  for (const [sessionId, record] of records) {
-    if (target.has(sessionId)) continue;
+  for (const source of sources) for (const [id, raw] of source.records) {
+    if (projectionCacheDomainSpec.layout === "per-record" && !/^[A-Za-z0-9_-]+$/.test(id)) continue;
+    guards?.revisions.set(id, 0);
+    const revision = 0;
+    const unchanged = () => !guards?.deleted.has(id) && (guards?.revisions.get(id) ?? 0) === revision;
     try {
-      const normalized = normalizeLegacyRecord(record);
-      if (normalized === void 0) {
-        ctx.logger.warn(`archive-manager projcache: ${label} row "${sessionId}" import skipped because its lifecycle identity is incomplete`);
-        continue;
+      const record = normalizeLegacyRecord(raw);
+      if (record === void 0 || !unchanged()) continue;
+      const snapshot = await persistence.stat(id);
+      const header = snapshot?.header;
+      if (!header || header.id !== id || header.createdAt !== record.identity.createdAt || header.cwd !== record.identity.cwd || (header.isSeeded ?? false) !== (record.identity.isSeeded ?? false) || record.identity.formatVersion !== void 0 && record.identity.formatVersion !== header.version) continue;
+      if (header.isSeeded) {
+        if (!persistence.open) continue;
+        const handle = await persistence.open(id, "read");
+        try {
+          if (handle.inheritedEventCount !== record.identity.inheritedEventCount) continue;
+        } finally {
+          await handle.close();
+        }
+      }
+      if (!unchanged()) continue;
+      const existing = target.get(id);
+      if (existing !== void 0 && mergeCheckpoint(existing, record) === existing) continue;
+      try {
+        await target.update(id, (current) => unchanged() ? mergeCheckpoint(current, record) : current);
+      } catch (error) {
+        if (!(error instanceof Error) || Reflect.get(error, "code") !== "missing-key") throw error;
+        if (!unchanged()) continue;
+        await target.put(id, record);
       }
-      await target.put(sessionId, normalized);
       imported += 1;
     } catch (error) {
-      ctx.logger.warn(`archive-manager projcache: ${label} row "${sessionId}" import failed: ${String(error)}`);
+      ctx.logger.warn(`archive-manager projcache: historical row "${id}" handoff failed: ${String(error)}`);
+    } finally {
+      guards?.revisions.delete(id);
     }
   }
   return imported;
 }
-async function importPreviousProjectionCache(ctx, target, currentTable) {
-  const sameSpec = projectionCacheDomainSpec.version === legacyProjectionCacheDomainSpec.version && projectionCacheDomainSpec.layout === legacyProjectionCacheDomainSpec.layout;
-  const legacySafeV2 = await readLegacySafeRecords(ctx, legacySafeV2ProjectionCacheDomainSpec, "archive-manager v2");
-  const legacySafe = await readLegacySafeRecords(ctx, legacySafeProjectionCacheDomainSpec, "archive-manager v1");
-  const legacy = sameSpec && currentTable !== void 0 ? { opened: true, records: [...currentTable.entries()] } : await readSourceRecords(ctx, legacyProjectionCacheDomainSpec, "legacy v3");
-  let imported = 0;
-  if (legacySafeV2.opened) imported += await importMissingRecords(ctx, target, legacySafeV2.records, "archive-manager v2");
-  if (legacySafe.opened) imported += await importMissingRecords(ctx, target, legacySafe.records, "archive-manager v1");
-  if (!sameSpec) {
-    const current = currentTable !== void 0 ? { opened: true, records: [...currentTable.entries()] } : await readSourceRecords(ctx, projectionCacheDomainSpec, "current");
-    if (current.opened) imported += await importMissingRecords(ctx, target, current.records, "current");
-  }
-  if (legacy.opened) imported += await importMissingRecords(ctx, target, legacy.records, "legacy v3");
-  return imported;
-}
-var ArchiveProjectionCache = class extends CacheBase {
-  /** 已永久删除的会话：其投影缓存行不再允许写入。 */
-  deletedSessionIds = /* @__PURE__ */ new Set();
-  /** 墓碑插入顺序，用于在上限处淘汰最旧项。 */
-  deletedSessionOrder = [];
-  deletedSessionTombstoneLimit = 4096;
-  /** 在途写入的队尾（只含已落定的 promise）。 */
-  writeTail = Promise.resolve();
-  constructor(ctx, config) {
-    super(ctx, config);
-  }
-  /**
-   * Replace the official cache domain with the path-safe compatibility
-   * domain, then preserve the upstream listener/write implementation.
-   */
+class ArchiveProjectionCache extends CacheBase {
+  static inject = [...SessionProjectionCache.inject, "sessionPersistence"];
   async [Service.init]() {
-    const domain = await this.ctx.storageDomain.open(safeProjectionCacheDomainSpec);
-    this.ctx.effect(() => () => domain.close(), "sessionProjectionCache.domainClose");
-    const table = new SafeSessionTable(domain.table("sessions"));
-    this.table = table;
-    await importPreviousProjectionCache(this.ctx, table);
-    this.installWritePath();
-  }
-  /** 跟踪公开写入路径，避免依赖上游私有 `flushSoft` 的实现细节。 */
-  write(session) {
-    const task = this.writeCore(session);
-    this.writeTail = Promise.allSettled([this.writeTail, task]).then(() => void 0);
-    return task;
-  }
-  /**
-   * 墓碑正确性依赖：super.write(session) 一次整体写入，返回后不再有后续异步落盘。
-   * 若上游改成多阶段异步，(C) 补删会漏掉后续写入，deletedSessionIds 挡不住复活。
-   */
-  async writeCore(session) {
-    if (this.deletedSessionIds.has(session.id)) return;
-    await super.write(session);
-    if (this.deletedSessionIds.has(session.id)) await this.requireTable().delete(session.id);
-  }
-  put(id, identity, rows) {
-    if (this.deletedSessionIds.has(id)) return Promise.resolve();
-    const task = this.putCore(id, identity, rows);
-    this.writeTail = Promise.allSettled([this.writeTail, task]).then(() => void 0);
-    return task;
-  }
-  async putCore(id, identity, rows) {
-    await super.put(id, identity, rows);
-    if (this.deletedSessionIds.has(id)) await this.requireTable().delete(id);
+    await super[Service.init]();
+    const uninstall = await installArchiveProjectionCache(this, Reflect.get(this.ctx, "sessionPersistence"));
+    this.ctx.effect(() => uninstall, "archive-manager.projcacheGuards");
   }
-  /**
-   * 全部被跟踪的在途写入落定后 resolve（含失败）。空闲缓存上调用立即返回。
-   * @returns 跟踪写入落定后的 resolution。
-   */
-  whenIdle() {
-    return this.writeTail;
-  }
-  /**
-   * 永久移除一个会话的缓存投影行。
-   * 同时清理当前表与底层原生表（如官方 session_projcache 域），防止残留孤儿文件。
-   * @param id - 要删除缓存行的会话。
-   * @returns 行删除完成后的 resolution。
-   */
-  async delete(id) {
-    trackTombstone(this.deletedSessionIds, this.deletedSessionOrder, id, this.deletedSessionTombstoneLimit);
-    const tasks = [this.requireTable().delete(id)];
-    const secondary = this.secondaryTable;
-    if (secondary !== void 0 && typeof secondary.delete === "function") {
-      tasks.push(secondary.delete(id).catch(() => false));
-    }
-    await Promise.all(tasks);
-  }
-  /** 撤销墓碑（供测试与同 id 新生命周期复用路径使用）。 */
-  clearTombstone(id) {
-    this.deletedSessionIds.delete(id);
-    const idx = this.deletedSessionOrder.indexOf(id);
-    if (idx !== -1) this.deletedSessionOrder.splice(idx, 1);
-  }
-};
+}
 const projectionGuards = /* @__PURE__ */ new WeakMap();
-function installArchiveProjectionCacheGuards(cache, table, secondaryTable) {
+function installArchiveProjectionCacheGuards(cache) {
   const target = Reflect.get(cache, symbols.original) ?? cache;
   const existing = projectionGuards.get(target);
-  if (existing) return existing;
-  const fields = {
-    table: table ?? target.table,
-    secondaryTable: secondaryTable !== (table ?? target.table) ? secondaryTable : void 0,
-    deletedSessionIds: /* @__PURE__ */ new Set(),
-    deletedSessionOrder: [],
-    deletedSessionTombstoneLimit: 4096,
-    writeTail: Promise.resolve()
-  };
-  const receiver = Object.create(target, Object.fromEntries(Object.entries(fields).map(([name, value]) => [name, { value, writable: true, configurable: true }])));
-  const restoredMethods = [];
+  if (existing) return existing.uninstall;
+  const table = target.requireTable();
+  const originalWrite = target.write;
+  const originalPut = target.put;
+  const deleted = /* @__PURE__ */ new Set();
+  const order = [];
+  const revisions = /* @__PURE__ */ new Map();
+  let tail = Promise.resolve();
   let active = true;
+  const track = (task) => {
+    tail = Promise.allSettled([tail, task]).then(() => void 0);
+    return task;
+  };
+  const changed = (id) => {
+    if (revisions.has(id)) revisions.set(id, revisions.get(id) + 1);
+  };
+  const put = (id, identity, rows) => {
+    changed(id);
+    if (deleted.has(id)) return Promise.resolve();
+    return track(Reflect.apply(originalPut, receiver, [id, identity, rows]));
+  };
+  const writeTable = Object.create(table, { put: { value: (id, record) => deleted.has(id) ? Promise.resolve() : table.put(id, record) } });
+  const receiver = Object.create(target, {
+    put: { value: put, configurable: true },
+    requireTable: { value: () => writeTable }
+  });
+  const methods = {
+    write(session) {
+      if (deleted.has(session.id)) return Promise.resolve();
+      return track(Reflect.apply(originalWrite, receiver, [session]));
+    },
+    put,
+    delete(id) {
+      changed(id);
+      trackTombstone(deleted, order, id, 4096);
+      return track(table.delete(id).then(() => void 0));
+    },
+    whenIdle: () => tail,
+    clearTombstone(id) {
+      changed(id);
+      deleted.delete(id);
+      const index = order.indexOf(id);
+      if (index !== -1) order.splice(index, 1);
+    }
+  };
+  const restored = [];
   const restore = () => {
     active = false;
-    for (const item of [...restoredMethods].reverse()) {
-      if (item.descriptor) Object.defineProperty(target, item.name, item.descriptor);
-      else delete target[item.name];
+    for (const { name, descriptor, wrapper } of [...restored].reverse()) {
+      if (target[name] !== wrapper) continue;
+      if (descriptor) Object.defineProperty(target, name, descriptor);
+      else delete target[name];
     }
   };
   try {
-    for (const name of Object.getOwnPropertyNames(ArchiveProjectionCache.prototype)) {
-      if (name === "constructor") continue;
-      const method = Reflect.get(ArchiveProjectionCache.prototype, name);
-      if (typeof method !== "function") continue;
-      Object.defineProperty(receiver, name, { value: method, writable: true, configurable: true });
+    for (const [name, method] of Object.entries(methods)) {
       const previous = target[name];
-      restoredMethods.push({ name, descriptor: Object.getOwnPropertyDescriptor(target, name) });
-      target[name] = (...args) => {
-        if (!active) {
-          if (typeof previous === "function") return Reflect.apply(previous, target, args);
-          throw new Error("archive-manager: projection cache guards are stopped");
-        }
-        const result = Reflect.apply(method, receiver, args);
-        if (name === "delete") receiver.writeTail = Promise.allSettled([receiver.writeTail, result]).then(() => void 0);
-        return result;
+      const wrapper = (...args) => {
+        if (!active && typeof previous === "function") return Reflect.apply(previous, target, args);
+        return Reflect.apply(method, target, args);
       };
+      restored.push({ name, descriptor: Object.getOwnPropertyDescriptor(target, name), wrapper });
+      target[name] = wrapper;
     }
   } catch (error) {
     restore();
@@ -309,50 +299,22 @@ function installArchiveProjectionCacheGuards(cache, table, secondaryTable) {
   let disposal;
   const uninstall = () => {
     if (disposal) return disposal;
-    const drain = receiver.writeTail;
+    const drain = tail;
     restore();
     projectionGuards.delete(target);
     return disposal = drain;
   };
-  projectionGuards.set(target, uninstall);
+  projectionGuards.set(target, { uninstall, deleted, revisions });
   return uninstall;
 }
-const projectionOverlay = Symbol.for("dsh-archive-manager.projcache-overlay");
-async function installArchiveProjectionCache(cache) {
+async function installArchiveProjectionCache(cache, persistence) {
   const target = Reflect.get(cache, symbols.original) ?? cache;
-  if (target[projectionOverlay] === true) return async () => {
-  };
-  const domain = await target.ctx.storageDomain.open(safeProjectionCacheDomainSpec);
-  let installed = false;
-  const previousTable = target.table;
-  let uninstallGuards;
+  const uninstall = installArchiveProjectionCacheGuards(cache);
   try {
-    const table = new SafeSessionTable(domain.table("sessions"));
-    await importPreviousProjectionCache(target.ctx, table, previousTable);
-    uninstallGuards = installArchiveProjectionCacheGuards(cache, table, previousTable);
-    target.table = table;
-    target[projectionOverlay] = true;
-    installed = true;
-    let disposal;
-    return () => disposal ??= (async () => {
-      if (target[projectionOverlay] !== true) return;
-      const drain = uninstallGuards();
-      target.table = previousTable;
-      delete target[projectionOverlay];
-      await drain;
-      await domain.close();
-    })();
+    await importPreviousProjectionCache(target.ctx, target.requireTable(), persistence, projectionGuards.get(target));
+    return uninstall;
   } catch (error) {
-    if (!installed) {
-      const drain = uninstallGuards?.();
-      target.table = previousTable;
-      delete target[projectionOverlay];
-      try {
-        await drain;
-      } finally {
-        await domain.close();
-      }
-    }
+    await uninstall();
     throw error;
   }
 }

package/lib/session-repair.js

@@ -5,11 +5,45 @@ import { join, resolve, basename, dirname } from "node:path";
 import * as zlib from "node:zlib";
 import { classifySessionError } from "./archive-discovery.js";
 const LIMIT = 32 * 1024 * 1024;
+function scanFirstZstdFrame(buffer) {
+  if (buffer.length < 4 || buffer.readUInt32LE(0) !== 4247762216) return void 0;
+  let offset = 4;
+  if (offset >= buffer.length) return void 0;
+  const descriptor = buffer.readUInt8(offset++);
+  if ((descriptor & 24) !== 0) return void 0;
+  const contentSizeFlag = descriptor >>> 6;
+  const singleSegment = (descriptor & 32) !== 0;
+  const checksum = (descriptor & 4) !== 0;
+  const dictionaryFlag = descriptor & 3;
+  const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+  const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
+  const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+  if (buffer.length - offset < remainingHeaderBytes) return void 0;
+  offset += remainingHeaderBytes;
+  for (; ; ) {
+    if (buffer.length - offset < 3) return void 0;
+    const blockHeader = buffer.readUIntLE(offset, 3);
+    offset += 3;
+    const lastBlock = (blockHeader & 1) !== 0;
+    const blockType = blockHeader >>> 1 & 3;
+    const blockSize = blockHeader >>> 3;
+    if (blockType === 3) return void 0;
+    const payloadBytes = blockType === 1 ? 1 : blockSize;
+    if (buffer.length - offset < payloadBytes) return void 0;
+    offset += payloadBytes;
+    if (lastBlock) break;
+  }
+  if (checksum) {
+    if (buffer.length - offset < 4) return void 0;
+    offset += 4;
+  }
+  return { start: 0, end: offset };
+}
 function decompressFrame(bytes, maxOutputLength) {
-  const result = record(zlib.zstdDecompressSync(bytes, { info: true, maxOutputLength }));
-  const engine = record(result.engine);
-  if (!Buffer.isBuffer(result.buffer) || typeof engine.bytesWritten !== "number") throw new Error("\u538B\u7F29\u5E27\u8FD4\u56DE\u683C\u5F0F\u65E0\u6548");
-  return { buffer: result.buffer, engine: { bytesWritten: engine.bytesWritten } };
+  const frame = scanFirstZstdFrame(bytes);
+  const target = frame ? bytes.subarray(0, frame.end) : bytes;
+  const buffer = zlib.zstdDecompressSync(target, { maxOutputLength });
+  return { buffer, engine: { bytesWritten: frame ? frame.end : bytes.length } };
 }
 const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
 function decodeRepairLog(bytes, compressed) {
@@ -170,6 +204,8 @@ export {
   childCatalogFact,
   classifySessionError,
   decodeRepairLog,
+  decompressFrame,
   normalizeAutomationSources,
-  prepareAutomationRepair
+  prepareAutomationRepair,
+  scanFirstZstdFrame
 };