@hatchet-dev/typescript-sdk 1.15.2 → 1.17.0

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

@@ -8,23 +8,29 @@
  * @module Context
  */
 import { Priority, RunOpts, TaskWorkflowDeclaration, BaseWorkflowDeclaration as WorkflowV1 } from '../../declaration';
-import { JsonObject } from '@bufbuild/protobuf';
 import { Action } from '../../../clients/dispatcher/action-listener';
 import { Logger, LogLevel } from '../../../util/logger';
 import WorkflowRunRef from '../../../util/workflow-run-ref';
 import { Conditions } from '../../conditions';
 import { CreateWorkflowDurableTaskOpts, CreateWorkflowTaskOpts } from '../../task';
-import { OutputType } from '../../types';
+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 { z } from 'zod';
 import { InternalWorker } from './worker-internal';
 import { Duration } from '../duration';
+import { DurableEvictionManager } from './eviction/eviction-manager';
 type TriggerData = Record<string, Record<string, any>>;
 type ChildRunOpts = RunOpts & {
     key?: string;
     sticky?: boolean;
 };
+export interface SleepResult {
+    /** The sleep duration in milliseconds. */
+    durationMs: number;
+}
 type LogExtra = {
     extra?: any;
     error?: Error;
@@ -207,7 +213,30 @@ export declare class Context<T, K = {}> {
      * @returns A promise that resolves when the data has been streamed.
      */
     putStream(data: string | Uint8Array): Promise<void>;
-    private spawnOptions;
+    protected spawnOptions(workflow: string | WorkflowV1<any, any>, options?: ChildRunOpts): {
+        workflowName: string;
+        opts: {
+            parentId: string;
+            parentTaskRunExternalId: string;
+            childIndex: number;
+            childKey: string | undefined;
+            desiredWorkerId: string | undefined;
+            _standaloneTaskName: string | undefined;
+            additionalMetadata?: {
+                [x: string]: string;
+            };
+            priority?: Priority;
+            sticky?: boolean;
+            returnExceptions?: boolean;
+            desiredWorkerLabels?: Record<string, {
+                value: string | number;
+                required?: boolean;
+                weight?: number;
+                comparator?: import("../..").WorkerLabelComparator;
+            }>;
+            key?: string;
+        };
+    };
     private spawn;
     private spawnBulk;
     /**
@@ -323,14 +352,26 @@ export declare class Context<T, K = {}> {
  * It extends the Context class and includes additional methods for durable execution like sleepFor and waitFor.
  */
 export declare class DurableContext<T, K = {}> extends Context<T, K> {
-    waitKey: number;
+    private _durableListener;
+    private _evictionManager;
+    private _engineVersion;
+    private _waitKey;
+    constructor(action: Action, v1: HatchetClient, worker: InternalWorker, durableListener: DurableListenerClient, evictionManager?: DurableEvictionManager, engineVersion?: string);
+    get supportsEviction(): boolean;
+    get durableListener(): DurableListenerClient;
+    /**
+     * The invocation count for the current durable task. Used for deduplication across replays.
+     */
+    get invocationCount(): number;
+    private get _actionKey();
+    private withEvictionWait;
     /**
      * 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: Duration, readableDataKey?: string): Promise<Record<string, any>>;
+    sleepFor(duration: Duration, readableDataKey?: string): Promise<SleepResult>;
     /**
      * Pauses execution until the specified conditions are met.
      * Conditions are "global" meaning they will wait in real time regardless of transient failures like worker restarts.
@@ -338,5 +379,59 @@ export declare class DurableContext<T, K = {}> extends Context<T, K> {
      * @returns A promise that resolves with the event that satisfied the conditions.
      */
     waitFor(conditions: Conditions | Conditions[]): Promise<Record<string, any>>;
+    /**
+     * Lightweight wrapper for waiting for a user event. Allows for shorthand usage of
+     * `ctx.waitFor` when specifying a user event condition.
+     *
+     * For more complicated conditions, use `ctx.waitFor` directly.
+     *
+     * @param key - The event key to wait for.
+     * @param expression - An optional CEL expression to filter events.
+     * @param payloadSchema - An optional Zod schema to validate and parse the event payload.
+     * @returns The event payload, validated against the schema if provided.
+     */
+    waitForEvent<T extends z.ZodTypeAny>(key: string, expression?: string, payloadSchema?: T): Promise<z.infer<T>>;
+    waitForEvent(key: string, expression?: string): Promise<Record<string, any>>;
+    /**
+     * 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: Date): Promise<SleepResult>;
+    /**
+     * 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(): Promise<Date>;
+    private _waitForPreEviction;
+    private _buildTriggerOpts;
+    /**
+     * 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<Q extends JsonObject, P extends OutputType>(workflow: string | WorkflowV1<Q, P> | TaskWorkflowDeclaration<Q, P>, input?: Q, options?: ChildRunOpts): Promise<P>;
+    /**
+     * 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<Q extends JsonObject, P extends OutputType>(children: Array<{
+        workflow: string | WorkflowV1<Q, P> | TaskWorkflowDeclaration<Q, P>;
+        input: Q;
+        options?: ChildRunOpts;
+    }>): Promise<P[]>;
+    /**
+     * 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.
+     */
+    private memo;
 }
 export {};

package/v1/client/worker/context.js

@@ -1,4 +1,13 @@
 "use strict";
+/**
+ * The Hatchet Context class provides helper methods and useful data to tasks at runtime. It is passed as the second argument to all tasks and durable tasks.
+ *
+ * There are two types of context classes you'll encounter:
+ *
+ * - Context - The standard context for regular tasks with methods for logging, task output retrieval, cancellation, and more.
+ * - DurableContext - An extended context for durable tasks that includes additional methods for durable execution.
+ * @module Context
+ */
 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) {
@@ -13,17 +22,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DurableContext = exports.Context = exports.ContextWorker = void 0;
-/**
- * The Hatchet Context class provides helper methods and useful data to tasks at runtime. It is passed as the second argument to all tasks and durable tasks.
- *
- * There are two types of context classes you'll encounter:
- *
- * - Context - The standard context for regular tasks with methods for logging, task output retrieval, cancellation, and more.
- * - DurableContext - An extended context for durable tasks that includes additional methods for durable execution.
- * @module Context
- */
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable max-classes-per-file */
 const declaration_1 = require("../../declaration");
 const hatchet_error_1 = __importDefault(require("../../../util/errors/hatchet-error"));
 const parse_1 = require("../../../util/parse");
@@ -32,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.
  */
@@ -330,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);
         });
     }
     /**
@@ -402,7 +404,6 @@ class Context {
         return __awaiter(this, void 0, void 0, function* () {
             const refs = yield this.spawnBulk(children);
             refs.forEach((ref) => {
-                // eslint-disable-next-line no-param-reassign
                 ref.defaultSignal = this.abortController.signal;
             });
             return refs;
@@ -431,7 +432,6 @@ class Context {
         return __awaiter(this, void 0, void 0, function* () {
             const run = yield this.spawn(workflow, input, options);
             // Ensure waiting for the child result aborts when this task is cancelled.
-            // eslint-disable-next-line no-param-reassign
             run.defaultSignal = this.abortController.signal;
             return run.output;
         });
@@ -560,7 +560,6 @@ class Context {
                 }
                 // `signal` must never be sent over the wire.
                 const optsWithoutSignal = Object.assign({}, opts);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 delete optsWithoutSignal.signal;
                 const resp = {
                     workflowName: name,
@@ -582,7 +581,6 @@ class Context {
                 resp.forEach((ref, index) => {
                     const wf = workflows[index].workflow;
                     if (wf instanceof declaration_1.TaskWorkflowDeclaration) {
-                        // eslint-disable-next-line no-param-reassign
                         ref._standaloneTaskName = wf._standalone_task_name;
                     }
                     res.push(ref);
@@ -608,13 +606,7 @@ class Context {
         return __awaiter(this, void 0, void 0, function* () {
             this.throwIfCancelled();
             const { workflowRunId, taskRunExternalId } = this.action;
-            let workflowName = '';
-            if (typeof workflow === 'string') {
-                workflowName = workflow;
-            }
-            else {
-                workflowName = workflow.name;
-            }
+            const workflowName = typeof workflow === 'string' ? workflow : workflow.name;
             const name = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace).toLowerCase();
             const opts = options || {};
             const { sticky } = opts;
@@ -646,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) };
         });
     }
     /**
@@ -670,24 +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);
-            // eslint-disable-next-line no-plusplus
-            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 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 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 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/deprecation.js

@@ -43,11 +43,13 @@ exports.DeprecationError = DeprecationError;
 function parseSemver(v) {
     let s = v.startsWith('v') ? v.slice(1) : v;
     const dashIdx = s.indexOf('-');
-    if (dashIdx !== -1)
+    if (dashIdx !== -1) {
         s = s.slice(0, dashIdx);
+    }
     const parts = s.split('.');
-    if (parts.length !== 3)
+    if (parts.length !== 3) {
         return [0, 0, 0];
+    }
     return [parseInt(parts[0], 10) || 0, parseInt(parts[1], 10) || 0, parseInt(parts[2], 10) || 0];
 }
 /**
@@ -56,10 +58,12 @@ function parseSemver(v) {
 function semverLessThan(a, b) {
     const [aMaj, aMin, aPat] = parseSemver(a);
     const [bMaj, bMin, bPat] = parseSemver(b);
-    if (aMaj !== bMaj)
+    if (aMaj !== bMaj) {
         return aMaj < bMaj;
-    if (aMin !== bMin)
+    }
+    if (aMin !== bMin) {
         return aMin < bMin;
+    }
     return aPat < bPat;
 }
 function emitDeprecationNotice(feature, message, start, logger, opts) {

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.