@hatchet-dev/typescript-sdk 1.36.0 → 1.38.0

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

@@ -57,7 +57,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/client/worker/engine-version.d.ts

@@ -1,5 +1,7 @@
 export declare const MinEngineVersion: {
     readonly SLOT_CONFIG: "v0.78.23";
     readonly DURABLE_EVICTION: "v0.80.0";
+    readonly RETRY_AFTER: "v0.111.0";
 };
+export declare function supportsRetryAfter(engineVersion: string | undefined): boolean;
 export declare function supportsEviction(engineVersion: string | undefined): boolean;

package/v1/client/worker/engine-version.js

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinEngineVersion = void 0;
+exports.supportsRetryAfter = supportsRetryAfter;
 exports.supportsEviction = supportsEviction;
 const deprecation_1 = require("./deprecated/deprecation");
 exports.MinEngineVersion = {
     SLOT_CONFIG: 'v0.78.23',
     DURABLE_EVICTION: 'v0.80.0',
+    RETRY_AFTER: 'v0.111.0',
 };
+function supportsRetryAfter(engineVersion) {
+    if (!engineVersion)
+        return false;
+    return !(0, deprecation_1.semverLessThan)(engineVersion, exports.MinEngineVersion.RETRY_AFTER);
+}
 function supportsEviction(engineVersion) {
     if (!engineVersion)
         return false;

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

@@ -69,6 +69,7 @@ export declare class InternalWorker {
      * Keep the signature in sync with the instrumentor wrapper.
      */
     handleStartStepRun(action: Action): Promise<Error | undefined>;
+    private retryAfterMs;
     getStepActionEvent(action: Action, eventType: StepActionEventType, shouldNotRetry: boolean, payload?: any, retryCount?: number): StepActionEvent;
     /**
      * Handles a START_BATCH action: invokes the registered batch task handler once with
@@ -88,6 +89,7 @@ export declare class InternalWorker {
     getBatchActionEvent(action: Action, eventType: StepActionEventType, items: {
         taskRunExternalId: string;
         eventPayload: string;
+        retryAfterMs?: number;
     }[]): BatchActionEvent;
     getGroupKeyActionEvent(action: Action, eventType: GroupKeyActionEventType, payload?: any): GroupKeyActionEvent;
     /**

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

@@ -349,6 +349,7 @@ class InternalWorker {
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
                     const shouldNotRetry = error instanceof task_1.NonRetryableError;
+                    const retryAfterMs = this.retryAfterMs(error, actionId);
                     try {
                         if (context.cancelled) {
                             return;
@@ -366,6 +367,7 @@ class InternalWorker {
                             message: error === null || error === void 0 ? void 0 : error.message,
                             stack: error === null || error === void 0 ? void 0 : error.stack,
                         }, action.retryCount);
+                        event.retryAfterMs = retryAfterMs;
                         yield this.client.dispatcher.sendStepActionEvent(event);
                     }
                     catch (e) {
@@ -423,6 +425,18 @@ class InternalWorker {
             }
         });
     }
+    retryAfterMs(error, actionId) {
+        var _a;
+        if (!(error instanceof task_1.RetryAfterError)) {
+            return undefined;
+        }
+        if (!(0, engine_version_1.supportsRetryAfter)(this.engineVersion)) {
+            this.logger.warn(`RetryAfterError requires engine >= ${engine_version_1.MinEngineVersion.RETRY_AFTER} ` +
+                `(connected: ${(_a = this.engineVersion) !== null && _a !== void 0 ? _a : 'unknown'}). Task ${actionId} threw it, so the engine ` +
+                `will handle the failure with the task's retry policy instead of the requested delay.`);
+        }
+        return error.afterMs;
+    }
     getStepActionEvent(action, eventType, shouldNotRetry, payload = '', retryCount = 0) {
         return {
             workerId: this.name,
@@ -518,7 +532,12 @@ class InternalWorker {
     sendBatchFailureForAll(action, memberIds, error) {
         return __awaiter(this, void 0, void 0, function* () {
             const payload = JSON.stringify({ message: error === null || error === void 0 ? void 0 : error.message, stack: error === null || error === void 0 ? void 0 : error.stack });
-            const items = memberIds.map((id) => ({ taskRunExternalId: id, eventPayload: payload }));
+            const retryAfterMs = this.retryAfterMs(error, action.actionId);
+            const items = memberIds.map((id) => ({
+                taskRunExternalId: id,
+                eventPayload: payload,
+                retryAfterMs,
+            }));
             try {
                 yield this.client.dispatcher.sendBatchActionEvent(this.getBatchActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, items));
             }

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/e2e-worker.js

@@ -33,23 +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("./on_failure/workflow");
-const workflow_19 = require("./idempotency/workflow");
-const workflow_20 = require("./on_event/workflow");
-const workflow_21 = require("./return_exceptions/workflow");
-const workflow_22 = 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_23 = require("./batch_assign/workflow");
-const workflow_24 = require("./streaming/workflow");
-const workflow_25 = require("./subscribe_to_stream/workflow");
-const workflow_26 = require("./timeout/workflow");
-const workflow_27 = require("./webhooks/workflow");
-const workflow_28 = require("./child_index/workflow");
-const workflow_29 = require("./support_agent/workflow");
-const workflow_30 = require("./welcome_email/workflow");
-const workflow_31 = 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,
@@ -90,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,
@@ -99,45 +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.failureWorkflow,
-    workflow_19.idempotentTask,
-    workflow_19.idempotentTaskShortWindow,
-    workflow_20.lower,
-    workflow_21.returnExceptionsTask,
-    workflow_22.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_24.streamingTask,
-    workflow_25.dagStream,
-    workflow_25.longStream,
-    workflow_26.timeoutTask,
-    workflow_26.refreshTimeoutTask,
-    workflow_27.webhookWorkflow,
-    workflow_28.childIndexChild,
-    workflow_28.childIndexParent,
-    workflow_28.scenarioTask,
-    workflow_28.orchestratorTask,
-    workflow_29.supportAgent,
-    workflow_29.triageTicket,
-    workflow_29.generateReply,
-    workflow_29.escalateTicket,
-    workflow_30.welcomeEmail,
-    workflow_31.pdfPipeline,
-    workflow_23.batchSimple,
-    workflow_23.batchKeyed,
-    workflow_23.batchKeyedFailable,
-    workflow_23.batchKeyedInterval,
-    workflow_23.batchLarge,
-    workflow_23.batchSingle,
-    workflow_23.batchOrdered,
-    workflow_23.batchBroadcast,
-    workflow_23.batchCancel,
-    workflow_23.child,
-    workflow_23.childBatch,
-    workflow_23.batchChildSpawn,
-    workflow_23.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/v1/examples/retry_after/run.d.ts

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

package/v1/examples/retry_after/run.js

@@ -0,0 +1,21 @@
+"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 workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.retryAfterUpstreamDelay.run({ failingAttempts: 2 });
+        console.log(res);
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/retry_after/worker.d.ts

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

package/v1/examples/retry_after/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('retry-after-worker', {
+            workflows: [workflow_1.retryAfterUpstreamDelay, workflow_1.retryAfterExponentialBackoff],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/retry_after/workflow.d.ts

@@ -0,0 +1,9 @@
+export type UpstreamInput = {
+    failingAttempts: number;
+};
+export declare const retryAfterUpstreamDelay: import("../..").TaskWorkflowDeclaration<UpstreamInput, {
+    attempt: number;
+}, {}, {}, {}, {}>;
+export declare const retryAfterExponentialBackoff: import("../..").TaskWorkflowDeclaration<UpstreamInput, {
+    attempt: number;
+}, {}, {}, {}, {}>;