@hatchet-dev/typescript-sdk 1.16.0 → 1.17.1

package/v1/client/worker/context.js

@@ -30,6 +30,10 @@ const transformer_1 = require("../../conditions/transformer");
 const condition_1 = require("../../../protoc/v1/shared/condition");
 const apply_namespace_1 = require("../../../util/apply-namespace");
 const abort_error_1 = require("../../../util/abort-error");
+const crypto_1 = require("crypto");
+const duration_1 = require("../duration");
+const engine_version_1 = require("./engine-version");
+const pre_eviction_1 = require("./deprecated/pre-eviction");
 /**
  * ContextWorker is a wrapper around the V1Worker class that provides a more user-friendly interface for the worker from the context of a run.
  */
@@ -328,7 +332,7 @@ class Context {
                 this._logger.warn('cannot refresh timeout from context without stepRunId');
                 return;
             }
-            yield this.v1.dispatcher.refreshTimeout(incrementBy, taskRunExternalId);
+            yield this.v1.dispatcher.refreshTimeout((0, duration_1.durationToString)(incrementBy), taskRunExternalId);
         });
     }
     /**
@@ -634,19 +638,68 @@ exports.Context = Context;
  * It extends the Context class and includes additional methods for durable execution like sleepFor and waitFor.
  */
 class DurableContext extends Context {
-    constructor() {
-        super(...arguments);
-        this.waitKey = 0;
+    constructor(action, v1, worker, durableListener, evictionManager, engineVersion) {
+        super(action, v1, worker);
+        this._waitKey = 0;
+        this._durableListener = durableListener;
+        this._evictionManager = evictionManager;
+        this._engineVersion = engineVersion;
+    }
+    get supportsEviction() {
+        return (0, engine_version_1.supportsEviction)(this._engineVersion);
+    }
+    get durableListener() {
+        return this._durableListener;
+    }
+    /**
+     * The invocation count for the current durable task. Used for deduplication across replays.
+     */
+    get invocationCount() {
+        var _a;
+        return (_a = this.action.durableTaskInvocationCount) !== null && _a !== void 0 ? _a : 1;
+    }
+    get _actionKey() {
+        return this.action.key;
+    }
+    withEvictionWait(waitKind, resourceId, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            (_a = this._evictionManager) === null || _a === void 0 ? void 0 : _a.markWaiting(this._actionKey, waitKind, resourceId);
+            try {
+                return yield fn();
+            }
+            finally {
+                (_b = this._evictionManager) === null || _b === void 0 ? void 0 : _b.markActive(this._actionKey);
+            }
+        });
     }
     /**
      * Pauses execution for the specified duration.
      * Duration is "global" meaning it will wait in real time regardless of transient failures like worker restarts.
      * @param duration - The duration to sleep for.
-     * @returns A promise that resolves when the sleep duration has elapsed.
+     * @returns A promise that resolves with a SleepResult when the sleep duration has elapsed.
      */
     sleepFor(duration, readableDataKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.waitFor({ sleepFor: duration, readableDataKey });
+            const res = yield this.waitFor({ sleepFor: duration, readableDataKey });
+            const matches = res['CREATE'] || {};
+            const [firstMatch] = Object.values(matches);
+            if (!firstMatch || firstMatch.length === 0) {
+                return { durationMs: (0, duration_1.durationToMs)(duration) };
+            }
+            const [sleep] = firstMatch;
+            const sleepDuration = sleep === null || sleep === void 0 ? void 0 : sleep.sleep_duration;
+            if (sleepDuration) {
+                const DURATION_RE = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/;
+                const match = sleepDuration.match(DURATION_RE);
+                if (match) {
+                    const [, h, m, s] = match;
+                    const ms = (parseInt(h !== null && h !== void 0 ? h : '0', 10) * 3600 + parseInt(m !== null && m !== void 0 ? m : '0', 10) * 60 + parseInt(s !== null && s !== void 0 ? s : '0', 10)) *
+                        1000;
+                    return { durationMs: ms };
+                }
+            }
+            return { durationMs: (0, duration_1.durationToMs)(duration) };
         });
     }
     /**
@@ -658,23 +711,196 @@ class DurableContext extends Context {
     waitFor(conditions) {
         return __awaiter(this, void 0, void 0, function* () {
             this.throwIfCancelled();
-            const pbConditions = (0, transformer_1.conditionsToPb)((0, conditions_1.Render)(condition_1.Action.CREATE, conditions), this.v1.config.namespace);
-            const key = `waitFor-${this.waitKey++}`;
-            yield this.v1.durableListener.registerDurableEvent({
-                taskId: this.action.taskRunExternalId,
-                signalKey: key,
-                sleepConditions: pbConditions.sleepConditions,
-                userEventConditions: pbConditions.userEventConditions,
+            if (!this.supportsEviction) {
+                return this._waitForPreEviction(conditions);
+            }
+            const rendered = (0, conditions_1.Render)(condition_1.Action.CREATE, conditions);
+            const pbConditions = (0, transformer_1.conditionsToPb)(rendered, this.v1.config.namespace);
+            const ack = yield this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
+                kind: 'waitFor',
+                waitForConditions: {
+                    sleepConditions: pbConditions.sleepConditions,
+                    userEventConditions: pbConditions.userEventConditions,
+                },
+            });
+            const resourceId = rendered
+                .map((c) => c.base.readableDataKey)
+                .filter(Boolean)
+                .join(',') || `node:${ack.nodeId}`;
+            return this.withEvictionWait('waitFor', resourceId, () => __awaiter(this, void 0, void 0, function* () {
+                const result = yield this._durableListener.waitForCallback(this.action.taskRunExternalId, this.invocationCount, ack.branchId, ack.nodeId, { signal: this.abortController.signal });
+                return result.payload || {};
+            }));
+        });
+    }
+    waitForEvent(key, expression, payloadSchema) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.waitFor({ eventKey: key, expression });
+            // The engine returns an object like:
+            // {"CREATE": {"signal_key_1": [{"id": ..., "data": {...}}]}}
+            // Since we have a single match, the list will only have one item.
+            const matches = res['CREATE'] || {};
+            const [firstMatch] = Object.values(matches);
+            if (!firstMatch || firstMatch.length === 0) {
+                if (payloadSchema) {
+                    return payloadSchema.parse({});
+                }
+                return {};
+            }
+            const [rawPayload] = firstMatch;
+            if (payloadSchema) {
+                return payloadSchema.parse(rawPayload);
+            }
+            return rawPayload;
+        });
+    }
+    /**
+     * Durably sleep until a specific timestamp.
+     * Uses the memoized `now()` to compute the remaining duration, then delegates to `sleepFor`.
+     *
+     * @param wakeAt - The timestamp to sleep until.
+     * @returns A SleepResult containing the actual duration slept.
+     */
+    sleepUntil(wakeAt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = yield this.now();
+            const remainingMs = wakeAt.getTime() - now.getTime();
+            return this.sleepFor(`${Math.max(0, Math.ceil(remainingMs / 1000))}s`);
+        });
+    }
+    /**
+     * Get the current timestamp, memoized across replays. Returns the same Date on every replay of the same task run.
+     * @returns The memoized current timestamp.
+     */
+    now() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.memo(() => __awaiter(this, void 0, void 0, function* () {
+                return { ts: new Date().toISOString() };
+            }), ['now']);
+            return new Date(result.ts);
+        });
+    }
+    _waitForPreEviction(conditions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { result, nextWaitKey } = yield (0, pre_eviction_1.waitForPreEviction)(this._durableListener, this.action.taskRunExternalId, this._waitKey, conditions, this.v1.config.namespace, this.abortController.signal);
+            this._waitKey = nextWaitKey;
+            return result;
+        });
+    }
+    _buildTriggerOpts(workflow, input, options) {
+        let workflowName;
+        if (typeof workflow === 'string') {
+            workflowName = workflow;
+        }
+        else {
+            workflowName = workflow.name;
+        }
+        workflowName = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace).toLowerCase();
+        const triggerOpts = {
+            name: workflowName,
+            input: JSON.stringify(input || {}),
+            parentId: this.action.workflowRunId,
+            parentTaskRunExternalId: this.action.taskRunExternalId,
+            childIndex: this.spawnIndex,
+            childKey: options === null || options === void 0 ? void 0 : options.key,
+            additionalMetadata: (options === null || options === void 0 ? void 0 : options.additionalMetadata)
+                ? JSON.stringify(options.additionalMetadata)
+                : undefined,
+            desiredWorkerId: (options === null || options === void 0 ? void 0 : options.sticky) ? this.worker.id() : undefined,
+            priority: options === null || options === void 0 ? void 0 : options.priority,
+            desiredWorkerLabels: {},
+        };
+        this.spawnIndex += 1;
+        return { workflowName, triggerOpts };
+    }
+    /**
+     * Spawns a child workflow through the durable event log, waits for the child to complete.
+     * @param workflow - The workflow to spawn.
+     * @param input - The input data for the child workflow.
+     * @param options - Options for spawning the child workflow.
+     * @returns The result of the child workflow.
+     */
+    spawnChild(workflow, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.supportsEviction) {
+                const { workflowName, opts } = this.spawnOptions(workflow, options);
+                const ref = yield this.v1.admin.runWorkflow(workflowName, (input || {}), opts);
+                ref.defaultSignal = this.abortController.signal;
+                return ref.output;
+            }
+            const results = yield this.spawnChildren([
+                { workflow, input: (input || {}), options },
+            ]);
+            return results[0];
+        });
+    }
+    /**
+     * Spawns multiple child workflows through the durable event log, waits for all to complete.
+     * @param children - An array of objects containing the workflow, input, and options for each child.
+     * @returns A list of results from the child workflows.
+     */
+    spawnChildren(children) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.throwIfCancelled();
+            if (!this.supportsEviction) {
+                const workflows = children.map((c) => {
+                    const { workflowName, opts } = this.spawnOptions(c.workflow, c.options);
+                    return { workflowName, input: c.input, options: opts };
+                });
+                const refs = yield this.v1.admin.runWorkflows(workflows);
+                for (const r of refs) {
+                    r.defaultSignal = this.abortController.signal;
+                }
+                return Promise.all(refs.map((r) => r.output));
+            }
+            const triggerOptsList = children.map((child) => {
+                const { triggerOpts } = this._buildTriggerOpts(child.workflow, child.input, child.options);
+                return triggerOpts;
+            });
+            const ack = yield this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
+                kind: 'runChildren',
+                triggerOpts: triggerOptsList,
             });
