@hatchet-dev/typescript-sdk 1.29.2 → 1.30.0

package/legacy/workflow.d.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod/v4';
 import { CreateStep } from '../step';
-import { ConcurrencyLimitStrategy as PbConcurrencyLimitStrategy, StickyStrategy as PbStickyStrategy } from '../protoc/workflows';
+import { ConcurrencyLimitStrategy as PbConcurrencyLimitStrategy, StickyStrategy as PbStickyStrategy } from '../protoc/v1/workflows';
 declare const StepsSchema: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     parents: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -12,7 +12,7 @@ declare const StepsSchema: z.ZodArray<z.ZodObject<{
         dynamicKey: z.ZodOptional<z.ZodString>;
         units: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
         limit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
-        duration: z.ZodOptional<z.ZodEnum<typeof import("../protoc/workflows").RateLimitDuration>>;
+        duration: z.ZodOptional<z.ZodEnum<typeof import("..").RateLimitDuration>>;
     }, z.core.$strip>>>;
     worker_labels: z.ZodOptional<z.ZodRecord<z.ZodAny, z.ZodLazy<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodObject<{
         value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
@@ -63,7 +63,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             dynamicKey: z.ZodOptional<z.ZodString>;
             units: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
             limit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
-            duration: z.ZodOptional<z.ZodEnum<typeof import("../protoc/workflows").RateLimitDuration>>;
+            duration: z.ZodOptional<z.ZodEnum<typeof import("..").RateLimitDuration>>;
         }, z.core.$strip>>>;
         worker_labels: z.ZodOptional<z.ZodRecord<z.ZodAny, z.ZodLazy<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodObject<{
             value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
@@ -87,7 +87,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             dynamicKey: z.ZodOptional<z.ZodString>;
             units: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
             limit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
-            duration: z.ZodOptional<z.ZodEnum<typeof import("../protoc/workflows").RateLimitDuration>>;
+            duration: z.ZodOptional<z.ZodEnum<typeof import("..").RateLimitDuration>>;
         }, z.core.$strip>>>;
         worker_labels: z.ZodOptional<z.ZodRecord<z.ZodAny, z.ZodLazy<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodObject<{
             value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;

package/legacy/workflow.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateWorkflowSchema = exports.StickyStrategy = exports.HatchetTimeoutSchema = exports.WorkflowConcurrency = exports.ConcurrencyLimitStrategy = void 0;
 const z = __importStar(require("zod/v4"));
 const step_1 = require("../step");
-const workflows_1 = require("../protoc/workflows");
+const workflows_1 = require("../protoc/v1/workflows");
 const CronConfigSchema = z.object({
     cron: z.string(),
     event: z.undefined().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.29.2",
+  "version": "1.30.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/protoc/v1/workflows.d.ts

@@ -48,6 +48,8 @@ export declare enum ConcurrencyLimitStrategy {
     QUEUE_NEWEST = 2,
     GROUP_ROUND_ROBIN = 3,
     CANCEL_NEWEST = 4,
+    CANCEL_QUEUED_EXCEPT_NEWEST = 5,
+    CANCEL_QUEUED_EXCEPT_OLDEST = 6,
     UNRECOGNIZED = -1
 }
 export declare function concurrencyLimitStrategyFromJSON(object: any): ConcurrencyLimitStrategy;

package/protoc/v1/workflows.js

@@ -209,6 +209,8 @@ var ConcurrencyLimitStrategy;
     ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["QUEUE_NEWEST"] = 2] = "QUEUE_NEWEST";
     ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["GROUP_ROUND_ROBIN"] = 3] = "GROUP_ROUND_ROBIN";
     ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["CANCEL_NEWEST"] = 4] = "CANCEL_NEWEST";
