@hatchet-dev/typescript-sdk 1.16.0 → 1.17.1

package/clients/listeners/durable-listener/durable-listener-client.js

@@ -1,38 +1,789 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DurableListenerClient = void 0;
+exports.LegacyDurableEventStreamable = exports.DurableListenerClient = void 0;
+const events_1 = require("events");
+const abort_controller_x_1 = require("abort-controller-x");
+const hatchet_error_1 = require("../../../util/errors/hatchet-error");
 const dispatcher_1 = require("../../../protoc/v1/dispatcher");
-const pooled_durable_listener_client_1 = require("./pooled-durable-listener-client");
+const non_determinism_error_1 = require("../../../util/errors/non-determinism-error");
+const abort_error_1 = require("../../../util/abort-error");
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+class TTLMap {
+    constructor(ttlMs) {
+        this.ttlMs = ttlMs;
+        this.cache = new Map();
+        this.timer = setInterval(() => this.evict(), ttlMs);
+    }
+    set(key, value) {
+        this.cache.set(key, { value, expiresAt: Date.now() + this.ttlMs });
+    }
+    get(key) {
+        var _a;
+        return (_a = this.cache.get(key)) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    get size() {
+        return this.cache.size;
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    keys() {
+        return this.cache.keys();
+    }
+    pop(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.cache.delete(key);
+            return entry.value;
+        }
+        return undefined;
+    }
+    clear() {
+        this.cache.clear();
+    }
+    destroy() {
+        clearInterval(this.timer);
+        this.cache.clear();
+    }
+    evict() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache) {
+            if (entry.expiresAt <= now) {
+                this.cache.delete(key);
+            }
+        }
+    }
+}
+const DEFAULT_RECONNECT_INTERVAL = 3000;
+const EVICTION_ACK_TIMEOUT_MS = 30000;
+const WORKER_STATUS_POLL_INTERVAL_MS = 1000;
+function eventLogEntryResultFromProto(proto) {
+    var _a, _b, _c, _d;
+    let payload;
+    if (proto.payload && proto.payload.length > 0) {
+        payload = JSON.parse(new TextDecoder().decode(proto.payload));
+    }
+    return {
+        durableTaskExternalId: (_b = (_a = proto.ref) === null || _a === void 0 ? void 0 : _a.durableTaskExternalId) !== null && _b !== void 0 ? _b : '',
+        nodeId: (_d = (_c = proto.ref) === null || _c === void 0 ? void 0 : _c.nodeId) !== null && _d !== void 0 ? _d : 0,
+        payload,
+    };
+}
+function ackKey(taskExtId, invocationCount) {
+    return `${taskExtId}:${invocationCount}`;
+}
+function callbackKey(taskExtId, invocationCount, branchId, nodeId) {
+    return `${taskExtId}:${invocationCount}:${branchId}:${nodeId}`;
+}
+function evictionKey(taskExtId, invocationCount) {
+    return `${taskExtId}:${invocationCount}`;
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
 class DurableListenerClient {
-    constructor(config, channel, factory, api) {
+    constructor(config, channel, factory) {
+        this._running = false;
+        this._requestQueue = [];
+        this._pendingEventAcks = new Map();
+        this._pendingCallbacks = new Map();
+        // Completions that arrived before waitForCallback() registered a deferred
+        // in _pendingCallbacks. This happens when the server delivers an
+        // entryCompleted between the event ack and the waitForCallback call
+        // (e.g. an already-satisfied sleep delivered via polling).
+        this._bufferedCompletions = new TTLMap(10000);
+        this._pendingEvictionAcks = new Map();
         this.config = config;
         this.client = factory.create(dispatcher_1.V1DispatcherDefinition, channel);
-        this.logger = config.logger(`Listener`, config.log_level);
-        this.api = api;
+        this.logger = config.logger(`DurableListener`, config.log_level);
     }
-    subscribe(request) {
-        if (!this.pooledListener) {
-            this.pooledListener = new pooled_durable_listener_client_1.DurableEventGrpcPooledListener(this, () => {
-                this.pooledListener = undefined;
+    get workerId() {
+        return this._workerId;
+    }
+    start(workerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._startLock) {
+                yield this._startLock;
+                return;
+            }
+            this._startLock = this._doStart(workerId);
+            yield this._startLock;
+        });
+    }
+    _doStart(workerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._running)
+                return;
+            this._workerId = workerId;
+            this._running = true;
+            yield this._connect();
+            this._startStatusPolling();
+        });
+    }
+    ensureStarted(workerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._running) {
+                yield this.start(workerId);
+            }
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._running = false;
+            this._startLock = undefined;
+            if (this._statusInterval) {
+                clearInterval(this._statusInterval);
+                this._statusInterval = undefined;
+            }
+            if (this._receiveAbort) {
+                this._receiveAbort.abort();
+            }
+            this._failPendingAcks(new Error('DurableListener stopped'));
+            this._bufferedCompletions.destroy();
+        });
+    }
+    _connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info('durable event listener connecting...');
+            this._requestQueue = [];
+            this._receiveAbort = new AbortController();
+            this._enqueueRequest({
+                registerWorker: { workerId: this._workerId },
             });