-            const event = yield this.v1.durableListener.result({
-                taskId: this.action.taskRunExternalId,
-                signalKey: key,
-            }, { signal: this.abortController.signal });
-            // Convert event.data from Uint8Array to string if needed
-            const eventData = event.data instanceof Uint8Array ? new TextDecoder().decode(event.data) : event.data;
-            const res = JSON.parse(eventData);
-            return res.CREATE;
+            const results = yield Promise.all(ack.runEntries.map((entry) => this.withEvictionWait('runChild', `workflow:bulk-child`, () => __awaiter(this, void 0, void 0, function* () {
+                const result = yield this._durableListener.waitForCallback(this.action.taskRunExternalId, this.invocationCount, entry.branchId, entry.nodeId, { signal: this.abortController.signal });
+                return (result.payload || {});
+            }))));
+            return results;
+        });
+    }
+    /**
+     * Memoize a function by storing its result in durable storage. Avoids recomputation on replay.
+     *
+     * @param fn - The async function to compute the value.
+     * @param deps - Dependency values that form the memoization key.
+     * @returns The memoized value, either from durable storage or freshly computed.
+     */
+    memo(fn, deps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.throwIfCancelled();
+            if (!this.supportsEviction) {
+                return fn();
+            }
+            const memoKey = computeMemoKey(this.action.taskRunExternalId, deps);
+            const ack = yield this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
+                kind: 'memo',
+                memoKey,
+            });
+            if (ack.memoAlreadyExisted && ack.memoResultPayload && ack.memoResultPayload.length > 0) {
+                const serialized = new TextDecoder().decode(ack.memoResultPayload);
+                return JSON.parse(serialized);
+            }
+            const result = yield fn();
+            const serializedResult = new TextEncoder().encode(JSON.stringify(result));
+            yield this._durableListener.sendMemoCompletedNotification(this.action.taskRunExternalId, ack.nodeId, ack.branchId, this.invocationCount, memoKey, serializedResult);
+            return result;
         });
     }
 }
 exports.DurableContext = DurableContext;
