@hatchet-dev/typescript-sdk 1.12.0 → 1.13.0

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;
+};

package/v1/client/worker/slot-utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testingExports = void 0;
+exports.resolveWorkerOptions = resolveWorkerOptions;
+const declaration_1 = require("../../declaration");
+const slot_types_1 = require("../../slot-types");
+const DEFAULT_DEFAULT_SLOTS = 100;
+const DEFAULT_DURABLE_SLOTS = 1000;
+function resolveWorkerOptions(options) {
+    const requiredSlotTypes = options.workflows
+        ? getRequiredSlotTypes(options.workflows)
+        : new Set();
+    const slotConfig = options.slots || options.durableSlots || options.maxRuns
+        ? Object.assign(Object.assign({}, (options.slots || options.maxRuns
+            ? { [slot_types_1.SlotType.Default]: options.slots || options.maxRuns || 0 }
+            : {})), (options.durableSlots ? { [slot_types_1.SlotType.Durable]: options.durableSlots } : {})) : {};
+    if (requiredSlotTypes.has(slot_types_1.SlotType.Default) && slotConfig[slot_types_1.SlotType.Default] == null) {
+        slotConfig[slot_types_1.SlotType.Default] = DEFAULT_DEFAULT_SLOTS;
+    }
+    if (requiredSlotTypes.has(slot_types_1.SlotType.Durable) && slotConfig[slot_types_1.SlotType.Durable] == null) {
+        slotConfig[slot_types_1.SlotType.Durable] = DEFAULT_DURABLE_SLOTS;
+    }
+    if (Object.keys(slotConfig).length === 0) {
+        slotConfig[slot_types_1.SlotType.Default] = DEFAULT_DEFAULT_SLOTS;
+    }
+    return Object.assign(Object.assign({}, options), { slots: options.slots ||
+            options.maxRuns ||
+            (slotConfig[slot_types_1.SlotType.Default] != null ? slotConfig[slot_types_1.SlotType.Default] : undefined), durableSlots: options.durableSlots ||
+            (slotConfig[slot_types_1.SlotType.Durable] != null ? slotConfig[slot_types_1.SlotType.Durable] : undefined), slotConfig });
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+exports.testingExports = {
+    resolveWorkerOptions,
+};
+function getRequiredSlotTypes(workflows) {
+    const required = new Set();
+    const addFromRequests = (requests, fallbackType) => {
+        if (requests && Object.keys(requests).length > 0) {
+            if (requests[slot_types_1.SlotType.Default] !== undefined) {
+                required.add(slot_types_1.SlotType.Default);
+            }
+            if (requests[slot_types_1.SlotType.Durable] !== undefined) {
+                required.add(slot_types_1.SlotType.Durable);
+            }
+        }
+        else {
+            required.add(fallbackType);
+        }
+    };
+    for (const wf of workflows) {
+        if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
+            // eslint-disable-next-line dot-notation
+            const tasks = wf.definition['_tasks'];
+            for (const task of tasks) {
+                addFromRequests(task.slotRequests, slot_types_1.SlotType.Default);
+            }
+            // eslint-disable-next-line dot-notation
+            const durableTasks = wf.definition['_durableTasks'];
+            if (durableTasks.length > 0) {
+                required.add(slot_types_1.SlotType.Durable);
+            }
+            if (wf.definition.onFailure) {
+                const opts = typeof wf.definition.onFailure === 'object' ? wf.definition.onFailure : undefined;
+                addFromRequests(opts === null || opts === void 0 ? void 0 : opts.slotRequests, slot_types_1.SlotType.Default);
+            }
+            if (wf.definition.onSuccess) {
+                const opts = typeof wf.definition.onSuccess === 'object' ? wf.definition.onSuccess : undefined;
+                addFromRequests(opts === null || opts === void 0 ? void 0 : opts.slotRequests, slot_types_1.SlotType.Default);
+            }
+        }
+    }
+    return required;
+}

package/v1/client/worker/worker-internal.d.ts

@@ -8,11 +8,13 @@ import { BaseWorkflowDeclaration, WorkflowDefinition, HatchetClient } from '../.
 import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
 import { StepRunFunction } from '../../../step';
 import { Context } from './context';
