@hatchet-dev/typescript-sdk 1.31.1 → 1.32.0

package/dist/check-edge-entry.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+// Verifies the edge entry point (`@hatchet-dev/typescript-sdk/edge`) imports nothing
+// from Node. Bundles dist/edge/index.js for a workerd-like browser target and fails on
+// any `node:` specifier or Node builtin reached from it, transitively.
+//
+// Run after `pnpm run tsc:build` (the `check:edge` script does both). An alternative
+// entry can be given as the first argument to inspect another module, for example
+// `node scripts/check-edge-entry.mjs dist/index.js` to see what the root reaches.
+import { builtinModules } from 'node:module';
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const entry = resolve(root, process.argv[2] ?? 'dist/edge/index.js');
+
+if (!existsSync(entry)) {
+  console.error(`entry not built: ${entry} is missing. Run \`pnpm run tsc:build\` first.`);
+  process.exit(1);
+}
+
+// Optional peers the declaration classes load lazily (`mcpTool()`); never reached on a
+// serverless code path and not part of the edge contract.
+const lazyOptionalPeers = ['@openai/agents', '@anthropic-ai/claude-agent-sdk', '@modelcontextprotocol/sdk'];
+
+const builtins = new Set(builtinModules.flatMap((m) => [m, `node:${m}`]));
+const violations = new Map();
+
+const nodeBuiltinDetector = {
+  name: 'node-builtin-detector',
+  setup(pluginBuild) {
+    pluginBuild.onResolve({ filter: /.*/ }, (args) => {
+      const isBuiltin = args.path.startsWith('node:') || builtins.has(args.path);
+      if (!isBuiltin) return undefined;
+      const importer = args.importer ? args.importer.replace(`${root}/`, '') : '<entry>';
+      if (!violations.has(args.path)) violations.set(args.path, new Set());
+      violations.get(args.path).add(importer);
+      // Resolve to an empty stub so the bundle continues and every violation is collected.
+      return { path: args.path, namespace: 'node-builtin-stub' };
+    });
+    pluginBuild.onLoad({ filter: /.*/, namespace: 'node-builtin-stub' }, () => ({
+      contents: 'export default {};',
+      loader: 'js',
+    }));
+  },
+};
+
+const result = await build({
+  entryPoints: [entry],
+  bundle: true,
+  write: false,
+  platform: 'browser',
+  conditions: ['workerd', 'worker', 'browser'],
+  mainFields: ['browser', 'module', 'main'],
+  format: 'esm',
+  target: 'es2022',
+  logLevel: 'silent',
+  metafile: true,
+  external: lazyOptionalPeers,
+  plugins: [nodeBuiltinDetector],
+});
+
+const bundled = Object.keys(result.metafile.inputs);
+const sdkInputs = bundled.filter((f) => f.startsWith('dist/'));
+const packageInputs = [...new Set(bundled.filter((f) => f.includes('node_modules/')).map((f) => {
+  const m = f.match(/node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?((?:@[^/]+\/)?[^/]+)/);
+  return m ? m[1] : f;
+}))].sort();
+
+console.log(`edge entry: bundled ${sdkInputs.length} SDK module(s) and ${packageInputs.length} package(s)`);
+if (packageInputs.length) console.log(`packages: ${packageInputs.join(', ')}`);
+
+if (violations.size > 0) {
+  console.error('\nedge entry reaches Node builtins:');
+  for (const [specifier, importers] of [...violations.entries()].sort()) {
+    console.error(`  ${specifier}`);
+    for (const importer of [...importers].sort()) console.error(`    from ${importer}`);
+  }
+  process.exit(1);
+}
+
+console.log('edge entry is free of Node builtins');

package/edge/declarations.d.ts