+function computeMemoKey(taskRunExternalId, args) {
+    const h = (0, crypto_1.createHash)('sha256');
+    h.update(taskRunExternalId);
+    h.update(JSON.stringify(args));
+    return new Uint8Array(h.digest());
+}

package/v1/client/worker/deprecated/index.d.ts

@@ -1,4 +1,4 @@
-export { isLegacyEngine, LegacyDualWorker } from './legacy-worker';
+export { isLegacyEngine, fetchEngineVersion, LegacyDualWorker } from './legacy-worker';
 export { LegacyV1Worker } from './legacy-v1-worker';
 export { legacyGetActionListener } from './legacy-registration';
 export { emitDeprecationNotice, DeprecationError, parseSemver, semverLessThan, } from './deprecation';

package/v1/client/worker/deprecated/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.semverLessThan = exports.parseSemver = exports.DeprecationError = exports.emitDeprecationNotice = exports.legacyGetActionListener = exports.LegacyV1Worker = exports.LegacyDualWorker = exports.isLegacyEngine = void 0;
+exports.semverLessThan = exports.parseSemver = exports.DeprecationError = exports.emitDeprecationNotice = exports.legacyGetActionListener = exports.LegacyV1Worker = exports.LegacyDualWorker = exports.fetchEngineVersion = exports.isLegacyEngine = void 0;
 var legacy_worker_1 = require("./legacy-worker");
 Object.defineProperty(exports, "isLegacyEngine", { enumerable: true, get: function () { return legacy_worker_1.isLegacyEngine; } });
