@hatchet-dev/typescript-sdk 1.12.0 → 1.13.0

package/v1/client/client.d.ts

@@ -1,4 +1,4 @@
-import { ClientConfig, HatchetClientOptions, LegacyHatchetClient } from '../../clients/hatchet-client';
+import { ClientConfig, HatchetClientOptions, LegacyHatchetClient, TaskMiddleware, InferMiddlewareBefore, InferMiddlewareAfter } from '../../clients/hatchet-client';
 import { AxiosRequestConfig } from 'axios';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { Workflow as V0Workflow } from '../../workflow';
@@ -12,7 +12,7 @@ import { MetricsClient } from './features/metrics';
 import { WorkersClient } from './features/workers';
 import { WorkflowsClient } from './features/workflows';
 import { RunsClient } from './features/runs';
-import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType } from '../types';
+import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType, Resolved } from '../types';
 import { RatelimitsClient } from './features';
 import { AdminClient } from './admin';
 import { FiltersClient } from './features/filters';
@@ -21,11 +21,16 @@ import { CronClient } from './features/crons';
 import { CELClient } from './features/cel';
 import { TenantClient } from './features/tenant';
 import { WebhooksClient } from './features/webhooks';
+type MergeIfNonEmpty<Base, Extra extends Record<string, any>> = keyof Extra extends never ? Base : Base & Extra;
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
+ *
+ * @template GlobalInput - Global input type required by all tasks. Set via `init<T>()`. Defaults to `{}`.
+ * @template MiddlewareBefore - Extra fields merged into task input by pre-middleware hooks. Inferred from middleware config.
+ * @template MiddlewareAfter - Extra fields merged into task output by post-middleware hooks. Inferred from middleware config.
  */