+import { SlotConfig } from '../../slot-types';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export interface WorkerOpts {
     name: string;
     handleKill?: boolean;
-    maxRuns?: number;
+    slots?: number;
+    durableSlots?: number;
     labels?: WorkerLabels;
     healthPort?: number;
     enableHealthServer?: boolean;
@@ -28,7 +30,9 @@ export declare class V1Worker {
     listener: ActionListener | undefined;
     futures: Record<Action['taskRunExternalId'], HatchetPromise<any>>;
     contexts: Record<Action['taskRunExternalId'], Context<any, any>>;
-    maxRuns?: number;
+    slots?: number;
+    durableSlots?: number;
+    slotConfig: SlotConfig;
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;
     labels: WorkerLabels;
@@ -39,7 +43,9 @@ export declare class V1Worker {
     constructor(client: HatchetClient, options: {
         name: string;
         handleKill?: boolean;
-        maxRuns?: number;
+        slots?: number;
+        durableSlots?: number;
+        slotConfig?: SlotConfig;
         labels?: WorkerLabels;
     });
     private initializeHealthServer;
@@ -66,6 +72,11 @@ export declare class V1Worker {
     handleCancelStepRun(action: Action): Promise<void>;
     stop(): Promise<void>;
     exitGracefully(handleKill: boolean): Promise<void>;
+    /**
+     * Creates an action listener by registering the worker with the dispatcher.
+     * Override in subclasses to change registration behavior (e.g. legacy engines).
+     */
+    protected createListener(): Promise<ActionListener>;
     start(): Promise<void>;
     handleAction(action: Action): Promise<void>;
     upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;

package/v1/client/worker/worker-internal.js

@@ -46,7 +46,9 @@ class V1Worker {
         this.client = client;
         this.name = (0, apply_namespace_1.applyNamespace)(options.name, this.client.config.namespace);
         this.action_registry = {};
-        this.maxRuns = options.maxRuns;
+        this.slots = options.slots;
+        this.durableSlots = options.durableSlots;
+        this.slotConfig = options.slotConfig || {};
         this.labels = options.labels || {};
         this.enableHealthServer = (_b = (_a = client.config.healthcheck) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : false;
         this.healthPort = (_d = (_c = client.config.healthcheck) === null || _c === void 0 ? void 0 : _c.port) !== null && _d !== void 0 ? _d : 8001;
@@ -67,11 +69,10 @@ class V1Worker {
         this.healthServer = new health_server_1.HealthServer(this.healthPort, () => this.status, this.name, () => this.getAvailableSlots(), () => this.getRegisteredActions(), () => this.getFilteredLabels(), this.logger);
     }
     getAvailableSlots() {
-        if (!this.maxRuns) {
-            return 0;
-        }
+        // sum all the slots in the slot config
+        const totalSlots = Object.values(this.slotConfig).reduce((acc, curr) => acc + curr, 0);
         const currentRuns = Object.keys(this.futures).length;
-        return Math.max(0, this.maxRuns - currentRuns);
+        return Math.max(0, totalSlots - currentRuns);
     }
     getRegisteredActions() {
         return Object.keys(this.action_registry);
@@ -177,6 +178,8 @@ class V1Worker {
                         rateLimits: [],
                         workerLabels: {},
                         concurrency: [],
+                        isDurable: false,
+                        slotRequests: { default: 1 },
                     };
                 }
                 if (workflow.onFailure && typeof workflow.onFailure === 'object') {
@@ -194,6 +197,8 @@ class V1Worker {
                         concurrency: [],
                         backoffFactor: ((_f = onFailure.backoff) === null || _f === void 0 ? void 0 : _f.factor) || ((_h = (_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.backoff) === null || _h === void 0 ? void 0 : _h.factor),
                         backoffMaxSeconds: ((_j = onFailure.backoff) === null || _j === void 0 ? void 0 : _j.maxSeconds) || ((_l = (_k = workflow.taskDefaults) === null || _k === void 0 ? void 0 : _k.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds),
+                        isDurable: false,
+                        slotRequests: { default: 1 },
                     };
                 }
                 let onSuccessTask;
@@ -252,6 +257,7 @@ class V1Worker {
                     const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(workflow.inputValidator);
                     inputJsonSchema = new TextEncoder().encode(JSON.stringify(jsonSchema));
                 }
+                const durableTaskSet = new Set(workflow._durableTasks);
                 const registeredWorkflow = this.client._v0.admin.putWorkflowV1({
                     name: workflow.name,
                     description: workflow.description || '',
@@ -282,6 +288,8 @@ class V1Worker {
                             backoffFactor: ((_h = task.backoff) === null || _h === void 0 ? void 0 : _h.factor) || ((_k = (_j = workflow.taskDefaults) === null || _j === void 0 ? void 0 : _j.backoff) === null || _k === void 0 ? void 0 : _k.factor),
                             backoffMaxSeconds: ((_l = task.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds) || ((_o = (_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.backoff) === null || _o === void 0 ? void 0 : _o.maxSeconds),
                             conditions: (0, transformer_1.taskConditionsToPb)(task),
+                            isDurable: durableTaskSet.has(task),
+                            slotRequests: task.slotRequests || (durableTaskSet.has(task) ? { durable: 1 } : { default: 1 }),
                             concurrency: task.concurrency
                                 ? Array.isArray(task.concurrency)
                                     ? task.concurrency
@@ -416,7 +424,30 @@ class V1Worker {
                         childIndex: 0,
                         desiredWorkerId: this.workerId || '',
                     });
-                    return step(context);
+                    const { middleware } = this.client.config;
+                    if (middleware === null || middleware === void 0 ? void 0 : middleware.before) {
+                        const hooks = Array.isArray(middleware.before) ? middleware.before : [middleware.before];
+                        for (const hook of hooks) {
+                            const returned = yield hook(context.input, context);
+                            if (returned !== undefined) {
+                                context.input = returned;
+                                if (context.data && typeof context.data === 'object') {
+                                    context.data.input = returned;
+                                }
+                            }
+                        }
+                    }
+                    let result = yield step(context);
+                    if (middleware === null || middleware === void 0 ? void 0 : middleware.after) {
+                        const hooks = Array.isArray(middleware.after) ? middleware.after : [middleware.after];
+                        for (const hook of hooks) {
+                            const returned = yield hook(result, context, context.input);
+                            if (returned !== undefined) {
+                                result = returned;
+                            }
+                        }
+                    }
+                    return result;
                 });
                 const success = (result) => __awaiter(this, void 0, void 0, function* () {
                     try {
@@ -671,6 +702,21 @@ class V1Worker {
             }
         });
     }
+    /**
+     * Creates an action listener by registering the worker with the dispatcher.
+     * Override in subclasses to change registration behavior (e.g. legacy engines).
+     */
+    createListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client._v0.dispatcher.getActionListener({
+                workerName: this.name,
+                services: ['default'],
+                actions: Object.keys(this.action_registry),
+                slotConfig: this.slotConfig,
+                labels: this.labels,
+            });
+        });
+    }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
@@ -691,13 +737,7 @@ class V1Worker {
                 return;
             }
             try {
-                this.listener = yield this.client._v0.dispatcher.getActionListener({
-                    workerName: this.name,
-                    services: ['default'],
-                    actions: Object.keys(this.action_registry),
-                    maxRuns: this.maxRuns,
-                    labels: this.labels,
-                });
+                this.listener = yield this.createListener();
                 this.workerId = this.listener.workerId;
                 this.setStatus(health_server_1.workerStatus.HEALTHY);
                 const generator = this.listener.actions();

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

@@ -5,23 +5,16 @@ import { WebhookWorkerCreateRequest } from '../../../clients/rest/generated/data
 import { BaseWorkflowDeclaration } from '../../declaration';
 import { HatchetClient } from '../..';
 import { V1Worker } from './worker-internal';
+import { type WorkerSlotOptions } from './slot-utils';
 /**
  * Options for creating a new hatchet worker
  * @interface CreateWorkerOpts
  */
-export interface CreateWorkerOpts {
-    /** (optional) Maximum number of concurrent runs on this worker, defaults to 100 */
-    slots?: number;
-    /** (optional) Array of workflows to register */
-    workflows?: BaseWorkflowDeclaration<any, any>[] | V0Workflow[];
+export interface CreateWorkerOpts extends WorkerSlotOptions {
     /** (optional) Worker labels for affinity-based assignment */
     labels?: WorkerLabels;
     /** (optional) Whether to handle kill signals */
     handleKill?: boolean;
-    /** @deprecated Use slots instead */
-    maxRuns?: number;
-    /** (optional) Maximum number of concurrent runs on the durable worker, defaults to 1,000 */
-    durableSlots?: number;
 }
 /**
  * HatchetWorker class for workflow execution runtime
@@ -32,8 +25,11 @@ export declare class Worker {
     _v1: HatchetClient;
     _v0: LegacyHatchetClient;
     /** Internal reference to the underlying V0 worker implementation */
-    nonDurable: V1Worker;
-    durable?: V1Worker;
+    _internal: V1Worker;
+    /** Set when connected to a legacy engine that needs dual-worker architecture */
+    private _legacyWorker;
+    /** Tracks all workflows registered after construction (via registerWorkflow/registerWorkflows) */
+    private _registeredWorkflows;
     /**
      * Creates a new HatchetWorker instance
      * @param nonDurable - The V0 worker implementation
@@ -63,12 +59,12 @@ export declare class Worker {
      * Starts the worker
      * @returns Promise that resolves when the worker is stopped or killed
      */
-    start(): Promise<void[]>;
+    start(): Promise<void>;
     /**
      * Stops the worker
      * @returns Promise that resolves when the worker stops
      */
-    stop(): Promise<void[]>;
+    stop(): Promise<void>;
     /**
      * Updates or inserts worker labels
      * @param labels - Worker labels to update
@@ -87,6 +83,7 @@ export declare class Worker {
      */
     registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any, {}>>;
     isPaused(): Promise<boolean>;
-    pause(): Promise<any[]>;
-    unpause(): Promise<any[]>;
+    pause(): Promise<void> | Promise<import("../../../clients/rest/generated/data-contracts").Worker>;
+    unpause(): Promise<void> | Promise<import("../../../clients/rest/generated/data-contracts").Worker>;
 }
+export { testingExports as __testing } from './slot-utils';

package/v1/client/worker/worker.js

@@ -9,10 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Worker = void 0;
+exports.__testing = exports.Worker = void 0;
 const declaration_1 = require("../../declaration");
 const worker_internal_1 = require("./worker-internal");
-const DEFAULT_DURABLE_SLOTS = 1000;
+const slot_utils_1 = require("./slot-utils");
+const deprecated_1 = require("./deprecated");
 /**
  * HatchetWorker class for workflow execution runtime
  */
@@ -22,9 +23,11 @@ class Worker {
      * @param nonDurable - The V0 worker implementation
      */
     constructor(v1, v0, nonDurable, config, name) {
+        /** Tracks all workflows registered after construction (via registerWorkflow/registerWorkflows) */
+        this._registeredWorkflows = [];
         this._v1 = v1;
         this._v0 = v0;
-        this.nonDurable = nonDurable;
+        this._internal = nonDurable;
         this.config = config;
         this.name = name;
     }
@@ -36,7 +39,8 @@ class Worker {
      */
     static create(v1, v0, name, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const opts = Object.assign(Object.assign({ name }, options), { maxRuns: options.slots || options.maxRuns });
+            const resolvedOptions = (0, slot_utils_1.resolveWorkerOptions)(options);
+            const opts = Object.assign({ name }, resolvedOptions);
             const internalWorker = new worker_internal_1.V1Worker(v1, opts);
             const worker = new Worker(v1, v0, internalWorker, options, name);
             yield worker.registerWorkflows(options.workflows);
@@ -51,21 +55,17 @@ class Worker {
     registerWorkflows(workflows) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const wf of workflows || []) {
+                this._registeredWorkflows.push(wf);
                 if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
                     // TODO check if tenant is V1
-                    yield this.nonDurable.registerWorkflowV1(wf);
+                    yield this._internal.registerWorkflowV1(wf);
                     if (wf.definition._durableTasks.length > 0) {
-                        if (!this.durable) {
-                            const opts = Object.assign(Object.assign({ name: `${this.name}-durable` }, this.config), { maxRuns: this.config.durableSlots || DEFAULT_DURABLE_SLOTS });
-                            this.durable = new worker_internal_1.V1Worker(this._v1, opts);
-                            yield this.durable.registerWorkflowV1(wf, true);
-                        }
-                        this.durable.registerDurableActionsV1(wf.definition);
+                        this._internal.registerDurableActionsV1(wf.definition);
                     }
                 }
                 else {
                     // fallback to v0 client for backwards compatibility
-                    yield this.nonDurable.registerWorkflow(wf);
+                    yield this._internal.registerWorkflow(wf);
                 }
             }
         });
@@ -84,22 +84,29 @@ class Worker {
      * @returns Promise that resolves when the worker is stopped or killed
      */
     start() {
-        const workers = [this.nonDurable];
-        if (this.durable) {
-            workers.push(this.durable);
-        }
-        return Promise.all(workers.map((w) => w.start()));
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check engine version and fall back to legacy dual-worker mode if needed
+            if (yield (0, deprecated_1.isLegacyEngine)(this._v1)) {
+                // Include workflows registered after construction (via registerWorkflow/registerWorkflows)
+                // so the legacy worker picks them up.
+                const legacyConfig = Object.assign(Object.assign({}, this.config), { workflows: this._registeredWorkflows.length
+                        ? this._registeredWorkflows
+                        : this.config.workflows });
+                this._legacyWorker = yield deprecated_1.LegacyDualWorker.create(this._v1, this.name, legacyConfig);
+                return this._legacyWorker.start();
+            }
+            return this._internal.start();
+        });
     }
     /**
      * Stops the worker
      * @returns Promise that resolves when the worker stops
      */
     stop() {
-        const workers = [this.nonDurable];
-        if (this.durable) {
-            workers.push(this.durable);
+        if (this._legacyWorker) {
+            return this._legacyWorker.stop();
         }
-        return Promise.all(workers.map((w) => w.stop()));
+        return this._internal.stop();
     }
     /**
      * Updates or inserts worker labels
@@ -107,14 +114,14 @@ class Worker {
      * @returns Promise that resolves when labels are updated
      */
     upsertLabels(labels) {
-        return this.nonDurable.upsertLabels(labels);
+        return this._internal.upsertLabels(labels);
     }
     /**
      * Get the labels for the worker
      * @returns The labels for the worker
      */
     getLabels() {
-        return this.nonDurable.labels;
+        return this._internal.labels;
     }
     /**
      * Register a webhook with the worker
@@ -122,44 +129,33 @@ class Worker {
      * @returns A promise that resolves when the webhook is registered
      */
     registerWebhook(webhook) {
-        return this.nonDurable.registerWebhook(webhook);
+        return this._internal.registerWebhook(webhook);
     }
     isPaused() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const promises = [];
-            if ((_a = this.nonDurable) === null || _a === void 0 ? void 0 : _a.workerId) {
-                promises.push(this._v1.workers.isPaused(this.nonDurable.workerId));
+            var _a;
+            if (!((_a = this._internal) === null || _a === void 0 ? void 0 : _a.workerId)) {
+                return false;
             }
-            if ((_b = this.durable) === null || _b === void 0 ? void 0 : _b.workerId) {
-                promises.push(this._v1.workers.isPaused(this.durable.workerId));
-            }
-            const res = yield Promise.all(promises);
-            return !res.includes(false);
+            return this._v1.workers.isPaused(this._internal.workerId);
         });
     }
     // TODO docstrings
     pause() {
-        var _a, _b;
-        const promises = [];
-        if ((_a = this.nonDurable) === null || _a === void 0 ? void 0 : _a.workerId) {
-            promises.push(this._v1.workers.pause(this.nonDurable.workerId));
-        }
-        if ((_b = this.durable) === null || _b === void 0 ? void 0 : _b.workerId) {
-            promises.push(this._v1.workers.pause(this.durable.workerId));
+        var _a;
+        if (!((_a = this._internal) === null || _a === void 0 ? void 0 : _a.workerId)) {
+            return Promise.resolve();
         }
-        return Promise.all(promises);
+        return this._v1.workers.pause(this._internal.workerId);
     }
     unpause() {
-        var _a, _b;
-        const promises = [];
-        if ((_a = this.nonDurable) === null || _a === void 0 ? void 0 : _a.workerId) {
-            promises.push(this._v1.workers.unpause(this.nonDurable.workerId));
-        }
-        if ((_b = this.durable) === null || _b === void 0 ? void 0 : _b.workerId) {
-            promises.push(this._v1.workers.unpause(this.durable.workerId));
+        var _a;
+        if (!((_a = this._internal) === null || _a === void 0 ? void 0 : _a.workerId)) {
+            return Promise.resolve();
         }
-        return Promise.all(promises);
+        return this._v1.workers.unpause(this._internal.workerId);
     }
 }
 exports.Worker = Worker;
+var slot_utils_2 = require("./slot-utils");
+Object.defineProperty(exports, "__testing", { enumerable: true, get: function () { return slot_utils_2.testingExports; } });