@hatchet-dev/typescript-sdk 1.31.0 → 1.32.0

package/v1/client/worker/context.d.ts

@@ -8,20 +8,20 @@
  * @module Context
  */
 import { Priority, RunOpts, TaskWorkflowDeclaration, BaseWorkflowDeclaration as WorkflowV1 } from '../../declaration';
-import type { Action } from '../../../clients/dispatcher/action-listener';
+import type { Action } from '../../../clients/dispatcher/action';
 import { Logger, LogLevel } from '../../../util/logger';
 import WorkflowRunRef from '../../../util/workflow-run-ref';
 import { Conditions } from '../../conditions';
 import { CreateWorkflowDurableTaskOpts, CreateWorkflowTaskOpts } from '../../task';
 import { JsonObject, OutputType } from '../../types';
-import { HatchetClient } from '../..';
-import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
-import { NextStep } from '../../../legacy/step';
-import { DurableListenerClient } from '../../../clients/listeners/durable-listener/durable-listener-client';
+import type { HatchetClient } from '../client';
+import type { NextStep } from '../../../legacy/step';
+import type { DurableListenerClient } from '../../../clients/listeners/durable-listener/durable-listener-client';
 import { z } from 'zod/v4';
-import { InternalWorker } from './worker-internal';
+import type { InternalWorker } from './worker-internal';
 import { Duration } from '../duration';