+Object.defineProperty(exports, "fetchEngineVersion", { enumerable: true, get: function () { return legacy_worker_1.fetchEngineVersion; } });
 Object.defineProperty(exports, "LegacyDualWorker", { enumerable: true, get: function () { return legacy_worker_1.LegacyDualWorker; } });
 var legacy_v1_worker_1 = require("./legacy-v1-worker");
 Object.defineProperty(exports, "LegacyV1Worker", { enumerable: true, get: function () { return legacy_v1_worker_1.LegacyV1Worker; } });

package/v1/client/worker/deprecated/legacy-worker.d.ts

@@ -8,6 +8,11 @@
 import { HatchetClient } from '../../..';
 import { CreateWorkerOpts } from '../worker';
 import { LegacyV1Worker } from './legacy-v1-worker';
+/**
+ * Fetches the engine version from the dispatcher.
+ * Returns the semver string, or undefined if the engine is too old to support GetVersion.
+ */
+export declare function fetchEngineVersion(v1: HatchetClient): Promise<string | undefined>;
 /**
  * Checks if the connected engine is legacy by comparing its semantic version
  * against the minimum required version for slot_config support.

package/v1/client/worker/deprecated/legacy-worker.js

@@ -17,22 +17,40 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LegacyDualWorker = void 0;
+exports.fetchEngineVersion = fetchEngineVersion;
 exports.isLegacyEngine = isLegacyEngine;
 const nice_grpc_1 = require("nice-grpc");
-const grpc_error_1 = require("../../../../util/grpc-error");
 const declaration_1 = require("../../../declaration");
 const legacy_v1_worker_1 = require("./legacy-v1-worker");
 const deprecation_1 = require("./deprecation");
 const legacy_transformer_1 = require("../../../../legacy/legacy-transformer");
+const engine_version_1 = require("../engine-version");
+const grpc_error_1 = require("../../../../util/grpc-error");
 const DEFAULT_DEFAULT_SLOTS = 100;
 const DEFAULT_DURABLE_SLOTS = 1000;
 /** The date when slot_config support was released. */
 const LEGACY_ENGINE_START = new Date('2026-02-12T00:00:00Z');
