ioredis 5.10.1 → 5.11.0

package/README.md

@@ -729,13 +729,16 @@ const stream = redis.zscanStream("myhash", {
   match: "age:??",
 });
 ```
+
 The `hscanStream` also accepts the `noValues` option to specify whether Redis should return only the keys in the hash table without their corresponding values.
+
 ```javascript
 const stream = redis.hscanStream("myhash", {
   match: "age:??",
   noValues: true,
 });
 ```
+
 You can learn more from the [Redis documentation](http://redis.io/commands/scan).
 
 **Useful Tips**
@@ -815,6 +818,7 @@ const redis = new Redis({
 ```
 
 When enabled:
+
 - For commands with a finite timeout (e.g., `blpop("key", 5)`), ioredis sets a client-side deadline based on the command's timeout plus a small grace period (`blockingTimeoutGrace`, default 100ms). If no reply arrives before the deadline, the command resolves with `null`—the same value Redis returns when a blocking command times out normally.
 - For commands that block forever (e.g., `timeout = 0` or `BLOCK 0`), the `blockingTimeout` value is used as a safety net.
 
@@ -842,15 +846,15 @@ On ElastiCache instances with Auto-failover enabled, `reconnectOnError` does not
 
 The Redis instance will emit some events about the state of the connection to the Redis server.
 
