bunqueue 2.8.0 → 2.8.2

package/dist/client/queue/stall.js

@@ -45,4 +45,3 @@ export async function getStallConfigAsync(ctx) {
     }
     return response.config;
 }
-//# sourceMappingURL=stall.js.map

package/dist/client/queue/workers.d.ts

@@ -26,4 +26,3 @@ export declare function getMetrics(ctx: WorkersContext, type: 'completed' | 'fai
 /** Trim events (no-op in bunqueue - events are real-time) */
 export declare function trimEvents(_ctx: WorkersContext, _maxLength: number): Promise<number>;
 export {};
-//# sourceMappingURL=workers.d.ts.map

package/dist/client/queue/workers.js

@@ -36,4 +36,3 @@ export async function getMetrics(ctx, type, _start, _end) {
 export function trimEvents(_ctx, _maxLength) {
     return Promise.resolve(0);
 }
-//# sourceMappingURL=workers.js.map

package/dist/client/queue.d.ts

@@ -3,4 +3,3 @@
  * @deprecated Import from './queue' instead
  */
 export { Queue } from './queue/queue';
-//# sourceMappingURL=queue.d.ts.map

package/dist/client/queue.js

@@ -3,4 +3,3 @@
  * @deprecated Import from './queue' instead
  */
 export { Queue } from './queue/queue';
-//# sourceMappingURL=queue.js.map

package/dist/client/queueGroup.d.ts

@@ -38,4 +38,3 @@ export declare class QueueGroup {
     /** Obliterate all queues in this group (remove all data) */
     obliterateAll(): void;
 }
-//# sourceMappingURL=queueGroup.d.ts.map

package/dist/client/queueGroup.js

@@ -78,4 +78,3 @@ export class QueueGroup {
         }
     }
 }
-//# sourceMappingURL=queueGroup.js.map

package/dist/client/resolveToken.d.ts

@@ -8,4 +8,3 @@
  * Empty strings are treated as not set.
  */
 export declare function resolveToken(explicitToken: string | undefined): string | undefined;
-//# sourceMappingURL=resolveToken.d.ts.map

package/dist/client/resolveToken.js

@@ -18,4 +18,3 @@ export function resolveToken(explicitToken) {
         return bunqueueToken;
     return undefined;
 }
-//# sourceMappingURL=resolveToken.js.map

package/dist/client/sandboxed/index.d.ts

@@ -5,4 +5,3 @@
 export type { SandboxedWorkerOptions, RequiredSandboxedWorkerOptions, WorkerProcess, IPCRequest, IPCResponse, } from './types';
 export { createWrapperScript, cleanupWrapperScript } from './wrapper';
 export { SandboxedWorker } from './worker';
-//# sourceMappingURL=index.d.ts.map

package/dist/client/sandboxed/index.js

@@ -4,4 +4,3 @@
  */
 export { createWrapperScript, cleanupWrapperScript } from './wrapper';
 export { SandboxedWorker } from './worker';
-//# sourceMappingURL=index.js.map

package/dist/client/sandboxed/queueOps.d.ts

@@ -22,4 +22,3 @@ export interface QueueOps {
 export declare function createEmbeddedOps(manager: SharedManager): QueueOps;
 /** Create TCP mode operations using connection pool */
 export declare function createTcpOps(tcp: TcpConnectionPool): QueueOps;
-//# sourceMappingURL=queueOps.d.ts.map

package/dist/client/sandboxed/queueOps.js

@@ -71,4 +71,3 @@ export function createTcpOps(tcp) {
         },
     };
 }
-//# sourceMappingURL=queueOps.js.map

package/dist/client/sandboxed/types.d.ts

