@bobfrankston/iflow-direct 0.1.33 → 0.1.34

package/imap-native.d.ts

@@ -48,7 +48,15 @@ export declare class NativeImapClient {
     private transport;
     private transportFactory;
     private config;
+    /** Receive buffer + read offset. CRITICAL: never reassign with
+     *  `this.buffer = this.buffer.substring(N)` — that copies the whole
+     *  remainder per line and is O(n²) over a multi-line response (a 457KB
+     *  LIST response actually blocked the daemon's event loop for 10 minutes
+     *  in production). Use bufferOffset to advance the read cursor; only
+     *  compact the buffer string when the consumed portion is >= half its
+     *  length, keeping per-line work O(1). */
     private buffer;
+    private bufferOffset;
     private pendingCommand;
     private capabilities;
     private _connected;
@@ -203,6 +211,11 @@ export declare class NativeImapClient {
     private waitForContinuation;
     private waitForTagged;
     private handleData;
+    /** Compact the buffer when bufferOffset has advanced past half. Cheap
+     *  amortized cost; eliminates the O(n²) substring-each-line antipattern
+     *  that synchronously blocked the daemon for 10 minutes on a large LIST
+     *  response. */
+    private compactBufferIfNeeded;
     private processBuffer;
     private handleUntaggedResponse;
     private parseFetchResponses;

package/imap-native.js

@@ -11,7 +11,15 @@ export class NativeImapClient {
     transport;
     transportFactory;
     config;
+    /** Receive buffer + read offset. CRITICAL: never reassign with
+     *  `this.buffer = this.buffer.substring(N)` — that copies the whole
+     *  remainder per line and is O(n²) over a multi-line response (a 457KB
+     *  LIST response actually blocked the daemon's event loop for 10 minutes
+     *  in production). Use bufferOffset to advance the read cursor; only
+     *  compact the buffer string when the consumed portion is >= half its
+     *  length, keeping per-line work O(1). */
     buffer = "";
+    bufferOffset = 0;
     pendingCommand = null;
     capabilities = new Set();
     _connected = false;
@@ -921,6 +929,16 @@ export class NativeImapClient {
         this.buffer += data;
         this.processBuffer();
     }
+    /** Compact the buffer when bufferOffset has advanced past half. Cheap
+     *  amortized cost; eliminates the O(n²) substring-each-line antipattern
+     *  that synchronously blocked the daemon for 10 minutes on a large LIST
+     *  response. */
+    compactBufferIfNeeded() {
+        if (this.bufferOffset > 0 && this.bufferOffset >= this.buffer.length / 2) {
+            this.buffer = this.buffer.substring(this.bufferOffset);
+            this.bufferOffset = 0;
+        }
+    }
     processBuffer() {
         while (true) {
             // Check for literal {size}\r\n — reading exact BYTE count of literal data
@@ -929,16 +947,20 @@ export class NativeImapClient {
             // We must use byte-accurate extraction (TextEncoder for browser, Buffer for Node).
             if (this.pendingCommand?.literalBytes != null) {
                 const neededBytes = this.pendingCommand.literalBytes;
-                const encoded = new TextEncoder().encode(this.buffer);
+                // Encode only the unread portion — was encoding the whole
+                // buffer (including already-consumed bytes) on every literal,
+                // which on a multi-MB buffer is a non-trivial chunk of work.
+                const unread = this.bufferOffset === 0 ? this.buffer : this.buffer.substring(this.bufferOffset);
+                const encoded = new TextEncoder().encode(unread);
                 const bufferBytes = encoded.byteLength;
                 if (bufferBytes >= neededBytes) {
                     const literal_bytes = encoded.subarray(0, neededBytes);
                     const rest_bytes = encoded.subarray(neededBytes);
                     let literal = new TextDecoder().decode(literal_bytes);
+                    // Reset buffer to just the rest — bufferOffset goes back
+                    // to 0 since we replaced the buffer content.
                     this.buffer = new TextDecoder().decode(rest_bytes);
-                    // if (neededBytes !== literal.length) {
-                    //     console.log(`iflow-direct:  [imap] literal: ${neededBytes} bytes → ${literal.length} chars (multi-byte corrected)`);
-                    // }
+                    this.bufferOffset = 0;
                     // For non-BODY literals (e.g. display names in ENVELOPE), wrap in quotes
                     // so tokenizeParenList treats them as a single token
                     if (!this.pendingCommand.currentLiteralKey) {
@@ -966,11 +988,23 @@ export class NativeImapClient {
                 }
                 break; // Wait for more data
             }
-            const lineEnd = this.buffer.indexOf("\r\n");
-            if (lineEnd < 0)
+            // Find next CRLF starting from the read offset (NOT from 0 —
+            // the bytes before bufferOffset are already consumed and
+            // searching them is dead work that scales with response size).
+            const lineEnd = this.buffer.indexOf("\r\n", this.bufferOffset);
+            if (lineEnd < 0) {
+                // No complete line yet. Compact the buffer if we've advanced
+                // far enough that the unconsumed-prefix is dragging.
+                this.compactBufferIfNeeded();
                 break;
-            const line = this.buffer.substring(0, lineEnd + 2);
-            this.buffer = this.buffer.substring(lineEnd + 2);
+            }
+            // Extract the line and advance the read cursor — no substring
+            // copy of the remainder, no buffer reallocation.
+            const line = this.buffer.substring(this.bufferOffset, lineEnd + 2);
+            this.bufferOffset = lineEnd + 2;
+            // Periodic compaction so the consumed prefix doesn't keep
+            // growing forever in long-running connections (IDLE, big sync).
+            this.compactBufferIfNeeded();
             // Check for literal announcement {size}\r\n at end of line
             const literalMatch = line.match(/\{(\d+)\}\r\n$/);
             if (literalMatch && this.pendingCommand) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/iflow-direct",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "description": "Direct IMAP client — transport-agnostic, no Node.js dependencies, browser-ready",
   "main": "index.js",
   "types": "index.ts",