@threadbase-sh/streamer 1.27.2 → 1.28.0

package/dist/cli.cjs

@@ -30931,7 +30931,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes4, createHash: createHash4 } = require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash5 } = require("crypto");
     var { Duplex, Readable: Readable3 } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -31599,7 +31599,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -31968,7 +31968,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter6 = require("events");
     var http = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash4 } = require("crypto");
+    var { createHash: createHash5 } = require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -32275,7 +32275,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -100397,11 +100397,11 @@ var require_out = __commonJS({
       async.read(path2, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports2.stat = stat10;
-    function statSync9(path2, optionsOrSettings) {
+    function statSync10(path2, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path2, settings);
     }
-    exports2.statSync = statSync9;
+    exports2.statSync = statSync10;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -123750,14 +123750,14 @@ __export(prompt_exports, {
   interactivePermissionModePrompt: () => interactivePermissionModePrompt,
   interactivePrompt: () => interactivePrompt
 });
-var import_node_process2, import_promises20, interactivePrompt, interactivePermissionModePrompt;
+var import_node_process2, import_promises22, interactivePrompt, interactivePermissionModePrompt;
 var init_prompt = __esm({
   "src/lifecycle/prompt.ts"() {
     "use strict";
     import_node_process2 = require("process");
-    import_promises20 = require("readline/promises");
+    import_promises22 = require("readline/promises");
     interactivePrompt = async ({ prodPort, suggestedAltPort, prodActive }) => {
-      const rl = (0, import_promises20.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
+      const rl = (0, import_promises22.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
       try {
         if (!prodActive) {
           import_node_process2.stdout.write(
@@ -123792,7 +123792,7 @@ The supervised prod streamer is already holding port ${prodPort}.
       }
     };
     interactivePermissionModePrompt = async () => {
-      const rl = (0, import_promises20.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
+      const rl = (0, import_promises22.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
       try {
         import_node_process2.stdout.write(
           "\nWhich permission mode should spawned Claude Code sessions use?\n  [a] acceptEdits \u2014 auto-approve file edits, still prompt for shell commands (default)\n  [m] manual \u2014 prompt for every edit and command\n"
@@ -128554,9 +128554,10 @@ var import_promises8 = require("timers/promises");
 var import_crypto2 = require("crypto");
 var import_fs11 = require("fs");
 var import_fs12 = require("fs");
+var import_fs13 = require("fs");
 var import_readline3 = require("readline");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_fs13 = require("fs");
+var import_fs14 = require("fs");
 var import_path9 = require("path");
 var import_promises9 = require("fs/promises");
 var import_path10 = require("path");
@@ -130939,6 +130940,17 @@ function reduceConvLine(state, entry) {
     attachment: entry.attachment !== void 0 ? entry.attachment : void 0
   };
 }
+function parseJsonlLine(line, state = initialConvState()) {
+  const text = line.trimEnd();
+  if (text.trim().length === 0) return null;
+  let entry;
+  try {
+    entry = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  return reduceConvLine(state, entry);
+}
 function applyTeamInfo(messages, state) {
   if (Object.keys(state.teamInfo).length === 0) return;
   for (const m2 of messages) {
@@ -131600,7 +131612,7 @@ async function parseMetaWithProvider(provider, filePath, account, tier) {
   const log8 = getLogger2();
   const acc = provider.createEmptyAccumulator();
   const rl = (0, import_readline3.createInterface)({
-    input: (0, import_fs12.createReadStream)(filePath),
+    input: (0, import_fs13.createReadStream)(filePath),
     crlfDelay: Infinity
   });
   try {
@@ -131823,7 +131835,7 @@ function hasColumn(db, table, column) {
 }
 function openDatabase(dbPath) {
   if (dbPath !== ":memory:") {
-    (0, import_fs13.mkdirSync)((0, import_path9.dirname)(dbPath), { recursive: true });
+    (0, import_fs14.mkdirSync)((0, import_path9.dirname)(dbPath), { recursive: true });
   }
   const db = new import_better_sqlite3.default(dbPath);
   db.pragma("journal_mode = WAL");
@@ -132623,7 +132635,13 @@ var PersistentEngine = class {
     await this.ensureCheckpoints(filePath, total);
     const beforeIndex = options.beforeIndex ?? total;
     const fromIndex = Math.max(0, beforeIndex - options.limit);
-    const floor = this.checkpoints.floor(filePath, fromIndex);
+    let floor = this.checkpoints.floor(filePath, fromIndex);
+    if (floor) {
+      try {
+        if (floor.byteOffset > (0, import_fs12.statSync)(filePath).size) floor = null;
+      } catch {
+      }
+    }
     return readPage(filePath, total, options, floor);
   }
   // Build or extend the checkpoint chain so it covers `total` messages. Cold
@@ -133512,8 +133530,8 @@ async function search(query, options, scanner) {
 
 // src/server.ts
 var import_events3 = require("events");
-var import_fs24 = require("fs");
-var import_promises17 = require("fs/promises");
+var import_fs25 = require("fs");
+var import_promises19 = require("fs/promises");
 var import_http = require("http");
 var import_os10 = require("os");
 var import_path22 = require("path");
@@ -136658,11 +136676,13 @@ async function createDirectory(parentAbsolutePath, name) {
 
 // src/conversation-cache.ts
 var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
-var import_fs16 = require("fs");
+var import_fs17 = require("fs");
+var import_promises12 = require("fs/promises");
 var import_path13 = require("path");
+var import_promises13 = require("timers/promises");
 
 // src/db/sqlite-migrate.ts
-var import_fs14 = require("fs");
+var import_fs15 = require("fs");
 var import_path12 = require("path");
 var import_url6 = require("url");
 var import_meta = {};
@@ -136681,7 +136701,7 @@ CREATE TABLE IF NOT EXISTS schema_migrations (
 function runSqliteMigrations(db, migrationsDir) {
   db.exec(SCHEMA_MIGRATIONS_SQL);
   const dir = migrationsDir ?? (0, import_path12.join)(getMigrationsDir(), "migrations");
-  const files = (0, import_fs14.readdirSync)(dir).filter((f2) => f2.endsWith(".sql")).sort();
+  const files = (0, import_fs15.readdirSync)(dir).filter((f2) => f2.endsWith(".sql")).sort();
   const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
   const appliedSet = new Set(appliedRows.map((r) => r.id));
   const recordApplied = db.prepare("INSERT INTO schema_migrations (id, applied_at) VALUES (?, ?)");
@@ -136692,7 +136712,7 @@ function runSqliteMigrations(db, migrationsDir) {
       skipped.push(file2);
       continue;
     }
-    const sql = (0, import_fs14.readFileSync)((0, import_path12.join)(dir, file2), "utf-8");
+    const sql = (0, import_fs15.readFileSync)((0, import_path12.join)(dir, file2), "utf-8");
     const tx = db.transaction(() => {
       db.exec(sql);
       recordApplied.run(file2, (/* @__PURE__ */ new Date()).toISOString());
@@ -136717,7 +136737,7 @@ function isProviderResumable(_provider, availabilityResumable) {
 }
 
 // src/services/conversations/isAgentConversation.ts
-var import_fs15 = require("fs");
+var import_fs16 = require("fs");
 var DEFAULT_AGENT_ENTRYPOINTS = /* @__PURE__ */ new Set(["sdk-cli", "claude-vscode"]);
 var CHUNK_BYTES = 64 * 1024;
 var ENTRYPOINT_PROBE = `"entrypoint":`;
@@ -136739,12 +136759,12 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   if (cached3 !== void 0) return cached3;
   let fd;
   try {
-    fd = (0, import_fs15.openSync)(filePath, "r");
+    fd = (0, import_fs16.openSync)(filePath, "r");
   } catch {
     return false;
   }
   try {
-    const fileSize = (0, import_fs15.statSync)(filePath).size;
+    const fileSize = (0, import_fs16.statSync)(filePath).size;
     if (fileSize === 0) {
       fileDecisionCache.set(key, false);
       return false;
@@ -136755,7 +136775,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
     let carry = "";
     while (offset < fileSize) {
       const toRead = Math.min(CHUNK_BYTES, fileSize - offset);
-      const got = (0, import_fs15.readSync)(fd, buf, 0, toRead, offset);
+      const got = (0, import_fs16.readSync)(fd, buf, 0, toRead, offset);
       if (got <= 0) break;
       const chunk = carry + buf.toString("utf8", 0, got);
       for (const marker of markers) {
@@ -136776,7 +136796,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   } catch {
     return false;
   } finally {
-    (0, import_fs15.closeSync)(fd);
+    (0, import_fs16.closeSync)(fd);
   }
 }
 function parseAgentEntrypointsEnv(raw2) {
@@ -136785,6 +136805,33 @@ function parseAgentEntrypointsEnv(raw2) {
   return new Set(parts);
 }
 
+// src/utils/fileIdentity.ts
+var import_crypto5 = require("crypto");
+function fileIdentity(stat10, headBytes) {
+  if (stat10.ino && stat10.ino > 0) return `inode:${stat10.dev}:${stat10.ino}`;
+  const head = headBytes ?? Buffer.alloc(0);
+  return `fp:${(0, import_crypto5.createHash)("sha1").update(head).digest("hex")}`;
+}
+function splitCompleteLines(buf, baseOffset) {
+  const spans = [];
+  let lineStart = 0;
+  let consumed = 0;
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] !== 10) continue;
+    const lineLen = i - lineStart;
+    if (lineLen > 0) {
+      spans.push({
+        byteOffset: baseOffset + lineStart,
+        byteLength: lineLen,
+        text: buf.toString("utf-8", lineStart, i)
+      });
+    }
+    lineStart = i + 1;
+    consumed = lineStart;
+  }
+  return { spans, consumed };
+}
+
 // src/conversation-cache.ts
 function shortProjectName(fullPath) {
   const parts = fullPath.split(/[/\\]/).filter(Boolean);
@@ -136833,6 +136880,14 @@ var ConversationCache = class _ConversationCache {
   tailSize;
   fileIndex = /* @__PURE__ */ new Map();
   fileIndexLoaded = false;
+  // Per-file scanner parse state for the incremental offset-index writer. The
+  // reducer is stateful across lines (pending tool_uses, latest timestamp), so
+  // it must persist between watcher reads of the same file. Cleared on
+  // truncation/backfill.
+  indexParseState = /* @__PURE__ */ new Map();
+  // Single-flight guard for backfillIndex — concurrent detail requests for the
+  // same cold file await one walk, not N. Entry dropped on settle.
+  backfillInFlight = /* @__PURE__ */ new Map();
   // Monotonically increasing counter for tail updated_at — guarantees strict
   // ordering even when multiple updateFromLine() calls land within the same ms.
   tailSeq = Date.now();
@@ -136996,6 +137051,42 @@ var ConversationCache = class _ConversationCache {
          GROUP BY project_path
          ORDER BY cnt DESC
          LIMIT ?`
+      ),
+      getFileState: db.prepare("SELECT * FROM conversation_file_state WHERE path = ?"),
+      upsertFileState: db.prepare(
+        `INSERT INTO conversation_file_state
+           (path, identity, size, mtime_ms, byte_offset, last_message_index)
+         VALUES (@path, @identity, @size, @mtime_ms, @byte_offset, @last_message_index)
+         ON CONFLICT(path) DO UPDATE SET
+           identity           = excluded.identity,
+           size               = excluded.size,
+           mtime_ms           = excluded.mtime_ms,
+           byte_offset        = excluded.byte_offset,
+           last_message_index = excluded.last_message_index`
+      ),
+      deleteFileState: db.prepare("DELETE FROM conversation_file_state WHERE path = ?"),
+      deleteMessageIndex: db.prepare(
+        "DELETE FROM conversation_message_index WHERE conversation_id = ?"
+      ),
+      insertMessageIndexRow: db.prepare(
+        `INSERT INTO conversation_message_index
+           (conversation_id, message_index, byte_offset, byte_length, uuid, role, ts)
+         VALUES (@conversation_id, @message_index, @byte_offset, @byte_length, @uuid, @role, @ts)
+         ON CONFLICT(conversation_id, message_index) DO UPDATE SET
+           byte_offset = excluded.byte_offset,
+           byte_length = excluded.byte_length,
+           uuid        = excluded.uuid,
+           role        = excluded.role,
+           ts          = excluded.ts`
+      ),
+      getMessageIndexWindow: db.prepare(
+        `SELECT message_index, byte_offset, byte_length, uuid, role, ts
+         FROM conversation_message_index
+         WHERE conversation_id = ? AND message_index >= ? AND message_index < ?
+         ORDER BY message_index ASC`
+      ),
+      getIndexedMessageCount: db.prepare(
+        "SELECT COUNT(*) as cnt FROM conversation_message_index WHERE conversation_id = ?"
       )
     };
   }
@@ -137006,6 +137097,258 @@ var ConversationCache = class _ConversationCache {
   getDatabase() {
     return this.db;
   }
+  // ── Offset index (design 1b) ────────────────────────────────────────────
+  // conversation_file_state + conversation_message_index back the windowed
+  // detail read path (SQL window select + pread of byte ranges). All methods
+  // are thin wrappers over the prepared statements above.
+  getFileState(path2) {
+    return this.stmts.getFileState.get(path2) ?? null;
+  }
+  upsertFileState(row) {
+    this.stmts.upsertFileState.run(row);
+  }
+  /** Drop a file's index rows + file_state (truncation / identity change). */
+  deleteFileIndex(path2, conversationId) {
+    const tx = this.db.transaction(() => {
+      this.stmts.deleteMessageIndex.run(conversationId);
+      this.stmts.deleteFileState.run(path2);
+    });
+    tx();
+    this.indexParseState.delete(path2);
+  }
+  /** Append/replace index rows in one transaction. */
+  appendMessageIndexRows(rows) {
+    const tx = this.db.transaction((batch) => {
+      for (const r of batch) this.stmts.insertMessageIndexRow.run(r);
+    });
+    tx(rows);
+  }
+  /** Rows for message_index in [fromIndex, toIndex), ordered ascending. */
+  getMessageIndexWindow(conversationId, fromIndex, toIndex) {
+    return this.stmts.getMessageIndexWindow.all(
+      conversationId,
+      fromIndex,
+      toIndex
+    );
+  }
+  getIndexedMessageCount(conversationId) {
+    return this.stmts.getIndexedMessageCount.get(conversationId).cnt;
+  }
+  /**
+   * Conversation id for a JSONL path — the filename stem (matches the pseudo-id
+   * updateFromLine derives and the uuid the detail read path resolves). The
+   * offset index keys on this so the window select and the cursor agree.
+   */
+  static conversationIdForFile(filePath) {
+    return filePath.split(/[/\\]/).pop()?.replace(/\.jsonl$/, "") ?? filePath;
+  }
+  /**
+   * Incremental offset-index writer: extend the index for a burst of appended
+   * lines (one watcher read) using their byte spans. Each line is classified
+   * with the scanner's parseJsonlLine (a running per-file reducer state), so the
+   * message ordering can never drift from the scanner's. Message lines get an
+   * index row at the next message_index; non-message lines (summary/sidecar)
+   * get no row but still advance byte_offset. file_state is updated to the end
+   * of the last consumed span.
+   *
+   * Requires an up-to-date `stat` (identity/size/mtime) for the file so the read
+   * path can detect truncation/replacement.
+   *
+   * `readFrom` is the absolute byte offset the watcher read started at, and
+   * `endOffset` is where it ended (readFrom + consumed, i.e. the watcher's new
+   * entry.offset). CONTIGUITY GUARD: the read must begin exactly where the index
+   * left off (`readFrom === existing.byte_offset`, or 0 with no state). If it
+   * doesn't — the watcher attached at EOF after the server was down, or an
+   * append raced an in-flight backfill — extending would assign wrong
+   * message_index values over a hole. In that case this writes nothing and
+   * returns null so the caller drops the index and backfills.
+   *
+   * On success returns the message_index assigned to each input span (null for a
+   * non-message line) so the caller can stamp WS `seq`. Empty array when spans
+   * is empty. `endOffset` is stored verbatim as byte_offset so the watcher's
+   * offset and file_state.byte_offset are the same number by construction.
+   */
+  extendMessageIndex(filePath, spans, stat10, readFrom, endOffset) {
+    const existing = this.getFileState(filePath);
+    const expectedStart = existing?.byte_offset ?? 0;
+    if (readFrom !== expectedStart) return null;
+    if (spans.length === 0) return [];
+    const convId = _ConversationCache.conversationIdForFile(filePath);
+    let state = this.indexParseState.get(filePath);
+    if (!state) {
+      state = initialConvState();
+      this.indexParseState.set(filePath, state);
+    }
+    let nextIndex = existing ? existing.last_message_index + 1 : 0;
+    const rows = [];
+    const seqs = [];
+    for (const span of spans) {
+      const msg = parseJsonlLine(span.text, state);
+      if (!msg) {
+        seqs.push(null);
+        continue;
+      }
+      rows.push({
+        conversation_id: convId,
+        message_index: nextIndex,
+        byte_offset: span.byteOffset,
+        byte_length: span.byteLength,
+        uuid: msg.uuid ?? null,
+        role: msg.role ?? null,
+        ts: msg.timestamp ? Date.parse(msg.timestamp) || null : null
+      });
+      seqs.push(nextIndex);
+      nextIndex++;
+    }
+    const tx = this.db.transaction(() => {
+      for (const r of rows) this.stmts.insertMessageIndexRow.run(r);
+      this.stmts.upsertFileState.run({
+        path: filePath,
+        identity: fileIdentity(stat10),
+        size: stat10.size,
+        mtime_ms: Math.round(stat10.mtimeMs),
+        // Store the watcher's end offset verbatim — same number as entry.offset,
+        // so the next read's contiguity check compares like-for-like (never
+        // false-positive on a read that ended in trailing empty lines).
+        byte_offset: endOffset,
+        last_message_index: nextIndex - 1
+      });
+    });
+    tx();
+    return seqs;
+  }
+  clearIndexParseState(filePath) {
+    this.indexParseState.delete(filePath);
+  }
+  /**
+   * On-demand full backfill of the offset index for a file with no/stale
+   * file_state (cold conversation, or after a truncation/replacement). Rebuilds
+   * from byte 0: drops any existing rows, walks the whole file in chunks with a
+   * running parse state, yields to the event loop every ~1000 lines so a large
+   * file never blocks, and writes index rows + file_state.
+   *
+   * Single-flighted per path: concurrent callers await the same walk. The
+   * triggering detail request is served by the scanner fallback while this runs.
+   */
+  backfillIndex(filePath) {
+    const inFlight = this.backfillInFlight.get(filePath);
+    if (inFlight) return inFlight;
+    const walk = this.runBackfill(filePath).finally(() => {
+      this.backfillInFlight.delete(filePath);
+    });
+    this.backfillInFlight.set(filePath, walk);
+    return walk;
+  }
+  async runBackfill(filePath) {
+    const convId = _ConversationCache.conversationIdForFile(filePath);
+    this.deleteFileIndex(filePath, convId);
+    this.indexParseState.delete(filePath);
+    const CHUNK = 256 * 1024;
+    const YIELD_EVERY = 1e3;
+    const state = initialConvState();
+    const fh = await (0, import_promises12.open)(filePath, "r");
+    let fileOffset = 0;
+    let carry = Buffer.alloc(0);
+    let nextIndex = 0;
+    let linesSinceYield = 0;
+    let lastConsumedEnd = 0;
+    let stat10;
+    try {
+      stat10 = await fh.stat();
+      const buf = Buffer.alloc(CHUNK);
+      for (; ; ) {
+        const { bytesRead } = await fh.read(buf, 0, CHUNK, null);
+        if (bytesRead === 0) break;
+        const combined = carry.length > 0 ? Buffer.concat([carry, buf.subarray(0, bytesRead)]) : buf.subarray(0, bytesRead);
+        const { spans, consumed } = splitCompleteLines(combined, fileOffset);
+        const rows = [];
+        for (const span of spans) {
+          const msg = parseJsonlLine(span.text, state);
+          linesSinceYield++;
+          if (msg) {
+            rows.push({
+              conversation_id: convId,
+              message_index: nextIndex,
+              byte_offset: span.byteOffset,
+              byte_length: span.byteLength,
+              uuid: msg.uuid ?? null,
+              role: msg.role ?? null,
+              ts: msg.timestamp ? Date.parse(msg.timestamp) || null : null
+            });
+            nextIndex++;
+          }
+          if (linesSinceYield >= YIELD_EVERY) {
+            linesSinceYield = 0;
+            await (0, import_promises13.setImmediate)();
+          }
+        }
+        if (rows.length > 0) this.appendMessageIndexRows(rows);
+        lastConsumedEnd = fileOffset + consumed;
+        carry = Buffer.from(combined.subarray(consumed));
+        fileOffset += consumed;
+      }
+    } finally {
+      await fh.close();
+    }
+    this.upsertFileState({
+      path: filePath,
+      identity: fileIdentity(stat10),
+      size: stat10.size,
+      mtime_ms: Math.round(stat10.mtimeMs),
+      byte_offset: lastConsumedEnd,
+      last_message_index: nextIndex - 1
+    });
+    this.indexParseState.set(filePath, state);
+  }
+  /**
+   * Windowed detail read straight from the offset index — the hot path.
+   * Returns the parsed messages for message_index in [fromIndex, toIndex) plus
+   * the total indexed count, or null when the index can't serve this file (no
+   * file_state, identity/size mismatch = truncation/replacement, or cold index)
+   * so the caller falls back to the scanner and enqueues a backfill.
+   *
+   * On a match it SQL-selects the window's byte ranges and preads exactly those
+   * ranges from the JSONL (never the whole file), parsing only the sliced lines.
+   * Returns messages in the same ConversationMessage shape parseJsonlLine
+   * produces during a scan, so the payload is identical to the scanner path.
+   */
+  readMessageWindow(filePath, fromIndex, toIndex) {
+    const fileState = this.getFileState(filePath);
+    if (!fileState) return null;
+    let stat10;
+    try {
+      stat10 = (0, import_fs17.statSync)(filePath);
+    } catch {
+      return null;
+    }
+    if (fileIdentity(stat10) !== fileState.identity || stat10.size !== fileState.byte_offset) {
+      return null;
+    }
+    const total = fileState.last_message_index + 1;
+    const from = Math.max(0, fromIndex);
+    const to2 = Math.min(toIndex, total);
+    if (to2 <= from) return { messages: [], total, fromIndex: from };
+    const rows = this.getMessageIndexWindow(
+      _ConversationCache.conversationIdForFile(filePath),
+      from,
+      to2
+    );
+    if (rows.length === 0) return { messages: [], total, fromIndex: from };
+    const messages = [];
+    const fd = (0, import_fs17.openSync)(filePath, "r");
+    try {
+      const state = initialConvState();
+      for (const row of rows) {
+        const buf = Buffer.alloc(row.byte_length);
+        (0, import_fs17.readSync)(fd, buf, 0, row.byte_length, row.byte_offset);
+        const msg = parseJsonlLine(buf.toString("utf-8"), state);
+        if (msg) messages.push(msg);
+      }
+    } finally {
+      (0, import_fs17.closeSync)(fd);
+    }
+    return { messages, total, fromIndex: from };
+  }
   agentEntrypointsKey() {
     return [...this.agentEntrypoints].sort().join(",");
   }
@@ -137030,14 +137373,14 @@ var ConversationCache = class _ConversationCache {
   isAgentFileCached(filePath) {
     let s3;
     try {
-      s3 = (0, import_fs16.statSync)(filePath);
+      s3 = (0, import_fs17.statSync)(filePath);
     } catch {
       return false;
     }
     return this.classifyAgentFile(filePath, s3.mtimeMs, s3.size);
   }
   static open(dbPath, tailSize = 10, migrationsDir, options) {
-    (0, import_fs16.mkdirSync)((0, import_path13.dirname)(dbPath), { recursive: true });
+    (0, import_fs17.mkdirSync)((0, import_path13.dirname)(dbPath), { recursive: true });
     const db = new import_better_sqlite32.default(dbPath);
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
@@ -137218,7 +137561,7 @@ var ConversationCache = class _ConversationCache {
         let mtimeMs = null;
         let fileSize = null;
         try {
-          const s3 = (0, import_fs16.statSync)(m2.filePath);
+          const s3 = (0, import_fs17.statSync)(m2.filePath);
           mtimeMs = s3.mtimeMs;
           fileSize = s3.size;
         } catch {
@@ -137277,8 +137620,8 @@ var ConversationCache = class _ConversationCache {
     let fileSize;
     let fd;
     try {
-      fileSize = (0, import_fs16.statSync)(filePath).size;
-      fd = (0, import_fs16.openSync)(filePath, "r");
+      fileSize = (0, import_fs17.statSync)(filePath).size;
+      fd = (0, import_fs17.openSync)(filePath, "r");
     } catch {
       return false;
     }
@@ -137291,7 +137634,7 @@ var ConversationCache = class _ConversationCache {
       while (pos > 0 && lines.length < this.tailSize * 4) {
         const toRead = Math.min(CHUNK, pos);
         pos -= toRead;
-        (0, import_fs16.readSync)(fd, buf, 0, toRead, pos);
+        (0, import_fs17.readSync)(fd, buf, 0, toRead, pos);
         const chunk = buf.subarray(0, toRead).toString("utf8");
         const combined = chunk + partial2;
         const parts = combined.split("\n");
@@ -137302,7 +137645,7 @@ var ConversationCache = class _ConversationCache {
       }
       if (partial2) lines.push(partial2);
     } finally {
-      (0, import_fs16.closeSync)(fd);
+      (0, import_fs17.closeSync)(fd);
     }
     const msgs = [];
     for (let i = 0; i < lines.length && msgs.length < this.tailSize; i++) {
@@ -137504,7 +137847,7 @@ var ConversationCache = class _ConversationCache {
    * `handleGetConversation` can still serve the cached tail even when the
    * JSONL has been deleted.
    */
-  pruneGhostFiles(exists = import_fs16.existsSync) {
+  pruneGhostFiles(exists = import_fs17.existsSync) {
     const rows = this.stmts.allFilePaths.all();
     const ghosts = [];
     const prune = this.db.transaction((ids) => {
@@ -137559,7 +137902,7 @@ var ConversationCache = class _ConversationCache {
    * Returns the removed IDs.
    */
   reconcileDeletions(livePaths, opts) {
-    const exists = opts?.exists ?? import_fs16.existsSync;
+    const exists = opts?.exists ?? import_fs17.existsSync;
     const rows = this.stmts.allFilePaths.all();
     const removed = [];
     const drop = this.db.transaction((ids) => {
@@ -137617,7 +137960,7 @@ function getDbConfig() {
 }
 
 // src/db/migrations.ts
-var import_fs17 = require("fs");
+var import_fs18 = require("fs");
 var import_path14 = require("path");
 var import_url7 = require("url");
 var import_meta2 = {};
@@ -137640,10 +137983,10 @@ async function runMigrations2(pool2, migrationsDir) {
   );
   const appliedSet = new Set(applied.map((r) => r.name));
   const dir = migrationsDir ?? (0, import_path14.join)(getMigrationsDir2(), "pg-migrations");
-  const files = (0, import_fs17.readdirSync)(dir).filter((f2) => f2.endsWith(".sql")).sort();
+  const files = (0, import_fs18.readdirSync)(dir).filter((f2) => f2.endsWith(".sql")).sort();
   for (const file2 of files) {
     if (appliedSet.has(file2)) continue;
-    const sql = (0, import_fs17.readFileSync)((0, import_path14.join)(dir, file2), "utf-8");
+    const sql = (0, import_fs18.readFileSync)((0, import_path14.join)(dir, file2), "utf-8");
     await pool2.query(sql);
     await pool2.query("INSERT INTO _migrations (name) VALUES ($1)", [file2]);
   }
@@ -137729,7 +138072,7 @@ var ConversationsRepository = class {
 };
 
 // src/db/repositories/projects.repository.ts
-var import_crypto5 = require("crypto");
+var import_crypto6 = require("crypto");
 
 // src/utils/canonicalizeProjectPath.ts
 function canonicalizeProjectPath(projectPath) {
@@ -137822,7 +138165,7 @@ var ProjectsRepository = class {
       });
       return rowToProject(this.getById.get(existing.id));
     }
-    const id = (0, import_crypto5.randomUUID)();
+    const id = (0, import_crypto6.randomUUID)();
     this.insert.run({
       id,
       path: path2,
@@ -137878,7 +138221,7 @@ async function recordUpload(pool2, instanceId, row) {
 }
 
 // src/handlers/handleListProjects.ts
-var import_fs18 = require("fs");
+var import_fs19 = require("fs");
 var import_os7 = require("os");
 var import_path15 = require("path");
 function decodeProjectPath(dirName) {
@@ -137890,11 +138233,11 @@ function handleListProjects(url2, res) {
   const projectsDir = (0, import_path15.join)((0, import_os7.homedir)(), ".claude", "projects");
   let entries;
   try {
-    entries = (0, import_fs18.readdirSync)(projectsDir).map((dirName) => {
+    entries = (0, import_fs19.readdirSync)(projectsDir).map((dirName) => {
       const fullPath = (0, import_path15.join)(projectsDir, dirName);
       let mtime = 0;
       try {
-        mtime = (0, import_fs18.statSync)(fullPath).mtimeMs;
+        mtime = (0, import_fs19.statSync)(fullPath).mtimeMs;
       } catch {
       }
       const path2 = decodeProjectPath(dirName);
@@ -137917,14 +138260,14 @@ var import_path19 = require("path");
 
 // src/codex-pty-runner.ts
 var import_headless = __toESM(require_xterm_headless(), 1);
-var import_crypto6 = require("crypto");
-var import_fs20 = require("fs");
+var import_crypto7 = require("crypto");
+var import_fs21 = require("fs");
 var import_path17 = require("path");
 init_logger();
 
 // src/platform.ts
 var import_child_process = require("child_process");
-var import_fs19 = require("fs");
+var import_fs20 = require("fs");
 var import_os8 = require("os");
 var import_path16 = require("path");
 var isWindows2 = (0, import_os8.platform)() === "win32";
@@ -137954,7 +138297,7 @@ function resolveClaudeExe() {
       )
     ];
     for (const p2 of candidates) {
-      if ((0, import_fs19.existsSync)(p2)) {
+      if ((0, import_fs20.existsSync)(p2)) {
         _claudeExe = p2;
         return _claudeExe;
       }
@@ -137965,7 +138308,7 @@ function resolveClaudeExe() {
         encoding: "utf-8",
         timeout: 3e3
       }).trim().split("\n")[0].trim();
-      if (found && (0, import_fs19.existsSync)(found)) {
+      if (found && (0, import_fs20.existsSync)(found)) {
         _claudeExe = found;
         return _claudeExe;
       }
@@ -137977,7 +138320,7 @@ function resolveClaudeExe() {
       (0, import_path16.join)((0, import_os8.homedir)(), ".local", "bin", "claude")
     ];
     for (const p2 of candidates) {
-      if ((0, import_fs19.existsSync)(p2)) {
+      if ((0, import_fs20.existsSync)(p2)) {
         _claudeExe = p2;
         return _claudeExe;
       }
@@ -138012,7 +138355,7 @@ function resolveCodexExe() {
       )
     ];
     for (const p2 of candidates) {
-      if ((0, import_fs19.existsSync)(p2)) {
+      if ((0, import_fs20.existsSync)(p2)) {
         _codexExe = p2;
         return _codexExe;
       }
@@ -138023,7 +138366,7 @@ function resolveCodexExe() {
         encoding: "utf-8",
         timeout: 3e3
       }).trim().split("\n")[0].trim();
-      if (found && (0, import_fs19.existsSync)(found)) {
+      if (found && (0, import_fs20.existsSync)(found)) {
         _codexExe = found;
         return _codexExe;
       }
@@ -138035,7 +138378,7 @@ function resolveCodexExe() {
       (0, import_path16.join)((0, import_os8.homedir)(), ".local", "bin", "codex")
     ];
     for (const p2 of candidates) {
-      if ((0, import_fs19.existsSync)(p2)) {
+      if ((0, import_fs20.existsSync)(p2)) {
         _codexExe = p2;
         return _codexExe;
       }
@@ -138172,7 +138515,7 @@ var CodexPtyRunner = class {
   // ManagedSession handle only.
   async startFresh(options) {
     const nodePty = await loadPty();
-    const sessionId = (0, import_crypto6.randomUUID)();
+    const sessionId = (0, import_crypto7.randomUUID)();
     const projectName = options.projectName ?? (0, import_path17.basename)(options.projectPath);
     const args = ["--cd", options.projectPath, "--no-alt-screen"];
     if (options.systemPrompt) {
@@ -138465,7 +138808,7 @@ var CodexPtyRunner = class {
     session.status = "idle";
     const elapsedMs = session.completedAt.getTime() - session.startedAt.getTime();
     if (exitCode !== 0 && elapsedMs < 2e3 && session.lastOutput === "") {
-      if (!(0, import_fs20.existsSync)(session.projectPath)) {
+      if (!(0, import_fs21.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       } else {
         session.failureReason = `Codex process exited immediately (code ${exitCode}).`;
@@ -138501,8 +138844,8 @@ function stripAnsi(str) {
 
 // src/pty-manager.ts
 var import_headless2 = __toESM(require_xterm_headless(), 1);
-var import_crypto7 = require("crypto");
-var import_fs21 = require("fs");
+var import_crypto8 = require("crypto");
+var import_fs22 = require("fs");
 var import_path18 = require("path");
 init_logger();
 
@@ -138905,7 +139248,7 @@ var PTYManager = class {
   // onReady fires once Claude reaches its first prompt (waiting_input).
   async startFresh(options) {
     const nodePty = await loadPty2();
-    const sessionId = (0, import_crypto7.randomUUID)();
+    const sessionId = (0, import_crypto8.randomUUID)();
     const projectName = options.projectName ?? (0, import_path18.basename)(options.projectPath);
     const args = [
       "--permission-mode",
@@ -139350,7 +139693,7 @@ var PTYManager = class {
     session.status = "idle";
     const elapsedMs = session.completedAt.getTime() - session.startedAt.getTime();
     if (exitCode !== 0 && elapsedMs < 2e3 && session.lastOutput === "") {
-      if (!(0, import_fs21.existsSync)(session.projectPath)) {
+      if (!(0, import_fs22.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       } else {
         session.failureReason = `Process exited immediately (code ${exitCode}). Check that the Claude binary is installed and accessible.`;
@@ -139489,7 +139832,7 @@ var LiveSessionManager = class {
 init_logger();
 
 // src/pair-store.ts
-var import_crypto8 = require("crypto");
+var import_crypto9 = require("crypto");
 var DEFAULT_TTL_SECONDS = 180;
 var SWEEP_INTERVAL_MS = 6e4;
 var PairTokenStore = class {
@@ -139504,7 +139847,7 @@ var PairTokenStore = class {
     }
   }
   mint() {
-    const token = `pt_${(0, import_crypto8.randomBytes)(16).toString("hex")}`;
+    const token = `pt_${(0, import_crypto9.randomBytes)(16).toString("hex")}`;
     const expiresAt = Date.now() + this.ttlMs;
     this.current = { token, expiresAt, used: false };
     return {
@@ -139709,11 +140052,11 @@ function seal(plaintext, recipientPublicKeyBase64) {
 // node_modules/chokidar/index.js
 var import_node_events2 = require("events");
 var import_node_fs7 = require("fs");
-var import_promises14 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var sp2 = __toESM(require("path"), 1);
 
 // node_modules/readdirp/index.js
-var import_promises12 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 var import_node_path9 = require("path");
 var import_node_stream2 = require("stream");
 var EntryTypes2 = {
@@ -139794,7 +140137,7 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
     const { root, type } = opts;
     this._fileFilter = normalizeFilter2(opts.fileFilter);
     this._directoryFilter = normalizeFilter2(opts.directoryFilter);
-    const statMethod = opts.lstat ? import_promises12.lstat : import_promises12.stat;
+    const statMethod = opts.lstat ? import_promises14.lstat : import_promises14.stat;
     if (wantBigintFsStats2) {
       this._stat = (path2) => statMethod(path2, { bigint: true });
     } else {
@@ -139865,7 +140208,7 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
   async _exploreDir(path2, depth) {
     let files;
     try {
-      files = await (0, import_promises12.readdir)(path2, this._rdOptions);
+      files = await (0, import_promises14.readdir)(path2, this._rdOptions);
     } catch (error51) {
       this._onError(error51);
     }
@@ -139903,8 +140246,8 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
     if (stats && stats.isSymbolicLink()) {
       const full = entry.fullPath;
       try {
-        const entryRealPath = await (0, import_promises12.realpath)(full);
-        const entryRealPathStats = await (0, import_promises12.lstat)(entryRealPath);
+        const entryRealPath = await (0, import_promises14.realpath)(full);
+        const entryRealPathStats = await (0, import_promises14.lstat)(entryRealPath);
         if (entryRealPathStats.isFile()) {
           return "file";
         }
@@ -139947,7 +140290,7 @@ function readdirp2(root, options = {}) {
 
 // node_modules/chokidar/handler.js
 var import_node_fs6 = require("fs");
-var import_promises13 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var import_node_os3 = require("os");
 var sp = __toESM(require("path"), 1);
 var STR_DATA2 = "data";
@@ -139974,7 +140317,7 @@ var EVENTS2 = {
 };
 var EV2 = EVENTS2;
 var THROTTLE_MODE_WATCH2 = "watch";
-var statMethods2 = { lstat: import_promises13.lstat, stat: import_promises13.stat };
+var statMethods2 = { lstat: import_promises15.lstat, stat: import_promises15.stat };
 var KEY_LISTENERS2 = "listeners";
 var KEY_ERR2 = "errHandlers";
 var KEY_RAW2 = "rawEmitters";
@@ -140331,7 +140674,7 @@ var setFsWatchListener2 = (path2, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows3 && error51.code === "EPERM") {
         try {
-          const fd = await (0, import_promises13.open)(path2, "r");
+          const fd = await (0, import_promises15.open)(path2, "r");
           await fd.close();
           broadcastErr(error51);
         } catch (err) {
@@ -140462,7 +140805,7 @@ var NodeFsHandler2 = class {
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await (0, import_promises13.stat)(file2);
+          const newStats2 = await (0, import_promises15.stat)(file2);
           if (this.fsw.closed)
             return;
           const at2 = newStats2.atimeMs;
@@ -140517,7 +140860,7 @@ var NodeFsHandler2 = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises13.realpath)(path2);
+        linkPath = await (0, import_promises15.realpath)(path2);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -140666,7 +141009,7 @@ var NodeFsHandler2 = class {
       let closer;
       if (stats.isDirectory()) {
         const absPath = sp.resolve(path2);
-        const targetPath = follow ? await (0, import_promises13.realpath)(path2) : path2;
+        const targetPath = follow ? await (0, import_promises15.realpath)(path2) : path2;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -140676,7 +141019,7 @@ var NodeFsHandler2 = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises13.realpath)(path2) : path2;
+        const targetPath = follow ? await (0, import_promises15.realpath)(path2) : path2;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
@@ -140836,7 +141179,7 @@ var DirEntry2 = class {
       return;
     const dir = this.path;
     try {
-      await (0, import_promises14.readdir)(dir);
+      await (0, import_promises16.readdir)(dir);
     } catch (err) {
       if (this._removeWatcher) {
         this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
@@ -141186,7 +141529,7 @@ var FSWatcher2 = class extends import_node_events2.EventEmitter {
       const fullPath = opts.cwd ? sp2.join(opts.cwd, path2) : path2;
       let stats2;
       try {
-        stats2 = await (0, import_promises14.stat)(fullPath);
+        stats2 = await (0, import_promises16.stat)(fullPath);
       } catch (err) {
       }
       if (!stats2 || this.closed)
@@ -141439,19 +141782,21 @@ function watch2(paths, options = {}) {
 var chokidar_default = { watch: watch2, FSWatcher: FSWatcher2 };
 
 // src/services/conversations/conversationWatcher.ts
-var import_fs22 = require("fs");
-var import_promises15 = require("fs/promises");
+var import_fs23 = require("fs");
+var import_promises17 = require("fs/promises");
 var ConversationWatcher = class {
   files = /* @__PURE__ */ new Map();
   directories = /* @__PURE__ */ new Map();
   onNewLine;
   onNewLines;
+  onNewLineSpans;
   onConversationChanged;
   onFileDeleted;
   onError;
   constructor(events = {}) {
     this.onNewLine = events.onNewLine;
     this.onNewLines = events.onNewLines;
+    this.onNewLineSpans = events.onNewLineSpans;
     this.onConversationChanged = events.onConversationChanged;
     this.onFileDeleted = events.onFileDeleted;
     this.onError = events.onError;
@@ -141460,7 +141805,7 @@ var ConversationWatcher = class {
     if (this.files.has(filePath)) return;
     let offset;
     try {
-      offset = (0, import_fs22.statSync)(filePath).size;
+      offset = (0, import_fs23.statSync)(filePath).size;
     } catch {
       offset = 0;
     }
@@ -141544,20 +141889,24 @@ var ConversationWatcher = class {
     entry.reading = true;
     try {
       for (; ; ) {
-        const st2 = await (0, import_promises15.stat)(filePath);
+        const st2 = await (0, import_promises17.stat)(filePath);
         if (st2.size <= entry.offset) break;
         const readFrom = entry.offset;
         const bytesToRead = st2.size - readFrom;
         const buf = Buffer.alloc(bytesToRead);
-        const fh = await (0, import_promises15.open)(filePath, "r");
+        const fh = await (0, import_promises17.open)(filePath, "r");
         try {
           await fh.read(buf, 0, bytesToRead, readFrom);
         } finally {
           await fh.close();
         }
-        entry.offset = readFrom + bytesToRead;
+        const { spans, consumed } = splitCompleteLines(buf, readFrom);
+        entry.offset = readFrom + consumed;
         if (!this.files.has(filePath)) return;
-        const lines = buf.toString("utf-8").split("\n").filter(Boolean);
+        const lines = spans.map((s3) => s3.text);
+        if (spans.length > 0) {
+          this.onNewLineSpans?.(filePath, spans, readFrom, entry.offset);
+        }
         if (this.onNewLines) {
           this.onNewLines(filePath, lines);
         } else {
@@ -141631,14 +141980,14 @@ function findSearchTarget(messages, query) {
 }
 
 // src/services/conversations/pruneAgentConversations.ts
-var import_fs23 = require("fs");
+var import_fs24 = require("fs");
 function pruneAgentConversations(cache) {
   const db = cache.getDatabase();
   const rows = db.prepare("SELECT id, file_path FROM conversation_meta").all();
   let pruned = 0;
   let missing = 0;
   for (const row of rows) {
-    if (!(0, import_fs23.existsSync)(row.file_path)) {
+    if (!(0, import_fs24.existsSync)(row.file_path)) {
       missing += 1;
       continue;
     }
@@ -141997,8 +142346,8 @@ function discoveredToResponse(d, conversationId) {
 }
 
 // src/uploads.ts
-var import_crypto9 = require("crypto");
-var import_promises16 = require("fs/promises");
+var import_crypto10 = require("crypto");
+var import_promises18 = require("fs/promises");
 var import_heic_convert = __toESM(require_heic_convert(), 1);
 var import_path21 = require("path");
 var UPLOAD_DIR_NAME = ".threadbase-uploads";
@@ -142031,12 +142380,12 @@ async function saveUploadFile(input) {
     mimeType = "image/jpeg";
     originalName = originalName.replace(/\.(heic|heif)$/i, ".jpg");
   }
-  const id = `up_${(0, import_crypto9.randomBytes)(8).toString("hex")}`;
+  const id = `up_${(0, import_crypto10.randomBytes)(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
   const dir = (0, import_path21.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
-  await (0, import_promises16.mkdir)(dir, { recursive: true });
+  await (0, import_promises18.mkdir)(dir, { recursive: true });
   const filePath = (0, import_path21.join)(dir, `${Date.now()}-${id}-${safeName}`);
-  await (0, import_promises16.writeFile)(filePath, buffer);
+  await (0, import_promises18.writeFile)(filePath, buffer);
   return {
     id,
     filePath,
@@ -142420,6 +142769,7 @@ var WSHub = class {
 var BROWSE_SYSTEM_PROMPT = (browseRoot) => `You are working within the project boundary: ${browseRoot}. Do not read, write, or execute commands that access files or directories outside this boundary.`;
 var DEFAULT_SYSTEM_PROMPT = "When presenting options or choices to the user, limit the options to at most 3.";
 var DEFAULT_PTY_GRACE_PERIOD_MS = 27e4;
+var REFRESH_TTL_MS = 2e3;
 var START_READY_TIMEOUT_MS = 15e3;
 function parseIncludeAgentsEnv(raw2) {
   if (raw2 === void 0) return false;
@@ -142434,6 +142784,10 @@ var StreamerServer = class {
   fileWatcher;
   sessionFileMap = /* @__PURE__ */ new Map();
   // sessionId → JSONL filePath
+  // Per-file seq assignments from the most recent onNewLineSpans (offset index),
+  // handed to the immediately-following onNewLines so it can stamp WS `seq` on
+  // the matching conversation_events entries. Same read → same lines order.
+  pendingLineSeqs = /* @__PURE__ */ new Map();
   pendingQuestions = /* @__PURE__ */ new Map();
   // Content key of the AskUserQuestion currently broadcast for a session (from
   // either the rendered screen or JSONL), used to de-dupe the two paths: when
@@ -142459,6 +142813,12 @@ var StreamerServer = class {
   // Set by onConversationChanged while a scan is in-flight; getScanner() does
   // a single rescan after the current one completes instead of restarting it.
   scannerStale = false;
+  // Single-flight + TTL guard around scanner.refreshFile (see refreshFileGuarded).
+  // A live file's mtime is always newer than the snapshot, so an unguarded
+  // refresh fires on every request and re-parses the whole file from byte 0.
+  // Keyed by filePath; entries drop on settle + TTL expiry, so the map stays
+  // bounded by the active-file set.
+  refreshInFlight = /* @__PURE__ */ new Map();
   // True only while bindWithRetry is actively retrying. The persistent
   // listener-level 'error' handler demotes EADDRINUSE to debug during this
   // window so the self-healing kickstart-relaunch race doesn't spam warn.
@@ -142551,7 +142911,7 @@ var StreamerServer = class {
     this.agentEntrypoints = parseAgentEntrypointsEnv(process.env.THREADBASE_AGENT_ENTRYPOINTS);
     const rawRoot = process.env.THREADBASE_BROWSE_ROOT ?? loadBrowseRoot() ?? config2.browseRoot;
     if (rawRoot) {
-      (0, import_promises17.realpath)(rawRoot).then((resolved) => {
+      (0, import_promises19.realpath)(rawRoot).then((resolved) => {
         this.browseRoot = resolved;
         if (this.verbose) this.log.info(`Browse root: ${resolved}`, { browseRoot: resolved });
       }).catch(() => {
@@ -142573,6 +142933,42 @@ var StreamerServer = class {
     this.sessionStore = new SessionStore();
     this.wsHub = new WSHub();
     this.fileWatcher = new ConversationWatcher({
+      onNewLineSpans: (filePath, spans, readFrom, endOffset) => {
+        if (!this.cache) return;
+        const cache = this.cache;
+        this.pendingLineSeqs.delete(filePath);
+        try {
+          const seqs = cache.extendMessageIndex(
+            filePath,
+            spans,
+            (0, import_fs25.statSync)(filePath),
+            readFrom,
+            endOffset
+          );
+          if (seqs === null) {
+            cache.deleteFileIndex(filePath, ConversationCache.conversationIdForFile(filePath));
+            cache.clearIndexParseState(filePath);
+            this.trackCacheWrite(
+              cache.backfillIndex(filePath).catch((err) => {
+                this.log.warn("offset-index.backfill_failed", {
+                  event: "offset_index.backfill_failed",
+                  filePath,
+                  trigger: "noncontiguous-append",
+                  err
+                });
+              })
+            );
+            return;
+          }
+          this.pendingLineSeqs.set(filePath, seqs);
+        } catch (err) {
+          this.log.warn("offset-index.extend_failed", {
+            event: "offset_index.extend_failed",
+            filePath,
+            err
+          });
+        }
+      },
       onNewLines: (filePath, lines) => {
         this.cache?.updateFromLines(filePath, lines);
         for (const [sessionId, watchedPath] of this.sessionFileMap) {
@@ -142599,13 +142995,20 @@ var StreamerServer = class {
               this.pendingQuestionKey.set(sessionId, key);
               if (broadcast) this.wsHub.broadcast(m2);
             }
-            this.wsHub.broadcast({ type: "conversation_events", sessionId, lines });
+            const seqs = this.pendingLineSeqs.get(filePath);
+            this.wsHub.broadcast({
+              type: "conversation_events",
+              sessionId,
+              lines,
+              ...seqs && seqs.length === lines.length ? { seqs } : {}
+            });
             for (const line of lines) {
               this.wsHub.broadcast({ type: "conversation_event", sessionId, line });
             }
             break;
           }
         }
+        this.pendingLineSeqs.delete(filePath);
       },
       onConversationChanged: (filePath) => {
         this.fileWatcher.poke(filePath);
@@ -142657,7 +143060,7 @@ var StreamerServer = class {
         if (session.status === "waiting_input" || session.status === "idle") {
           const filePath = this.sessionFileMap.get(session.id);
           if (filePath) {
-            this.getScanner().then((scanner) => scanner.refreshFile(filePath)).then((meta3) => {
+            this.getScanner().then((scanner) => this.refreshFileGuarded(scanner, filePath)).then((meta3) => {
               this.log.info("scanner.refreshFile: ok", {
                 event: "scanner.refresh",
                 sessionId: session.id,
@@ -143106,6 +143509,34 @@ var StreamerServer = class {
       this.inFlightCacheWrites.delete(guarded);
     });
   }
+  // Single-flight + TTL wrapper for scanner.refreshFile. Both call sites (the
+  // detail-stale branch and the per-turn refresh) route through here so that
+  // N stacked retries on a live, actively-appended file cost one parse, not N:
+  //  - a refresh already in flight for the path → await the same promise;
+  //  - a refresh that settled within REFRESH_TTL_MS → skip, return null (the
+  //    caller keeps serving the current snapshot);
+  //  - otherwise start one, cache the promise, and stamp completedAt on settle.
+  // The map is bounded by the active-file set (entries only live while a
+  // refresh is in flight or within its TTL and are overwritten on the next
+  // refresh of the same path).
+  refreshFileGuarded(scanner, filePath) {
+    const existing = this.refreshInFlight.get(filePath);
+    if (existing) {
+      const settled = existing.completedAt > 0;
+      if (!settled) {
+        return existing.promise;
+      }
+      if (Date.now() - existing.completedAt < REFRESH_TTL_MS) {
+        return Promise.resolve(null);
+      }
+    }
+    const entry = { promise: Promise.resolve(null), completedAt: 0 };
+    entry.promise = scanner.refreshFile(filePath).finally(() => {
+      entry.completedAt = Date.now();
+    });
+    this.refreshInFlight.set(filePath, entry);
+    return entry.promise;
+  }
   async close() {
     for (const timer of this.ptyGraceTimers.values()) clearTimeout(timer);
     this.ptyGraceTimers.clear();
@@ -143516,16 +143947,16 @@ var StreamerServer = class {
   }
   findJsonlPath(uuid3) {
     const projectsDir = (0, import_path22.join)((0, import_os10.homedir)(), ".claude", "projects");
-    if (!(0, import_fs24.existsSync)(projectsDir)) return null;
+    if (!(0, import_fs25.existsSync)(projectsDir)) return null;
     const filename = `${uuid3}.jsonl`;
-    for (const dir of (0, import_fs24.readdirSync)(projectsDir)) {
+    for (const dir of (0, import_fs25.readdirSync)(projectsDir)) {
       const fp = (0, import_path22.join)(projectsDir, dir, filename);
-      if ((0, import_fs24.existsSync)(fp)) return fp;
+      if ((0, import_fs25.existsSync)(fp)) return fp;
       const projectDir = (0, import_path22.join)(projectsDir, dir);
       try {
-        for (const sub of (0, import_fs24.readdirSync)(projectDir)) {
+        for (const sub of (0, import_fs25.readdirSync)(projectDir)) {
           const subagentPath = (0, import_path22.join)(projectDir, sub, "subagents", filename);
-          if ((0, import_fs24.existsSync)(subagentPath)) return subagentPath;
+          if ((0, import_fs25.existsSync)(subagentPath)) return subagentPath;
         }
       } catch {
       }
@@ -143534,7 +143965,7 @@ var StreamerServer = class {
   }
   async readCwdFromJsonl(filePath) {
     return new Promise((resolve6) => {
-      const rl = (0, import_readline4.createInterface)({ input: (0, import_fs24.createReadStream)(filePath), crlfDelay: Infinity });
+      const rl = (0, import_readline4.createInterface)({ input: (0, import_fs25.createReadStream)(filePath), crlfDelay: Infinity });
       let found = false;
       rl.on("line", (line) => {
         if (found) return;
@@ -143570,10 +144001,22 @@ var StreamerServer = class {
     const scanner = await this.getScanner(true);
     const fromIndex = await scanner.getConversation(uuid3);
     if (fromIndex) {
+      if (this.ptyManager.hasSession(uuid3)) {
+        return fromIndex;
+      }
       if (fromIndex.filePath && this.isConversationSnapshotStale(fromIndex)) {
-        const refreshedMeta = await scanner.refreshFile(fromIndex.filePath);
-        if (!refreshedMeta) return null;
-        return await scanner.getConversation(uuid3) ?? fromIndex;
+        const filePath2 = fromIndex.filePath;
+        this.trackCacheWrite(
+          this.refreshFileGuarded(scanner, filePath2).catch((err) => {
+            this.log.warn("scanner.refreshFile: failed", {
+              event: "scanner.refresh_failed",
+              conversationId: uuid3,
+              filePath: filePath2,
+              trigger: "detail-swr",
+              err
+            });
+          })
+        );
       }
       return fromIndex;
     }
@@ -143591,7 +144034,7 @@ var StreamerServer = class {
     if (!conv.filePath) return false;
     let mtimeMs = null;
     try {
-      mtimeMs = (0, import_fs24.statSync)(conv.filePath).mtimeMs;
+      mtimeMs = (0, import_fs25.statSync)(conv.filePath).mtimeMs;
     } catch {
       return false;
     }
@@ -143649,9 +144092,13 @@ var StreamerServer = class {
       return;
     }
     const etagSource = conversation;
+    const indexedCount = etagSource.filePath && this.cache ? this.cache.getIndexedMessageCount(
+      ConversationCache.conversationIdForFile(etagSource.filePath)
+    ) : 0;
+    const etagMessageCount = Math.max(etagSource.messageCount, indexedCount);
     const etag = computeConversationEtag({
       filePath: etagSource.filePath,
-      messageCount: etagSource.messageCount,
+      messageCount: etagMessageCount,
       timestamp: etagSource.timestamp
     });
     const isFirstPage = !url2.searchParams.has("before_index") && !url2.searchParams.has("anchor_index") && !url2.searchParams.has("after_index");
@@ -143668,12 +144115,14 @@ var StreamerServer = class {
     let slice = filtered;
     let fromIdx = 0;
     let messagePagination;
+    let indexTotal = null;
     if (usePaging) {
       const limit = Math.min(Math.max(intParam(url2, "msg_limit", 80), 1), 500);
       let beforeIndex = total;
       let scanLimit = limit;
       let anchorIndex = null;
       let newerPaging = false;
+      let usedAfterIndex = false;
       if (url2.searchParams.has("before_index")) {
         beforeIndex = intParam(url2, "before_index", total);
         beforeIndex = Math.min(Math.max(beforeIndex, 0), total);
@@ -143682,6 +144131,7 @@ var StreamerServer = class {
         beforeIndex = Math.min(total, from + limit);
         scanLimit = beforeIndex - from;
         newerPaging = true;
+        usedAfterIndex = true;
       } else if (hasAnchor) {
         anchorIndex = Math.min(
           Math.max(intParam(url2, "anchor_index", 0), 0),
@@ -143691,9 +144141,34 @@ var StreamerServer = class {
         beforeIndex = Math.min(total, from + limit);
         newerPaging = true;
       }
-      const pagedScanner = this.scannerReady ? await this.getScanner(true) : null;
-      const page = scanLimit > 0 && pagedScanner && typeof pagedScanner.getConversationPage === "function" ? await pagedScanner.getConversationPage(id, { beforeIndex, limit: scanLimit }) : null;
-      const start = page?.fromIndex ?? Math.max(0, beforeIndex - scanLimit);
+      const isTailRequest = !url2.searchParams.has("before_index") && !hasAfter && !hasAnchor;
+      const indexFilePath = conversation.filePath;
+      if (isTailRequest && indexFilePath && this.cache) {
+        const indexed = this.cache.getIndexedMessageCount(
+          ConversationCache.conversationIdForFile(indexFilePath)
+        );
+        if (indexed > beforeIndex) {
+          beforeIndex = indexed;
+        }
+      }
+      const windowStart = Math.max(0, beforeIndex - scanLimit);
+      const indexWindow = scanLimit > 0 && !hasAnchor && indexFilePath && this.cache ? this.cache.readMessageWindow(indexFilePath, windowStart, beforeIndex) : null;
+      if (!indexWindow && indexFilePath && this.cache && !hasAnchor) {
+        this.trackCacheWrite(
+          this.cache.backfillIndex(indexFilePath).catch((err) => {
+            this.log.warn("offset-index.backfill_failed", {
+              event: "offset_index.backfill_failed",
+              conversationId: id,
+              filePath: indexFilePath,
+              err
+            });
+          })
+        );
+      }
+      const pagedScanner = !indexWindow && this.scannerReady ? await this.getScanner(true) : null;
+      const page = indexWindow ?? (scanLimit > 0 && pagedScanner && typeof pagedScanner.getConversationPage === "function" ? await pagedScanner.getConversationPage(id, { beforeIndex, limit: scanLimit }) : null);
+      if (indexWindow) indexTotal = indexWindow.total;
+      const start = page?.fromIndex ?? windowStart;
       slice = page?.messages ?? filtered.slice(start, beforeIndex);
       fromIdx = start;
       const effectiveTotal = page?.total ?? total;
@@ -143709,6 +144184,9 @@ var StreamerServer = class {
         messagePagination.has_more_newer = beforeIndex < effectiveTotal;
         messagePagination.next_after_index = beforeIndex < effectiveTotal ? beforeIndex : null;
       }
+      if (usedAfterIndex) {
+        messagePagination.etag = etag;
+      }
     }
     const messagesPayload = slice.map((m2, localIdx) => {
       const content = [];
@@ -143750,6 +144228,8 @@ var StreamerServer = class {
     const cachedConvMeta = this.cache?.getMetaById(id);
     const convProvider = coerceProviderForRunner(conv.provider ?? cachedConvMeta?.provider);
     const availability = classifyResumability(conv.projectPath);
+    const metaMessageCount = indexTotal != null && indexTotal > conv.messageCount ? indexTotal : conv.messageCount;
+    const metaLastUpdatedAt = indexTotal != null && indexTotal > conv.messageCount ? slice.at(-1)?.timestamp ?? conv.timestamp : conv.timestamp;
     const body = {
       meta: {
         id,
@@ -143757,8 +144237,8 @@ var StreamerServer = class {
         project_name: conv.projectName,
         project_path: conv.projectPath,
         file_path: conv.filePath,
-        last_updated_at: conv.timestamp,
-        message_count: conv.messageCount,
+        last_updated_at: metaLastUpdatedAt,
+        message_count: metaMessageCount,
         last_prompt: conv.lastPrompt ?? void 0,
         provider: convProvider,
         resumable: isProviderResumable(convProvider, availability.resumable),
@@ -143921,7 +144401,7 @@ var StreamerServer = class {
   handleGetSession(sessionId, res) {
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (session) {
-      if (!(0, import_fs24.existsSync)(session.projectPath)) {
+      if (!(0, import_fs25.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       }
       json2(res, 200, session);
@@ -144478,11 +144958,11 @@ var StreamerServer = class {
         cleanup();
         return;
       }
-      let resolvedFilePath = (0, import_fs24.existsSync)(filePath) ? filePath : null;
-      if (!resolvedFilePath && (0, import_fs24.existsSync)(projectsDir)) {
+      let resolvedFilePath = (0, import_fs25.existsSync)(filePath) ? filePath : null;
+      if (!resolvedFilePath && (0, import_fs25.existsSync)(projectsDir)) {
         try {
           const now = Date.now();
-          const recent = (0, import_fs24.readdirSync)(projectsDir).filter((f2) => f2.endsWith(".jsonl")).map((f2) => ({ f: f2, mtime: (0, import_fs24.statSync)((0, import_path22.join)(projectsDir, f2)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b2) => b2.mtime - a.mtime)[0];
+          const recent = (0, import_fs25.readdirSync)(projectsDir).filter((f2) => f2.endsWith(".jsonl")).map((f2) => ({ f: f2, mtime: (0, import_fs25.statSync)((0, import_path22.join)(projectsDir, f2)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b2) => b2.mtime - a.mtime)[0];
           if (recent) resolvedFilePath = (0, import_path22.join)(projectsDir, recent.f);
         } catch {
         }
@@ -144492,7 +144972,7 @@ var StreamerServer = class {
       this.sessionFileMap.set(sessionId, resolvedFilePath);
       this.fileWatcher.watch(resolvedFilePath);
       try {
-        const existing = (0, import_fs24.readFileSync)(resolvedFilePath, "utf8").split("\n").filter(Boolean);
+        const existing = (0, import_fs25.readFileSync)(resolvedFilePath, "utf8").split("\n").filter(Boolean);
         if (existing.length > 0) {
           this.wsHub.broadcast({ type: "conversation_events", sessionId, lines: existing });
           for (const line of existing) {
@@ -144518,7 +144998,7 @@ var StreamerServer = class {
     if (this.sessionFileMap.has(sessionId)) return;
     try {
       require("fs").mkdirSync(projectsDir, { recursive: true });
-      watcher = (0, import_fs24.watch)(projectsDir, tryWire);
+      watcher = (0, import_fs25.watch)(projectsDir, tryWire);
       watcher.on("error", cleanup);
     } catch {
     }
@@ -144547,7 +145027,7 @@ var StreamerServer = class {
     };
     const matchesProjectPath = (candidatePath) => {
       try {
-        const firstLine = (0, import_fs24.readFileSync)(candidatePath, "utf8").split("\n", 1)[0];
+        const firstLine = (0, import_fs25.readFileSync)(candidatePath, "utf8").split("\n", 1)[0];
         if (!firstLine) return null;
         const parsed = JSON.parse(firstLine);
         if (parsed?.type !== "session_meta") return null;
@@ -144576,15 +145056,15 @@ var StreamerServer = class {
       );
       for (const root of this.codexRoots) {
         const sessionsDir = (0, import_path22.join)(root, dateDir);
-        if (!(0, import_fs24.existsSync)(sessionsDir)) continue;
+        if (!(0, import_fs25.existsSync)(sessionsDir)) continue;
         let candidateFiles;
         try {
-          candidateFiles = (0, import_fs24.readdirSync)(sessionsDir).filter((f2) => f2.endsWith(".jsonl"));
+          candidateFiles = (0, import_fs25.readdirSync)(sessionsDir).filter((f2) => f2.endsWith(".jsonl"));
         } catch {
           continue;
         }
         const nowMs = Date.now();
-        const recentCandidates = candidateFiles.map((f2) => ({ f: f2, mtime: (0, import_fs24.statSync)((0, import_path22.join)(sessionsDir, f2)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b2) => b2.mtime - a.mtime);
+        const recentCandidates = candidateFiles.map((f2) => ({ f: f2, mtime: (0, import_fs25.statSync)((0, import_path22.join)(sessionsDir, f2)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b2) => b2.mtime - a.mtime);
         for (const { f: f2 } of recentCandidates) {
           const candidatePath = (0, import_path22.join)(sessionsDir, f2);
           const match2 = matchesProjectPath(candidatePath);
@@ -144596,7 +145076,7 @@ var StreamerServer = class {
           this.sessionFileMap.set(sessionId, candidatePath);
           this.fileWatcher.watch(candidatePath);
           try {
-            const existing = (0, import_fs24.readFileSync)(candidatePath, "utf8").split("\n").filter(Boolean);
+            const existing = (0, import_fs25.readFileSync)(candidatePath, "utf8").split("\n").filter(Boolean);
             if (existing.length > 0) {
               this.wsHub.broadcast({ type: "conversation_events", sessionId, lines: existing });
               for (const line of existing) {
@@ -144721,7 +145201,7 @@ var StreamerServer = class {
 };
 function classifyResumability(cwd) {
   if (!cwd) return { resumable: true };
-  if ((0, import_fs24.existsSync)(cwd)) return { resumable: true };
+  if ((0, import_fs25.existsSync)(cwd)) return { resumable: true };
   const ranInWorktree = /\/\.worktrees\//.test(cwd) || /\/\.claude\/worktrees\//.test(cwd);
   return {
     resumable: false,
@@ -145040,7 +145520,7 @@ function isBrewInstall(scriptPath = process.argv[1] ?? "") {
 var import_node_crypto4 = require("crypto");
 var import_node_fs8 = require("fs");
 var import_node_path10 = require("path");
-var import_promises18 = require("stream/promises");
+var import_promises20 = require("stream/promises");
 
 // src/updater/manifest.ts
 init_zod();
@@ -145115,7 +145595,7 @@ async function downloadAndVerify(opts) {
     }
   });
   try {
-    await (0, import_promises18.pipeline)(res.body.pipeThrough(measured), out);
+    await (0, import_promises20.pipeline)(res.body.pipeThrough(measured), out);
   } catch (err) {
     (0, import_node_fs8.rmSync)(targetPath, { force: true });
     throw err;
@@ -145301,7 +145781,7 @@ var import_node_fs17 = require("fs");
 
 // node_modules/tar/dist/esm/index.min.js
 var import_events4 = __toESM(require("events"), 1);
-var import_fs25 = __toESM(require("fs"), 1);
+var import_fs26 = __toESM(require("fs"), 1);
 var import_node_events3 = require("events");
 var import_node_stream3 = __toESM(require("stream"), 1);
 var import_node_string_decoder = require("string_decoder");
@@ -145315,8 +145795,8 @@ var Ps = __toESM(require("zlib"), 1);
 var import_zlib = __toESM(require("zlib"), 1);
 var import_node_path15 = require("path");
 var import_node_path16 = require("path");
-var import_fs26 = __toESM(require("fs"), 1);
 var import_fs27 = __toESM(require("fs"), 1);
+var import_fs28 = __toESM(require("fs"), 1);
 var import_path24 = __toESM(require("path"), 1);
 var import_node_path17 = require("path");
 var import_path25 = __toESM(require("path"), 1);
@@ -145325,11 +145805,11 @@ var import_node_assert = __toESM(require("assert"), 1);
 var import_node_crypto5 = require("crypto");
 var import_node_fs13 = __toESM(require("fs"), 1);
 var import_node_path18 = __toESM(require("path"), 1);
-var import_fs28 = __toESM(require("fs"), 1);
+var import_fs29 = __toESM(require("fs"), 1);
 var import_node_fs14 = __toESM(require("fs"), 1);
 var import_node_path19 = __toESM(require("path"), 1);
 var import_node_fs15 = __toESM(require("fs"), 1);
-var import_promises19 = __toESM(require("fs/promises"), 1);
+var import_promises21 = __toESM(require("fs/promises"), 1);
 var import_node_path20 = __toESM(require("path"), 1);
 var import_node_path21 = require("path");
 var import_node_fs16 = __toESM(require("fs"), 1);
@@ -145677,7 +146157,7 @@ var A = class extends import_node_events3.EventEmitter {
     return Wr;
   }
 };
-var Jr = import_fs25.default.writev;
+var Jr = import_fs26.default.writev;
 var ht = /* @__PURE__ */ Symbol("_autoClose");
 var H = /* @__PURE__ */ Symbol("_close");
 var te = /* @__PURE__ */ Symbol("_ended");
@@ -145732,7 +146212,7 @@ var _t = class extends A {
     throw new TypeError("this is a readable stream");
   }
   [at]() {
-    import_fs25.default.open(this[U2], "r", (t2, e) => this[Ht](t2, e));
+    import_fs26.default.open(this[U2], "r", (t2, e) => this[Ht](t2, e));
   }
   [Ht](t2, e) {
     t2 ? this[Ut](t2) : (this[u2] = e, this.emit("open", e), this[zt]());
@@ -145745,7 +146225,7 @@ var _t = class extends A {
       this[j] = true;
       let t2 = this[vi]();
       if (t2.length === 0) return process.nextTick(() => this[Ii](null, 0, t2));
-      import_fs25.default.read(this[u2], t2, 0, t2.length, null, (e, i, r) => this[Ii](e, i, r));
+      import_fs26.default.read(this[u2], t2, 0, t2.length, null, (e, i, r) => this[Ii](e, i, r));
     }
   }
   [Ii](t2, e, i) {
@@ -145754,7 +146234,7 @@ var _t = class extends A {
   [H]() {
     if (this[ht] && typeof this[u2] == "number") {
       let t2 = this[u2];
-      this[u2] = void 0, import_fs25.default.close(t2, (e) => e ? this.emit("error", e) : this.emit("close"));
+      this[u2] = void 0, import_fs26.default.close(t2, (e) => e ? this.emit("error", e) : this.emit("close"));
     }
   }
   [Ut](t2) {
@@ -145782,7 +146262,7 @@ var Be = class extends _t {
   [at]() {
     let t2 = true;
     try {
-      this[Ht](null, import_fs25.default.openSync(this[U2], "r")), t2 = false;
+      this[Ht](null, import_fs26.default.openSync(this[U2], "r")), t2 = false;
     } finally {
       t2 && this[H]();
     }
@@ -145793,7 +146273,7 @@ var Be = class extends _t {
       if (!this[j]) {
         this[j] = true;
         do {
-          let e = this[vi](), i = e.length === 0 ? 0 : import_fs25.default.readSync(this[u2], e, 0, e.length, null);
+          let e = this[vi](), i = e.length === 0 ? 0 : import_fs26.default.readSync(this[u2], e, 0, e.length, null);
           if (!this[ki](i, e)) break;
         } while (true);
         this[j] = false;
@@ -145806,7 +146286,7 @@ var Be = class extends _t {
   [H]() {
     if (this[ht] && typeof this[u2] == "number") {
       let t2 = this[u2];
-      this[u2] = void 0, import_fs25.default.closeSync(t2), this.emit("close");
+      this[u2] = void 0, import_fs26.default.closeSync(t2), this.emit("close");
     }
   }
 };
@@ -145848,7 +146328,7 @@ var et = class extends import_events4.default {
     this[H](), this[gt] = true, this.emit("error", t2);
   }
   [at]() {
-    import_fs25.default.open(this[U2], this[tt], this[ie], (t2, e) => this[Ht](t2, e));
+    import_fs26.default.open(this[U2], this[tt], this[ie], (t2, e) => this[Ht](t2, e));
   }
   [Ht](t2, e) {
     this[Me] && this[tt] === "r+" && t2 && t2.code === "ENOENT" ? (this[tt] = "w", this[at]()) : t2 ? this[Ut](t2) : (this[u2] = e, this.emit("open", e), this[gt] || this[Ai]());
@@ -145860,7 +146340,7 @@ var et = class extends import_events4.default {
     return typeof t2 == "string" && (t2 = Buffer.from(t2, e)), this[te] ? (this.emit("error", new Error("write() after end()")), false) : this[u2] === void 0 || this[gt] || this[Y2].length ? (this[Y2].push(t2), this[ke] = true, false) : (this[gt] = true, this[ve](t2), true);
   }
   [ve](t2) {
-    import_fs25.default.write(this[u2], t2, 0, t2.length, this[ot], (e, i) => this[Pt](e, i));
+    import_fs26.default.write(this[u2], t2, 0, t2.length, this[ot], (e, i) => this[Pt](e, i));
   }
   [Pt](t2, e) {
     t2 ? this[Ut](t2) : (this[ot] !== void 0 && typeof e == "number" && (this[ot] += e), this[Y2].length ? this[Ai]() : (this[gt] = false, this[te] && !this[Ni] ? (this[Ni] = true, this[H](), this.emit("finish")) : this[ke] && (this[ke] = false, this.emit("drain"))));
@@ -145876,7 +146356,7 @@ var et = class extends import_events4.default {
   [H]() {
     if (this[ht] && typeof this[u2] == "number") {
       let t2 = this[u2];
-      this[u2] = void 0, import_fs25.default.close(t2, (e) => e ? this.emit("error", e) : this.emit("close"));
+      this[u2] = void 0, import_fs26.default.close(t2, (e) => e ? this.emit("error", e) : this.emit("close"));
     }
   }
 };
@@ -145884,24 +146364,24 @@ var Wt = class extends et {
   [at]() {
     let t2;
     if (this[Me] && this[tt] === "r+") try {
-      t2 = import_fs25.default.openSync(this[U2], this[tt], this[ie]);
+      t2 = import_fs26.default.openSync(this[U2], this[tt], this[ie]);
     } catch (e) {
       if (e?.code === "ENOENT") return this[tt] = "w", this[at]();
       throw e;
     }
-    else t2 = import_fs25.default.openSync(this[U2], this[tt], this[ie]);
+    else t2 = import_fs26.default.openSync(this[U2], this[tt], this[ie]);
     this[Ht](null, t2);
   }
   [H]() {
     if (this[ht] && typeof this[u2] == "number") {
       let t2 = this[u2];
-      this[u2] = void 0, import_fs25.default.closeSync(t2), this.emit("close");
+      this[u2] = void 0, import_fs26.default.closeSync(t2), this.emit("close");
     }
   }
   [ve](t2) {
     let e = true;
     try {
-      this[Pt](null, import_fs25.default.writeSync(this[u2], t2, 0, t2.length, this[ot])), e = false;
+      this[Pt](null, import_fs26.default.writeSync(this[u2], t2, 0, t2.length, this[ot])), e = false;
     } finally {
       if (e) try {
         this[H]();
@@ -146819,7 +147299,7 @@ var de = class extends A {
     return t2 === "error" && (this.#t = true), super.emit(t2, ...e);
   }
   [ss]() {
-    import_fs27.default.lstat(this.absolute, (t2, e) => {
+    import_fs28.default.lstat(this.absolute, (t2, e) => {
       if (t2) return this.emit("error", t2);
       this[si](e);
     });
@@ -146857,7 +147337,7 @@ var de = class extends A {
     this.path.slice(-1) !== "/" && (this.path += "/"), this.stat.size = 0, this[fe](), this.end();
   }
   [is]() {
-    import_fs27.default.readlink(this.absolute, (t2, e) => {
+    import_fs28.default.readlink(this.absolute, (t2, e) => {
       if (t2) return this.emit("error", t2);
       this[ns](e);
     });
@@ -146880,7 +147360,7 @@ var de = class extends A {
     this[os]();
   }
   [os]() {
-    import_fs27.default.open(this.absolute, "r", (t2, e) => {
+    import_fs28.default.open(this.absolute, "r", (t2, e) => {
       if (t2) return this.emit("error", t2);
       this[hs](e);
     });
@@ -146895,14 +147375,14 @@ var de = class extends A {
   [ii]() {
     let { fd: t2, buf: e, offset: i, length: r, pos: n } = this;
     if (t2 === void 0 || e === void 0) throw new Error("cannot read file without first opening");
-    import_fs27.default.read(t2, e, i, r, n, (o, h) => {
+    import_fs28.default.read(t2, e, i, r, n, (o, h) => {
       if (o) return this[pt](() => this.emit("error", o));
       this[rs](h);
     });
   }
   [pt](t2 = () => {
   }) {
-    this.fd !== void 0 && import_fs27.default.close(this.fd, t2);
+    this.fd !== void 0 && import_fs28.default.close(this.fd, t2);
   }
   [rs](t2) {
     if (t2 <= 0 && this.remain > 0) {
@@ -146937,20 +147417,20 @@ var de = class extends A {
 var ni = class extends de {
   sync = true;
   [ss]() {
-    this[si](import_fs27.default.lstatSync(this.absolute));
+    this[si](import_fs28.default.lstatSync(this.absolute));
   }
   [is]() {
-    this[ns](import_fs27.default.readlinkSync(this.absolute));
+    this[ns](import_fs28.default.readlinkSync(this.absolute));
   }
   [os]() {
-    this[hs](import_fs27.default.openSync(this.absolute, "r"));
+    this[hs](import_fs28.default.openSync(this.absolute, "r"));
   }
   [ii]() {
     let t2 = true;
     try {
       let { fd: e, buf: i, offset: r, length: n, pos: o } = this;
       if (e === void 0 || i === void 0) throw new Error("fd and buf must be set in READ method");
-      let h = import_fs27.default.readSync(e, i, r, n, o);
+      let h = import_fs28.default.readSync(e, i, r, n, o);
       this[rs](h), t2 = false;
     } finally {
       if (t2) try {
@@ -146965,7 +147445,7 @@ var ni = class extends de {
   }
   [pt](t2 = () => {
   }) {
-    this.fd !== void 0 && import_fs27.default.closeSync(this.fd), t2();
+    this.fd !== void 0 && import_fs28.default.closeSync(this.fd), t2();
   }
 };
 var oi = class extends A {
@@ -147296,7 +147776,7 @@ var wt = class extends A {
   [ds](t2) {
     t2.pending = true, this[G2] += 1;
     let e = this.follow ? "stat" : "lstat";
-    import_fs26.default[e](t2.absolute, (i, r) => {
+    import_fs27.default[e](t2.absolute, (i, r) => {
       t2.pending = false, this[G2] -= 1, i ? this.emit("error", i) : this[li](t2, r);
     });
   }
@@ -147310,7 +147790,7 @@ var wt = class extends A {
     this[Ft]();
   }
   [ms](t2) {
-    t2.pending = true, this[G2] += 1, import_fs26.default.readdir(t2.absolute, (e, i) => {
+    t2.pending = true, this[G2] += 1, import_fs27.default.readdir(t2.absolute, (e, i) => {
       if (t2.pending = false, this[G2] -= 1, e) return this.emit("error", e);
       this[fi](t2, i);
     });
@@ -147411,10 +147891,10 @@ var kt = class extends wt {
   }
   [ds](t2) {
     let e = this.follow ? "statSync" : "lstatSync";
-    this[li](t2, import_fs26.default[e](t2.absolute));
+    this[li](t2, import_fs27.default[e](t2.absolute));
   }
   [ms](t2) {
-    this[fi](t2, import_fs26.default.readdirSync(t2.absolute));
+    this[fi](t2, import_fs27.default.readdirSync(t2.absolute));
   }
   [di](t2) {
     let e = t2.entry, i = this.zip;
@@ -147465,8 +147945,8 @@ var Qn = K2(Vn, $n, Xn, qn, (s3, t2) => {
 });
 var Jn = process.env.__FAKE_PLATFORM__ || process.platform;
 var Er = Jn === "win32";
-var { O_CREAT: wr, O_NOFOLLOW: mr, O_TRUNC: Sr, O_WRONLY: yr } = import_fs28.default.constants;
-var Rr = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs28.default.constants.UV_FS_O_FILEMAP || 0;
+var { O_CREAT: wr, O_NOFOLLOW: mr, O_TRUNC: Sr, O_WRONLY: yr } = import_fs29.default.constants;
+var Rr = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs29.default.constants.UV_FS_O_FILEMAP || 0;
 var jn = Er && !!Rr;
 var to = 512 * 1024;
 var eo = Rr | Sr | wr | yr;
@@ -147561,7 +148041,7 @@ var gr = (s3, t2, e) => {
     E2 ? e(E2) : x2 && a ? Es(x2, o, h, (Le) => S2(Le)) : n ? import_node_fs15.default.chmod(s3, r, e) : e();
   };
   if (s3 === d) return no(s3, S2);
-  if (l) return import_promises19.default.mkdir(s3, { mode: r, recursive: true }).then((E2) => S2(null, E2 ?? void 0), S2);
+  if (l) return import_promises21.default.mkdir(s3, { mode: r, recursive: true }).then((E2) => S2(null, E2 ?? void 0), S2);
   let D2 = f(import_node_path20.default.relative(d, s3)).split("/");
   Ss(d, D2, r, c, d, void 0, S2);
 };