-export declare class HatchetClient implements IHatchetClient {
+export declare class HatchetClient<GlobalInput extends Record<string, any> = {}, GlobalOutput extends Record<string, any> = {}, MiddlewareBefore extends Record<string, any> = {}, MiddlewareAfter extends Record<string, any> = {}> implements IHatchetClient {
     /** The underlying v0 client instance */
     _v0: LegacyHatchetClient;
     _api: Api;
@@ -47,12 +52,22 @@ export declare class HatchetClient implements IHatchetClient {
     constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig);
     /**
      * Static factory method to create a new Hatchet client instance.
-     * @param config - Optional configuration for the client
-     * @param options - Optional client options
-     * @param axiosConfig - Optional Axios configuration for HTTP requests
-     * @returns A new Hatchet client instance
-     */
-    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
+     * @template T - Global input type required by all tasks created from this client. Defaults to `{}`.
+     * @template U - Global output type required by all tasks created from this client. Defaults to `{}`.
+     * @param config - Optional configuration for the client.
+     * @param options - Optional client options.
+     * @param axiosConfig - Optional Axios configuration for HTTP requests.
+     * @returns A new Hatchet client instance. Chain `.withMiddleware()` to attach typed middleware.
+     */
+    static init<T extends Record<string, any> = {}, U extends Record<string, any> = {}>(config?: Omit<Partial<ClientConfig>, 'middleware'>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient<T, U>;
+    /**
+     * Attaches middleware to this client and returns a re-typed instance
+     * with inferred pre/post middleware types.
+     *
+     * Use this after `init<T, U>()` to get full middleware return-type inference
+     * that TypeScript can't provide when global types are explicitly set on `init`.
+     */
+    withMiddleware<const M extends TaskMiddleware<Resolved<GlobalInput, MiddlewareBefore>, Resolved<GlobalOutput, MiddlewareAfter>>>(middleware: M): HatchetClient<GlobalInput, GlobalOutput, MiddlewareBefore & InferMiddlewareBefore<M>, MiddlewareAfter & InferMiddlewareAfter<M>>;
     private _config;
     get config(): ClientConfig;
     /**
@@ -63,7 +78,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @returns A new Workflow instance
      * @note It is possible to create an orphaned workflow if no client is available using @hatchet/client CreateWorkflow
      */
-    workflow<I extends InputType = UnknownInputType, O extends StrictWorkflowOutputType = {}>(options: CreateWorkflowOpts): WorkflowDeclaration<I, O>;
+    workflow<I extends InputType = UnknownInputType, O extends StrictWorkflowOutputType = {}>(options: CreateWorkflowOpts): WorkflowDeclaration<I, O, Resolved<GlobalInput, MiddlewareBefore>>;
     /**
      * Creates a new task workflow.
      * Types can be explicitly specified as generics or inferred from the function signature.
@@ -72,7 +87,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options Task configuration options
      * @returns A TaskWorkflowDeclaration instance
      */
-    task<I extends InputType = UnknownInputType, O extends OutputType = void>(options: CreateTaskWorkflowOpts<I, O>): TaskWorkflowDeclaration<I, O>;
+    task<I extends InputType = UnknownInputType, O extends OutputType = void>(options: CreateTaskWorkflowOpts<I & Resolved<GlobalInput, MiddlewareBefore>, MergeIfNonEmpty<O, GlobalOutput>>): TaskWorkflowDeclaration<I, O, GlobalInput, GlobalOutput, MiddlewareBefore, MiddlewareAfter>;
     /**
      * Creates a new task workflow with types inferred from the function parameter.
      * @template Fn The type of the task function with input and output extending JsonObject
@@ -81,7 +96,7 @@ export declare class HatchetClient implements IHatchetClient {
      */
     task<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends InputType = Parameters<Fn>[0] | UnknownInputType, O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
         fn: Fn;
-    } & Omit<CreateTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
+    } & Omit<CreateTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O, GlobalInput, GlobalOutput, MiddlewareBefore, MiddlewareAfter>;
     /**
      * Creates a new durable task workflow.
      * Types can be explicitly specified as generics or inferred from the function signature.
@@ -90,7 +105,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options Durable task configuration options
      * @returns A TaskWorkflowDeclaration instance for a durable task
      */
-    durableTask<I extends InputType, O extends OutputType>(options: CreateDurableTaskWorkflowOpts<I, O>): TaskWorkflowDeclaration<I, O>;
+    durableTask<I extends InputType, O extends OutputType>(options: CreateDurableTaskWorkflowOpts<I & Resolved<GlobalInput, MiddlewareBefore>, MergeIfNonEmpty<O, GlobalOutput>>): TaskWorkflowDeclaration<I, O, GlobalInput, GlobalOutput, MiddlewareBefore, MiddlewareAfter>;
     /**
      * Creates a new durable task workflow with types inferred from the function parameter.
      * @template Fn The type of the durable task function with input and output extending JsonObject
@@ -99,7 +114,7 @@ export declare class HatchetClient implements IHatchetClient {
      */
     durableTask<Fn extends (input: I, ctx: V0DurableContext<I>) => O | Promise<O>, I extends InputType = Parameters<Fn>[0], O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
         fn: Fn;
-    } & Omit<CreateDurableTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
+    } & Omit<CreateDurableTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O, GlobalInput, GlobalOutput, MiddlewareBefore, MiddlewareAfter>;
     /**
      * Triggers a workflow run without waiting for completion.
      * @template I - The input type for the workflow
@@ -255,3 +270,4 @@ export declare class HatchetClient implements IHatchetClient {
     v0webhooks(workflows: V0Workflow[]): import("../../clients/worker/handler").WebhookHandler;
     runRef<T extends Record<string, any> = any>(id: string): WorkflowRunRef<T>;
 }
+export {};

package/v1/client/client.js

@@ -41,6 +41,10 @@ const webhooks_1 = require("./features/webhooks");
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
+ *
+ * @template GlobalInput - Global input type required by all tasks. Set via `init<T>()`. Defaults to `{}`.
+ * @template MiddlewareBefore - Extra fields merged into task input by pre-middleware hooks. Inferred from middleware config.
+ * @template MiddlewareAfter - Extra fields merged into task output by post-middleware hooks. Inferred from middleware config.
  */
 class HatchetClient {
     /**
@@ -95,7 +99,7 @@ class HatchetClient {
                         .warn('🚨⚠️‼️ YOU ARE USING A V0 ENGINE WITH A V1 SDK, WHICH IS NOT SUPPORTED. PLEASE UPGRADE YOUR ENGINE TO V1.🚨⚠️‼️');
                 }
             })
-                .catch((error) => {
+                .catch(() => {
                 // Do nothing here
             });
         }
@@ -105,14 +109,38 @@ class HatchetClient {
     }
     /**
      * Static factory method to create a new Hatchet client instance.
-     * @param config - Optional configuration for the client
-     * @param options - Optional client options
-     * @param axiosConfig - Optional Axios configuration for HTTP requests
-     * @returns A new Hatchet client instance
+     * @template T - Global input type required by all tasks created from this client. Defaults to `{}`.
+     * @template U - Global output type required by all tasks created from this client. Defaults to `{}`.
+     * @param config - Optional configuration for the client.
+     * @param options - Optional client options.
+     * @param axiosConfig - Optional Axios configuration for HTTP requests.
+     * @returns A new Hatchet client instance. Chain `.withMiddleware()` to attach typed middleware.
      */
     static init(config, options, axiosConfig) {
         return new HatchetClient(config, options, axiosConfig);
     }
+    /**
+     * Attaches middleware to this client and returns a re-typed instance
+     * with inferred pre/post middleware types.
+     *
+     * Use this after `init<T, U>()` to get full middleware return-type inference
+     * that TypeScript can't provide when global types are explicitly set on `init`.
+     */
+    withMiddleware(middleware) {
+        const existing = this._config.middleware || {};
+        const toArray = (v) => {
+            if (v == null)
+                return [];
+            if (Array.isArray(v))
+                return [...v];
+            return [v];
+        };
+        this._config.middleware = {
+            before: [...toArray(existing.before), ...toArray(middleware.before)],
+            after: [...toArray(existing.after), ...toArray(middleware.after)],
+        };
+        return this;
+    }
     get config() {
         return this._config;
     }

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

@@ -113,6 +113,12 @@ export declare class Context<T, K = {}> {
      * @returns The task run ID.
      */
     taskRunExternalId(): string;
+    /**
+     * Gets the ID of the current task run.
+     * @returns The task run ID.
+     * @deprecated use taskRunExternalId() instead
+     */
+    taskRunId(): string;
     /**
      * Gets the number of times the current task has been retried.
      * @returns The retry count.

package/v1/client/worker/context.js

@@ -180,6 +180,14 @@ class Context {
     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.taskRunExternalId();
+    }
     /**
      * Gets the number of times the current task has been retried.
      * @returns The retry count.

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