-/** Minimum engine version that supports multiple slot types. */
-const MIN_SLOT_CONFIG_VERSION = 'v0.78.23';
 const LEGACY_ENGINE_MESSAGE = 'Connected to an older Hatchet engine that does not support multiple slot types. ' +
     'Falling back to legacy worker registration. ' +
     'Please upgrade your Hatchet engine to the latest version.';
+/**
+ * Fetches the engine version from the dispatcher.
+ * Returns the semver string, or undefined if the engine is too old to support GetVersion.
+ */
+function fetchEngineVersion(v1) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const version = yield v1.dispatcher.getVersion();
+            return version || undefined;
+        }
+        catch (e) {
+            if ((0, grpc_error_1.getGrpcErrorCode)(e) == nice_grpc_1.Status.UNIMPLEMENTED) {
+                return undefined;
+            }
+            throw e;
+        }
+    });
+}
 /**
  * Checks if the connected engine is legacy by comparing its semantic version
  * against the minimum required version for slot_config support.
@@ -41,29 +59,20 @@ const LEGACY_ENGINE_MESSAGE = 'Connected to an older Hatchet engine that does no
  */
 function isLegacyEngine(v1) {
     return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const version = yield v1.dispatcher.getVersion();
-            // If the version is empty or older than the minimum, treat as legacy
-            if (!version || (0, deprecation_1.semverLessThan)(version, MIN_SLOT_CONFIG_VERSION)) {
-                const logger = v1.config.logger('Worker', v1.config.log_level);
-                (0, deprecation_1.emitDeprecationNotice)('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
-                    errorDays: 180,
-                });
-                return true;
-            }
-            return false;
-        }
-        catch (e) {
+        const version = yield fetchEngineVersion(v1).catch((e) => {
             if ((0, grpc_error_1.getGrpcErrorCode)(e) === nice_grpc_1.Status.UNIMPLEMENTED) {
-                const logger = v1.config.logger('Worker', v1.config.log_level);
-                (0, deprecation_1.emitDeprecationNotice)('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
-                    errorDays: 180,
-                });
-                return true;
+                return undefined;
             }
-            // For other errors, assume new engine and let registration fail naturally
-            return false;
+            throw e;
+        });
+        if (!version || (0, deprecation_1.semverLessThan)(version, engine_version_1.MinEngineVersion.SLOT_CONFIG)) {
+            const logger = v1.config.logger('Worker', v1.config.log_level);
+            (0, deprecation_1.emitDeprecationNotice)('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
+                errorDays: 180,
+            });
+            return true;
         }
+        return false;
     });
 }
 /**

package/v1/client/worker/deprecated/pre-eviction.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Pre-eviction fallback for DurableContext.
+ *
+ * Supports engines older than MinEngineVersion.DURABLE_EVICTION.
+ * Remove this module when support for those engines is dropped.
+ */
+import { Conditions } from '../../../conditions';
+import { DurableListenerClient } from '../../../../clients/listeners/durable-listener/durable-listener-client';
+export declare function waitForPreEviction(durableListener: DurableListenerClient, taskRunExternalId: string, waitKey: number, conditions: Conditions | Conditions[], namespace?: string, signal?: AbortSignal): Promise<{
+    result: Record<string, unknown>;
+    nextWaitKey: number;
+}>;

package/v1/client/worker/deprecated/pre-eviction.js

