@hatchet-dev/typescript-sdk 1.13.1 → 1.14.0

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

@@ -1,10 +1,8 @@
 import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
-import { LegacyHatchetClient } from '../../../clients/hatchet-client';
-import { Workflow as V0Workflow } from '../../../workflow';
-import { WebhookWorkerCreateRequest } from '../../../clients/rest/generated/data-contracts';
 import { BaseWorkflowDeclaration } from '../../declaration';
+import type { LegacyWorkflow } from '../../../legacy/legacy-transformer';
 import { HatchetClient } from '../..';
-import { V1Worker } from './worker-internal';
+import { InternalWorker } from './worker-internal';
 import { type WorkerSlotOptions } from './slot-utils';
 /**
  * Options for creating a new hatchet worker
@@ -23,9 +21,8 @@ export declare class Worker {
     config: CreateWorkerOpts;
     name: string;
     _v1: HatchetClient;
-    _v0: LegacyHatchetClient;
     /** Internal reference to the underlying V0 worker implementation */
-    _internal: V1Worker;
+    _internal: InternalWorker;
     /** Set when connected to a legacy engine that needs dual-worker architecture */
     private _legacyWorker;
     /** Tracks all workflows registered after construction (via registerWorkflow/registerWorkflows) */
@@ -34,27 +31,31 @@ export declare class Worker {
      * Creates a new HatchetWorker instance
      * @param nonDurable - The V0 worker implementation
      */
-    constructor(v1: HatchetClient, v0: LegacyHatchetClient, nonDurable: V1Worker, config: CreateWorkerOpts, name: string);
+    constructor(v1: HatchetClient, nonDurable: InternalWorker, config: CreateWorkerOpts, name: string);
     /**
      * Creates and initializes a new HatchetWorker
      * @param v0 - The HatchetClient instance
      * @param options - Worker creation options
      * @returns A new HatchetWorker instance
      */
-    static create(v1: HatchetClient, v0: LegacyHatchetClient, name: string, options: CreateWorkerOpts): Promise<Worker>;
+    static create(v1: HatchetClient, name: string, options: CreateWorkerOpts): Promise<Worker>;
     /**
-     * Registers workflows with the worker
+     * Registers workflows with the worker.
+     * Accepts both v1 BaseWorkflowDeclaration and legacy Workflow objects.
+     * Legacy workflows are automatically transformed and a deprecation warning is emitted.
      * @param workflows - Array of workflows to register
      * @returns Array of registered workflow promises
      */
-    registerWorkflows(workflows?: Array<BaseWorkflowDeclaration<any, any> | V0Workflow>): Promise<void>;
+    registerWorkflows(workflows?: Array<BaseWorkflowDeclaration<any, any> | LegacyWorkflow>): Promise<void>;
     /**
-     * Registers a single workflow with the worker
+     * Registers a single workflow with the worker.
+     * Accepts both v1 BaseWorkflowDeclaration and legacy Workflow objects.
+     * Legacy workflows are automatically transformed and a deprecation warning is emitted.
      * @param workflow - The workflow to register
      * @returns A promise that resolves when the workflow is registered
      * @deprecated use registerWorkflows instead
      */
-    registerWorkflow(workflow: BaseWorkflowDeclaration<any, any> | V0Workflow): Promise<void>;
+    registerWorkflow(workflow: BaseWorkflowDeclaration<any, any> | LegacyWorkflow): Promise<void>;
     /**
      * Starts the worker
      * @returns Promise that resolves when the worker is stopped or killed
@@ -76,14 +77,13 @@ export declare class Worker {
      * @returns The labels for the worker
      */
     getLabels(): WorkerLabels;
-    /**
-     * Register a webhook with the worker
-     * @param webhook - The webhook to register
-     * @returns A promise that resolves when the webhook is registered
-     */
-    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any, {}>>;
     isPaused(): Promise<boolean>;
     pause(): Promise<void> | Promise<import("../../../clients/rest/generated/data-contracts").Worker>;
     unpause(): Promise<void> | Promise<import("../../../clients/rest/generated/data-contracts").Worker>;
+    /**
+     * Waits until the worker has connected and registered with the server.
+     * Polls every 200ms. Use after start() to avoid fixed sleeps before running workflows.
+     */
+    waitUntilReady(timeoutMs?: number): Promise<void>;
 }
 export { testingExports as __testing } from './slot-utils';

package/v1/client/worker/worker.js

