@qwen-code/qwen-code 0.19.6 → 0.19.7

package/chunks/{chunk-3VJ7MT3N.js → chunk-EXPMGZZV.js}

@@ -40,6 +40,11 @@ function ndJsonStream(output, input, hooks) {
       try {
         await writer.write(frame);
         callHook(hooks?.onMessageSent, payload.byteLength);
+        callHook(hooks?.onMessageObserved, {
+          direction: "sent",
+          bytes: payload.byteLength,
+          message
+        });
       } finally {
         writer.releaseLock();
       }
@@ -83,7 +88,13 @@ function handleLine(lineBytes, controller, textDecoder, hooks) {
   try {
     const message = JSON.parse(trimmedLine);
     controller.enqueue(message);
-    callHook(hooks?.onMessageReceived, jsonPayloadByteLength(lineBytes));
+    const bytes = jsonPayloadByteLength(lineBytes);
+    callHook(hooks?.onMessageReceived, bytes);
+    callHook(hooks?.onMessageObserved, {
+      direction: "received",
+      bytes,
+      message
+    });
   } catch (err) {
     console.error("Failed to parse JSON message:", trimmedLine, err);
   }
@@ -93,9 +104,9 @@ function jsonPayloadByteLength(lineBytes) {
   return lineBytes[lineBytes.byteLength - 1] === 13 ? lineBytes.byteLength - 1 : lineBytes.byteLength;
 }
 __name(jsonPayloadByteLength, "jsonPayloadByteLength");
-function callHook(hook, bytes) {
+function callHook(hook, value) {
   try {
-    hook?.(bytes);
+    hook?.(value);
   } catch {
   }
 }

package/chunks/{chunk-RZORUN6X.js → chunk-FEJ2FZ3U.js}

@@ -5,7 +5,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MJKMIQMK.js";
+} from "./chunk-X3YGAX7V.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-OIFSBXSP.js → chunk-FRFFNYUY.js}

@@ -6,16 +6,16 @@ import {
 import {
   JsonFormatter,
   parseAndFormatApiError
-} from "./chunk-AGZF43UV.js";
+} from "./chunk-YEGT55NW.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
   FatalTurnLimitedError,
   createDebugLogger
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   runExitCleanup
-} from "./chunk-ZO5EA3XJ.js";
+} from "./chunk-4UCTWSTP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-MHQKYQDS.js → chunk-FTFXDZYI.js}

@@ -2,16 +2,19 @@
 "use strict";
 import {
   getEffectiveSupportedModes
-} from "./chunk-GQBRGBLS.js";
+} from "./chunk-B4U2M63D.js";
 import {
   require_jsx_runtime
-} from "./chunk-YSU33ACT.js";
+} from "./chunk-DGHJTO2K.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
+import {
+  getCachedStringWidth
+} from "./chunk-GL5TV7B5.js";
 import {
   uiTelemetryService
-} from "./chunk-JN2VJ33O.js";
+} from "./chunk-GMOWQOQQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -370,6 +373,153 @@ function getCommandSubcommandNames(command) {
 }
 __name(getCommandSubcommandNames, "getCommandSubcommandNames");
 