+            this._pollWorkerStatus();
+            void this._streamLoop();
+            this.logger.info('durable event listener connected');
+        });
+    }
+    _streamLoop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            var _d;
+            while (this._running) {
+                try {
+                    const stream = this.client.durableTask(this._requestIterator(), {
+                        signal: (_d = this._receiveAbort) === null || _d === void 0 ? void 0 : _d.signal,
+                    });
+                    try {
+                        for (var _e = true, stream_1 = (e_1 = void 0, __asyncValues(stream)), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _e = true) {
+                            _c = stream_1_1.value;
+                            _e = false;
+                            const response = _c;
+                            this._handleResponse(response);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_e && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    if (this._running) {
+                        this.logger.warn(`durable event listener disconnected (EOF), reconnecting in ${DEFAULT_RECONNECT_INTERVAL}ms...`);
+                        this._failPendingAcks(new Error('durable stream disconnected'));
+                        yield (0, sleep_1.default)(DEFAULT_RECONNECT_INTERVAL);
+                        yield this._connect();
+                        return;
+                    }
+                }
+                catch (e) {
+                    if ((0, abort_controller_x_1.isAbortError)(e)) {
+                        this.logger.debug('durable event listener aborted');
+                        return;
+                    }
+                    this.logger.error(`error in durable event listener: ${(0, hatchet_error_1.getErrorMessage)(e)}`);
+                    if (this._running) {
+                        this._failPendingAcks(new Error(`durable stream error: ${(0, hatchet_error_1.getErrorMessage)(e)}`));
+                        yield (0, sleep_1.default)(DEFAULT_RECONNECT_INTERVAL);
+                        yield this._connect();
+                        return;
+                    }
+                }
+            }
+        });
+    }
+    _requestIterator() {
+        return __asyncGenerator(this, arguments, function* _requestIterator_1() {
+            while (this._running) {
+                while (this._requestQueue.length > 0) {
+                    yield yield __await(this._requestQueue.shift());
+                }
+                yield __await(new Promise((resolve) => {
+                    this._requestNotify = resolve;
+                }));
+                this._requestNotify = undefined;
+            }
+        });
+    }
+    _enqueueRequest(request) {
+        this._requestQueue.push(request);
+        if (this._requestNotify) {
+            this._requestNotify();
         }
-        return this.pooledListener.subscribe(request);
     }
