@trigger.dev/sdk 2.2.10 → 2.3.0

package/dist/index.js

@@ -1,29 +1,24 @@
-"use strict";
-var __create = Object.create;
+'use strict';
+
+var node_async_hooks = require('node:async_hooks');
+var core = require('@trigger.dev/core');
+var node_process = require('node:process');
+var zod = require('zod');
+var coreBackend = require('@trigger.dev/core-backend');
+var crypto = require('node:crypto');
+var node_buffer = require('node:buffer');
+var cronstrue = require('cronstrue');
+var EventEmitter = require('node:events');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var cronstrue__default = /*#__PURE__*/_interopDefault(cronstrue);
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
@@ -50,58 +45,9 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  CronTrigger: () => CronTrigger,
-  DynamicSchedule: () => DynamicSchedule,
-  DynamicTrigger: () => DynamicTrigger,
-  EventSpecificationExampleSchema: () => EventSpecificationExampleSchema,
-  EventTrigger: () => EventTrigger,
-  ExternalSource: () => ExternalSource,
-  ExternalSourceTrigger: () => ExternalSourceTrigger,
-  IO: () => IO,
-  IOLogger: () => IOLogger,
-  IntervalTrigger: () => IntervalTrigger,
-  InvokeTrigger: () => InvokeTrigger,
-  JSONOutputSerializer: () => JSONOutputSerializer,
-  Job: () => Job,
-  MissingConnectionNotification: () => MissingConnectionNotification,
-  MissingConnectionResolvedNotification: () => MissingConnectionResolvedNotification,
-  TriggerClient: () => TriggerClient,
-  WebhookSource: () => WebhookSource,
-  WebhookTrigger: () => WebhookTrigger,
-  cronTrigger: () => cronTrigger,
-  eventTrigger: () => eventTrigger,
-  intervalTrigger: () => intervalTrigger,
-  invokeTrigger: () => invokeTrigger,
-  isTriggerError: () => isTriggerError,
-  missingConnectionNotification: () => missingConnectionNotification,
-  missingConnectionResolvedNotification: () => missingConnectionResolvedNotification,
-  omit: () => omit,
-  redactString: () => redactString,
-  retry: () => retry,
-  slugifyId: () => slugifyId,
-  verifyHmacSha256: () => verifyHmacSha256,
-  verifyRequestSignature: () => verifyRequestSignature,
-  waitForEventSchema: () => waitForEventSchema
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/utils.ts
-function slugifyId(input) {
-  const replaceSpacesWithDash = input.toLowerCase().replace(/\s+/g, "-");
-  const removeNonUrlSafeChars = replaceSpacesWithDash.replace(/[^a-zA-Z0-9-._~]/g, "");
-  return removeNonUrlSafeChars;
-}
-__name(slugifyId, "slugifyId");
-
-// src/utils/typedAsyncLocalStorage.ts
-var import_node_async_hooks = require("async_hooks");
-var TypedAsyncLocalStorage = class {
+var _TypedAsyncLocalStorage = class _TypedAsyncLocalStorage {
   constructor() {
-    this.storage = new import_node_async_hooks.AsyncLocalStorage();
+    this.storage = new node_async_hooks.AsyncLocalStorage();
   }
   runWith(context, fn) {
     return this.storage.run(context, fn);
@@ -110,20 +56,36 @@ var TypedAsyncLocalStorage = class {
     return this.storage.getStore();
   }
 };
-__name(TypedAsyncLocalStorage, "TypedAsyncLocalStorage");
+__name(_TypedAsyncLocalStorage, "TypedAsyncLocalStorage");
+var TypedAsyncLocalStorage = _TypedAsyncLocalStorage;
 
 // src/runLocalStorage.ts
 var runLocalStorage = new TypedAsyncLocalStorage();
 
+// src/utils.ts
+function slugifyId(input) {
+  const replaceSpacesWithDash = input.toLowerCase().replace(/\s+/g, "-");
+  const removeNonUrlSafeChars = replaceSpacesWithDash.replace(/[^a-zA-Z0-9-._~]/g, "");
+  return removeNonUrlSafeChars;
+}
+__name(slugifyId, "slugifyId");
+
 // src/job.ts
 var _validate, validate_fn;
-var Job = class {
-  constructor(client, options) {
+var _Job = class _Job {
+  constructor(options) {
+    // Make sure the id is valid (must only contain alphanumeric characters and dashes)
+    // Make sure the version is valid (must be a valid semver version)
     __privateAdd(this, _validate);
-    this.client = client;
     this.options = options;
     __privateMethod(this, _validate, validate_fn).call(this);
-    client.attach(this);
+  }
+  /**
+  * Attaches the job to a client. This is called automatically when you define a job using `client.defineJob()`.
+  */
+  attachToClient(client) {
+    this.client = client;
+    this.trigger.attachToJob(client, this);
   }
   get id() {
     return slugifyId(this.options.id);
@@ -174,6 +136,10 @@ var Job = class {
     };
   }
   async invoke(param1, param2 = void 0, param3 = void 0) {
+    const triggerClient = this.client;
+    if (!triggerClient) {
+      throw new Error("Cannot invoke a job that is not attached to a client. Make sure you attach the job to a client before invoking it.");
+    }
     const runStore = runLocalStorage.getStore();
     if (typeof param1 === "string") {
       if (!runStore) {
@@ -181,7 +147,7 @@ var Job = class {
       }
       const options = param3 ?? {};
       return await runStore.io.runTask(param1, async (task) => {
-        const result = await this.client.invokeJob(this.id, param2, {
+        const result = await triggerClient.invokeJob(this.id, param2, {
           idempotencyKey: task.idempotencyKey,
           ...options
         });
@@ -212,9 +178,13 @@ var Job = class {
     if (runStore) {
       throw new Error("Cannot invoke a job from within a run without a cacheKey.");
     }
-    return await this.client.invokeJob(this.id, param1, param3);
+    return await triggerClient.invokeJob(this.id, param1, param3);
   }
   async invokeAndWaitForCompletion(cacheKey, payload, timeoutInSeconds = 60 * 60, options = {}) {
+    const triggerClient = this.client;
+    if (!triggerClient) {
+      throw new Error("Cannot invoke a job that is not attached to a client. Make sure you attach the job to a client before invoking it.");
+    }
     const runStore = runLocalStorage.getStore();
     if (!runStore) {
       throw new Error("Cannot invoke a job from outside of a run using invokeAndWaitForCompletion. Make sure you are running the job from within a run or use the invoke method instead.");
@@ -222,7 +192,7 @@ var Job = class {
     const { io, ctx } = runStore;
     return await io.runTask(cacheKey, async (task) => {
       const parsedPayload = this.trigger.event.parseInvokePayload ? this.trigger.event.parseInvokePayload(payload) ? payload : void 0 : payload;
-      const result = await this.client.invokeJob(this.id, parsedPayload, {
+      const result = await triggerClient.invokeJob(this.id, parsedPayload, {
         idempotencyKey: task.idempotencyKey,
         callbackUrl: task.callbackUrl ?? void 0,
         ...options
@@ -286,71 +256,64 @@ var Job = class {
     return results;
   }
 };
-__name(Job, "Job");
 _validate = new WeakSet();
 validate_fn = /* @__PURE__ */ __name(function() {
   if (!this.version.match(/^(\d+)\.(\d+)\.(\d+)$/)) {
     throw new Error(`Invalid job version: "${this.version}". Job versions must be valid semver versions.`);
   }
 }, "#validate");
-
-// src/triggerClient.ts
-var import_core8 = require("@trigger.dev/core");
-var import_colorette = require("colorette");
-
-// src/apiClient.ts
-var import_core3 = require("@trigger.dev/core");
-var import_zod3 = require("zod");
-
-// src/io.ts
-var import_core2 = require("@trigger.dev/core");
-var import_core_backend = require("@trigger.dev/core-backend");
-var import_node_async_hooks2 = require("async_hooks");
-var import_node_crypto = require("crypto");
+__name(_Job, "Job");
+var Job = _Job;
 
 // src/errors.ts
-var ResumeWithTaskError = class {
+var _ResumeWithTaskError = class _ResumeWithTaskError {
   constructor(task) {
     this.task = task;
   }
 };
-__name(ResumeWithTaskError, "ResumeWithTaskError");
-var ResumeWithParallelTaskError = class {
+__name(_ResumeWithTaskError, "ResumeWithTaskError");
+var ResumeWithTaskError = _ResumeWithTaskError;
+var _ResumeWithParallelTaskError = class _ResumeWithParallelTaskError {
   constructor(task, childErrors) {
     this.task = task;
     this.childErrors = childErrors;
   }
 };
-__name(ResumeWithParallelTaskError, "ResumeWithParallelTaskError");
-var RetryWithTaskError = class {
+__name(_ResumeWithParallelTaskError, "ResumeWithParallelTaskError");
+var ResumeWithParallelTaskError = _ResumeWithParallelTaskError;
+var _RetryWithTaskError = class _RetryWithTaskError {
   constructor(cause, task, retryAt) {
     this.cause = cause;
     this.task = task;
     this.retryAt = retryAt;
   }
 };
-__name(RetryWithTaskError, "RetryWithTaskError");
-var CanceledWithTaskError = class {
+__name(_RetryWithTaskError, "RetryWithTaskError");
+var RetryWithTaskError = _RetryWithTaskError;
+var _CanceledWithTaskError = class _CanceledWithTaskError {
   constructor(task) {
     this.task = task;
   }
 };
-__name(CanceledWithTaskError, "CanceledWithTaskError");
-var YieldExecutionError = class {
+__name(_CanceledWithTaskError, "CanceledWithTaskError");
+var CanceledWithTaskError = _CanceledWithTaskError;
+var _YieldExecutionError = class _YieldExecutionError {
   constructor(key) {
     this.key = key;
   }
 };
-__name(YieldExecutionError, "YieldExecutionError");
-var AutoYieldExecutionError = class {
+__name(_YieldExecutionError, "YieldExecutionError");
+var YieldExecutionError = _YieldExecutionError;
+var _AutoYieldExecutionError = class _AutoYieldExecutionError {
   constructor(location, timeRemaining, timeElapsed) {
     this.location = location;
     this.timeRemaining = timeRemaining;
     this.timeElapsed = timeElapsed;
   }
 };
-__name(AutoYieldExecutionError, "AutoYieldExecutionError");
-var AutoYieldWithCompletedTaskExecutionError = class {
+__name(_AutoYieldExecutionError, "AutoYieldExecutionError");
+var AutoYieldExecutionError = _AutoYieldExecutionError;
+var _AutoYieldWithCompletedTaskExecutionError = class _AutoYieldWithCompletedTaskExecutionError {
   constructor(id, properties, data, output) {
     this.id = id;
     this.properties = properties;
@@ -358,27 +321,27 @@ var AutoYieldWithCompletedTaskExecutionError = class {
     this.output = output;
   }
 };
-__name(AutoYieldWithCompletedTaskExecutionError, "AutoYieldWithCompletedTaskExecutionError");
-var ParsedPayloadSchemaError = class {
+__name(_AutoYieldWithCompletedTaskExecutionError, "AutoYieldWithCompletedTaskExecutionError");
+var AutoYieldWithCompletedTaskExecutionError = _AutoYieldWithCompletedTaskExecutionError;
+var _ParsedPayloadSchemaError = class _ParsedPayloadSchemaError {
   constructor(schemaErrors) {
     this.schemaErrors = schemaErrors;
   }
 };
-__name(ParsedPayloadSchemaError, "ParsedPayloadSchemaError");
+__name(_ParsedPayloadSchemaError, "ParsedPayloadSchemaError");
+var ParsedPayloadSchemaError = _ParsedPayloadSchemaError;
 function isTriggerError(err) {
   return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError || err instanceof YieldExecutionError || err instanceof AutoYieldExecutionError || err instanceof AutoYieldWithCompletedTaskExecutionError || err instanceof ResumeWithParallelTaskError;
 }
 __name(isTriggerError, "isTriggerError");
-var ErrorWithTask = class extends Error {
+var _ErrorWithTask = class _ErrorWithTask extends Error {
   constructor(cause, message) {
     super(message);
     this.cause = cause;
   }
 };
-__name(ErrorWithTask, "ErrorWithTask");
-
-// src/retry.ts
-var import_core = require("@trigger.dev/core");
+__name(_ErrorWithTask, "ErrorWithTask");
+var ErrorWithTask = _ErrorWithTask;
 var retry = {
   standardBackoff: {
     limit: 8,
@@ -397,7 +360,7 @@ var retry = {
 };
 
 // src/status.ts
-var TriggerStatus = class {
+var _TriggerStatus = class _TriggerStatus {
   constructor(id, io) {
     this.id = id;
     this.io = io;
@@ -428,35 +391,30 @@ var TriggerStatus = class {
     });
   }
 };
-__name(TriggerStatus, "TriggerStatus");
-
-// src/types.ts
-var import_zod = require("zod");
-var EventSpecificationExampleSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  name: import_zod.z.string(),
-  icon: import_zod.z.string().optional(),
-  payload: import_zod.z.any()
+__name(_TriggerStatus, "TriggerStatus");
+var TriggerStatus = _TriggerStatus;
+var EventSpecificationExampleSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  icon: zod.z.string().optional(),
+  payload: zod.z.any()
 });
 function waitForEventSchema(schema) {
-  return import_zod.z.object({
-    id: import_zod.z.string(),
-    name: import_zod.z.string(),
-    source: import_zod.z.string(),
+  return zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    source: zod.z.string(),
     payload: schema,
-    timestamp: import_zod.z.coerce.date(),
-    context: import_zod.z.any().optional(),
-    accountId: import_zod.z.string().optional()
+    timestamp: zod.z.coerce.date(),
+    context: zod.z.any().optional(),
+    accountId: zod.z.string().optional()
   });
 }
 __name(waitForEventSchema, "waitForEventSchema");
 
-// src/io.ts
-var import_zod2 = require("zod");
-
 // src/store/keyValueStore.ts
 var _namespacedKey, namespacedKey_fn, _sharedProperties, sharedProperties_fn;
-var KeyValueStore = class {
+var _KeyValueStore = class _KeyValueStore {
   constructor(apiClient, type = null, namespace = "") {
     __privateAdd(this, _namespacedKey);
     __privateAdd(this, _sharedProperties);
@@ -579,7 +537,6 @@ var KeyValueStore = class {
     });
   }
 };
-__name(KeyValueStore, "KeyValueStore");
 _namespacedKey = new WeakSet();
 namespacedKey_fn = /* @__PURE__ */ __name(function(key) {
   const parts = [];
@@ -605,9 +562,9 @@ sharedProperties_fn = /* @__PURE__ */ __name(function(key1) {
     }
   ];
 }, "#sharedProperties");
-
-// src/io.ts
-var JSONOutputSerializer = class {
+__name(_KeyValueStore, "KeyValueStore");
+var KeyValueStore = _KeyValueStore;
+var _JSONOutputSerializer = class _JSONOutputSerializer {
   serialize(value) {
     return JSON.stringify(value);
   }
@@ -615,9 +572,10 @@ var JSONOutputSerializer = class {
     return value ? JSON.parse(value) : void 0;
   }
 };
-__name(JSONOutputSerializer, "JSONOutputSerializer");
+__name(_JSONOutputSerializer, "JSONOutputSerializer");
+var JSONOutputSerializer = _JSONOutputSerializer;
 var _addToCachedTasks, addToCachedTasks_fn, _detectAutoYield, detectAutoYield_fn, _forceYield, forceYield_fn, _getTimeElapsed, getTimeElapsed_fn, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn;
-var IO = class {
+var _IO = class _IO {
   constructor(options) {
     __privateAdd(this, _addToCachedTasks);
     __privateAdd(this, _detectAutoYield);
@@ -626,12 +584,15 @@ var IO = class {
     __privateAdd(this, _getRemainingTimeInMillis);
     __publicField(this, "_outputSerializer", new JSONOutputSerializer());
     __publicField(this, "_visitedCacheKeys", /* @__PURE__ */ new Set());
+    /**
+    * `io.brb()` is an alias of `io.yield()`
+    */
     __publicField(this, "brb", this.yield.bind(this));
     this._id = options.id;
     this._jobId = options.jobId;
     this._apiClient = options.apiClient;
     this._triggerClient = options.client;
-    this._logger = options.logger ?? new import_core2.Logger("trigger.dev", options.logLevel);
+    this._logger = options.logger ?? new core.Logger("trigger.dev", options.logLevel);
     this._cachedTasks = /* @__PURE__ */ new Map();
     this._jobLogger = options.jobLogger;
     this._jobLogLevel = options.jobLogLevel;
@@ -655,11 +616,11 @@ var IO = class {
       });
       this._stats.initialCachedTasks = options.cachedTasks.length;
     }
-    this._taskStorage = new import_node_async_hooks2.AsyncLocalStorage();
+    this._taskStorage = new node_async_hooks.AsyncLocalStorage();
     this._context = options.context;
     this._yieldedExecutions = options.yieldedExecutions ?? [];
     if (options.noopTasksSet) {
-      this._noopTasksBloomFilter = import_core_backend.BloomFilter.deserialize(options.noopTasksSet, import_core_backend.BloomFilter.NOOP_TASK_SET_SIZE);
+      this._noopTasksBloomFilter = coreBackend.BloomFilter.deserialize(options.noopTasksSet, coreBackend.BloomFilter.NOOP_TASK_SET_SIZE);
     }
     this._cachedTasksCursor = options.cachedTasksCursor;
     this._serverVersion = options.serverVersion ?? "unversioned";
@@ -667,16 +628,19 @@ var IO = class {
   get stats() {
     return this._stats;
   }
+  /** @internal */
   get runId() {
     return this._id;
   }
+  /** @internal */
   get triggerClient() {
     return this._triggerClient;
   }
+  /** Used to send log messages to the [Run log](https://trigger.dev/docs/documentation/guides/viewing-runs). */
   get logger() {
     return new IOLogger(async (level, message, data) => {
       let logLevel = "info";
-      if (import_core2.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
+      if (core.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
         await this.runTask([
           message,
           level
@@ -728,6 +692,12 @@ var IO = class {
       }
     });
   }
+  /** `io.random()` is identical to `Math.random()` when called without options but ensures your random numbers are not regenerated on resume or retry. It will return a pseudo-random floating-point number between optional `min` (default: 0, inclusive) and `max` (default: 1, exclusive). Can optionally `round` to the nearest integer.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param min Sets the lower bound (inclusive). Can't be higher than `max`.
+  * @param max Sets the upper bound (exclusive). Can't be lower than `min`.
+  * @param round Controls rounding to the nearest integer. Any `max` integer will become inclusive when enabled. Rounding with floating-point bounds may cause unexpected skew and boundary inclusivity.
+  */
   async random(cacheKey, { min = 0, max = 1, round = false } = {}) {
     return await this.runTask(cacheKey, async (task) => {
       if (min > max) {
@@ -778,6 +748,10 @@ var IO = class {
       }
     });
   }
+  /** `io.wait()` waits for the specified amount of time before continuing the Job. Delays work even if you're on a serverless platform with timeouts, or if your server goes down. They utilize [resumability](https://trigger.dev/docs/documentation/concepts/resumability) to ensure that the Run can be resumed after the delay.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param seconds The number of seconds to wait. This can be very long, serverless timeouts are not an issue.
+  */
   async wait(cacheKey, seconds) {
     return await this.runTask(cacheKey, async (task) => {
     }, {
@@ -846,10 +820,29 @@ var IO = class {
         ] : []
       ],
       parseOutput: (output) => {
-        return waitForEventSchema(event.schema ?? import_zod2.z.any()).parse(output);
+        return waitForEventSchema(event.schema ?? zod.z.any()).parse(output);
       }
     });
   }
+  /** `io.waitForRequest()` allows you to pause the execution of a run until the url provided in the callback is POSTed to.
+  *  This is useful for integrating with external services that require a callback URL to be provided, or if you want to be able to wait until an action is performed somewhere else in your system.
+  *  @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  *  @param callback A callback function that will provide the unique URL to POST to.
+  *  @param options Options for the callback.
+  *  @param options.timeoutInSeconds How long to wait for the request to be POSTed to the callback URL before timing out. Defaults to 1hr.
+  *  @returns The POSTed request JSON body.
+  *  @example
+  * ```ts
+   const result = await io.waitForRequest<{ message: string }>(
+     "wait-for-request",
+     async (url, task) => {
+       // Save the URL somewhere so you can POST to it later
+       // Or send it to an external service that will POST to it
+     },
+     { timeoutInSeconds: 60 } // wait 60 seconds
+   );
+   * ```
+  */
   async waitForRequest(cacheKey, callback, options) {
     const timeoutInSeconds = options?.timeoutInSeconds ?? 60 * 60;
     return await this.runTask(cacheKey, async (task, io) => {
@@ -878,12 +871,55 @@ var IO = class {
       ]
     });
   }
+  /** `io.createStatus()` allows you to set a status with associated data during the Run. Statuses can be used by your UI using the react package 
+     * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+     * @param initialStatus The initial status you want this status to have. You can update it during the rub using the returned object.
+     * @returns a TriggerStatus object that you can call `update()` on, to update the status.
+     * @example 
+     * ```ts
+     * client.defineJob(
+    //...
+      run: async (payload, io, ctx) => {
+        const generatingImages = await io.createStatus("generating-images", {
+          label: "Generating Images",
+          state: "loading",
+          data: {
+            progress: 0.1,
+          },
+        });
+  
+        //...do stuff
+  
+        await generatingImages.update("completed-generation", {
+          label: "Generated images",
+          state: "success",
+          data: {
+            progress: 1.0,
+            urls: ["http://..."]
+          },
+        });
+  
+      //...
+    });
+     * ```
+    */
   async createStatus(cacheKey, initialStatus) {
     const id = typeof cacheKey === "string" ? cacheKey : cacheKey.join("-");
     const status = new TriggerStatus(id, this);
     await status.update(cacheKey, initialStatus);
     return status;
   }
+  /** `io.backgroundFetch()` fetches data from a URL that can take longer that the serverless timeout. The actual `fetch` request is performed on the Trigger.dev platform, and the response is sent back to you.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param url The URL to fetch from.
+  * @param requestInit The options for the request
+  * @param retry The options for retrying the request if it fails
+  * An object where the key is a status code pattern and the value is a retrying strategy.
+  * Supported patterns are:
+  * - Specific status codes: 429
+  * - Ranges: 500-599
+  * - Wildcards: 2xx, 3xx, 4xx, 5xx
+  */
   async backgroundFetch(cacheKey, url, requestInit, options) {
     const urlObject = new URL(url);
     return await this.runTask(cacheKey, async (task) => {
@@ -926,6 +962,39 @@ var IO = class {
       }
     });
   }
+  /** `io.backgroundPoll()` will fetch data from a URL on an interval. The actual `fetch` requests are performed on the Trigger.dev server, so you don't have to worry about serverless function timeouts.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param params The options for the background poll
+  * @param params.url The URL to fetch from.
+  * @param params.requestInit The options for the request, like headers and method
+  * @param params.responseFilter An [EventFilter](https://trigger.dev/docs/documentation/guides/event-filter) that allows you to specify when to stop polling.
+  * @param params.interval The interval in seconds to poll the URL in seconds. Defaults to 10 seconds which is the minimum.
+  * @param params.timeout The timeout in seconds for each request in seconds. Defaults to 10 minutes. Minimum is 60 seconds and max is 1 hour
+  * @param params.requestTimeout An optional object that allows you to timeout individual fetch requests
+  * @param params.requestTimeout An optional object that allows you to timeout individual fetch requests
+  * @param params.requestTimeout.durationInMs The duration in milliseconds to timeout the request
+  * 
+  * @example
+  * ```ts
+  * const result = await io.backgroundPoll<{ id: string; status: string; }>("poll", {
+     url: `http://localhost:3030/api/v1/runs/${run.id}`,
+     requestInit: {
+       headers: {
+         Accept: "application/json",
+         Authorization: redactString`Bearer ${process.env["TRIGGER_API_KEY"]!}`,
+       },
+     },
+     interval: 10,
+     timeout: 600,
+     responseFilter: {
+       status: [200],
+       body: {
+         status: ["SUCCESS"],
+       },
+     },
+   });
+   * ```
+  */
   async backgroundPoll(cacheKey, params) {
     const urlObject = new URL(params.url);
     return await this.runTask(cacheKey, async (task) => {
@@ -955,6 +1024,17 @@ var IO = class {
       }
     });
   }
+  /** `io.backgroundFetchResponse()` fetches data from a URL that can take longer that the serverless timeout. The actual `fetch` request is performed on the Trigger.dev platform, and the response is sent back to you.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param url The URL to fetch from.
+  * @param requestInit The options for the request
+  * @param retry The options for retrying the request if it fails
+  * An object where the key is a status code pattern and the value is a retrying strategy.
+  * Supported patterns are:
+  * - Specific status codes: 429
+  * - Ranges: 500-599
+  * - Wildcards: 2xx, 3xx, 4xx, 5xx
+  */
   async backgroundFetchResponse(cacheKey, url, requestInit, options) {
     const urlObject = new URL(url);
     return await this.runTask(cacheKey, async (task) => {
@@ -996,6 +1076,11 @@ var IO = class {
       }
     });
   }
+  /** `io.sendEvent()` allows you to send an event from inside a Job run. The sent event will trigger any Jobs that are listening for that event (based on the name).
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param event The event to send. The event name must match the name of the event that your Jobs are listening for.
+  * @param options Options for sending the event.
+  */
   async sendEvent(cacheKey, event, options) {
     return await this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.sendEvent(event, options);
@@ -1021,6 +1106,11 @@ var IO = class {
       ]
     });
   }
+  /** `io.sendEvents()` allows you to send multiple events from inside a Job run. The sent events will trigger any Jobs that are listening for those events (based on the name).
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param event The events to send. The event names must match the names of the events that your Jobs are listening for.
+  * @param options Options for sending the events.
+  */
   async sendEvents(cacheKey, events, options) {
     return await this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.sendEvents(events, options);
@@ -1056,6 +1146,11 @@ var IO = class {
       ]
     });
   }
+  /** `io.cancelEvent()` allows you to cancel an event that was previously sent with `io.sendEvent()`. This will prevent any Jobs from running that are listening for that event if the event was sent with a delay
+  * @param cacheKey
+  * @param eventId
+  * @returns
+  */
   async cancelEvent(cacheKey, eventId) {
     return await this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.cancelEvent(eventId);
@@ -1107,6 +1202,14 @@ var IO = class {
       params: options
     });
   }
+  /** `io.registerInterval()` allows you to register a [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) that will trigger any jobs it's attached to on a regular interval.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param dynamicSchedule The [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) to register a new schedule on.
+  * @param id A unique id for the interval. This is used to identify and unregister the interval later.
+  * @param options The options for the interval.
+  * @returns A promise that has information about the interval.
+  * @deprecated Use `DynamicSchedule.register` instead.
+  */
   async registerInterval(cacheKey, dynamicSchedule, id, options) {
     return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.register(id, {
@@ -1132,6 +1235,12 @@ var IO = class {
       params: options
     });
   }
+  /** `io.unregisterInterval()` allows you to unregister a [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) that was previously registered with `io.registerInterval()`.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param dynamicSchedule The [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) to unregister a schedule on.
+  * @param id A unique id for the interval. This is used to identify and unregister the interval later.
+  * @deprecated Use `DynamicSchedule.unregister` instead.
+  */
   async unregisterInterval(cacheKey, dynamicSchedule, id) {
     return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.unregister(id);
@@ -1149,6 +1258,13 @@ var IO = class {
       ]
     });
   }
+  /** `io.registerCron()` allows you to register a [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) that will trigger any jobs it's attached to on a regular CRON schedule.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param dynamicSchedule The [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) to register a new schedule on.
+  * @param id A unique id for the schedule. This is used to identify and unregister the schedule later.
+  * @param options The options for the CRON schedule.
+  * @deprecated Use `DynamicSchedule.register` instead.
+  */
   async registerCron(cacheKey, dynamicSchedule, id, options) {
     return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.register(id, {
@@ -1174,6 +1290,12 @@ var IO = class {
       params: options
     });
   }
+  /** `io.unregisterCron()` allows you to unregister a [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) that was previously registered with `io.registerCron()`.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param dynamicSchedule The [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) to unregister a schedule on.
+  * @param id A unique id for the interval. This is used to identify and unregister the interval later.
+  * @deprecated Use `DynamicSchedule.unregister` instead.
+  */
   async unregisterCron(cacheKey, dynamicSchedule, id) {
     return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.unregister(id);
@@ -1191,6 +1313,13 @@ var IO = class {
       ]
     });
   }
+  /** `io.registerTrigger()` allows you to register a [DynamicTrigger](https://trigger.dev/docs/sdk/dynamictrigger) with the specified trigger params.
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param trigger The [DynamicTrigger](https://trigger.dev/docs/sdk/dynamictrigger) to register.
+  * @param id A unique id for the trigger. This is used to identify and unregister the trigger later.
+  * @param params The params for the trigger.
+  * @deprecated Use `DynamicTrigger.register` instead.
+  */
   async registerTrigger(cacheKey, trigger, id, params) {
     return await this.runTask(cacheKey, async (task) => {
       const registration = await this.runTask("register-source", async (subtask1) => {
@@ -1246,6 +1375,14 @@ var IO = class {
     });
     return results;
   }
+  /** `io.runTask()` allows you to run a [Task](https://trigger.dev/docs/documentation/concepts/tasks) from inside a Job run. A Task is a resumable unit of a Run that can be retried, resumed and is logged. [Integrations](https://trigger.dev/docs/integrations) use Tasks internally to perform their actions.
+  *
+  * @param cacheKey Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+  * @param callback The callback that will be called when the Task is run. The callback receives the Task and the IO as parameters.
+  * @param options The options of how you'd like to run and log the Task.
+  * @param onError The callback that will be called when the Task fails. The callback receives the error, the Task and the IO as parameters. If you wish to retry then return an object with a `retryAt` property.
+  * @returns A Promise that resolves with the returned value of the callback.
+  */
   async runTask(cacheKey, callback, options, onError) {
     __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "start_task", 500);
     const parentId = this._taskStorage.getStore()?.taskId;
@@ -1299,14 +1436,14 @@ var IO = class {
     }, {
       cachedTasksCursor: this._cachedTasksCursor
     });
-    const task = response.version === import_core2.API_VERSIONS.LAZY_LOADED_CACHED_TASKS ? response.body.task : response.body;
+    const task = response.version === core.API_VERSIONS.LAZY_LOADED_CACHED_TASKS ? response.body.task : response.body;
     if (task.forceYield) {
       this._logger.debug("Forcing yield after run task", {
         idempotencyKey
       });
       __privateMethod(this, _forceYield, forceYield_fn).call(this, "after_run_task");
     }
-    if (response.version === import_core2.API_VERSIONS.LAZY_LOADED_CACHED_TASKS) {
+    if (response.version === core.API_VERSIONS.LAZY_LOADED_CACHED_TASKS) {
       this._cachedTasksCursor = response.body.cachedTasks?.cursor;
       for (const cachedTask2 of response.body.cachedTasks?.tasks ?? []) {
         if (!this._cachedTasks.has(cachedTask2.idempotencyKey)) {
@@ -1395,7 +1532,7 @@ var IO = class {
               } else {
                 skipRetrying = !!onErrorResult.skipRetrying;
                 if (onErrorResult.retryAt && !skipRetrying) {
-                  const parsedError2 = import_core2.ErrorWithStackSchema.safeParse(onErrorResult.error);
+                  const parsedError2 = core.ErrorWithStackSchema.safeParse(onErrorResult.error);
                   throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
                     message: "Unknown error"
                   }, task, onErrorResult.retryAt);
@@ -1414,9 +1551,9 @@ var IO = class {
             error: error.cause.output
           });
         }
-        const parsedError = import_core2.ErrorWithStackSchema.safeParse(error);
+        const parsedError = core.ErrorWithStackSchema.safeParse(error);
         if (options?.retry && !skipRetrying) {
-          const retryAt = (0, import_core.calculateRetryAt)(options.retry, task.attempts - 1);
+          const retryAt = core.calculateRetryAt(options.retry, task.attempts - 1);
           if (retryAt) {
             throw new RetryWithTaskError(parsedError.success ? parsedError.data : {
               message: "Unknown error"
@@ -1462,8 +1599,11 @@ var IO = class {
       taskId: task.id
     }, executeTask);
   }
+  /**
+  * `io.yield()` allows you to yield execution of the current run and resume it in a new function execution. Similar to `io.wait()` but does not create a task and resumes execution immediately.
+  */
   yield(cacheKey) {
-    if (!(0, import_core2.supportsFeature)("yieldExecution", this._serverVersion)) {
+    if (!core.supportsFeature("yieldExecution", this._serverVersion)) {
       console.warn("[trigger.dev] io.yield() is not support by the version of the Trigger.dev server you are using, you will need to upgrade your self-hosted Trigger.dev instance.");
       return;
     }
@@ -1472,6 +1612,12 @@ var IO = class {
     }
     throw new YieldExecutionError(cacheKey);
   }
+  /** `io.try()` allows you to run Tasks and catch any errors that are thrown, it's similar to a normal `try/catch` block but works with [io.runTask()](https://trigger.dev/docs/sdk/io/runtask).
+  * A regular `try/catch` block on its own won't work as expected with Tasks. Internally `runTask()` throws some special errors to control flow execution. This is necessary to deal with resumability, serverless timeouts, and retrying Tasks.
+  * @param tryCallback The code you wish to run
+  * @param catchCallback Thhis will be called if the Task fails. The callback receives the error
+  * @returns A Promise that resolves with the returned value or the error
+  */
   async try(tryCallback, catchCallback) {
     try {
       return await tryCallback();
@@ -1490,7 +1636,6 @@ var IO = class {
     };
   }
 };
-__name(IO, "IO");
 _addToCachedTasks = new WeakSet();
 addToCachedTasks_fn = /* @__PURE__ */ __name(function(task) {
   this._cachedTasks.set(task.idempotencyKey, task);
@@ -1528,6 +1673,8 @@ getRemainingTimeInMillis_fn = /* @__PURE__ */ __name(function() {
   }
   return void 0;
 }, "#getRemainingTimeInMillis");
+__name(_IO, "IO");
+var IO = _IO;
 async function generateIdempotencyKey(keyMaterial) {
   const keys = keyMaterial.map((key2) => {
     if (typeof key2 === "string") {
@@ -1536,8 +1683,8 @@ async function generateIdempotencyKey(keyMaterial) {
     return stableStringify(key2);
   });
   const key = keys.join(":");
-  const hash = await import_node_crypto.webcrypto.subtle.digest("SHA-256", Buffer.from(key));
-  return Buffer.from(hash).toString("hex");
+  const hash = await crypto.webcrypto.subtle.digest("SHA-256", node_buffer.Buffer.from(key));
+  return node_buffer.Buffer.from(hash).toString("hex");
 }
 __name(generateIdempotencyKey, "generateIdempotencyKey");
 function stableStringify(obj) {
@@ -1560,27 +1707,33 @@ function stableStringify(obj) {
   return JSON.stringify(sortedObj);
 }
 __name(stableStringify, "stableStringify");
-var IOLogger = class {
+var _IOLogger = class _IOLogger {
   constructor(callback) {
     this.callback = callback;
   }
+  /** Log: essential messages */
   log(message, properties) {
     return this.callback("LOG", message, properties);
   }
+  /** For debugging: the least important log level */
   debug(message, properties) {
     return this.callback("DEBUG", message, properties);
   }
+  /** Info: the second least important log level */
   info(message, properties) {
     return this.callback("INFO", message, properties);
   }
+  /** Warnings: the third most important log level  */
   warn(message, properties) {
     return this.callback("WARN", message, properties);
   }
+  /** Error: The second most important log level */
   error(message, properties) {
     return this.callback("ERROR", message, properties);
   }
 };
-__name(IOLogger, "IOLogger");
+__name(_IOLogger, "IOLogger");
+var IOLogger = _IOLogger;
 async function spaceOut(callback, index, delay) {
   await new Promise((resolve) => setTimeout(resolve, index * delay));
   return await callback();
@@ -1612,7 +1765,7 @@ __name(sendEventOptionsProperties, "sendEventOptionsProperties");
 
 // src/store/keyValueStoreClient.ts
 var _serializer, _namespacedKey2, namespacedKey_fn2;
-var KeyValueStoreClient = class {
+var _KeyValueStoreClient = class _KeyValueStoreClient {
   constructor(queryStore, type = null, namespace = "") {
     __privateAdd(this, _namespacedKey2);
     __privateAdd(this, _serializer, void 0);
@@ -1659,7 +1812,6 @@ var KeyValueStoreClient = class {
     return __privateGet(this, _serializer).deserialize(result.value);
   }
 };
-__name(KeyValueStoreClient, "KeyValueStoreClient");
 _serializer = new WeakMap();
 _namespacedKey2 = new WeakSet();
 namespacedKey_fn2 = /* @__PURE__ */ __name(function(key) {
@@ -1673,10 +1825,12 @@ namespacedKey_fn2 = /* @__PURE__ */ __name(function(key) {
   parts.push(key);
   return parts.join(":");
 }, "#namespacedKey");
+__name(_KeyValueStoreClient, "KeyValueStoreClient");
+var KeyValueStoreClient = _KeyValueStoreClient;
 
 // src/apiClient.ts
 var _apiUrl, _options, _logger, _storeClient, _queryKeyValueStore, queryKeyValueStore_fn, _apiKey, apiKey_fn;
-var ApiClient = class {
+var _ApiClient = class _ApiClient {
   constructor(options) {
     __privateAdd(this, _queryKeyValueStore);
     __privateAdd(this, _apiKey);
@@ -1685,8 +1839,8 @@ var ApiClient = class {
     __privateAdd(this, _logger, void 0);
     __privateAdd(this, _storeClient, void 0);
     __privateSet(this, _options, options);
-    __privateSet(this, _apiUrl, __privateGet(this, _options).apiUrl ?? process.env.TRIGGER_API_URL ?? "https://api.trigger.dev");
-    __privateSet(this, _logger, new import_core3.Logger("trigger.dev", __privateGet(this, _options).logLevel));
+    __privateSet(this, _apiUrl, __privateGet(this, _options).apiUrl ?? node_process.env.TRIGGER_API_URL ?? "https://api.trigger.dev");
+    __privateSet(this, _logger, new core.Logger("trigger.dev", __privateGet(this, _options).logLevel));
     __privateSet(this, _storeClient, new KeyValueStoreClient(__privateMethod(this, _queryKeyValueStore, queryKeyValueStore_fn).bind(this)));
   }
   async registerEndpoint(options) {
@@ -1721,15 +1875,15 @@ var ApiClient = class {
       task
     });
     return await zodfetchWithVersions({
-      [import_core3.API_VERSIONS.LAZY_LOADED_CACHED_TASKS]: import_core3.RunTaskResponseWithCachedTasksBodySchema
-    }, import_core3.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
+      [core.API_VERSIONS.LAZY_LOADED_CACHED_TASKS]: core.RunTaskResponseWithCachedTasksBodySchema
+    }, core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${apiKey}`,
         "Idempotency-Key": task.idempotencyKey,
         "X-Cached-Tasks-Cursor": options.cachedTasksCursor ?? "",
-        "Trigger-Version": import_core3.API_VERSIONS.LAZY_LOADED_CACHED_TASKS
+        "Trigger-Version": core.API_VERSIONS.LAZY_LOADED_CACHED_TASKS
       },
       body: JSON.stringify(task)
     });
@@ -1739,12 +1893,12 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Complete Task", {
       task
     });
-    return await zodfetch(import_core3.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
+    return await zodfetch(core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${apiKey}`,
-        "Trigger-Version": import_core3.API_VERSIONS.SERIALIZED_TASK_OUTPUT
+        "Trigger-Version": core.API_VERSIONS.SERIALIZED_TASK_OUTPUT
       },
       body: JSON.stringify(task)
     });
@@ -1756,7 +1910,7 @@ var ApiClient = class {
       runId,
       body
     });
-    return await zodfetch(import_core3.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/fail`, {
+    return await zodfetch(core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/fail`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1770,7 +1924,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Sending event", {
       event
     });
-    return await zodfetch(import_core3.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
+    return await zodfetch(core.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1787,7 +1941,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Sending multiple events", {
       events
     });
-    return await zodfetch(import_core3.ApiEventLogSchema.array(), `${__privateGet(this, _apiUrl)}/api/v1/events/bulk`, {
+    return await zodfetch(core.ApiEventLogSchema.array(), `${__privateGet(this, _apiUrl)}/api/v1/events/bulk`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1804,7 +1958,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Cancelling event", {
       eventId
     });
-    return await zodfetch(import_core3.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel`, {
+    return await zodfetch(core.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1817,7 +1971,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Cancelling runs for event", {
       eventId
     });
-    return await zodfetch(import_core3.CancelRunsForEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel-runs`, {
+    return await zodfetch(core.CancelRunsForEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel-runs`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1831,7 +1985,7 @@ var ApiClient = class {
       id,
       status
     });
-    return await zodfetch(import_core3.JobRunStatusRecordSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses/${id}`, {
+    return await zodfetch(core.JobRunStatusRecordSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses/${id}`, {
       method: "PUT",
       headers: {
         "Content-Type": "application/json",
@@ -1845,7 +1999,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("activating http source", {
       source
     });
-    const response = await zodfetch(import_core3.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v2/${client}/sources/${key}`, {
+    const response = await zodfetch(core.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v2/${client}/sources/${key}`, {
       method: "PUT",
       headers: {
         "Content-Type": "application/json",
@@ -1860,7 +2014,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("activating webhook", {
       webhookData
     });
-    const response = await zodfetch(import_core3.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v1/webhooks/${key}`, {
+    const response = await zodfetch(core.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v1/webhooks/${key}`, {
       method: "PUT",
       headers: {
         "Content-Type": "application/json",
@@ -1883,7 +2037,7 @@ var ApiClient = class {
     if (idempotencyKey) {
       headers["Idempotency-Key"] = idempotencyKey;
     }
-    const response = await zodfetch(import_core3.RegisterSourceEventSchemaV2, `${__privateGet(this, _apiUrl)}/api/v2/${client}/triggers/${id}/registrations/${key}`, {
+    const response = await zodfetch(core.RegisterSourceEventSchemaV2, `${__privateGet(this, _apiUrl)}/api/v2/${client}/triggers/${id}/registrations/${key}`, {
       method: "PUT",
       headers,
       body: JSON.stringify(payload)
@@ -1896,7 +2050,7 @@ var ApiClient = class {
       id,
       payload
     });
-    const response = await zodfetch(import_core3.RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
+    const response = await zodfetch(core.RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1914,8 +2068,8 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("unregistering schedule", {
       id
     });
-    const response = await zodfetch(import_zod3.z.object({
-      ok: import_zod3.z.boolean()
+    const response = await zodfetch(zod.z.object({
+      ok: zod.z.boolean()
     }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
       method: "DELETE",
       headers: {
@@ -1930,7 +2084,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("getting auth", {
       id
     });
-    const response = await zodfetch(import_core3.ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
+    const response = await zodfetch(core.ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
       method: "GET",
       headers: {
         Accept: "application/json",
@@ -1946,7 +2100,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Getting Event", {
       eventId
     });
-    return await zodfetch(import_core3.GetEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}`, {
+    return await zodfetch(core.GetEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}`, {
       method: "GET",
       headers: {
         Authorization: `Bearer ${apiKey}`
@@ -1958,7 +2112,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Getting Run", {
       runId
     });
-    return await zodfetch(import_core3.GetRunSchema, (0, import_core3.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}`, options), {
+    return await zodfetch(core.GetRunSchema, core.urlWithSearchParams(`${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}`, options), {
       method: "GET",
       headers: {
         Authorization: `Bearer ${apiKey}`
@@ -1970,7 +2124,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Cancelling Run", {
       runId
     });
-    return await zodfetch(import_core3.GetRunSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/cancel`, {
+    return await zodfetch(core.GetRunSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/cancel`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1983,7 +2137,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Getting Run statuses", {
       runId
     });
-    return await zodfetch(import_core3.GetRunStatusesSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses`, {
+    return await zodfetch(core.GetRunStatusesSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses`, {
       method: "GET",
       headers: {
         Authorization: `Bearer ${apiKey}`
@@ -1995,7 +2149,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Getting Runs", {
       jobSlug
     });
-    return await zodfetch(import_core3.GetRunsSchema, (0, import_core3.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobSlug}/runs`, options), {
+    return await zodfetch(core.GetRunsSchema, core.urlWithSearchParams(`${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobSlug}/runs`, options), {
       method: "GET",
       headers: {
         Authorization: `Bearer ${apiKey}`
@@ -2015,7 +2169,7 @@ var ApiClient = class {
         callbackUrl: options.callbackUrl
       }
     };
-    return await zodfetch(import_core3.InvokeJobResponseSchema, `${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobId}/invoke`, {
+    return await zodfetch(core.InvokeJobResponseSchema, `${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobId}/invoke`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -2032,7 +2186,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Creating ephemeral event dispatcher", {
       payload
     });
-    const response = await zodfetch(import_core3.EphemeralEventDispatcherResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/event-dispatchers/ephemeral`, {
+    const response = await zodfetch(core.EphemeralEventDispatcherResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/event-dispatchers/ephemeral`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -2046,7 +2200,6 @@ var ApiClient = class {
     return __privateGet(this, _storeClient);
   }
 };
-__name(ApiClient, "ApiClient");
 _apiUrl = new WeakMap();
 _options = new WeakMap();
 _logger = new WeakMap();
@@ -2105,10 +2258,10 @@ queryKeyValueStore_fn = /* @__PURE__ */ __name(async function(action, data) {
       break;
     }
     default: {
-      (0, import_core3.assertExhaustive)(action);
+      core.assertExhaustive(action);
     }
   }
-  const response = await zodfetch(import_core3.KeyValueStoreResponseBodySchema, STORE_URL, requestInit);
+  const response = await zodfetch(core.KeyValueStoreResponseBodySchema, STORE_URL, requestInit);
   return response;
 }, "#queryKeyValueStore");
 _apiKey = new WeakSet();
@@ -2121,8 +2274,10 @@ apiKey_fn = /* @__PURE__ */ __name(async function() {
   }
   return apiKey.apiKey;
 }, "#apiKey");
+__name(_ApiClient, "ApiClient");
+var ApiClient = _ApiClient;
 function getApiKey(key) {
-  const apiKey = key ?? process.env.TRIGGER_API_KEY;
+  const apiKey = key ?? node_process.env.TRIGGER_API_KEY;
   if (!apiKey) {
     return {
       status: "missing"
@@ -2142,10 +2297,7 @@ function getApiKey(key) {
 }
 __name(getApiKey, "getApiKey");
 async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount = 0) {
-  const response = await fetch(url, {
-    ...requestInit,
-    cache: "no-cache"
-  });
+  const response = await fetch(url, requestInitWithCache(requestInit));
   if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
     return;
   }
@@ -2179,15 +2331,25 @@ async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url,
   };
 }
 __name(zodfetchWithVersions, "zodfetchWithVersions");
+function requestInitWithCache(requestInit) {
+  try {
+    const withCache = {
+      ...requestInit,
+      cache: "no-cache"
+    };
+    const _ = new Request("http://localhost", withCache);
+    return withCache;
+  } catch (error) {
+    return requestInit ?? {};
+  }
+}
+__name(requestInitWithCache, "requestInitWithCache");
 async function fetchHead(url, requestInitWithoutMethod, retryCount = 0) {
   const requestInit = {
     ...requestInitWithoutMethod,
     method: "HEAD"
   };
-  const response = await fetch(url, {
-    ...requestInit,
-    cache: "no-cache"
-  });
+  const response = await fetch(url, requestInitWithCache(requestInit));
   if (response.status >= 500 && retryCount < 6) {
     const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
     await new Promise((resolve) => setTimeout(resolve, delay));
@@ -2197,10 +2359,7 @@ async function fetchHead(url, requestInitWithoutMethod, retryCount = 0) {
 }
 __name(fetchHead, "fetchHead");
 async function zodfetch(schema, url, requestInit, options, retryCount = 0) {
-  const response = await fetch(url, {
-    ...requestInit,
-    cache: "no-cache"
-  });
+  const response = await fetch(url, requestInitWithCache(requestInit));
   if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
     return;
   }
@@ -2227,9 +2386,6 @@ function exponentialBackoff(retryCount, exponential, minDelay, maxDelay, jitter)
 }
 __name(exponentialBackoff, "exponentialBackoff");
 
-// src/httpEndpoint.ts
-var import_core4 = require("@trigger.dev/core");
-
 // src/utils/formatSchemaErrors.ts
 function formatSchemaErrors(errors) {
   return errors.map((error) => {
@@ -2243,7 +2399,7 @@ function formatSchemaErrors(errors) {
 __name(formatSchemaErrors, "formatSchemaErrors");
 
 // src/httpEndpoint.ts
-var HttpEndpoint = class {
+var _HttpEndpoint = class _HttpEndpoint {
   constructor(options) {
     this.options = options;
   }
@@ -2258,6 +2414,7 @@ var HttpEndpoint = class {
       verify: this.options.verify
     });
   }
+  // @internal
   async handleRequest(request) {
     if (!this.options.respondWith)
       return;
@@ -2279,8 +2436,10 @@ var HttpEndpoint = class {
     };
   }
 };
-__name(HttpEndpoint, "HttpEndpoint");
-var HttpTrigger = /* @__PURE__ */ __name(class HttpTrigger2 {
+__name(_HttpEndpoint, "HttpEndpoint");
+var HttpEndpoint = _HttpEndpoint;
+var _a;
+var HttpTrigger = (_a = class {
   constructor(options) {
     this.options = options;
   }
@@ -2315,7 +2474,7 @@ var HttpTrigger = /* @__PURE__ */ __name(class HttpTrigger2 {
     const clonedRequest = payload.clone();
     return this.options.verify(clonedRequest);
   }
-}, "HttpTrigger");
+}, __name(_a, "HttpTrigger"), _a);
 function httpEndpoint(options) {
   const id = slugifyId(options.id);
   return new HttpEndpoint({
@@ -2347,7 +2506,7 @@ function httpEndpoint(options) {
         }
       ],
       parsePayload: (rawPayload) => {
-        const result = import_core4.RequestWithRawBodySchema.safeParse(rawPayload);
+        const result = core.RequestWithRawBodySchema.safeParse(rawPayload);
         if (!result.success) {
           throw new ParsedPayloadSchemaError(formatSchemaErrors(result.error.issues));
         }
@@ -2390,11 +2549,12 @@ function createIOWithIntegrations(io, auths, integrations) {
   });
 }
 __name(createIOWithIntegrations, "createIOWithIntegrations");
-
-// src/triggers/dynamic.ts
-var import_core5 = require("@trigger.dev/core");
 var _client, _options2;
-var DynamicTrigger = class {
+var _DynamicTrigger = class _DynamicTrigger {
+  /** `DynamicTrigger` allows you to define a trigger that can be configured dynamically at runtime.
+  * @param client The `TriggerClient` instance to use for registering the trigger.
+  * @param options The options for the dynamic trigger.
+  * */
   constructor(client, options) {
     __privateAdd(this, _client, void 0);
     __privateAdd(this, _options2, void 0);
@@ -2415,19 +2575,21 @@ var DynamicTrigger = class {
   get event() {
     return __privateGet(this, _options2).event;
   }
+  // @internal
   registeredTriggerForParams(params, options = {}) {
     const key = slugifyId(this.source.key(params));
     return {
       rule: {
         event: this.event.name,
         source: this.event.source,
-        payload: (0, import_core5.deepMergeFilters)(this.source.filter(params), this.event.filter ?? {}, options.filter ?? {})
+        payload: core.deepMergeFilters(this.source.filter(params), this.event.filter ?? {}, options.filter ?? {})
       },
       source: {
         version: "2",
         key,
         channel: this.source.channel,
         params,
+        //todo add other options here
         options: {
           event: typeof this.event.name === "string" ? [
             this.event.name
@@ -2442,6 +2604,14 @@ var DynamicTrigger = class {
       accountId: options.accountId
     };
   }
+  /** Use this method to register a new configuration with the DynamicTrigger.
+  * @param key The key for the configuration. This will be used to identify the configuration when it is triggered.
+  * @param params The params for the configuration.
+  * @param options Options for the configuration.
+  * @param options.accountId The accountId to associate with the configuration.
+  * @param options.filter The filter to use for the configuration.
+  *
+  */
   async register(key, params, options = {}) {
     const runStore = runLocalStorage.getStore();
     if (!runStore) {
@@ -2480,14 +2650,12 @@ var DynamicTrigger = class {
     };
   }
 };
-__name(DynamicTrigger, "DynamicTrigger");
 _client = new WeakMap();
 _options2 = new WeakMap();
-
-// src/triggers/eventTrigger.ts
-var import_core6 = require("@trigger.dev/core");
+__name(_DynamicTrigger, "DynamicTrigger");
+var DynamicTrigger = _DynamicTrigger;
 var _options3;
-var EventTrigger = class {
+var _EventTrigger = class _EventTrigger {
   constructor(options) {
     __privateAdd(this, _options3, void 0);
     __privateSet(this, _options3, options);
@@ -2499,7 +2667,7 @@ var EventTrigger = class {
       rule: {
         event: __privateGet(this, _options3).name ?? __privateGet(this, _options3).event.name,
         source: __privateGet(this, _options3).source ?? "trigger.dev",
-        payload: (0, import_core6.deepMergeFilters)(__privateGet(this, _options3).filter ?? {}, __privateGet(this, _options3).event.filter ?? {})
+        payload: core.deepMergeFilters(__privateGet(this, _options3).filter ?? {}, __privateGet(this, _options3).event.filter ?? {})
       }
     };
   }
@@ -2523,8 +2691,9 @@ var EventTrigger = class {
     };
   }
 };
-__name(EventTrigger, "EventTrigger");
 _options3 = new WeakMap();
+__name(_EventTrigger, "EventTrigger");
+var EventTrigger = _EventTrigger;
 function eventTrigger(options) {
   return new EventTrigger({
     name: options.name,
@@ -2549,22 +2718,18 @@ function eventTrigger(options) {
   });
 }
 __name(eventTrigger, "eventTrigger");
-
-// src/triggers/scheduled.ts
-var import_core7 = require("@trigger.dev/core");
-var import_cronstrue = __toESM(require("cronstrue"));
 var examples = [
   {
     id: "now",
     name: "Now",
     icon: "clock",
     payload: {
-      ts: import_core7.currentDate.marker,
-      lastTimestamp: import_core7.currentDate.marker
+      ts: core.currentDate.marker,
+      lastTimestamp: core.currentDate.marker
     }
   }
 ];
-var IntervalTrigger = class {
+var _IntervalTrigger = class _IntervalTrigger {
   constructor(options) {
     this.options = options;
   }
@@ -2575,7 +2740,7 @@ var IntervalTrigger = class {
       source: "trigger.dev",
       icon: "schedule-interval",
       examples,
-      parsePayload: import_core7.ScheduledPayloadSchema.parse,
+      parsePayload: core.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "Interval",
@@ -2606,17 +2771,18 @@ var IntervalTrigger = class {
     };
   }
 };
-__name(IntervalTrigger, "IntervalTrigger");
+__name(_IntervalTrigger, "IntervalTrigger");
+var IntervalTrigger = _IntervalTrigger;
 function intervalTrigger(options) {
   return new IntervalTrigger(options);
 }
 __name(intervalTrigger, "intervalTrigger");
-var CronTrigger = class {
+var _CronTrigger = class _CronTrigger {
   constructor(options) {
     this.options = options;
   }
   get event() {
-    const humanReadable = import_cronstrue.default.toString(this.options.cron, {
+    const humanReadable = cronstrue__default.default.toString(this.options.cron, {
       throwExceptionOnParseError: false
     });
     return {
@@ -2625,7 +2791,7 @@ var CronTrigger = class {
       source: "trigger.dev",
       icon: "schedule-cron",
       examples,
-      parsePayload: import_core7.ScheduledPayloadSchema.parse,
+      parsePayload: core.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "cron",
@@ -2660,12 +2826,17 @@ var CronTrigger = class {
     };
   }
 };
-__name(CronTrigger, "CronTrigger");
+__name(_CronTrigger, "CronTrigger");
+var CronTrigger = _CronTrigger;
 function cronTrigger(options) {
   return new CronTrigger(options);
 }
 __name(cronTrigger, "cronTrigger");
-var DynamicSchedule = class {
+var _DynamicSchedule = class _DynamicSchedule {
+  /**
+  * @param client The `TriggerClient` instance to use for registering the trigger.
+  * @param options The options for the schedule.
+  */
   constructor(client, options) {
     this.client = client;
     this.options = options;
@@ -2681,7 +2852,7 @@ var DynamicSchedule = class {
       source: "trigger.dev",
       icon: "schedule-dynamic",
       examples,
-      parsePayload: import_core7.ScheduledPayloadSchema.parse
+      parsePayload: core.ScheduledPayloadSchema.parse
     };
   }
   async register(key, metadata) {
@@ -2755,16 +2926,14 @@ var DynamicSchedule = class {
     };
   }
 };
-__name(DynamicSchedule, "DynamicSchedule");
-
-// src/triggerClient.ts
-var import_node_events = __toESM(require("events"));
+__name(_DynamicSchedule, "DynamicSchedule");
+var DynamicSchedule = _DynamicSchedule;
 
 // package.json
-var version = "2.2.10";
+var version = "2.3.0";
 
 // src/concurrencyLimit.ts
-var ConcurrencyLimit = class {
+var _ConcurrencyLimit = class _ConcurrencyLimit {
   constructor(options) {
     this.options = options;
   }
@@ -2775,25 +2944,26 @@ var ConcurrencyLimit = class {
     return this.options.limit;
   }
 };
-__name(ConcurrencyLimit, "ConcurrencyLimit");
+__name(_ConcurrencyLimit, "ConcurrencyLimit");
+var ConcurrencyLimit = _ConcurrencyLimit;
 
 // src/triggerClient.ts
 var registerWebhookEvent = /* @__PURE__ */ __name((key) => ({
-  name: `${import_core8.REGISTER_WEBHOOK}.${key}`,
+  name: `${core.REGISTER_WEBHOOK}.${key}`,
   title: "Register Webhook",
   source: "internal",
   icon: "webhook",
-  parsePayload: import_core8.RegisterWebhookPayloadSchema.parse
+  parsePayload: core.RegisterWebhookPayloadSchema.parse
 }), "registerWebhookEvent");
 var registerSourceEvent = {
-  name: import_core8.REGISTER_SOURCE_EVENT_V2,
+  name: core.REGISTER_SOURCE_EVENT_V2,
   title: "Register Source",
   source: "internal",
   icon: "register-source",
-  parsePayload: import_core8.RegisterSourceEventSchemaV2.parse
+  parsePayload: core.RegisterSourceEventSchemaV2.parse
 };
 var _options4, _registeredJobs, _registeredSources, _registeredWebhooks, _registeredHttpSourceHandlers, _registeredWebhookSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _registeredHttpEndpoints, _authResolvers, _envStore, _eventEmitter, _client2, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn, _handleHttpEndpointRequestForResponse, handleHttpEndpointRequestForResponse_fn, _handleWebhookRequest, handleWebhookRequest_fn, _resolveConnections, resolveConnections_fn, _resolveConnection, resolveConnection_fn, _buildJobsIndex, buildJobsIndex_fn, _buildJobIndex, buildJobIndex_fn, _buildJobIntegrations, buildJobIntegrations_fn, _buildJobIntegration, buildJobIntegration_fn, _logIOStats, logIOStats_fn, _standardResponseHeaders, standardResponseHeaders_fn, _serializeRunMetadata, serializeRunMetadata_fn, _deliverSuccessfulRunNotification, deliverSuccessfulRunNotification_fn, _deliverFailedRunNotification, deliverFailedRunNotification_fn;
-var TriggerClient = class {
+var _TriggerClient = class _TriggerClient {
   constructor(options) {
     __privateAdd(this, _preprocessRun);
     __privateAdd(this, _executeJob);
@@ -2826,14 +2996,14 @@ var TriggerClient = class {
     __privateAdd(this, _registeredHttpEndpoints, {});
     __privateAdd(this, _authResolvers, {});
     __privateAdd(this, _envStore, void 0);
-    __privateAdd(this, _eventEmitter, new import_node_events.default());
+    __privateAdd(this, _eventEmitter, new EventEmitter__default.default());
     __privateAdd(this, _client2, void 0);
     __privateAdd(this, _internalLogger, void 0);
     __publicField(this, "on", __privateGet(this, _eventEmitter).on.bind(__privateGet(this, _eventEmitter)));
     this.id = options.id;
     __privateSet(this, _options4, options);
     __privateSet(this, _client2, new ApiClient(__privateGet(this, _options4)));
-    __privateSet(this, _internalLogger, new import_core8.Logger("trigger.dev", __privateGet(this, _options4).verbose ? "debug" : "log", [
+    __privateSet(this, _internalLogger, new core.Logger("trigger.dev", __privateGet(this, _options4).verbose ? "debug" : "log", [
       "output",
       "noopTasksSet"
     ]));
@@ -2957,7 +3127,7 @@ var TriggerClient = class {
       }
       case "INITIALIZE_TRIGGER": {
         const json = await request.json();
-        const body = import_core8.InitializeTriggerBodySchema.safeParse(json);
+        const body = core.InitializeTriggerBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -2983,7 +3153,7 @@ var TriggerClient = class {
       }
       case "EXECUTE_JOB": {
         const json = await request.json();
-        const execution = import_core8.RunJobBodySchema.safeParse(json);
+        const execution = core.RunJobBodySchema.safeParse(json);
         if (!execution.success) {
           return {
             status: 400,
@@ -3018,7 +3188,7 @@ var TriggerClient = class {
       }
       case "PREPROCESS_RUN": {
         const json = await request.json();
-        const body = import_core8.PreprocessRunBodySchema.safeParse(json);
+        const body = core.PreprocessRunBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -3047,7 +3217,7 @@ var TriggerClient = class {
         };
       }
       case "DELIVER_HTTP_SOURCE_REQUEST": {
-        const headers = import_core8.HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
+        const headers = core.HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
         if (!headers.success) {
           return {
             status: 400,
@@ -3097,7 +3267,7 @@ var TriggerClient = class {
         };
       }
       case "DELIVER_HTTP_ENDPOINT_REQUEST_FOR_RESPONSE": {
-        const headers = import_core8.HttpEndpointRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
+        const headers = core.HttpEndpointRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
         if (!headers.success) {
           return {
             status: 400,
@@ -3130,7 +3300,7 @@ var TriggerClient = class {
         };
       }
       case "DELIVER_WEBHOOK_REQUEST": {
-        const headers = import_core8.WebhookSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
+        const headers = core.WebhookSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
         if (!headers.success) {
           return {
             status: 400,
@@ -3221,9 +3391,11 @@ var TriggerClient = class {
   defineJob(options) {
     const existingRegisteredJob = __privateGet(this, _registeredJobs)[options.id];
     if (existingRegisteredJob) {
-      console.warn((0, import_colorette.yellow)(`[@trigger.dev/sdk] Warning: The Job "${existingRegisteredJob.id}" you're attempting to define has already been defined. Please assign a different ID to the job.`));
+      console.warn(`[@trigger.dev/sdk] Warning: The Job "${existingRegisteredJob.id}" you're attempting to define has already been defined. Please assign a different ID to the job.`);
     }
-    return new Job(this, options);
+    const job = new Job(options);
+    this.attach(job);
+    return job;
   }
   defineAuthResolver(integration, resolver) {
     __privateGet(this, _authResolvers)[integration.id] = resolver;
@@ -3235,10 +3407,16 @@ var TriggerClient = class {
   defineDynamicTrigger(options) {
     return new DynamicTrigger(this, options);
   }
+  /**
+  * An [HTTP endpoint](https://trigger.dev/docs/documentation/concepts/http-endpoints) allows you to create a [HTTP Trigger](https://trigger.dev/docs/documentation/concepts/triggers/http), which means you can trigger your Jobs from any webhooks.
+  * @param options The Endpoint options
+  * @returns An HTTP Endpoint, that can be used to create an HTTP Trigger.
+  * @link https://trigger.dev/docs/documentation/concepts/http-endpoints
+  */
   defineHttpEndpoint(options, suppressWarnings = false) {
     const existingHttpEndpoint = __privateGet(this, _registeredHttpEndpoints)[options.id];
     if (!suppressWarnings && existingHttpEndpoint) {
-      console.warn((0, import_colorette.yellow)(`[@trigger.dev/sdk] Warning: The HttpEndpoint "${existingHttpEndpoint.id}" you're attempting to define has already been defined. Please assign a different ID to the HttpEndpoint.`));
+      console.warn(`[@trigger.dev/sdk] Warning: The HttpEndpoint "${existingHttpEndpoint.id}" you're attempting to define has already been defined. Please assign a different ID to the HttpEndpoint.`);
     }
     const endpoint = httpEndpoint(options);
     __privateGet(this, _registeredHttpEndpoints)[endpoint.id] = endpoint;
@@ -3249,7 +3427,7 @@ var TriggerClient = class {
   }
   attach(job) {
     __privateGet(this, _registeredJobs)[job.id] = job;
-    job.trigger.attachToJob(this, job);
+    job.attachToClient(this);
   }
   attachDynamicTrigger(trigger) {
     __privateGet(this, _registeredDynamicTriggers)[trigger.id] = trigger;
@@ -3319,7 +3497,7 @@ var TriggerClient = class {
     }, options.options ?? {});
     registeredSource.options = deepMergeOptions(registeredSource.options, newOptions);
     __privateGet(this, _registeredSources)[options.key] = registeredSource;
-    new Job(this, {
+    this.defineJob({
       id: options.key,
       name: options.key,
       version: options.source.version,
@@ -3386,7 +3564,7 @@ var TriggerClient = class {
       registeredWebhook.config = deepMergeOptions(registeredWebhook.config, options.config);
     }
     __privateGet(this, _registeredWebhooks)[options.key] = registeredWebhook;
-    new Job(this, {
+    this.defineJob({
       id: `webhook.register.${options.key}`,
       name: `webhook.register.${options.key}`,
       version: source.version,
@@ -3401,6 +3579,7 @@ var TriggerClient = class {
           __privateGet(this, _internalLogger).debug("[webhook.register] Start");
           const crudOptions = {
             io,
+            // this is just a more strongly typed payload
             ctx: registerPayload
           };
           if (!registerPayload.active) {
@@ -3455,9 +3634,19 @@ var TriggerClient = class {
   async getAuth(id) {
     return __privateGet(this, _client2).getAuth(this.id, id);
   }
+  /** You can call this function from anywhere in your backend to send an event. The other way to send an event is by using [`io.sendEvent()`](https://trigger.dev/docs/sdk/io/sendevent) from inside a `run()` function.
+  * @param event The event to send.
+  * @param options Options for sending the event.
+  * @returns A promise that resolves to the event details
+  */
   async sendEvent(event, options) {
     return __privateGet(this, _client2).sendEvent(event, options);
   }
+  /** You can call this function from anywhere in your backend to send multiple events. The other way to send multiple events is by using [`io.sendEvents()`](https://trigger.dev/docs/sdk/io/sendevents) from inside a `run()` function.
+  * @param events The events to send.
+  * @param options Options for sending the events.
+  * @returns A promise that resolves to an array of event details
+  */
   async sendEvents(events, options) {
     return __privateGet(this, _client2).sendEvents(events, options);
   }
@@ -3506,17 +3695,16 @@ var TriggerClient = class {
     if (typeof apiKey !== "string") {
       return "missing-header";
     }
-    const localApiKey = __privateGet(this, _options4).apiKey ?? process.env.TRIGGER_API_KEY;
+    const localApiKey = __privateGet(this, _options4).apiKey ?? node_process.env.TRIGGER_API_KEY;
     if (!localApiKey) {
       return "missing-client";
     }
     return apiKey === localApiKey ? "authorized" : "unauthorized";
   }
   apiKey() {
-    return __privateGet(this, _options4).apiKey ?? process.env.TRIGGER_API_KEY;
+    return __privateGet(this, _options4).apiKey ?? node_process.env.TRIGGER_API_KEY;
   }
 };
-__name(TriggerClient, "TriggerClient");
 _options4 = new WeakMap();
 _registeredJobs = new WeakMap();
 _registeredSources = new WeakMap();
@@ -3534,7 +3722,7 @@ _client2 = new WeakMap();
 _internalLogger = new WeakMap();
 _preprocessRun = new WeakSet();
 preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
-  const context = __privateMethod(this, _createPreprocessRunContext, createPreprocessRunContext_fn).call(this, body);
+  __privateMethod(this, _createPreprocessRunContext, createPreprocessRunContext_fn).call(this, body);
   const parsedPayload = job.trigger.event.parsePayload(body.event.payload ?? {});
   const properties = job.trigger.event.runProperties?.(parsedPayload) ?? [];
   return {
@@ -3563,7 +3751,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, timeOrigin, t
     client: this,
     context,
     jobLogLevel: job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info",
-    jobLogger: __privateGet(this, _options4).ioLogLocalEnabled ? new import_core8.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info") : void 0,
+    jobLogger: __privateGet(this, _options4).ioLogLocalEnabled ? new core.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info") : void 0,
     serverVersion: triggerVersion,
     timeOrigin,
     executionTimeout: body1.runChunkExecutionLimit
@@ -3674,7 +3862,7 @@ convertErrorToExecutionResponse_fn = /* @__PURE__ */ __name(function(error, body
     };
   }
   if (error instanceof ErrorWithTask) {
-    const errorWithStack2 = import_core8.ErrorWithStackSchema.safeParse(error.cause.output);
+    const errorWithStack2 = core.ErrorWithStackSchema.safeParse(error.cause.output);
     if (errorWithStack2.success) {
       return {
         status: "ERROR",
@@ -3691,7 +3879,7 @@ convertErrorToExecutionResponse_fn = /* @__PURE__ */ __name(function(error, body
     };
   }
   if (error instanceof RetryWithTaskError) {
-    const errorWithStack2 = import_core8.ErrorWithStackSchema.safeParse(error.cause);
+    const errorWithStack2 = core.ErrorWithStackSchema.safeParse(error.cause);
     if (errorWithStack2.success) {
       return {
         status: "ERROR",
@@ -3707,7 +3895,7 @@ convertErrorToExecutionResponse_fn = /* @__PURE__ */ __name(function(error, body
       task: error.task
     };
   }
-  const errorWithStack = import_core8.ErrorWithStackSchema.safeParse(error);
+  const errorWithStack = core.ErrorWithStackSchema.safeParse(error);
   if (errorWithStack.success) {
     return {
       status: "ERROR",
@@ -4095,7 +4283,7 @@ logIOStats_fn = /* @__PURE__ */ __name(function(stats) {
 _standardResponseHeaders = new WeakSet();
 standardResponseHeaders_fn = /* @__PURE__ */ __name(function(start) {
   return {
-    "Trigger-Version": import_core8.API_VERSIONS.LAZY_LOADED_CACHED_TASKS,
+    "Trigger-Version": core.API_VERSIONS.LAZY_LOADED_CACHED_TASKS,
     "Trigger-SDK-Version": version,
     "X-Trigger-Request-Timing": `dur=${performance.now() - start / 1e3}`
   };
@@ -4139,6 +4327,8 @@ deliverFailedRunNotification_fn = /* @__PURE__ */ __name(async function(notifica
     await job.options.onFailure(notification1);
   }
 }, "#deliverFailedRunNotification");
+__name(_TriggerClient, "TriggerClient");
+var TriggerClient = _TriggerClient;
 function dynamicTriggerRegisterSourceJobId(id) {
   return `register-dynamic-trigger-${id}`;
 }
@@ -4162,10 +4352,7 @@ function deepMergeOptions(obj1, obj2) {
   return mergedOptions;
 }
 __name(deepMergeOptions, "deepMergeOptions");
-
-// src/triggers/externalSource.ts
-var import_core9 = require("@trigger.dev/core");
-var ExternalSource = class {
+var _ExternalSource = class _ExternalSource {
   constructor(channel, options) {
     this.options = options;
     this.channel = channel;
@@ -4224,8 +4411,9 @@ var ExternalSource = class {
     return this.options.version;
   }
 };
-__name(ExternalSource, "ExternalSource");
-var ExternalSourceTrigger = class {
+__name(_ExternalSource, "ExternalSource");
+var ExternalSource = _ExternalSource;
+var _ExternalSourceTrigger = class _ExternalSourceTrigger {
   constructor(options) {
     this.options = options;
   }
@@ -4238,7 +4426,7 @@ var ExternalSourceTrigger = class {
       title: "External Source",
       rule: {
         event: this.event.name,
-        payload: (0, import_core9.deepMergeFilters)(this.options.source.filter(this.options.params, this.options.options), this.event.filter ?? {}, this.options.params.filter ?? {}),
+        payload: core.deepMergeFilters(this.options.source.filter(this.options.params, this.options.options), this.event.filter ?? {}, this.options.params.filter ?? {}),
         source: this.event.source
       },
       properties: this.options.source.properties(this.options.params)
@@ -4262,7 +4450,8 @@ var ExternalSourceTrigger = class {
     };
   }
 };
-__name(ExternalSourceTrigger, "ExternalSourceTrigger");
+__name(_ExternalSourceTrigger, "ExternalSourceTrigger");
+var ExternalSourceTrigger = _ExternalSourceTrigger;
 function omit(obj, key) {
   const result = {};
   for (const k of Object.keys(obj)) {
@@ -4276,9 +4465,6 @@ function omit(obj, key) {
   };
 }
 __name(omit, "omit");
-
-// src/triggers/notifications.ts
-var import_core10 = require("@trigger.dev/core");
 function missingConnectionNotification(integrations) {
   return new MissingConnectionNotification({
     integrations
@@ -4291,17 +4477,17 @@ function missingConnectionResolvedNotification(integrations) {
   });
 }
 __name(missingConnectionResolvedNotification, "missingConnectionResolvedNotification");
-var MissingConnectionNotification = class {
+var _MissingConnectionNotification = class _MissingConnectionNotification {
   constructor(options) {
     this.options = options;
   }
   get event() {
     return {
-      name: import_core10.MISSING_CONNECTION_NOTIFICATION,
+      name: core.MISSING_CONNECTION_NOTIFICATION,
       title: "Missing Connection Notification",
       source: "trigger.dev",
       icon: "connection-alert",
-      parsePayload: import_core10.MissingConnectionNotificationPayloadSchema.parse,
+      parsePayload: core.MissingConnectionNotificationPayloadSchema.parse,
       properties: [
         {
           label: "Integrations",
@@ -4336,18 +4522,19 @@ var MissingConnectionNotification = class {
     };
   }
 };
-__name(MissingConnectionNotification, "MissingConnectionNotification");
-var MissingConnectionResolvedNotification = class {
+__name(_MissingConnectionNotification, "MissingConnectionNotification");
+var MissingConnectionNotification = _MissingConnectionNotification;
+var _MissingConnectionResolvedNotification = class _MissingConnectionResolvedNotification {
   constructor(options) {
     this.options = options;
   }
   get event() {
     return {
-      name: import_core10.MISSING_CONNECTION_RESOLVED_NOTIFICATION,
+      name: core.MISSING_CONNECTION_RESOLVED_NOTIFICATION,
       title: "Missing Connection Resolved Notification",
       source: "trigger.dev",
       icon: "connection-alert",
-      parsePayload: import_core10.MissingConnectionResolvedNotificationPayloadSchema.parse,
+      parsePayload: core.MissingConnectionResolvedNotificationPayloadSchema.parse,
       properties: [
         {
           label: "Integrations",
@@ -4382,11 +4569,12 @@ var MissingConnectionResolvedNotification = class {
     };
   }
 };
-__name(MissingConnectionResolvedNotification, "MissingConnectionResolvedNotification");
+__name(_MissingConnectionResolvedNotification, "MissingConnectionResolvedNotification");
+var MissingConnectionResolvedNotification = _MissingConnectionResolvedNotification;
 
 // src/triggers/invokeTrigger.ts
 var _options5;
-var InvokeTrigger = class {
+var _InvokeTrigger = class _InvokeTrigger {
   constructor(options) {
     __privateAdd(this, _options5, void 0);
     __privateSet(this, _options5, options);
@@ -4436,18 +4624,15 @@ var InvokeTrigger = class {
     };
   }
 };
-__name(InvokeTrigger, "InvokeTrigger");
 _options5 = new WeakMap();
+__name(_InvokeTrigger, "InvokeTrigger");
+var InvokeTrigger = _InvokeTrigger;
 function invokeTrigger(options) {
   return new InvokeTrigger(options ?? {});
 }
 __name(invokeTrigger, "invokeTrigger");
-
-// src/triggers/webhook.ts
-var import_core11 = require("@trigger.dev/core");
-var import_node_crypto2 = require("crypto");
 var _shortHash, shortHash_fn;
-var WebhookSource = class {
+var _WebhookSource = class _WebhookSource {
   constructor(options) {
     __privateAdd(this, _shortHash);
     this.options = options;
@@ -4515,13 +4700,14 @@ var WebhookSource = class {
     return this.options.version;
   }
 };
-__name(WebhookSource, "WebhookSource");
 _shortHash = new WeakSet();
 shortHash_fn = /* @__PURE__ */ __name(function(str) {
-  const hash = (0, import_node_crypto2.createHash)("sha1").update(str).digest("hex");
+  const hash = crypto.createHash("sha1").update(str).digest("hex");
   return hash.slice(0, 7);
 }, "#shortHash");
-var WebhookTrigger = class {
+__name(_WebhookSource, "WebhookSource");
+var WebhookSource = _WebhookSource;
+var _WebhookTrigger = class _WebhookTrigger {
   constructor(options) {
     this.options = options;
   }
@@ -4540,7 +4726,7 @@ var WebhookTrigger = class {
       title: "Webhook",
       rule: {
         event: this.event.name,
-        payload: (0, import_core11.deepMergeFilters)(this.options.source.filter(this.options.params, this.options.config), this.event.filter ?? {}),
+        payload: core.deepMergeFilters(this.options.source.filter(this.options.params, this.options.config), this.event.filter ?? {}),
         source: this.event.source
       },
       properties: this.options.source.properties(this.options.params),
@@ -4550,11 +4736,11 @@ var WebhookTrigger = class {
   filter(eventFilter) {
     const { event, ...optionsWithoutEvent } = this.options;
     const { filter, ...eventWithoutFilter } = event;
-    return new WebhookTrigger({
+    return new _WebhookTrigger({
       ...optionsWithoutEvent,
       event: {
         ...eventWithoutFilter,
-        filter: (0, import_core11.deepMergeFilters)(filter ?? {}, eventFilter)
+        filter: core.deepMergeFilters(filter ?? {}, eventFilter)
       }
     });
   }
@@ -4584,10 +4770,8 @@ var WebhookTrigger = class {
     };
   }
 };
-__name(WebhookTrigger, "WebhookTrigger");
-
-// src/security.ts
-var import_crypto = __toESM(require("crypto"));
+__name(_WebhookTrigger, "WebhookTrigger");
+var WebhookTrigger = _WebhookTrigger;
 async function verifyRequestSignature({ request, headerName, headerEncoding = "hex", secret, algorithm }) {
   if (!secret) {
     return {
@@ -4621,7 +4805,7 @@ async function verifyRequestSignature({ request, headerName, headerEncoding = "h
 }
 __name(verifyRequestSignature, "verifyRequestSignature");
 function verifyHmacSha256(headerValue, headerEncoding, secret, body) {
-  const bodyDigest = import_crypto.default.createHmac("sha256", secret).update(body).digest(headerEncoding);
+  const bodyDigest = crypto__default.default.createHmac("sha256", secret).update(body).digest(headerEncoding);
   const signature = headerValue?.replace("hmac-sha256=", "").replace("sha256=", "") ?? "";
   return signature === bodyDigest;
 }
@@ -4636,39 +4820,38 @@ function redactString(strings, ...interpolations) {
   };
 }
 __name(redactString, "redactString");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CronTrigger,
-  DynamicSchedule,
-  DynamicTrigger,
-  EventSpecificationExampleSchema,
-  EventTrigger,
-  ExternalSource,
-  ExternalSourceTrigger,
-  IO,
-  IOLogger,
-  IntervalTrigger,
-  InvokeTrigger,
-  JSONOutputSerializer,
-  Job,
-  MissingConnectionNotification,
-  MissingConnectionResolvedNotification,
-  TriggerClient,
-  WebhookSource,
-  WebhookTrigger,
-  cronTrigger,
-  eventTrigger,
-  intervalTrigger,
-  invokeTrigger,
-  isTriggerError,
-  missingConnectionNotification,
-  missingConnectionResolvedNotification,
-  omit,
-  redactString,
-  retry,
-  slugifyId,
-  verifyHmacSha256,
-  verifyRequestSignature,
-  waitForEventSchema
-});
+
+exports.CronTrigger = CronTrigger;
+exports.DynamicSchedule = DynamicSchedule;
+exports.DynamicTrigger = DynamicTrigger;
+exports.EventSpecificationExampleSchema = EventSpecificationExampleSchema;
+exports.EventTrigger = EventTrigger;
+exports.ExternalSource = ExternalSource;
+exports.ExternalSourceTrigger = ExternalSourceTrigger;
+exports.IO = IO;
+exports.IOLogger = IOLogger;
+exports.IntervalTrigger = IntervalTrigger;
+exports.InvokeTrigger = InvokeTrigger;
+exports.JSONOutputSerializer = JSONOutputSerializer;
+exports.Job = Job;
+exports.MissingConnectionNotification = MissingConnectionNotification;
+exports.MissingConnectionResolvedNotification = MissingConnectionResolvedNotification;
+exports.TriggerClient = TriggerClient;
+exports.WebhookSource = WebhookSource;
+exports.WebhookTrigger = WebhookTrigger;
+exports.cronTrigger = cronTrigger;
+exports.eventTrigger = eventTrigger;
+exports.intervalTrigger = intervalTrigger;
+exports.invokeTrigger = invokeTrigger;
+exports.isTriggerError = isTriggerError;
+exports.missingConnectionNotification = missingConnectionNotification;
+exports.missingConnectionResolvedNotification = missingConnectionResolvedNotification;
+exports.omit = omit;
+exports.redactString = redactString;
+exports.retry = retry;
+exports.slugifyId = slugifyId;
+exports.verifyHmacSha256 = verifyHmacSha256;
+exports.verifyRequestSignature = verifyRequestSignature;
+exports.waitForEventSchema = waitForEventSchema;
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map