@postalsys/email-text-tools 2.4.3 → 2.4.5

package/.github/workflows/test.yaml

@@ -0,0 +1,22 @@
+name: Run tests
+
+on:
+    push:
+    pull_request:
+
+jobs:
+    test:
+        strategy:
+            matrix:
+                node: [20.x, 22.x, 24.x]
+                os: [ubuntu-latest]
+        runs-on: ${{ matrix.os }}
+        steps:
+            - uses: actions/checkout@v4
+            - name: Use Node.js ${{ matrix.node }}
+              uses: actions/setup-node@v4
+              with:
+                  node-version: ${{ matrix.node }}
+            - run: npm install
+            - run: npm run lint
+            - run: npm test

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "2.4.3"
+    ".": "2.4.5"
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.4.5](https://github.com/postalsys/email-text-tools/compare/v2.4.4...v2.4.5) (2026-04-16)
+
+
+### Bug Fixes
+
+* Bumped deps ([feceb0b](https://github.com/postalsys/email-text-tools/commit/feceb0b8d1dc6b8e74c40e54e60730ef43d5e8f9))
+
+## [2.4.4](https://github.com/postalsys/email-text-tools/compare/v2.4.3...v2.4.4) (2026-04-08)
+
+
+### Bug Fixes
+
+* Bumped deps ([fd057e4](https://github.com/postalsys/email-text-tools/commit/fd057e436e693bf612bae28458e1e74c38739caa))
+
 ## [2.4.3](https://github.com/postalsys/email-text-tools/compare/v2.4.2...v2.4.3) (2026-03-15)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@postalsys/email-text-tools",
-    "version": "2.4.3",
+    "version": "2.4.5",
     "description": "Email text tools",
     "main": "index.js",
     "scripts": {
@@ -26,18 +26,18 @@
     "homepage": "https://github.com/postalsys/email-text-tools#readme",
     "devDependencies": {
         "@eslint/js": "10.0.1",
-        "eslint": "10.0.3",
+        "eslint": "10.2.0",
         "eslint-config-prettier": "10.1.8",
-        "prettier": "3.8.1"
+        "prettier": "3.8.3"
     },
     "dependencies": {
-        "dompurify": "3.3.3",
+        "dompurify": "3.4.0",
         "he": "1.2.0",
         "html-to-text": "9.0.5",
         "jsdom": "27.0.0",
         "juice": "11.1.1",
         "linkify-it": "5.0.0",
-        "moment-timezone": "0.6.0",
+        "moment-timezone": "0.6.1",
         "node-html-parser": "7.1.0",
         "tlds": "1.261.0"
     }

package/test/inline-html.test.js

@@ -0,0 +1,230 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const inlineHtml = require('../lib/inline-html');
+
+describe('inline-html', () => {
+    const baseDate = new Date('2024-06-15T14:30:00Z');
+
+    const fullMessageData = {
+        from: [{ name: 'Alice Sender', address: 'alice@example.com' }],
+        subject: 'Test Subject',
+        date: baseDate,
+        to: [{ name: 'Bob Receiver', address: 'bob@example.com' }],
+        cc: [{ name: 'Charlie', address: 'charlie@example.com' }],
+        bcc: [{ address: 'secret@example.com' }],
+        html: '<html><body><p>Original message</p></body></html>'
+    };
+
+    describe('reply action', () => {
+        it('should create reply with date and from header', () => {
+            const result = inlineHtml('reply', '<p>My reply</p>', fullMessageData);
+            assert.ok(result.includes('wrote:'));
+            assert.ok(result.includes('alice@example.com'));
+            assert.ok(result.includes('My reply'));
+            assert.ok(result.includes('<blockquote'));
+            assert.ok(result.includes('Original message'));
+        });
+
+        it('should create reply with no from address using <> fallback', () => {
+            const data = { date: baseDate, html: '<p>Body</p>' };
+            const result = inlineHtml('reply', '', data);
+            assert.ok(result.includes('&lt;&gt;'));
+            assert.ok(result.includes('wrote:'));
+        });
+
+        it('should create reply with no date', () => {
+            const data = {
+                from: [{ name: 'Sender', address: 's@test.com' }],
+                html: '<p>Body</p>'
+            };
+            const result = inlineHtml('reply', '', data);
+            assert.ok(result.includes('wrote:'));
+            assert.ok(!result.includes('undefined'));
+        });
+    });
+
+    describe('forward action', () => {
+        it('should create forward with all headers', () => {
+            const result = inlineHtml('forward', '<p>FYI</p>', fullMessageData);
+            assert.ok(result.includes('Begin forwarded message:'));
+            assert.ok(result.includes('<b>From: </b>'));
+            assert.ok(result.includes('<b>Subject: </b>'));
+            assert.ok(result.includes('<b>Date: </b>'));
+            assert.ok(result.includes('<b>To: </b>'));
+            assert.ok(result.includes('<b>Cc: </b>'));
+            assert.ok(result.includes('<b>Bcc: </b>'));
+            assert.ok(result.includes('FYI'));
+            assert.ok(result.includes('Original message'));
+        });
+
+        it('should include from fallback in forward with no from', () => {
+            const data = { subject: 'Fwd', html: '<p>Body</p>' };
+            const result = inlineHtml('forward', '', data);
+            assert.ok(result.includes('Begin forwarded message:'));
+            assert.ok(!result.includes('<b>From: </b>'));
+        });
+    });
+
+    describe('unknown action', () => {
+        it('should include original body in blockquote without header lines', () => {
+            const data = { html: '<p>Body</p>' };
+            const result = inlineHtml('draft', '', data);
+            assert.ok(result.includes('<blockquote'));
+            assert.ok(result.includes('Body'));
+            assert.ok(!result.includes('wrote:'));
+            assert.ok(!result.includes('Begin forwarded message:'));
+        });
+    });
+
+    describe('original body extraction', () => {
+        it('should use textToHtml when messageData has text but no html', () => {
+            const data = { text: 'Plain text original' };
+            const result = inlineHtml('reply', '', data);
+            assert.ok(result.includes('Plain text original'));
+            assert.ok(result.includes('<blockquote'));
+        });
+
+        it('should extract body innerHTML when messageData has html', () => {
+            const data = { html: '<html><body><p>Extracted</p></body></html>' };
+            const result = inlineHtml('reply', '', data);
+            assert.ok(result.includes('<p>Extracted</p>'));
+            assert.ok(!result.includes('<body>'));
+        });
+
+        it('should extract content when html has no body tag', () => {
+            const data = { html: '<p>No body tag</p>' };
+            const result = inlineHtml('reply', '', data);
+            assert.ok(result.includes('No body tag'));
+        });
+
+        it('should return messageContent unchanged when no originalBody', () => {
+            const data = { text: '', html: '' };
+            const result = inlineHtml('reply', 'Untouched', data);
+            assert.equal(result, 'Untouched');
+        });
+
+        it('should return messageContent when messageData has no text or html', () => {
+            const result = inlineHtml('reply', 'Keep this', {});
+            assert.equal(result, 'Keep this');
+        });
+    });
+
+    describe('address formatting', () => {
+        it('should format address with both name and address', () => {
+            const data = {
+                from: [{ name: 'Full Name', address: 'full@test.com' }],
+                html: '<p>Body</p>'
+            };
+            const result = inlineHtml('forward', '', data);
+            assert.ok(result.includes('Full Name'));
+            assert.ok(result.includes('mailto:full@test.com'));
+        });
+
+        it('should format address with name only', () => {
+            const data = {
+                from: [{ name: 'Name Only' }],
+                html: '<p>Body</p>'
+            };
+            const result = inlineHtml('forward', '', data);
+            assert.ok(result.includes('Name Only'));
+            assert.ok(!result.includes('mailto:'));
+        });
+
+        it('should format address with address only', () => {
+            const data = {
+                from: [{ address: 'addr@test.com' }],
+                html: '<p>Body</p>'
+            };
+            const result = inlineHtml('forward', '', data);
+            assert.ok(result.includes('mailto:addr@test.com'));
+        });
+
+        it('should use <> fallback for empty address object', () => {
+            const data = {
+                from: [{}],
+                html: '<p>Body</p>'
+            };
+            const result = inlineHtml('reply', '', data);
+            assert.ok(result.includes('&lt;&gt;'));
+        });
+
+        it('should format multiple addresses separated by commas', () => {
+            const data = {
+                to: [
+                    { name: 'A', address: 'a@t.com' },
+                    { name: 'B', address: 'b@t.com' }
+                ],
+                html: '<p>Body</p>'
+            };
+            const result = inlineHtml('forward', '', data);
+            assert.ok(result.includes('a@t.com'));
+            assert.ok(result.includes('b@t.com'));
+        });
+
+        it('should skip invalid entries in address list', () => {
+            const data = {
+                to: [null, {}, { name: 'Valid', address: 'v@t.com' }],
+                html: '<p>Body</p>'
+            };
+            const result = inlineHtml('forward', '', data);
+            assert.ok(result.includes('v@t.com'));
+        });
+
+        it('should omit header for empty address list result', () => {
+            const data = {
+                to: [{}],
+                html: '<p>Body</p>'
+            };
+            const result = inlineHtml('forward', '', data);
+            assert.ok(!result.includes('<b>To: </b>'));
+        });
+    });
+
+    describe('date formatting', () => {
+        it('should format date with locale option', () => {
+            const data = { date: baseDate, html: '<p>Body</p>' };
+            const result = inlineHtml('forward', '', data, { locale: 'de' });
+            assert.ok(result.includes('<b>Date: </b>'));
+        });
+
+        it('should format date with timezone option', () => {
+            const data = { date: baseDate, html: '<p>Body</p>' };
+            const result = inlineHtml('forward', '', data, { tz: 'America/New_York' });
+            assert.ok(result.includes('<b>Date: </b>'));
+        });
+
+        it('should format date with both locale and timezone', () => {
+            const data = { date: baseDate, html: '<p>Body</p>' };
+            const result = inlineHtml('forward', '', data, { locale: 'en', tz: 'UTC' });
+            assert.ok(result.includes('<b>Date: </b>'));
+        });
+    });
+
+    describe('messageContent handling', () => {
+        it('should handle null messageContent', () => {
+            const data = { html: '<p>Body</p>' };
+            const result = inlineHtml('reply', null, data);
+            assert.ok(result.includes('<html>'));
+            assert.ok(result.includes('Body'));
+        });
+
+        it('should extract body from full HTML messageContent', () => {
+            const data = { html: '<p>Original</p>' };
+            const result = inlineHtml('reply', '<html><body><p>Reply content</p></body></html>', data);
+            assert.ok(result.includes('Reply content'));
+        });
+    });
+
+    describe('output structure', () => {
+        it('should produce valid HTML document structure', () => {
+            const result = inlineHtml('reply', 'Reply', fullMessageData);
+            assert.ok(result.includes('<html>'));
+            assert.ok(result.includes('<head>'));
+            assert.ok(result.includes('charset=utf-8'));
+            assert.ok(result.includes('<body'));
+            assert.ok(result.includes('</html>'));
+        });
+    });
+});

package/test/inline-text.test.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const inlineText = require('../lib/inline-text');
+
+describe('inline-text', () => {
+    const baseDate = new Date('2024-06-15T14:30:00Z');
+
+    const fullMessageData = {
+        from: [{ name: 'Alice Sender', address: 'alice@example.com' }],
+        subject: 'Test Subject',
+        date: baseDate,
+        to: [{ name: 'Bob', address: 'bob@example.com' }],
+        cc: [{ name: 'Charlie', address: 'charlie@example.com' }],
+        bcc: [{ address: 'secret@example.com' }],
+        text: 'Original message text'
+    };
+
+    describe('reply action', () => {
+        it('should create reply with "On date, from wrote:" header', () => {
+            const result = inlineText('reply', 'My reply', fullMessageData);
+            assert.ok(result.includes('My reply'));
+            assert.ok(result.includes('> On '));
+            assert.ok(result.includes('wrote:'));
+            assert.ok(result.includes('alice@example.com'));
+            assert.ok(result.includes('> Original message text'));
+        });
+
+        it('should create reply with no from using <> fallback', () => {
+            const data = { date: baseDate, text: 'Body text' };
+            const result = inlineText('reply', '', data);
+            assert.ok(result.includes('<>'));
+            assert.ok(result.includes('wrote:'));
+        });
+
+        it('should include original body with > quoting', () => {
+            const data = { text: 'Line 1\nLine 2\nLine 3' };
+            const result = inlineText('reply', 'Reply', data);
+            assert.ok(result.includes('> Line 1'));
+            assert.ok(result.includes('> Line 2'));
+            assert.ok(result.includes('> Line 3'));
+        });
+    });
+
+    describe('forward action', () => {
+        it('should create forward with all headers', () => {
+            const result = inlineText('forward', 'FYI', fullMessageData);
+            assert.ok(result.includes('> Begin forwarded message:'));
+            assert.ok(result.includes('> From:'));
+            assert.ok(result.includes('> Subject: Test Subject'));
+            assert.ok(result.includes('> Date:'));
+            assert.ok(result.includes('> To:'));
+            assert.ok(result.includes('> Cc:'));
+            assert.ok(result.includes('> Bcc:'));
+            assert.ok(result.includes('> Original message text'));
+        });
+
+        it('should omit from header when no from provided', () => {
+            const data = { subject: 'Fwd', text: 'Body' };
+            const result = inlineText('forward', '', data);
+            assert.ok(result.includes('> Begin forwarded message:'));
+            assert.ok(result.includes('> Subject: Fwd'));
+            assert.ok(!result.includes('> From:'));
+        });
+    });
+
+    describe('unknown action', () => {
+        it('should include original body without typed headers', () => {
+            const data = { text: 'Body text' };
+            const result = inlineText('other', '', data);
+            assert.ok(result.includes('> Body text'));
+            assert.ok(!result.includes('wrote:'));
+            assert.ok(!result.includes('Begin forwarded message:'));
+        });
+    });
+
+    describe('original body source', () => {
+        it('should use htmlToText when messageData has html but no text', () => {
+            const data = { html: '<p>HTML content</p>' };
+            const result = inlineText('reply', '', data);
+            assert.ok(result.includes('HTML content'));
+        });
+
+        it('should use text directly when available', () => {
+            const data = { text: 'Direct text', html: '<p>HTML</p>' };
+            const result = inlineText('reply', '', data);
+            assert.ok(result.includes('> Direct text'));
+        });
+
+        it('should return messageContent unchanged when no originalBody', () => {
+            const result = inlineText('reply', 'Keep this', { text: '' });
+            assert.equal(result, 'Keep this');
+        });
+
+        it('should return messageContent when messageData is empty', () => {
+            const result = inlineText('reply', 'Keep', {});
+            assert.equal(result, 'Keep');
+        });
+    });
+
+    describe('address formatting', () => {
+        it('should format address with name and address', () => {
+            const data = {
+                from: [{ name: 'Full Name', address: 'full@test.com' }],
+                text: 'Body'
+            };
+            const result = inlineText('forward', '', data);
+            assert.ok(result.includes('Full Name <full@test.com>'));
+        });
+
+        it('should format address with name only', () => {
+            const data = {
+                from: [{ name: 'Name Only' }],
+                text: 'Body'
+            };
+            const result = inlineText('forward', '', data);
+            assert.ok(result.includes('Name Only'));
+            assert.ok(!result.includes('<>'));
+        });
+
+        it('should format address with address only', () => {
+            const data = {
+                from: [{ address: 'addr@test.com' }],
+                text: 'Body'
+            };
+            const result = inlineText('forward', '', data);
+            assert.ok(result.includes('<addr@test.com>'));
+        });
+
+        it('should use <> fallback for empty address object', () => {
+            const data = {
+                from: [{}],
+                text: 'Body'
+            };
+            const result = inlineText('reply', '', data);
+            assert.ok(result.includes('<>'));
+        });
+
+        it('should format multiple addresses separated by commas', () => {
+            const data = {
+                to: [
+                    { name: 'A', address: 'a@t.com' },
+                    { name: 'B', address: 'b@t.com' }
+                ],
+                text: 'Body'
+            };
+            const result = inlineText('forward', '', data);
+            assert.ok(result.includes('A <a@t.com>'));
+            assert.ok(result.includes('B <b@t.com>'));
+        });
+
+        it('should skip invalid entries in address list', () => {
+            const data = {
+                to: [null, {}, { name: 'Valid', address: 'v@t.com' }],
+                text: 'Body'
+            };
+            const result = inlineText('forward', '', data);
+            assert.ok(result.includes('Valid <v@t.com>'));
+        });
+
+        it('should omit header for empty address list result', () => {
+            const data = {
+                to: [{}],
+                text: 'Body'
+            };
+            const result = inlineText('forward', '', data);
+            assert.ok(!result.includes('> To:'));
+        });
+    });
+
+    describe('escapeText', () => {
+        it('should handle \\r\\n line endings', () => {
+            const data = { text: 'Line1\r\nLine2\r\nLine3' };
+            const result = inlineText('reply', '', data);
+            assert.ok(result.includes('> Line1'));
+            assert.ok(result.includes('> Line2'));
+            assert.ok(result.includes('> Line3'));
+        });
+    });
+
+    describe('date formatting', () => {
+        it('should format date with locale', () => {
+            const data = { date: baseDate, text: 'Body' };
+            const result = inlineText('forward', '', data, { locale: 'de' });
+            assert.ok(result.includes('> Date:'));
+        });
+
+        it('should format date with timezone', () => {
+            const data = { date: baseDate, text: 'Body' };
+            const result = inlineText('forward', '', data, { tz: 'America/New_York' });
+            assert.ok(result.includes('> Date:'));
+        });
+    });
+
+    describe('messageContent handling', () => {
+        it('should handle null messageContent', () => {
+            const data = { text: 'Body' };
+            const result = inlineText('reply', null, data);
+            assert.ok(typeof result === 'string');
+            assert.ok(result.includes('> Body'));
+        });
+    });
+});

package/test/mime-html-extra.test.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { describe, it, after } = require('node:test');
+const assert = require('node:assert/strict');
+const mimeHtml = require('../lib/mime-html');
+
+describe('mime-html additional coverage', () => {
+    after(async () => {
+        await mimeHtml.closeWorkerPool();
+    });
+
+    describe('getWorkerPoolStats', () => {
+        it('should return null when no pool is initialized', async () => {
+            await mimeHtml.closeWorkerPool();
+            const stats = mimeHtml.getWorkerPoolStats();
+            assert.equal(stats, null);
+        });
+    });
+
+    describe('pool fallback to single worker', () => {
+        it('should still return result when pool times out and falls back', async () => {
+            await mimeHtml.closeWorkerPool();
+
+            // Use timeout: 1 to force pool timeout, triggering fallback to single worker
+            // Both may time out, but fallbackOnError defaults to true so processing continues
+            const result = await mimeHtml.async(
+                { html: '<p>Fallback test</p>' },
+                {
+                    timeout: 1,
+                    useWorkerPool: true
+                }
+            );
+
+            // Should still get a result (with or without inlined CSS)
+            assert.ok(result.includes('Fallback test'));
+        });
+    });
+});

package/test/text-to-html-extra.test.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const textToHtml = require('../lib/text-to-html');
+
+describe('text-to-html additional coverage', () => {
+    describe('trailing quoted lines', () => {
+        it('should handle text ending with quoted lines', () => {
+            const result = textToHtml('Normal line\n> Quoted at end\n> Still quoted');
+            assert.ok(result.includes('<blockquote'));
+            assert.ok(result.includes('Quoted at end'));
+            assert.ok(result.includes('Still quoted'));
+            assert.ok(result.includes('Normal line'));
+        });
+    });
+
+    describe('horizontal rule detection', () => {
+        it('should convert --- to <hr /> when followed by non-empty line', () => {
+            const result = textToHtml('Before\n---\nAfter');
+            assert.ok(result.includes('<hr />'));
+            assert.ok(result.includes('Before'));
+            assert.ok(result.includes('After'));
+        });
+
+        it('should convert --- to <hr /> when it is the last line', () => {
+            const result = textToHtml('Before\n---');
+            assert.ok(result.includes('<hr />'));
+            assert.ok(result.includes('Before'));
+        });
+
+        it('should convert ___ to <hr />', () => {
+            const result = textToHtml('Before\n___\nAfter');
+            assert.ok(result.includes('<hr />'));
+        });
+
+        it('should convert --- to <hr /> when followed by empty line', () => {
+            const result = textToHtml('Before\n---\n');
+            assert.ok(result.includes('<hr />'));
+        });
+    });
+});

package/test/worker-pool-extra.test.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const { describe, it, before, after, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('path');
+const fs = require('fs');
+const WorkerPool = require('../lib/worker-pool');
+
+const crashWorkerPath = path.join(__dirname, 'crash-test-worker.js');
+const crashWorkerCode = `
+'use strict';
+const { parentPort } = require('worker_threads');
+parentPort.on('message', (data) => {
+    if (data === 'crash') {
+        setTimeout(() => { throw new Error('intentional crash'); }, 0);
+    } else if (data === 'slow') {
+        setTimeout(() => {
+            parentPort.postMessage({ success: true, result: 'slow: ' + data });
+        }, 50);
+    } else {
+        parentPort.postMessage({ success: true, result: 'ok: ' + data });
+    }
+});
+`;
+
+describe('WorkerPool additional coverage', () => {
+    let pool;
+
+    before(() => {
+        fs.writeFileSync(crashWorkerPath, crashWorkerCode);
+    });
+
+    after(() => {
+        try {
+            fs.unlinkSync(crashWorkerPath);
+        } catch (_err) {
+            // ignore cleanup errors
+        }
+    });
+
+    afterEach(async () => {
+        if (pool) {
+            await pool.close();
+            pool = null;
+        }
+    });
+
+    describe('worker error handling', () => {
+        it('should replace a crashed worker and remain functional', async () => {
+            pool = new WorkerPool({
+                workerPath: crashWorkerPath,
+                minWorkers: 2,
+                maxWorkers: 3
+            });
+
+            // Verify initial state
+            let stats = pool.getStats();
+            assert.equal(stats.totalWorkers, 2);
+
+            // Trigger a crash
+            try {
+                await pool.process('crash');
+                assert.fail('Should have rejected');
+            } catch (err) {
+                assert.ok(err);
+            }
+
+            // Wait for replacement worker to be created
+            await new Promise(r => setTimeout(r, 300));
+
+            // Pool should have replaced the crashed worker
+            stats = pool.getStats();
+            assert.ok(stats.totalWorkers >= 2, `Expected >= 2 workers but got ${stats.totalWorkers}`);
+
+            // Pool should still be functional
+            const result = await pool.process('hello');
+            assert.equal(result, 'ok: hello');
+        });
+    });
+
+    describe('idle timeout', () => {
+        it('should terminate idle worker above minimum via _setupIdleTimeout', async () => {
+            pool = new WorkerPool({
+                workerPath: crashWorkerPath,
+                minWorkers: 1,
+                maxWorkers: 3,
+                idleTimeout: 200
+            });
+
+            assert.equal(pool.getStats().totalWorkers, 1);
+
+            // Manually create an extra worker above minWorkers (without a task).
+            // This triggers _setupIdleTimeout in _createWorker.
+            pool._createWorker();
+
+            assert.equal(pool.getStats().totalWorkers, 2);
+
+            // Wait for idle timeout to fire and remove the extra worker
+            await new Promise(r => setTimeout(r, 400));
+
+            assert.equal(pool.getStats().totalWorkers, 1);
+        });
+    });
+
+    describe('close with active idle timeouts', () => {
+        it('should close cleanly when workers have pending idle timeouts', async () => {
+            pool = new WorkerPool({
+                workerPath: crashWorkerPath,
+                minWorkers: 1,
+                maxWorkers: 3,
+                idleTimeout: 10000
+            });
+
+            // Scale up
+            const promises = [];
+            for (let i = 0; i < 3; i++) {
+                promises.push(pool.process(`task-${i}`));
+            }
+            await Promise.all(promises);
+
+            // Workers above min should have idle timeouts set
+            let stats = pool.getStats();
+            assert.ok(stats.totalWorkers > 1);
+
+            // Close immediately before idle timeout fires
+            await pool.close();
+            pool = null;
+
+            // Should not throw or leak timers
+        });
+    });
+});