+// packages/cli/src/ui/utils/pending-rendered-height.ts
+init_esbuild_shims();
+var TABLE_CHROME_ROWS = 5;
+var TABLE_ROW_RE = /^\s*\|(.+)\|\s*$/;
+var TABLE_SEPARATOR_RE = /^(?=.*\|)\s*\|?\s*(:?-+:?)\s*(\|\s*(:?-+:?)\s*)*\|?\s*$/;
+var CODE_FENCE_RE = /^ *(`{3,}|~{3,}) *([^`]*)$/;
+var INLINE_MATH_MAX_CHARS = 1024;
+var TABLE_INLINE_MATH_SPAN_RE = new RegExp(
+  String.raw`(?<![\w$])\$(?![\s\d$])(?=[^$\n]{1,${INLINE_MATH_MAX_CHARS}}\S\$)[^$\n]{1,${INLINE_MATH_MAX_CHARS}}\$(?![\w$])`,
+  "y"
+);
+function readTableInlineMathSpan(row, index) {
+  TABLE_INLINE_MATH_SPAN_RE.lastIndex = index;
+  return TABLE_INLINE_MATH_SPAN_RE.exec(row)?.[0] ?? null;
+}
+__name(readTableInlineMathSpan, "readTableInlineMathSpan");
+function splitMarkdownTableRow(row) {
+  const cells = [];
+  let current = "";
+  let activeCodeFenceLength = 0;
+  for (let index = 0; index < row.length; index++) {
+    const char = row[index];
+    if (char === "\\") {
+      const next = row[index + 1];
+      if (next === "|") {
+        current += "|";
+        index += 1;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === "`") {
+      let runLength = 1;
+      while (row[index + runLength] === "`") {
+        runLength += 1;
+      }
+      if (activeCodeFenceLength === 0) {
+        activeCodeFenceLength = runLength;
+      } else if (runLength === activeCodeFenceLength) {
+        activeCodeFenceLength = 0;
+      }
+      current += "`".repeat(runLength);
+      index += runLength - 1;
+      continue;
+    }
+    if (char === "$" && activeCodeFenceLength === 0) {
+      const mathSpan = readTableInlineMathSpan(row, index);
+      if (mathSpan) {
+        current += mathSpan;
+        index += mathSpan.length - 1;
+        continue;
+      }
+    }
+    if (char === "|" && activeCodeFenceLength === 0) {
+      cells.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  cells.push(current.trim());
+  return cells;
+}
+__name(splitMarkdownTableRow, "splitMarkdownTableRow");
+function estimateWrappedRows(line, width) {
+  if (width <= 0) return 1;
+  return Math.max(1, Math.ceil(getCachedStringWidth(line) / width));
+}
+__name(estimateWrappedRows, "estimateWrappedRows");
+function isTableStart(lines, i) {
+  const header = lines[i];
+  if (header === void 0 || i + 1 >= lines.length) return false;
+  const headerMatch = TABLE_ROW_RE.exec(header);
+  if (!headerMatch) return false;
+  const separator = lines[i + 1];
+  if (!TABLE_SEPARATOR_RE.test(separator)) return false;
+  const headerCols = splitMarkdownTableRow(headerMatch[1]).length;
+  const sepCols = splitMarkdownTableRow(separator).filter(
+    (cell) => cell.length > 0
+  ).length;
+  return headerCols === sepCols;
+}
+__name(isTableStart, "isTableStart");
+function fitPendingSlice(allLines, contentWidth, budget, tableClampRows) {
+  let rendered = 0;
+  let kept = allLines.length;
+  let codeFence = "";
+  for (let i = 0; i < allLines.length; ) {
+    const line = allLines[i];
+    const fenceMatch = CODE_FENCE_RE.exec(line);
+    if (codeFence) {
+      if (fenceMatch && fenceMatch[1].startsWith(codeFence[0]) && fenceMatch[1].length >= codeFence.length) {
+        codeFence = "";
+      }
+      rendered += estimateWrappedRows(line, contentWidth);
+      if (rendered > budget) {
+        kept = i;
+        break;
+      }
+      i++;
+      continue;
+    }
+    if (fenceMatch) {
+      codeFence = fenceMatch[1];
+      rendered += estimateWrappedRows(line, contentWidth);
+      if (rendered > budget) {
+        kept = i;
+        break;
+      }
+      i++;
+      continue;
+    }
+    if (isTableStart(allLines, i)) {
+      let j = i + 2;
+      while (j < allLines.length && TABLE_ROW_RE.test(allLines[j])) j++;
+      const dataRows = j - (i + 2);
+      const colCount = splitMarkdownTableRow(
+        TABLE_ROW_RE.exec(allLines[i])[1]
+      ).length;
+      const minHorizontalWidth = Math.max(24, 6 * colCount + 5);
+      const usesVertical = contentWidth < minHorizontalWidth;
+      const rows = usesVertical ? dataRows * colCount + Math.max(0, dataRows - 1) + 2 : 2 * dataRows + TABLE_CHROME_ROWS;
+      const cost = Math.min(rows, tableClampRows);
+      if (rendered + cost > budget && i > 0) {
+        kept = i;
+        break;
+      }
+      rendered += cost;
+      i = j;
+      if (rendered >= budget) {
+        kept = j;
+        break;
+      }
+    } else {
+      rendered += estimateWrappedRows(line, contentWidth);
+      if (rendered > budget) {
+        kept = i;
+        break;
+      }
+      i++;
+    }
+  }
+  return { keptLines: kept, clipped: kept < allLines.length };
+}
+__name(fitPendingSlice, "fitPendingSlice");
+
 // packages/cli/src/ui/constants.ts
 init_esbuild_shims();
 var EstimatedArtWidth = 59;
@@ -388,6 +538,11 @@ var TOOL_STATUS = {
 };
 
 export {
+  TABLE_ROW_RE,
+  TABLE_SEPARATOR_RE,
+  CODE_FENCE_RE,
+  splitMarkdownTableRow,
+  fitPendingSlice,
   SHELL_COMMAND_NAME,
   SHELL_NAME,
   TOOL_STATUS,

package/chunks/{chunk-DMSNJDWG.js → chunk-FV7425LN.js}

@@ -5,11 +5,11 @@ import {
 } from "./chunk-OMX7CUOE.js";
 import {
   atomicWriteJSON
-} from "./chunk-T42ACHFI.js";
+} from "./chunk-7LTB54MK.js";
 import {
   Storage,
   getProjectHash
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -21,6 +21,22 @@ import {
 init_esbuild_shims();
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+var MAX_TASK_RUNS = 20;
+function appendCronRun(runs, entry) {
+  const base = Array.isArray(runs) ? runs : [];
+  const next = [...base, entry];
+  return next.length > MAX_TASK_RUNS ? next.slice(next.length - MAX_TASK_RUNS) : next;
+}
+__name(appendCronRun, "appendCronRun");
+function generateCronTaskId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  for (let i = 0; i < 8; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return id;
+}
+__name(generateCronTaskId, "generateCronTaskId");
 var TASKS_FILENAME = "scheduled_tasks.json";
 var CRON_TASKS_DISPLAY_PATH = `~/.qwen/tmp/<project-hash>/${TASKS_FILENAME}`;
 var UPDATE_LOCK_RETRY_MS = 15;
@@ -164,14 +180,33 @@ function isFiniteTimestamp(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
 __name(isFiniteTimestamp, "isFiniteTimestamp");
+function isValidRuns(value) {
+  if (!Array.isArray(value)) return false;
+  return value.every((entry) => {
+    if (typeof entry !== "object" || entry === null) return false;
+    const run = entry;
+    return isFiniteTimestamp(run["at"]) && (run["kind"] === void 0 || typeof run["kind"] === "string") && (run["sessionId"] === void 0 || typeof run["sessionId"] === "string");
+  });
+}
+__name(isValidRuns, "isValidRuns");
 function isValidTask(value) {
   if (typeof value !== "object" || value === null) return false;
   const obj = value;
-  return typeof obj["id"] === "string" && typeof obj["cron"] === "string" && typeof obj["prompt"] === "string" && typeof obj["recurring"] === "boolean" && isFiniteTimestamp(obj["createdAt"]) && (obj["lastFiredAt"] === null || isFiniteTimestamp(obj["lastFiredAt"]));
+  return typeof obj["id"] === "string" && typeof obj["cron"] === "string" && typeof obj["prompt"] === "string" && typeof obj["recurring"] === "boolean" && isFiniteTimestamp(obj["createdAt"]) && (obj["lastFiredAt"] === null || isFiniteTimestamp(obj["lastFiredAt"])) && // Optional fields (added for the management UI): absent is valid and
+  // means "unnamed" / "enabled". Present-but-wrong-type routes through
+  // the same fix-or-delete contract as any other corrupt field rather
+  // than being silently coerced or dropped.
+  (obj["name"] === void 0 || typeof obj["name"] === "string") && (obj["enabled"] === void 0 || typeof obj["enabled"] === "boolean") && (obj["disabledByArchive"] === void 0 || typeof obj["disabledByArchive"] === "boolean") && // A bound sessionId must be a NON-EMPTY string: an empty string would pass
+  // a bare `typeof` check but the scheduler's truthy `task.sessionId` guard
+  // would treat it as unbound, so a "bound" task would silently run unbound.
+  (obj["sessionId"] === void 0 || typeof obj["sessionId"] === "string" && obj["sessionId"].length > 0) && (obj["runs"] === void 0 || isValidRuns(obj["runs"]));
 }
 __name(isValidTask, "isValidTask");
 
 export {
+  MAX_TASK_RUNS,
+  appendCronRun,
+  generateCronTaskId,
   CRON_TASKS_DISPLAY_PATH,
   getCronFilePath,
   readCronTasks,

package/chunks/{chunk-ALX6BUYW.js → chunk-G7ZG7CA6.js}

@@ -11,6 +11,7 @@ import {
 init_esbuild_shims();
 var EVENT_SCHEMA_VERSION = 1;
 var DEFAULT_MAX_QUEUED = 256;
+var DEFAULT_MAX_QUEUED_BYTES = 2 * 1024 * 1024;
 var DEFAULT_RING_SIZE = 8e3;
 var WARN_THRESHOLD_RATIO = 0.75;
 var WARN_RESET_RATIO = 0.375;
@@ -20,6 +21,55 @@ function getServerTimestamp(meta) {
   return typeof existing === "number" && Number.isFinite(existing) ? existing : Date.now();
 }
 __name(getServerTimestamp, "getServerTimestamp");
+function normalizeMaxQueuedBytes(value) {
+  if (value === void 0) return DEFAULT_MAX_QUEUED_BYTES;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError("maxQueuedBytes must be a positive safe integer");
+  }
+  return value;
+}
+__name(normalizeMaxQueuedBytes, "normalizeMaxQueuedBytes");
+function serializedByteLength(event) {
+  try {
+    const serialized = JSON.stringify(event);
+    if (serialized === void 0) return 0;
+    return Buffer.byteLength(serialized, "utf8");
+  } catch {
+    logEventSizingFailed(event.type);
+    return 0;
+  }
+}
+__name(serializedByteLength, "serializedByteLength");
+function logEventSizingFailed(type) {
+  try {
+    process.stderr.write(
+      `qwen serve: EventBus event sizing failed ${JSON.stringify({ type })}
+`
+    );
+  } catch {
+  }
+}
+__name(logEventSizingFailed, "logEventSizingFailed");
+function logSubscriberEvicted(data) {
+  try {
+    process.stderr.write(
+      `qwen serve: EventBus subscriber evicted ${JSON.stringify(data)}
+`
+    );
+  } catch {
+  }
+}
+__name(logSubscriberEvicted, "logSubscriberEvicted");
+function logSlowClientWarning(data) {
+  try {
+    process.stderr.write(
+      `qwen serve: EventBus slow_client_warning ${JSON.stringify(data)}
+`
+    );
+  } catch {
+  }
+}
+__name(logSlowClientWarning, "logSlowClientWarning");
 var SubscriberLimitExceededError = class extends Error {
   static {
     __name(this, "SubscriberLimitExceededError");
@@ -32,10 +82,11 @@ var SubscriberLimitExceededError = class extends Error {
   }
 };
 var EventBus = class {
-  constructor(ringSize = DEFAULT_RING_SIZE, maxSubscribers = DEFAULT_MAX_SUBSCRIBERS, compactionEngine) {
+  constructor(ringSize = DEFAULT_RING_SIZE, maxSubscribers = DEFAULT_MAX_SUBSCRIBERS, compactionEngine, opts = {}) {
     this.ringSize = ringSize;
     this.maxSubscribers = maxSubscribers;
     this.compactionEngine = compactionEngine;
+    this.maxQueuedBytes = normalizeMaxQueuedBytes(opts.maxQueuedBytes);
   }
   static {
     __name(this, "EventBus");
@@ -43,6 +94,7 @@ var EventBus = class {
   nextId = 1;
   ring = [];
   subs = /* @__PURE__ */ new Set();
+  maxQueuedBytes;
   closed = false;
   snapshotReplay() {
     return this.compactionEngine?.snapshot();
@@ -55,6 +107,30 @@ var EventBus = class {
   get subscriberCount() {
     return this.subs.size;
   }
+  seedReplayEvents(inputs) {
+    if (this.closed) return [];
+    if (inputs.length === 0) return [];
+    const events = [];
+    for (const input of inputs) {
+      const existingMeta = input._meta;
+      const event = {
+        id: this.nextId++,
+        v: EVENT_SCHEMA_VERSION,
+        ...input,
+        _meta: {
+          ...existingMeta ?? {},
+          serverTimestamp: getServerTimestamp(existingMeta)
+        }
+      };
+      events.push(event);
+      try {
+        this.compactionEngine?.ingest(event);
+      } catch {
+      }
+    }
+    this.ring.length = 0;
+    return events;
+  }
   /**
    * Publish an event to the bus. Returns the constructed `BridgeEvent`
    * (with `id` + `v` assigned) on success, or `undefined` when the
@@ -87,38 +163,64 @@ var EventBus = class {
     } catch {
     }
     if (this.ring.length > this.ringSize) this.ring.shift();
+    let eventBytes;
+    const getEventBytes = /* @__PURE__ */ __name(() => {
+      eventBytes ??= serializedByteLength(event);
+      return eventBytes;
+    }, "getEventBytes");
     for (const sub of Array.from(this.subs)) {
       if (sub.evicted) continue;
-      if (!sub.queue.push(event)) {
+      const pushResult = sub.queue.push(event, getEventBytes);
+      if (!pushResult.ok) {
         sub.evicted = true;
+        const evictionData = {
+          reason: pushResult.reason,
+          droppedAfter: event.id,
+          queueSize: pushResult.liveSize,
+          maxQueued: sub.maxQueued,
+          queuedBytes: pushResult.liveBytes,
+          maxQueuedBytes: sub.maxQueuedBytes,
+          ...pushResult.reason === "queue_bytes_overflow" ? { eventBytes: pushResult.eventBytes } : {}
+        };
+        logSubscriberEvicted(evictionData);
         const evictionFrame = {
           v: EVENT_SCHEMA_VERSION,
           type: "client_evicted",
-          data: { reason: "queue_overflow", droppedAfter: event.id }
+          data: evictionData
         };
         sub.queue.forcePush(evictionFrame);
         sub.queue.close();
         sub.dispose();
         continue;
       }
-      const liveSize = sub.queue.size;
-      if (!sub.warned && liveSize >= sub.warnThreshold) {
+      const liveSize = pushResult.liveSize;
+      const liveBytes = pushResult.liveBytes;
+      if (sub.warned && liveSize <= sub.warnResetThreshold && liveBytes <= sub.warnBytesResetThreshold) {
+        sub.warned = false;
+      }
+      const frameThresholdReached = liveSize >= sub.warnThreshold;
+      const byteThresholdReached = liveBytes >= sub.warnBytesThreshold;
+      if (!sub.warned && (frameThresholdReached || byteThresholdReached)) {
         sub.warned = true;
+        const threshold = frameThresholdReached && byteThresholdReached ? "frames_and_bytes" : byteThresholdReached ? "bytes" : "frames";
+        const warningData = {
+          queueSize: liveSize,
+          maxQueued: sub.maxQueued,
+          // `event.id` is always defined here — the just-published
+          // `event` is constructed at the top of `publish()` with
+          // `id: this.nextId++`. No `??` fallback needed.
+          lastEventId: event.id,
+          queuedBytes: liveBytes,
+          maxQueuedBytes: sub.maxQueuedBytes,
+          threshold
+        };
+        logSlowClientWarning(warningData);
         const warningFrame = {
           v: EVENT_SCHEMA_VERSION,
           type: "slow_client_warning",
-          data: {
-            queueSize: liveSize,
-            maxQueued: sub.maxQueued,
-            // `event.id` is always defined here — the just-published
-            // `event` is constructed at the top of `publish()` with
-            // `id: this.nextId++`. No `??` fallback needed.
-            lastEventId: event.id
-          }
+          data: warningData
         };
         sub.queue.forcePush(warningFrame);
-      } else if (sub.warned && liveSize <= sub.warnResetThreshold) {
-        sub.warned = false;
       }
     }
     return event;
@@ -145,13 +247,19 @@ var EventBus = class {
       throw new SubscriberLimitExceededError(this.maxSubscribers);
     }
     const maxQueued = opts.maxQueued ?? DEFAULT_MAX_QUEUED;
-    const queue = new BoundedAsyncQueue(maxQueued);
+    const queue = new BoundedAsyncQueue(
+      maxQueued,
+      this.maxQueuedBytes
+    );
     const sub = {
       queue,
       evicted: false,
       maxQueued,
       warnThreshold: WARN_THRESHOLD_RATIO * maxQueued,
       warnResetThreshold: WARN_RESET_RATIO * maxQueued,
+      maxQueuedBytes: this.maxQueuedBytes,
+      warnBytesThreshold: WARN_THRESHOLD_RATIO * this.maxQueuedBytes,
+      warnBytesResetThreshold: WARN_RESET_RATIO * this.maxQueuedBytes,
       warned: false,
       dispose: /* @__PURE__ */ __name(() => {
       }, "dispose")
@@ -174,7 +282,17 @@ var EventBus = class {
         });
       } else {
         const earliestInRing = this.ring[0]?.id;
-        if (earliestInRing !== void 0 && earliestInRing > opts.lastEventId + 1) {
+        if (earliestInRing === void 0 && opts.lastEventId < this.nextId - 1) {
+          queue.forcePush({
+            v: EVENT_SCHEMA_VERSION,
+            type: "state_resync_required",
+            data: {
+              reason: "seeded_replay_not_in_ring",
+              lastDeliveredId: opts.lastEventId,
+              earliestAvailableId: this.nextId
+            }
+          });
+        } else if (earliestInRing !== void 0 && earliestInRing > opts.lastEventId + 1) {
           queue.forcePush({
             v: EVENT_SCHEMA_VERSION,
             type: "state_resync_required",
@@ -268,8 +386,9 @@ function emptyAsyncIterable() {
 }
 __name(emptyAsyncIterable, "emptyAsyncIterable");
 var BoundedAsyncQueue = class {
-  constructor(maxSize) {
+  constructor(maxSize, maxBytes) {
     this.maxSize = maxSize;
+    this.maxBytes = maxBytes;
   }
   static {
     __name(this, "BoundedAsyncQueue");
@@ -286,6 +405,7 @@ var BoundedAsyncQueue = class {
    * no matter where in the queue the forced entries are.
    */
   liveCount = 0;
+  liveBytes = 0;
   /**
    * Number of LIVE (non-force-pushed) items currently waiting in the
    * buffer. Backpressure decisions in `EventBus.publish()` (the
@@ -294,18 +414,53 @@ var BoundedAsyncQueue = class {
   get size() {
     return this.liveCount;
   }
-  /** Returns true if accepted, false if dropped due to overflow. */
-  push(value) {
-    if (this.closed) return false;
+  get bytes() {
+    return this.liveBytes;
+  }
+  push(value, getBytes) {
+    if (this.closed) {
+      return {
+        ok: false,
+        reason: "queue_overflow",
+        liveSize: this.liveCount,
+        liveBytes: this.liveBytes
+      };
+    }
     const r = this.resolvers.shift();
     if (r) {
       r({ value, done: false });
-      return true;
+      return {
+        ok: true,
+        liveSize: this.liveCount,
+        liveBytes: this.liveBytes
+      };
+    }
+    if (this.liveCount >= this.maxSize) {
+      return {
+        ok: false,
+        reason: "queue_overflow",
+        liveSize: this.liveCount,
+        liveBytes: this.liveBytes
+      };
     }
-    if (this.liveCount >= this.maxSize) return false;
-    this.buf.push({ value, forced: false });
+    const bytes = getBytes();
+    if (this.liveCount > 0 && this.liveBytes + bytes > this.maxBytes) {
+      return {
+        ok: false,
+        reason: "queue_bytes_overflow",
+        liveSize: this.liveCount,
+        liveBytes: this.liveBytes,
+        eventBytes: bytes
+      };
+    }
+    this.buf.push({ value, forced: false, bytes });
     this.liveCount += 1;
-    return true;
+    this.liveBytes += bytes;
+    return {
+      ok: true,
+      liveSize: this.liveCount,
+      liveBytes: this.liveBytes
+    };
   }
   /** Bypasses the size cap. Used for replay frames, eviction terminal,
    * and slow-client warnings. */
@@ -316,7 +471,7 @@ var BoundedAsyncQueue = class {
       r({ value, done: false });
       return;
     }
-    this.buf.push({ value, forced: true });
+    this.buf.push({ value, forced: true, bytes: 0 });
   }
   /**
    * Mark the queue closed. By default `next()` continues to drain
@@ -338,6 +493,7 @@ var BoundedAsyncQueue = class {
     if (opts.drain === false) {
       this.buf.length = 0;
       this.liveCount = 0;
+      this.liveBytes = 0;
     }
     while (this.resolvers.length > 0) {
       this.resolvers.shift()({
@@ -349,7 +505,10 @@ var BoundedAsyncQueue = class {
   next() {
     if (this.buf.length > 0) {
       const entry = this.buf.shift();
-      if (!entry.forced) this.liveCount -= 1;
+      if (!entry.forced) {
+        this.liveCount -= 1;
+        this.liveBytes -= entry.bytes;
+      }
       return Promise.resolve({ value: entry.value, done: false });
     }
     if (this.closed) {

package/chunks/chunk-GD236YPV.js

@@ -0,0 +1,28 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getPackageJson
+} from "./chunk-43W4YSO6.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/version.ts
+init_esbuild_shims();
+async function getCliVersion() {
+  const pkgJson = await getPackageJson();
+  return "0.19.7";
+}
+__name(getCliVersion, "getCliVersion");
+
+export {
+  getCliVersion
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */