@runuai/host 0.9.13 → 0.9.42

package/src/event-outbox.ts

@@ -17,13 +17,31 @@ export interface OutboxEntry {
   seq: number;
   /** The full serialized `{kind:"event", seq, event}` frame, ready to send. */
   raw: string;
+  /** Exact UTF-8 wire bytes retained by this frame. */
+  bytes: number;
 }
 
+export interface EventOutboxSink {
+  readonly bufferedAmount: number;
+  send(raw: string): void;
+}
+
+export type EventOutboxTransmitResult =
+  | "empty"
+  | "backpressured"
+  | "send_failed";
+
 /** Overflow bounds. Generous: a disconnect longer than this many events is a
  *  real outage, not a deploy blip, and dropping OLDEST keeps the tail — the
  *  most recent turn — intact for replay. */
 const MAX_ENTRIES = 10_000;
 const MAX_BYTES = 32 * 1024 * 1024;
+// Match the historical `ws` single-message default and the authenticated
+// cloud receiver ceiling. Task diffs and message_complete events are not yet
+// field-bounded, so rolling hosts must retain one legitimate frame above the
+// ordinary outbox/transport budgets. Anything larger could never reach the
+// cloud and would otherwise put the host into a permanent reconnect loop.
+export const MAX_EVENT_FRAME_BYTES = 100 * 1024 * 1024;
 
 export class EventOutbox {
   private entries: OutboxEntry[] = [];
@@ -38,15 +56,20 @@ export class EventOutbox {
   enqueue(event: HostEvent): number {
     const seq = this.nextSeq++;
     const raw = JSON.stringify({ kind: "event", seq, event });
-    this.entries.push({ seq, raw });
-    this.totalBytes += raw.length;
+    const bytes = Buffer.byteLength(raw, "utf8");
+    if (bytes > MAX_EVENT_FRAME_BYTES) {
+      this.droppedSinceDrain += 1;
+      return seq;
+    }
+    this.entries.push({ seq, raw, bytes });
+    this.totalBytes += bytes;
     while (
       this.entries.length > MAX_ENTRIES ||
       (this.totalBytes > MAX_BYTES && this.entries.length > 1)
     ) {
       const dropped = this.entries.shift();
       if (!dropped) break;
-      this.totalBytes -= dropped.raw.length;
+      this.totalBytes -= dropped.bytes;
       // Only a NEVER-SENT entry is a real loss; an unacked-but-sent one most
       // likely landed and just lost its ack.
       if (dropped.seq > this.sentUpTo) this.droppedSinceDrain += 1;
@@ -59,7 +82,7 @@ export class EventOutbox {
     let i = 0;
     for (const entry of this.entries) {
       if (entry.seq > seq) break;
-      this.totalBytes -= entry.raw.length;
+      this.totalBytes -= entry.bytes;
       i += 1;
     }
     if (i > 0) this.entries.splice(0, i);
@@ -87,6 +110,19 @@ export class EventOutbox {
     return due;
   }
 
+  /** Oldest due entry without advancing the transmit cursor. */
+  nextDue(): OutboxEntry | null {
+    return this.entries.find((entry) => entry.seq > this.sentUpTo) ?? null;
+  }
+
+  /** Advance only the exact next due entry after the caller queues it. */
+  markSent(seq: number): boolean {
+    const due = this.nextDue();
+    if (!due || due.seq !== seq) return false;
+    this.sentUpTo = seq;
+    return true;
+  }
+
   /** Never-sent entries lost to overflow since the last call; resets. */
   takeDroppedCount(): number {
     const n = this.droppedSinceDrain;
@@ -102,3 +138,46 @@ export class EventOutbox {
     return this.totalBytes;
   }
 }
+
+/**
+ * Queue due frames only until the transport reaches its high-water mark.
+ * Entries advance one at a time after `send` accepts them, so a slow socket
+ * leaves the remainder replayable in the bounded outbox instead of moving the
+ * whole backlog into the WebSocket implementation's own buffer.
+ */
+export function transmitEventOutbox(
+  outbox: EventOutbox,
+  sink: EventOutboxSink,
+  maxBufferedBytes: number,
+): EventOutboxTransmitResult {
+  let projectedBufferedBytes = sink.bufferedAmount;
+  while (true) {
+    const entry = outbox.nextDue();
+    if (!entry) return "empty";
+    if (
+      maxBufferedBytes <= 0 ||
+      (projectedBufferedBytes > 0 &&
+        (projectedBufferedBytes >= maxBufferedBytes ||
+          entry.bytes > maxBufferedBytes - projectedBufferedBytes))
+    ) {
+      return "backpressured";
+    }
+    try {
+      sink.send(entry.raw);
+    } catch {
+      return "send_failed";
+    }
+    if (!outbox.markSent(entry.seq)) return "send_failed";
+    projectedBufferedBytes = Math.max(
+      sink.bufferedAmount,
+      projectedBufferedBytes + entry.bytes,
+    );
+
+    // A rolling-compatible frame above the normal high-water budget gets one
+    // empty transport to itself. Do not depend on a sink updating
+    // `bufferedAmount` synchronously before protecting the following frame.
+    if (entry.bytes > maxBufferedBytes) {
+      return outbox.nextDue() ? "backpressured" : "empty";
+    }
+  }
+}