@hatchet-dev/typescript-sdk 1.4.0-alpha.2 → 1.4.1

package/clients/dispatcher/action-listener.d.ts

@@ -9,6 +9,8 @@ declare enum ListenStrategy {
 }
 export interface Action extends AssignedAction {
 }
+export type ActionKey = string;
+export declare function createActionKey(action: Action): ActionKey;
 export declare class ActionListener {
     config: ClientConfig;
     client: PbDispatcherClient;

package/clients/dispatcher/action-listener.js

@@ -33,6 +33,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionListener = void 0;
+exports.createActionKey = createActionKey;
+const dispatcher_1 = require("../../protoc/dispatcher");
 const nice_grpc_1 = require("nice-grpc");
 const sleep_1 = __importDefault(require("../../util/sleep"));
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
@@ -45,6 +47,20 @@ var ListenStrategy;
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V1"] = 1] = "LISTEN_STRATEGY_V1";
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V2"] = 2] = "LISTEN_STRATEGY_V2";
 })(ListenStrategy || (ListenStrategy = {}));
+function createActionKey(action) {
+    switch (action.actionType) {
+        case dispatcher_1.ActionType.START_GET_GROUP_KEY:
+            return `${action.getGroupKeyRunId}/${action.retryCount}`;
+        case dispatcher_1.ActionType.CANCEL_STEP_RUN:
+        case dispatcher_1.ActionType.START_STEP_RUN:
+        case dispatcher_1.ActionType.UNRECOGNIZED:
+            return `${action.stepRunId}/${action.retryCount}`;
+        default:
+            // eslint-disable-next-line no-case-declarations
+            const exhaustivenessCheck = action.actionType;
+            throw new Error(`Unhandled action type: ${exhaustivenessCheck}`);
+    }
+}
 class ActionListener {
     constructor(client, workerId, retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL, retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
         this.lastConnectionAttempt = 0;

package/clients/hatchet-client/features/cron-client.d.ts

@@ -9,7 +9,7 @@ import { ClientConfig } from '../client-config';
  */
 export declare const CreateCronTriggerSchema: z.ZodObject<{
     name: z.ZodString;
-    expression: z.ZodEffects<z.ZodString, string, string>;
+    expression: z.ZodString;
     input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     additionalMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     priority: z.ZodOptional<z.ZodNumber>;

package/clients/hatchet-client/features/cron-client.js

@@ -17,11 +17,7 @@ const axios_1 = require("axios");
  */
 exports.CreateCronTriggerSchema = zod_1.z.object({
     name: zod_1.z.string(),
-    expression: zod_1.z.string().refine((val) => {
-        // Basic cron validation regex
-        const cronRegex = /^(\*|([0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])|\*\/([0-9]|1[0-9]|2[0-3])) (\*|([0-9]|1[0-9]|2[0-3])|\*\/([0-9]|1[0-9]|2[0-3])) (\*|([1-9]|1[0-9]|2[0-9]|3[0-1])|\*\/([1-9]|1[0-9]|2[0-9]|3[0-1])) (\*|([1-9]|1[0-2])|\*\/([1-9]|1[0-2])) (\*|([0-6])|\*\/([0-6]))$/;
-        return cronRegex.test(val);
-    }, 'Invalid cron expression'),
+    expression: zod_1.z.string(),
     input: zod_1.z.record(zod_1.z.any()).optional(),
     additionalMetadata: zod_1.z.record(zod_1.z.string()).optional(),
     priority: zod_1.z.number().optional(),

package/clients/worker/worker.d.ts

@@ -1,5 +1,5 @@
 import { LegacyHatchetClient } from '../hatchet-client';
-import { Action, ActionListener } from '../dispatcher/action-listener';
+import { Action, ActionKey, ActionListener } from '../dispatcher/action-listener';
 import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType } from '../../protoc/dispatcher';
 import HatchetPromise from '../../util/hatchet-promise/hatchet-promise';
 import { Workflow } from '../../workflow';
@@ -25,8 +25,8 @@ export declare class V0Worker {
     action_registry: ActionRegistry;
     workflow_registry: Array<WorkflowDefinition | Workflow>;
     listener: ActionListener | undefined;
-    futures: Record<Action['stepRunId'], HatchetPromise<any>>;
-    contexts: Record<Action['stepRunId'], V0Context<any, any>>;
+    futures: Record<ActionKey, HatchetPromise<any>>;
+    contexts: Record<ActionKey, V0Context<any, any>>;
     maxRuns?: number;
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;

package/clients/worker/worker.js

@@ -21,6 +21,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.V0Worker = void 0;
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const action_listener_1 = require("../dispatcher/action-listener");
 const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
 const workflows_1 = require("../../protoc/workflows");
@@ -174,7 +175,7 @@ class V0Worker {
             try {
                 // Note: we always use a DurableContext since its a superset of the Context class
                 const context = new step_1.V0DurableContext(action, this.client, this);
-                this.contexts[action.stepRunId] = context;
+                this.contexts[(0, action_listener_1.createActionKey)(action)] = context;
                 const step = this.action_registry[actionId];
                 if (!step) {
                     this.logger.error(`Registered actions: '${Object.keys(this.action_registry).join(', ')}'`);
@@ -205,8 +206,8 @@ class V0Worker {
                     }
                     finally {
                         // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
+                        delete this.futures[(0, action_listener_1.createActionKey)(action)];
+                        delete this.contexts[(0, action_listener_1.createActionKey)(action)];
                     }
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
@@ -228,8 +229,8 @@ class V0Worker {
                     }
                     finally {
                         // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
+                        delete this.futures[(0, action_listener_1.createActionKey)(action)];
+                        delete this.contexts[(0, action_listener_1.createActionKey)(action)];
                     }
                 });
                 const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
@@ -243,7 +244,7 @@ class V0Worker {
                     }
                     yield success(result);
                 }))());
-                this.futures[action.stepRunId] = future;
+                this.futures[(0, action_listener_1.createActionKey)(action)] = future;
                 // Send the action event to the dispatcher
                 const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED, false, undefined, action.retryCount);
                 this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
@@ -266,7 +267,7 @@ class V0Worker {
             const { actionId } = action;
             try {
                 const context = new step_1.V0Context(action, this.client, this);
-                const key = action.getGroupKeyRunId;
+                const key = (0, action_listener_1.createActionKey)(action);
                 if (!key) {
                     this.logger.error(`No group key run id provided for action ${actionId}`);
                     return;
@@ -365,8 +366,8 @@ class V0Worker {
             const { stepRunId } = action;
             try {
                 this.logger.info(`Cancelling step run ${action.stepRunId}`);
-                const future = this.futures[stepRunId];
-                const context = this.contexts[stepRunId];
+                const future = this.futures[(0, action_listener_1.createActionKey)(action)];
+                const context = this.contexts[(0, action_listener_1.createActionKey)(action)];
                 if (context && context.controller) {
                     context.controller.abort('Cancelled by worker');
                 }
@@ -382,8 +383,8 @@ class V0Worker {
                 this.logger.error('Could not cancel step run: ', e);
             }
             finally {
-                delete this.futures[stepRunId];
-                delete this.contexts[stepRunId];
+                delete this.futures[(0, action_listener_1.createActionKey)(action)];
+                delete this.contexts[(0, action_listener_1.createActionKey)(action)];
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.4.0-alpha.2",
+  "version": "1.4.1",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -18,6 +18,7 @@
   "scripts": {
     "build": "echo 'build hatchet sdk with `npm run tsc:build` to ensure it is not build during the publish step' && exit 0",
     "prepare": "npm run build",
+    "postinstall": "node scripts/version-check.js",
     "dump-version": "node -e \"console.log('export const HATCHET_VERSION = \\'' + require('./package.json').version + '\\';');\" > src/version.ts",
     "tsc:build": "npm run dump-version && tsc && resolve-tspaths",
     "test:unit": "jest --testMatch='**/*.test.ts'",
@@ -32,7 +33,7 @@
     "eslint:fix": "eslint \"{src,tests}/**/*.{ts,tsx,js}\" --fix",
     "prettier:check": "prettier \"src/**/*.{ts,tsx}\" --list-different",
     "prettier:fix": "prettier \"src/**/*.{ts,tsx}\" --write",
-    "prepublish": "cp package.json dist/package.json; cp README.md dist/",
+    "prepublish": "cp package.json dist/package.json; cp README.md dist/; cp -r scripts dist/",
     "publish:ci": "rm -rf ./dist && npm run dump-version && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks",
     "publish:ci:alpha": "rm -rf ./dist && npm run dump-version && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks --tag alpha",
     "generate-docs": "typedoc",
@@ -43,10 +44,10 @@
   "license": "MIT",
   "devDependencies": {
     "@tsd/typescript": "^5.8.2",
-    "@typescript-eslint/eslint-plugin": "^6.21.0",
-    "@typescript-eslint/parser": "^6.21.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.13.14",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
     "autoprefixer": "^10.4.21",
     "dotenv-cli": "^7.4.4",
     "eslint": "^8.56.0",
@@ -86,6 +87,7 @@
     "nice-grpc-common": "^2.0.2",
     "protobufjs": "^7.4.0",
     "qs": "^6.14.0",
+    "semver": "^7.7.1",
     "yaml": "^2.7.1",
     "zod": "^3.24.2"
   },

package/scripts/version-check.js

@@ -0,0 +1,65 @@
+/* eslint-disable no-console */
+const fs = require('fs');
+const path = require('path');
+const semver = require('semver');
+
+const WARNINGS = {
+  '1.4.0':
+    'Breaking Changes in v1.4.0: This release fixes a critical bug which makes the runNoWait methods async. You will need to await this method to access the runRef.',
+};
+
+try {
+  // Get the current package version
+  // eslint-disable-next-line global-require
+  const currentVersion = require('../package.json').version;
+
+  // Look for the package.json in various possible locations
+  const possiblePaths = [
+    // npm
+    path.join(process.cwd(), 'package.json'),
+    // pnpm
+    path.join(process.cwd(), '..', 'package.json'),
+    // yarn
+    path.join(process.cwd(), '..', '..', 'package.json'),
+    // monorepo setup
+    path.join(process.cwd(), '..', '..', '..', 'package.json'),
+  ];
+
+  let parentPackagePath = null;
+  for (const possiblePath of possiblePaths) {
+    if (fs.existsSync(possiblePath)) {
+      parentPackagePath = possiblePath;
+      break;
+    }
+  }
+
+  if (parentPackagePath) {
+    const parentPackage = JSON.parse(fs.readFileSync(parentPackagePath, 'utf8'));
+    const dependencies = {
+      ...parentPackage.dependencies,
+      ...parentPackage.devDependencies,
+    };
+
+    const installedVersion = dependencies['@hatchet-dev/typescript-sdk'];
+
+    // If there's no installed version, this is a first-time install
+    if (!installedVersion) {
+      // Show all warnings for the current version
+      for (const [version, warning] of Object.entries(WARNINGS)) {
+        if (semver.gte(currentVersion, version)) {
+          console.warn('\x1b[33m%s\x1b[0m', warning);
+        }
+      }
+    } else {
+      // Check for specific version warnings
+      for (const [version, warning] of Object.entries(WARNINGS)) {
+        if (semver.gte(currentVersion, version) && semver.lt(installedVersion, version)) {
+          console.warn('\x1b[33m%s\x1b[0m', warning);
+        }
+      }
+    }
+  }
+} catch (error) {
+  // Silently fail - this is just a warning system
+  // console.error(error);
+}

package/util/batch.d.ts

@@ -0,0 +1,7 @@
+interface BatchedItem<T> {
+    batchIndex: number;
+    payloads: T[];
+    originalIndices: number[];
+}
+export declare function batch<T>(payloads: T[], numElm: number, maxBytes: number): Array<BatchedItem<T>>;
+export {};

package/util/batch.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batch = batch;
+function batch(payloads, numElm, maxBytes) {
+    const batches = [];
+    let currentBatchPayloads = [];
+    let currentBatchIndices = [];
+    let currentBatchSize = 0;
+    for (let i = 0; i < payloads.length; i += 1) {
+        const request = payloads[i];
+        const requestSize = Buffer.byteLength(JSON.stringify(request), 'utf8');
+        // Check if adding this request would exceed either the payload limit or batch size
+        if (currentBatchPayloads.length > 0 &&
+            (currentBatchSize + requestSize > maxBytes || currentBatchPayloads.length >= numElm)) {
+            batches.push({
+                batchIndex: batches.length,
+                payloads: currentBatchPayloads,
+                originalIndices: currentBatchIndices,
+            });
+            currentBatchPayloads = [];
+            currentBatchIndices = [];
+            currentBatchSize = 0;
+        }
+        // Add the request to the current batch
+        currentBatchPayloads.push(request);
+        currentBatchIndices.push(i);
+        currentBatchSize += requestSize;
+    }
+    if (currentBatchPayloads.length > 0) {
+        batches.push({
+            batchIndex: batches.length,
+            payloads: currentBatchPayloads,
+            originalIndices: currentBatchIndices,
+        });
+    }
+    return batches;
+}

package/v1/client/admin.d.ts

@@ -59,6 +59,5 @@ export declare class AdminClient {
             priority?: Priority;
         };
     }>, batchSize?: number): Promise<WorkflowRunRef<P>[]>;
-    private batchWorkflows;
     putRateLimit(key: string, limit: number, duration?: RateLimitDuration): Promise<void>;
 }

package/v1/client/admin.js

@@ -18,6 +18,7 @@ const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"
 const grpc_helpers_1 = require("../../util/grpc-helpers");
 const child_listener_client_1 = require("../../clients/listeners/run-listener/child-listener-client");
 const workflows_1 = require("../../protoc/workflows");
+const batch_1 = require("../../util/batch");
 class AdminClient {
     constructor(config, api, runs) {
         this.config = config;
@@ -75,17 +76,16 @@ class AdminClient {
                         ? JSON.stringify(options.additionalMetadata)
                         : undefined });
             });
-            const batches = this.batchWorkflows(workflowRequests, batchSize);
+            const limit = 4 * 1024 * 1024; // FIXME configurable GRPC limit
+            const batches = (0, batch_1.batch)(workflowRequests, batchSize, limit);
             this.logger.debug(`batching ${batches.length} batches`);
             try {
-                const allResults = [];
-                // Process each batch
-                for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {
-                    const batch = batches[batchIndex];
-                    const { requests, originalIndices } = batch;
+                const results = [];
+                // for loop to ensure serial execution of batches
+                for (const { payloads, originalIndices, batchIndex } of batches) {
                     // Call the bulk trigger workflow method for this batch
                     const bulkTriggerWorkflowResponse = yield this.grpc.bulkTriggerWorkflow(workflows_1.BulkTriggerWorkflowRequest.create({
-                        workflows: requests,
+                        workflows: payloads,
                     }));
                     this.logger.debug(`batch ${batchIndex + 1} of ${batches.length}`);
                     // Map the results back to their original indices
@@ -94,54 +94,15 @@ class AdminClient {
                         const { options } = workflowRuns[originalIndex];
                         return new workflow_run_ref_1.default(resp, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId);
                     });
-                    allResults.push(...batchResults);
+                    results.push(...batchResults);
                 }
-                return allResults;
+                return results;
             }
             catch (e) {
                 throw new hatchet_error_1.default(e.message);
             }
         });
     }
-    batchWorkflows(workflowRequests, batchSize) {
-        const payloadLimit = 4 * 1024 * 1024; // 4MB limit
-        const batches = [];
-        let currentBatch = [];
-        let currentBatchIndices = [];
-        let currentBatchSize = 0;
-        for (let i = 0; i < workflowRequests.length; i += 1) {
-            const request = workflowRequests[i];
-            const requestSize = Buffer.byteLength(JSON.stringify(request), 'utf8');
-            // Check if adding this request would exceed either the payload limit or batch size
-            if (currentBatchSize + requestSize > payloadLimit || currentBatch.length >= batchSize) {
-                // If we have a batch, add it to batches
-                if (currentBatch.length > 0) {
-                    batches.push({
-                        requests: currentBatch,
-                        originalIndices: currentBatchIndices,
-                    });
-                }
-                // Start a new batch
-                currentBatch = [request];
-                currentBatchIndices = [i];
-                currentBatchSize = requestSize;
-            }
-            else {
-                // Add to current batch
-                currentBatch.push(request);
-                currentBatchIndices.push(i);
-                currentBatchSize += requestSize;
-            }
-        }
-        // Add the last batch if it exists
-        if (currentBatch.length > 0) {
-            batches.push({
-                requests: currentBatch,
-                originalIndices: currentBatchIndices,
-            });
-        }
-        return batches;
-    }
     putRateLimit(key, limit, duration) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.grpc.putRateLimit({

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

@@ -51,14 +51,14 @@ export declare class Worker {
      * @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> | V0Workflow>): Promise<void>;
     /**
      * Registers a single workflow with the worker
      * @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> | V0Workflow): Promise<void>;
     /**
      * Starts the worker
      * @returns Promise that resolves when the worker is stopped or killed

package/v1/client/worker/worker.js

@@ -50,10 +50,10 @@ class Worker {
      */
     registerWorkflows(workflows) {
         return __awaiter(this, void 0, void 0, function* () {
-            return Promise.all((workflows === null || workflows === void 0 ? void 0 : workflows.map((wf) => __awaiter(this, void 0, void 0, function* () {
+            for (const wf of workflows || []) {
                 if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
                     // TODO check if tenant is V1
-                    const register = this.nonDurable.registerWorkflowV1(wf);
+                    yield this.nonDurable.registerWorkflowV1(wf);
                     if (wf.definition._durableTasks.length > 0) {
                         if (!this.durable) {
                             const opts = Object.assign(Object.assign({ name: `${this.name}-durable` }, this.config), { maxRuns: this.config.durableSlots || DEFAULT_DURABLE_SLOTS });
@@ -62,11 +62,12 @@ class Worker {
                         }
                         this.durable.registerDurableActionsV1(wf.definition);
                     }
-                    return register;
                 }
-                // fallback to v0 client for backwards compatibility
-                return this.nonDurable.registerWorkflow(wf);
-            }))) || []);
+                else {
+                    // fallback to v0 client for backwards compatibility
+                    yield this.nonDurable.registerWorkflow(wf);
+                }
+            }
         });
     }
     /**

package/v1/examples/migration-guides/hatchet-client.d.ts

@@ -0,0 +1,2 @@
+import HatchetClient from '../../../sdk';
+export declare const hatchet: HatchetClient;

package/v1/examples/migration-guides/hatchet-client.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hatchet = void 0;
+const sdk_1 = __importDefault(require("../../../sdk"));
+exports.hatchet = sdk_1.default.init();

package/v1/examples/migration-guides/mergent.d.ts

@@ -0,0 +1,23 @@
+export declare function processImageTask(req: {
+    body: {
+        imageUrl: string;
+        filters: string[];
+    };
+}): Promise<{
+    success: boolean;
+    processedUrl: string;
+}>;
+type ImageProcessInput = {
+    imageUrl: string;
+    filters: string[];
+};
+type ImageProcessOutput = {
+    processedUrl: string;
+    metadata: {
+        size: number;
+        format: string;
+        appliedFilters: string[];
+    };
+};
+export declare const imageProcessor: import("../..").TaskWorkflowDeclaration<ImageProcessInput, ImageProcessOutput>;
+export {};

package/v1/examples/migration-guides/mergent.js

@@ -0,0 +1,109 @@
+"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.imageProcessor = void 0;
+exports.processImageTask = processImageTask;
+const hatchet_client_1 = require("./hatchet-client");
+function processImage(imageUrl, filters) {
+    // Do some image processing
+    return Promise.resolve({ url: imageUrl, size: 100, format: 'png' });
+}
+// ❓ Before (Mergent)
+function processImageTask(req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { imageUrl, filters } = req.body;
+        try {
+            const result = yield processImage(imageUrl, filters);
+            return { success: true, processedUrl: result.url };
+        }
+        catch (error) {
+            console.error('Image processing failed:', error);
+            throw error;
+        }
+    });
+}
+exports.imageProcessor = hatchet_client_1.hatchet.task({
+    name: 'image-processor',
+    retries: 3,
+    executionTimeout: '10m',
+    fn: (_a) => __awaiter(void 0, [_a], void 0, function* ({ imageUrl, filters }) {
+        // Do some image processing
+        const result = yield processImage(imageUrl, filters);
+        if (!result.url)
+            throw new Error('Processing failed to generate URL');
+        return {
+            processedUrl: result.url,
+            metadata: {
+                size: result.size,
+                format: result.format,
+                appliedFilters: filters,
+            },
+        };
+    }),
+});
+// !!
+function run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // ❓ Running a task (Mergent)
+        const options = {
+            method: 'POST',
+            headers: { Authorization: 'Bearer <token>', 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: '4cf95241-fa19-47ef-8a67-71e483747649',
+                queue: 'default',
+                request: {
+                    url: 'https://example.com',
+                    headers: { Authorization: 'fake-secret-token', 'Content-Type': 'application/json' },
+                    body: 'Hello, world!',
+                },
+            }),
+        };
+        fetch('https://api.mergent.co/v2/tasks', options)
+            .then((response) => response.json())
+            .then((response) => console.log(response))
+            .catch((err) => console.error(err));
+        // !!
+        // ❓ Running a task (Hatchet)
+        const result = yield exports.imageProcessor.run({
+            imageUrl: 'https://example.com/image.png',
+            filters: ['blur'],
+        });
+        // you can await fully typed results
+        console.log(result);
+        // !!
+    });
+}
+function schedule() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // ❓ Scheduling tasks (Mergent)
+        const options = {
+            // same options as before
+            body: JSON.stringify({
+                // same body as before
+                delay: '5m',
+            }),
+        };
+        // !!
+        // ❓ Scheduling tasks (Hatchet)
+        // Schedule the task to run at a specific time
+        const runAt = new Date(Date.now() + 1000 * 60 * 60 * 24);
+        exports.imageProcessor.schedule(runAt, {
+            imageUrl: 'https://example.com/image.png',
+            filters: ['blur'],
+        });
+        // Schedule the task to run every hour
+        exports.imageProcessor.cron('run-hourly', '0 * * * *', {
+            imageUrl: 'https://example.com/image.png',
+            filters: ['blur'],
+        });
+        // !!
+    });
+}

package/v1/index.d.ts

@@ -6,3 +6,4 @@ export * from './conditions';
 export * from './client/duration';
 export * from './types';
 export * from './task';
+export * from './client/worker/context';

package/v1/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./conditions"), exports);
 __exportStar(require("./client/duration"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./task"), exports);
+__exportStar(require("./client/worker/context"), exports);

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.4.0-alpha.2";
+export declare const HATCHET_VERSION = "1.4.1";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.4.0-alpha.2';
+exports.HATCHET_VERSION = '1.4.1';