@hatchet-dev/typescript-sdk 1.20.0 → 1.21.0

package/package.json

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

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

@@ -81,8 +81,10 @@ export declare class Context<T, K = {}> {
     worker: ContextWorker;
     overridesData: Record<string, any>;
     _logger: Logger;
+    /** @deprecated — kept for backward compat; prefer {@link nextChildIndex}. */
     spawnIndex: number;
     streamIndex: number;
+    protected nextChildIndex(n?: number): number;
     constructor(action: Action, v1: HatchetClient, worker: InternalWorker);
     get abortController(): AbortController;
     get cancelled(): boolean;

package/v1/client/worker/context.js

@@ -30,6 +30,7 @@ const transformer_1 = require("../../conditions/transformer");
 const condition_1 = require("../../../protoc/v1/shared/condition");
 const apply_namespace_1 = require("../../../util/apply-namespace");
 const abort_error_1 = require("../../../util/abort-error");
+const parent_run_context_vars_1 = require("../../parent-run-context-vars");
 const crypto_1 = require("crypto");
 const duration_1 = require("../duration");
 const engine_version_1 = require("./engine-version");
@@ -74,10 +75,19 @@ class ContextWorker {
 }
 exports.ContextWorker = ContextWorker;
 class Context {
+    nextChildIndex(n = 1) {
+        var _a;
+        const ctx = parent_run_context_vars_1.parentRunContextManager.getContext();
+        const idx = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.childIndex) !== null && _a !== void 0 ? _a : this.spawnIndex;
+        parent_run_context_vars_1.parentRunContextManager.incrementChildIndex(n);
+        this.spawnIndex = idx + n;
+        return idx;
+    }
     constructor(action, v1, worker) {
         // @deprecated use ctx.abortController instead
         this.controller = new AbortController();
         this.overridesData = {};
+        /** @deprecated — kept for backward compat; prefer {@link nextChildIndex}. */
         this.spawnIndex = 0;
         this.streamIndex = 0;
         try {
@@ -379,8 +389,8 @@ class Context {
             throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${workflowName} is not registered on the worker`);
         }
         const { workflowRunId, taskRunExternalId } = this.action;
-        const finalOpts = Object.assign(Object.assign({}, opts), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, childKey: options === null || options === void 0 ? void 0 : options.key, desiredWorkerId: sticky ? this.worker.id() : undefined, _standaloneTaskName: workflow instanceof declaration_1.TaskWorkflowDeclaration ? workflow._standalone_task_name : undefined });
-        this.spawnIndex += 1;
+        const childIndex = this.nextChildIndex();
+        const finalOpts = Object.assign(Object.assign({}, opts), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex, childKey: options === null || options === void 0 ? void 0 : options.key, desiredWorkerId: sticky ? this.worker.id() : undefined, _standaloneTaskName: workflow instanceof declaration_1.TaskWorkflowDeclaration ? workflow._standalone_task_name : undefined });
         return { workflowName, opts: finalOpts };
     }
     spawn(workflow, input, options) {
@@ -561,12 +571,12 @@ class Context {
                 // `signal` must never be sent over the wire.
                 const optsWithoutSignal = Object.assign({}, opts);
                 delete optsWithoutSignal.signal;
+                const childIndex = this.nextChildIndex();
                 const resp = {
                     workflowName: name,
                     input,
-                    options: Object.assign(Object.assign({}, optsWithoutSignal), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }),
+                    options: Object.assign(Object.assign({}, optsWithoutSignal), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }),
                 };
-                this.spawnIndex += 1;
                 return resp;
             });
             try {
@@ -614,8 +624,8 @@ class Context {
                 throw new hatchet_error_1.default(`cannot run with sticky: workflow ${name} is not registered on the worker`);
             }
             try {
-                const resp = yield this.v1.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
-                this.spawnIndex += 1;
+                const childIndex = this.nextChildIndex();
+                const resp = yield this.v1.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
                 if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
                     resp._standaloneTaskName = workflow._standalone_task_name;
                 }
@@ -805,12 +815,13 @@ class DurableContext extends Context {
             workflowName = workflow.name;
         }
         workflowName = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace).toLowerCase();
+        const childIndex = this.nextChildIndex();
         const triggerOpts = {
             name: workflowName,
             input: JSON.stringify(input || {}),
             parentId: this.action.workflowRunId,
             parentTaskRunExternalId: this.action.taskRunExternalId,
-            childIndex: this.spawnIndex,
+            childIndex,
             childKey: options === null || options === void 0 ? void 0 : options.key,
             additionalMetadata: (options === null || options === void 0 ? void 0 : options.additionalMetadata)
                 ? JSON.stringify(options.additionalMetadata)
@@ -819,7 +830,6 @@ class DurableContext extends Context {
             priority: options === null || options === void 0 ? void 0 : options.priority,
             desiredWorkerLabels: {},
         };
-        this.spawnIndex += 1;
         return { workflowName, triggerOpts };
     }
     /**

package/v1/declaration.d.ts

@@ -65,6 +65,10 @@ export type RunOpts = {
         comparator?: WorkerLabelComparator;
     }>;
 };
+export type RunManyOpt<I extends InputType = UnknownInputType> = {
+    input: I;
+    opts?: RunOpts;
+};
 /**
  * Helper type to safely extract output types from task results
  * @hidden
@@ -263,6 +267,13 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      */
     runNoWait(input: I, options?: RunOpts, _standaloneTaskName?: string): Promise<WorkflowRunRef<O>>;
     runNoWait(input: I[], options?: RunOpts, _standaloneTaskName?: string): Promise<WorkflowRunRef<O>[]>;
+    /**
+     * Synchronously trigger multiple workflow runs without waiting for completion.
+     * @param runs A list of run requests containing input and per-run options.
+     * @returns WorkflowRunRef values in the same order as input runs.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    runManyNoWait(runs: RunManyOpt<I>[], _standaloneTaskName?: string): Promise<WorkflowRunRef<O>[]>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -283,6 +294,12 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      */
     run(input: I, options?: RunOpts, _standaloneTaskName?: string): Promise<O>;
     run(input: I[], options?: RunOpts, _standaloneTaskName?: string): Promise<O[]>;
+    /**
+     * Executes many workflow runs and waits for all results.
+     * @param runs A list of run requests containing input and per-run options.
+     * @returns Results in the same order as input runs.
+     */
+    runMany(runs: RunManyOpt<I>[], _standaloneTaskName?: string): Promise<O[]>;
     /**
      * Schedules a workflow to run at a specific date and time in the future.
      * @param enqueueAt The date when the workflow should be triggered.
@@ -376,6 +393,7 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
  * - Scheduled execution with `schedule()`
  * - Cron-based recurring execution with `cron()`
  * - Bulk execution by passing an array input to `run()` and `runNoWait()`
+ * - Per-run bulk execution options with `runMany()` and `runManyNoWait()`
  *
  * Tasks within workflows can be defined with `workflow.task()` or
  * `workflow.durableTask()` and arranged into complex dependency patterns.
@@ -484,6 +502,18 @@ export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputT
      */
     runNoWait(input: I & GlobalInput, options?: RunOpts): Promise<WorkflowRunRef<O & Resolved<GlobalOutput, MiddlewareAfter>>>;
     runNoWait(input: (I & GlobalInput)[], options?: RunOpts): Promise<WorkflowRunRef<O & Resolved<GlobalOutput, MiddlewareAfter>>[]>;
+    /**
+     * Triggers many task runs and waits for all results.
+     * @param runs - The list of inputs and optional per-run options.
+     * @returns A promise that resolves with ordered task outputs.
+     */
+    runMany(runs: RunManyOpt<I & GlobalInput>[]): Promise<(O & Resolved<GlobalOutput, MiddlewareAfter>)[]>;
+    /**
+     * Triggers many task runs without waiting for completion.
+     * @param runs - The list of inputs and optional per-run options.
+     * @returns WorkflowRunRef values for each scheduled run.
+     */
+    runManyNoWait(runs: RunManyOpt<I & GlobalInput>[]): Promise<WorkflowRunRef<O & Resolved<GlobalOutput, MiddlewareAfter>>[]>;
     /**
      * Schedules the task to run at a specific date and time.
      * @param enqueueAt - The date when the task should be triggered.

package/v1/declaration.js

@@ -15,6 +15,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskWorkflowDeclaration = exports.WorkflowDeclaration = exports.BaseWorkflowDeclaration = exports.StickyStrategy = exports.Priority = void 0;
 exports.CreateTaskWorkflow = CreateTaskWorkflow;
@@ -63,9 +74,7 @@ class BaseWorkflowDeclaration {
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
-            // set the parent run context
             const parentRunContext = parent_run_context_vars_1.parentRunContextManager.getContext();
-            parent_run_context_vars_1.parentRunContextManager.incrementChildIndex(Array.isArray(input) ? input.length : 1);
             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');
             }
@@ -79,20 +88,21 @@ class BaseWorkflowDeclaration {
                     : 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 });
+            // Snapshot childIndex before incrementing — shared with Context.spawnIndex
+            // via parentRunContextManager so both spawning APIs produce unique indices.
+            const baseChildIndex = parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.childIndex;
+            const inputCount = Array.isArray(input) ? input.length : 1;
+            parent_run_context_vars_1.parentRunContextManager.incrementChildIndex(inputCount);
+            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: baseChildIndex, 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) {
                     const batch = input.slice(i, i + 500);
-                    const batchResp = yield this.client.admin.runWorkflows(batch.map((inp) => {
-                        var _a;
-                        return ({
-                            workflowName: this.definition.name,
-                            input: inp,
-                            options: Object.assign(Object.assign({}, runOpts), { childIndex: ((_a = runOpts.childIndex) !== null && _a !== void 0 ? _a : 0) + i }),
-                        });
-                    }));
+                    const batchResp = yield this.client.admin.runWorkflows(batch.map((inp, batchIdx) => ({
+                        workflowName: this.definition.name,
+                        input: inp,
+                        options: Object.assign(Object.assign({}, runOpts), { childIndex: (baseChildIndex !== null && baseChildIndex !== void 0 ? baseChildIndex : 0) + i + batchIdx }),
+                    })));
                     resp = resp.concat(batchResp);
                 }
                 const res = [];
@@ -118,6 +128,59 @@ class BaseWorkflowDeclaration {
             return res;
         });
     }
+    /**
+     * Synchronously trigger multiple workflow runs without waiting for completion.
+     * @param runs A list of run requests containing input and per-run options.
+     * @returns WorkflowRunRef values in the same order as input runs.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    runManyNoWait(runs, _standaloneTaskName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            const parentRunContext = parent_run_context_vars_1.parentRunContextManager.getContext();
+            const hasChildKeyOrSticky = runs.some((run) => { var _a, _b; return ((_a = run.opts) === null || _a === void 0 ? void 0 : _a.childKey) || ((_b = run.opts) === null || _b === void 0 ? void 0 : _b.sticky); });
+            if (!parentRunContext && hasChildKeyOrSticky) {
+                this.client.admin.logger.warn('ignoring childKey or sticky because run is not being spawned from a parent task');
+            }
+            const inheritedSignal = parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.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(runs.length);
+            const baseOpts = {
+                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,
+            };
+            let resp = [];
+            for (let i = 0; i < runs.length; i += 500) {
+                const batch = runs.slice(i, i + 500);
+                const batchResp = yield this.client.admin.runWorkflows(batch.map((run, batchIndex) => {
+                    var _a, _b, _c;
+                    const _d = (_a = run.opts) !== null && _a !== void 0 ? _a : {}, { sticky } = _d, restOpts = __rest(_d, ["sticky"]);
+                    return {
+                        workflowName: this.definition.name,
+                        input: run.input,
+                        options: Object.assign(Object.assign(Object.assign({}, baseOpts), restOpts), { childIndex: ((_b = baseOpts.childIndex) !== null && _b !== void 0 ? _b : 0) + i + batchIndex, desiredWorkerId: sticky ? parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.desiredWorkerId : undefined, childKey: (_c = run.opts) === null || _c === void 0 ? void 0 : _c.childKey }),
+                    };
+                }));
+                resp = resp.concat(batchResp);
+            }
+            resp.forEach((ref) => {
+                if (_standaloneTaskName) {
+                    ref._standaloneTaskName = _standaloneTaskName;
+                }
+                ref.defaultSignal = inheritedSignal;
+            });
+            return resp;
+        });
+    }
     runAndWait(input, options, _standaloneTaskName) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.client) {
@@ -163,6 +226,43 @@ class BaseWorkflowDeclaration {
             return res.result();
         });
     }
+    /**
+     * Executes many workflow runs and waits for all results.
+     * @param runs A list of run requests containing input and per-run options.
+     * @returns Results in the same order as input runs.
+     */
+    runMany(runs, _standaloneTaskName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            const durableCtx = (_a = parent_run_context_vars_1.parentRunContextManager.getContext()) === null || _a === void 0 ? void 0 : _a.durableContext;
+            if (durableCtx) {
+                return durableCtx.spawnChildren(runs.map((run) => ({
+                    workflow: this,
+                    input: run.input,
+                    options: run.opts,
+                })));
+            }
+            const refs = yield this.runManyNoWait(runs, _standaloneTaskName);
+            const returnExceptions = runs.some((run) => { var _a; return (_a = run.opts) === null || _a === void 0 ? void 0 : _a.returnExceptions; });
+            if (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()));
+        });
+    }
     /**
      * Schedules a workflow to run at a specific date and time in the future.
      * @param enqueueAt The date when the workflow should be triggered.
@@ -345,6 +445,7 @@ exports.BaseWorkflowDeclaration = BaseWorkflowDeclaration;
  * - Scheduled execution with `schedule()`
  * - Cron-based recurring execution with `cron()`
  * - Bulk execution by passing an array input to `run()` and `runNoWait()`
+ * - Per-run bulk execution options with `runMany()` and `runManyNoWait()`
  *
  * Tasks within workflows can be defined with `workflow.task()` or
  * `workflow.durableTask()` and arranged into complex dependency patterns.
@@ -493,6 +594,32 @@ class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
                 : _super.runNoWait.call(this, input, options, this._standalone_task_name);
         });
     }
+    /**
+     * Triggers many task runs and waits for all results.
+     * @param runs - The list of inputs and optional per-run options.
+     * @returns A promise that resolves with ordered task outputs.
+     */
+    runMany(runs) {
+        const _super = Object.create(null, {
+            runMany: { get: () => super.runMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.runMany.call(this, runs, this._standalone_task_name);
+        });
+    }
+    /**
+     * Triggers many task runs without waiting for completion.
+     * @param runs - The list of inputs and optional per-run options.
+     * @returns WorkflowRunRef values for each scheduled run.
+     */
+    runManyNoWait(runs) {
+        const _super = Object.create(null, {
+            runManyNoWait: { get: () => super.runManyNoWait }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.runManyNoWait.call(this, runs, this._standalone_task_name);
+        });
+    }
     /**
      * Schedules the task to run at a specific date and time.
      * @param enqueueAt - The date when the task should be triggered.

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

@@ -0,0 +1,21 @@
+export declare const childIndexChild: import("../..").TaskWorkflowDeclaration<{
+    tag: string;
+}, {
+    tag: string;
+}, {}, {}, {}, {}>;
+export declare const childIndexParent: import("../..").WorkflowDeclaration<{
+    n: number;
+}, {}, {}>;
+export declare const scenarioTask: import("../..").TaskWorkflowDeclaration<{
+    scenarioId: string;
+}, {
+    scenarioId: string;
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const orchestratorTask: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+    total: number;
+    expected: number;
+    uniqueRunIds: number;
+    hasDuplicates: boolean;
+    scenarios: string[];
+}, {}, {}, {}, {}>;

package/v1/examples/child_index/workflow.js

@@ -0,0 +1,155 @@
+"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.orchestratorTask = exports.scenarioTask = exports.childIndexParent = exports.childIndexChild = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+exports.childIndexChild = hatchet_client_1.hatchet.task({
+    name: 'child-index-child',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { tag: input.tag };
+    }),
+});
+exports.childIndexParent = hatchet_client_1.hatchet.workflow({
+    name: 'child-index-parent',
+});
+exports.childIndexParent.task({
+    name: 'mixed-spawn',
+    executionTimeout: '3m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const { n } = input;
+        const ctxResults = [];
+        for (let i = 0; i < n; i++) {
+            const result = yield ctx.runChild(exports.childIndexChild, { tag: `ctx-${i}` });
+            ctxResults.push(result.tag);
+        }
+        const refs = yield Promise.all(Array.from({ length: n }, (_, i) => exports.childIndexChild.runNoWait({ tag: `rnw-${i}` })));
+        const runIds = yield Promise.all(refs.map((r) => r.runId));
+        const outputs = yield Promise.all(refs.map((r) => r.output));
+        const rnwResults = outputs.map((o) => o.tag);
+        return {
+            ctxResults,
+            rnwResults,
+            runIds,
+        };
+    }),
+});
+function buildTree() {
+    // Root → Fund → Portfolio → Portfolio → Project structure
+    // ~30 total nodes to keep the test manageable
+    return {
+        id: 'fund-root',
+        children: [
+            {
+                id: 'fund-a',
+                children: [
+                    {
+                        id: 'portfolio-a1',
+                        children: [
+                            { id: 'project-a1a', children: [] },
+                            { id: 'project-a1b', children: [] },
+                            { id: 'project-a1c', children: [] },
+                        ],
+                    },
+                    {
+                        id: 'portfolio-a2',
+                        children: [
+                            { id: 'project-a2a', children: [] },
+                            { id: 'project-a2b', children: [] },
+                        ],
+                    },
+                ],
+            },
+            {
+                id: 'fund-b',
+                children: [
+                    {
+                        id: 'portfolio-b1',
+                        children: [
+                            { id: 'project-b1a', children: [] },
+                            { id: 'project-b1b', children: [] },
+                            { id: 'project-b1c', children: [] },
+                            { id: 'project-b1d', children: [] },
+                        ],
+                    },
+                    {
+                        id: 'portfolio-b2',
+                        children: [
+                            { id: 'project-b2a', children: [] },
+                            { id: 'project-b2b', children: [] },
+                        ],
+                    },
+                ],
+            },
+            {
+                id: 'fund-c',
+                children: [
+                    {
+                        id: 'portfolio-c1',
+                        children: [
+                            { id: 'project-c1a', children: [] },
+                            { id: 'project-c1b', children: [] },
+                            { id: 'project-c1c', children: [] },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+}
+function countNodes(node) {
+    return 1 + node.children.reduce((sum, c) => sum + countNodes(c), 0);
+}
+exports.scenarioTask = hatchet_client_1.hatchet.task({
+    name: 'child-index-scenario',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(100);
+        return { scenarioId: input.scenarioId, status: 'completed' };
+    }),
+});
+exports.orchestratorTask = hatchet_client_1.hatchet.task({
+    name: 'child-index-orchestrator',
+    executionTimeout: '5m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const tree = buildTree();
+        const totalExpected = countNodes(tree);
+        const collectedRunIds = [];
+        const collectedScenarios = [];
+        // Recursive bottom-up traversal — mirrors Evan's runChildScenarioFn pattern.
+        // Process children first, wait for completion, then process this node.
+        function processNode(node) {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (const child of node.children) {
+                    yield processNode(child);
+                }
+                const runRef = yield exports.scenarioTask.runNoWait({
+                    scenarioId: node.id,
+                });
+                const runId = yield runRef.runId;
+                collectedRunIds.push(runId);
+                collectedScenarios.push(node.id);
+                yield runRef.output;
+            });
+        }
+        yield processNode(tree);
+        const uniqueRunIds = new Set(collectedRunIds);
+        return {
+            total: collectedRunIds.length,
+            expected: totalExpected,
+            uniqueRunIds: uniqueRunIds.size,
+            hasDuplicates: uniqueRunIds.size !== collectedRunIds.length,
+            scenarios: collectedScenarios,
+        };
+    }),
+});

package/v1/examples/e2e-worker.js

@@ -39,6 +39,7 @@ const e2e_workflows_1 = require("./simple/e2e-workflows");
 const workflow_18 = require("./streaming/workflow");
 const workflow_19 = require("./timeout/workflow");
 const workflow_20 = require("./webhooks/workflow");
+const workflow_21 = require("./child_index/workflow");
 const workflows = [
     workflow_1.bulkChild,
     workflow_1.bulkParentWorkflow,
@@ -89,6 +90,10 @@ const workflows = [
     workflow_19.timeoutTask,
     workflow_19.refreshTimeoutTask,
     workflow_20.webhookWorkflow,
+    workflow_21.childIndexChild,
+    workflow_21.childIndexParent,
+    workflow_21.scenarioTask,
+    workflow_21.orchestratorTask,
 ];
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/v1/examples/simple/bulk.js

@@ -26,6 +26,25 @@ function main() {
         console.log(res[0].TransformedMessage);
         console.log(res[1].TransformedMessage);
         // !!
+        // > Bulk Run a Task with runMany
+        const runManyRes = yield workflow_1.simple.runMany([
+            {
+                input: {
+                    Message: 'HeLlO WoRlD',
+                },
+            },
+            {
+                input: {
+                    Message: 'Hello MoOn',
+                },
+                opts: {
+                    priority: 3,
+                },
+            },
+        ]);
+        console.log(runManyRes[0].TransformedMessage);
+        console.log(runManyRes[1].TransformedMessage);
+        // !!
         // > Bulk Run Tasks from within a Task
         const parent = hatchet_client_1.hatchet.task({
             name: 'simple',

package/v1/parent-run-context-vars.d.ts

@@ -1,4 +1,4 @@
-import { DurableContext } from './client/worker/context';
+import type { DurableContext } from './client/worker/context';
 export interface ParentRunContext {
     parentId: string;
     /**
@@ -22,8 +22,6 @@ export declare class ParentRunContextManager {
     private storage;
     constructor();
     runWithContext<T>(opts: ParentRunContext, fn: () => T): T;
-    setContext(opts: ParentRunContext): void;
-    setParentRunIdAndIncrementChildIndex(opts: ParentRunContext): void;
     incrementChildIndex(n: number): void;
     getContext(): ParentRunContext | undefined;
 }

package/v1/parent-run-context-vars.js

@@ -9,25 +9,16 @@ class ParentRunContextManager {
     runWithContext(opts, fn) {
         return this.storage.run(Object.assign({}, opts), fn);
     }
-    setContext(opts) {
-        this.storage.enterWith(Object.assign({}, opts));
-    }
-    setParentRunIdAndIncrementChildIndex(opts) {
-        var _a;
-        const parentRunContext = this.getContext();
-        if (parentRunContext) {
-            parentRunContext.parentId = opts.parentId;
-            parentRunContext.parentTaskRunExternalId = opts.parentTaskRunExternalId;
-            parentRunContext.childIndex = ((_a = parentRunContext.childIndex) !== null && _a !== void 0 ? _a : 0) + 1;
-            this.setContext(parentRunContext);
-        }
-    }
     incrementChildIndex(n) {
         var _a;
         const parentRunContext = this.getContext();
         if (parentRunContext) {
+            // Mutate in place — do NOT use enterWith here.
+            // storage.run() gives every async descendant the same object reference,
+            // so direct mutation is visible across all await boundaries within the
+            // same task execution.  enterWith would replace the object, and the new
+            // object's updates would be invisible to parent async contexts after an await.
             parentRunContext.childIndex = ((_a = parentRunContext.childIndex) !== null && _a !== void 0 ? _a : 0) + n;
-            this.setContext(parentRunContext);
         }
     }
     getContext() {

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.20.0";
+export declare const HATCHET_VERSION = "1.21.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.20.0';
+exports.HATCHET_VERSION = '1.21.0';