+    ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["CANCEL_QUEUED_EXCEPT_NEWEST"] = 5] = "CANCEL_QUEUED_EXCEPT_NEWEST";
+    ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["CANCEL_QUEUED_EXCEPT_OLDEST"] = 6] = "CANCEL_QUEUED_EXCEPT_OLDEST";
     ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(ConcurrencyLimitStrategy || (exports.ConcurrencyLimitStrategy = ConcurrencyLimitStrategy = {}));
 function concurrencyLimitStrategyFromJSON(object) {
@@ -228,6 +230,12 @@ function concurrencyLimitStrategyFromJSON(object) {
         case 4:
         case 'CANCEL_NEWEST':
             return ConcurrencyLimitStrategy.CANCEL_NEWEST;
+        case 5:
+        case 'CANCEL_QUEUED_EXCEPT_NEWEST':
+            return ConcurrencyLimitStrategy.CANCEL_QUEUED_EXCEPT_NEWEST;
+        case 6:
+        case 'CANCEL_QUEUED_EXCEPT_OLDEST':
+            return ConcurrencyLimitStrategy.CANCEL_QUEUED_EXCEPT_OLDEST;
         case -1:
         case 'UNRECOGNIZED':
         default:
@@ -246,6 +254,10 @@ function concurrencyLimitStrategyToJSON(object) {
             return 'GROUP_ROUND_ROBIN';
         case ConcurrencyLimitStrategy.CANCEL_NEWEST:
             return 'CANCEL_NEWEST';
+        case ConcurrencyLimitStrategy.CANCEL_QUEUED_EXCEPT_NEWEST:
+            return 'CANCEL_QUEUED_EXCEPT_NEWEST';
+        case ConcurrencyLimitStrategy.CANCEL_QUEUED_EXCEPT_OLDEST:
+            return 'CANCEL_QUEUED_EXCEPT_OLDEST';
         case ConcurrencyLimitStrategy.UNRECOGNIZED:
         default:
             return 'UNRECOGNIZED';

package/util/config-loader/config-loader.js

@@ -59,7 +59,7 @@ class ConfigLoader {
             port: parseInt(this.env('HATCHET_CLIENT_WORKER_HEALTHCHECK_PORT') || '8001', 10),
         };
         if (!token) {
-            throw new Error('No token provided. Provide it by setting the HATCHET_CLIENT_TOKEN environment variable.');
+            throw new Error('API token is required. Set it via the HATCHET_CLIENT_TOKEN environment variable. For local development, you can run Hatchet embedded via HatchetEmbeddedClient.init() (imported from @hatchet-dev/typescript-sdk/v1/embedded). More docs here: https://docs.hatchet.run/v1/embedded');
         }
         let grpcBroadcastAddress;
         let apiUrl;

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

@@ -5,7 +5,7 @@ import { CreateStepRateLimit } from '../../../protoc/workflows';
 import { Logger } from '../../../util/logger';
 import { BaseWorkflowDeclaration, WorkflowDefinition, HatchetClient } from '../..';
 import { TaskBatchConfig } from '../../../protoc/v1/workflows';
-import { CreateWorkflowTaskOpts } from '../../task';
+import { Concurrency, CreateWorkflowTaskOpts } from '../../task';
 import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
 import { Duration } from '../duration';
 import { Context } from './context';
@@ -113,6 +113,7 @@ export declare function mapSlotRequestsPb(task: {
     slotCost?: number;
 }, isDurable: boolean): Record<string, number>;
 export declare function mapRateLimitPb(limits: CreateWorkflowTaskOpts<any, any>['rateLimits']): CreateStepRateLimit[];
+export declare function assertValidConcurrencyArr(concurrency: Concurrency[] | undefined): void;
 export declare function mapBatchConfigPb(batch: CreateWorkflowTaskOpts<any, any>['batch']): TaskBatchConfig | undefined;
 export declare function resolveExecutionTimeout(task: {
     executionTimeout?: Duration;

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

@@ -55,6 +55,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalWorker = void 0;
 exports.mapSlotRequestsPb = mapSlotRequestsPb;
 exports.mapRateLimitPb = mapRateLimitPb;
+exports.assertValidConcurrencyArr = assertValidConcurrencyArr;
 exports.mapBatchConfigPb = mapBatchConfigPb;
 exports.resolveExecutionTimeout = resolveExecutionTimeout;
 exports.resolveScheduleTimeout = resolveScheduleTimeout;
@@ -269,6 +270,8 @@ class InternalWorker {
                 ];
                 const concurrencyArr = Array.isArray(concurrency) ? concurrency : [];
                 const concurrencySolo = !Array.isArray(concurrency) ? concurrency : undefined;
+                assertValidConcurrencyArr(concurrencyArr);
+                assertValidConcurrencyArr(concurrencySolo ? [concurrencySolo] : undefined);
                 // Convert Zod schema to JSON Schema if provided
                 let inputJsonSchema;
                 if (workflow.inputValidator) {
@@ -309,7 +312,7 @@ class InternalWorker {
                     defaultPriority: workflow.defaultPriority,
                     inputJsonSchema,
                     tasks: [...workflow._tasks, ...workflow._durableTasks].map((task) => {
-                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
                         return ({
                             readableId: task.name,
                             action: `${workflow.name}:${task.name}`,
@@ -329,15 +332,20 @@ class InternalWorker {
                             isDurable: durableTaskSet.has(task),
                             slotRequests: mapSlotRequestsPb(task, durableTaskSet.has(task)),
                             batch: mapBatchConfigPb(batchOf(task)),
-                            concurrency: task.concurrency
-                                ? Array.isArray(task.concurrency)
-                                    ? task.concurrency
-                                    : [task.concurrency]
-                                : ((_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.concurrency)
-                                    ? Array.isArray(workflow.taskDefaults.concurrency)
-                                        ? workflow.taskDefaults.concurrency
-                                        : [workflow.taskDefaults.concurrency]
-                                    : [],
+                            concurrency: (() => {
+                                var _a;
+                                const taskConcurrency = task.concurrency
+                                    ? Array.isArray(task.concurrency)
+                                        ? task.concurrency
+                                        : [task.concurrency]
+                                    : ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.concurrency)
+                                        ? Array.isArray(workflow.taskDefaults.concurrency)
+                                            ? workflow.taskDefaults.concurrency
+                                            : [workflow.taskDefaults.concurrency]
+                                        : [];
+                                assertValidConcurrencyArr(taskConcurrency);
+                                return taskConcurrency;
+                            })(),
                         });
                     }),
                     concurrency: concurrencySolo,
@@ -1096,6 +1104,13 @@ function parseBatchPayload(actionPayload) {
 function batchOf(task) {
     return 'batch' in task ? task.batch : undefined;
 }
+function assertValidConcurrencyArr(concurrency) {
+    concurrency === null || concurrency === void 0 ? void 0 : concurrency.forEach((c) => {
+        if (c.maxRuns !== undefined && (!Number.isInteger(c.maxRuns) || c.maxRuns <= 0)) {
+            throw new Error(`concurrency.maxRuns must be a positive integer when provided, got: ${c.maxRuns}`);
+        }
+    });
+}
 function mapBatchConfigPb(batch) {
     if (!batch) {
         return undefined;

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

@@ -0,0 +1,9 @@
+import type { EmptyTaskOutput } from '../concurrency-types';
+export type WorkflowInput = {
+    group: string;
+};
+export type WorkflowOutput = {
+    step1: EmptyTaskOutput;
+    step2: EmptyTaskOutput;
+};
+export declare const concurrencyCancelQueuedExceptNewestWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_cancel_queued_except_newest/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.concurrencyCancelQueuedExceptNewestWorkflow = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+// > Cancel Queued Except Newest
+exports.concurrencyCancelQueuedExceptNewestWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrencycancelqueuedexceptnewest',
+    concurrency: {
+        expression: 'input.group',
+        maxRuns: 1,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.CANCEL_QUEUED_EXCEPT_NEWEST,
+    },
+});
+// !!
+const step1 = exports.concurrencyCancelQueuedExceptNewestWorkflow.task({
+    name: 'step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});
+exports.concurrencyCancelQueuedExceptNewestWorkflow.task({
+    name: 'step2',
+    parents: [step1],
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});

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

@@ -0,0 +1,9 @@
+import type { EmptyTaskOutput } from '../concurrency-types';
+export type WorkflowInput = {
+    group: string;
+};
+export type WorkflowOutput = {
+    step1: EmptyTaskOutput;
+    step2: EmptyTaskOutput;
+};
+export declare const concurrencyCancelQueuedExceptOldestWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_cancel_queued_except_oldest/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.concurrencyCancelQueuedExceptOldestWorkflow = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+// > Cancel Queued Except Oldest
+exports.concurrencyCancelQueuedExceptOldestWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrencycancelqueuedexceptoldest',
+    concurrency: {
+        expression: 'input.group',
+        maxRuns: 1,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.CANCEL_QUEUED_EXCEPT_OLDEST,
+    },
+});
+// !!
+const step1 = exports.concurrencyCancelQueuedExceptOldestWorkflow.task({
+    name: 'step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});
+exports.concurrencyCancelQueuedExceptOldestWorkflow.task({
+    name: 'step2',
+    parents: [step1],
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});

package/v1/examples/e2e-worker.js

@@ -22,29 +22,32 @@ const cancellation_workflow_1 = require("./cancellation/cancellation-workflow");
 const complex_workflow_1 = require("./conditions/complex-workflow");
 const workflow_3 = require("./concurrency_cancel_in_progress/workflow");
 const workflow_4 = require("./concurrency_cancel_newest/workflow");
-const workflow_5 = require("./concurrency_multiple_keys/workflow");
-const workflow_6 = require("./concurrency_workflow_level/workflow");
-const workflow_7 = require("./dag/workflow");
-const workflow_8 = require("./durable/workflow");
-const workflow_9 = require("./durable_event/workflow");
-const workflow_10 = require("./durable_eviction/workflow");
-const workflow_11 = require("./durable_sleep/workflow");
-const workflow_12 = require("./logger/workflow");
-const workflow_13 = require("./non_retryable/workflow");
-const workflow_14 = require("./on_failure/workflow");
-const workflow_15 = require("./idempotency/workflow");
-const workflow_16 = require("./on_event/workflow");
-const workflow_17 = require("./return_exceptions/workflow");
-const workflow_18 = require("./run_details/workflow");
+const workflow_5 = require("./concurrency_cancel_queued_except_newest/workflow");
+const workflow_6 = require("./concurrency_cancel_queued_except_oldest/workflow");
+const workflow_7 = require("./concurrency_multiple_keys/workflow");
+const workflow_8 = require("./concurrency_workflow_level/workflow");
+const workflow_9 = require("./dag/workflow");
+const workflow_10 = require("./durable/workflow");
+const workflow_11 = require("./durable_event/workflow");
+const workflow_12 = require("./durable_eviction/workflow");
+const workflow_13 = require("./durable_sleep/workflow");
+const workflow_14 = require("./logger/workflow");
+const workflow_15 = require("./non_retryable/workflow");
+const workflow_16 = require("./on_failure/workflow");
+const workflow_17 = require("./idempotency/workflow");
+const workflow_18 = require("./on_event/workflow");
+const workflow_19 = require("./return_exceptions/workflow");
+const workflow_20 = require("./run_details/workflow");
 const e2e_workflows_1 = require("./simple/e2e-workflows");
-const workflow_19 = require("./batch_assign/workflow");
-const workflow_20 = require("./streaming/workflow");
-const workflow_21 = require("./timeout/workflow");
-const workflow_22 = require("./webhooks/workflow");
-const workflow_23 = require("./child_index/workflow");
-const workflow_24 = require("./support_agent/workflow");
-const workflow_25 = require("./welcome_email/workflow");
-const workflow_26 = require("./pdf_pipeline/workflow");
+const workflow_21 = require("./batch_assign/workflow");
+const workflow_22 = require("./streaming/workflow");
+const workflow_23 = require("./subscribe_to_stream/workflow");
+const workflow_24 = require("./timeout/workflow");
+const workflow_25 = require("./webhooks/workflow");
+const workflow_26 = require("./child_index/workflow");
+const workflow_27 = require("./support_agent/workflow");
+const workflow_28 = require("./welcome_email/workflow");
+const workflow_29 = require("./pdf_pipeline/workflow");
 const workflows = [
     workflow_1.bulkChild,
     workflow_1.bulkParentWorkflow,
@@ -55,73 +58,77 @@ const workflows = [
     complex_workflow_1.taskConditionWorkflow,
     workflow_3.concurrencyCancelInProgressWorkflow,
     workflow_4.concurrencyCancelNewestWorkflow,
-    workflow_5.concurrencyMultipleKeysWorkflow,
-    workflow_6.concurrencyWorkflowLevelWorkflow,
-    workflow_7.dag,
-    workflow_8.durableWorkflow,
-    workflow_8.waitForSleepTwice,
-    workflow_8.spawnChildTask,
-    workflow_8.durableWithSpawn,
-    workflow_8.durableWithBulkSpawn,
-    workflow_8.durableSleepEventSpawn,
-    workflow_8.durableWithExplicitSpawn,
-    workflow_8.durableNonDeterminism,
-    workflow_8.durableReplayReset,
-    workflow_8.dagChildWorkflow,
-    workflow_8.durableSpawnDag,
-    workflow_8.waitForEventLookback,
-    workflow_8.waitForOrEventLookback,
-    workflow_8.waitForTwoEventsSecondPushedFirst,
-    workflow_8.errorRaisingTask,
-    workflow_8.errorRaisingDurableParent,
-    workflow_9.durableEvent,
-    workflow_9.durableEventWithFilter,
-    workflow_11.durableSleep,
-    workflow_10.evictableSleep,
-    workflow_10.evictableWaitForEvent,
-    workflow_10.evictableChildSpawn,
-    workflow_10.multipleEviction,
-    workflow_10.nonEvictableSleep,
-    workflow_10.childTask,
-    workflow_10.bulkChildTask,
-    workflow_10.evictableChildBulkSpawn,
-    (0, workflow_12.createLoggingWorkflow)(hatchet_client_1.hatchet),
-    workflow_13.nonRetryableWorkflow,
-    workflow_14.failureWorkflow,
-    workflow_15.idempotentTask,
-    workflow_15.idempotentTaskShortWindow,
-    workflow_16.lower,
-    workflow_17.returnExceptionsTask,
-    workflow_18.runDetailTestWorkflow,
+    workflow_5.concurrencyCancelQueuedExceptNewestWorkflow,
+    workflow_6.concurrencyCancelQueuedExceptOldestWorkflow,
+    workflow_7.concurrencyMultipleKeysWorkflow,
+    workflow_8.concurrencyWorkflowLevelWorkflow,
+    workflow_9.dag,
+    workflow_10.durableWorkflow,
+    workflow_10.waitForSleepTwice,
+    workflow_10.spawnChildTask,
+    workflow_10.durableWithSpawn,
+    workflow_10.durableWithBulkSpawn,
+    workflow_10.durableSleepEventSpawn,
+    workflow_10.durableWithExplicitSpawn,
+    workflow_10.durableNonDeterminism,
+    workflow_10.durableReplayReset,
+    workflow_10.dagChildWorkflow,
+    workflow_10.durableSpawnDag,
+    workflow_10.waitForEventLookback,
+    workflow_10.waitForOrEventLookback,
+    workflow_10.waitForTwoEventsSecondPushedFirst,
+    workflow_10.errorRaisingTask,
+    workflow_10.errorRaisingDurableParent,
+    workflow_11.durableEvent,
+    workflow_11.durableEventWithFilter,
+    workflow_13.durableSleep,
+    workflow_12.evictableSleep,
+    workflow_12.evictableWaitForEvent,
+    workflow_12.evictableChildSpawn,
+    workflow_12.multipleEviction,
+    workflow_12.nonEvictableSleep,
+    workflow_12.childTask,
+    workflow_12.bulkChildTask,
+    workflow_12.evictableChildBulkSpawn,
+    (0, workflow_14.createLoggingWorkflow)(hatchet_client_1.hatchet),
+    workflow_15.nonRetryableWorkflow,
+    workflow_16.failureWorkflow,
+    workflow_17.idempotentTask,
+    workflow_17.idempotentTaskShortWindow,
+    workflow_18.lower,
+    workflow_19.returnExceptionsTask,
+    workflow_20.runDetailTestWorkflow,
     e2e_workflows_1.helloWorld,
     e2e_workflows_1.helloWorldDurable,
-    workflow_20.streamingTask,
-    workflow_21.timeoutTask,
-    workflow_21.refreshTimeoutTask,
-    workflow_22.webhookWorkflow,
-    workflow_23.childIndexChild,
-    workflow_23.childIndexParent,
-    workflow_23.scenarioTask,
-    workflow_23.orchestratorTask,
-    workflow_24.supportAgent,
-    workflow_24.triageTicket,
-    workflow_24.generateReply,
-    workflow_24.escalateTicket,
-    workflow_25.welcomeEmail,
-    workflow_26.pdfPipeline,
-    workflow_19.batchSimple,
-    workflow_19.batchKeyed,
-    workflow_19.batchKeyedFailable,
-    workflow_19.batchKeyedInterval,
-    workflow_19.batchLarge,
-    workflow_19.batchSingle,
-    workflow_19.batchOrdered,
-    workflow_19.batchBroadcast,
-    workflow_19.batchCancel,
-    workflow_19.child,
-    workflow_19.childBatch,
-    workflow_19.batchChildSpawn,
-    workflow_19.batchChildBatchSpawn,
+    workflow_22.streamingTask,
+    workflow_23.dagStream,
+    workflow_23.longStream,
+    workflow_24.timeoutTask,
+    workflow_24.refreshTimeoutTask,
+    workflow_25.webhookWorkflow,
+    workflow_26.childIndexChild,
+    workflow_26.childIndexParent,
+    workflow_26.scenarioTask,
+    workflow_26.orchestratorTask,
+    workflow_27.supportAgent,
+    workflow_27.triageTicket,
+    workflow_27.generateReply,
+    workflow_27.escalateTicket,
+    workflow_28.welcomeEmail,
+    workflow_29.pdfPipeline,
+    workflow_21.batchSimple,
+    workflow_21.batchKeyed,
+    workflow_21.batchKeyedFailable,
+    workflow_21.batchKeyedInterval,
+    workflow_21.batchLarge,
+    workflow_21.batchSingle,
+    workflow_21.batchOrdered,
+    workflow_21.batchBroadcast,
+    workflow_21.batchCancel,
+    workflow_21.child,
+    workflow_21.childBatch,
+    workflow_21.batchChildSpawn,
+    workflow_21.batchChildBatchSpawn,
 ];
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

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

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

package/v1/examples/subscribe_to_stream/worker.js

@@ -0,0 +1,25 @@
+"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('subscribe-stream-worker', {
+            workflows: [workflow_1.longStream, workflow_1.dagStream],
+            slots: 8,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

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

@@ -0,0 +1,5 @@
+export declare const STREAM_CHUNKS: string[];
+export declare const PRE_STREAM_SLEEP_MS = 2000;
+export declare const INTER_CHUNK_MS = 50;
+export declare const longStream: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;
+export declare const dagStream: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;

package/v1/examples/subscribe_to_stream/workflow.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dagStream = exports.longStream = exports.INTER_CHUNK_MS = exports.PRE_STREAM_SLEEP_MS = exports.STREAM_CHUNKS = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+exports.STREAM_CHUNKS = Array.from({ length: 20 }, (_, i) => `c${String(i).padStart(2, '0')}|`);
+exports.PRE_STREAM_SLEEP_MS = 2000;
+exports.INTER_CHUNK_MS = 50;
+exports.longStream = hatchet_client_1.hatchet.task({
+    name: 'subscribe-stream-long',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(exports.PRE_STREAM_SLEEP_MS);
+        for (const chunk of exports.STREAM_CHUNKS) {
+            yield ctx.putStream(chunk);
+            yield (0, sleep_1.default)(exports.INTER_CHUNK_MS);
+        }
+    }),
+});
+// An onFailure handler makes the run a DAG. DAG QUEUED->RUNNING used to be
+// published as workflow-run-finished, which hung up stream subscribers as
+// soon as the run started.
+exports.dagStream = hatchet_client_1.hatchet.workflow({
+    name: 'subscribe-stream-dag',
+});
+exports.dagStream.task({
+    name: 'subscribe-stream-dag',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(exports.PRE_STREAM_SLEEP_MS);
+        for (const chunk of exports.STREAM_CHUNKS) {
+            yield ctx.putStream(chunk);
+        }
+    }),
+});
+exports.dagStream.onFailure({
+    name: 'subscribe-stream-dag-on-failure',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () { }),
+});

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.29.2";
+export declare const HATCHET_VERSION = "1.30.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.29.2';
+exports.HATCHET_VERSION = '1.30.0';