@hatchet-dev/typescript-sdk 1.37.0 → 1.39.0

package/scripts/check-core-esm-exports.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// Verifies that every export of the built core entry is visible to an ESM importer under Node:
+// the entry is CommonJS, and Node derives its named exports statically, so a re-export written
+// in a form that detection misses (a getter over a default import) vanishes for `import { X }`.
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+
+const entry = resolve('dist/core/index.js');
+const cjs = createRequire(import.meta.url)(entry);
+const esm = await import(pathToFileURL(entry).href);
+const missing = Object.keys(cjs).filter((name) => name !== '__esModule' && !(name in esm));
+
+if (missing.length > 0) {
+  console.error(`core entry exports hidden from ESM importers: ${missing.join(', ')}`);
+  process.exit(1);
+}
+
+console.log(`core entry: ${Object.keys(cjs).length} exports visible to ESM importers`);

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

@@ -1,3 +1,4 @@
+import type { StreamCallOptions, StreamTopicMetadata } from '../../../core/types';
 import { HatchetClient } from '../client';
 export type StreamEvent = {
     /** the message payload */
@@ -7,23 +8,7 @@ export type StreamEvent = {
     /** when the message was stored */
     createdAt?: Date;
 };
-/** Covers only messages within the tenant's retention. */
-export type StreamTopicMetadata = {
-    namespace: string;
-    topic: string;
-    tenantId: string;
-    messageCount: number;
-    /** resumes events() after the newest retained message; undefined when none is retained */
-    latestCursor?: string;
-    /** when the newest retained message was stored; undefined when none is retained */
-    lastPublishedAt?: Date;
-};
-export type StreamCallOptions = {
-    namespace?: string;
-    cursor?: string;
-    /** ends an events() iteration cleanly, without throwing */
-    signal?: AbortSignal;
-};
+export type { StreamCallOptions, StreamTopicMetadata } from '../../../core/types';
 /**
  * StreamsClient publishes to and reads from durable topics. Unlike
  * `runs.subscribeToStream`, topics are stored, independent of any run, and
@@ -57,7 +42,16 @@ export declare class StreamsClient {
      */
     topicMetadata(topic: string, options?: Pick<StreamCallOptions, 'namespace'>): Promise<StreamTopicMetadata>;
     /**
-     * Yields topic's messages after options.cursor, or from the oldest retained.
+     * Makes events() calls without a cursor start after the topic's latest
+     * message. Readers already iterating, and any call with a cursor, are
+     * unaffected.
+     * @param topic - the topic to reset
+     * @param options - optional namespace override
+     */
+    reset(topic: string, options?: Pick<StreamCallOptions, 'namespace'>): Promise<void>;
+    /**
+     * Yields topic's messages after options.cursor, or from the oldest retained
+     * (or, once the topic is reset, after the reset).
      * If the connection drops, it resubscribes from the last message yielded, so
      * nothing is skipped or repeated. Ends when the server hangs up an idle
      * subscription, options.signal aborts, or the caller stops iterating; throws

package/v1/client/features/streams.js

@@ -216,7 +216,21 @@ class StreamsClient {
         });
     }
     /**
-     * Yields topic's messages after options.cursor, or from the oldest retained.
+     * Makes events() calls without a cursor start after the topic's latest
+     * message. Readers already iterating, and any call with a cursor, are
+     * unaffected.
+     * @param topic - the topic to reset
+     * @param options - optional namespace override
+     */
+    reset(topic, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.grpc.reset({ namespace: (_a = options === null || options === void 0 ? void 0 : options.namespace) !== null && _a !== void 0 ? _a : '', topic });
+        });
+    }
+    /**
+     * Yields topic's messages after options.cursor, or from the oldest retained
+     * (or, once the topic is reset, after the reset).
      * If the connection drops, it resubscribes from the last message yielded, so
      * nothing is skipped or repeated. Ends when the server hangs up an idle
      * subscription, options.signal aborts, or the caller stops iterating; throws

package/v1/examples/durable-streams/run.d.ts

@@ -0,0 +1,6 @@
+export declare function consume(): Promise<void>;
+export declare function publishFromAnywhere(): Promise<void>;
+export declare function resumeFromCursor(topic: string): Promise<void>;
+export declare function stopWithSignal(topic: string): Promise<void>;
+export declare function namespaces(): Promise<void>;
+export declare function resetTopic(): Promise<void>;

package/v1/examples/durable-streams/run.js

@@ -0,0 +1,192 @@
+"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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consume = consume;
+exports.publishFromAnywhere = publishFromAnywhere;
+exports.resumeFromCursor = resumeFromCursor;
+exports.stopWithSignal = stopWithSignal;
+exports.namespaces = namespaces;
+exports.resetTopic = resetTopic;
+const crypto_1 = require("crypto");
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+const decode = (payload) => new TextDecoder().decode(payload);
+function consume() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        // > Consume
+        const topic = `progress-${(0, crypto_1.randomUUID)()}`;
+        yield workflow_1.progressTask.runNoWait({ topic });
+        try {
+            for (var _d = true, _e = __asyncValues(hatchet_client_1.hatchet.streams.events(topic)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const event = _c;
+                const { step, total } = JSON.parse(decode(event.payload));
+                console.log(`step ${step} of ${total}`);
+                // the stream outlives the run, so the reader decides when it's done
+                if (step === total) {
+                    break;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        // !!
+    });
+}
+function publishFromAnywhere() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Publish from anywhere
+        yield hatchet_client_1.hatchet.streams.publish('orders', JSON.stringify({ orderId: 'ord_123', status: 'shipped' }));
+        // !!
+    });
+}
+function resumeFromCursor(topic) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_2, _b, _c, _d, e_3, _e, _f;
+        // > Resume from a cursor
+        let cursor;
+        try {
+            for (var _g = true, _h = __asyncValues(hatchet_client_1.hatchet.streams.events(topic)), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
+                _c = _j.value;
+                _g = false;
+                const event = _c;
+                console.log(decode(event.payload));
+                ({ cursor } = event);
+                break;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        try {
+            // picks up right after the last event read, even from another process
+            for (var _k = true, _l = __asyncValues(hatchet_client_1.hatchet.streams.events(topic, { cursor })), _m; _m = yield _l.next(), _d = _m.done, !_d; _k = true) {
+                _f = _m.value;
+                _k = false;
+                const event = _f;
+                console.log(decode(event.payload));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (!_k && !_d && (_e = _l.return)) yield _e.call(_l);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        // !!
+    });
+}
+function stopWithSignal(topic) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_4, _b, _c;
+        // > Stop reading
+        const controller = new AbortController();
+        setTimeout(() => controller.abort(), 10000);
+        try {
+            for (var _d = true, _e = __asyncValues(hatchet_client_1.hatchet.streams.events(topic, { signal: controller.signal })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const event = _c;
+                console.log(decode(event.payload));
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        // !!
+    });
+}
+function namespaces() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_5, _b, _c;
+        // > Namespaces
+        yield hatchet_client_1.hatchet.streams.publish('updates', 'hello', { namespace: 'customer-a' });
+        try {
+            for (var _d = true, _e = __asyncValues(hatchet_client_1.hatchet.streams.events('updates', { namespace: 'customer-a' })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const event = _c;
+                console.log(decode(event.payload));
+                break;
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        // !!
+    });
+}
+function resetTopic() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_6, _b, _c;
+        // > Reset a topic
+        yield hatchet_client_1.hatchet.streams.reset('orders');
+        try {
+            // starts after the reset; readers that were already iterating aren't affected
+            for (var _d = true, _e = __asyncValues(hatchet_client_1.hatchet.streams.events('orders')), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const event = _c;
+                console.log(decode(event.payload));
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        // !!
+    });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield consume();
+        yield publishFromAnywhere();
+        yield stopWithSignal('orders');
+        yield namespaces();
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => {
+        process.exit(0);
+    });
+}

package/v1/examples/durable-streams/worker.d.ts

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

package/v1/examples/durable-streams/worker.js

@@ -0,0 +1,24 @@
+"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 hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('durable-streams-worker', {
+            workflows: [workflow_1.progressTask, workflow_1.retryingProgressTask],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/durable-streams/workflow.d.ts

@@ -0,0 +1,9 @@
+export type ProgressInput = {
+    topic: string;
+};
+export declare const progressTask: import("../..").TaskWorkflowDeclaration<ProgressInput, {
+    steps: number;
+}, {}, {}, {}, {}>;
+export declare const retryingProgressTask: import("../..").TaskWorkflowDeclaration<ProgressInput, {
+    chunks: number;
+}, {}, {}, {}, {}>;

package/v1/examples/durable-streams/workflow.js

@@ -0,0 +1,47 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryingProgressTask = exports.progressTask = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+exports.progressTask = hatchet_client_1.hatchet.task({
+    name: 'durable-streams-progress',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const total = 5;
+        for (let step = 1; step <= total; step += 1) {
+            yield (0, sleep_1.default)(500);
+            yield hatchet_client_1.hatchet.streams.publish(input.topic, JSON.stringify({ step, total }));
+        }
+        return { steps: total };
+    }),
+});
+// !!
+// > Reset on retry
+exports.retryingProgressTask = hatchet_client_1.hatchet.task({
+    name: 'durable-streams-retrying-progress',
+    retries: 1,
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // readers that subscribe from here on skip a failed attempt's messages
+        yield hatchet_client_1.hatchet.streams.reset(input.topic);
+        for (let chunk = 0; chunk < 3; chunk += 1) {
+            yield hatchet_client_1.hatchet.streams.publish(input.topic, JSON.stringify({ attempt: ctx.retryCount(), chunk }));
+        }
+        if (ctx.retryCount() === 0) {
+            throw new Error('intentional failure before the final message');
+        }
+        yield hatchet_client_1.hatchet.streams.publish(input.topic, JSON.stringify({ done: true }));
+        return { chunks: 3 };
+    }),
+});
+// !!

package/v1/examples/durable_eviction/graceful-worker.d.ts

@@ -0,0 +1 @@
+export declare const DURABLE_WAIT_MARKED = "[e2e] durable wait marked";

package/v1/examples/durable_eviction/graceful-worker.js

@@ -0,0 +1,49 @@
+"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 });
+exports.DURABLE_WAIT_MARKED = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+exports.DURABLE_WAIT_MARKED = '[e2e] durable wait marked';
+// Worker for the graceful termination e2e test. The test must not terminate
+// this worker before the SDK has recorded the run as waiting, and nothing
+// observable outside the process marks that moment: the engine writes the
+// WAIT_FOR entry before it acks, and the SDK only calls markWaiting once the
+// ack arrives. The eviction manager is created lazily on the worker's
+// internal state, so it is wrapped on assignment to print a line the test can
+// wait for.
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('graceful-eviction-worker', {
+            workflows: [workflow_1.evictableSleepForGracefulTermination],
+        });
+        let manager;
+        Object.defineProperty(worker._internal, 'evictionManager', {
+            configurable: true,
+            enumerable: true,
+            get: () => manager,
+            set: (next) => {
+                manager = next;
+                if (!next)
+                    return;
+                const markWaiting = next.markWaiting.bind(next);
+                next.markWaiting = (key, waitKind, resourceId) => {
+                    markWaiting(key, waitKind, resourceId);
+                    console.log(`${exports.DURABLE_WAIT_MARKED} key=${key} kind=${waitKind} resource=${resourceId}`);
+                };
+            },
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/e2e-worker.js

@@ -33,24 +33,25 @@ const workflow_12 = require("./durable_event/workflow");
 const workflow_13 = require("./durable_eviction/workflow");
 const workflow_14 = require("./durable_callback_ordering/workflow");
 const workflow_15 = require("./durable_sleep/workflow");
-const workflow_16 = require("./logger/workflow");
-const workflow_17 = require("./non_retryable/workflow");
-const workflow_18 = require("./retry_after/workflow");
-const workflow_19 = require("./on_failure/workflow");
-const workflow_20 = require("./idempotency/workflow");
-const workflow_21 = require("./on_event/workflow");
-const workflow_22 = require("./return_exceptions/workflow");
-const workflow_23 = require("./run_details/workflow");
+const workflow_16 = require("./durable-streams/workflow");
+const workflow_17 = require("./logger/workflow");
+const workflow_18 = require("./non_retryable/workflow");
+const workflow_19 = require("./retry_after/workflow");
+const workflow_20 = require("./on_failure/workflow");
+const workflow_21 = require("./idempotency/workflow");
+const workflow_22 = require("./on_event/workflow");
+const workflow_23 = require("./return_exceptions/workflow");
+const workflow_24 = require("./run_details/workflow");
 const e2e_workflows_1 = require("./simple/e2e-workflows");
-const workflow_24 = require("./batch_assign/workflow");
-const workflow_25 = require("./streaming/workflow");
-const workflow_26 = require("./subscribe_to_stream/workflow");
-const workflow_27 = require("./timeout/workflow");
-const workflow_28 = require("./webhooks/workflow");
-const workflow_29 = require("./child_index/workflow");
-const workflow_30 = require("./support_agent/workflow");
-const workflow_31 = require("./welcome_email/workflow");
-const workflow_32 = require("./pdf_pipeline/workflow");
+const workflow_25 = require("./batch_assign/workflow");
+const workflow_26 = require("./streaming/workflow");
+const workflow_27 = require("./subscribe_to_stream/workflow");
+const workflow_28 = require("./timeout/workflow");
+const workflow_29 = require("./webhooks/workflow");
+const workflow_30 = require("./child_index/workflow");
+const workflow_31 = require("./support_agent/workflow");
+const workflow_32 = require("./welcome_email/workflow");
+const workflow_33 = require("./pdf_pipeline/workflow");
 const workflows = [
     workflow_1.bulkChild,
     workflow_1.bulkParentWorkflow,
@@ -91,6 +92,8 @@ const workflows = [
     workflow_14.callbackOrderingMid,
     workflow_14.callbackOrderingRoot,
     workflow_15.durableSleep,
+    workflow_16.progressTask,
+    workflow_16.retryingProgressTask,
     workflow_13.evictableSleep,
     workflow_13.evictableWaitForEvent,
     workflow_13.evictableMemoThenWaitForEvent,
@@ -100,47 +103,47 @@ const workflows = [
     workflow_13.childTask,
     workflow_13.bulkChildTask,
     workflow_13.evictableChildBulkSpawn,
-    (0, workflow_16.createLoggingWorkflow)(hatchet_client_1.hatchet),
-    workflow_17.nonRetryableWorkflow,
-    workflow_18.retryAfterUpstreamDelay,
-    workflow_18.retryAfterExponentialBackoff,
-    workflow_19.failureWorkflow,
-    workflow_20.idempotentTask,
-    workflow_20.idempotentTaskShortWindow,
-    workflow_21.lower,
-    workflow_22.returnExceptionsTask,
-    workflow_23.runDetailTestWorkflow,
+    (0, workflow_17.createLoggingWorkflow)(hatchet_client_1.hatchet),
+    workflow_18.nonRetryableWorkflow,
+    workflow_19.retryAfterUpstreamDelay,
+    workflow_19.retryAfterExponentialBackoff,
+    workflow_20.failureWorkflow,
+    workflow_21.idempotentTask,
+    workflow_21.idempotentTaskShortWindow,
+    workflow_22.lower,
+    workflow_23.returnExceptionsTask,
+    workflow_24.runDetailTestWorkflow,
     e2e_workflows_1.helloWorld,
     e2e_workflows_1.helloWorldDurable,
-    workflow_25.streamingTask,
-    workflow_26.dagStream,
-    workflow_26.longStream,
-    workflow_27.timeoutTask,
-    workflow_27.refreshTimeoutTask,
-    workflow_28.webhookWorkflow,
-    workflow_29.childIndexChild,
-    workflow_29.childIndexParent,
-    workflow_29.scenarioTask,
-    workflow_29.orchestratorTask,
-    workflow_30.supportAgent,
-    workflow_30.triageTicket,
-    workflow_30.generateReply,
-    workflow_30.escalateTicket,
-    workflow_31.welcomeEmail,
-    workflow_32.pdfPipeline,
-    workflow_24.batchSimple,
-    workflow_24.batchKeyed,
-    workflow_24.batchKeyedFailable,
-    workflow_24.batchKeyedInterval,
-    workflow_24.batchLarge,
-    workflow_24.batchSingle,
-    workflow_24.batchOrdered,
-    workflow_24.batchBroadcast,
-    workflow_24.batchCancel,
-    workflow_24.child,
-    workflow_24.childBatch,
-    workflow_24.batchChildSpawn,
-    workflow_24.batchChildBatchSpawn,
+    workflow_26.streamingTask,
+    workflow_27.dagStream,
+    workflow_27.longStream,
+    workflow_28.timeoutTask,
+    workflow_28.refreshTimeoutTask,
+    workflow_29.webhookWorkflow,
+    workflow_30.childIndexChild,
+    workflow_30.childIndexParent,
+    workflow_30.scenarioTask,
+    workflow_30.orchestratorTask,
+    workflow_31.supportAgent,
+    workflow_31.triageTicket,
+    workflow_31.generateReply,
+    workflow_31.escalateTicket,
+    workflow_32.welcomeEmail,
+    workflow_33.pdfPipeline,
+    workflow_25.batchSimple,
+    workflow_25.batchKeyed,
+    workflow_25.batchKeyedFailable,
+    workflow_25.batchKeyedInterval,
+    workflow_25.batchLarge,
+    workflow_25.batchSingle,
+    workflow_25.batchOrdered,
+    workflow_25.batchBroadcast,
+    workflow_25.batchCancel,
+    workflow_25.child,
+    workflow_25.childBatch,
+    workflow_25.batchChildSpawn,
+    workflow_25.batchChildBatchSpawn,
 ];
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.37.0";
+export declare const HATCHET_VERSION = "1.39.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.37.0';
+exports.HATCHET_VERSION = '1.39.0';