@@ -0,0 +1,49 @@
+import { CreateBatchTaskWorkflowOpts, CreateDurableTaskWorkflowOpts, CreateTaskWorkflowOpts, CreateWorkflowOpts, TaskWorkflowDeclaration, WorkflowDeclaration } from '../v1/declaration';
+import type { InputType, JsonObject, OutputType, StrictWorkflowOutputType, UnknownInputType } from '../v1/types';
+import type { BatchTaskConfig, BatchTaskFn } from '../v1/task';
+import type { DurableContext } from '../v1/client/worker/context';
+/**
+ * The declaration factories of `HatchetClient` (`task`, `durableTask`, `workflow`,
+ * `batchTask`) bound to no client. The declarations they return can be registered and
+ * served but cannot be run, scheduled or triggered from the process that declared them.
+ */
+export interface Declarations {
+    /**
+     * Declares a task. Types come from generics or are inferred from `fn`.
+     */
+    task<I extends InputType = UnknownInputType, O extends OutputType = void>(options: CreateTaskWorkflowOpts<I, O>): TaskWorkflowDeclaration<I, O>;
+    task<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends InputType = Parameters<Fn>[0], O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
+        fn: Fn;
+    } & Omit<CreateTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
+    /**
+     * Declares a durable task. Types come from generics or are inferred from `fn`.
+     */
+    durableTask<I extends InputType, O extends OutputType>(options: CreateDurableTaskWorkflowOpts<I, O>): TaskWorkflowDeclaration<I, O>;
+    durableTask<Fn extends (input: I, ctx: DurableContext<I>) => O | Promise<O>, I extends JsonObject = Parameters<Fn>[0], O extends JsonObject = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+        fn: Fn;
+    } & Omit<CreateDurableTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
+    /**
+     * Declares a workflow: a DAG of tasks added with `workflow.task(...)`.
+     */
+    workflow<I extends InputType = UnknownInputType, O extends StrictWorkflowOutputType = {}>(options: CreateWorkflowOpts): WorkflowDeclaration<I, O>;
+    /**
+     * Declares a batch task. Types come from generics or are inferred from `fn`.
+     *
+     * Preview: batch tasks are in beta and may change in future releases.
+     */
+    batchTask<I extends InputType = UnknownInputType, O extends OutputType = void>(options: CreateBatchTaskWorkflowOpts<I, O>): TaskWorkflowDeclaration<I, O>;
+    batchTask<Fn extends BatchTaskFn<I, O>, I extends InputType = Parameters<Fn>[0] extends Record<string, infer II> ? II extends InputType ? II : UnknownInputType : UnknownInputType, O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
+        fn: Fn;
+        batch: BatchTaskConfig;
+    } & Omit<CreateBatchTaskWorkflowOpts<I, O>, 'fn' | 'batch'>): TaskWorkflowDeclaration<I, O>;
+}
+/**
+ * Returns the declaration factories bound to no client, so tasks can be declared where
+ * a `HatchetClient` cannot exist (edge runtimes, or code that must not read
+ * `HATCHET_CLIENT_TOKEN`).
+ *
+ * ```typescript
+ * const { task, durableTask, workflow, batchTask } = declarations();
+ * ```
+ */
+export declare function declarations(): Declarations;

package/edge/declarations.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declarations = declarations;
+const declaration_1 = require("../v1/declaration");
+/**
+ * Returns the declaration factories bound to no client, so tasks can be declared where
+ * a `HatchetClient` cannot exist (edge runtimes, or code that must not read
+ * `HATCHET_CLIENT_TOKEN`).
+ *
+ * ```typescript
+ * const { task, durableTask, workflow, batchTask } = declarations();
+ * ```
+ */
+function declarations() {
+    return {
+        task: (options) => (0, declaration_1.CreateTaskWorkflow)(options),
+        durableTask: (options) => (0, declaration_1.CreateDurableTaskWorkflow)(options),
+        workflow: (options) => (0, declaration_1.CreateWorkflow)(options),
+        batchTask: (options) => (0, declaration_1.CreateBatchTaskWorkflow)(options),
+    };
+}

