@hatchet-dev/typescript-sdk 1.11.0 → 1.12.1

package/v1/client/worker/context.js

@@ -59,7 +59,7 @@ class Context {
     cancel() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.v1.runs.cancel({
-                ids: [this.action.stepRunId],
+                ids: [this.action.taskRunExternalId],
             });
             // optimistically abort the run
             this.controller.abort();
@@ -150,7 +150,7 @@ class Context {
      * @returns The name of the task.
      */
     taskName() {
-        return this.action.stepName;
+        return this.action.taskName;
     }
     /**
      * Gets the ID of the current workflow run.
@@ -177,8 +177,16 @@ class Context {
      * Gets the ID of the current task run.
      * @returns The task run ID.
      */
+    taskRunExternalId() {
+        return this.action.taskRunExternalId;
+    }
+    /**
+     * Gets the ID of the current task run.
+     * @returns The task run ID.
+     * @deprecated use taskRunExternalId() instead
+     */
     taskRunId() {
-        return this.action.stepRunId;
+        return this.taskRunExternalId();
     }
     /**
      * Gets the number of times the current task has been retried.
@@ -194,14 +202,14 @@ class Context {
      * @deprecated use ctx.logger.infoger.info, ctx.logger.infoger.debug, ctx.logger.infoger.warn, ctx.logger.infoger.error, ctx.logger.infoger.trace instead
      */
     log(message, level, extra) {
-        const { stepRunId } = this.action;
-        if (!stepRunId) {
+        const { taskRunExternalId } = this.action;
+        if (!taskRunExternalId) {
             // log a warning
             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 contextExtra = Object.assign({ workflowRunId: this.action.workflowRunId, taskRunId: this.action.stepRunId, retryCount: this.action.retryCount, workflowName: this.action.jobName }, extra === null || extra === void 0 ? void 0 : extra.extra);
+        const contextExtra = Object.assign({ workflowRunId: this.action.workflowRunId, taskRunExternalId: this.action.taskRunExternalId, retryCount: this.action.retryCount, workflowName: this.action.jobName }, extra === null || extra === void 0 ? void 0 : extra.extra);
         const promises = [];
         if (!level || level === 'INFO') {
             promises.push(logger.info(message, contextExtra));
@@ -216,7 +224,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(stepRunId, message, level, this.retryCount(), extra === null || extra === void 0 ? void 0 : extra.extra));
+        promises.push(this.v1.event.putLog(taskRunExternalId, message, level, this.retryCount(), extra === null || extra === void 0 ? void 0 : extra.extra));
         return Promise.all(promises);
     }
     get logger() {
@@ -249,13 +257,13 @@ class Context {
      */
     refreshTimeout(incrementBy) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { stepRunId } = this.action;
-            if (!stepRunId) {
+            const { taskRunExternalId } = this.action;
+            if (!taskRunExternalId) {
                 // log a warning
                 this._logger.warn('cannot refresh timeout from context without stepRunId');
                 return;
             }
-            yield this.v1._v0.dispatcher.refreshTimeout(incrementBy, stepRunId);
+            yield this.v1._v0.dispatcher.refreshTimeout(incrementBy, taskRunExternalId);
         });
     }
     /**
@@ -266,7 +274,7 @@ class Context {
     releaseSlot() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.v1._v0.dispatcher.client.releaseSlot({
-                stepRunId: this.action.stepRunId,
+                taskRunExternalId: this.action.taskRunExternalId,
             });
         });
     }
@@ -277,14 +285,14 @@ class Context {
      */
     putStream(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { stepRunId } = this.action;
-            if (!stepRunId) {
+            const { taskRunExternalId } = this.action;
+            if (!taskRunExternalId) {
                 // log a warning
                 this._logger.warn('cannot log from context without stepRunId');
                 return;
             }
             const index = this._incrementStreamIndex();
-            yield this.v1._v0.event.putStream(stepRunId, data, index);
+            yield this.v1._v0.event.putStream(taskRunExternalId, data, index);
         });
     }
     spawnOptions(workflow, options) {
@@ -300,8 +308,8 @@ class Context {
         if (sticky && !this.worker.hasWorkflow(workflowName)) {
             throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${workflowName} is not registered on the worker`);
         }
-        const { workflowRunId, stepRunId } = this.action;
-        const finalOpts = Object.assign(Object.assign({}, options), { parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, childKey: options === null || options === void 0 ? void 0 : options.key, desiredWorkerId: sticky ? this.worker.id() : undefined, _standaloneTaskName: workflow instanceof declaration_1.TaskWorkflowDeclaration ? workflow._standalone_task_name : undefined });
+        const { workflowRunId, taskRunExternalId } = this.action;
+        const finalOpts = Object.assign(Object.assign({}, options), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, childKey: options === null || options === void 0 ? void 0 : options.key, desiredWorkerId: sticky ? this.worker.id() : undefined, _standaloneTaskName: workflow instanceof declaration_1.TaskWorkflowDeclaration ? workflow._standalone_task_name : undefined });
         this.spawnIndex += 1;
         return { workflowName, opts: finalOpts };
     }
@@ -452,7 +460,7 @@ class Context {
      */
     spawnWorkflows(workflows) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { workflowRunId, stepRunId } = this.action;
+            const { workflowRunId, taskRunExternalId } = this.action;
             const workflowRuns = workflows.map(({ workflow, input, options }) => {
                 let workflowName;
                 if (typeof workflow === 'string') {
@@ -470,7 +478,7 @@ class Context {
                 const resp = {
                     workflowName: name,
                     input,
-                    options: Object.assign(Object.assign({}, opts), { parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }),
+                    options: Object.assign(Object.assign({}, opts), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }),
                 };
                 this.spawnIndex += 1;
                 return resp;
@@ -510,7 +518,7 @@ class Context {
      */
     spawnWorkflow(workflow, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { workflowRunId, stepRunId } = this.action;
+            const { workflowRunId, taskRunExternalId } = this.action;
             let workflowName = '';
             if (typeof workflow === 'string') {
                 workflowName = workflow;
@@ -525,7 +533,7 @@ class Context {
                 throw new hatchet_error_1.default(`cannot run with sticky: workflow ${name} is not registered on the worker`);
             }
             try {
-                const resp = yield this.v1._v0.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
+                const resp = yield this.v1._v0.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
                 this.spawnIndex += 1;
                 if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
                     resp._standaloneTaskName = workflow._standalone_task_name;
@@ -572,13 +580,13 @@ class DurableContext extends Context {
             // eslint-disable-next-line no-plusplus
             const key = `waitFor-${this.waitKey++}`;
             yield this.v1._v0.durableListener.registerDurableEvent({
-                taskId: this.action.stepRunId,
+                taskId: this.action.taskRunExternalId,
                 signalKey: key,
                 sleepConditions: pbConditions.sleepConditions,
                 userEventConditions: pbConditions.userEventConditions,
             });
             const listener = this.v1._v0.durableListener.subscribe({
-                taskId: this.action.stepRunId,
+                taskId: this.action.taskRunExternalId,
                 signalKey: key,
             });
             const event = yield listener.get();

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

@@ -0,0 +1,44 @@
+/**
+ * Generic time-aware deprecation helper.
+ *
+ * Timeline (from a given start date, with configurable windows):
+ *   0 to warnDays:              WARNING logged once per feature
+ *   warnDays to errorDays:      ERROR logged once per feature
+ *   after errorDays:            throws an error 1-in-5 calls (20% chance)
+ *
+ * Defaults: warnDays=90, errorDays=undefined (error phase disabled unless set).
+ */
+import { Logger } from '../../../../util/logger';
+export declare class DeprecationError extends Error {
+    feature: string;
+    constructor(feature: string, message: string);
+}
+export interface DeprecationOpts {
+    /** Days after start during which a warning is logged. Defaults to 90. */
+    warnDays?: number;
+    /** Days after start during which an error is logged.
+     *  After this window, calls have a 20% chance of throwing.
+     *  If undefined (default), the error/raise phase is never reached —
+     *  the notice stays at error-level logging indefinitely. */
+    errorDays?: number;
+}
+/**
+ * Emit a time-aware deprecation notice.
+ *
+ * @param feature - A short identifier for deduplication (each feature logs once).
+ * @param message - The human-readable deprecation message.
+ * @param start   - The Date when the deprecation window began.
+ * @param logger  - A Logger instance for outputting warnings/errors.
+ * @param opts    - Optional configuration for time windows.
+ * @throws DeprecationError after the errorDays window (~20% chance).
+ */
+/**
+ * Parses a semver string like "v0.78.23" into [major, minor, patch].
+ * Returns [0, 0, 0] if parsing fails.
+ */
+export declare function parseSemver(v: string): [number, number, number];
+/**
+ * Returns true if semver string a is strictly less than b.
+ */
+export declare function semverLessThan(a: string, b: string): boolean;
+export declare function emitDeprecationNotice(feature: string, message: string, start: Date, logger: Logger, opts?: DeprecationOpts): void;

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

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Generic time-aware deprecation helper.
+ *
+ * Timeline (from a given start date, with configurable windows):
+ *   0 to warnDays:              WARNING logged once per feature
+ *   warnDays to errorDays:      ERROR logged once per feature
+ *   after errorDays:            throws an error 1-in-5 calls (20% chance)
+ *
+ * Defaults: warnDays=90, errorDays=undefined (error phase disabled unless set).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeprecationError = void 0;
+exports.parseSemver = parseSemver;
+exports.semverLessThan = semverLessThan;
+exports.emitDeprecationNotice = emitDeprecationNotice;
+const DEFAULT_WARN_DAYS = 90;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/** Tracks which features have already been logged (keyed by feature name). */
+const alreadyLogged = new Set();
+class DeprecationError extends Error {
+    constructor(feature, message) {
+        super(`${feature}: ${message}`);
+        this.name = 'DeprecationError';
+        this.feature = feature;
+    }
+}
+exports.DeprecationError = DeprecationError;
+/**
+ * Emit a time-aware deprecation notice.
+ *
+ * @param feature - A short identifier for deduplication (each feature logs once).
+ * @param message - The human-readable deprecation message.
+ * @param start   - The Date when the deprecation window began.
+ * @param logger  - A Logger instance for outputting warnings/errors.
+ * @param opts    - Optional configuration for time windows.
+ * @throws DeprecationError after the errorDays window (~20% chance).
+ */
+/**
+ * Parses a semver string like "v0.78.23" into [major, minor, patch].
+ * Returns [0, 0, 0] if parsing fails.
+ */
+function parseSemver(v) {
+    let s = v.startsWith('v') ? v.slice(1) : v;
+    const dashIdx = s.indexOf('-');
+    if (dashIdx !== -1)
+        s = s.slice(0, dashIdx);
+    const parts = s.split('.');
+    if (parts.length !== 3)
+        return [0, 0, 0];
+    return [parseInt(parts[0], 10) || 0, parseInt(parts[1], 10) || 0, parseInt(parts[2], 10) || 0];
+}
+/**
+ * Returns true if semver string a is strictly less than b.
+ */
+function semverLessThan(a, b) {
+    const [aMaj, aMin, aPat] = parseSemver(a);
+    const [bMaj, bMin, bPat] = parseSemver(b);
+    if (aMaj !== bMaj)
+        return aMaj < bMaj;
+    if (aMin !== bMin)
+        return aMin < bMin;
+    return aPat < bPat;
+}
+function emitDeprecationNotice(feature, message, start, logger, opts) {
+    var _a;
+    const warnMs = ((_a = opts === null || opts === void 0 ? void 0 : opts.warnDays) !== null && _a !== void 0 ? _a : DEFAULT_WARN_DAYS) * MS_PER_DAY;
+    const errorDays = opts === null || opts === void 0 ? void 0 : opts.errorDays;
+    const errorMs = errorDays != null ? errorDays * MS_PER_DAY : undefined;
+    const elapsed = Date.now() - start.getTime();
+    if (elapsed < warnMs) {
+        // Phase 1: warning
+        if (!alreadyLogged.has(feature)) {
+            logger.warn(message);
+            alreadyLogged.add(feature);
+        }
+    }
+    else if (errorMs === undefined || elapsed < errorMs) {
+        // Phase 2: error-level log (indefinite when errorDays is not set)
+        if (!alreadyLogged.has(feature)) {
+            logger.error(`${message} This fallback will be removed soon. Upgrade immediately.`);
+            alreadyLogged.add(feature);
+        }
+    }
+    else {
+        // Phase 3: throw 1-in-5 times
+        if (!alreadyLogged.has(feature)) {
+            logger.error(`${message} This fallback is no longer supported and will fail intermittently.`);
+            alreadyLogged.add(feature);
+        }
+        if (Math.random() < 0.2) {
+            throw new DeprecationError(feature, message);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+export { isLegacyEngine, 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

@@ -0,0 +1,15 @@
+"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;
+var legacy_worker_1 = require("./legacy-worker");
+Object.defineProperty(exports, "isLegacyEngine", { enumerable: true, get: function () { return legacy_worker_1.isLegacyEngine; } });
+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; } });
+var legacy_registration_1 = require("./legacy-registration");
+Object.defineProperty(exports, "legacyGetActionListener", { enumerable: true, get: function () { return legacy_registration_1.legacyGetActionListener; } });
+var deprecation_1 = require("./deprecation");
+Object.defineProperty(exports, "emitDeprecationNotice", { enumerable: true, get: function () { return deprecation_1.emitDeprecationNotice; } });
+Object.defineProperty(exports, "DeprecationError", { enumerable: true, get: function () { return deprecation_1.DeprecationError; } });
+Object.defineProperty(exports, "parseSemver", { enumerable: true, get: function () { return deprecation_1.parseSemver; } });
+Object.defineProperty(exports, "semverLessThan", { enumerable: true, get: function () { return deprecation_1.semverLessThan; } });

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

@@ -0,0 +1,18 @@
+/**
+ * Legacy worker registration using the deprecated `slots` proto field
+ * instead of `slotConfig`. For backward compatibility with engines
+ * that do not support multiple slot types.
+ */
+import { DispatcherClient, WorkerLabels } from '../../../../clients/dispatcher/dispatcher-client';
+import { ActionListener } from '../../../../clients/dispatcher/action-listener';
+export interface LegacyRegistrationOptions {
+    workerName: string;
+    services: string[];
+    actions: string[];
+    slots: number;
+    labels: WorkerLabels;
+}
+/**
+ * Registers a worker using the legacy `slots` proto field instead of `slotConfig`.
+ */
+export declare function legacyGetActionListener(dispatcher: DispatcherClient, options: LegacyRegistrationOptions): Promise<ActionListener>;

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

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Legacy worker registration using the deprecated `slots` proto field
+ * instead of `slotConfig`. For backward compatibility with engines
+ * that do not support multiple slot types.
+ */
+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.legacyGetActionListener = legacyGetActionListener;
+const dispatcher_client_1 = require("../../../../clients/dispatcher/dispatcher-client");
+const action_listener_1 = require("../../../../clients/dispatcher/action-listener");
+/**
+ * Registers a worker using the legacy `slots` proto field instead of `slotConfig`.
+ */
+function legacyGetActionListener(dispatcher, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const registration = yield dispatcher.client.register({
+            workerName: options.workerName,
+            services: options.services,
+            actions: options.actions,
+            slots: options.slots,
+            labels: options.labels ? (0, dispatcher_client_1.mapLabels)(options.labels) : undefined,
+            runtimeInfo: dispatcher.getRuntimeInfo(),
+        });
+        return new action_listener_1.ActionListener(dispatcher, registration.workerId);
+    });
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Legacy V1Worker subclass that registers with the old `slots` proto field
+ * instead of `slotConfig`. Used when connected to pre-slot-config engines.
+ */
+import { ActionListener } from '../../../../clients/dispatcher/action-listener';
+import { HatchetClient } from '../../..';
+import { V1Worker } from '../worker-internal';
+export declare class LegacyV1Worker extends V1Worker {
+    private _legacySlotCount;
+    constructor(client: HatchetClient, options: ConstructorParameters<typeof V1Worker>[1], legacySlots: number);
+    /**
+     * Override registration to use the legacy `slots` proto field.
+     */
+    protected createListener(): Promise<ActionListener>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Legacy V1Worker subclass that registers with the old `slots` proto field
+ * instead of `slotConfig`. Used when connected to pre-slot-config engines.
+ */
+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.LegacyV1Worker = void 0;
+const worker_internal_1 = require("../worker-internal");
+const legacy_registration_1 = require("./legacy-registration");
+class LegacyV1Worker extends worker_internal_1.V1Worker {
+    constructor(client, options, legacySlots) {
+        super(client, options);
+        this._legacySlotCount = legacySlots;
+    }
+    /**
+     * Override registration to use the legacy `slots` proto field.
+     */
+    createListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, legacy_registration_1.legacyGetActionListener)(this.client._v0.dispatcher, {
+                workerName: this.name,
+                services: ['default'],
+                actions: Object.keys(this.action_registry),
+                slots: this._legacySlotCount,
+                labels: this.labels,
+            });
+        });
+    }
+}
+exports.LegacyV1Worker = LegacyV1Worker;

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

@@ -0,0 +1,41 @@
+/**
+ * Legacy dual-worker implementation for pre-slot-config engines.
+ *
+ * When connected to an older Hatchet engine that does not support multiple slot types,
+ * this module provides the old worker start flow which creates separate durable and
+ * non-durable workers, each registered with the legacy `slots` proto field.
+ */
+import { HatchetClient } from '../../..';
+import { CreateWorkerOpts } from '../worker';
+import { LegacyV1Worker } from './legacy-v1-worker';
+/**
+ * Checks if the connected engine is legacy by comparing its semantic version
+ * against the minimum required version for slot_config support.
+ * Returns true if the engine is legacy, false otherwise.
+ * Emits a time-aware deprecation notice when a legacy engine is detected.
+ */
+export declare function isLegacyEngine(v1: HatchetClient): Promise<boolean>;
+/**
+ * LegacyDualWorker manages two V1Worker instances (nonDurable + durable)
+ * for engines that don't support slot_config.
+ * Uses the legacy `slots` proto field (maxRuns) instead of `slotConfig`.
+ */
+export declare class LegacyDualWorker {
+    private nonDurable;
+    private durable;
+    private name;
+    constructor(name: string, nonDurable: LegacyV1Worker, durable?: LegacyV1Worker);
+    /**
+     * Creates a legacy dual-worker setup from the given options.
+     * Workers are created with legacy registration (old `slots` proto field).
+     */
+    static create(v1: HatchetClient, name: string, options: CreateWorkerOpts): Promise<LegacyDualWorker>;
+    /**
+     * Starts both workers using Promise.all.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops both workers.
+     */
+    stop(): Promise<void>;
+}

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

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Legacy dual-worker implementation for pre-slot-config engines.
+ *
+ * When connected to an older Hatchet engine that does not support multiple slot types,
+ * this module provides the old worker start flow which creates separate durable and
+ * non-durable workers, each registered with the legacy `slots` proto field.
+ */
+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.LegacyDualWorker = void 0;
+exports.isLegacyEngine = isLegacyEngine;
+const nice_grpc_1 = require("nice-grpc");
+const declaration_1 = require("../../../declaration");
+const legacy_v1_worker_1 = require("./legacy-v1-worker");
+const deprecation_1 = require("./deprecation");
+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.';
+/**
+ * Checks if the connected engine is legacy by comparing its semantic version
+ * against the minimum required version for slot_config support.
+ * Returns true if the engine is legacy, false otherwise.
+ * Emits a time-aware deprecation notice when a legacy engine is detected.
+ */
+function isLegacyEngine(v1) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const version = yield v1._v0.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._v0.config.logger('Worker', v1._v0.config.log_level);
+                (0, deprecation_1.emitDeprecationNotice)('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
+                    errorDays: 180,
+                });
+                return true;
+            }
+            return false;
+        }
+        catch (e) {
+            if ((e === null || e === void 0 ? void 0 : e.code) === nice_grpc_1.Status.UNIMPLEMENTED) {
+                const logger = v1._v0.config.logger('Worker', v1._v0.config.log_level);
+                (0, deprecation_1.emitDeprecationNotice)('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
+                    errorDays: 180,
+                });
+                return true;
+            }
+            // For other errors, assume new engine and let registration fail naturally
+            return false;
+        }
+    });
+}
+/**
+ * LegacyDualWorker manages two V1Worker instances (nonDurable + durable)
+ * for engines that don't support slot_config.
+ * Uses the legacy `slots` proto field (maxRuns) instead of `slotConfig`.
+ */
+class LegacyDualWorker {
+    constructor(name, nonDurable, durable) {
+        this.name = name;
+        this.nonDurable = nonDurable;
+        this.durable = durable;
+    }
+    /**
+     * Creates a legacy dual-worker setup from the given options.
+     * Workers are created with legacy registration (old `slots` proto field).
+     */
+    static create(v1, name, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultSlots = options.slots || options.maxRuns || DEFAULT_DEFAULT_SLOTS;
+            const durableSlots = options.durableSlots || DEFAULT_DURABLE_SLOTS;
+            // Create the non-durable worker with legacy registration
+            const nonDurable = new legacy_v1_worker_1.LegacyV1Worker(v1, { name, labels: options.labels, handleKill: options.handleKill }, defaultSlots);
+            // Check if any workflows have durable tasks
+            let hasDurableTasks = false;
+            for (const wf of options.workflows || []) {
+                if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
+                    if (wf.definition._durableTasks.length > 0) {
+                        hasDurableTasks = true;
+                        break;
+                    }
+                }
+            }
+            let durableWorker;
+            if (hasDurableTasks) {
+                // Create the durable worker with legacy registration
+                durableWorker = new legacy_v1_worker_1.LegacyV1Worker(v1, { name: `${name}-durable`, labels: options.labels, handleKill: options.handleKill }, durableSlots);
+            }
+            const legacyWorker = new LegacyDualWorker(name, nonDurable, durableWorker);
+            // Register workflows on appropriate workers
+            for (const wf of options.workflows || []) {
+                if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
+                    if (wf.definition._durableTasks.length > 0 && durableWorker) {
+                        yield durableWorker.registerWorkflowV1(wf);
+                        durableWorker.registerDurableActionsV1(wf.definition);
+                    }
+                    else {
+                        yield nonDurable.registerWorkflowV1(wf);
+                    }
+                }
+                else {
+                    // fallback to v0 client for backwards compatibility
+                    yield nonDurable.registerWorkflow(wf);
+                }
+            }
+            return legacyWorker;
+        });
+    }
+    /**
+     * Starts both workers using Promise.all.
+     */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [this.nonDurable.start()];
+            if (this.durable) {
+                promises.push(this.durable.start());
+            }
+            yield Promise.all(promises);
+        });
+    }
+    /**
+     * Stops both workers.
+     */
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [this.nonDurable.stop()];
+            if (this.durable) {
+                promises.push(this.durable.stop());
+            }
+            yield Promise.all(promises);
+        });
+    }
+}
+exports.LegacyDualWorker = LegacyDualWorker;

package/v1/client/worker/slot-utils.d.ts

@@ -0,0 +1,21 @@
+import { Workflow as V0Workflow } from '../../../workflow';
+import { BaseWorkflowDeclaration } from '../../declaration';
+import { SlotConfig } from '../../slot-types';
+export interface WorkerSlotOptions {
+    /** (optional) Maximum number of concurrent runs on this worker, defaults to 100 */
+    slots?: number;
+    /** (optional) Maximum number of concurrent durable tasks, defaults to 1,000 */
+    durableSlots?: number;
+    /** (optional) Array of workflows to register */
+    workflows?: BaseWorkflowDeclaration<any, any>[] | V0Workflow[];
+    /** @deprecated Use slots instead */
+    maxRuns?: number;
+}
+export declare function resolveWorkerOptions<T extends WorkerSlotOptions>(options: T): T & {
+    slots?: number;
+    durableSlots?: number;
+    slotConfig: SlotConfig;
+};
+export declare const testingExports: {
+    resolveWorkerOptions: typeof resolveWorkerOptions;
+};