billion-context 0.1.83-pr.517.340 → 0.1.83

package/dist/index.js

@@ -49806,7 +49806,6 @@ function rel(p2, base) {
 
 // src/persist.ts
 var PERSIST_VERSION = 3;
-var STALE_WARN_THROTTLE_MS = 6e4;
 function mergeState(parsed) {
   const fresh = createInitialState();
   return {
@@ -49837,13 +49836,10 @@ var SessionStore = class {
   enabled;
   dir;
   store;
-  log;
-  staleWarnAt = /* @__PURE__ */ new Map();
   constructor(opts) {
     const debounceMs = opts?.debounceMs ?? defaultDebounce();
     this.enabled = (opts?.enabled ?? true) && debounceMs >= 0;
     this.dir = opts?.dir ?? defaultDir();
-    this.log = opts?.log ?? defaultLogger;
     this.store = new StateStore({
       dir: this.dir,
       version: PERSIST_VERSION,
@@ -49939,74 +49935,29 @@ var SessionStore = class {
    *  LRU eviction). Sync fs is acceptable here because a miss is rare and
    *  reads a single small file (~1ms). Returns null if missing/corrupt or the
    *  body id does not match what we asked for. */
-  /** Shared envelope probe for the sync read paths: namespaced path
-   *  first, then the _unknown/ location, letting the kernel store layer
-   *  also check its discovered map and the flat legacy name. */
-  loadEnvelope(id, meta) {
+  loadSync(id, meta) {
+    if (!this.enabled) return null;
     const envelopes = [
       this.store.loadSync(id, relPathFor(id, meta?.protocol, meta?.upstreamOrigin)),
       meta?.protocol ? this.store.loadSync(id, relPathFor(id)) : null
     ];
     for (const envelope of envelopes) {
-      if (envelope) return envelope;
+      if (envelope) return buildSession(envelope.payload);
     }
     return null;
   }
-  loadSync(id, meta) {
-    if (!this.enabled) return null;
-    const envelope = this.loadEnvelope(id, meta);
-    if (!envelope) return null;
-    return buildSession(envelope.payload);
-  }
-  /** #405 fix #4: dual-instance rollback guard. When two proxy processes
-   *  share BILI_SESSIONS_DIR, whoever saves last used to win — an instance
-   *  holding a STALE in-memory copy would roll counters back (requests:3 →
-   *  2). Both signals below are monotonic per session id, so either being
-   *  strictly smaller proves staleness. Returns the fresher-on-disk payload
-   *  when the incoming record is stale, else null. */
-  staleDiskPayload(incoming) {
-    const envelope = this.loadEnvelope(incoming.id, incoming.meta);
-    if (!envelope) return null;
-    const disk = envelope.payload;
-    const diskRequests = disk.stats?.requests ?? disk.requests ?? 0;
-    const incRequests = incoming.stats?.requests ?? incoming.requests ?? 0;
-    if (incRequests < diskRequests) return disk;
-    if (incRequests === diskRequests) {
-      const diskBlocks = disk.state?.nextBlockId ?? 0;
-      const incBlocks = incoming.state?.nextBlockId ?? 0;
-      if (incBlocks < diskBlocks) return disk;
-    }
-    return null;
-  }
-  guardedBuild(session) {
-    return () => {
-      const record = buildRecord(session);
-      const disk = this.staleDiskPayload(record);
-      if (disk === null) return record;
-      const now = Date.now();
-      const last = this.staleWarnAt.get(record.id) ?? 0;
-      if (now - last >= STALE_WARN_THROTTLE_MS) {
-        this.staleWarnAt.set(record.id, now);
-        this.log(
-          "warn",
-          `[persist] rejected stale snapshot for session ${record.id}: in-memory copy is older than the on-disk one (another bili instance holds newer state) \u2014 keeping disk state, no rollback (#405)`
-        );
-      }
-      return disk;
-    };
-  }
   /** Schedule a debounced write for a session. Multiple calls within the
    *  window coalesce; the record is built at WRITE time, so the freshest
    *  session state is persisted. Safe to call on the hot path. No-op if
    *  disabled. */
   scheduleSave(session) {
-    this.store.scheduleSave(session.id, this.guardedBuild(session));
+    this.store.scheduleSave(session.id, () => buildRecord(session));
   }
   /** Asynchronously persist a session right now (skips the debounce). Throws
    *  on write failure so callers can react (e.g. avoid evicting). Serialized
    *  per-session by the kernel store's write chains. */
   async writeNow(session) {
-    await this.store.writeNow(session.id, this.guardedBuild(session));
+    await this.store.writeNow(session.id, () => buildRecord(session));
   }
   /** Synchronous flush for a single session. Used on memory eviction so a
    *  dirty evicted session is not lost. Sync because eviction runs in the
@@ -50014,7 +49965,7 @@ var SessionStore = class {
    *  Returns true on success, false on failure (caller must NOT evict on
    *  failure for a never-persisted session or it is lost permanently). */
   flushSync(session) {
-    return this.store.flushSync(session.id, this.guardedBuild(session));
+    return this.store.flushSync(session.id, () => buildRecord(session));
   }
   /** Flush all dirty sessions with a pending debounce timer. Called on
    *  SIGTERM/SIGINT for graceful shutdown. The kernel store flushes its own
@@ -57013,7 +56964,7 @@ Content-Length: ${Buffer.byteLength(body)}\r
       );
     }
     if (opts.debug) {
-      log2("info", `[debug] build features: raw-HTTP-capture(${bodyDumpEnabled() ? "on" : "off"}) | remote_compaction_v2-strip(on) | cert-MITM-launcher(on) | strip-acp-summary(on) \u2014 seeing this line confirms the launcher build (not registry 0.1.34)`);
+      log2("info", `[debug] build features: raw-HTTP-capture(on) | remote_compaction_v2-strip(on) | cert-MITM-launcher(on) | strip-acp-summary(on) \u2014 seeing this line confirms the launcher build (not registry 0.1.34)`);
     }
   };
   const attemptListen = (port) => {