@@ -8,9 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.__testing = exports.Worker = void 0;
-const declaration_1 = require("../../declaration");
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const legacy_transformer_1 = require("../../../legacy/legacy-transformer");
 const worker_internal_1 = require("./worker-internal");
 const slot_utils_1 = require("./slot-utils");
 const deprecated_1 = require("./deprecated");
@@ -22,11 +26,10 @@ class Worker {
      * Creates a new HatchetWorker instance
      * @param nonDurable - The V0 worker implementation
      */
-    constructor(v1, v0, nonDurable, config, name) {
+    constructor(v1, nonDurable, config, name) {
         /** Tracks all workflows registered after construction (via registerWorkflow/registerWorkflows) */
         this._registeredWorkflows = [];
         this._v1 = v1;
-        this._v0 = v0;
         this._internal = nonDurable;
         this.config = config;
         this.name = name;
@@ -37,41 +40,40 @@ class Worker {
      * @param options - Worker creation options
      * @returns A new HatchetWorker instance
      */
-    static create(v1, v0, name, options) {
+    static create(v1, name, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const resolvedOptions = (0, slot_utils_1.resolveWorkerOptions)(options);
+            // Normalize any legacy workflows before resolving worker options
+            const normalizedOptions = Object.assign(Object.assign({}, options), { workflows: options.workflows ? (0, legacy_transformer_1.normalizeWorkflows)(options.workflows) : undefined });
+            const resolvedOptions = (0, slot_utils_1.resolveWorkerOptions)(normalizedOptions);
             const opts = Object.assign({ name }, resolvedOptions);
-            const internalWorker = new worker_internal_1.V1Worker(v1, opts);
-            const worker = new Worker(v1, v0, internalWorker, options, name);
-            yield worker.registerWorkflows(options.workflows);
+            const internalWorker = new worker_internal_1.InternalWorker(v1, opts);
+            const worker = new Worker(v1, internalWorker, normalizedOptions, name);
+            yield worker.registerWorkflows(normalizedOptions.workflows);
             return worker;
         });
     }
     /**
-     * Registers workflows with the worker
+     * Registers workflows with the worker.
+     * Accepts both v1 BaseWorkflowDeclaration and legacy Workflow objects.
+     * Legacy workflows are automatically transformed and a deprecation warning is emitted.
      * @param workflows - Array of workflows to register
      * @returns Array of registered workflow promises
      */
     registerWorkflows(workflows) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const wf of workflows || []) {
-                this._registeredWorkflows.push(wf);
-                if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
-                    // TODO check if tenant is V1
-                    yield this._internal.registerWorkflowV1(wf);
-                    if (wf.definition._durableTasks.length > 0) {
-                        this._internal.registerDurableActionsV1(wf.definition);
-                    }
-                }
-                else {
-                    // fallback to v0 client for backwards compatibility
-                    yield this._internal.registerWorkflow(wf);
+            const normalized = workflows ? (0, legacy_transformer_1.normalizeWorkflows)(workflows) : [];
+            for (const wf of normalized) {
+                yield this._internal.registerWorkflow(wf);
+                if (wf.definition._durableTasks.length > 0) {
+                    this._internal.registerDurableActions(wf.definition);
                 }
             }
         });
     }
     /**
-     * Registers a single workflow with the worker
+     * Registers a single workflow with the worker.
+     * Accepts both v1 BaseWorkflowDeclaration and legacy Workflow objects.
+     * Legacy workflows are automatically transformed and a deprecation warning is emitted.
      * @param workflow - The workflow to register
      * @returns A promise that resolves when the workflow is registered
      * @deprecated use registerWorkflows instead
@@ -123,14 +125,6 @@ class Worker {
     getLabels() {
         return this._internal.labels;
     }
-    /**
-     * Register a webhook with the worker
-     * @param webhook - The webhook to register
-     * @returns A promise that resolves when the webhook is registered
-     */
-    registerWebhook(webhook) {
-        return this._internal.registerWebhook(webhook);
-    }
     isPaused() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -155,6 +149,27 @@ class Worker {
         }
         return this._v1.workers.unpause(this._internal.workerId);
     }
+    /**
+     * Waits until the worker has connected and registered with the server.
+     * Polls every 200ms. Use after start() to avoid fixed sleeps before running workflows.
+     */
+    waitUntilReady() {
+        return __awaiter(this, arguments, void 0, function* (timeoutMs = 10000) {
+            var _a;
+            if (this._legacyWorker) {
+                yield (0, sleep_1.default)(2000);
+                return;
+            }
+            const pollInterval = 200;
+            const start = Date.now();
+            while (Date.now() - start < timeoutMs) {
+                if ((_a = this._internal) === null || _a === void 0 ? void 0 : _a.workerId)
+                    return;
+                yield (0, sleep_1.default)(pollInterval);
+            }
+            throw new Error(`Worker ${this.name} did not become ready within ${timeoutMs}ms`);
+        });
+    }
 }
 exports.Worker = Worker;
 var slot_utils_2 = require("./slot-utils");