package/edge/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The edge entry point: everything needed to declare Hatchet tasks and run them from a
+ * runtime that has no Hatchet client, such as a Cloudflare Worker or a Vercel Function.
+ *
+ * Nothing exported here imports from Node. `scripts/check-edge-entry.mjs` bundles this
+ * module for a browser-like target and fails the build if a Node builtin sneaks in.
+ *
+ * ```typescript
+ * import { declarations, workflowToProto } from './';
+ *
+ * const { task } = declarations();
+ * const greet = task({ name: 'greet', fn: (input: { name: string }) => ({ hi: input.name }) });
+ * const request = workflowToProto(greet, { namespace: 'prod_' });
+ * ```
+ * @module Edge
+ */
+export { BaseWorkflowDeclaration, CreateBatchTaskWorkflow, CreateDurableTaskWorkflow, CreateTaskWorkflow, CreateWorkflow, Priority, StickyStrategy, TaskWorkflowDeclaration, WorkflowDeclaration, } from '../v1/declaration';
+export type { CreateBaseWorkflowOpts, CreateBatchTaskWorkflowOpts, CreateDurableTaskWorkflowOpts, CreateTaskWorkflowOpts, CreateWorkflowOpts, RunManyOpt, RunOpts, StickyStrategyInput, TaskDefaults, TaskOutput, TaskOutputType, WorkflowDefinition, } from '../v1/declaration';
+export * from '../v1/task';
+export * from '../v1/types';
+export * from '../v1/client/duration';
+export * from '../v1/conditions';
+export { conditionsToPb, taskConditionsToPb } from '../v1/conditions/transformer';
+export { applyNamespace } from '../util/apply-namespace';
+export { createAction, createActionId, workflowNameFromAction, } from '../clients/dispatcher/action';
+export type { Action, ActionKey } from '../clients/dispatcher/action';
+export { Context, ContextWorker, DurableContext, computeMemoKey, } from '../v1/client/worker/context';
+export type { SleepForOptions, SleepResult } from '../v1/client/worker/context';
+export type { CancelBatchRequest, ContextRuntime, DesiredWorkerLabel, DurableContextOptions, DurableTransport, SpawnRunOptions, SpawnRunRequest, WorkerLabels, } from '../v1/client/worker/runtime';
+export { isContextRuntime } from '../v1/client/worker/runtime';
+export type { DurableTaskEventAck, DurableTaskEventLogEntryResult, DurableTaskEventMemoAck, DurableTaskEventRunAck, DurableTaskEventWaitForAck, DurableTaskRunAckEntryResult, DurableTaskSendEvent, MemoEvent, RunChildrenEvent, WaitForEvent, } from '../clients/listeners/durable-listener/durable-events';
+export { Logger, LogLevelEnum } from '../util/logger/logger';
+export type { LogExtra, LogLevel } from '../util/logger/logger';
+export { ParentRunContextManager, parentRunContextManager, } from '../v1/parent-run-context-vars';
+export type { ParentRunContext, ParentRunContextStorage, } from '../v1/parent-run-context-vars';
+export { default as HatchetError, getErrorMessage, toHatchetError, } from '../util/errors/hatchet-error';
+export { NonDeterminismError } from '../util/errors/non-determinism-error';
+export { TaskRunTerminatedError, isTaskRunTerminatedError, } from '../util/errors/task-run-terminated-error';
+export type { TaskRunTerminationReason } from '../util/errors/task-run-terminated-error';
+export { AbortError, createAbortError, isAbortError, rethrowIfAborted, throwIfAborted, } from '../util/abort-error';
+export { DEFAULT_DURABLE_TASK_EVICTION_POLICY, EvictionPolicy, } from '../v1/client/worker/eviction/eviction-policy';
+export { MinEngineVersion, supportsEviction } from '../v1/client/worker/engine-version';
+export { ON_FAILURE_TASK_NAME, ON_SUCCESS_TASK_NAME, normalizeWorkflowDefinition, onFailureTaskName, workflowToProto, } from '../v1/client/worker/workflow-proto';
+export type { WorkflowProtoOptions } from '../v1/client/worker/workflow-proto';
+export { CreateWorkflowVersionRequest } from '../protoc/v1/workflows';
+export { AssignedAction } from '../protoc/dispatcher';
+export { DurableTaskRequest, DurableTaskResponse } from '../protoc/v1/dispatcher';
+export { declarations } from './declarations';
+export type { Declarations } from './declarations';

