@hatchet-dev/typescript-sdk 0.14.0 → 0.16.0-alpha.1

package/clients/rest/index.d.ts

@@ -1,8 +1,8 @@
-import api from './api';
+import api, { cloudApi, CloudApi } from './api';
 import { Api } from './generated/Api';
 import { Worker as _Worker, Workflow as _Workflow } from './generated/data-contracts';
 import * as APIContracts from './generated/data-contracts';
 type ApiWorker = _Worker;
 type ApiWorkflow = _Workflow;
-export { ApiWorker, ApiWorkflow, APIContracts, Api };
+export { ApiWorker, ApiWorkflow, APIContracts, Api, CloudApi, cloudApi };
 export default api;

package/clients/rest/index.js

@@ -22,12 +22,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Api = exports.APIContracts = void 0;
-const api_1 = __importDefault(require("./api"));
+exports.cloudApi = exports.CloudApi = exports.Api = exports.APIContracts = void 0;
+const api_1 = __importStar(require("./api"));
+Object.defineProperty(exports, "cloudApi", { enumerable: true, get: function () { return api_1.cloudApi; } });
+Object.defineProperty(exports, "CloudApi", { enumerable: true, get: function () { return api_1.CloudApi; } });
 const Api_1 = require("./generated/Api");
 Object.defineProperty(exports, "Api", { enumerable: true, get: function () { return Api_1.Api; } });
 const APIContracts = __importStar(require("./generated/data-contracts"));

package/clients/worker/compute/compute-config.d.ts

@@ -0,0 +1,96 @@
+import { ManagedWorkerRegion } from '../../rest/generated/cloud/data-contracts';
+import { z } from 'zod';
+export declare const SharedCPUComputeSchema: z.ZodObject<z.objectUtil.extendShape<{
+    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    numReplicas: z.ZodDefault<z.ZodNumber>;
+    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
+    cpus: z.ZodNumber;
+}, {
+    cpuKind: z.ZodLiteral<"shared">;
+    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
+}>, "strip", z.ZodTypeAny, {
+    numReplicas: number;
+    cpus: number;
+    cpuKind: "shared";
+    memoryMb: number;
+    pool?: string | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}, {
+    cpus: number;
+    cpuKind: "shared";
+    memoryMb: number;
+    pool?: string | undefined;
+    numReplicas?: number | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}>;
+export type SharedCPUCompute = z.infer<typeof SharedCPUComputeSchema>;
+export declare const DedicatedCPUComputeSchema: z.ZodObject<z.objectUtil.extendShape<{
+    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    numReplicas: z.ZodDefault<z.ZodNumber>;
+    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
+    cpus: z.ZodNumber;
+}, {
+    cpuKind: z.ZodLiteral<"dedicated">;
+    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
+}>, "strip", z.ZodTypeAny, {
+    numReplicas: number;
+    cpus: number;
+    cpuKind: "dedicated";
+    memoryMb: number;
+    pool?: string | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}, {
+    cpus: number;
+    cpuKind: "dedicated";
+    memoryMb: number;
+    pool?: string | undefined;
+    numReplicas?: number | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}>;
+export type DedicatedCPUCompute = z.infer<typeof DedicatedCPUComputeSchema>;
+export declare const ComputeSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    numReplicas: z.ZodDefault<z.ZodNumber>;
+    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
+    cpus: z.ZodNumber;
+}, {
+    cpuKind: z.ZodLiteral<"shared">;
+    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
+}>, "strip", z.ZodTypeAny, {
+    numReplicas: number;
+    cpus: number;
+    cpuKind: "shared";
+    memoryMb: number;
+    pool?: string | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}, {
+    cpus: number;
+    cpuKind: "shared";
+    memoryMb: number;
+    pool?: string | undefined;
+    numReplicas?: number | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    numReplicas: z.ZodDefault<z.ZodNumber>;
+    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
+    cpus: z.ZodNumber;
+}, {
+    cpuKind: z.ZodLiteral<"dedicated">;
+    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
+}>, "strip", z.ZodTypeAny, {
+    numReplicas: number;
+    cpus: number;
+    cpuKind: "dedicated";
+    memoryMb: number;
+    pool?: string | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}, {
+    cpus: number;
+    cpuKind: "dedicated";
+    memoryMb: number;
+    pool?: string | undefined;
+    numReplicas?: number | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}>]>;
+export declare const computeHash: (compute: z.infer<typeof ComputeSchema>) => string;