package/v1/declaration.d.ts

@@ -1,6 +1,5 @@
 import WorkflowRunRef from '../util/workflow-run-ref';
 import { CronWorkflows, ScheduledWorkflows, V1CreateFilterRequest } from '../clients/rest/generated/data-contracts';
-import { Workflow as WorkflowV0 } from '../workflow';
 import { z } from 'zod';
 import { IHatchetClient } from './client/client.interface';
 import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn } from './task';
@@ -41,6 +40,12 @@ export type RunOpts = {
      * only used if spawned from within a parent task.
      */
     childKey?: string;
+    /**
+     * (optional) when running multiple workflows (array input), if true, return
+     * exceptions in the result array instead of throwing. Successes are outputs,
+     * failures are Error instances.
+     */
+    returnExceptions?: boolean;
 };
 /**
  * Helper type to safely extract output types from task results
@@ -51,28 +56,44 @@ export type TaskOutput<O, Key extends string, Fallback> = O extends Record<Key,
  */
 export type TaskOutputType<O, TaskName extends string, InferredType extends OutputType> = TaskName extends keyof O ? O[TaskName] extends OutputType ? O[TaskName] : InferredType : InferredType;
 type DefaultFilter = Omit<V1CreateFilterRequest, 'workflowId'>;
+/**
+ * Sticky strategy for workflow scheduling.
+ *
+ * Prefer using `StickyStrategy.SOFT` / `StickyStrategy.HARD` (v1, non-protobuf).
+ * For backwards compatibility, the workflow/task `sticky` field also accepts legacy
+ * protobuf enum values (`0`/`1`) and strings (`'SOFT'`/`'HARD'`).
+ */
+export declare const StickyStrategy: {
+    readonly SOFT: "soft";
+    readonly HARD: "hard";
+};
+export type StickyStrategy = (typeof StickyStrategy)[keyof typeof StickyStrategy];
+export type StickyStrategyInput = StickyStrategy | 'SOFT' | 'HARD' | 0 | 1;
 export type CreateBaseWorkflowOpts = {
     /**
      * The name of the workflow.
      */
-    name: WorkflowV0['id'];
+    name: string;
     /**
      * (optional) description of the workflow.
      */
-    description?: WorkflowV0['description'];
+    description?: string;
     /**
      * (optional) version of the workflow.
      */
-    version?: WorkflowV0['version'];
+    version?: string;
     /**
      * (optional) sticky strategy for the workflow.
      */
-    sticky?: WorkflowV0['sticky'];
+    sticky?: StickyStrategyInput;
     /**
      * (optional) on config for the workflow.
-     * @deprecated use onCrons and onEvents instead
+     * @alias for onCrons and onEvents
      */
-    on?: WorkflowV0['on'];
+    on?: {
+        cron?: string | string[];
+        event?: string | string[];
+    };
     /**
      * (optional) cron config for the workflow.
      */

package/v1/declaration.js

@@ -9,10 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskWorkflowDeclaration = exports.WorkflowDeclaration = exports.BaseWorkflowDeclaration = exports.Priority = void 0;
+exports.TaskWorkflowDeclaration = exports.WorkflowDeclaration = exports.BaseWorkflowDeclaration = exports.StickyStrategy = exports.Priority = void 0;
 exports.CreateTaskWorkflow = CreateTaskWorkflow;
 exports.CreateWorkflow = CreateWorkflow;
 exports.CreateDurableTaskWorkflow = CreateDurableTaskWorkflow;
+const abort_error_1 = require("../util/abort-error");
 const parent_run_context_vars_1 = require("./parent-run-context-vars");
 const UNBOUND_ERR = new Error('workflow unbound to hatchet client, hint: use client.run instead');
 // eslint-disable-next-line no-shadow
@@ -22,6 +23,17 @@ var Priority;
     Priority[Priority["MEDIUM"] = 2] = "MEDIUM";
     Priority[Priority["HIGH"] = 3] = "HIGH";
 })(Priority || (exports.Priority = Priority = {}));