@@ -0,0 +1,37 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForPreEviction = waitForPreEviction;
+/**
+ * Pre-eviction fallback for DurableContext.
+ *
+ * Supports engines older than MinEngineVersion.DURABLE_EVICTION.
+ * Remove this module when support for those engines is dropped.
+ */
+const conditions_1 = require("../../../conditions");
+const transformer_1 = require("../../../conditions/transformer");
+const condition_1 = require("../../../../protoc/v1/shared/condition");
+function waitForPreEviction(durableListener, taskRunExternalId, waitKey, conditions, namespace, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pbConditions = (0, transformer_1.conditionsToPb)((0, conditions_1.Render)(condition_1.Action.CREATE, conditions), namespace);
+        const key = `waitFor-${waitKey}`;
+        yield durableListener.registerDurableEvent({
+            taskId: taskRunExternalId,
+            signalKey: key,
+            sleepConditions: pbConditions.sleepConditions,
+            userEventConditions: pbConditions.userEventConditions,
+        });
+        const event = yield durableListener.result({ taskId: taskRunExternalId, signalKey: key }, { signal });
+        const eventData = event.data instanceof Uint8Array ? new TextDecoder().decode(event.data) : event.data;
+        const res = JSON.parse(eventData);
+        return { result: res.CREATE, nextWaitKey: waitKey + 1 };
+    });
+}

package/v1/client/worker/engine-version.d.ts

@@ -0,0 +1,5 @@
+export declare const MinEngineVersion: {
+    readonly SLOT_CONFIG: "v0.78.23";
+    readonly DURABLE_EVICTION: "v0.80.0";
+};
+export declare function supportsEviction(engineVersion: string | undefined): boolean;

package/v1/client/worker/engine-version.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinEngineVersion = void 0;
+exports.supportsEviction = supportsEviction;
+const deprecation_1 = require("./deprecated/deprecation");
+exports.MinEngineVersion = {
+    SLOT_CONFIG: 'v0.78.23',
+    DURABLE_EVICTION: 'v0.80.0',
+};
+function supportsEviction(engineVersion) {
+    if (!engineVersion)
+        return false;
+    return !(0, deprecation_1.semverLessThan)(engineVersion, exports.MinEngineVersion.DURABLE_EVICTION);
+}

package/v1/client/worker/eviction/eviction-cache.d.ts

@@ -0,0 +1,33 @@
+import { ActionKey } from '../../../../clients/dispatcher/action-listener';
+import { EvictionPolicy } from './eviction-policy';
+export type { ActionKey };
+export declare enum EvictionCause {
+    TTL_EXCEEDED = "ttl_exceeded",
+    CAPACITY_PRESSURE = "capacity_pressure",
+    WORKER_SHUTDOWN = "worker_shutdown"
+}
+export interface DurableRunRecord {
+    key: ActionKey;
+    taskRunExternalId: string;
+    invocationCount: number;
+    evictionPolicy: EvictionPolicy | undefined;
+    registeredAt: number;
+    waitingSince: number | undefined;
+    waitKind: string | undefined;
+    waitResourceId: string | undefined;
+    _waitCount: number;
+    evictionReason: string | undefined;
+}
+export declare class DurableEvictionCache {
+    private _runs;
+    registerRun(key: ActionKey, taskRunExternalId: string, invocationCount: number, now: number, evictionPolicy: EvictionPolicy | undefined): void;
+    unregisterRun(key: ActionKey): void;
+    get(key: ActionKey): DurableRunRecord | undefined;
+    getAllWaiting(): DurableRunRecord[];
+    findKeyByTaskRunExternalId(taskRunExternalId: string): ActionKey | undefined;
+    markWaiting(key: ActionKey, now: number, waitKind: string, resourceId: string): void;
+    markActive(key: ActionKey): void;
+    selectEvictionCandidate(now: number, durableSlots: number, reserveSlots: number, minWaitForCapacityEvictionMs: number): ActionKey | undefined;
+    private _hasCapacityPressure;
+}
+export declare function buildEvictionReason(cause: EvictionCause, rec: DurableRunRecord): string;