-import { DurableEvictionManager } from './eviction/eviction-manager';
+import type { DurableEvictionManager } from './eviction/eviction-manager';
+import { ContextRuntime, DurableContextOptions, DurableTransport, WorkerLabels } from './runtime';
 type TriggerData = Record<string, Record<string, any>>;
 type ChildRunOpts = RunOpts & {
     key?: string;
@@ -50,11 +50,11 @@ interface ContextData<T, K> {
     step_run_errors: Record<string, string>;
 }
 /**
- * ContextWorker is a wrapper around the V1Worker class that provides a more user-friendly interface for the worker from the context of a run.
+ * ContextWorker is a user-friendly view of the worker running the task, from the context of a run.
  */
 export declare class ContextWorker {
-    private worker;
-    constructor(worker: InternalWorker);
+    private runtime;
+    constructor(runtime: ContextRuntime);
     /**
      * Gets the ID of the worker.
      * @returns The ID of the worker.
@@ -83,7 +83,14 @@ export declare class Context<T, K = {}> {
     input: T;
     controller: AbortController;
     action: Action;
+    /**
+     * The Hatchet client of the worker running the task. Only set when the context was
+     * created by a worker; a runtime without a client (see {@link ContextRuntime}) leaves
+     * it undefined.
+     */
     v1: HatchetClient;
+    /** The runtime the context performs engine-facing operations through. */
+    runtime: ContextRuntime;
     worker: ContextWorker;
     overridesData: Record<string, any>;
     _logger: Logger;
@@ -91,6 +98,18 @@ export declare class Context<T, K = {}> {
     spawnIndex: number;
     streamIndex: number;
     protected nextChildIndex(n?: number): number;
+    /**
+     * Creates a context on top of a runtime.
+     * @param action - The action assigned to the task.
+     * @param runtime - The runtime the context performs engine-facing operations through.
+     */
+    constructor(action: Action, runtime: ContextRuntime);
+    /**
+     * Creates a context for a task running on a worker.
+     * @param action - The action assigned to the task.
+     * @param v1 - The worker's Hatchet client.
+     * @param worker - The worker running the task.
+     */
     constructor(action: Action, v1: HatchetClient, worker: InternalWorker);
     get abortController(): AbortController;
     get cancelled(): boolean;
@@ -247,7 +266,7 @@ export declare class Context<T, K = {}> {
                 value: string | number;
                 required?: boolean;
                 weight?: number;
-                comparator?: import("../..").WorkerLabelComparator;
+                comparator?: import("../../task").WorkerLabelComparator;
             }>;
             key?: string;
         };
@@ -383,9 +402,29 @@ export declare class DurableContext<T, K = {}> extends Context<T, K> {
     private _waitKey;
     private _sendEventLock;
     private _serializeSendEvent;
+    /**
+     * Creates a durable context on top of a runtime and a durable transport.
+     * @param action - The action assigned to the task.
+     * @param runtime - The runtime the context performs engine-facing operations through.
+     * @param transport - The transport durable events travel over.
+     * @param options - Engine version and eviction settings.
+     */
+    constructor(action: Action, runtime: ContextRuntime, transport: DurableTransport, options?: DurableContextOptions & {
+        evictionManager?: DurableEvictionManager;
+    });
+    /**
+     * Creates a durable context for a task running on a worker.
+     * @param action - The action assigned to the task.
+     * @param v1 - The worker's Hatchet client.
+     * @param worker - The worker running the task.
+     * @param durableListener - The worker's durable listener.
+     * @param evictionManager - The worker's eviction manager, when the engine supports eviction.
+     * @param engineVersion - The engine version the worker is connected to.
+     */
     constructor(action: Action, v1: HatchetClient, worker: InternalWorker, durableListener: DurableListenerClient, evictionManager?: DurableEvictionManager, engineVersion?: string);
     get supportsEviction(): boolean;
-    get durableListener(): DurableListenerClient;
+    /** The transport durable events travel over. */
+    get durableListener(): DurableTransport;
     /**
      * The invocation count for the current durable task. Used for deduplication across replays.
      */
@@ -465,4 +504,11 @@ export declare class DurableContext<T, K = {}> extends Context<T, K> {
      */
     private memo;
 }
+/**
+ * Derives the memo key for a task run and its dependency values: the SHA-256 of the task
+ * run id followed by the JSON-serialised dependencies, over WebCrypto so it works in
+ * every runtime. The bytes are identical to the previous Node `createHash` version, so
+ * event logs recorded by older SDKs keep replaying.
+ */
+export declare function computeMemoKey(taskRunExternalId: string, args: readonly unknown[]): Promise<Uint8Array>;
 export {};

package/v1/client/worker/context.js

@@ -22,34 +22,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DurableContext = exports.Context = exports.ContextWorker = void 0;
+exports.computeMemoKey = computeMemoKey;
 const declaration_1 = require("../../declaration");
 const hatchet_error_1 = __importDefault(require("../../../util/errors/hatchet-error"));
-const action_listener_1 = require("../../../clients/dispatcher/action-listener");
+const action_1 = require("../../../clients/dispatcher/action");
 const parse_1 = require("../../../util/parse");
 const conditions_1 = require("../../conditions");
 const transformer_1 = require("../../conditions/transformer");
 const condition_1 = require("../../../protoc/v1/shared/condition");
-const dispatcher_1 = require("../../../protoc/dispatcher");
 const apply_namespace_1 = require("../../../util/apply-namespace");
 const abort_error_1 = require("../../../util/abort-error");
 const parent_run_context_vars_1 = require("../../parent-run-context-vars");
-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");
+const runtime_1 = require("./runtime");
+const worker_runtime_1 = require("./worker-runtime");
 /**
- * ContextWorker is a wrapper around the V1Worker class that provides a more user-friendly interface for the worker from the context of a run.
+ * ContextWorker is a user-friendly view of the worker running the task, from the context of a run.
  */
 class ContextWorker {
-    constructor(worker) {
-        this.worker = worker;
+    constructor(runtime) {
+        this.runtime = runtime;
     }
     /**
      * Gets the ID of the worker.
      * @returns The ID of the worker.
      */
     id() {
-        return this.worker.workerId;
+        return this.runtime.workerId();
     }
     /**
      * Checks if the worker has a registered workflow.
@@ -57,14 +58,14 @@ class ContextWorker {
      * @returns True if the workflow is registered, otherwise false.
      */
     hasWorkflow(workflowName) {
-        return !!this.worker.workflow_registry.find((workflow) => 'id' in workflow ? workflow.id === workflowName : workflow.name === workflowName);
+        return this.runtime.hasWorkflow(workflowName);
     }
     /**
      * Gets the current state of the worker labels.
      * @returns The labels of the worker.
      */
     labels() {
-        return this.worker.labels;
+        return this.runtime.workerLabels();
     }
     /**
      * Upserts the a set of labels on the worker.
@@ -72,10 +73,16 @@ class ContextWorker {
      * @returns A promise that resolves when the labels have been upserted.
      */
     upsertLabels(labels) {
-        return this.worker.upsertLabels(labels);
+        return this.runtime.upsertWorkerLabels(labels);
     }
 }
 exports.ContextWorker = ContextWorker;
+function resolveRuntime(runtimeOrClient, worker) {
+    if ((0, runtime_1.isContextRuntime)(runtimeOrClient)) {
+        return runtimeOrClient;
+    }
+    return (0, worker_runtime_1.createWorkerContextRuntime)(runtimeOrClient, worker);
+}
 class Context {
     nextChildIndex(n = 1) {
         var _a;
@@ -85,7 +92,7 @@ class Context {
         this.spawnIndex = idx + n;
         return idx;
     }
-    constructor(action, v1, worker) {
+    constructor(action, runtimeOrClient, worker) {
         // @deprecated use ctx.abortController instead
         this.controller = new AbortController();
         this.overridesData = {};
@@ -93,12 +100,14 @@ class Context {
         this.spawnIndex = 0;
         this.streamIndex = 0;
         try {
+            const runtime = resolveRuntime(runtimeOrClient, worker);
             const data = (0, parse_1.parseJSON)(action.actionPayload);
             this.data = data;
             this.action = action;
-            this.v1 = v1;
-            this.worker = new ContextWorker(worker);
-            this._logger = v1.config.logger(`Context Logger`, v1.config.log_level);
+            this.runtime = runtime;
+            this.v1 = runtime.client;
+            this.worker = new ContextWorker(runtime);
+            this._logger = runtime.logger(`Context Logger`);
             // if this is a getGroupKeyRunId, the data is the workflow input
             if (action.getGroupKeyRunId !== '') {
                 this.input = data;
@@ -143,20 +152,16 @@ class Context {
                 // the raw batch-items map for a START_BATCH action, keyed by each member's
                 // task-run external id.
                 const memberIds = Object.keys((_a = this.data) !== null && _a !== void 0 ? _a : {});
-                yield this.v1.dispatcher.sendBatchActionEvent({
+                yield this.runtime.cancelBatch({
                     workerId: (_b = this.worker.id()) !== null && _b !== void 0 ? _b : '',
                     jobId: this.action.jobId,
                     actionId: this.action.actionId,
                     batchId: this.action.batchId,
-                    eventTimestamp: new Date(),
-                    eventType: dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_CANCELLED,
-                    items: memberIds.map((id) => ({ taskRunExternalId: id, eventPayload: '' })),
+                    memberIds,
                 });
             }
             else {
-                yield this.v1.runs.cancel({
-                    ids: [this.action.taskRunExternalId],
-                });
+                yield this.runtime.cancelRun(this.action.taskRunExternalId);
             }
             // optimistically abort the run
             this.controller.abort();
@@ -242,7 +247,7 @@ class Context {
      * @returns The name of the workflow.
      */
     workflowNameV1() {
-        return (0, action_listener_1.workflowNameFromAction)(this.action);
+        return (0, action_1.workflowNameFromAction)(this.action);
     }
     /**
      * Gets the user data associated with the workflow.
@@ -317,7 +322,7 @@ class Context {
             this._logger.warn('cannot log from context without stepRunId');
             return Promise.resolve();
         }
-        const logger = this.v1.config.logger('ctx', this.v1.config.log_level);
+        const logger = this.runtime.logger('ctx');
         const contextExtra = Object.assign({ workflowRunId: this.action.workflowRunId, taskRunExternalId: this.action.taskRunExternalId, retryCount: this.action.retryCount, workflowName: this.workflowNameV1() }, extra === null || extra === void 0 ? void 0 : extra.extra);
         const promises = [];
         if (!level || level === 'INFO') {
@@ -333,7 +338,7 @@ class Context {
             promises.push(logger.error(message, extra === null || extra === void 0 ? void 0 : extra.error, contextExtra));
         }
         // FIXME: this is a hack to get around the fact that the log level is not typed
-        promises.push(this.v1.event.putLog(taskRunExternalId, message, level, this.retryCount(), extra === null || extra === void 0 ? void 0 : extra.extra));
+        promises.push(this.runtime.putLog(taskRunExternalId, message, level, this.retryCount(), extra === null || extra === void 0 ? void 0 : extra.extra));
         return Promise.all(promises);
     }
     get logger() {
@@ -351,7 +356,7 @@ class Context {
                 return this.log(message, 'ERROR', extra);
             },
             util: (key, message, extra) => {
-                const logger = this.v1.config.logger('ctx', this.v1.config.log_level);
+                const logger = this.runtime.logger('ctx');
                 if (!logger.util) {
                     return Promise.resolve();
                 }
@@ -372,7 +377,7 @@ class Context {
                 this._logger.warn('cannot refresh timeout from context without stepRunId');
                 return;
             }
-            yield this.v1.dispatcher.refreshTimeout((0, duration_1.durationToString)(incrementBy), taskRunExternalId);
+            yield this.runtime.refreshTimeout(taskRunExternalId, (0, duration_1.durationToString)(incrementBy));
         });
     }
     /**
@@ -382,9 +387,7 @@ class Context {
      */
     releaseSlot() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.v1.dispatcher.client.releaseSlot({
-                taskRunExternalId: this.action.taskRunExternalId,
-            });
+            yield this.runtime.releaseSlot(this.action.taskRunExternalId);
         });
     }
     /**
@@ -401,7 +404,7 @@ class Context {
                 return;
             }
             const index = this._incrementStreamIndex();
-            yield this.v1.events.putStream(taskRunExternalId, data, index);
+            yield this.runtime.putStream(taskRunExternalId, data, index);
         });
     }
     spawnOptions(workflow, options) {
@@ -425,7 +428,7 @@ class Context {
     }
     spawn(workflow, input, options) {
         const { workflowName, opts } = this.spawnOptions(workflow, options);
-        return this.v1.admin.runWorkflow(workflowName, input, opts);
+        return this.runtime.runWorkflow(workflowName, input, opts);
     }
     spawnBulk(children) {
         this.throwIfCancelled();
@@ -433,7 +436,7 @@ class Context {
             const { workflowName, opts } = this.spawnOptions(child.workflow, child.options);
             return { workflowName, input: child.input, options: opts };
         });
-        return this.v1.admin.runWorkflows(workflows);
+        return this.runtime.runWorkflows(workflows);
     }
     /**
      * Runs multiple children workflows in parallel without waiting for their results.
@@ -606,7 +609,7 @@ class Context {
                 else {
                     workflowName = workflow.name;
                 }
-                const name = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace).toLowerCase();
+                const name = (0, apply_namespace_1.applyNamespace)(workflowName, this.runtime.namespace).toLowerCase();
                 const opts = options || {};
                 const { sticky } = opts;
                 if (sticky && !this.worker.hasWorkflow(name)) {
@@ -628,7 +631,7 @@ class Context {
                 let resp = [];
                 for (let i = 0; i < workflowRuns.length; i += batchSize) {
                     const batch = workflowRuns.slice(i, i + batchSize);
-                    const batchResp = yield this.v1.admin.runWorkflows(batch);
+                    const batchResp = yield this.runtime.runWorkflows(batch);
                     resp = resp.concat(batchResp);
                 }
                 const res = [];
@@ -661,7 +664,7 @@ class Context {
             this.throwIfCancelled();
             const { workflowRunId, taskRunExternalId } = this.action;
             const workflowName = typeof workflow === 'string' ? workflow : workflow.name;
-            const name = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace).toLowerCase();
+            const name = (0, apply_namespace_1.applyNamespace)(workflowName, this.runtime.namespace).toLowerCase();
             const opts = options || {};
             const { sticky } = opts;
             if (sticky && !this.worker.hasWorkflow(name)) {
@@ -669,7 +672,7 @@ class Context {
             }
             try {
                 const childIndex = this.nextChildIndex();
-                const resp = yield this.v1.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
+                const resp = yield this.runtime.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
                 if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
                     resp._standaloneTaskName = workflow._standalone_task_name;
                 }
@@ -706,20 +709,31 @@ class DurableContext extends Context {
         this._sendEventLock = result.then(() => undefined, () => undefined);
         return result;
     }
-    constructor(action, v1, worker, durableListener, evictionManager, engineVersion) {
-        super(action, v1, worker);
+    constructor(action, runtimeOrClient, workerOrTransport, listenerOrOptions, evictionManager, engineVersion) {
+        // The base constructor tells a runtime apart from a client itself, so the worker
+        // argument is ignored on the runtime path.
+        super(action, runtimeOrClient, workerOrTransport);
         this._waitKey = 0;
         // Serializes sendEvent calls from concurrent coroutines in this invocation.
         // The listener keys pending acks by (task, invocation), so overlapping sends
         // would overwrite each other's ack and cross-wire branch/node assignments.
         this._sendEventLock = Promise.resolve();
-        this._durableListener = durableListener;
-        this._evictionManager = evictionManager;
-        this._engineVersion = engineVersion;
+        if ((0, runtime_1.isContextRuntime)(runtimeOrClient)) {
+            const options = listenerOrOptions;
+            this._durableListener = workerOrTransport;
+            this._evictionManager = options === null || options === void 0 ? void 0 : options.evictionManager;
+            this._engineVersion = options === null || options === void 0 ? void 0 : options.engineVersion;
+        }
+        else {
+            this._durableListener = listenerOrOptions;
+            this._evictionManager = evictionManager;
+            this._engineVersion = engineVersion;
+        }
     }
     get supportsEviction() {
         return (0, engine_version_1.supportsEviction)(this._engineVersion);
     }
+    /** The transport durable events travel over. */
     get durableListener() {
         return this._durableListener;
     }
@@ -784,7 +798,7 @@ class DurableContext extends Context {
                 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 pbConditions = (0, transformer_1.conditionsToPb)(rendered, this.runtime.namespace);
             const ack = yield this._serializeSendEvent(() => this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
                 kind: 'waitFor',
                 waitForConditions: {
@@ -860,7 +874,10 @@ class DurableContext extends Context {
     }
     _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);
+            if (!(0, pre_eviction_1.isLegacyDurableTransport)(this._durableListener)) {
+                throw new hatchet_error_1.default(`Engine ${this._engineVersion || 'unknown'} does not support durable eviction and the durable transport has no legacy fallback. Upgrade the Hatchet engine.`);
+            }
+            const { result, nextWaitKey } = yield (0, pre_eviction_1.waitForPreEviction)(this._durableListener, this.action.taskRunExternalId, this._waitKey, conditions, this.runtime.namespace, this.abortController.signal);
             this._waitKey = nextWaitKey;
             return result;
         });
@@ -873,7 +890,7 @@ class DurableContext extends Context {
         else {
             workflowName = workflow.name;
         }
-        workflowName = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace).toLowerCase();
+        workflowName = (0, apply_namespace_1.applyNamespace)(workflowName, this.runtime.namespace).toLowerCase();
         const childIndex = this.nextChildIndex();
         const triggerOpts = {
             name: workflowName,
@@ -902,7 +919,7 @@ class DurableContext extends Context {
         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);
+                const ref = yield this.runtime.runWorkflow(workflowName, (input || {}), opts);
                 ref.defaultSignal = this.abortController.signal;
                 return ref.output;
             }
@@ -925,7 +942,7 @@ class DurableContext extends Context {
                     const { workflowName, opts } = this.spawnOptions(c.workflow, c.options);
                     return { workflowName, input: c.input, options: opts };
                 });
-                const refs = yield this.v1.admin.runWorkflows(workflows);
+                const refs = yield this.runtime.runWorkflows(workflows);
                 for (const r of refs) {
                     r.defaultSignal = this.abortController.signal;
                 }
@@ -962,7 +979,7 @@ class DurableContext extends Context {
             if (!this.supportsEviction) {
                 return fn();
             }
-            const memoKey = computeMemoKey(this.action.taskRunExternalId, deps);
+            const memoKey = yield computeMemoKey(this.action.taskRunExternalId, deps);
             const ack = yield this._serializeSendEvent(() => this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
                 kind: 'memo',
                 memoKey,
@@ -980,9 +997,20 @@ class DurableContext extends Context {
     }
 }
 exports.DurableContext = DurableContext;
+/**
+ * Derives the memo key for a task run and its dependency values: the SHA-256 of the task
+ * run id followed by the JSON-serialised dependencies, over WebCrypto so it works in
+ * every runtime. The bytes are identical to the previous Node `createHash` version, so
+ * event logs recorded by older SDKs keep replaying.
+ */
 function computeMemoKey(taskRunExternalId, args) {
-    const h = (0, crypto_1.createHash)('sha256');
-    h.update(taskRunExternalId);
-    h.update(JSON.stringify(args));
-    return new Uint8Array(h.digest());
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { subtle } = (_a = globalThis.crypto) !== null && _a !== void 0 ? _a : {};
+        if (!subtle) {
+            throw new hatchet_error_1.default('WebCrypto is not available in this runtime. Durable tasks need globalThis.crypto.subtle (Node 20 or newer).');
+        }
+        const data = new TextEncoder().encode(taskRunExternalId + JSON.stringify(args));
+        return new Uint8Array(yield subtle.digest('SHA-256', data));
+    });
 }

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

@@ -5,8 +5,11 @@
  * 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<{
+import type { DurableListenerClient } from '../../../../clients/listeners/durable-listener/durable-listener-client';
+/** The unary and streaming RPCs the pre-eviction fallback needs from the listener. */
+export type LegacyDurableTransport = Pick<DurableListenerClient, 'registerDurableEvent' | 'result'>;
+export declare function isLegacyDurableTransport(value: unknown): value is LegacyDurableTransport;
+export declare function waitForPreEviction(durableListener: LegacyDurableTransport, 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

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLegacyDurableTransport = isLegacyDurableTransport;
 exports.waitForPreEviction = waitForPreEviction;
 /**
  * Pre-eviction fallback for DurableContext.
@@ -19,6 +20,10 @@ exports.waitForPreEviction = waitForPreEviction;
 const conditions_1 = require("../../../conditions");
 const transformer_1 = require("../../../conditions/transformer");
 const condition_1 = require("../../../../protoc/v1/shared/condition");
+function isLegacyDurableTransport(value) {
+    const candidate = value;
+    return (typeof (candidate === null || candidate === void 0 ? void 0 : candidate.registerDurableEvent) === 'function' && typeof (candidate === null || candidate === void 0 ? void 0 : candidate.result) === 'function');
+}
 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);

package/v1/client/worker/runtime.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The seams between a task's `Context` / `DurableContext` and whatever runs the task.
+ *
+ * A worker process implements them over its `HatchetClient` and durable listener (see
+ * `worker-runtime.ts`); a serverless handler implements them over the operator's request
+ * and durable socket. Nothing in this module imports from Node, so the interfaces are
+ * usable from the edge entry point.
+ * @module Runtime
+ */
+import type { Logger, LogLevel } from '../../../util/logger';
+import type WorkflowRunRef from '../../../util/workflow-run-ref';
+import type { WorkerLabelComparator } from '../../../protoc/v1/shared/trigger';
+import type { Priority } from '../../declaration';
+import type { DurableTaskEventLogEntryResult, DurableTaskEventMemoAck, DurableTaskEventRunAck, DurableTaskEventWaitForAck, MemoEvent, RunChildrenEvent, WaitForEvent } from '../../../clients/listeners/durable-listener/durable-events';
+/** Labels a worker advertises for affinity-based assignment. */
+export type WorkerLabels = Record<string, string | number | undefined>;
+/** A worker label a spawned child run asks for. */
+export type DesiredWorkerLabel = {
+    value: string | number;
+    required?: boolean;
+    weight?: number;
+    comparator?: WorkerLabelComparator;
+};
+/**
+ * Options a context passes when it spawns a child run. Mirrors the options accepted by
+ * `AdminClient.runWorkflow`.
+ */
+export type SpawnRunOptions = {
+    parentId?: string | undefined;
+    parentTaskRunExternalId?: string | undefined;
+    /** @deprecated Use `parentTaskRunExternalId` instead. */
+    parentStepRunId?: string | undefined;
+    childIndex?: number | undefined;
+    childKey?: string | undefined;
+    /** Alias of `childKey` kept for the child run APIs on `Context`. */
+    key?: string | undefined;
+    additionalMetadata?: Record<string, string> | undefined;
+    desiredWorkerId?: string | undefined;
+    priority?: Priority;
+    sticky?: boolean;
+    returnExceptions?: boolean;
+    desiredWorkerLabels?: Record<string, DesiredWorkerLabel>;
+    _standaloneTaskName?: string | undefined;
+};
+export type SpawnRunRequest<Q = object> = {
+    workflowName: string;
+    input: Q;
+    options?: SpawnRunOptions;
+};
+/** Identifies every member of a batch task run when the whole batch is cancelled. */
+export type CancelBatchRequest = {
+    workerId: string;
+    jobId: string;
+    actionId: string;
+    batchId: string;
+    memberIds: string[];
+};
+/**
+ * Everything a `Context` needs from the process running the task: a logger factory,
+ * the namespace, the engine-facing operations, and the worker facts `ctx.worker` reports.
+ *
+ * Implementations that cannot honour an operation (for example a serverless runtime
+ * without a Hatchet client) throw from it; the context does not guard against that.
+ */
+export interface ContextRuntime {
+    /** The namespace applied to workflow names and event keys, if any. */
+    readonly namespace?: string;
+    /** Creates a logger for the given component, at the runtime's configured level. */
+    logger(name: string): Logger;
+    /** Cancels a single task run. */
+    cancelRun(taskRunExternalId: string): Promise<void>;
+    /** Cancels every member of a batch task run. */
+    cancelBatch(request: CancelBatchRequest): Promise<void>;
+    /** Writes a log line for a task run to the engine. */
+    putLog(taskRunExternalId: string, message: string, level: LogLevel | undefined, retryCount: number, extra?: Record<string, unknown>): Promise<void>;
+    /** Extends the execution timeout of a task run by `incrementBy` (Go duration string). */
+    refreshTimeout(taskRunExternalId: string, incrementBy: string): Promise<void>;
+    /** Releases the worker slot held by a task run. */
+    releaseSlot(taskRunExternalId: string): Promise<void>;
+    /** Streams a chunk of data from a task run. */
+    putStream(taskRunExternalId: string, data: string | Uint8Array, index: number): Promise<void>;
+    /** Spawns one run. */
+    runWorkflow<Q = object, P = object>(workflowName: string, input: Q, options?: SpawnRunOptions): Promise<WorkflowRunRef<P>>;
+    /** Spawns many runs in one call. */
+    runWorkflows<Q = object, P = object>(runs: SpawnRunRequest<Q>[]): Promise<WorkflowRunRef<P>[]>;
+    /** The id the engine assigned to the worker, once registered. */
+    workerId(): string | undefined;
+    /** Whether the worker serves the given workflow (used by sticky child runs). */
+    hasWorkflow(workflowName: string): boolean;
+    /** The worker's current labels. */
+    workerLabels(): WorkerLabels;
+    /** Replaces the worker's labels. */
+    upsertWorkerLabels(labels: WorkerLabels): Promise<WorkerLabels>;
+}
+/**
+ * The seam a `DurableContext` talks to for durable events: the worker implements it with
+ * `DurableListenerClient` over gRPC, a serverless handler with frames over a websocket.
+ */
+export interface DurableTransport {
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: RunChildrenEvent): Promise<DurableTaskEventRunAck>;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: WaitForEvent): Promise<DurableTaskEventWaitForAck>;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: MemoEvent): Promise<DurableTaskEventMemoAck>;
+    waitForCallback(durableTaskExternalId: string, invocationCount: number, branchId: number, nodeId: number, opts?: {
+        signal?: AbortSignal;
+    }): Promise<DurableTaskEventLogEntryResult>;
+    consumeCallbackWithoutBlocking(durableTaskExternalId: string, invocationCount: number, branchId: number, nodeId: number): void;
+    sendMemoCompletedNotification(durableTaskExternalId: string, nodeId: number, branchId: number, invocationCount: number, memoKey: Uint8Array, memoResultPayload?: Uint8Array): Promise<void>;
+    cleanupTaskState(durableTaskExternalId: string, invocationCount: number): void;
+    sendEvictInvocation(durableTaskExternalId: string, invocationCount: number, reason?: string): Promise<void>;
+}
+/**
+ * Options for constructing a `DurableContext` on top of a `ContextRuntime`.
+ */
+export interface DurableContextOptions {
+    /** The engine version the runtime is talking to; decides whether eviction is supported. */
+    engineVersion?: string;
+}
+export declare function isContextRuntime(value: unknown): value is ContextRuntime;

package/v1/client/worker/runtime.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContextRuntime = isContextRuntime;
+function isContextRuntime(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return typeof candidate.logger === 'function' && typeof candidate.workerId === 'function';
+}