+/**
+ * Sticky strategy for workflow scheduling.
+ *
+ * Prefer using `StickyStrategy.SOFT` / `StickyStrategy.HARD` (v1, non-protobuf).
+ * For backwards compatibility, the workflow/task `sticky` field also accepts legacy
+ * protobuf enum values (`0`/`1`) and strings (`'SOFT'`/`'HARD'`).
+ */
+exports.StickyStrategy = {
+    SOFT: 'soft',
+    HARD: 'hard',
+};
 /**
  * Represents a workflow that can be executed by Hatchet.
  * @template I The input type for the workflow.
@@ -48,7 +60,18 @@ class BaseWorkflowDeclaration {
             if (!parentRunContext && ((options === null || options === void 0 ? void 0 : options.childKey) || (options === null || options === void 0 ? void 0 : options.sticky))) {
                 this.client.admin.logger.warn('ignoring childKey or sticky because run is not being spawned from a parent task');
             }
-            const runOpts = Object.assign(Object.assign({}, options), { parentId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentId, parentTaskRunExternalId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentTaskRunExternalId, childIndex: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.childIndex, sticky: (options === null || options === void 0 ? void 0 : options.sticky) ? parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.desiredWorkerId : undefined, childKey: options === null || options === void 0 ? void 0 : options.childKey });
+            const inheritedSignal = parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.signal;
+            // Precheck: if we're being called from a cancelled parent task, do not enqueue more work.
+            // The signal is inherited from the parent task's `ctx.abortController.signal`.
+            (0, abort_error_1.throwIfAborted)(inheritedSignal, {
+                isTrigger: true,
+                context: (parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentTaskRunExternalId)
+                    ? `task run ${parentRunContext.parentTaskRunExternalId}`
+                    : undefined,
+                warn: (message) => this.client.admin.logger.warn(message),
+            });
+            parent_run_context_vars_1.parentRunContextManager.incrementChildIndex(Array.isArray(input) ? input.length : 1);
+            const runOpts = Object.assign(Object.assign({}, (options !== null && options !== void 0 ? options : {})), { parentId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentId, parentTaskRunExternalId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentTaskRunExternalId, childIndex: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.childIndex, sticky: (options === null || options === void 0 ? void 0 : options.sticky) ? parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.desiredWorkerId : undefined, childKey: options === null || options === void 0 ? void 0 : options.childKey });
             if (Array.isArray(input)) {
                 let resp = [];
                 for (let i = 0; i < input.length; i += 500) {
@@ -74,6 +97,9 @@ class BaseWorkflowDeclaration {
                         // eslint-disable-next-line no-param-reassign
                         ref._standaloneTaskName = _standaloneTaskName;
                     }
+                    // Ensure result subscriptions inherit cancellation if no signal is provided explicitly.
+                    // eslint-disable-next-line no-param-reassign
+                    ref.defaultSignal = inheritedSignal;
                     res.push(ref);
                 });
                 return res;
@@ -82,6 +108,7 @@ class BaseWorkflowDeclaration {
             if (_standaloneTaskName) {
                 res._standaloneTaskName = _standaloneTaskName;
             }
+            res.defaultSignal = inheritedSignal;
             return res;
         });
     }
@@ -103,6 +130,17 @@ class BaseWorkflowDeclaration {
             }
             if (Array.isArray(input)) {
                 const refs = yield this.runNoWait(input, options, _standaloneTaskName);
+                if (options === null || options === void 0 ? void 0 : options.returnExceptions) {
+                    const settled = yield Promise.allSettled(refs.map((ref) => ref.result()));
+                    return settled.map((s) => {
+                        if (s.status === 'fulfilled')
+                            return s.value;
+                        const { reason } = s;
+                        if (reason instanceof Error)
+                            return reason;
+                        return new Error(Array.isArray(reason) ? reason.join('; ') : String(reason));
+                    });
+                }
                 return Promise.all(refs.map((ref) => ref.result()));
             }
             const res = yield this.runNoWait(input, options, _standaloneTaskName);
@@ -119,10 +157,16 @@ class BaseWorkflowDeclaration {
      */
     schedule(enqueueAt, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
-            const scheduled = this.client.scheduled.create(this.definition.name, Object.assign({ triggerAt: enqueueAt, input: input }, options));
+            // If called from within a cancelled parent task, do not enqueue scheduled work.
+            (0, abort_error_1.throwIfAborted)((_a = parent_run_context_vars_1.parentRunContextManager.getContext()) === null || _a === void 0 ? void 0 : _a.signal, {
+                isTrigger: true,
+                warn: (message) => this.client.admin.logger.warn(message),
+            });
+            const scheduled = this.client.scheduled.create(this.definition.name, Object.assign({ triggerAt: enqueueAt, input: input }, (options !== null && options !== void 0 ? options : {})));
             return scheduled;
         });
     }