-    result(request, opts) {
-        if (!this.pooledListener) {
-            this.pooledListener = new pooled_durable_listener_client_1.DurableEventGrpcPooledListener(this, () => {
-                this.pooledListener = undefined;
+    _startStatusPolling() {
+        if (this._statusInterval) {
+            clearInterval(this._statusInterval);
+        }
+        this._statusInterval = setInterval(() => {
+            this._pollWorkerStatus();
+        }, WORKER_STATUS_POLL_INTERVAL_MS);
+    }
+    _pollWorkerStatus() {
+        if (!this._workerId || this._pendingCallbacks.size === 0)
+            return;
+        const waitingEntries = [];
+        for (const key of this._pendingCallbacks.keys()) {
+            const parts = key.split(':');
+            waitingEntries.push({
+                durableTaskExternalId: parts[0],
+                invocationCount: parseInt(parts[1], 10),
+                branchId: parseInt(parts[2], 10),
+                nodeId: parseInt(parts[3], 10),
             });
         }
-        return this.pooledListener.result(request, opts);
+        this._enqueueRequest({
+            workerStatus: {
+                workerId: this._workerId,
+                waitingEntries,
+            },
+        });
+    }
+    _failPendingAcks(exc) {
+        for (const d of this._pendingEventAcks.values()) {
+            d.reject(exc);
+        }
+        this._pendingEventAcks.clear();
+        for (const d of this._pendingEvictionAcks.values()) {
+            d.reject(exc);
+        }
+        this._pendingEvictionAcks.clear();
+    }
+    _failAllPending(exc) {
+        this._failPendingAcks(exc);
+        for (const d of this._pendingCallbacks.values()) {
+            d.reject(exc);
+        }
+        this._pendingCallbacks.clear();
+        this._bufferedCompletions.clear();
     }
+    _handleResponse(response) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
+        if (response.registerWorker) {
+            // registration acknowledged
+        }
+        else if (response.triggerRunsAck) {
+            const ack = response.triggerRunsAck;
+            const key = ackKey(ack.durableTaskExternalId, ack.invocationCount);
+            const pending = this._pendingEventAcks.get(key);
+            if (pending) {
+                pending.resolve({
+                    ackType: 'run',
+                    invocationCount: ack.invocationCount,
+                    durableTaskExternalId: ack.durableTaskExternalId,
+                    runEntries: (ack.runEntries || []).map((e) => ({
+                        nodeId: e.nodeId,
+                        branchId: e.branchId,
+                        workflowRunExternalId: e.workflowRunExternalId,
+                    })),
+                });
+                this._pendingEventAcks.delete(key);
+            }
+        }
+        else if (response.memoAck) {
+            const ack = response.memoAck;
+            const { ref } = ack;
+            const key = ackKey((_a = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _a !== void 0 ? _a : '', (_b = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _b !== void 0 ? _b : 0);
+            const pending = this._pendingEventAcks.get(key);
+            if (pending) {
+                pending.resolve({
+                    ackType: 'memo',
+                    invocationCount: (_c = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _c !== void 0 ? _c : 0,
+                    durableTaskExternalId: (_d = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _d !== void 0 ? _d : '',
+                    branchId: (_e = ref === null || ref === void 0 ? void 0 : ref.branchId) !== null && _e !== void 0 ? _e : 0,
+                    nodeId: (_f = ref === null || ref === void 0 ? void 0 : ref.nodeId) !== null && _f !== void 0 ? _f : 0,
+                    memoAlreadyExisted: ack.memoAlreadyExisted,
+                    memoResultPayload: ack.memoResultPayload,
+                });
+                this._pendingEventAcks.delete(key);
+            }
+        }
+        else if (response.waitForAck) {
+            const ack = response.waitForAck;
+            const { ref } = ack;
+            const key = ackKey((_g = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _g !== void 0 ? _g : '', (_h = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _h !== void 0 ? _h : 0);
+            const pending = this._pendingEventAcks.get(key);
+            if (pending) {
+                pending.resolve({
+                    ackType: 'waitFor',
+                    invocationCount: (_j = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _j !== void 0 ? _j : 0,
+                    durableTaskExternalId: (_k = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _k !== void 0 ? _k : '',
+                    branchId: (_l = ref === null || ref === void 0 ? void 0 : ref.branchId) !== null && _l !== void 0 ? _l : 0,
+                    nodeId: (_m = ref === null || ref === void 0 ? void 0 : ref.nodeId) !== null && _m !== void 0 ? _m : 0,
+                });
+                this._pendingEventAcks.delete(key);
+            }
+        }
+        else if (response.entryCompleted) {
+            const completed = response.entryCompleted;
+            const { ref } = completed;
+            const key = callbackKey((_o = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _o !== void 0 ? _o : '', (_p = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _p !== void 0 ? _p : 0, (_q = ref === null || ref === void 0 ? void 0 : ref.branchId) !== null && _q !== void 0 ? _q : 0, (_r = ref === null || ref === void 0 ? void 0 : ref.nodeId) !== null && _r !== void 0 ? _r : 0);
+            const result = eventLogEntryResultFromProto(completed);
+            const pending = this._pendingCallbacks.get(key);
+            if (pending) {
+                pending.resolve(result);
+                this._pendingCallbacks.delete(key);
+            }
+            else {
+                this._bufferedCompletions.set(key, result);
+            }
+        }
+        else if (response.evictionAck) {
+            const ack = response.evictionAck;
+            const key = evictionKey(ack.durableTaskExternalId, ack.invocationCount);
+            const pending = this._pendingEvictionAcks.get(key);
+            if (pending) {
+                pending.resolve();
+                this._pendingEvictionAcks.delete(key);
+            }
+        }
+        else if (response.serverEvict) {
+            const evict = response.serverEvict;
+            this.logger.info(`received server eviction notification for task ${evict.durableTaskExternalId} ` +
+                `invocation ${evict.invocationCount}: ${evict.reason}`);
+            this.cleanupTaskState(evict.durableTaskExternalId, evict.invocationCount);
+            if (this.onServerEvict) {
+                this.onServerEvict(evict.durableTaskExternalId, evict.invocationCount);
+            }
+        }
+        else if (response.error) {
+            const { error } = response;
+            const { ref } = error;
+            let exc;
+            if (error.errorType === dispatcher_1.DurableTaskErrorType.DURABLE_TASK_ERROR_TYPE_NONDETERMINISM) {
+                exc = new non_determinism_error_1.NonDeterminismError((_s = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _s !== void 0 ? _s : '', (_t = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _t !== void 0 ? _t : 0, (_u = ref === null || ref === void 0 ? void 0 : ref.nodeId) !== null && _u !== void 0 ? _u : 0, error.errorMessage);
+            }
+            else {
+                exc = new Error(`Unspecified durable task error: ${error.errorMessage} (type: ${error.errorType})`);
+            }
+            const eAckKey = ackKey((_v = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _v !== void 0 ? _v : '', (_w = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _w !== void 0 ? _w : 0);
+            const pendingAck = this._pendingEventAcks.get(eAckKey);
+            if (pendingAck) {
+                pendingAck.reject(exc);
+                this._pendingEventAcks.delete(eAckKey);
+            }
+            const eCbKey = callbackKey((_x = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _x !== void 0 ? _x : '', (_y = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _y !== void 0 ? _y : 0, (_z = ref === null || ref === void 0 ? void 0 : ref.branchId) !== null && _z !== void 0 ? _z : 0, (_0 = ref === null || ref === void 0 ? void 0 : ref.nodeId) !== null && _0 !== void 0 ? _0 : 0);
+            const pendingCb = this._pendingCallbacks.get(eCbKey);
+            if (pendingCb) {
+                pendingCb.reject(exc);
+                this._pendingCallbacks.delete(eCbKey);
+            }
+            const eEvKey = evictionKey((_1 = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _1 !== void 0 ? _1 : '', (_2 = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _2 !== void 0 ? _2 : 0);
+            const pendingEv = this._pendingEvictionAcks.get(eEvKey);
+            if (pendingEv) {
+                pendingEv.reject(exc);
+                this._pendingEvictionAcks.delete(eEvKey);
+            }
+        }
+    }
+    sendEvent(durableTaskExternalId, invocationCount, event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = ackKey(durableTaskExternalId, invocationCount);
+            const d = deferred();
+            this._pendingEventAcks.set(key, d);
+            let request;
+            switch (event.kind) {
+                case 'runChildren': {
+                    const triggerRunsReq = {
+                        invocationCount,
+                        durableTaskExternalId,
+                        triggerOpts: event.triggerOpts,
+                    };
+                    request = { triggerRuns: triggerRunsReq };
+                    break;
+                }
+                case 'waitFor': {
+                    const waitForReq = {
+                        invocationCount,
+                        durableTaskExternalId,
+                        waitForConditions: event.waitForConditions,
+                    };
+                    request = { waitFor: waitForReq };
+                    break;
+                }
+                case 'memo': {
+                    const memoReq = {
+                        invocationCount,
+                        durableTaskExternalId,
+                        key: event.memoKey,
+                        payload: event.payload,
+                    };
+                    request = { memo: memoReq };
+                    break;
+                }
+                default: {
+                    const _ = event;
+                    throw new Error(`Unknown durable task send event: ${_}`);
+                }
+            }
+            this._enqueueRequest(request);
+            return d.promise;
+        });
+    }
+    waitForCallback(durableTaskExternalId, invocationCount, branchId, nodeId, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = callbackKey(durableTaskExternalId, invocationCount, branchId, nodeId);
+            const early = this._bufferedCompletions.get(key);
+            if (early) {
+                this._bufferedCompletions.delete(key);
+                return early;
+            }
+            if (!this._pendingCallbacks.has(key)) {
+                this._pendingCallbacks.set(key, deferred());
+                this._pollWorkerStatus();
+            }
+            const d = this._pendingCallbacks.get(key);
+            const signal = opts === null || opts === void 0 ? void 0 : opts.signal;
+            if (!signal) {
+                return d.promise;
+            }
+            if (signal.aborted) {
+                return Promise.reject((0, abort_error_1.createAbortError)('Operation cancelled by AbortSignal'));
+            }
+            return new Promise((resolve, reject) => {
+                let settled = false;
+                const onAbort = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    reject((0, abort_error_1.createAbortError)('Operation cancelled by AbortSignal'));
+                };
+                (0, abort_error_1.bindAbortSignalHandler)(signal, onAbort);
+                d.promise.then((value) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    signal.removeEventListener('abort', onAbort);
+                    resolve(value);
+                }, (err) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    signal.removeEventListener('abort', onAbort);
+                    reject(err);
+                });
+            });
+        });
+    }
+    cleanupTaskState(durableTaskExternalId, invocationCount) {
+        for (const [k, d] of this._pendingCallbacks) {
+            const parts = k.split(':');
+            if (parts[0] === durableTaskExternalId && parseInt(parts[1], 10) <= invocationCount) {
+                d.reject(new Error('task state cleaned up'));
+                this._pendingCallbacks.delete(k);
+            }
+        }
+        for (const [k, d] of this._pendingEventAcks) {
+            const parts = k.split(':');
+            if (parts[0] === durableTaskExternalId && parseInt(parts[1], 10) <= invocationCount) {
+                d.reject(new Error('task state cleaned up'));
+                this._pendingEventAcks.delete(k);
+            }
+        }
+        for (const k of this._bufferedCompletions.keys()) {
+            const parts = k.split(':');
+            if (parts[0] === durableTaskExternalId && parseInt(parts[1], 10) <= invocationCount) {
+                this._bufferedCompletions.delete(k);
+            }
+        }
+    }
+    sendEvictInvocation(durableTaskExternalId, invocationCount, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = evictionKey(durableTaskExternalId, invocationCount);
+            const d = deferred();
+            this._pendingEvictionAcks.set(key, d);
+            const req = {
+                invocationCount,
+                durableTaskExternalId,
+                reason,
+            };
+            this._enqueueRequest({ evictInvocation: req });
+            const timeout = (0, sleep_1.default)(EVICTION_ACK_TIMEOUT_MS).then(() => {
+                throw new Error(`Eviction ack timed out after ${EVICTION_ACK_TIMEOUT_MS}ms for task ${durableTaskExternalId} invocation ${invocationCount}`);
+            });
+            try {
+                yield Promise.race([d.promise, timeout]);
+            }
+            catch (err) {
+                this._pendingEvictionAcks.delete(key);
+                throw err;
+            }
+        });
+    }
+    sendMemoCompletedNotification(durableTaskExternalId, nodeId, branchId, invocationCount, memoKey, memoResultPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ref = {
+                durableTaskExternalId,
+                invocationCount,
+                branchId,
+                nodeId,
+            };
+            const req = {
+                ref,
+                payload: memoResultPayload !== null && memoResultPayload !== void 0 ? memoResultPayload : new Uint8Array(),
+                memoKey,
+            };
+            this._enqueueRequest({ completeMemo: req });
+        });
+    }
+    /**
+     * @deprecated Legacy backward-compat: uses the old unary RegisterDurableEvent RPC.
+     */
     registerDurableEvent(request) {
-        if (!this.pooledListener) {
-            this.pooledListener = new pooled_durable_listener_client_1.DurableEventGrpcPooledListener(this, () => {
-                this.pooledListener = undefined;
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.registerDurableEvent({
+                taskId: request.taskId,
+                signalKey: request.signalKey,
+                conditions: {
+                    sleepConditions: request.sleepConditions,
+                    userEventConditions: request.userEventConditions,
+                },
             });
+        });
+    }
+    /**
+     * @deprecated Legacy backward-compat: uses the old streaming ListenForDurableEvent RPC.
+     */
+    subscribe(request) {
+        if (!this._legacyPooledListener) {
+            this._legacyPooledListener = new LegacyPooledListener(this);
         }
-        return this.pooledListener.registerDurableEvent(request);
+        return this._legacyPooledListener.subscribe(request);
+    }
+    /**
+     * @deprecated Legacy backward-compat: subscribes and waits for a single result.
+     */
+    result(request, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subscriber = this.subscribe(request);
+            return subscriber.get({ signal: opts === null || opts === void 0 ? void 0 : opts.signal });
+        });
     }
 }
 exports.DurableListenerClient = DurableListenerClient;
+/**
+ * @deprecated Legacy support for the old streaming ListenForDurableEvent RPC.
+ */
+class LegacyDurableEventStreamable {
+    constructor(onCleanup) {
+        this.responseEmitter = new events_1.EventEmitter();
+        this._onCleanup = onCleanup;
+    }
+    get(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signal = opts === null || opts === void 0 ? void 0 : opts.signal;
+            return new Promise((resolve, reject) => {
+                let cleanedUp = false;
+                const cleanup = () => {
+                    if (cleanedUp)
+                        return;
+                    cleanedUp = true;
+                    this.responseEmitter.removeListener('response', onResponse);
+                    if (signal) {
+                        signal.removeEventListener('abort', onAbort);
+                    }
+                    this._onCleanup();
+                };
+                const onResponse = (event) => {
+                    cleanup();
+                    resolve(event);
+                };
+                const onAbort = () => {
+                    cleanup();
+                    reject((0, abort_error_1.createAbortError)('Operation cancelled by AbortSignal'));
+                };
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    onAbort();
+                    return;
+                }
+                this.responseEmitter.once('response', onResponse);
+                if (signal) {
+                    (0, abort_error_1.bindAbortSignalHandler)(signal, onAbort);
+                }
+            });
+        });
+    }
+}
+exports.LegacyDurableEventStreamable = LegacyDurableEventStreamable;
+/**
+ * @deprecated Legacy pooled listener for old ListenForDurableEvent streaming RPC.
+ */
+class LegacyPooledListener {
+    constructor(client) {
+        this.requestEmitter = new events_1.EventEmitter();
+        this.signal = new AbortController();
+        this.subscribers = {};
+        this.taskSignalKeyToSubscriptionIds = {};
+        this.subscriptionCounter = 0;
+        this.currRequester = 0;
+        this.client = client;
+        this.init();
+    }
+    init() {
+        return __awaiter(this, arguments, void 0, function* (retries = 0) {
+            var _a, e_2, _b, _c;
+            const MAX_RETRY_INTERVAL = 5000;
+            const BASE_RETRY_INTERVAL = 100;
+            const MAX_RETRY_COUNT = 5;
+            if (retries > 0) {
+                const backoffTime = Math.min(BASE_RETRY_INTERVAL * 2 ** (retries - 1), MAX_RETRY_INTERVAL);
+                yield (0, sleep_1.default)(backoffTime);
+            }
+            if (retries > MAX_RETRY_COUNT)
+                return;
+            try {
+                this.signal = new AbortController();
+                this.currRequester++;
+                this.listener = this.client.client.listenForDurableEvent(this.request(), {
+                    signal: this.signal.signal,
+                });
+                try {
+                    for (var _d = true, _e = __asyncValues(this.listener), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const event = _c;
+                        const subscriptionKey = `${event.taskId}|${event.signalKey}`;
+                        const subscriptionIds = this.taskSignalKeyToSubscriptionIds[subscriptionKey] || [];
+                        for (const subId of subscriptionIds) {
+                            const emitter = this.subscribers[subId];
+                            if (emitter) {
+                                emitter.responseEmitter.emit('response', event);
+                                this.cleanupSubscription(subId);
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            catch (e) {
+                if ((0, abort_controller_x_1.isAbortError)(e))
+                    return;
+            }
+            finally {
+                if (Object.keys(this.subscribers).length > 0) {
+                    this.init(retries + 1);
+                }
+            }
+        });
+    }
+    cleanupSubscription(subscriptionId) {
+        var _a;
+        const emitter = this.subscribers[subscriptionId];
+        if (!emitter)
+            return;
+        const key = (_a = Object.entries(this.taskSignalKeyToSubscriptionIds).find(([, ids]) => ids.includes(subscriptionId))) === null || _a === void 0 ? void 0 : _a[0];
+        delete this.subscribers[subscriptionId];
+        if (key && this.taskSignalKeyToSubscriptionIds[key]) {
+            this.taskSignalKeyToSubscriptionIds[key] = this.taskSignalKeyToSubscriptionIds[key].filter((id) => id !== subscriptionId);
+            if (this.taskSignalKeyToSubscriptionIds[key].length === 0) {
+                delete this.taskSignalKeyToSubscriptionIds[key];
+            }
+        }
+    }
+    subscribe(request) {
+        const subscriptionId = (this.subscriptionCounter++).toString();
+        const subscriber = new LegacyDurableEventStreamable(() => this.cleanupSubscription(subscriptionId));
+        this.subscribers[subscriptionId] = subscriber;
+        const key = `${request.taskId}|${request.signalKey}`;
+        if (!this.taskSignalKeyToSubscriptionIds[key]) {
+            this.taskSignalKeyToSubscriptionIds[key] = [];
+        }
+        this.taskSignalKeyToSubscriptionIds[key].push(subscriptionId);
+        this.requestEmitter.emit('subscribe', request);
+        return subscriber;
+    }
+    request() {
+        return __asyncGenerator(this, arguments, function* request_1() {
+            var _a, e_3, _b, _c;
+            const { currRequester } = this;
+            const existing = new Set();
+            for (const key in this.taskSignalKeyToSubscriptionIds) {
+                if (this.taskSignalKeyToSubscriptionIds[key].length > 0) {
+                    const [taskId, signalKey] = key.split('|');
+                    existing.add(key);
+                    yield yield __await({ taskId, signalKey });
+                }
+            }
+            try {
+                for (var _d = true, _e = __asyncValues((0, events_1.on)(this.requestEmitter, 'subscribe')), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const e = _c;
+                    if (currRequester !== this.currRequester)
+                        break;
+                    const request = e[0];
+                    const key = `${request.taskId}|${request.signalKey}`;
+                    if (!existing.has(key)) {
+                        existing.add(key);
+                        yield yield __await(request);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        });
+    }
+}