-| Event        | Description                                                                                                                                                                                                                                     |
-| :----------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| connect      | emits when a connection is established to the Redis server.                                                                                                                                                                                     |
-| ready        | If `enableReadyCheck` is `true`, client will emit `ready` when the server reports that it is ready to receive commands (e.g. finish loading data from disk).<br>Otherwise, `ready` will be emitted immediately right after the `connect` event. |
-| error        | emits when an error occurs while connecting.<br>However, ioredis emits all `error` events silently (only emits when there's at least one listener) so that your application won't crash if you're not listening to the `error` event.<br>When `redis.connect()` is explicitly called the error will also be rejected from the returned promise, in addition to emitting it. If `redis.connect()` is not called explicitly and `lazyConnect` is true, ioredis will try to connect automatically on the first command and emit the `error` event silently.                                                      |
-| close        | emits when an established Redis server connection has closed.                                                                                                                                                                                   |
-| reconnecting | emits after `close` when a reconnection will be made. The argument of the event is the time (in ms) before reconnecting.                                                                                                                        |
-| end          | emits after `close` when no more reconnections will be made, or the connection is failed to establish.                                                                                                                                          |
-| wait         | emits when `lazyConnect` is set and will wait for the first command to be called before connecting.                                                                                                                                             |
+| Event        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| connect      | emits when a connection is established to the Redis server.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| ready        | If `enableReadyCheck` is `true`, client will emit `ready` when the server reports that it is ready to receive commands (e.g. finish loading data from disk).<br>Otherwise, `ready` will be emitted immediately right after the `connect` event.                                                                                                                                                                                                                                                                                                          |
+| error        | emits when an error occurs while connecting.<br>However, ioredis emits all `error` events silently (only emits when there's at least one listener) so that your application won't crash if you're not listening to the `error` event.<br>When `redis.connect()` is explicitly called the error will also be rejected from the returned promise, in addition to emitting it. If `redis.connect()` is not called explicitly and `lazyConnect` is true, ioredis will try to connect automatically on the first command and emit the `error` event silently. |
+| close        | emits when an established Redis server connection has closed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| reconnecting | emits after `close` when a reconnection will be made. The argument of the event is the time (in ms) before reconnecting.                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| end          | emits after `close` when no more reconnections will be made, or the connection is failed to establish.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| wait         | emits when `lazyConnect` is set and will wait for the first command to be called before connecting.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 
 You can also check out the `Redis#status` property to get the current connection status.
 
@@ -860,6 +864,38 @@ Besides the above connection events, there are several other custom events:
 | :----- | :------------------------------------------------------------------ |
 | select | emits when the database changed. The argument is the new db number. |
 
+## Diagnostics Channel
+
+ioredis publishes telemetry through Node.js [`diagnostics_channel`](https://nodejs.org/api/diagnostics_channel.html), allowing APM tools and custom instrumentation to observe commands, connections, and batch operations without modifying application code.
+
+These channels use `TracingChannel#tracePromise()` and emit `start`, `end`, `asyncStart`, `asyncEnd`, and `error` sub-events. Requires Node.js >= 18.19.0; on older versions the channels are silently unavailable (zero overhead). Subscribe via `tracing:<name>:<event>`:
+
+```typescript
+import dc from "node:diagnostics_channel";
+
+dc.subscribe("tracing:ioredis:command:start", ({ command, args }) => {
+  console.log(`> ${command}`, args);
+});
+
+dc.subscribe("tracing:ioredis:command:asyncEnd", ({ command }) => {
+  console.log(`${command} settled`);
+});
+
+dc.subscribe("tracing:ioredis:command:error", ({ command, error }) => {
+  console.error(`${command} failed:`, error);
+});
+```
+
+| Channel name      | Payload                 | Description                                              |
+| :---------------- | :---------------------- | :------------------------------------------------------- |
+| `ioredis:command` | `CommandTraceContext`   | Individual command (standalone, pipeline, or within MULTI) |
+| `ioredis:batch`   | `BatchOperationContext` | MULTI transaction as a whole                             |
+| `ioredis:connect` | `ConnectTraceContext`   | Socket connection attempt                                |
+
+Command arguments are sanitized before emission using rules adapted from `@opentelemetry/redis-common`. Sensitive values (e.g. values in `SET`, `AUTH` passwords) are replaced with `?`, while read-only commands like `GET` and `DEL` retain all arguments. This is safe by default: unlisted or custom commands have all arguments redacted.
+
+Context types (`CommandTraceContext`, `BatchOperationContext`, `ConnectTraceContext`) are exported from `ioredis`.
+
 ## Offline Queue
 
 When a command can't be processed by Redis (being sent before the `ready` event), by default, it's added to the offline queue and will be
@@ -1159,6 +1195,7 @@ const cluster = new Redis.Cluster(
 ```
 
 Or you can specify this parameter through function:
+
 ```javascript
 const cluster = new Redis.Cluster(
   [
@@ -1169,7 +1206,7 @@ const cluster = new Redis.Cluster(
   ],
   {
     natMap: (key) => {
-      if(key.includes('30001')) {
+      if (key.includes("30001")) {
         return { host: "203.0.113.73", port: 30001 };
       }
 
@@ -1226,28 +1263,33 @@ For sharded Pub/Sub, use the `spublish` and `ssubscribe` commands instead of the
 The following basic example shows you how to use sharded Pub/Sub:
 
 ```javascript
-const cluster: Cluster = new Cluster([{host: host, port: port}], {shardedSubscribers: true});
+const cluster: Cluster = new Cluster([{ host: host, port: port }], {
+  shardedSubscribers: true,
+});
 
 //Register the callback
 cluster.on("smessage", (channel, message) => {
-    console.log(message);
+  console.log(message);
 });
 
-
 //Subscribe to the channels on the same slot
-cluster.ssubscribe("channel{my}:1", "channel{my}:2").then( ( count: number ) => {
+cluster
+  .ssubscribe("channel{my}:1", "channel{my}:2")
+  .then((count: number) => {
     console.log(count);
-}).catch( (err) => {
+  })
+  .catch((err) => {
     console.log(err);
-});
+  });
 
 //Publish a message
-cluster.spublish("channel{my}:1", "This is a test message to my first channel.").then((value: number) => {
+cluster
+  .spublish("channel{my}:1", "This is a test message to my first channel.")
+  .then((value: number) => {
     console.log("Published a message to channel{my}:1");
-});
+  });
 ```
 
-
 ### Events
 
 | Event        | Description                                                                                                                                                                                                |

package/built/Command.d.ts

@@ -94,6 +94,7 @@ export default class Command implements Respondable {
     args: CommandParameter[];
     inTransaction: boolean;
     pipelineIndex?: number;
+    isTraced: boolean;
     isResolved: boolean;
     reject: (err: Error) => void;
     resolve: (result: any) => void;

package/built/Command.js

@@ -37,6 +37,7 @@ class Command {
     constructor(name, args = [], options = {}, callback) {
         this.name = name;
         this.inTransaction = false;
+        this.isTraced = false;
         this.isResolved = false;
         this.transformed = false;
         this.replyEncoding = options.replyEncoding;

package/built/Pipeline.js

@@ -5,6 +5,7 @@ const commands_1 = require("@ioredis/commands");
 const standard_as_callback_1 = require("standard-as-callback");
 const util_1 = require("util");
 const Command_1 = require("./Command");
+const buffer_1 = require("buffer");
 const utils_1 = require("./utils");
 const Commander_1 = require("./utils/Commander");
 /*
@@ -315,6 +316,15 @@ Pipeline.prototype.exec = function (callback) {
                     buffers.push(writable);
                 }
                 else {
+                    if (data.length + writable.length >= buffer_1.constants.MAX_STRING_LENGTH) {
+                        if (!buffers) {
+                            buffers = [];
+                        }
+                        if (data) {
+                            buffers.push(Buffer.from(data, "utf8"));
+                            data = "";
+                        }
+                    }
                     data += writable;
                 }
                 if (!--writePending) {

package/built/Redis.d.ts

@@ -7,6 +7,7 @@ import { RedisOptions } from "./redis/RedisOptions";
 import ScanStream from "./ScanStream";
 import { Transaction } from "./transaction";
 import { Callback, CommandItem, NetStream, ScanStreamOptions, WriteableStream } from "./types";
+import { type BatchOperationContext } from "./tracing";
 import Commander from "./utils/Commander";
 import Deque = require("denque");
 declare type RedisStatus = "wait" | "reconnecting" | "connecting" | "connect" | "ready" | "close" | "end";
@@ -85,6 +86,7 @@ declare class Redis extends Commander implements DataHandledable {
      * if the connection fails, times out, or if Redis is already connecting/connected.
      */
     connect(callback?: Callback<void>): Promise<void>;
+    private _connect;
     /**
      * Disconnect from Redis.
      *
@@ -186,6 +188,15 @@ declare class Redis extends Commander implements DataHandledable {
      * @ignore
      */
     handleReconnection(err: Error, item: CommandItem): void;
+    /**
+     * @ignore
+     */
+    _getServerAddress(): {
+        address: string;
+        port: number | undefined;
+    };
+    private _buildCommandContext;
+    _buildBatchContext(batchSize: number): BatchOperationContext;
     /**
      * Get description of the connection. Used for debugging.
      */

package/built/Redis.js

@@ -12,6 +12,7 @@ const RedisOptions_1 = require("./redis/RedisOptions");
 const ScanStream_1 = require("./ScanStream");
 const transaction_1 = require("./transaction");
 const utils_1 = require("./utils");
+const tracing_1 = require("./tracing");
 const applyMixin_1 = require("./utils/applyMixin");
 const Commander_1 = require("./utils/Commander");
 const lodash_1 = require("./utils/lodash");
@@ -101,7 +102,18 @@ class Redis extends Commander_1.default {
      * if the connection fails, times out, or if Redis is already connecting/connected.
      */
     connect(callback) {
-        const promise = new Promise((resolve, reject) => {
+        const promise = (0, tracing_1.traceConnect)(() => this._connect(), () => {
+            const { address, port } = this._getServerAddress();
+            return {
+                serverAddress: address,
+                serverPort: port,
+                connectionEpoch: this.connectionEpoch,
+            };
+        });
+        return (0, standard_as_callback_1.default)(promise, callback);
+    }
+    _connect() {
+        return new Promise((resolve, reject) => {
             if (this.status === "connecting" ||
                 this.status === "connect" ||
                 this.status === "ready") {
@@ -211,7 +223,6 @@ class Redis extends Commander_1.default {
                 _this.once("close", connectionCloseHandler);
             });
         });
-        return (0, standard_as_callback_1.default)(promise, callback);
     }
     /**
      * Disconnect from Redis.
@@ -416,7 +427,8 @@ class Redis extends Commander_1.default {
             if (Command_1.default.checkFlag("WILL_DISCONNECT", command.name)) {
                 this.manuallyClosing = true;
             }
-            if (this.options.socketTimeout !== undefined && this.socketTimeoutTimer === undefined) {
+            if (this.options.socketTimeout !== undefined &&
+                this.socketTimeoutTimer === undefined) {
                 this.setSocketTimeout();
             }
         }
@@ -428,7 +440,15 @@ class Redis extends Commander_1.default {
                 debug("switch to db [%d]", this.condition.select);
             }
         }
-        return command.promise;
+        if (!writable || command.isTraced) {
+            return command.promise;
+        }
+        // Trace on the write path only, and only once per command. Commands may
+        // pass through sendCommand multiple times (offline queue flush,
+        // prevCommandQueue resend after reconnect). The isTraced flag ensures
+        // we don't emit duplicate trace events.
+        command.isTraced = true;
+        return (0, tracing_1.traceCommand)(() => command.promise, () => this._buildCommandContext(command));
     }
     getBlockingTimeoutInMs(command) {
         var _a;
@@ -444,7 +464,8 @@ class Redis extends Commander_1.default {
         if (typeof timeout === "number") {
             if (timeout > 0) {
                 // Finite timeout from command args - add grace period
-                return timeout + ((_a = this.options.blockingTimeoutGrace) !== null && _a !== void 0 ? _a : RedisOptions_1.DEFAULT_REDIS_OPTIONS.blockingTimeoutGrace);
+                return (timeout +
+                    ((_a = this.options.blockingTimeoutGrace) !== null && _a !== void 0 ? _a : RedisOptions_1.DEFAULT_REDIS_OPTIONS.blockingTimeoutGrace));
             }
             // Command has timeout=0 (block forever), use blockingTimeout option as safety net
             return configuredTimeout;
@@ -575,6 +596,40 @@ class Redis extends Commander_1.default {
                 item.command.reject(err);
         }
     }
+    /**
+     * @ignore
+     */
+    _getServerAddress() {
+        if ("path" in this.options && this.options.path) {
+            return { address: this.options.path, port: undefined };
+        }
+        return {
+            address: ("host" in this.options && this.options.host) || "localhost",
+            port: ("port" in this.options && this.options.port) || 6379,
+        };
+    }
+    _buildCommandContext(command) {
+        var _a, _b, _c;
+        const { address, port } = this._getServerAddress();
+        return {
+            command: command.name,
+            args: (0, tracing_1.sanitizeArgs)(command.name, command.args),
+            database: (_c = (_b = (_a = this.condition) === null || _a === void 0 ? void 0 : _a.select) !== null && _b !== void 0 ? _b : this.options.db) !== null && _c !== void 0 ? _c : 0,
+            serverAddress: address,
+            serverPort: port,
+        };
+    }
+    _buildBatchContext(batchSize) {
+        var _a, _b, _c;
+        const { address, port } = this._getServerAddress();
+        return {
+            batchMode: "MULTI",
+            batchSize,
+            database: (_c = (_b = (_a = this.condition) === null || _a === void 0 ? void 0 : _a.select) !== null && _b !== void 0 ? _b : this.options.db) !== null && _c !== void 0 ? _c : 0,
+            serverAddress: address,
+            serverPort: port,
+        };
+    }
     /**
      * Get description of the connection. Used for debugging.
      */

package/built/autoPipelining.js

@@ -100,6 +100,18 @@ function getFirstValueInFlattenedArray(args) {
     return undefined;
 }
 exports.getFirstValueInFlattenedArray = getFirstValueInFlattenedArray;
+function getFirstKeyForCommand(commandName, args) {
+    if ((0, commands_1.exists)(commandName, { caseInsensitive: true })) {
+        const flattenedArgs = args.flat();
+        const keyIndexes = (0, commands_1.getKeyIndexes)(commandName, flattenedArgs, {
+            nameCaseInsensitive: true,
+        });
+        if (keyIndexes.length) {
+            return flattenedArgs[keyIndexes[0]];
+        }
+    }
+    return getFirstValueInFlattenedArray(args);
+}
 function executeWithAutoPipelining(client, functionName, commandName, args, callback) {
     // On cluster mode let's wait for slots to be available
     if (client.isCluster && !client.slots.length) {
@@ -116,11 +128,9 @@ function executeWithAutoPipelining(client, functionName, commandName, args, call
         }), callback);
     }
     // If we have slot information, we can improve routing by grouping slots served by the same subset of nodes
-    // Note that the first value in args may be a (possibly empty) array.
-    // ioredis will only flatten one level of the array, in the Command constructor.
     const prefix = client.options.keyPrefix || "";
     let slotKey = client.isCluster
-        ? client.slots[calculateSlot(`${prefix}${getFirstValueInFlattenedArray(args)}`)].join(",")
+        ? client.slots[calculateSlot(`${prefix}${getFirstKeyForCommand(commandName, args)}`)].join(",")
         : "main";
     // When scaleReads is enabled, separate read and write commands into different pipelines
     // so they can be routed to replicas and masters respectively

package/built/index.d.ts

@@ -36,6 +36,7 @@ export { ClusterNode } from "./cluster";
 export { ClusterOptions, DNSLookupFunction, DNSResolveSrvFunction, NatMap, } from "./cluster/ClusterOptions";
 export { NodeRole } from "./cluster/util";
 export type { RedisKey, RedisValue, ChainableCommander, } from "./utils/RedisCommander";
+export type { CommandTraceContext, BatchOperationContext, ConnectTraceContext, } from "./tracing";
 export declare const ReplyError: any;
 /**
  * @ignore

package/built/tracing.d.ts

@@ -0,0 +1,26 @@
+import type { CommandParameter } from "./types";
+export declare function sanitizeArgs(commandName: string, args: CommandParameter[]): string[];
+export interface CommandTraceContext {
+    command: string;
+    args: string[];
+    database: number;
+    serverAddress: string;
+    serverPort: number | undefined;
+}
+export interface BatchOperationContext {
+    batchMode: "MULTI";
+    batchSize: number;
+    database: number;
+    serverAddress: string;
+    serverPort: number | undefined;
+}
+export interface ConnectTraceContext {
+    serverAddress: string;
+    serverPort: number | undefined;
+    connectionEpoch: number;
+}
+declare type CommandContext = CommandTraceContext;
+export declare function traceCommand<T>(fn: () => Promise<T>, contextFactory: () => CommandContext): Promise<T>;
+export declare function traceBatch<T>(fn: () => Promise<T>, contextFactory: () => BatchOperationContext): Promise<T>;
+export declare function traceConnect<T>(fn: () => Promise<T>, contextFactory: () => ConnectTraceContext): Promise<T>;
+export {};

package/built/tracing.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceConnect = exports.traceBatch = exports.traceCommand = exports.sanitizeArgs = void 0;
+// Argument sanitization rules adapted from @opentelemetry/redis-common (Apache 2.0).
+// https://github.com/open-telemetry/opentelemetry-js-contrib/blob/main/packages/redis-common/src/index.ts
+//
+// Each entry specifies how many positional args (after the command name) are safe
+// to emit. -1 means all args are safe (read-only/structural commands).
+// Unlisted commands default to 0 (all args redacted) for safe-by-default behavior,
+// which covers AUTH, HELLO, and unknown/custom commands.
+const SERIALIZATION_SUBSETS = [
+    { regex: /^ECHO/i, args: 0 },
+    {
+        regex: /^(LPUSH|MSET|PFA|PUBLISH|RPUSH|SADD|SET|SPUBLISH|XADD|ZADD)/i,
+        args: 1,
+    },
+    { regex: /^(HSET|HMSET|LSET|LINSERT)/i, args: 2 },
+    {
+        regex: /^(ACL|BIT|B[LRZ]|CLIENT|CLUSTER|CONFIG|COMMAND|DECR|DEL|EVAL|EX|FUNCTION|GEO|GET|HINCR|HMGET|HSCAN|INCR|L[TRLM]|MEMORY|P[EFISTU]|RPOP|S[CDIMORSU]|XACK|X[CDGILPRT]|Z[CDILMPRS])/i,
+        args: -1,
+    },
+];
+function sanitizeArgs(commandName, args) {
+    let allowedArgCount = 0;
+    for (const subset of SERIALIZATION_SUBSETS) {
+        if (subset.regex.test(commandName)) {
+            allowedArgCount = subset.args;
+            break;
+        }
+    }
+    if (allowedArgCount === -1) {
+        return args.map((a) => String(a));
+    }
+    const result = [];
+    for (let i = 0; i < args.length; i++) {
+        if (i < allowedArgCount) {
+            result.push(String(args[i]));
+        }
+        else {
+            result.push("?");
+        }
+    }
+    return result;
+}
+exports.sanitizeArgs = sanitizeArgs;
+// Load diagnostics_channel with Node 18 compatibility
+const dc = (() => {
+    try {
+        return "getBuiltinModule" in process
+            ? process.getBuiltinModule("node:diagnostics_channel")
+            : require("node:diagnostics_channel");
+    }
+    catch {
+        return undefined;
+    }
+})();
+const hasTracingChannel = dc && typeof dc.tracingChannel === "function";
+const commandChannel = hasTracingChannel
+    ? dc.tracingChannel("ioredis:command")
+    : undefined;
+const batchChannel = hasTracingChannel
+    ? dc.tracingChannel("ioredis:batch")
+    : undefined;
+const connectChannel = hasTracingChannel
+    ? dc.tracingChannel("ioredis:connect")
+    : undefined;
+function shouldTrace(channel) {
+    return !!channel && channel.hasSubscribers !== false;
+}
+const noop = () => { };
+function traceCommand(fn, contextFactory) {
+    if (!shouldTrace(commandChannel))
+        return fn();
+    // tracePromise returns a wrapper promise that re-rejects on error.
+    // Silence the wrapper to prevent unhandled rejections when callers
+    // (e.g. Pipeline) discard the return value. Callers that await this
+    // promise still see the rejection through their own .then() chain.
+    const traced = commandChannel.tracePromise(fn, contextFactory());
+    traced.catch(noop);
+    return traced;
+}
+exports.traceCommand = traceCommand;
+function traceBatch(fn, contextFactory) {
+    if (!shouldTrace(batchChannel))
+        return fn();
+    const traced = batchChannel.tracePromise(fn, contextFactory());
+    traced.catch(noop);
+    return traced;
+}
+exports.traceBatch = traceBatch;
+function traceConnect(fn, contextFactory) {
+    if (!shouldTrace(connectChannel))
+        return fn();
+    return connectChannel.tracePromise(fn, contextFactory());
+}
+exports.traceConnect = traceConnect;

package/built/transaction.js

@@ -4,6 +4,7 @@ exports.addTransactionSupport = void 0;
 const utils_1 = require("./utils");
 const standard_as_callback_1 = require("standard-as-callback");
 const Pipeline_1 = require("./Pipeline");
+const tracing_1 = require("./tracing");
 function addTransactionSupport(redis) {
     redis.pipeline = function (commands) {
         const pipeline = new Pipeline_1.default(this);
@@ -51,8 +52,9 @@ function addTransactionSupport(redis) {
             if (this.nodeifiedPromise) {
                 return exec.call(pipeline);
             }
-            const promise = exec.call(pipeline);
-            return (0, standard_as_callback_1.default)(promise.then(function (result) {
+            // Count only user commands (exclude MULTI/EXEC wrappers).
+            const batchSize = Math.max(pipeline.length - 2, 0);
+            const execAndUnwrap = () => exec.call(pipeline).then(function (result) {
                 const execResult = result[result.length - 1];
                 if (typeof execResult === "undefined") {
                     throw new Error("Pipeline cannot be used to send any commands when the `exec()` has been called on it.");
@@ -67,7 +69,12 @@ function addTransactionSupport(redis) {
                     throw execResult[0];
                 }
                 return (0, utils_1.wrapMultiResult)(execResult[1]);
-            }), callback);
+            });
+            // Trace MULTI as a single batch operation on ioredis:batch.
+            const promise = "_buildBatchContext" in this.redis
+                ? (0, tracing_1.traceBatch)(execAndUnwrap, () => this.redis._buildBatchContext(batchSize))
+                : execAndUnwrap();
+            return (0, standard_as_callback_1.default)(promise, callback);
         };
         // @ts-expect-error
         const { execBuffer } = pipeline;