@@ -152,10 +196,16 @@ class BaseWorkflowDeclaration {
      */
     cron(name, expression, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
-            const cronDef = this.client.crons.create(this.definition.name, Object.assign(Object.assign({ expression, input: input }, options), { additionalMetadata: options === null || options === void 0 ? void 0 : options.additionalMetadata, name }));
+            // If called from within a cancelled parent task, do not enqueue cron work.
+            (0, abort_error_1.throwIfAborted)((_a = parent_run_context_vars_1.parentRunContextManager.getContext()) === null || _a === void 0 ? void 0 : _a.signal, {
+                isTrigger: true,
+                warn: (message) => this.client.admin.logger.warn(message),
+            });
+            const cronDef = this.client.crons.create(this.definition.name, Object.assign(Object.assign({ expression, input: input }, (options !== null && options !== void 0 ? options : {})), { additionalMetadata: options === null || options === void 0 ? void 0 : options.additionalMetadata, name }));
             return cronDef;
         });
     }
@@ -283,7 +333,7 @@ class WorkflowDeclaration extends BaseWorkflowDeclaration {
             typedOptions = options;
         }
         if (this.definition.onFailure) {
-            (_a = this.client) === null || _a === void 0 ? void 0 : _a._v0.logger.warn(`onFailure task will override existing onFailure task`);
+            (_a = this.client) === null || _a === void 0 ? void 0 : _a.logger.warn(`onFailure task will override existing onFailure task`);
         }
         this.definition.onFailure = typedOptions;
         return typedOptions;
@@ -306,7 +356,7 @@ class WorkflowDeclaration extends BaseWorkflowDeclaration {
             typedOptions = options;
         }
         if (this.definition.onSuccess) {
-            (_a = this.client) === null || _a === void 0 ? void 0 : _a._v0.logger.warn(`onSuccess task will override existing onSuccess task`);
+            (_a = this.client) === null || _a === void 0 ? void 0 : _a.logger.warn(`onSuccess task will override existing onSuccess task`);
         }
         this.definition.onSuccess = typedOptions;
         return typedOptions;

package/v1/examples/__e2e__/harness.d.ts

@@ -0,0 +1,19 @@
+import { HatchetClient } from '../..';
+import type { BaseWorkflowDeclaration } from '../..';
+import { Worker } from '../../client/worker/worker';
+export declare function requireEnv(name: string): string;
+export declare function makeE2EClient(): HatchetClient;
+export declare function makeTestScope(prefix?: string): string;
+export declare function startWorker({ client, name, workflows, slots, }: {
+    client: HatchetClient;
+    name: string;
+    workflows: Array<BaseWorkflowDeclaration<any, any>>;
+    slots?: number;
+}): Promise<Worker>;
+export declare function stopWorker(worker: Worker | undefined): Promise<void>;
+export declare function poll<T>(fn: () => Promise<T>, { timeoutMs, intervalMs, shouldStop, label, }: {
+    timeoutMs?: number;
+    intervalMs?: number;
+    shouldStop: (value: T) => boolean;
+    label?: string;
+}): Promise<T>;

package/v1/examples/__e2e__/harness.js

@@ -0,0 +1,70 @@
+"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.requireEnv = requireEnv;
+exports.makeE2EClient = makeE2EClient;
+exports.makeTestScope = makeTestScope;
+exports.startWorker = startWorker;
+exports.stopWorker = stopWorker;
+exports.poll = poll;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const crypto_1 = require("crypto");
+const v1_1 = require("../..");
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        throw new Error(`Missing required environment variable ${name}. ` +
+            `E2E tests require a configured Hatchet instance and credentials.`);
+    }
+    return value;
+}
+function makeE2EClient() {
+    // ConfigLoader requires a token; this makes the failure message obvious.
+    requireEnv('HATCHET_CLIENT_TOKEN');
+    return v1_1.HatchetClient.init();
+}
+function makeTestScope(prefix = 'ts_e2e') {
+    return `${prefix}_${(0, crypto_1.randomUUID)()}`;
+}
+function startWorker(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ client, name, workflows, slots = 50, }) {
+        const worker = yield client.worker(name, { workflows, slots });
+        void worker.start();
+        yield worker.waitUntilReady(10000);
+        return worker;
+    });
+}
+function stopWorker(worker) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!worker)
+            return;
+        yield worker.stop();
+        yield (0, sleep_1.default)(300);
+    });
+}
+function poll(fn_1, _a) {
+    return __awaiter(this, arguments, void 0, function* (fn, { timeoutMs = 30000, intervalMs = 100, shouldStop, label = 'poll', }) {
+        const start = Date.now();
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const value = yield fn();
+            if (shouldStop(value))
+                return value;
+            if (Date.now() - start > timeoutMs) {
+                throw new Error(`Timed out waiting for ${label} after ${timeoutMs}ms`);
+            }
+            yield (0, sleep_1.default)(intervalMs);
+        }
+    });
+}