package/clients/worker/compute/compute-config.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHash = exports.ComputeSchema = exports.DedicatedCPUComputeSchema = exports.SharedCPUComputeSchema = void 0;
+const data_contracts_1 = require("../../rest/generated/cloud/data-contracts");
+const crypto_1 = require("crypto");
+const zod_1 = require("zod");
+const BaseComputeSchema = zod_1.z.object({
+    pool: zod_1.z.string().default('default').optional().describe('The name of the compute pool to use'),
+    numReplicas: zod_1.z
+        .number()
+        .int()
+        .min(0, { message: 'Must be at least 0' })
+        .max(1000, { message: 'Must be at most 1000' })
+        .default(1)
+        .describe('The number of replicas'),
+    regions: zod_1.z
+        .array(zod_1.z.nativeEnum(data_contracts_1.ManagedWorkerRegion))
+        .optional()
+        .describe('The regions to deploy the worker to'),
+    cpus: zod_1.z
+        .number()
+        .int()
+        .min(1, { message: 'Must be at least 1' })
+        .max(64, { message: 'Must be at most 64' })
+        .describe('The number of CPUs to use for the worker'),
+});
+exports.SharedCPUComputeSchema = BaseComputeSchema.extend({
+    cpuKind: zod_1.z.literal('shared'),
+    memoryMb: zod_1.z
+        .number()
+        .int()
+        .min(256, { message: 'Must be at least 256 MB' })
+        .max(65536, { message: 'Must be at most 65536 MB' })
+        .refine((val) => val % 256 === 0, { message: 'Must be divisible by 256 MB' })
+        .describe('The amount of memory in MB to use for the worker'),
+});
+exports.DedicatedCPUComputeSchema = BaseComputeSchema.extend({
+    cpuKind: zod_1.z.literal('dedicated'),
+    memoryMb: zod_1.z
+        .number()
+        .int()
+        .min(2048, { message: 'Must be at least 1024 MB' })
+        .max(65536, { message: 'Must be at most 65536 MB' })
+        .refine((val) => val % 256 === 0, { message: 'Must be divisible by 256 MB' })
+        .describe('The amount of memory in MB to use for the worker'),
+});
+exports.ComputeSchema = zod_1.z.union([exports.SharedCPUComputeSchema, exports.DedicatedCPUComputeSchema]);
+const computeHash = (compute) => {
+    const str = JSON.stringify(compute);
+    return (0, crypto_1.createHash)('sha256').update(str).digest('hex');
+};
+exports.computeHash = computeHash;

package/clients/worker/compute/managed-compute.d.ts

@@ -0,0 +1,15 @@
+import { HatchetClient } from '../../hatchet-client';
+import { CreateManagedWorkerRuntimeConfigRequest } from '../../rest/generated/cloud/data-contracts';
+import { Logger } from '../../../util/logger';
+import { ActionRegistry } from '../worker';
+export declare class ManagedCompute {
+    actions: ActionRegistry;
+    client: HatchetClient;
+    maxRuns: number;
+    configs: CreateManagedWorkerRuntimeConfigRequest[];
+    cloudRegisterId: string | undefined;
+    logger: Logger;
+    constructor(actions: ActionRegistry, client: HatchetClient, maxRuns?: number);
+    getComputeConfigs(actions: ActionRegistry): CreateManagedWorkerRuntimeConfigRequest[];
+    cloudRegister(): Promise<void>;
+}

package/clients/worker/compute/managed-compute.js

