@hatchet-dev/typescript-sdk 1.34.0 → 1.35.0

package/clients/dispatcher/action-listener.d.ts

@@ -28,5 +28,6 @@ export declare class ActionListener {
     getListenStrategy(): Promise<ListenStrategy>;
     incrementRetries(): Promise<void>;
     getListenClient(): Promise<AsyncIterable<AssignedAction>>;
+    stopStream(): void;
     unregister(): Promise<import("../../protoc/dispatcher").WorkerUnsubscribeResponse>;
 }

package/clients/dispatcher/action-listener.js

@@ -225,14 +225,19 @@ class ActionListener {
             }
         });
     }
+    // Leaves the heartbeat running: tasks that are already in flight still need
+    // the engine to see this worker as alive until they finish.
+    stopStream() {
+        this.done = true;
+        // Abort the gRPC stream to immediately cancel the generator
+        if (this.abortController) {
+            this.abortController.abort('Worker stopping');
+        }
+    }
     unregister() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.done = true;
+            this.stopStream();
             this.heartbeat.stop();
-            // Abort the gRPC stream to immediately cancel the generator
-            if (this.abortController) {
-                this.abortController.abort('Worker stopping');
-            }
             try {
                 return yield this.client.unsubscribe({
                     workerId: this.workerId,

package/clients/listeners/durable-listener/durable-listener-client.d.ts

@@ -18,6 +18,9 @@ export declare class DurableListenerClient {
     private _pendingCallbacks;
     private _orderedCompletions;
     private _pendingEvictionAcks;
+    private _newlyWaitingKeys;
+    private _waitingSince;
+    private _workerStatusSendScheduled;
     private _receiveAbort;
     private _statusInterval;
     private _startLock;
@@ -34,13 +37,20 @@ export declare class DurableListenerClient {
     private _requestIterator;
     private _enqueueRequest;
     private _startStatusPolling;
-    private _pollWorkerStatus;
+    private _registerWaitingKey;
+    private _scheduleWorkerStatusSend;
+    private _enqueueWorkerStatusForNewlyWaitingKeys;
+    private _enqueueWorkerStatusForLongPendingWaiters;
+    private _enqueueFullWorkerStatus;
+    private _enqueueWorkerStatusFor;
     private _failPendingAcks;
     private _failAllPending;
     private _handleResponse;
     sendEvent(durableTaskExternalId: string, invocationCount: number, event: RunChildrenEvent): Promise<DurableTaskEventRunAck>;
     sendEvent(durableTaskExternalId: string, invocationCount: number, event: WaitForEvent): Promise<DurableTaskEventWaitForAck>;
     sendEvent(durableTaskExternalId: string, invocationCount: number, event: MemoEvent): Promise<DurableTaskEventMemoAck>;
+    private _sendRequestAndAwaitAck;
+    private _sendRunChildrenEvent;
     private _drainsInProgress;
     private _drainRerunRequests;
     private _drainOrderedCompletions;

package/clients/listeners/durable-listener/durable-listener-client.js

@@ -94,7 +94,10 @@ class TTLMap {
 }
 const DEFAULT_RECONNECT_INTERVAL = 3000;
 const EVICTION_ACK_TIMEOUT_MS = 30000;
-const WORKER_STATUS_POLL_INTERVAL_MS = 1000;
+const WORKER_STATUS_RESEND_INTERVAL_MS = 5000;
+const WORKER_STATUS_RESEND_MIN_PENDING_MS = 2000;
+const WORKER_STATUS_MAX_ENTRIES_PER_REQUEST = 10000;
+const RUN_CHILDREN_MAX_CHILDREN_PER_REQUEST = 100;
 function eventLogEntryResultFromProto(proto) {
     var _a, _b, _c, _d;
     let payload;
@@ -109,6 +112,15 @@ function eventLogEntryResultFromProto(proto) {
         errorMessage: proto.errorMessage,
     };
 }
+function awaitedCompletedEntryFromCallbackKey(key) {
+    const [durableTaskExternalId, invocationCount, branchId, nodeId] = key.split(':');
+    return {
+        durableTaskExternalId,
+        invocationCount: parseInt(invocationCount, 10),
+        branchId: parseInt(branchId, 10),
+        nodeId: parseInt(nodeId, 10),
+    };
+}
 function ackKey(taskExtId, invocationCount) {
     return `${taskExtId}:${invocationCount}`;
 }
@@ -142,6 +154,9 @@ class DurableListenerClient {
         // without consuming everything; the server stall-evicts long before.
         this._orderedCompletions = new TTLMap(300000);
         this._pendingEvictionAcks = new Map();
+        this._newlyWaitingKeys = new Set();
+        this._waitingSince = new Map();
+        this._workerStatusSendScheduled = false;
         this._consecutiveFailures = 0;
         this._drainsInProgress = new Set();
         this._drainRerunRequests = new Set();
@@ -205,7 +220,7 @@ class DurableListenerClient {
             this._enqueueRequest({
                 registerWorker: { workerId: this._workerId },
             });
-            this._pollWorkerStatus();
+            this._enqueueFullWorkerStatus();
             void this._streamLoop();
             this.logger.info('durable event listener connected');
         });
@@ -300,28 +315,57 @@ class DurableListenerClient {
             clearInterval(this._statusInterval);
         }
         this._statusInterval = setInterval(() => {
-            this._pollWorkerStatus();
-        }, WORKER_STATUS_POLL_INTERVAL_MS);
+            this._enqueueWorkerStatusForLongPendingWaiters();
+        }, WORKER_STATUS_RESEND_INTERVAL_MS);
     }
-    _pollWorkerStatus() {
-        if (!this._workerId || this._pendingCallbacks.size === 0)
+    _registerWaitingKey(key) {
+        this._waitingSince.set(key, Date.now());
+        this._newlyWaitingKeys.add(key);
+    }
+    // Waiters registered in the same turn of the event loop share one request,
+    // instead of each sending its own.
+    _scheduleWorkerStatusSend() {
+        if (this._workerStatusSendScheduled)
             return;
-        const waitingEntries = [];
-        for (const key of this._pendingCallbacks.keys()) {
-            const parts = key.split(':');
-            waitingEntries.push({
-                durableTaskExternalId: parts[0],
-                invocationCount: parseInt(parts[1], 10),
-                branchId: parseInt(parts[2], 10),
-                nodeId: parseInt(parts[3], 10),
+        this._workerStatusSendScheduled = true;
+        setImmediate(() => this._enqueueWorkerStatusForNewlyWaitingKeys());
+    }
+    _enqueueWorkerStatusForNewlyWaitingKeys() {
+        this._workerStatusSendScheduled = false;
+        const keys = [...this._newlyWaitingKeys].filter((key) => this._pendingCallbacks.has(key));
+        this._newlyWaitingKeys.clear();
+        this._enqueueWorkerStatusFor(keys);
+    }
+    _enqueueWorkerStatusForLongPendingWaiters() {
+        const registeredBefore = Date.now() - WORKER_STATUS_RESEND_MIN_PENDING_MS;
+        const keys = [];
+        for (const [key, waitingSince] of this._waitingSince) {
+            if (!this._pendingCallbacks.has(key)) {
+                this._waitingSince.delete(key);
+            }
+            else if (waitingSince <= registeredBefore) {
+                keys.push(key);
+            }
+        }
+        this._enqueueWorkerStatusFor(keys);
+    }
+    _enqueueFullWorkerStatus() {
+        this._newlyWaitingKeys.clear();
+        this._enqueueWorkerStatusFor([...this._pendingCallbacks.keys()]);
+    }
+    _enqueueWorkerStatusFor(keys, maxEntriesPerRequest = WORKER_STATUS_MAX_ENTRIES_PER_REQUEST) {
+        if (!this._workerId)
+            return;
+        for (let start = 0; start < keys.length; start += maxEntriesPerRequest) {
+            this._enqueueRequest({
+                workerStatus: {
+                    workerId: this._workerId,
+                    waitingEntries: keys
+                        .slice(start, start + maxEntriesPerRequest)
+                        .map(awaitedCompletedEntryFromCallbackKey),
+                },
             });
         }
-        this._enqueueRequest({
-            workerStatus: {
-                workerId: this._workerId,
-                waitingEntries,
-            },
-        });
     }
     _failPendingAcks(exc) {
         for (const d of this._pendingEventAcks.values()) {
@@ -406,13 +450,15 @@ class DurableListenerClient {
             const orderKey = completionOrderKey((_s = ref === null || ref === void 0 ? void 0 : ref.durableTaskExternalId) !== null && _s !== void 0 ? _s : '', (_t = ref === null || ref === void 0 ? void 0 : ref.invocationCount) !== null && _t !== void 0 ? _t : 0);
             const queue = (_u = this._orderedCompletions.get(orderKey)) !== null && _u !== void 0 ? _u : {
                 pending: [],
+                pendingKeys: new Set(),
                 delivered: new Set(),
             };
             if (!queue.delivered.has(key)) {
                 queue.delivered.add(key);
+                queue.pendingKeys.add(key);
                 queue.pending.push({ key, result });
             }
-            else if (queue.pending.every((entry) => entry.key !== key)) {
+            else if (!queue.pendingKeys.has(key)) {
                 // Re-delivery of a completion that already drained (reconnect,
                 // worker-status re-send, or a repeated wait on a node deduped by
                 // child key). Its satisfied order was released before anything
@@ -478,20 +524,10 @@ class DurableListenerClient {
     }
     sendEvent(durableTaskExternalId, invocationCount, event) {
         return __awaiter(this, void 0, void 0, function* () {
-            const key = ackKey(durableTaskExternalId, invocationCount);
-            const d = deferred();
-            this._pendingEventAcks.set(key, d);
             let request;
             switch (event.kind) {
-                case 'runChildren': {
-                    const triggerRunsReq = {
-                        invocationCount,
-                        durableTaskExternalId,
-                        triggerOpts: event.triggerOpts,
-                    };
-                    request = { triggerRuns: triggerRunsReq };
-                    break;
-                }
+                case 'runChildren':
+                    return this._sendRunChildrenEvent(durableTaskExternalId, invocationCount, event);
                 case 'waitFor': {
                     const waitForReq = {
                         invocationCount,
@@ -517,8 +553,33 @@ class DurableListenerClient {
                     throw new Error(`Unknown durable task send event: ${_}`);
                 }
             }
-            this._enqueueRequest(request);
-            return d.promise;
+            return this._sendRequestAndAwaitAck(durableTaskExternalId, invocationCount, request);
+        });
+    }
+    _sendRequestAndAwaitAck(durableTaskExternalId, invocationCount, request) {
+        const d = deferred();
+        this._pendingEventAcks.set(ackKey(durableTaskExternalId, invocationCount), d);
+        this._enqueueRequest(request);
+        return d.promise;
+    }
+    _sendRunChildrenEvent(durableTaskExternalId, invocationCount, event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runEntries = [];
+            for (let start = 0; start < event.triggerOpts.length; start += RUN_CHILDREN_MAX_CHILDREN_PER_REQUEST) {
+                const triggerRunsReq = {
+                    invocationCount,
+                    durableTaskExternalId,
+                    triggerOpts: event.triggerOpts.slice(start, start + RUN_CHILDREN_MAX_CHILDREN_PER_REQUEST),
+                };
+                const ack = yield this._sendRequestAndAwaitAck(durableTaskExternalId, invocationCount, {
+                    triggerRuns: triggerRunsReq,
+                });
+                if (ack.ackType !== 'run') {
+                    throw new Error(`Expected a run ack for a trigger runs request, got ${ack.ackType}`);
+                }
+                runEntries.push(...ack.runEntries);
+            }
+            return { ackType: 'run', invocationCount, durableTaskExternalId, runEntries };
         });
     }
     // Hands queued completions to their waiters strictly in delivery order.
@@ -560,6 +621,7 @@ class DurableListenerClient {
                 if (!waiter)
                     return;
                 queue.pending.shift();
+                queue.pendingKeys.delete(head.key);
                 this._pendingCallbacks.delete(head.key);
                 waiter.resolve(head.result);
                 released = true;
@@ -577,6 +639,7 @@ class DurableListenerClient {
         const d = deferred();
         d.promise.catch(() => { });
         this._pendingCallbacks.set(key, d);
+        this._registerWaitingKey(key);
         this._drainOrderedCompletions(completionOrderKey(durableTaskExternalId, invocationCount));
     }
     waitForCallback(durableTaskExternalId, invocationCount, branchId, nodeId, opts) {
@@ -594,9 +657,10 @@ class DurableListenerClient {
                 // not crash the process as an unhandled rejection.
                 d.promise.catch(() => { });
                 this._pendingCallbacks.set(key, d);
+                this._registerWaitingKey(key);
                 this._drainOrderedCompletions(completionOrderKey(durableTaskExternalId, invocationCount));
                 if (this._pendingCallbacks.has(key)) {
-                    this._pollWorkerStatus();
+                    this._scheduleWorkerStatusSend();
                 }
             }
             if (!signal) {
@@ -656,6 +720,10 @@ class DurableListenerClient {
     sendEvictInvocation(durableTaskExternalId, invocationCount, reason) {
         return __awaiter(this, void 0, void 0, function* () {
             const key = evictionKey(durableTaskExternalId, invocationCount);
+            const pending = this._pendingEvictionAcks.get(key);
+            if (pending) {
+                return pending.promise;
+            }
             const d = deferred();
             this._pendingEvictionAcks.set(key, d);
             const req = {
@@ -664,15 +732,17 @@ class DurableListenerClient {
                 reason,
             };
             this._enqueueRequest({ evictInvocation: req });
-            const timeout = (0, sleep_1.default)(EVICTION_ACK_TIMEOUT_MS).then(() => {
-                throw new Error(`Eviction ack timed out after ${EVICTION_ACK_TIMEOUT_MS}ms for task ${durableTaskExternalId} invocation ${invocationCount}`);
-            });
+            const timeout = setTimeout(() => {
+                d.reject(new Error(`Eviction ack timed out after ${EVICTION_ACK_TIMEOUT_MS}ms for task ${durableTaskExternalId} invocation ${invocationCount}`));
+            }, EVICTION_ACK_TIMEOUT_MS);
             try {
-                yield Promise.race([d.promise, timeout]);
+                yield d.promise;
             }
-            catch (err) {
-                this._pendingEvictionAcks.delete(key);
-                throw err;
+            finally {
+                clearTimeout(timeout);
+                if (this._pendingEvictionAcks.get(key) === d) {
+                    this._pendingEvictionAcks.delete(key);
+                }
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.34.0",
+  "version": "1.35.0",
   "engines": {
     "node": ">=20"
   },

package/v1/client/features/workflows.d.ts

@@ -1,6 +1,17 @@
 import { BaseWorkflowDeclaration, WorkflowDefinition } from '../..';
 import type { LegacyWorkflow } from '../../../legacy/legacy-transformer';
+import { WorkflowPauseScheduledCronRunQueueBehavior } from '../../../clients/rest/generated/data-contracts';
 import { HatchetClient } from '../client';
+import { Duration } from '../duration';
+export { WorkflowPauseScheduledCronRunQueueBehavior };
+export type PauseWorkflowOpts = {
+    /** How long runs stay queued while the workflow is paused before they are dropped. */
+    queueTTL: Duration;
+    /** The behavior of cron runs triggered while the workflow is paused. Defaults to QUEUE. */
+    pausedWorkflowCronRunQueueBehavior?: WorkflowPauseScheduledCronRunQueueBehavior;
+    /** The behavior of scheduled runs triggered while the workflow is paused. Defaults to QUEUE. */
+    pausedWorkflowScheduledRunQueueBehavior?: WorkflowPauseScheduledCronRunQueueBehavior;
+};
 export declare const workflowNameString: (workflow: string | WorkflowDefinition | BaseWorkflowDeclaration<any, any> | LegacyWorkflow) => string;
 /**
  * The workflows client is a client for managing workflows programmatically within Hatchet.
@@ -39,4 +50,18 @@ export declare class WorkflowsClient {
      * @returns A promise that resolves to the deleted workflow.
      */
     delete(workflow: string | BaseWorkflowDeclaration<any, any> | LegacyWorkflow): Promise<void>;
+    /**
+     * Pause a workflow. While paused, new runs of the workflow are queued but not started.
+     * @param workflow - The workflow name, ID, or object.
+     * @param opts - The options for the pause operation.
+     * @returns A promise that resolves to the updated workflow.
+     */
+    pause(workflow: string | BaseWorkflowDeclaration<any, any> | LegacyWorkflow, opts: PauseWorkflowOpts): Promise<import("../../../clients/rest/generated/data-contracts").Workflow>;
+    /**
+     * Unpause a workflow.
+     * @param workflow - The workflow name, ID, or object.
+     * @returns A promise that resolves to the updated workflow.
+     */
+    unpause(workflow: string | BaseWorkflowDeclaration<any, any> | LegacyWorkflow): Promise<import("../../../clients/rest/generated/data-contracts").Workflow>;
+    private update;
 }

package/v1/client/features/workflows.js

@@ -9,9 +9,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowsClient = exports.workflowNameString = void 0;
+exports.WorkflowsClient = exports.workflowNameString = exports.WorkflowPauseScheduledCronRunQueueBehavior = void 0;
 const legacy_transformer_1 = require("../../../legacy/legacy-transformer");
 const uuid_1 = require("../../../util/uuid");
+const data_contracts_1 = require("../../../clients/rest/generated/data-contracts");
+Object.defineProperty(exports, "WorkflowPauseScheduledCronRunQueueBehavior", { enumerable: true, get: function () { return data_contracts_1.WorkflowPauseScheduledCronRunQueueBehavior; } });
+const duration_1 = require("../duration");
 const workflowNameString = (workflow) => {
     if (typeof workflow === 'string') {
         return workflow;
@@ -148,5 +151,50 @@ class WorkflowsClient {
             }
         });
     }
+    /**
+     * Pause a workflow. While paused, new runs of the workflow are queued but not started.
+     * @param workflow - The workflow name, ID, or object.
+     * @param opts - The options for the pause operation.
+     * @returns A promise that resolves to the updated workflow.
+     */
+    pause(workflow, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return this.update(workflow, {
+                pause: {
+                    action: 'pause',
+                    pausedWorkflowQueueTTL: (0, duration_1.durationToString)(opts.queueTTL),
+                    pausedWorkflowCronRunQueueBehavior: (_a = opts.pausedWorkflowCronRunQueueBehavior) !== null && _a !== void 0 ? _a : data_contracts_1.WorkflowPauseScheduledCronRunQueueBehavior.QUEUE,
+                    pausedWorkflowScheduledRunQueueBehavior: (_b = opts.pausedWorkflowScheduledRunQueueBehavior) !== null && _b !== void 0 ? _b : data_contracts_1.WorkflowPauseScheduledCronRunQueueBehavior.QUEUE,
+                },
+            });
+        });
+    }
+    /**
+     * Unpause a workflow.
+     * @param workflow - The workflow name, ID, or object.
+     * @returns A promise that resolves to the updated workflow.
+     */
+    unpause(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.update(workflow, { pause: { action: 'unpause' } });
+        });
+    }
+    update(workflow, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = (0, exports.workflowNameString)(workflow);
+            const workflowId = yield this.getWorkflowIdFromName(name);
+            try {
+                const { data } = yield this.api.workflowUpdate(workflowId, request);
+                this.workflowCache.delete(name);
+                this.workflowCache.delete(data.name);
+                return data;
+            }
+            catch (error) {
+                this.workflowCache.delete(name);
+                throw error;
+            }
+        });
+    }
 }
 exports.WorkflowsClient = WorkflowsClient;

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

@@ -45,6 +45,7 @@ export declare class InternalWorker {
     enableHealthServer: boolean;
     private healthServer;
     private status;
+    private shutdownPromise;
     constructor(client: HatchetClient, options: {
         name: string;
         handleKill?: boolean;
@@ -96,6 +97,7 @@ export declare class InternalWorker {
     handleCancelStepRun(action: Action): Promise<void>;
     stop(): Promise<void>;
     exitGracefully(handleKill: boolean): Promise<void>;
+    private shutdown;
     /**
      * Creates an action listener by registering the worker with the dispatcher.
      * Override in subclasses to change registration behavior (e.g. legacy engines).

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

@@ -628,6 +628,18 @@ class InternalWorker {
     exitGracefully(handleKill) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
+            // Signals and an explicit stop must await the same eviction and listener teardown.
+            (_a = this.shutdownPromise) !== null && _a !== void 0 ? _a : (this.shutdownPromise = this.shutdown());
+            yield this.shutdownPromise;
+            if (handleKill) {
+                this.logger.info('Exiting hatchet worker...');
+                process.exit(0);
+            }
+        });
+    }
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             this.killing = true;
             this.setStatus(health_server_1.workerStatus.UNHEALTHY);
             this.logger.info('Starting to exit...');
@@ -658,16 +670,19 @@ class InternalWorker {
             catch (e) {
                 this.logger.error(`Could not stop durable listener: ${e.message}`);
             }
+            (_a = this.listener) === null || _a === void 0 ? void 0 : _a.stopStream();
+            this.logger.info('Gracefully exiting hatchet worker, running tasks will attempt to finish...');
+            // attempt to wait for futures to finish
+            yield Promise.all(Object.values(this.futures).map(({ promise }) => promise));
+            this.logger.info('Successfully finished pending tasks.');
+            // Unregistering stops the heartbeat, so it has to wait until the running tasks are done:
+            // otherwise the engine sees a dead worker and reassigns tasks that are about to complete.
             try {
-                yield ((_a = this.listener) === null || _a === void 0 ? void 0 : _a.unregister());
+                yield ((_b = this.listener) === null || _b === void 0 ? void 0 : _b.unregister());
             }
             catch (e) {
                 this.logger.error(`Could not unregister listener: ${e.message}`);
             }
-            this.logger.info('Gracefully exiting hatchet worker, running tasks will attempt to finish...');
-            // attempt to wait for futures to finish
-            yield Promise.all(Object.values(this.futures).map(({ promise }) => promise));
-            this.logger.info('Successfully finished pending tasks.');
             if (this.healthServer) {
                 try {
                     yield this.healthServer.stop();
@@ -676,10 +691,6 @@ class InternalWorker {
                     this.logger.error(`Could not stop health server: ${e.message}`);
                 }
             }
-            if (handleKill) {
-                this.logger.info('Exiting hatchet worker...');
-                process.exit(0);
-            }
         });
     }
     /**
@@ -700,10 +711,18 @@ class InternalWorker {
     start() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
+            if (this.killing) {
+                return;
+            }
             this.setStatus(health_server_1.workerStatus.STARTING);
             if (this.healthServer) {
                 try {
                     yield this.healthServer.start();
+                    if (this.killing) {
+                        yield this.shutdownPromise;
+                        yield this.healthServer.stop();
+                        return;
+                    }
                 }
                 catch (e) {
                     this.logger.error(`Could not start health server: ${e.message}`);
@@ -713,11 +732,17 @@ class InternalWorker {
             }
             // ensure all workflows are registered
             yield Promise.all(this.registeredWorkflowPromises);
-            if (Object.keys(this.action_registry).length === 0) {
+            if (this.killing || Object.keys(this.action_registry).length === 0) {
                 return;
             }
             try {
-                this.listener = yield this.createListener();
+                const listener = yield this.createListener();
+                if (this.killing) {
+                    // Shutdown cannot clean up a listener that registration has not returned yet.
+                    yield listener.unregister();
+                    return;
+                }
+                this.listener = listener;
                 this.workerId = this.listener.workerId;
                 this.setStatus(health_server_1.workerStatus.HEALTHY);
                 const generator = this.listener.actions();

package/v1/declaration.d.ts

@@ -12,6 +12,7 @@ import { IHatchetClient } from './client/client.interface';
 import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn, WorkerLabelComparator, IdempotencyConfig, BatchTaskConfig, BatchTaskFn } from './task';
 import { Duration } from './client/duration';
 import { MetricsClient } from './client/features/metrics';
+import type { PauseWorkflowOpts } from './client/features/workflows';
 import { InputType, OutputType, UnknownInputType, JsonObject, Resolved } from './types';
 import { Context, DurableContext } from './client/worker/context';
 import { EvictionPolicy } from './client/worker/eviction/eviction-policy';
@@ -374,6 +375,19 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
     get(): Promise<import("../clients/rest/generated/data-contracts").Workflow>;
+    /**
+     * Pause the workflow. While paused, new runs of the workflow are queued but not started.
+     * @param opts - The options for the pause operation.
+     * @returns A promise that resolves to the updated workflow.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    pause(opts: PauseWorkflowOpts): Promise<import("../clients/rest/generated/data-contracts").Workflow>;
+    /**
+     * Unpause the workflow.
+     * @returns A promise that resolves to the updated workflow.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    unpause(): Promise<import("../clients/rest/generated/data-contracts").Workflow>;
     /**
      * @deprecated use definition.name instead
      * @hidden

package/v1/declaration.js

@@ -379,27 +379,29 @@ class BaseWorkflowDeclaration {
         }
         return this.client.workflows.get(this);
     }
-    // // gets the pause state of the workflow
-    // isPaused() {
-    //   if (!this.client) {
-    //     throw UNBOUND_ERR;
-    //   }
-    //   return this.client.workflows.isPaused(this);
-    // }
-    // // pause assignment of workflow
-    // pause() {
-    //   if (!this.client) {
-    //     throw UNBOUND_ERR;
-    //   }
-    //   return this.client.workflows.pause(this);
-    // }
-    // // unpause assignment of workflow
-    // unpause() {
-    //   if (!this.client) {
-    //     throw UNBOUND_ERR;
-    //   }
-    //   return this.client.workflows.unpause(this);
-    // }
+    /**
+     * Pause the workflow. While paused, new runs of the workflow are queued but not started.
+     * @param opts - The options for the pause operation.
+     * @returns A promise that resolves to the updated workflow.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    pause(opts) {
+        if (!this.client) {
+            throw UNBOUND_ERR;
+        }
+        return this.client.workflows.pause(this, opts);
+    }
+    /**
+     * Unpause the workflow.
+     * @returns A promise that resolves to the updated workflow.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    unpause() {
+        if (!this.client) {
+            throw UNBOUND_ERR;
+        }
+        return this.client.workflows.unpause(this);
+    }
     /**
      * @deprecated use definition.name instead
      * @hidden

package/v1/examples/workflow_pause/pause.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/workflow_pause/pause.js

@@ -0,0 +1,35 @@
+"use strict";
+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 });
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+const pausableWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'pausable-workflow',
+});
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Pause a workflow
+        yield pausableWorkflow.pause({
+            queueTTL: '24h',
+            pausedWorkflowCronRunQueueBehavior: v1_1.WorkflowPauseScheduledCronRunQueueBehavior.DROP,
+            pausedWorkflowScheduledRunQueueBehavior: v1_1.WorkflowPauseScheduledCronRunQueueBehavior.QUEUE,
+        });
+        // !!
+        // > Unpause a workflow
+        yield pausableWorkflow.unpause();
+        // !!
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.34.0";
+export declare const HATCHET_VERSION = "1.35.0";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.34.0';
+exports.HATCHET_VERSION = '1.35.0';