@@ -77,4 +77,3 @@ export interface IPCResponse {
     progress?: number;
     message?: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/client/sandboxed/types.js

@@ -3,4 +3,3 @@
  * Type definitions for sandboxed worker processes
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/client/sandboxed/worker.d.ts

@@ -84,4 +84,3 @@ export declare class SandboxedWorker<T = unknown> extends EventEmitter {
     /** Create a public Job object from a DomainJob for event payloads */
     private createEventJob;
 }
-//# sourceMappingURL=worker.d.ts.map

package/dist/client/sandboxed/worker.js

@@ -7,6 +7,7 @@ import { getSharedManager } from '../manager';
 import { getSharedPool, releaseSharedPool } from '../tcpPool';
 import { createPublicJob } from '../jobConversion';
 import { jobId } from '../../domain/types/job';
+import { createProgressHandler, createLogHandler, createGetStateHandler, createGetChildrenValuesHandler, createGetFailedChildrenValuesHandler, createGetIgnoredChildrenFailuresHandler, createRemoveChildDependencyHandler, createRemoveUnprocessedChildrenHandler, createRemoveHandler, createRetryHandler, createUpdateDataHandler, createPromoteHandler, createChangeDelayHandler, createChangePriorityHandler, createExtendLockHandler, createClearLogsHandler, createMoveToWaitHandler, createMoveToDelayedHandler, createMoveToWaitingChildrenHandler, createWaitUntilFinishedHandler, createDiscardHandler, createGetDependenciesHandler, createGetDependenciesCountHandler, createRemoveDeduplicationKeyHandler, } from '../worker/processorHandlers';
 import { createWrapperScript, cleanupWrapperScript } from './wrapper';
 import { createEmbeddedOps, createTcpOps } from './queueOps';
 const LOG_PREFIX = '[SandboxedWorker]';
@@ -92,12 +93,17 @@ export class SandboxedWorker extends EventEmitter {
         if (this.tcp)
             await this.tcp.connect();
         this.wrapperPath = await createWrapperScript(this.queueName, this.options.processor);
-        // Spawn all workers and wait for them to be ready
-        const spawnPromises = [];
-        for (let i = 0; i < this.options.concurrency; i++) {
-            spawnPromises.push(this.spawnWorker(i));
+        // Spawn the first worker synchronously so Bun's bundler resolves and caches
+        // the wrapper entry point before concurrent siblings race for it. Remaining
+        // workers can then spawn in parallel without a ModuleNotFound flake.
+        await this.spawnWorker(0);
+        if (this.options.concurrency > 1) {
+            const spawnPromises = [];
+            for (let i = 1; i < this.options.concurrency; i++) {
+                spawnPromises.push(this.spawnWorker(i));
+            }
+            await Promise.all(spawnPromises);
         }
-        await Promise.all(spawnPromises);
         this.startHeartbeat();
         this.emit('ready');
         this.pullPromise = this.pullLoop();
@@ -496,20 +502,55 @@ export class SandboxedWorker extends EventEmitter {
     /** Create a public Job object from a DomainJob for event payloads */
     createEventJob(domainJob) {
         const data = domainJob.data;
+        const embedded = !this.tcp;
+        const tcp = this.tcp;
+        // Event-context moveToCompleted/moveToFailed: direct ack/fail without manual-move tracking
+        const moveToCompleted = async (id, returnValue, _token) => {
+            if (embedded) {
+                await getSharedManager().ack(jobId(id), returnValue);
+            }
+            else if (tcp) {
+                await tcp.send({ cmd: 'ACK', id, result: returnValue });
+            }
+            return null;
+        };
+        const moveToFailed = async (id, error, _token) => {
+            if (embedded) {
+                await getSharedManager().fail(jobId(id), error.message);
+            }
+            else if (tcp) {
+                await tcp.send({ cmd: 'FAIL', id, error: error.message });
+            }
+        };
         return createPublicJob({
             job: domainJob,
             name: data?.name ?? 'default',
-            updateProgress: async () => { },
-            log: async () => { },
-            getState: async (id) => {
-                if (this.tcp) {
-                    const response = await this.tcp.send({ cmd: 'GetState', id });
-                    return (response.state ?? 'unknown');
-                }
-                const manager = getSharedManager();
-                return (await manager.getJobState(jobId(id)));
-            },
+            updateProgress: createProgressHandler(embedded, tcp, this, { current: null }),
+            log: createLogHandler(embedded, tcp, this, { current: null }),
+            getState: createGetStateHandler(embedded, tcp),
+            getChildrenValues: createGetChildrenValuesHandler(embedded, tcp),
+            getFailedChildrenValues: createGetFailedChildrenValuesHandler(embedded, tcp),
+            getIgnoredChildrenFailures: createGetIgnoredChildrenFailuresHandler(embedded, tcp),
+            removeChildDependency: createRemoveChildDependencyHandler(embedded, tcp),
+            removeUnprocessedChildren: createRemoveUnprocessedChildrenHandler(embedded, tcp),
+            remove: createRemoveHandler(embedded, tcp),
+            retry: createRetryHandler(embedded, tcp, domainJob),
+            updateData: createUpdateDataHandler(embedded, tcp),
+            promote: createPromoteHandler(embedded, tcp),
+            changeDelay: createChangeDelayHandler(embedded, tcp),
+            changePriority: createChangePriorityHandler(embedded, tcp),
+            extendLock: createExtendLockHandler(embedded, tcp),
+            clearLogs: createClearLogsHandler(embedded, tcp),
+            moveToWait: createMoveToWaitHandler(embedded, tcp),
+            moveToDelayed: createMoveToDelayedHandler(embedded, tcp),
+            moveToWaitingChildren: createMoveToWaitingChildrenHandler(embedded, tcp),
+            waitUntilFinished: createWaitUntilFinishedHandler(embedded, tcp),
+            discard: createDiscardHandler(embedded, tcp),
+            getDependencies: createGetDependenciesHandler(embedded, tcp, domainJob),
+            getDependenciesCount: createGetDependenciesCountHandler(embedded, tcp, domainJob),
+            removeDeduplicationKey: createRemoveDeduplicationKeyHandler(),
+            moveToCompleted,
+            moveToFailed,
         });
     }
 }
-//# sourceMappingURL=worker.js.map

package/dist/client/sandboxed/wrapper.d.ts

@@ -10,4 +10,3 @@ export declare function createWrapperScript(queueName: string, processorPath: st
  * Cleanup wrapper script file
  */
 export declare function cleanupWrapperScript(wrapperPath: string | null): Promise<void>;
-//# sourceMappingURL=wrapper.d.ts.map

package/dist/client/sandboxed/wrapper.js

@@ -2,7 +2,9 @@
  * Worker Wrapper Script Generator
  * Creates the wrapper script that loads processor in worker process
  */
-import { mkdir, unlink } from 'node:fs/promises';
+import { mkdir, unlink, realpath } from 'node:fs/promises';
+import { closeSync, fsyncSync, openSync, writeSync } from 'node:fs';
+import { join, normalize } from 'node:path';
 /**
  * Escape a string for safe embedding in a template literal
  * Prevents code injection via backticks or backslashes in paths
@@ -14,9 +16,38 @@ function escapeForTemplateLiteral(str) {
  * Create wrapper script file that loads the processor
  */
 export async function createWrapperScript(queueName, processorPath) {
-    const fullPath = processorPath.startsWith('/')
-        ? processorPath
-        : `${process.cwd()}/${processorPath}`;
+    // Normalize the path so double slashes from callers like
+    // `${TMPDIR}/file` (TMPDIR often ends with `/`) don't trip the Worker's
+    // import resolver. Then resolve symlinks (e.g. macOS `/var` → `/private/var`)
+    // so the import target matches what Bun's module loader will see.
+    const normalized = normalize(processorPath.startsWith('/') ? processorPath : `${process.cwd()}/${processorPath}`);
+    // Verify the processor file is visible on disk before generating a wrapper
+    // that will import it from a Worker thread. On macOS, files written by
+    // Bun.write (no fsync) can briefly be invisible to fresh Worker processes,
+    // surfacing as ModuleNotFound when the wrapper's top-level await import()
+    // runs. Poll briefly with a fast cap to catch the race without slowing
+    // the happy path.
+    let processorVisible = false;
+    for (let i = 0; i < 20; i++) {
+        if (await Bun.file(normalized).exists()) {
+            processorVisible = true;
+            break;
+        }
+        await Bun.sleep(5);
+    }
+    if (!processorVisible) {
+        throw new Error(`Processor file not visible after polling: ${normalized}`);
+    }
+    // Resolve symlinks AFTER the existence check so a non-existent file fails
+    // with a clear error rather than realpath's ENOENT.
+    let fullPath;
+    try {
+        fullPath = await realpath(normalized);
+    }
+    catch {
+        // realpath can fail in restricted sandboxes; fall back to normalized.
+        fullPath = normalized;
+    }
     // Escape the path to prevent code injection via backticks or template expressions
     const escapedPath = escapeForTemplateLiteral(fullPath);
     const wrapperCode = `
@@ -59,13 +90,34 @@ self.onmessage = async (event) => {
   }
 };
 `;
-    const tempDir = `${Bun.env.TMPDIR ?? '/tmp'}/bunqueue-workers`;
-    const tempDirFile = Bun.file(tempDir);
-    if (!(await tempDirFile.exists())) {
-        await mkdir(tempDir, { recursive: true });
+    // path.join normalizes double slashes ($TMPDIR often ends in '/').
+    const tempDir = join(Bun.env.TMPDIR ?? '/tmp', 'bunqueue-workers');
+    await mkdir(tempDir, { recursive: true });
+    const wrapperPath = join(tempDir, `worker-${queueName}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}.ts`);
+    // Write with explicit fsync so Bun's Worker spawn sees the file on macOS,
+    // where fs/promises.writeFile (no fdatasync) has produced ModuleNotFound.
+    const fd = openSync(wrapperPath, 'w');
+    try {
+        writeSync(fd, wrapperCode);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    // Belt-and-braces: some macOS environments still need a moment for the
+    // dirent to be visible to a fresh Worker process. Poll, then throw if
+    // still missing — swallowing here just moves the failure into Worker spawn.
+    let visible = false;
+    for (let i = 0; i < 10; i++) {
+        if (await Bun.file(wrapperPath).exists()) {
+            visible = true;
+            break;
+        }
+        await Bun.sleep(5);
+    }
+    if (!visible) {
+        throw new Error(`Wrapper script not visible after fsync: ${wrapperPath}`);
     }
-    const wrapperPath = `${tempDir}/worker-${queueName}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}.ts`;
-    await Bun.write(wrapperPath, wrapperCode);
     return wrapperPath;
 }
 /**
@@ -84,4 +136,3 @@ export async function cleanupWrapperScript(wrapperPath) {
         // Ignore cleanup errors
     }
 }
-//# sourceMappingURL=wrapper.js.map

package/dist/client/sandboxedWorker.d.ts

@@ -4,4 +4,3 @@
  */
 export type { SandboxedWorkerOptions } from './sandboxed';
 export { SandboxedWorker } from './sandboxed';
-//# sourceMappingURL=sandboxedWorker.d.ts.map

package/dist/client/sandboxedWorker.js

@@ -3,4 +3,3 @@
  * @deprecated Import from './sandboxed' instead
  */
 export { SandboxedWorker } from './sandboxed';
-//# sourceMappingURL=sandboxedWorker.js.map

package/dist/client/tcp/client.d.ts

@@ -5,6 +5,15 @@
  */
 import { EventEmitter } from 'events';
 import type { ConnectionOptions, ConnectionHealth } from './types';
+/**
+ * Sentinel error class for the synthetic rejection issued by close()/rejectAll().
+ * Using a dedicated subclass (instead of matching `error.message`) ensures the
+ * process-level filter never collides with user code that happens to throw an
+ * Error whose message is "Client closed" (Redis, HTTP, DB pool clients all do).
+ */
+export declare class ClientClosedError extends Error {
+    constructor(message?: string);
+}
 /**
  * TCP Client - manages connection to bunqueue server
  * Supports pipelining for high-throughput operations
@@ -93,4 +102,3 @@ export declare class TcpClient extends EventEmitter {
     /** Get number of in-flight commands (for monitoring) */
     getInFlightCount(): number;
 }
-//# sourceMappingURL=client.d.ts.map

package/dist/client/tcp/client.js

@@ -10,6 +10,46 @@ import { ReconnectManager } from './reconnect';
 import { createConnection, CommandQueue } from './connection';
 import { pack, unpack } from 'msgpackr';
 import { FrameParser } from '../../infrastructure/server/protocol';
+/**
+ * Sentinel error class for the synthetic rejection issued by close()/rejectAll().
+ * Using a dedicated subclass (instead of matching `error.message`) ensures the
+ * process-level filter never collides with user code that happens to throw an
+ * Error whose message is "Client closed" (Redis, HTTP, DB pool clients all do).
+ */
+export class ClientClosedError extends Error {
+    constructor(message = 'Client closed') {
+        super(message);
+        this.name = 'ClientClosedError';
+    }
+}
+/**
+ * One-time installer of a process-level filter that swallows the synthetic
+ * ClientClosedError issued by close()/rejectAll(). Catches the rare chained-
+ * Promise leak that `cmd.promise?.catch(() => {})` in rejectAll cannot reach
+ * (e.g. await-then-throw patterns where the rejection propagates through the
+ * awaiter's own Promise chain).
+ *
+ * Implementation note: the listener is intentionally a no-op for non-matching
+ * rejections. process.on('unhandledRejection', fn) calls all registered
+ * listeners independently — so existing handlers (e.g. main.ts shutdown
+ * handler) still fire for real rejections. We must NOT re-throw here because
+ * a throw inside an unhandledRejection listener becomes an uncaughtException,
+ * which would interact badly with main.ts's existing uncaughtException
+ * handler and cause double-shutdown attempts.
+ */
+let clientClosedFilterInstalled = false;
+function installClientClosedFilter() {
+    if (clientClosedFilterInstalled)
+        return;
+    clientClosedFilterInstalled = true;
+    process.on('unhandledRejection', (reason) => {
+        if (reason instanceof ClientClosedError) {
+            return; // swallow — other listeners (if any) fire independently
+        }
+        // Non-matching rejection: no-op here. Other registered listeners (or the
+        // runtime default per --unhandled-rejections) handle it independently.
+    });
+}
 /**
  * TCP Client - manages connection to bunqueue server
  * Supports pipelining for high-throughput operations
@@ -158,14 +198,17 @@ export class TcpClient extends EventEmitter {
             this.emit('warning', { type: 'unknown_response', reqId });
         }
         catch {
-            // Invalid response - reject current command if any
-            const current = this.commands.getCurrentCommand();
-            if (current) {
-                clearTimeout(current.timeout);
-                current.reject(new Error('Invalid response from server'));
-                this.commands.setCurrentCommand(null);
-                this.processQueue();
-            }
+            // Malformed/unparseable frame: the framed byte stream is now
+            // unrecoverable (we cannot trust subsequent frame boundaries), and in
+            // pipelining mode the legacy `currentCommand` slot is null — so checking
+            // it alone would leave every in-flight command hanging until its
+            // per-command timeout. Reject ALL pending + in-flight commands promptly
+            // and tear down the socket so reconnection (if enabled) can re-establish
+            // a clean stream.
+            const err = new Error('Invalid response from server');
+            this.emit('warning', { type: 'malformed_frame' });
+            this.commands.rejectAll(err);
+            this.forceReconnect();
         }
     }
     handleClose() {
@@ -248,7 +291,9 @@ export class TcpClient extends EventEmitter {
         this.health.recordCommandSent();
         const reqId = this.generateReqId();
         const commandWithReqId = { ...command, reqId };
-        return new Promise((resolve, reject) => {
+        // Definite-assignment assertion: assigned synchronously by Promise executor below.
+        let pendingRef;
+        const promise = new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 // Try to remove from in-flight
                 const removed = this.commands.removeByReqId(reqId);
@@ -257,7 +302,7 @@ export class TcpClient extends EventEmitter {
                     reject(new Error('Command timeout'));
                 }
             }, this.options.commandTimeout);
-            const pending = {
+            pendingRef = {
                 id: 0,
                 reqId,
                 command: commandWithReqId,
@@ -271,11 +316,13 @@ export class TcpClient extends EventEmitter {
                 },
                 timeout,
             };
-            // Add to in-flight tracking
-            this.commands.addInFlight(pending);
-            // Send immediately
-            this.socket?.write(FrameParser.frame(pack(commandWithReqId)));
         });
+        // Promise constructor executor is synchronous, so pendingRef is assigned.
+        pendingRef.promise = promise;
+        this.commands.addInFlight(pendingRef);
+        // Send immediately (this.socket null-checked at entry of sendDirect)
+        this.socket.write(FrameParser.frame(pack(commandWithReqId)));
+        return promise;
     }
     /**
      * Process queued commands
@@ -313,8 +360,10 @@ export class TcpClient extends EventEmitter {
         this.health.recordCommandSent();
         const reqId = this.generateReqId();
         const commandWithReqId = { ...command, reqId };
-        return new Promise((resolve, reject) => {
-            const id = this.commands.nextId();
+        const id = this.commands.nextId();
+        // Definite-assignment assertion: assigned synchronously by Promise executor below.
+        let pendingRef;
+        const promise = new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 // Try to remove from queue first
                 if (this.commands.remove(id)) {
@@ -329,7 +378,7 @@ export class TcpClient extends EventEmitter {
                     reject(new Error('Command timeout'));
                 }
             }, this.options.commandTimeout);
-            const pending = {
+            pendingRef = {
                 id,
                 reqId,
                 command: commandWithReqId,
@@ -343,24 +392,31 @@ export class TcpClient extends EventEmitter {
                 },
                 timeout,
             };
-            // Add to queue
-            this.commands.enqueue(pending);
-            // Connect if needed, then process queue
-            if (!this.connected && !this.connecting) {
-                // Connection errors during send are handled by command timeout/rejection
-                this.connect().catch(() => { });
-            }
-            else if (this.connected) {
-                this.processQueue();
-            }
         });
+        // Promise constructor executor is synchronous, so pendingRef is assigned.
+        pendingRef.promise = promise;
+        this.commands.enqueue(pendingRef);
+        // Connect if needed, then process queue
+        if (!this.connected && !this.connecting) {
+            // Connection errors during send are handled by command timeout/rejection
+            this.connect().catch(() => { });
+        }
+        else if (this.connected) {
+            this.processQueue();
+        }
+        return promise;
     }
     /** Close connection */
     close() {
         this.reconnect.setClosed(true);
         this.health.stopPing();
         this.reconnect.cancelReconnect();
-        this.commands.rejectAll(new Error('Client closed'));
+        // Install a process-level filter for the synthetic ClientClosedError we
+        // are about to issue. Catches the rare case where a caller's .catch() is
+        // attached on a chained Promise that our cmd.promise?.catch() cannot
+        // reach (await-then-throw patterns).
+        installClientClosedFilter();
+        this.commands.rejectAll(new ClientClosedError());
         if (this.socket) {
             this.socket.end();
             this.socket = null;
@@ -386,4 +442,3 @@ export class TcpClient extends EventEmitter {
         return this.commands.getInFlightCount();
     }
 }
-//# sourceMappingURL=client.js.map

package/dist/client/tcp/connection.d.ts

@@ -65,4 +65,3 @@ export declare class CommandQueue {
     /** Clear current command with optional rejection (legacy mode) */
     clearCurrent(error?: Error): void;
 }
-//# sourceMappingURL=connection.d.ts.map

package/dist/client/tcp/connection.js

@@ -165,9 +165,13 @@ export class CommandQueue {
     }
     /** Reject all pending and in-flight commands */
     rejectAll(error) {
-        // Reject queued commands
+        // Reject queued commands. Attach a silent .catch BEFORE rejecting so that
+        // callers without a .catch in place (fire-and-forget heartbeats, polling
+        // loops mid-await on intentional close) don't surface as unhandled
+        // rejections and force non-zero process exit.
         for (const cmd of this.pendingCommands.values()) {
             clearTimeout(cmd.timeout);
+            cmd.promise?.catch(() => { });
             cmd.reject(error);
         }
         this.pendingCommands.clear();
@@ -175,6 +179,7 @@ export class CommandQueue {
         // Reject in-flight commands (pipelining)
         for (const cmd of this.inFlightByReqId.values()) {
             clearTimeout(cmd.timeout);
+            cmd.promise?.catch(() => { });
             cmd.reject(error);
         }
         this.inFlightByReqId.clear();
@@ -196,4 +201,3 @@ export class CommandQueue {
         }
     }
 }
-//# sourceMappingURL=connection.js.map

package/dist/client/tcp/health.d.ts

@@ -44,4 +44,3 @@ export declare class HealthTracker {
     /** Record latency for averaging */
     private recordLatency;
 }
-//# sourceMappingURL=health.d.ts.map

package/dist/client/tcp/health.js

@@ -92,4 +92,3 @@ export class HealthTracker {
         }
     }
 }
-//# sourceMappingURL=health.js.map

package/dist/client/tcp/index.d.ts

@@ -9,4 +9,3 @@ export { ReconnectManager, type ReconnectConfig } from './reconnect';
 export { createConnection, CommandQueue } from './connection';
 export { TcpClient } from './client';
 export { getSharedTcpClient, closeSharedTcpClient } from './shared';
-//# sourceMappingURL=index.d.ts.map

package/dist/client/tcp/index.js

@@ -8,4 +8,3 @@ export { ReconnectManager } from './reconnect';
 export { createConnection, CommandQueue } from './connection';
 export { TcpClient } from './client';
 export { getSharedTcpClient, closeSharedTcpClient } from './shared';
-//# sourceMappingURL=index.js.map

package/dist/client/tcp/reconnect.d.ts

@@ -45,4 +45,3 @@ export declare class ReconnectManager extends EventEmitter {
      */
     scheduleReconnect(connectFn: () => Promise<void>): boolean;
 }
-//# sourceMappingURL=reconnect.d.ts.map

package/dist/client/tcp/reconnect.js

@@ -75,4 +75,3 @@ export class ReconnectManager extends EventEmitter {
         return true;
     }
 }
-//# sourceMappingURL=reconnect.js.map

package/dist/client/tcp/shared.d.ts

@@ -8,4 +8,3 @@ import { TcpClient } from './client';
 export declare function getSharedTcpClient(options?: Partial<ConnectionOptions>): TcpClient;
 /** Close shared client */
 export declare function closeSharedTcpClient(): void;
-//# sourceMappingURL=shared.d.ts.map

package/dist/client/tcp/shared.js

@@ -17,4 +17,3 @@ export function closeSharedTcpClient() {
         sharedClient = null;
     }
 }
-//# sourceMappingURL=shared.js.map

package/dist/client/tcp/types.d.ts

@@ -63,6 +63,13 @@ export interface PendingCommand {
     resolve: (value: Record<string, unknown>) => void;
     reject: (error: Error) => void;
     timeout: ReturnType<typeof setTimeout>;
+    /**
+     * Reference to the Promise returned to the caller. Used by rejectAll() on
+     * intentional shutdown to attach a silent .catch — prevents unhandled
+     * rejections from leaking when callers (fire-and-forget heartbeats, polling
+     * loops mid-await) don't have a .catch in place at the moment we reject.
+     */
+    promise?: Promise<Record<string, unknown>>;
 }
 /** Socket wrapper interface */
 export interface SocketWrapper {
@@ -74,4 +81,3 @@ export interface SocketWrapper {
 export interface FrameParser {
     addData(data: Uint8Array): Uint8Array[];
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/client/tcp/types.js

@@ -18,4 +18,3 @@ export const DEFAULT_CONNECTION = {
     pipelining: true,
     maxInFlight: 100,
 };
-//# sourceMappingURL=types.js.map

package/dist/client/tcpClient.d.ts

@@ -4,4 +4,3 @@
  */
 export type { ConnectionOptions, ConnectionHealth } from './tcp';
 export { DEFAULT_CONNECTION, TcpClient, getSharedTcpClient, closeSharedTcpClient } from './tcp';
-//# sourceMappingURL=tcpClient.d.ts.map

package/dist/client/tcpClient.js

@@ -3,4 +3,3 @@
  * @deprecated Import from './tcp' instead
  */
 export { DEFAULT_CONNECTION, TcpClient, getSharedTcpClient, closeSharedTcpClient } from './tcp';
-//# sourceMappingURL=tcpClient.js.map

package/dist/client/tcpPool.d.ts

@@ -60,4 +60,3 @@ export declare function getSharedPool(options?: PoolOptions): TcpConnectionPool;
 export declare function releaseSharedPool(pool: TcpConnectionPool): void;
 /** Close all shared pools */
 export declare function closeAllSharedPools(): void;
-//# sourceMappingURL=tcpPool.d.ts.map