package/v1/examples/affinity/affinity-workers.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const workflows_1 = require("../../../protoc/workflows");
+const v1_1 = require("../..");
 const hatchet_client_1 = require("../hatchet-client");
 // > AffinityWorkflow
 const workflow = hatchet_client_1.hatchet.workflow({
@@ -22,8 +22,8 @@ workflow.task({
         const results = [];
         // eslint-disable-next-line no-plusplus
         for (let i = 0; i < 50; i++) {
-            const result = yield ctx.spawnWorkflow(childWorkflow.id, {});
-            results.push(result.output);
+            const result = yield childWorkflow.run({});
+            results.push(result);
         }
         console.log('Spawned 50 child workflows');
         console.log('Results:', yield Promise.all(results));
@@ -55,7 +55,7 @@ childWorkflow.task({
         memory: {
             value: 512,
             required: true,
-            comparator: workflows_1.WorkerLabelComparator.LESS_THAN,
+            comparator: v1_1.WorkerLabelComparator.LESS_THAN,
         },
     },
     fn: (ctx) => __awaiter(void 0, void 0, void 0, function* () {

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

@@ -0,0 +1,9 @@
+export type ParentInput = {
+    n: number;
+};
+export declare const bulkChild: import("../..").TaskWorkflowDeclaration<{
+    i: number;
+}, {
+    i: number;
+}, {}, {}, {}, {}>;
+export declare const bulkParentWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;

package/v1/examples/bulk_fanout/workflow.js

@@ -0,0 +1,34 @@
+"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.bulkParentWorkflow = exports.bulkChild = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+exports.bulkChild = hatchet_client_1.hatchet.task({
+    name: 'bulk-child',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { i: input.i };
+    }),
+});
+exports.bulkParentWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'bulk-parent',
+});
+exports.bulkParentWorkflow.task({
+    name: 'spawn',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const typed = input;
+        const children = Array.from({ length: typed.n }, (_, i) => ({
+            workflow: exports.bulkChild,
+            input: { i },
+        }));
+        const results = yield ctx.bulkRunChildren(children);
+        return { results };
+    }),
+});

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

@@ -0,0 +1,3 @@
+export declare const bulkReplayTest1: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;
+export declare const bulkReplayTest2: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;
+export declare const bulkReplayTest3: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;

package/v1/examples/bulk_operations/workflow.js

@@ -0,0 +1,44 @@
+"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.bulkReplayTest3 = exports.bulkReplayTest2 = exports.bulkReplayTest1 = void 0;
+/* eslint-disable no-console */
+const hatchet_client_1 = require("../hatchet-client");
+exports.bulkReplayTest1 = hatchet_client_1.hatchet.task({
+    name: 'bulk-replay-test-1',
+    retries: 1,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('retrying bulk replay test task', ctx.retryCount());
+        if (ctx.retryCount() === 0) {
+            throw new Error('This is a test error to trigger a retry.');
+        }
+    }),
+});
+exports.bulkReplayTest2 = hatchet_client_1.hatchet.task({
+    name: 'bulk-replay-test-2',
+    retries: 1,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('retrying bulk replay test task', ctx.retryCount());
+        if (ctx.retryCount() === 0) {
+            throw new Error('This is a test error to trigger a retry.');
+        }
+    }),
+});
+exports.bulkReplayTest3 = hatchet_client_1.hatchet.task({
+    name: 'bulk-replay-test-3',
+    retries: 1,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('retrying bulk replay test task', ctx.retryCount());
+        if (ctx.retryCount() === 0) {
+            throw new Error('This is a test error to trigger a retry.');
+        }
+    }),
+});

package/v1/examples/cancellation/cancellation-workflow.d.ts

@@ -0,0 +1,2 @@
+export declare const cancellationWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;
+export declare const abortSignal: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;