package/edge/index.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * The edge entry point: everything needed to declare Hatchet tasks and run them from a
+ * runtime that has no Hatchet client, such as a Cloudflare Worker or a Vercel Function.
+ *
+ * Nothing exported here imports from Node. `scripts/check-edge-entry.mjs` bundles this
+ * module for a browser-like target and fails the build if a Node builtin sneaks in.
+ *
+ * ```typescript
+ * import { declarations, workflowToProto } from './index.js';
+ *
+ * const { task } = declarations();
+ * const greet = task({ name: 'greet', fn: (input: { name: string }) => ({ hi: input.name }) });
+ * const request = workflowToProto(greet, { namespace: 'prod_' });
+ * ```
+ * @module Edge
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declarations = exports.DurableTaskResponse = exports.DurableTaskRequest = exports.AssignedAction = exports.CreateWorkflowVersionRequest = exports.workflowToProto = exports.onFailureTaskName = exports.normalizeWorkflowDefinition = exports.ON_SUCCESS_TASK_NAME = exports.ON_FAILURE_TASK_NAME = exports.supportsEviction = exports.MinEngineVersion = exports.DEFAULT_DURABLE_TASK_EVICTION_POLICY = exports.throwIfAborted = exports.rethrowIfAborted = exports.isAbortError = exports.createAbortError = exports.AbortError = exports.isTaskRunTerminatedError = exports.TaskRunTerminatedError = exports.NonDeterminismError = exports.toHatchetError = exports.getErrorMessage = exports.HatchetError = exports.parentRunContextManager = exports.ParentRunContextManager = exports.LogLevelEnum = exports.Logger = exports.isContextRuntime = exports.computeMemoKey = exports.DurableContext = exports.ContextWorker = exports.Context = exports.workflowNameFromAction = exports.createActionId = exports.createAction = exports.applyNamespace = exports.taskConditionsToPb = exports.conditionsToPb = exports.WorkflowDeclaration = exports.TaskWorkflowDeclaration = exports.StickyStrategy = exports.Priority = exports.CreateWorkflow = exports.CreateTaskWorkflow = exports.CreateDurableTaskWorkflow = exports.CreateBatchTaskWorkflow = exports.BaseWorkflowDeclaration = void 0;
+// Declarations
+var declaration_1 = require("../v1/declaration");
+Object.defineProperty(exports, "BaseWorkflowDeclaration", { enumerable: true, get: function () { return declaration_1.BaseWorkflowDeclaration; } });
+Object.defineProperty(exports, "CreateBatchTaskWorkflow", { enumerable: true, get: function () { return declaration_1.CreateBatchTaskWorkflow; } });
+Object.defineProperty(exports, "CreateDurableTaskWorkflow", { enumerable: true, get: function () { return declaration_1.CreateDurableTaskWorkflow; } });
+Object.defineProperty(exports, "CreateTaskWorkflow", { enumerable: true, get: function () { return declaration_1.CreateTaskWorkflow; } });
+Object.defineProperty(exports, "CreateWorkflow", { enumerable: true, get: function () { return declaration_1.CreateWorkflow; } });
+Object.defineProperty(exports, "Priority", { enumerable: true, get: function () { return declaration_1.Priority; } });
+Object.defineProperty(exports, "StickyStrategy", { enumerable: true, get: function () { return declaration_1.StickyStrategy; } });
+Object.defineProperty(exports, "TaskWorkflowDeclaration", { enumerable: true, get: function () { return declaration_1.TaskWorkflowDeclaration; } });
+Object.defineProperty(exports, "WorkflowDeclaration", { enumerable: true, get: function () { return declaration_1.WorkflowDeclaration; } });
+// Tasks, types, durations and conditions
+__exportStar(require("../v1/task"), exports);
+__exportStar(require("../v1/types"), exports);
+__exportStar(require("../v1/client/duration"), exports);
+__exportStar(require("../v1/conditions"), exports);
+var transformer_1 = require("../v1/conditions/transformer");
+Object.defineProperty(exports, "conditionsToPb", { enumerable: true, get: function () { return transformer_1.conditionsToPb; } });
+Object.defineProperty(exports, "taskConditionsToPb", { enumerable: true, get: function () { return transformer_1.taskConditionsToPb; } });
+// Naming
+var apply_namespace_1 = require("../util/apply-namespace");
+Object.defineProperty(exports, "applyNamespace", { enumerable: true, get: function () { return apply_namespace_1.applyNamespace; } });
+var action_1 = require("../clients/dispatcher/action");
+Object.defineProperty(exports, "createAction", { enumerable: true, get: function () { return action_1.createAction; } });
+Object.defineProperty(exports, "createActionId", { enumerable: true, get: function () { return action_1.createActionId; } });
+Object.defineProperty(exports, "workflowNameFromAction", { enumerable: true, get: function () { return action_1.workflowNameFromAction; } });
+// Contexts and the runtime seams they depend on
+var context_1 = require("../v1/client/worker/context");
+Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });
+Object.defineProperty(exports, "ContextWorker", { enumerable: true, get: function () { return context_1.ContextWorker; } });
+Object.defineProperty(exports, "DurableContext", { enumerable: true, get: function () { return context_1.DurableContext; } });
+Object.defineProperty(exports, "computeMemoKey", { enumerable: true, get: function () { return context_1.computeMemoKey; } });
+var runtime_1 = require("../v1/client/worker/runtime");
+Object.defineProperty(exports, "isContextRuntime", { enumerable: true, get: function () { return runtime_1.isContextRuntime; } });
+var logger_1 = require("../util/logger/logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+Object.defineProperty(exports, "LogLevelEnum", { enumerable: true, get: function () { return logger_1.LogLevelEnum; } });
+var parent_run_context_vars_1 = require("../v1/parent-run-context-vars");
+Object.defineProperty(exports, "ParentRunContextManager", { enumerable: true, get: function () { return parent_run_context_vars_1.ParentRunContextManager; } });
+Object.defineProperty(exports, "parentRunContextManager", { enumerable: true, get: function () { return parent_run_context_vars_1.parentRunContextManager; } });
+// Errors
+var hatchet_error_1 = require("../util/errors/hatchet-error");
+Object.defineProperty(exports, "HatchetError", { enumerable: true, get: function () { return __importDefault(hatchet_error_1).default; } });
+Object.defineProperty(exports, "getErrorMessage", { enumerable: true, get: function () { return hatchet_error_1.getErrorMessage; } });
+Object.defineProperty(exports, "toHatchetError", { enumerable: true, get: function () { return hatchet_error_1.toHatchetError; } });
+var non_determinism_error_1 = require("../util/errors/non-determinism-error");
+Object.defineProperty(exports, "NonDeterminismError", { enumerable: true, get: function () { return non_determinism_error_1.NonDeterminismError; } });
+var task_run_terminated_error_1 = require("../util/errors/task-run-terminated-error");
+Object.defineProperty(exports, "TaskRunTerminatedError", { enumerable: true, get: function () { return task_run_terminated_error_1.TaskRunTerminatedError; } });
+Object.defineProperty(exports, "isTaskRunTerminatedError", { enumerable: true, get: function () { return task_run_terminated_error_1.isTaskRunTerminatedError; } });
+var abort_error_1 = require("../util/abort-error");
+Object.defineProperty(exports, "AbortError", { enumerable: true, get: function () { return abort_error_1.AbortError; } });
+Object.defineProperty(exports, "createAbortError", { enumerable: true, get: function () { return abort_error_1.createAbortError; } });
+Object.defineProperty(exports, "isAbortError", { enumerable: true, get: function () { return abort_error_1.isAbortError; } });
+Object.defineProperty(exports, "rethrowIfAborted", { enumerable: true, get: function () { return abort_error_1.rethrowIfAborted; } });
+Object.defineProperty(exports, "throwIfAborted", { enumerable: true, get: function () { return abort_error_1.throwIfAborted; } });
+// Eviction policy
+var eviction_policy_1 = require("../v1/client/worker/eviction/eviction-policy");
+Object.defineProperty(exports, "DEFAULT_DURABLE_TASK_EVICTION_POLICY", { enumerable: true, get: function () { return eviction_policy_1.DEFAULT_DURABLE_TASK_EVICTION_POLICY; } });
+var engine_version_1 = require("../v1/client/worker/engine-version");
+Object.defineProperty(exports, "MinEngineVersion", { enumerable: true, get: function () { return engine_version_1.MinEngineVersion; } });
+Object.defineProperty(exports, "supportsEviction", { enumerable: true, get: function () { return engine_version_1.supportsEviction; } });
+// Registration
+var workflow_proto_1 = require("../v1/client/worker/workflow-proto");
+Object.defineProperty(exports, "ON_FAILURE_TASK_NAME", { enumerable: true, get: function () { return workflow_proto_1.ON_FAILURE_TASK_NAME; } });
+Object.defineProperty(exports, "ON_SUCCESS_TASK_NAME", { enumerable: true, get: function () { return workflow_proto_1.ON_SUCCESS_TASK_NAME; } });
+Object.defineProperty(exports, "normalizeWorkflowDefinition", { enumerable: true, get: function () { return workflow_proto_1.normalizeWorkflowDefinition; } });
+Object.defineProperty(exports, "onFailureTaskName", { enumerable: true, get: function () { return workflow_proto_1.onFailureTaskName; } });
+Object.defineProperty(exports, "workflowToProto", { enumerable: true, get: function () { return workflow_proto_1.workflowToProto; } });
+// Wire types
+var workflows_1 = require("../protoc/v1/workflows");
+Object.defineProperty(exports, "CreateWorkflowVersionRequest", { enumerable: true, get: function () { return workflows_1.CreateWorkflowVersionRequest; } });
+var dispatcher_1 = require("../protoc/dispatcher");
+Object.defineProperty(exports, "AssignedAction", { enumerable: true, get: function () { return dispatcher_1.AssignedAction; } });
+var dispatcher_2 = require("../protoc/v1/dispatcher");
+Object.defineProperty(exports, "DurableTaskRequest", { enumerable: true, get: function () { return dispatcher_2.DurableTaskRequest; } });
+Object.defineProperty(exports, "DurableTaskResponse", { enumerable: true, get: function () { return dispatcher_2.DurableTaskResponse; } });
+var declarations_1 = require("./declarations");
+Object.defineProperty(exports, "declarations", { enumerable: true, get: function () { return declarations_1.declarations; } });

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.31.1",
+  "version": "1.32.0",
+  "engines": {
+    "node": ">=20"
+  },
   "description": "Background task orchestration & visibility for developers",
-  "types": "dist/index.d.ts",
+  "types": "index.d.ts",
   "files": [
     "*",
     "!**/*.test.js",
@@ -48,6 +51,7 @@
     "@types/node": "^22.13.14",
     "autoprefixer": "^10.4.27",
     "dotenv-cli": "^7.4.4",
+    "esbuild": "0.28.2",
     "eslint": "^10.0.3",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^3.10.0",
@@ -140,6 +144,7 @@
     "dump-version": "node -e \"console.log('export const HATCHET_VERSION = \\'' + require('./package.json').version + '\\';');\" > src/version.ts",
     "tsc:build": "pnpm run dump-version && tsc && resolve-tspaths",
     "test:unit": "jest --testMatch='**/*.test.ts'",
+    "check:edge": "pnpm run tsc:build && node scripts/check-edge-entry.mjs",
     "test:e2e": "jest --config jest.e2e.config.ts --silent --forceExit --runInBand",
     "test:unit:watch": "jest --testMatch='**/*.test.ts' --watch",
     "generate": "pnpm run '/generate-.*/'",

package/scripts/check-edge-entry.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+// Verifies the edge entry point (`@hatchet-dev/typescript-sdk/edge`) imports nothing
+// from Node. Bundles dist/edge/index.js for a workerd-like browser target and fails on
+// any `node:` specifier or Node builtin reached from it, transitively.
+//
+// Run after `pnpm run tsc:build` (the `check:edge` script does both). An alternative
+// entry can be given as the first argument to inspect another module, for example
+// `node scripts/check-edge-entry.mjs dist/index.js` to see what the root reaches.
+import { builtinModules } from 'node:module';
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const entry = resolve(root, process.argv[2] ?? 'dist/edge/index.js');
+
+if (!existsSync(entry)) {
+  console.error(`entry not built: ${entry} is missing. Run \`pnpm run tsc:build\` first.`);
+  process.exit(1);
+}
+
+// Optional peers the declaration classes load lazily (`mcpTool()`); never reached on a
+// serverless code path and not part of the edge contract.
+const lazyOptionalPeers = ['@openai/agents', '@anthropic-ai/claude-agent-sdk', '@modelcontextprotocol/sdk'];
+
+const builtins = new Set(builtinModules.flatMap((m) => [m, `node:${m}`]));
+const violations = new Map();
+
+const nodeBuiltinDetector = {
+  name: 'node-builtin-detector',
+  setup(pluginBuild) {
+    pluginBuild.onResolve({ filter: /.*/ }, (args) => {
+      const isBuiltin = args.path.startsWith('node:') || builtins.has(args.path);
+      if (!isBuiltin) return undefined;
+      const importer = args.importer ? args.importer.replace(`${root}/`, '') : '<entry>';
+      if (!violations.has(args.path)) violations.set(args.path, new Set());
+      violations.get(args.path).add(importer);
+      // Resolve to an empty stub so the bundle continues and every violation is collected.
+      return { path: args.path, namespace: 'node-builtin-stub' };
+    });
+    pluginBuild.onLoad({ filter: /.*/, namespace: 'node-builtin-stub' }, () => ({
+      contents: 'export default {};',
+      loader: 'js',
+    }));
+  },
+};
+
+const result = await build({
+  entryPoints: [entry],
+  bundle: true,
+  write: false,
+  platform: 'browser',
+  conditions: ['workerd', 'worker', 'browser'],
+  mainFields: ['browser', 'module', 'main'],
+  format: 'esm',
+  target: 'es2022',
+  logLevel: 'silent',
+  metafile: true,
+  external: lazyOptionalPeers,
+  plugins: [nodeBuiltinDetector],
+});
+
+const bundled = Object.keys(result.metafile.inputs);
+const sdkInputs = bundled.filter((f) => f.startsWith('dist/'));
+const packageInputs = [...new Set(bundled.filter((f) => f.includes('node_modules/')).map((f) => {
+  const m = f.match(/node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?((?:@[^/]+\/)?[^/]+)/);
+  return m ? m[1] : f;
+}))].sort();
+
+console.log(`edge entry: bundled ${sdkInputs.length} SDK module(s) and ${packageInputs.length} package(s)`);
+if (packageInputs.length) console.log(`packages: ${packageInputs.join(', ')}`);
+
+if (violations.size > 0) {
+  console.error('\nedge entry reaches Node builtins:');
+  for (const [specifier, importers] of [...violations.entries()].sort()) {
+    console.error(`  ${specifier}`);
+    for (const importer of [...importers].sort()) console.error(`    from ${importer}`);
+  }
+  process.exit(1);
+}
+
+console.log('edge entry is free of Node builtins');

package/util/abort-error.d.ts

@@ -13,16 +13,6 @@ export declare function isAbortError(err: unknown): err is Error;
  * ```
  */
 export declare function rethrowIfAborted(err: unknown): void;
-/**
- * Attach an `abort` listener to a signal, disabling the Node.js
- * `MaxListenersExceededWarning` first.
- *
- * A single durable task can attach many concurrent listeners to the same signal
- * (fan-out children, parallel waitFor calls, etc.), easily exceeding the default
- * cap of 10. Setting max to 0 (unlimited) is safe here because every listener is
- * removed on settlement.
- */
-export declare function bindAbortSignalHandler(signal: AbortSignal, handler: () => void): void;
 export type ThrowIfAbortedOpts = {
     /**
      * Optional: called before throwing when the signal is aborted.

package/util/abort-error.js

@@ -4,9 +4,7 @@ exports.AbortError = void 0;
 exports.createAbortError = createAbortError;
 exports.isAbortError = isAbortError;
 exports.rethrowIfAborted = rethrowIfAborted;
-exports.bindAbortSignalHandler = bindAbortSignalHandler;
 exports.throwIfAborted = throwIfAborted;
-const events_1 = require("events");
 class AbortError extends Error {
     constructor(message = 'Operation aborted') {
         super(message);
@@ -38,19 +36,6 @@ function rethrowIfAborted(err) {
         throw err;
     }
 }
-/**
- * Attach an `abort` listener to a signal, disabling the Node.js
- * `MaxListenersExceededWarning` first.
- *
- * A single durable task can attach many concurrent listeners to the same signal
- * (fan-out children, parallel waitFor calls, etc.), easily exceeding the default
- * cap of 10. Setting max to 0 (unlimited) is safe here because every listener is
- * removed on settlement.
- */
-function bindAbortSignalHandler(signal, handler) {
-    (0, events_1.setMaxListeners)(0, signal);
-    signal.addEventListener('abort', handler, { once: true });
-}
 /**
  * Throws an AbortError if the provided signal is aborted.
  *

package/util/abort-signal.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Attach an `abort` listener to a signal, disabling the Node.js
+ * `MaxListenersExceededWarning` first.
+ *
+ * A single durable task can attach many concurrent listeners to the same signal
+ * (fan-out children, parallel waitFor calls, etc.), easily exceeding the default
+ * cap of 10. Setting max to 0 (unlimited) is safe here because every listener is
+ * removed on settlement.
+ *
+ * Lives apart from `abort-error.ts` so the abort helpers stay free of Node imports.
+ */
+export declare function bindAbortSignalHandler(signal: AbortSignal, handler: () => void): void;

package/util/abort-signal.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindAbortSignalHandler = bindAbortSignalHandler;
+const events_1 = require("events");
+/**
+ * Attach an `abort` listener to a signal, disabling the Node.js
+ * `MaxListenersExceededWarning` first.
+ *
+ * A single durable task can attach many concurrent listeners to the same signal
+ * (fan-out children, parallel waitFor calls, etc.), easily exceeding the default
+ * cap of 10. Setting max to 0 (unlimited) is safe here because every listener is
+ * removed on settlement.
+ *
+ * Lives apart from `abort-error.ts` so the abort helpers stay free of Node imports.
+ */
+function bindAbortSignalHandler(signal, handler) {
+    (0, events_1.setMaxListeners)(0, signal);
+    signal.addEventListener('abort', handler, { once: true });
+}

package/util/logger/logger.d.ts

@@ -1,4 +1,4 @@
-import { JsonObject } from '../../v1';
+import { JsonObject } from '../../v1/types';
 export type LogExtra = JsonObject;
 export declare abstract class Logger {
     abstract debug(message: string, extra?: LogExtra): void | Promise<void>;