@hatchet-dev/typescript-sdk 1.11.0 → 1.12.1

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;
@@ -26,9 +28,11 @@ export declare class V1Worker {
     action_registry: ActionRegistry;
     workflow_registry: Array<WorkflowDefinition | Workflow>;
     listener: ActionListener | undefined;
-    futures: Record<Action['stepRunId'], HatchetPromise<any>>;
-    contexts: Record<Action['stepRunId'], Context<any, any>>;
-    maxRuns?: number;
+    futures: Record<Action['taskRunExternalId'], HatchetPromise<any>>;
+    contexts: Record<Action['taskRunExternalId'], Context<any, any>>;
+    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
@@ -398,11 +406,11 @@ class V1Worker {
     }
     handleStartStepRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { actionId } = action;
+            const { actionId, taskRunExternalId } = action;
             try {
                 // Note: we always use a DurableContext since its a superset of the Context class
                 const context = new context_1.DurableContext(action, this.client, this);
-                this.contexts[action.stepRunId] = context;
+                this.contexts[taskRunExternalId] = context;
                 const step = this.action_registry[actionId];
                 if (!step) {
                     this.logger.error(`Registered actions: '${Object.keys(this.action_registry).join(', ')}'`);
@@ -412,7 +420,7 @@ class V1Worker {
                 const run = () => __awaiter(this, void 0, void 0, function* () {
                     parent_run_context_vars_1.parentRunContextManager.setContext({
                         parentId: action.workflowRunId,
-                        parentRunId: action.stepRunId,
+                        parentTaskRunExternalId: taskRunExternalId,
                         childIndex: 0,
                         desiredWorkerId: this.workerId || '',
                     });
@@ -423,7 +431,7 @@ class V1Worker {
                         if (context.cancelled) {
                             return;
                         }
-                        this.logger.info(`Task run ${action.stepRunId} succeeded`);
+                        this.logger.info(`Task run ${taskRunExternalId} succeeded`);
                         // Send the action event to the dispatcher
                         const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, false, result || null, action.retryCount);
                         yield this.client._v0.dispatcher.sendStepActionEvent(event);
@@ -442,8 +450,8 @@ class V1Worker {
                     }
                     finally {
                         // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
+                        delete this.futures[taskRunExternalId];
+                        delete this.contexts[taskRunExternalId];
                     }
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
@@ -452,7 +460,7 @@ class V1Worker {
                         if (context.cancelled) {
                             return;
                         }
-                        this.logger.error(`Task run ${action.stepRunId} failed: ${error.message}`);
+                        this.logger.error(`Task run ${taskRunExternalId} failed: ${error.message}`);
                         if (error.stack) {
                             this.logger.error(error.stack);
                         }
@@ -468,8 +476,8 @@ class V1Worker {
                     }
                     finally {
                         // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
+                        delete this.futures[taskRunExternalId];
+                        delete this.contexts[taskRunExternalId];
                     }
                 });
                 const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
@@ -483,7 +491,7 @@ class V1Worker {
                     }
                     yield success(result);
                 }))());
-                this.futures[action.stepRunId] = future;
+                this.futures[taskRunExternalId] = future;
                 // Send the action event to the dispatcher
                 const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED, false, undefined, action.retryCount);
                 this.client._v0.dispatcher.sendStepActionEvent(event).catch((e) => {
@@ -495,10 +503,10 @@ class V1Worker {
                 catch (e) {
                     const message = (e === null || e === void 0 ? void 0 : e.message) || String(e);
                     if (message.includes('Cancelled')) {
-                        this.logger.debug(`Task run ${action.stepRunId} was cancelled`);
+                        this.logger.debug(`Task run ${taskRunExternalId} was cancelled`);
                     }
                     else {
-                        this.logger.error(`Could not wait for task run ${action.stepRunId} to finish. ` +
+                        this.logger.error(`Could not wait for task run ${taskRunExternalId} to finish. ` +
                             `See https://docs.hatchet.run/home/cancellation for best practices on handling cancellation: `, e);
                     }
                 }
@@ -510,11 +518,11 @@ class V1Worker {
     }
     handleStartGroupKeyRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { actionId } = action;
+            const { actionId, getGroupKeyRunId, taskRunExternalId } = action;
             this.logger.error('Concurrency Key Functions have been deprecated and will be removed in a future release. Use Concurrency Expressions instead.');
             try {
                 const context = new context_1.Context(action, this.client, this);
-                const key = action.getGroupKeyRunId;
+                const key = getGroupKeyRunId;
                 if (!key) {
                     this.logger.error(`No group key run id provided for action ${actionId}`);
                     return;
@@ -530,7 +538,7 @@ class V1Worker {
                     return step(context);
                 });
                 const success = (result) => {
-                    this.logger.info(`Task run ${action.stepRunId} succeeded`);
+                    this.logger.info(`Task run ${taskRunExternalId} succeeded`);
                     try {
                         // Send the action event to the dispatcher
                         const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
@@ -584,8 +592,8 @@ class V1Worker {
             workerId: this.name,
             jobId: action.jobId,
             jobRunId: action.jobRunId,
-            stepId: action.stepId,
-            stepRunId: action.stepRunId,
+            taskId: action.taskId,
+            taskRunExternalId: action.taskRunExternalId,
             actionId: action.actionId,
             eventTimestamp: new Date(),
             eventType,
@@ -610,17 +618,17 @@ class V1Worker {
     }
     handleCancelStepRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { stepRunId } = action;
+            const { taskRunExternalId } = action;
             try {
-                this.logger.info(`Cancelling task run ${action.stepRunId}`);
-                const future = this.futures[stepRunId];
-                const context = this.contexts[stepRunId];
+                this.logger.info(`Cancelling task run ${taskRunExternalId}`);
+                const future = this.futures[taskRunExternalId];
+                const context = this.contexts[taskRunExternalId];
                 if (context && context.abortController) {
                     context.abortController.abort('Cancelled by worker');
                 }
                 if (future) {
                     future.promise.catch(() => {
-                        this.logger.info(`Cancelled task run ${action.stepRunId}`);
+                        this.logger.info(`Cancelled task run ${taskRunExternalId}`);
                     });
                     future.cancel('Cancelled by worker');
                     yield future.promise;
@@ -628,11 +636,11 @@ class V1Worker {
             }
             catch (e) {
                 // Expected: the promise rejects when cancelled
-                this.logger.debug(`Task run ${stepRunId} cancellation completed`);
+                this.logger.debug(`Task run ${taskRunExternalId} cancellation completed`);
             }
             finally {
-                delete this.futures[stepRunId];
-                delete this.contexts[stepRunId];
+                delete this.futures[taskRunExternalId];
+                delete this.contexts[taskRunExternalId];
             }
         });
     }
@@ -671,6 +679,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 +714,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; } });

package/v1/declaration.js

@@ -48,7 +48,7 @@ class BaseWorkflowDeclaration {
             if (!parentRunContext && ((options === null || options === void 0 ? void 0 : options.childKey) || (options === null || options === void 0 ? void 0 : options.sticky))) {
                 this.client.admin.logger.warn('ignoring childKey or sticky because run is not being spawned from a parent task');
             }
-            const runOpts = Object.assign(Object.assign({}, options), { parentId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentId, parentStepRunId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentRunId, childIndex: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.childIndex, sticky: (options === null || options === void 0 ? void 0 : options.sticky) ? parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.desiredWorkerId : undefined, childKey: options === null || options === void 0 ? void 0 : options.childKey });
+            const runOpts = Object.assign(Object.assign({}, options), { parentId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentId, parentTaskRunExternalId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentTaskRunExternalId, childIndex: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.childIndex, sticky: (options === null || options === void 0 ? void 0 : options.sticky) ? parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.desiredWorkerId : undefined, childKey: options === null || options === void 0 ? void 0 : options.childKey });
             if (Array.isArray(input)) {
                 let resp = [];
                 for (let i = 0; i < input.length; i += 500) {

package/v1/index.d.ts

@@ -7,3 +7,4 @@ export * from './client/duration';
 export * from './types';
 export * from './task';
 export * from './client/worker/context';
+export * from './slot-types';

package/v1/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./client/duration"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./task"), exports);
 __exportStar(require("./client/worker/context"), exports);
+__exportStar(require("./slot-types"), exports);

package/v1/parent-run-context-vars.d.ts

@@ -1,6 +1,9 @@
 export interface ParentRunContext {
     parentId: string;
-    parentRunId: string;
+    /**
+     * External ID of the parent task/step run.
+     */
+    parentTaskRunExternalId: string;
     desiredWorkerId: string;
     childIndex?: number;
 }