imapflow 1.2.9 → 1.2.11

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "1.2.9"
+    ".": "1.2.11"
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.2.11](https://github.com/postalsys/imapflow/compare/v1.2.10...v1.2.11) (2026-03-03)
+
+
+### Bug Fixes
+
+* release backpressure in fetch() generator on early break/throw ([d42a377](https://github.com/postalsys/imapflow/commit/d42a377f8102f44fc76d8fa9a268bbf2526a7fa8)), closes [#338](https://github.com/postalsys/imapflow/issues/338)
+
+## [1.2.10](https://github.com/postalsys/imapflow/compare/v1.2.9...v1.2.10) (2026-02-19)
+
+
+### Bug Fixes
+
+* add null guards in compress() to prevent crash on TLS teardown ([84cd3ff](https://github.com/postalsys/imapflow/commit/84cd3ff8815d8ba37a37c1e7a09c244e80b61948))
+
 ## [1.2.9](https://github.com/postalsys/imapflow/compare/v1.2.8...v1.2.9) (2026-02-06)
 
 

package/README.md

@@ -1,109 +1,87 @@
 # ImapFlow
 
-ImapFlow is a modern and easy-to-use IMAP client library for Node.js.
+Modern and easy-to-use IMAP client library for Node.js.
 
-> [!NOTE]
-> Managing an IMAP connection is cool, but if you are only looking for an easy way to integrate email accounts, then ImapFlow was built for [EmailEngine Email API](https://emailengine.app/). It's a self-hosted software that converts all IMAP accounts to easy-to-use REST interfaces.
-
-The focus for ImapFlow is to provide easy to use API over IMAP. Using ImapFlow does not expect knowledge about specific IMAP details. A general understanding is good enough.
-
-IMAP extensions are handled in the background, so, for example, you can always request `labels` value from a `fetch()` call, but if the IMAP server does not support `X-GM-EXT-1` extension, then `labels` value is not included in the response.
+[![npm](https://img.shields.io/npm/v/imapflow)](https://www.npmjs.com/package/imapflow)
+[![license](https://img.shields.io/npm/l/imapflow)](https://github.com/postalsys/imapflow/blob/master/LICENSE)
 
-## Source
+ImapFlow provides a clean, promise-based API for working with IMAP, so you don't need in-depth knowledge of the protocol. IMAP extensions are detected and handled automatically. You write the same code regardless of server capabilities, and ImapFlow adapts behind the scenes.
 
-Source code is available from [Github](https://github.com/postalsys/imapflow).
+## Features
 
-## Usage
+- **Async/await API** - all methods return Promises
+- **Automatic IMAP extension handling** - CONDSTORE, QRESYNC, IDLE, COMPRESS, and [more](https://imapflow.com/docs/)
+- **Message streaming** - async iterators for efficient processing
+- **Mailbox locking** - built-in locking mechanism for safe concurrent access
+- **TypeScript support** - type definitions included
+- **Proxy support** - SOCKS and HTTP CONNECT proxies
+- **Gmail support** - labels, raw search via X-GM-EXT-1
 
-First install the module from npm:
+## Installation
 
-```
+```bash
 npm install imapflow
 ```
 
-next import the ImapFlow class into your script:
+## Quick Example
 
 ```js
 const { ImapFlow } = require('imapflow');
-```
-
-### Promises
 
-All ImapFlow methods use Promises, so you need to wait using `await` or wait for the `then()` method to fire until you get the response.
-
-```js
-const { ImapFlow } = require('imapflow');
 const client = new ImapFlow({
-    host: 'ethereal.email',
+    host: 'imap.example.com',
     port: 993,
     secure: true,
     auth: {
-        user: 'garland.mcclure71@ethereal.email',
-        pass: 'mW6e4wWWnEd3H4hT5B'
+        user: 'user@example.com',
+        pass: 'password'
     }
 });
 
 const main = async () => {
-    // Wait until client connects and authorizes
     await client.connect();
 
-    // Select and lock a mailbox. Throws if mailbox does not exist
     let lock = await client.getMailboxLock('INBOX');
     try {
-        // fetch latest message source
-        // client.mailbox includes information about currently selected mailbox
-        // "exists" value is also the largest sequence number available in the mailbox
+        // fetch latest message
         let message = await client.fetchOne(client.mailbox.exists, { source: true });
         console.log(message.source.toString());
 
         // list subjects for all messages
-        // uid value is always included in FETCH response, envelope strings are in unicode.
         for await (let message of client.fetch('1:*', { envelope: true })) {
             console.log(`${message.uid}: ${message.envelope.subject}`);
         }
     } finally {
-        // Make sure lock is released, otherwise next `getMailboxLock()` never returns
+        // always release the lock
         lock.release();
     }
 
-    // log out and close connection
     await client.logout();
 };
 
-main().catch(err => console.error(err));
+main().catch(console.error);
 ```
 
-### Admin Impersonation / Delegation (SASL PLAIN with authzid)
+See the [Quick Start guide](https://imapflow.com/docs/getting-started/quick-start) for more examples, including Gmail, Outlook, and Yahoo configuration.
 
-ImapFlow supports admin impersonation for mail systems like Zimbra that allow administrators to access user mailboxes. This is done using the SASL PLAIN mechanism with an authorization identity (`authzid`).
-
-```js
-const { ImapFlow } = require('imapflow');
-const client = new ImapFlow({
-    host: 'mail.example.com',
-    port: 993,
-    secure: true,
-    auth: {
-        user: 'admin@example.com', // Admin credentials (authentication identity)
-        pass: 'adminpassword',
-        authzid: 'user@example.com', // User to impersonate (authorization identity)
-        loginMethod: 'AUTH=PLAIN' // Must use PLAIN mechanism for authzid
-    }
-});
+## Documentation
 
-// Connection will authenticate as admin but authorize as the specified user
-await client.connect();
-// Now operating on user@example.com's mailbox as admin
-```
+Full documentation is available at **[imapflow.com](https://imapflow.com/docs/)**.
 
-**Note:** The `authzid` parameter only works with the `AUTH=PLAIN` mechanism. The server must support admin delegation/impersonation for this to work.
+- [Installation](https://imapflow.com/docs/getting-started/installation) - requirements and setup
+- [Quick Start](https://imapflow.com/docs/getting-started/quick-start) - your first ImapFlow application
+- [Basic Usage](https://imapflow.com/docs/guides/basic-usage) - core concepts and patterns
+- [Configuration](https://imapflow.com/docs/guides/configuration) - connection options and settings
+- [Fetching Messages](https://imapflow.com/docs/guides/fetching-messages) - reading email data
+- [Searching](https://imapflow.com/docs/guides/searching) - finding messages with search queries
+- [Mailbox Management](https://imapflow.com/docs/guides/mailbox-management) - creating, renaming, and deleting mailboxes
+- [API Reference](https://imapflow.com/docs/api/imapflow-client) - complete method and event documentation
 
-## Documentation
-
-[API reference](https://imapflow.com/docs/api/imapflow-client).
+> [!NOTE]
+> If you are looking for a complete email integration solution, ImapFlow was built for [EmailEngine](https://emailengine.app/), a self-hosted email gateway that provides REST API access to IMAP and SMTP accounts.
 
 ## License
 
-© 2020-2025 Postal Systems OÜ
+Copyright (c) 2020-2025 Postal Systems OU
 
-Licensed under **MIT-license**
+Licensed under the MIT license.

package/eslint.config.js

@@ -1,38 +1,40 @@
 'use strict';
 
-const { FlatCompat } = require('@eslint/eslintrc');
 const js = require('@eslint/js');
-
-const compat = new FlatCompat({
-    baseDirectory: __dirname,
-    recommendedConfig: js.configs.recommended
-});
+const globals = require('globals');
+const prettierConfig = require('eslint-config-prettier/flat');
+const nodemailerConfig = require('eslint-config-nodemailer');
 
 module.exports = [
     {
         ignores: ['node_modules/**', 'examples/**', 'docs/**']
     },
-    ...compat.extends('nodemailer', 'prettier'),
+    js.configs.recommended,
     {
         languageOptions: {
-            ecmaVersion: 2020,
+            ecmaVersion: 2022,
             sourceType: 'script',
-            globals: {
-                BigInt: 'readonly'
-            },
-            parser: require('@babel/eslint-parser'),
             parserOptions: {
-                requireConfigFile: false
+                ecmaFeatures: {
+                    globalReturn: true
+                }
+            },
+            globals: {
+                ...globals.node,
+                ...globals.es2021,
+                it: 'readonly',
+                describe: 'readonly',
+                beforeEach: 'readonly',
+                afterEach: 'readonly'
             }
         },
-        plugins: {
-            '@babel': require('@babel/eslint-plugin')
-        },
         rules: {
+            ...nodemailerConfig.rules,
             'no-await-in-loop': 0,
             'require-atomic-updates': 0
         }
     },
+    prettierConfig,
     {
         files: ['eslint.config.js', '.prettierrc.js', '.ncurc.js'],
         rules: {

package/lib/imap-flow.js

@@ -1018,7 +1018,7 @@ class ImapFlow extends EventEmitter {
                 processedChunks = 0;
 
                 let chunk;
-                while ((chunk = this.writeSocket.read()) !== null) {
+                while (this.writeSocket && (chunk = this.writeSocket.read()) !== null) {
                     if (this._deflate && this._deflate.write(chunk) === false) {
                         return this._deflate.once('drain', readNext);
                     }
@@ -1027,6 +1027,9 @@ class ImapFlow extends EventEmitter {
                     processedChunks++;
                     if (processedChunks % 100 === 0) {
                         await new Promise(resolve => setImmediate(resolve));
+                        if (!this.writeSocket) {
+                            break;
+                        }
                     }
                 }
 
@@ -1042,17 +1045,21 @@ class ImapFlow extends EventEmitter {
         };
 
         this.writeSocket.on('readable', () => {
-            if (!reading) {
+            if (!reading && this.writeSocket) {
                 readNext();
             }
         });
         this.writeSocket.on('error', err => {
-            this.socket.emit('error', err);
+            if (this.socket) {
+                this.socket.emit('error', err);
+            }
         });
 
         this._deflate.pipe(this.socket);
         this._deflate.on('error', err => {
-            this.socket.emit('error', err);
+            if (this.socket) {
+                this.socket.emit('error', err);
+            }
         });
     }
 
@@ -2711,6 +2718,7 @@ class ImapFlow extends EventEmitter {
         // two: when the consumer is waiting and the queue is empty, `push` is set to
         // a function that wakes up the consumer when new data arrives.
         let finished = false;
+        let aborted = false;
         let push = false;
         let rowQueue = [];
 
@@ -2748,6 +2756,10 @@ class ImapFlow extends EventEmitter {
             binary: options.binary,
             changedSince: options.changedSince,
             onUntaggedFetch: (untagged, next) => {
+                if (aborted) {
+                    next();
+                    return;
+                }
                 rowQueue.push({
                     value: {
                         response: untagged,
@@ -2772,26 +2784,36 @@ class ImapFlow extends EventEmitter {
                 }
             });
 
-        let res;
-        while ((res = await getNext())) {
-            if (this.isClosed || !this.socket || this.socket.destroyed) {
-                let error = new Error('Connection closed');
-                error.code = 'EConnectionClosed';
-                throw error;
-            }
+        let lastRes = null;
+        try {
+            let res;
+            while ((res = await getNext())) {
+                lastRes = res;
+
+                if (this.isClosed || !this.socket || this.socket.destroyed) {
+                    let error = new Error('Connection closed');
+                    error.code = 'EConnectionClosed';
+                    throw error;
+                }
 
-            if (res !== null) {
                 yield res.response;
                 // Signal the FETCH handler to process the next untagged response
                 res.next();
+                lastRes = null;
+            }
+        } finally {
+            aborted = true;
+            // Release backpressure for the item that was yielded but whose
+            // next() was not yet called (happens on break/return/throw)
+            if (lastRes && typeof lastRes.next === 'function') {
+                lastRes.next();
+            }
+            while (rowQueue.length) {
+                let entry = rowQueue.shift();
+                if (entry.value && typeof entry.value.next === 'function') {
+                    entry.value.next();
+                }
             }
-        }
-
-        if (!finished) {
-            // FETCH never finished!
-            let error = new Error('FETCH did not finish');
-            error.code = 'ENotFinished';
-            throw error;
         }
     }
 

package/lib/tools.js

@@ -206,11 +206,7 @@ const tools = {
                 if (cur) {
                     node = cur;
                 } else {
-                    // not yet set
-                    cur = {
-                        name: parent,
-                        folders: []
-                    };
+                    // not yet set, will be created by the caller
                 }
             }
 
@@ -901,7 +897,6 @@ const tools = {
                 if (node[i]) {
                     curNode.location = ((node[i] || {}).value || '').toString();
                 }
-                i++;
             }
 
             return curNode;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.2.9",
+    "version": "1.2.11",
     "description": "IMAP Client for Node",
     "main": "lib/imap-flow.js",
     "types": "lib/imap-flow.d.ts",
@@ -27,21 +27,16 @@
     },
     "homepage": "https://imapflow.com/",
     "devDependencies": {
-        "@babel/eslint-parser": "7.28.6",
-        "@babel/eslint-plugin": "7.27.1",
-        "@babel/plugin-syntax-class-properties": "7.12.13",
-        "@babel/preset-env": "7.29.0",
-        "@eslint/eslintrc": "3.3.3",
-        "@eslint/js": "9.39.2",
-        "@types/node": "25.2.1",
-        "c8": "10.1.3",
-        "eslint": "9.39.2",
+        "@eslint/js": "10.0.1",
+        "@types/node": "25.3.3",
+        "c8": "11.0.0",
+        "eslint": "10.0.2",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "10.1.8",
         "grunt": "1.6.1",
         "grunt-cli": "1.5.0",
         "grunt-contrib-nodeunit": "5.0.0",
-        "grunt-eslint": "24.3.0",
+        "grunt-eslint": "26.0.0",
         "prettier": "3.8.1",
         "proxyquire": "^2.1.3",
         "typescript": "5.9.3"
@@ -53,8 +48,8 @@
         "libbase64": "1.3.0",
         "libmime": "5.3.7",
         "libqp": "2.1.1",
-        "nodemailer": "8.0.0",
-        "pino": "10.3.0",
+        "nodemailer": "8.0.1",
+        "pino": "10.3.1",
         "socks": "2.8.7"
     }
 }

package/test/bodystructure-test.js

@@ -234,237 +234,6 @@ module.exports['Process correct TEXT with line count'] = test => {
         null
     ];
 
-    attribute = [
-        [
-            [
-                {
-                    type: 'STRING',
-                    value: 'text'
-                },
-                {
-                    type: 'STRING',
-                    value: 'plain'
-                },
-                [
-                    {
-                        type: 'STRING',
-                        value: 'charset'
-                    },
-                    {
-                        type: 'STRING',
-                        value: 'UTF-8'
-                    }
-                ],
-                null,
-                null,
-                {
-                    type: 'STRING',
-                    value: '7bit'
-                },
-                {
-                    type: 'ATOM',
-                    value: '23'
-                },
-                {
-                    type: 'ATOM',
-                    value: '1'
-                },
-                null,
-                null,
-                null,
-                null
-            ],
-            [
-                {
-                    type: 'STRING',
-                    value: 'text'
-                },
-                {
-                    type: 'STRING',
-                    value: 'html'
-                },
-                [
-                    {
-                        type: 'STRING',
-                        value: 'charset'
-                    },
-                    {
-                        type: 'STRING',
-                        value: 'UTF-8'
-                    }
-                ],
-                null,
-                null,
-                {
-                    type: 'STRING',
-                    value: '7bit'
-                },
-                {
-                    type: 'ATOM',
-                    value: '49'
-                },
-                {
-                    type: 'ATOM',
-                    value: '1'
-                },
-                null,
-                null,
-                null,
-                null
-            ],
-            {
-                type: 'STRING',
-                value: 'alternative'
-            },
-            [
-                {
-                    type: 'STRING',
-                    value: 'boundary'
-                },
-                {
-                    type: 'STRING',
-                    value: '000000000000b56402062b1fba83'
-                }
-            ],
-            null,
-            null,
-            null
-        ],
-        [
-            {
-                type: 'STRING',
-                value: 'text'
-            },
-            {
-                type: 'STRING',
-                value: 'plain'
-            },
-            [
-                {
-                    type: 'STRING',
-                    value: 'charset'
-                },
-                {
-                    type: 'STRING',
-                    value: 'US-ASCII'
-                },
-                {
-                    type: 'STRING',
-                    value: 'name'
-                },
-                {
-                    type: 'STRING',
-                    value: 'log_imap_missing_attachments.txt'
-                }
-            ],
-            {
-                type: 'STRING',
-                value: '<f_m5mnf91y1>'
-            },
-            null,
-            {
-                type: 'STRING',
-                value: 'base64'
-            },
-            {
-                type: 'ATOM',
-                value: '33954'
-            },
-            {
-                type: 'ATOM',
-                value: '435'
-            },
-            null,
-            [
-                {
-                    type: 'STRING',
-                    value: 'attachment'
-                },
-                [
-                    {
-                        type: 'STRING',
-                        value: 'filename'
-                    },
-                    {
-                        type: 'STRING',
-                        value: 'log_imap_missing_attachments.txt'
-                    }
-                ]
-            ],
-            null,
-            null
-        ],
-        [
-            {
-                type: 'STRING',
-                value: 'image'
-            },
-            {
-                type: 'STRING',
-                value: 'jpeg'
-            },
-            [
-                {
-                    type: 'STRING',
-                    value: 'name'
-                },
-                {
-                    type: 'STRING',
-                    value: 'img2.jpeg'
-                }
-            ],
-            {
-                type: 'STRING',
-                value: '<f_m5mnf4c70>'
-            },
-            null,
-            {
-                type: 'STRING',
-                value: 'base64'
-            },
-            {
-                type: 'ATOM',
-                value: '3776960'
-            },
-            null,
-            [
-                {
-                    type: 'STRING',
-                    value: 'attachment'
-                },
-                [
-                    {
-                        type: 'STRING',
-                        value: 'filename'
-                    },
-                    {
-                        type: 'STRING',
-                        value: 'img2.jpeg'
-                    }
-                ]
-            ],
-            null,
-            null
-        ],
-        {
-            type: 'STRING',
-            value: 'mixed'
-        },
-        [
-            {
-                type: 'STRING',
-                value: 'boundary'
-            },
-            {
-                type: 'STRING',
-                value: '000000000000b56402062b1fba85'
-            }
-        ],
-        null,
-        null,
-        null
-    ];
-
     let bodyStruct = parseBodystructure(attribute);
 
     test.deepEqual(bodyStruct, {

package/test/connection-edge-cases-test.js

@@ -1464,3 +1464,108 @@ module.exports['Connection Edge: connect throws if called twice'] = async test =
 
     test.done();
 };
+
+// Helper to create a mock client with compression enabled
+async function setupCompressedClient() {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    let mockSocket = new EventEmitter();
+    mockSocket.pipe = dest => dest;
+    mockSocket.unpipe = () => {};
+    mockSocket.destroy = () => {};
+    mockSocket.destroyed = false;
+    client.socket = mockSocket;
+    client.streamer = new EventEmitter();
+
+    client.run = async command => {
+        if (command === 'COMPRESS') {
+            return true;
+        }
+    };
+
+    await client.compress();
+    return { client, mockSocket };
+}
+
+module.exports['Connection Edge: compress writeSocket error forwarded to socket when live'] = async test => {
+    let { client, mockSocket } = await setupCompressedClient();
+
+    let errorReceived = false;
+    mockSocket.on('error', err => {
+        errorReceived = true;
+        test.equal(err.message, 'writeSocket error');
+    });
+
+    client.writeSocket.emit('error', new Error('writeSocket error'));
+
+    test.ok(errorReceived, 'Error should be forwarded to socket');
+    test.done();
+};
+
+module.exports['Connection Edge: compress _deflate error forwarded to socket when live'] = async test => {
+    let { client, mockSocket } = await setupCompressedClient();
+
+    let errorReceived = false;
+    mockSocket.on('error', err => {
+        errorReceived = true;
+        test.equal(err.message, 'deflate error');
+    });
+
+    client._deflate.emit('error', new Error('deflate error'));
+
+    test.ok(errorReceived, 'Error should be forwarded to socket');
+    test.done();
+};
+
+module.exports['Connection Edge: compress readable after close does not crash'] = async test => {
+    let { client } = await setupCompressedClient();
+
+    // Save reference before close() nulls it
+    let writeSocket = client.writeSocket;
+
+    client.close();
+
+    // Emit readable on the saved reference after close has nulled this.writeSocket
+    // This should not throw (guards at lines 1048 and 1021)
+    test.doesNotThrow(() => {
+        writeSocket.emit('readable');
+    });
+
+    test.done();
+};
+
+module.exports['Connection Edge: compress writeSocket error after close does not crash'] = async test => {
+    let { client } = await setupCompressedClient();
+
+    let writeSocket = client.writeSocket;
+
+    client.close();
+
+    // Emit error on saved writeSocket after close has nulled this.socket
+    // This should not throw (guard at lines 1053-1055)
+    test.doesNotThrow(() => {
+        writeSocket.emit('error', new Error('late writeSocket error'));
+    });
+
+    test.done();
+};
+
+module.exports['Connection Edge: compress _deflate error after close does not crash'] = async test => {
+    let { client } = await setupCompressedClient();
+
+    let deflate = client._deflate;
+
+    client.close();
+
+    // Emit error on saved _deflate after close has nulled this.socket
+    // This should not throw (guard at lines 1060-1062)
+    test.doesNotThrow(() => {
+        deflate.emit('error', new Error('late deflate error'));
+    });
+
+    test.done();
+};

package/test/fetch-generator-test.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const { ImapFlow } = require('../lib/imap-flow');
+
+// Helper: create a minimal mock context with the fetch() generator bound to it.
+// The `run` override controls how untagged FETCH responses are delivered.
+const createFetchContext = runOverride => ({
+    mailbox: { path: 'INBOX', exists: 10 },
+    isClosed: false,
+    socket: { destroyed: false },
+    resolveRange: async range => range,
+    run: runOverride
+});
+
+// Helper: invoke the fetch generator on a mock context
+function callFetch(ctx, range, query, options) {
+    return ImapFlow.prototype.fetch.call(ctx, range, query, options);
+}
+
+// Helper: create a mock `run` that delivers `count` untagged FETCH responses,
+// each with a `next` callback for backpressure. Returns a tracking object.
+function createMockRun(count) {
+    const tracker = {
+        nextCalls: [], // records which message indices had next() called
+        onUntaggedFetch: null,
+        runResolved: false
+    };
+
+    const run = async (_cmd, _range, _query, opts) => {
+        tracker.onUntaggedFetch = opts.onUntaggedFetch;
+
+        for (let i = 0; i < count; i++) {
+            await new Promise(resolve => {
+                opts.onUntaggedFetch({ seq: i + 1, uid: 100 + i }, () => {
+                    tracker.nextCalls.push(i);
+                    resolve();
+                });
+            });
+        }
+        tracker.runResolved = true;
+    };
+
+    return { tracker, run };
+}
+
+// ---------------------------------------------------------------------------
+// Test: early break releases backpressure
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: early break releases backpressure'] = async test => {
+    const { tracker, run } = createMockRun(5);
+    const ctx = createFetchContext(run);
+
+    const gen = callFetch(ctx, '1:5', { uid: true });
+    // Consume only the first message and break
+    for await (let msg of gen) {
+        test.ok(msg.seq === 1, 'should receive the first message');
+        break;
+    }
+
+    // Allow microtasks to flush (the finally block runs synchronously with
+    // generator return, but the remaining run() deliveries are async)
+    await new Promise(r => setTimeout(r, 50));
+
+    // The first message had next() called by the yield loop (res.next()).
+    // Remaining queued/future messages should have next() called by the
+    // finally block or the aborted guard.
+    test.equal(tracker.nextCalls.length, 5, 'all 5 messages should have next() called');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: subsequent operations work after early exit
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: connection usable after early break'] = async test => {
+    let runCallCount = 0;
+
+    const run = async (_cmd, _range, _query, opts) => {
+        runCallCount++;
+        // Deliver 3 messages
+        for (let i = 0; i < 3; i++) {
+            await new Promise(resolve => {
+                opts.onUntaggedFetch({ seq: i + 1, uid: 200 + i }, () => resolve());
+            });
+        }
+    };
+
+    const ctx = createFetchContext(run);
+
+    // First fetch: break early
+    const gen1 = callFetch(ctx, '1:3', { uid: true });
+    for await (let msg of gen1) {
+        test.ok(msg.seq === 1);
+        break;
+    }
+
+    await new Promise(r => setTimeout(r, 50));
+
+    // Second fetch: should work (run gets called again)
+    const gen2 = callFetch(ctx, '1:3', { uid: true });
+    let secondFetchMessages = [];
+    for await (let msg of gen2) {
+        secondFetchMessages.push(msg);
+    }
+
+    test.ok(runCallCount === 2, 'run was called for both fetch operations');
+    test.ok(secondFetchMessages.length === 3, 'second fetch received all 3 messages');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: normal full iteration works correctly
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: normal full iteration receives all messages'] = async test => {
+    const { tracker, run } = createMockRun(4);
+    const ctx = createFetchContext(run);
+
+    let messages = [];
+    for await (let msg of callFetch(ctx, '1:4', { uid: true })) {
+        messages.push(msg);
+    }
+
+    test.equal(messages.length, 4, 'should receive all 4 messages');
+    test.equal(messages[0].seq, 1);
+    test.equal(messages[3].seq, 4);
+    test.equal(tracker.nextCalls.length, 4, 'all next() callbacks were called');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: error thrown in loop body releases backpressure
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: error in loop body releases backpressure'] = async test => {
+    const { tracker, run } = createMockRun(5);
+    const ctx = createFetchContext(run);
+
+    const gen = callFetch(ctx, '1:5', { uid: true });
+
+    let caught = false;
+    try {
+        for await (let msg of gen) {
+            if (msg.seq === 2) {
+                throw new Error('intentional test error');
+            }
+        }
+    } catch (err) {
+        caught = true;
+        test.equal(err.message, 'intentional test error');
+    }
+
+    await new Promise(r => setTimeout(r, 50));
+
+    test.ok(caught, 'error was caught');
+    // Messages 0 and 1 had next() called by the yield loop. The rest should
+    // be drained by the finally block or the aborted guard.
+    test.equal(tracker.nextCalls.length, 5, 'all 5 messages should have next() called');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: zero messages from server
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: zero messages yields nothing'] = async test => {
+    const { tracker, run } = createMockRun(0);
+    const ctx = createFetchContext(run);
+
+    let messages = [];
+    for await (let msg of callFetch(ctx, '1:*', { uid: true })) {
+        messages.push(msg);
+    }
+
+    test.equal(messages.length, 0, 'no messages should be yielded');
+    test.equal(tracker.nextCalls.length, 0, 'no next() calls needed');
+    test.ok(tracker.runResolved, 'run should have resolved');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: connection closed during iteration throws and releases backpressure
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: connection closed mid-iteration throws and cleans up'] = async test => {
+    const tracker = {
+        nextCalls: []
+    };
+
+    const run = async (_cmd, _range, _query, opts) => {
+        for (let i = 0; i < 3; i++) {
+            await new Promise(resolve => {
+                opts.onUntaggedFetch({ seq: i + 1, uid: 300 + i }, () => {
+                    tracker.nextCalls.push(i);
+                    resolve();
+                });
+            });
+        }
+    };
+
+    const ctx = createFetchContext(run);
+
+    let caught = false;
+    try {
+        for await (let msg of callFetch(ctx, '1:3', { uid: true })) {
+            if (msg.seq === 1) {
+                // Simulate connection closing after first message
+                ctx.isClosed = true;
+            }
+        }
+    } catch (err) {
+        caught = true;
+        test.equal(err.code, 'EConnectionClosed', 'should throw EConnectionClosed');
+    }
+
+    await new Promise(r => setTimeout(r, 50));
+
+    test.ok(caught, 'error was caught');
+    test.equal(tracker.nextCalls.length, 3, 'all next() callbacks should be called for cleanup');
+    test.done();
+};

package/.babelrc

@@ -1,6 +0,0 @@
-{
-    "presets": ["@babel/env"],
-    "plugins": [
-        "@babel/plugin-syntax-class-properties"
-    ]
-}

package/.eslintrc

@@ -1,16 +0,0 @@
-{
-    "rules": {
-        "no-await-in-loop": 0,
-        "require-atomic-updates": 0
-    },
-    "globals": {
-        "BigInt": true
-    },
-    "extends": ["nodemailer", "prettier"],
-    "parser": "@babel/eslint-parser",
-    "parserOptions": {
-        "ecmaVersion": 2020,
-        "sourceType": "script"
-    },
-    "plugins": ["@babel"]
-}