@qwen-code/qwen-code 0.19.12 → 0.20.0-nightly.20260721.cda0e0348

package/chunks/{chunk-ZSDFNE6Y.js → chunk-RF34V75B.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   scanForSecrets
-} from "./chunk-GCY7QTCE.js";
+} from "./chunk-NO6XTCYT.js";
 import {
   isTeamAutoMemPath
-} from "./chunk-LPHGXXZX.js";
+} from "./chunk-JD3MKVKL.js";
 import {
   createDebugLogger
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-HCCR43AY.js → chunk-RFIAR4YL.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   Storage
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-RS7MT2QG.js

@@ -0,0 +1,305 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  stringWidth
+} from "./chunk-H2XVO6NE.js";
+import {
+  ansiRegex,
+  init_ansi_regex,
+  stripAnsi
+} from "./chunk-T4TZQJ7W.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/utils/textUtils.ts
+init_esbuild_shims();
+init_ansi_regex();
+import { stripVTControlCharacters } from "node:util";
+var getAsciiArtWidth = /* @__PURE__ */ __name((asciiArt) => {
+  if (!asciiArt) {
+    return 0;
+  }
+  const lines = asciiArt.split("\n");
+  return Math.max(...lines.map((line) => getCachedStringWidth(line)));
+}, "getAsciiArtWidth");
+var codePointsCache = /* @__PURE__ */ new Map();
+var MAX_STRING_LENGTH_TO_CACHE = 1e3;
+function toCodePoints(str) {
+  let isAscii = true;
+  for (let i = 0; i < str.length; i++) {
+    if (str.charCodeAt(i) > 127) {
+      isAscii = false;
+      break;
+    }
+  }
+  if (isAscii) {
+    return str.split("");
+  }
+  if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+    const cached = codePointsCache.get(str);
+    if (cached) {
+      return cached;
+    }
+  }
+  const result = Array.from(str);
+  if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+    codePointsCache.set(str, result);
+  }
+  return result;
+}
+__name(toCodePoints, "toCodePoints");
+function cpLen(str) {
+  return toCodePoints(str).length;
+}
+__name(cpLen, "cpLen");
+function cpSlice(str, start, end) {
+  const arr = toCodePoints(str).slice(start, end);
+  return arr.join("");
+}
+__name(cpSlice, "cpSlice");
+function stripUnsafeCharacters(str) {
+  const strippedAnsi = stripAnsi(str);
+  const strippedVT = stripVTControlCharacters(strippedAnsi);
+  return toCodePoints(strippedVT).filter((char) => {
+    const code = char.codePointAt(0);
+    if (code === void 0) return false;
+    if (code === 9 || code === 10 || code === 13) return true;
+    if (code >= 0 && code <= 31) return false;
+    if (code >= 128 && code <= 159) return false;
+    return true;
+  }).join("");
+}
+__name(stripUnsafeCharacters, "stripUnsafeCharacters");
+var stringWidthCache = /* @__PURE__ */ new Map();
+var getCachedStringWidth = /* @__PURE__ */ __name((str) => {
+  if (/^[\x20-\x7E]*$/.test(str)) {
+    return str.length;
+  }
+  if (stringWidthCache.has(str)) {
+    return stringWidthCache.get(str);
+  }
+  const width = stringWidth(str);
+  stringWidthCache.set(str, width);
+  return width;
+}, "getCachedStringWidth");
+var graphemeSegmenter = new Intl.Segmenter(void 0, {
+  granularity: "grapheme"
+});
+function truncateToWidth(text, maxWidth) {
+  if (maxWidth <= 0) {
+    return "";
+  }
+  if (getCachedStringWidth(text) <= maxWidth) {
+    return text;
+  }
+  const ellipsis = "\u2026";
+  const budget = Math.max(0, maxWidth - getCachedStringWidth(ellipsis));
+  let width = 0;
+  let result = "";
+  for (const { segment } of graphemeSegmenter.segment(text)) {
+    const segmentWidth = getCachedStringWidth(segment);
+    if (width + segmentWidth > budget) {
+      break;
+    }
+    result += segment;
+    width += segmentWidth;
+  }
+  return `${result}${ellipsis}`;
+}
+__name(truncateToWidth, "truncateToWidth");
+function wrapToVisualLines(text, width) {
+  if (width <= 0) {
+    return [""];
+  }
+  const visualLines = [];
+  for (const logicalLine of text.split("\n")) {
+    if (logicalLine === "") {
+      visualLines.push("");
+      continue;
+    }
+    let currentLine = "";
+    let currentWidth = 0;
+    for (const char of logicalLine) {
+      const charWidth = getCachedStringWidth(char);
+      if (currentWidth + charWidth > width && currentWidth > 0) {
+        visualLines.push(currentLine);
+        currentLine = "";
+        currentWidth = 0;
+      }
+      currentLine += char;
+      currentWidth += charWidth;
+    }
+    if (currentLine) {
+      visualLines.push(currentLine);
+    }
+  }
+  if (visualLines.length === 0) {
+    visualLines.push("");
+  }
+  return visualLines;
+}
+__name(wrapToVisualLines, "wrapToVisualLines");
+var regex = ansiRegex();
+var BARE_C0_CONTROL_CHARS_REGEX = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+var BIDI_OVERRIDE_CHARS_REGEX = /[\u200e\u200f\u202a-\u202e\u2066-\u2069]/g;
+function sanitizeTerminalText(value) {
+  return escapeAnsiCtrlCodes(value).replace(BARE_C0_CONTROL_CHARS_REGEX, "").replace(BIDI_OVERRIDE_CHARS_REGEX, "");
+}
+__name(sanitizeTerminalText, "sanitizeTerminalText");
+function escapeAnsiCtrlCodes(obj) {
+  if (typeof obj === "string") {
+    if (obj.search(regex) === -1) {
+      return obj;
+    }
+    regex.lastIndex = 0;
+    return obj.replace(
+      regex,
+      (match) => JSON.stringify(match).slice(1, -1)
+    );
+  }
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    let newArr = null;
+    for (let i = 0; i < obj.length; i++) {
+      const value = obj[i];
+      const escapedValue = escapeAnsiCtrlCodes(value);
+      if (escapedValue !== value) {
+        if (newArr === null) {
+          newArr = [...obj];
+        }
+        newArr[i] = escapedValue;
+      }
+    }
+    return newArr !== null ? newArr : obj;
+  }
+  let newObj = null;
+  const keys = Object.keys(obj);
+  for (const key of keys) {
+    const value = obj[key];
+    const escapedValue = escapeAnsiCtrlCodes(value);
+    if (escapedValue !== value) {
+      if (newObj === null) {
+        newObj = { ...obj };
+      }
+      newObj[key] = escapedValue;
+    }
+  }
+  return newObj !== null ? newObj : obj;
+}
+__name(escapeAnsiCtrlCodes, "escapeAnsiCtrlCodes");
+var SENSITIVE_PATTERNS = [
+  // API keys with common prefixes
+  {
+    pattern: /(sk-[a-zA-Z0-9]{20,})/g,
+    replacement: "sk-***REDACTED***"
+  },
+  {
+    pattern: /(api[_-]?key[_-]?[=:]\s*)[a-zA-Z0-9_-]{20,}/gi,
+    replacement: "$1***REDACTED***"
+  },
+  // Bearer tokens
+  {
+    pattern: /(Bearer\s+)[a-zA-Z0-9._-]+/gi,
+    replacement: "$1***REDACTED***"
+  },
+  // Generic tokens
+  {
+    pattern: /(token[_-]?[=:]\s*)[a-zA-Z0-9._-]{10,}/gi,
+    replacement: "$1***REDACTED***"
+  },
+  // Passwords in connection strings or assignments
+  {
+    pattern: /(password[_-]?[=:]\s*)[^\s]+/gi,
+    replacement: "$1***REDACTED***"
+  },
+  {
+    pattern: /(pwd[_-]?[=:]\s*)[^\s]+/gi,
+    replacement: "$1***REDACTED***"
+  },
+  // AWS keys
+  {
+    pattern: /(AKIA[A-Z0-9]{16})/g,
+    replacement: "***REDACTED***"
+  },
+  // Generic secret patterns
+  {
+    pattern: /(secret[_-]?[=:]\s*)[a-zA-Z0-9._-]{10,}/gi,
+    replacement: "$1***REDACTED***"
+  }
+];
+function sanitizeSensitiveText(text, maxLength = 200) {
+  let result = text;
+  for (const { pattern, replacement } of SENSITIVE_PATTERNS) {
+    result = result.replace(pattern, replacement);
+  }
+  if (result.length > maxLength) {
+    if (maxLength <= 3) {
+      return result.slice(0, maxLength);
+    }
+    return result.slice(0, maxLength - 3) + "...";
+  }
+  return result;
+}
+__name(sanitizeSensitiveText, "sanitizeSensitiveText");
+var FILENAME_CONTROL_CHARS_REGEX = /[\x00-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g;
+var MULTILINE_CONTROL_CHARS_REGEX = /[\x00-\x08\x0b-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g;
+function escapeControlChar(ch) {
+  switch (ch) {
+    case "\b":
+      return "\\b";
+    case "	":
+      return "\\t";
+    case "\n":
+      return "\\n";
+    case "\f":
+      return "\\f";
+    case "\r":
+      return "\\r";
+    default: {
+      const code = ch.charCodeAt(0);
+      return `\\u${code.toString(16).padStart(4, "0")}`;
+    }
+  }
+}
+__name(escapeControlChar, "escapeControlChar");
+function sanitizeFilenameForDisplay(name) {
+  return escapeAnsiCtrlCodes(name).replace(
+    FILENAME_CONTROL_CHARS_REGEX,
+    escapeControlChar
+  );
+}
+__name(sanitizeFilenameForDisplay, "sanitizeFilenameForDisplay");
+function sanitizeMultilineForDisplay(text) {
+  return escapeAnsiCtrlCodes(text).replace(
+    MULTILINE_CONTROL_CHARS_REGEX,
+    escapeControlChar
+  );
+}
+__name(sanitizeMultilineForDisplay, "sanitizeMultilineForDisplay");
+
+export {
+  getAsciiArtWidth,
+  toCodePoints,
+  cpLen,
+  cpSlice,
+  stripUnsafeCharacters,
+  getCachedStringWidth,
+  truncateToWidth,
+  wrapToVisualLines,
+  sanitizeTerminalText,
+  escapeAnsiCtrlCodes,
+  sanitizeSensitiveText,
+  sanitizeFilenameForDisplay,
+  sanitizeMultilineForDisplay
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-BKNPMEN6.js → chunk-RVLZCXEE.js}

@@ -461,6 +461,12 @@ var AcpBridge = class extends EventEmitter {
           break;
         }
         const content = update["content"];
+        if (meta?.["qwenDiscreteMessage"] === true) {
+          if (meta["source"] === "background_notification_response" && meta["rewritten"] !== true && content?.type === "text" && content.text) {
+            this.emit("backgroundResponse", sessionId, content.text);
+          }
+          break;
+        }
         if (content?.type === "text" && content.text) {
           this.emit(meta?.["source"] === "slash_command" ? "slashCommandOutput" : "textChunk", sessionId, content.text);
         }
@@ -1080,6 +1086,12 @@ var DaemonChannelBridge = class extends EventEmitter2 {
           break;
         }
         const text = getTextContent(update["content"]);
+        if (meta?.["qwenDiscreteMessage"] === true) {
+          if (meta["source"] === "background_notification_response" && meta["rewritten"] !== true && text) {
+            this.emit("backgroundResponse", sessionId, text);
+          }
+          break;
+        }
         if (text) {
           this.emit(meta?.["source"] === "slash_command" ? "slashCommandOutput" : "textChunk", sessionId, text);
         }
@@ -3146,16 +3158,29 @@ function truncateEntryToRecallBudget(entry) {
 }
 __name(truncateEntryToRecallBudget, "truncateEntryToRecallBudget");
 function selectRelevantChannelMemory(message, entries) {
+  return selectRelevantChannelMemoryFromIndex(message, createChannelMemoryRecallIndex(entries));
+}
+__name(selectRelevantChannelMemory, "selectRelevantChannelMemory");
+function createChannelMemoryRecallIndex(entries) {
+  return {
+    candidates: entries.map((entry, index) => {
+      const normalized = normalize(entry.text);
+      return {
+        entry: { ...entry },
+        index,
+        entryTerms: terms(normalized),
+        normalizedLength: Array.from(normalized).length
+      };
+    })
+  };
+}
+__name(createChannelMemoryRecallIndex, "createChannelMemoryRecallIndex");
+function selectRelevantChannelMemoryFromIndex(message, recallIndex) {
   const messageTerms = terms(normalize(message));
-  const candidates = entries.map((entry, index) => {
-    const normalized = normalize(entry.text);
-    return {
-      entry,
-      index,
-      score: overlapSize(messageTerms, terms(normalized)),
-      normalizedLength: Array.from(normalized).length
-    };
-  });
+  const candidates = recallIndex.candidates.map((candidate) => ({
+    ...candidate,
+    score: overlapSize(messageTerms, candidate.entryTerms)
+  }));
   const positive = candidates.filter(({ score }) => score > 0).sort((left, right) => right.score - left.score || left.index - right.index);
   const fallback = candidates.filter(({ score, normalizedLength }) => score === 0 && normalizedLength <= CHANNEL_MEMORY_RECALL_FALLBACK_CODE_POINTS);
   const selected = [];
@@ -3176,10 +3201,11 @@ function selectRelevantChannelMemory(message, entries) {
   }
   return selected;
 }
-__name(selectRelevantChannelMemory, "selectRelevantChannelMemory");
+__name(selectRelevantChannelMemoryFromIndex, "selectRelevantChannelMemoryFromIndex");
 
 // packages/channels/base/dist/ChannelBase.js
 var CLEAR_CANCEL_TIMEOUT_MS = 3e3;
+var CHANNEL_MEMORY_RECALL_CACHE_MAX_TARGETS = 128;
 var GROUP_HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
 var CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
 var GROUP_HISTORY_ENTRY_TEXT_LIMIT = 1e3;
@@ -3253,6 +3279,7 @@ var ChannelBase = class {
   proxy;
   channelMemory;
   memoryIntentClassifier;
+  channelMemoryRecallObserver;
   groupHistory;
   loopController;
   observedContacts;
@@ -3260,6 +3287,7 @@ var ChannelBase = class {
   instructedSessions = /* @__PURE__ */ new Set();
   unattendedMemorySessions = /* @__PURE__ */ new Set();
   channelMemoryReads = /* @__PURE__ */ new Map();
+  channelMemoryRecallCache = /* @__PURE__ */ new Map();
   commands = /* @__PURE__ */ new Map();
   /** Per-session promise chain to serialize prompt + send (followup mode). */
   sessionQueues = /* @__PURE__ */ new Map();
@@ -3280,6 +3308,12 @@ var ChannelBase = class {
   bridgeToolCallListener = /* @__PURE__ */ __name((event) => {
     this.dispatchToolCall(event);
   }, "bridgeToolCallListener");
+  bridgeBackgroundResponseListener = /* @__PURE__ */ __name((sessionId, text) => {
+    void this.dispatchBackgroundResponse(sessionId, text).catch((err) => {
+      process.stderr.write(`[${this.name}] background response delivery failed for session ${sanitizeLogText(sessionId, 128)}: ${this.lifecycleError(err)}
+`);
+    });
+  }, "bridgeBackgroundResponseListener");
   bridgeSessionDiedListener = /* @__PURE__ */ __name((event) => {
     this.onSessionDied(event.sessionId);
   }, "bridgeSessionDiedListener");
@@ -3323,6 +3357,17 @@ var ChannelBase = class {
     }
     this.onToolCall(chatId, event);
   }
+  async dispatchBackgroundResponse(sessionId, text) {
+    const target = this.router.getTarget(sessionId);
+    if (!target || target.channelName !== this.name || text.trim().length === 0) {
+      return;
+    }
+    if (this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
+      await this.pushProactive(target, text);
+      return;
+    }
+    await this.sendResponseMessage(target.chatId, text, sessionId);
+  }
   async dispatchPermissionRequest(event) {
     const target = this.permissionTargetForEvent(event);
     if (!target) {
@@ -3404,6 +3449,7 @@ var ChannelBase = class {
     this.memoryScope = Object.freeze(this.resolveMemoryScope(name, config));
     this.channelMemory = options?.channelMemory;
     this.memoryIntentClassifier = options?.memoryIntentClassifier;
+    this.channelMemoryRecallObserver = options?.channelMemoryRecallObserver;
     this.groupHistory = new GroupHistoryStore(options?.groupHistoryPath ?? join5(getGlobalQwenDir(), "channels", `${encodeURIComponent(name)}-group-history.jsonl`));
     this.loopController = options?.loopController;
     this.observedContacts = options?.observedContacts;
@@ -3588,6 +3634,99 @@ var ChannelBase = class {
       this.channelMemoryReads.delete(token.key);
     }
   }
+  getCachedChannelMemoryRecallIndex(key, revision) {
+    const cached = this.channelMemoryRecallCache.get(key);
+    if (!cached || cached.revision !== revision)
+      return void 0;
+    this.channelMemoryRecallCache.delete(key);
+    this.channelMemoryRecallCache.set(key, cached);
+    return cached.index;
+  }
+  setCachedChannelMemoryRecallIndex(key, revision, index) {
+    this.channelMemoryRecallCache.delete(key);
+    this.channelMemoryRecallCache.set(key, { revision, index });
+    if (this.channelMemoryRecallCache.size > CHANNEL_MEMORY_RECALL_CACHE_MAX_TARGETS) {
+      const oldestKey = this.channelMemoryRecallCache.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.channelMemoryRecallCache.delete(oldestKey);
+      }
+    }
+  }
+  async selectRelevantChannelMemory(envelope, target, read) {
+    const message = envelope.text;
+    const channelMemory = this.channelMemory;
+    if (!channelMemory)
+      return { entries: [], cache: "bypass" };
+    if (!channelMemory.getChannelMemoryRevision) {
+      const entries = await channelMemory.listChannelMemoryEntries(target);
+      return {
+        entries: selectRelevantChannelMemory(message, entries),
+        cache: "bypass"
+      };
+    }
+    let revision;
+    try {
+      revision = await channelMemory.getChannelMemoryRevision(target);
+    } catch {
+      const entries = await channelMemory.listChannelMemoryEntries(target);
+      return {
+        entries: selectRelevantChannelMemory(message, entries),
+        cache: "bypass"
+      };
+    }
+    let latestEntries = [];
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const cached = this.getCachedChannelMemoryRecallIndex(read.key, revision);
+      if (cached) {
+        return {
+          entries: selectRelevantChannelMemoryFromIndex(message, cached),
+          cache: "hit"
+        };
+      }
+      latestEntries = await channelMemory.listChannelMemoryEntries(target);
+      let verifiedRevision;
+      try {
+        verifiedRevision = await channelMemory.getChannelMemoryRevision(target);
+      } catch {
+        return {
+          entries: selectRelevantChannelMemory(message, latestEntries),
+          cache: "bypass"
+        };
+      }
+      if (revision !== verifiedRevision) {
+        if (read.generation !== read.state.generation) {
+          return { entries: [], cache: "miss" };
+        }
+        revision = verifiedRevision;
+        continue;
+      }
+      const index = createChannelMemoryRecallIndex(latestEntries);
+      if (read.generation === read.state.generation) {
+        this.setCachedChannelMemoryRecallIndex(read.key, revision, index);
+      }
+      return {
+        entries: selectRelevantChannelMemoryFromIndex(message, index),
+        cache: "miss"
+      };
+    }
+    this.logChannelMemoryError("read", envelope, "recall revision unstable after retry");
+    return {
+      entries: selectRelevantChannelMemory(message, latestEntries),
+      cache: "miss",
+      result: "revision_unstable"
+    };
+  }
+  observeChannelMemoryRecall(startedAt, cache, result, selectedCount) {
+    try {
+      this.channelMemoryRecallObserver?.({
+        durationMs: Math.max(0, performance.now() - startedAt),
+        selectedCount: Math.min(CHANNEL_MEMORY_RECALL_MAX_ENTRIES, Math.max(0, Math.trunc(selectedCount))),
+        cache,
+        result
+      });
+    } catch {
+    }
+  }
   drainCollectBufferForCurrentPrompt(sessionId, stillCurrent, taskLabel) {
     const buffer = this.collectBuffers.get(sessionId);
     if (!stillCurrent || !buffer || buffer.length === 0) {
@@ -4175,12 +4314,14 @@ ${promptText}` : promptText;
   }
   attachBridgeEvents(bridge) {
     bridge.on("toolCall", this.bridgeToolCallListener);
+    bridge.on("backgroundResponse", this.bridgeBackgroundResponseListener);
     bridge.on("sessionDied", this.bridgeSessionDiedListener);
     bridge.on("permissionRequest", this.bridgePermissionRequestListener);
     bridge.on("permissionResolved", this.bridgePermissionResolvedListener);
   }
   detachBridgeEvents(bridge) {
     bridge.off("toolCall", this.bridgeToolCallListener);
+    bridge.off("backgroundResponse", this.bridgeBackgroundResponseListener);
     bridge.off("sessionDied", this.bridgeSessionDiedListener);
     bridge.off("permissionRequest", this.bridgePermissionRequestListener);
     bridge.off("permissionResolved", this.bridgePermissionResolvedListener);
@@ -4935,7 +5076,9 @@ ${requestList}`);
   }
   invalidateUnattendedMemory(envelope) {
     const target = this.channelMemoryTarget(envelope);
-    const activeRead = this.channelMemoryReads.get(this.channelMemoryReadKey(target));
+    const readKey = this.channelMemoryReadKey(target);
+    this.channelMemoryRecallCache.delete(readKey);
+    const activeRead = this.channelMemoryReads.get(readKey);
     if (activeRead) {
       activeRead.generation += 1;
     }
@@ -5896,18 +6039,20 @@ ${promptText}`;
       if (!recognizedSlashCommand && this.channelMemory && this.shouldInjectChannelMemory()) {
         const memoryTarget = this.channelMemoryTarget(envelope);
         recallRead = this.beginChannelMemoryRead(memoryTarget);
+        const recallStartedAt = performance.now();
         try {
-          const entries = [
-            ...await this.channelMemory.listChannelMemoryEntries(memoryTarget)
-          ];
-          const relevantEntries = selectRelevantChannelMemory(envelope.text, entries);
+          const selection = await this.selectRelevantChannelMemory(envelope, memoryTarget, recallRead);
+          const stale = recallRead.generation !== recallRead.state.generation;
+          const relevantEntries = stale ? [] : selection.entries;
+          this.observeChannelMemoryRecall(recallStartedAt, selection.cache, stale ? "stale" : selection.result ?? (relevantEntries.length > 0 ? "selected" : "empty"), relevantEntries.length);
           if (relevantEntries.length > 0) {
             recallContext = this.formatRelevantChannelMemoryContext(relevantEntries);
           }
-        } catch (error) {
+        } catch {
+          this.observeChannelMemoryRecall(recallStartedAt, "bypass", "read_error", 0);
           this.releaseChannelMemoryRead(recallRead);
           recallRead = void 0;
-          this.logChannelMemoryError("read", envelope, this.channelMemoryErrorMessage(error));
+          this.logChannelMemoryError("read", envelope, "entry listing failed");
         }
       }
       if (this.dropQueuedTurnIfStale(sessionId, generation, envelope)) {

package/chunks/chunk-SV5PQVQE.js

@@ -0,0 +1,71 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __commonJS,
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// node_modules/react/cjs/react-jsx-runtime.production.js
+var require_react_jsx_runtime_production = __commonJS({
+  "node_modules/react/cjs/react-jsx-runtime.production.js"(exports) {
+    "use strict";
+    init_esbuild_shims();
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+    var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+    function jsxProd(type, config, maybeKey) {
+      var key = null;
+      void 0 !== maybeKey && (key = "" + maybeKey);
+      void 0 !== config.key && (key = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          "key" !== propName && (maybeKey[propName] = config[propName]);
+      } else maybeKey = config;
+      config = maybeKey.ref;
+      return {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        ref: void 0 !== config ? config : null,
+        props: maybeKey
+      };
+    }
+    __name(jsxProd, "jsxProd");
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.jsx = jsxProd;
+    exports.jsxs = jsxProd;
+  }
+});
+
+// node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS({
+  "node_modules/react/jsx-runtime.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    if (true) {
+      module.exports = require_react_jsx_runtime_production();
+    } else {
+      module.exports = null;
+    }
+  }
+});
+
+export {
+  require_jsx_runtime
+};
+/*! Bundled license information:
+
+react/cjs/react-jsx-runtime.production.js:
+  (**
+   * @license React
+   * react-jsx-runtime.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/