@@ -0,0 +1,100 @@
+"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.ManagedCompute = void 0;
+const logger_1 = require("../../../util/logger");
+const compute_config_1 = require("./compute-config");
+class ManagedCompute {
+    constructor(actions, client, maxRuns = 1) {
+        this.actions = actions;
+        this.client = client;
+        this.maxRuns = maxRuns;
+        this.configs = this.getComputeConfigs(this.actions);
+        this.cloudRegisterId = this.client.config.cloud_register_id;
+        this.logger = new logger_1.Logger(`Compute`, this.client.config.log_level);
+        if (this.configs.length === 0) {
+            this.logger.debug('No compute configs found, skipping cloud registration and running all actions locally.');
+            return;
+        }
+        if (!this.cloudRegisterId) {
+            this.logger.warn('Managed cloud compute plan:');
+            this.configs.forEach((compute) => {
+                var _a;
+                this.logger.warn('    ----------------------------');
+                this.logger.warn(`    actions: ${(_a = compute.actions) === null || _a === void 0 ? void 0 : _a.join(', ')}`);
+                this.logger.warn(`    num replicas: ${compute.numReplicas}`);
+                this.logger.warn(`    cpu kind: ${compute.cpuKind}`);
+                this.logger.warn(`    cpus: ${compute.cpus}`);
+                this.logger.warn(`    memory mb: ${compute.memoryMb}`);
+                // this.logger.warn(`    regions: ${compute.regions?.join(', ')}`);
+            });
+            this.logger.warn('NOTICE: local mode detected, skipping cloud registration and running all actions locally.');
+        }
+    }
+    getComputeConfigs(actions) {
+        /**
+         * Builds a map of compute hashes to compute configs and lists of actions that correspond to each compute hash.
+         */
+        const computeMap = {};
+        try {
+            Object.entries(actions).forEach(([action, { compute }]) => {
+                if (!compute) {
+                    return;
+                }
+                const key = (0, compute_config_1.computeHash)(compute);
+                if (!computeMap[key]) {
+                    computeMap[key] = {
+                        actions: [],
+                        numReplicas: compute.numReplicas,
+                        cpuKind: compute.cpuKind,
+                        cpus: compute.cpus,
+                        memoryMb: compute.memoryMb,
+                        regions: compute.regions,
+                        slots: this.maxRuns,
+                    };
+                }
+                computeMap[key].actions.push(action);
+            });
+            return Object.values(computeMap);
+        }
+        catch (e) {
+            this.logger.error(`Error getting compute configs: ${e}`);
+            return [];
+        }
+    }
+    cloudRegister() {
+        return __awaiter(this, void 0, void 0, function* () {
+            /**
+             * Registers the compute plan with the cloud if the environment variable is set.
+             * Exits the process upon completion.
+             */
+            if (this.cloudRegisterId) {
+                this.logger.info(`Registering cloud compute plan with ID: ${this.cloudRegisterId}`);
+                try {
+                    if (this.configs.length === 0) {
+                        this.logger.warn('No actions to register, skipping cloud registration.');
+                        process.exit(0);
+                    }
+                    const req = {
+                        runtimeConfigs: this.configs,
+                    };
+                    yield this.client.cloudApi.infraAsCodeCreate(this.cloudRegisterId, req);
+                    process.exit(0);
+                }
+                catch (e) {
+                    this.logger.error(`ERROR: ${e}`);
+                    process.exit(1);
+                }
+            }
+        });
+    }
+}
+exports.ManagedCompute = ManagedCompute;

package/clients/worker/worker.d.ts

@@ -6,9 +6,16 @@ import { Workflow } from '../../workflow';
 import { Logger } from '../../util/logger';
 import { WebhookHandler } from './handler';
 import { WebhookWorkerCreateRequest } from '../rest/generated/data-contracts';
+import { z } from 'zod';
 import { Context, StepRunFunction } from '../../step';
 import { WorkerLabels } from '../dispatcher/dispatcher-client';
-export type ActionRegistry = Record<Action['actionId'], Function>;
+import { ComputeSchema } from './compute/compute-config';
+type ActionFunction = StepRunFunction<any, any> | ((ctx: any) => string | Promise<string>);
+type ActionRegistryRecord = {
+    func: ActionFunction;
+    compute?: z.infer<typeof ComputeSchema>;
+};
+export type ActionRegistry = Record<Action['actionId'], ActionRegistryRecord>;
 export interface WorkerOpts {
     name: string;
     handleKill?: boolean;
@@ -44,7 +51,7 @@ export declare class Worker {
      */
     register_workflow(initWorkflow: Workflow): Promise<void>;
     registerWorkflow(initWorkflow: Workflow): Promise<void>;
-    registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
+    registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>, compute?: z.infer<typeof ComputeSchema>): void;
     handleStartStepRun(action: Action): Promise<void>;
     handleStartGroupKeyRun(action: Action): Promise<void>;
     getStepActionEvent(action: Action, eventType: StepActionEventType, payload?: any): StepActionEvent;
@@ -56,3 +63,4 @@ export declare class Worker {
     handleAction(action: Action): Promise<void>;
     upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;
 }
+export {};

package/clients/worker/worker.js

@@ -27,6 +27,7 @@ const workflows_1 = require("../../protoc/workflows");
 const logger_1 = require("../../util/logger");
 const handler_1 = require("./handler");
 const step_1 = require("../../step");
+const managed_compute_1 = require("./compute/managed-compute");
 class Worker {
     constructor(client, options) {
         this.workflow_registry = [];
@@ -48,18 +49,33 @@ class Worker {
     registerActions(workflow) {
         var _a;
         const newActions = workflow.steps.reduce((acc, step) => {
-            acc[`${workflow.id}:${step.name}`] = step.run;
+            // Only register actions that are in the runnable_actions list
+            if (!this.client.config.runnable_actions ||
+                this.client.config.runnable_actions.includes(`${workflow.id}:${step.name}`)) {
+                acc[`${workflow.id}:${step.name}`] = {
+                    func: step.run,
+                    compute: step.compute,
+                };
+            }
             return acc;
         }, {});
         const onFailureAction = workflow.onFailure
             ? {
-                [`${workflow.id}-on-failure:${workflow.onFailure.name}`]: workflow.onFailure.run,
+                [`${workflow.id}-on-failure:${workflow.onFailure.name}`]: {
+                    func: workflow.onFailure.run,
+                    compute: workflow.onFailure.compute,
+                },
+            }
+            : {};
+        const concurrencyAction = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name) && workflow.concurrency.key
+            ? {
+                [`${workflow.id}:${workflow.concurrency.name}`]: {
+                    func: workflow.concurrency.key,
+                    compute: undefined,
+                },
             }
             : {};
-        this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
-        this.action_registry =
-            ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name) && workflow.concurrency.key
-                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
+        this.action_registry = Object.assign(Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction), concurrencyAction);
     }
     getHandler(workflows) {
         for (const workflow of workflows) {
@@ -162,8 +178,11 @@ class Worker {
             this.registerActions(workflow);
         });
     }
-    registerAction(actionId, action) {
-        this.action_registry[actionId] = action;
+    registerAction(actionId, action, compute) {
+        this.action_registry[actionId] = {
+            func: action,
+            compute,
+        };
     }
     handleStartStepRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -177,7 +196,7 @@ class Worker {
                     return;
                 }
                 const run = () => __awaiter(this, void 0, void 0, function* () {
-                    return step(context);
+                    return step.func(context);
                 });
                 const success = (result) => __awaiter(this, void 0, void 0, function* () {
                     this.logger.info(`Step run ${action.stepRunId} succeeded`);
@@ -262,7 +281,7 @@ class Worker {
                     return;
                 }
                 const run = () => __awaiter(this, void 0, void 0, function* () {
-                    return step(context);
+                    return step.func(context);
                 });
                 const success = (result) => {
                     this.logger.info(`Step run ${action.stepRunId} succeeded`);
@@ -391,6 +410,8 @@ class Worker {
             var _a, e_1, _b, _c;
             // ensure all workflows are registered
             yield Promise.all(this.registeredWorkflowPromises);
+            const managedCompute = new managed_compute_1.ManagedCompute(this.action_registry, this.client, this.maxRuns);
+            yield managedCompute.cloudRegister();
             try {
                 this.listener = yield this.client.dispatcher.getActionListener({
                     workerName: this.name,

package/examples/bulk-fanout-trigger.d.ts

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

package/examples/bulk-fanout-trigger.js

@@ -0,0 +1,74 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("../sdk"));
+const hatchet = sdk_1.default.init();
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workflowRuns = [];
+        workflowRuns[0] = {
+            workflowName: 'bulk-parent-workflow',
+            input: {},
+            options: {
+                additionalMetadata: {
+                    key: 'value',
+                },
+            },
+        };
+        workflowRuns[1] = {
+            workflowName: 'bulk-parent-workflow',
+            input: { second: 'second' },
+            options: {
+                additionalMetadata: {
+                    key: 'value',
+                },
+            },
+        };
+        try {
+            const workflowRunResponse = hatchet.admin.runWorkflows(workflowRuns);
+            const result = yield workflowRunResponse;
+            console.log('result', result);
+            result.forEach((workflowRun) => __awaiter(this, void 0, void 0, function* () {
+                var _a, e_1, _b, _c;
+                const stream = yield workflowRun.stream();
+                try {
+                    for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+                        _c = stream_1_1.value;
+                        _d = false;
+                        const event = _c;
+                        console.log('event received', event);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }));
+        }
+        catch (error) {
+            console.log('error', error);
+        }
+    });
+}
+main();

package/examples/bulk-fanout-worker.d.ts

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

package/examples/bulk-fanout-worker.js

@@ -0,0 +1,93 @@
+"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 });
+const sdk_1 = __importDefault(require("../sdk"));
+const hatchet = sdk_1.default.init();
+const parentWorkflow = {
+    id: 'bulk-parent-workflow',
+    description: 'simple example for spawning child workflows',
+    on: {
+        event: 'bulk:fanout:create',
+    },
+    steps: [
+        {
+            name: 'parent-spawn',
+            timeout: '70s',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                // Prepare the workflows to spawn
+                const workflowRequests = Array.from({ length: 300 }, (_, i) => ({
+                    workflow: 'child-workflow',
+                    input: { input: `child-input-${i}` },
+                    options: { additionalMetadata: { childKey: 'childValue' } },
+                }));
+                const spawnedWorkflows = yield ctx.spawnWorkflows(workflowRequests);
+                const results = yield Promise.all(spawnedWorkflows.map((workflowRef) => workflowRef.result().then((result) => {
+                    ctx.log('spawned workflow result:');
+                    return result;
+                })));
+                console.log('spawned workflow results:', results);
+                console.log('number of spawned workflows:', results.length);
+                return { spawned: results.length };
+            }),
+        },
+    ],
+};
+const childWorkflow = {
+    id: 'child-workflow',
+    description: 'simple example for spawning child workflows',
+    on: {
+        event: 'child:create',
+    },
+    steps: [
+        {
+            name: 'child-work',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const { input } = ctx.workflowInput();
+                // throw new Error('child error');
+                return { 'child-output': 'sm' };
+            }),
+        },
+        {
+            name: 'child-work2',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const { input } = ctx.workflowInput();
+                // Perform CPU-bound work
+                // throw new Error('child error');
+                console.log('child workflow input:', input);
+                // Generate a large amount of garbage data
+                const garbageData = 'garbage'; // Print a snippet of the garbage data
+                return { 'child-output': garbageData };
+            }),
+        },
+        {
+            name: 'child-work3',
+            parents: ['child-work'],
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const { input } = ctx.workflowInput();
+                // throw new Error('child error');
+                const garbageData = 'child garbage';
+                return { 'child-output': garbageData };
+            }),
+        },
+    ],
+};
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet.worker('fanout-worker', { maxRuns: 1000 });
+        yield worker.registerWorkflow(parentWorkflow);
+        yield worker.registerWorkflow(childWorkflow);
+        worker.start();
+    });
+}
+main();

package/examples/bulk-trigger.d.ts

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

package/examples/bulk-trigger.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("../sdk"));
+const hatchet = sdk_1.default.init();
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workflowRuns = [];
+        for (let i = 0; i < 100; i += 1) {
+            workflowRuns.push({
+                workflowName: 'simple-workflow',
+                input: {},
+                options: {
+                    additionalMetadata: {
+                        key: 'value',
+                        dedupe: 'key',
+                    },
+                },
+            });
+        }
+        const workflowRunResponse = hatchet.admin.runWorkflows(workflowRuns);
+        const result = yield workflowRunResponse;
+        console.log('result', result);
+        result.forEach((workflowRun) => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const stream = yield workflowRun.stream();
+            try {
+                for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+                    _c = stream_1_1.value;
+                    _d = false;
+                    const event = _c;
+                    console.log('event received', event);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }));
+    });
+}
+main();

package/examples/managed-worker.d.ts

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