@trigger.dev/sdk 2.2.4 → 2.2.6

package/dist/index.js

@@ -57,12 +57,15 @@ __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,
@@ -70,12 +73,16 @@ __export(src_exports, {
   cronTrigger: () => cronTrigger,
   eventTrigger: () => eventTrigger,
   intervalTrigger: () => intervalTrigger,
+  invokeTrigger: () => invokeTrigger,
   isTriggerError: () => isTriggerError,
   missingConnectionNotification: () => missingConnectionNotification,
   missingConnectionResolvedNotification: () => missingConnectionResolvedNotification,
   omit: () => omit,
   redactString: () => redactString,
-  retry: () => retry
+  retry: () => retry,
+  verifyHmacSha256: () => verifyHmacSha256,
+  verifyRequestSignature: () => verifyRequestSignature,
+  waitForEventSchema: () => waitForEventSchema
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -87,6 +94,24 @@ function slugifyId(input) {
 }
 __name(slugifyId, "slugifyId");
 
+// src/utils/typedAsyncLocalStorage.ts
+var import_node_async_hooks = require("async_hooks");
+var TypedAsyncLocalStorage = class {
+  constructor() {
+    this.storage = new import_node_async_hooks.AsyncLocalStorage();
+  }
+  runWith(context, fn) {
+    return this.storage.run(context, fn);
+  }
+  getStore() {
+    return this.storage.getStore();
+  }
+};
+__name(TypedAsyncLocalStorage, "TypedAsyncLocalStorage");
+
+// src/runLocalStorage.ts
+var runLocalStorage = new TypedAsyncLocalStorage();
+
 // src/job.ts
 var _validate, validate_fn;
 var Job = class {
@@ -141,6 +166,118 @@ var Job = class {
       internal
     };
   }
+  async invoke(param1, param2 = void 0, param3 = void 0) {
+    const runStore = runLocalStorage.getStore();
+    if (typeof param1 === "string") {
+      if (!runStore) {
+        throw new Error("Cannot invoke a job from outside of a run when passing a cacheKey. Make sure you are running the job from within a run or use the invoke method without the cacheKey.");
+      }
+      const options = param3 ?? {};
+      return await runStore.io.runTask(param1, async (task) => {
+        const result = await this.client.invokeJob(this.id, param2, {
+          idempotencyKey: task.idempotencyKey,
+          ...options
+        });
+        task.outputProperties = [
+          {
+            label: "Run",
+            text: result.id,
+            url: `/orgs/${runStore.ctx.organization.slug}/projects/${runStore.ctx.project.slug}/jobs/${this.id}/runs/${result.id}/trigger`
+          }
+        ];
+        return result;
+      }, {
+        name: `Manually Invoke '${this.name}'`,
+        params: param2,
+        properties: [
+          {
+            label: "Job",
+            text: this.id,
+            url: `/orgs/${runStore.ctx.organization.slug}/projects/${runStore.ctx.project.slug}/jobs/${this.id}`
+          },
+          {
+            label: "Env",
+            text: runStore.ctx.environment.slug
+          }
+        ]
+      });
+    }
+    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);
+  }
+  async invokeAndWaitForCompletion(cacheKey, payload, timeoutInSeconds = 60 * 60, options = {}) {
+    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.");
+    }
+    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, {
+        idempotencyKey: task.idempotencyKey,
+        callbackUrl: task.callbackUrl ?? void 0,
+        ...options
+      });
+      task.outputProperties = [
+        {
+          label: "Run",
+          text: result.id,
+          url: `/orgs/${ctx.organization.slug}/projects/${ctx.project.slug}/jobs/${this.id}/runs/${result.id}/trigger`
+        }
+      ];
+      return {};
+    }, {
+      name: `Manually Invoke '${this.name}' and wait for completion`,
+      params: payload,
+      properties: [
+        {
+          label: "Job",
+          text: this.id,
+          url: `/orgs/${ctx.organization.slug}/projects/${ctx.project.slug}/jobs/${this.id}`
+        },
+        {
+          label: "Env",
+          text: ctx.environment.slug
+        }
+      ],
+      callback: {
+        enabled: true,
+        timeoutInSeconds
+      }
+    });
+  }
+  async batchInvokeAndWaitForCompletion(cacheKey, batch) {
+    const runStore = runLocalStorage.getStore();
+    if (!runStore) {
+      throw new Error("Cannot invoke a job from outside of a run using batchInvokeAndWaitForCompletion.");
+    }
+    if (batch.length === 0) {
+      return [];
+    }
+    if (batch.length > 25) {
+      throw new Error(`Cannot batch invoke more than 25 items. You tried to batch invoke ${batch.length} items.`);
+    }
+    const { io, ctx } = runStore;
+    const results = await io.parallel(cacheKey, batch, async (item, index) => {
+      return await this.invokeAndWaitForCompletion(String(index), item.payload, item.timeoutInSeconds ?? 60 * 60, item.options);
+    }, {
+      name: `Batch Invoke '${this.name}'`,
+      properties: [
+        {
+          label: "Job",
+          text: this.id,
+          url: `/orgs/${ctx.organization.slug}/projects/${ctx.project.slug}/jobs/${this.id}`
+        },
+        {
+          label: "Env",
+          text: ctx.environment.slug
+        }
+      ]
+    });
+    return results;
+  }
 };
 __name(Job, "Job");
 _validate = new WeakSet();
@@ -151,7 +288,8 @@ validate_fn = /* @__PURE__ */ __name(function() {
 }, "#validate");
 
 // src/triggerClient.ts
-var import_core7 = require("@trigger.dev/core");
+var import_core8 = require("@trigger.dev/core");
+var import_colorette = require("colorette");
 
 // src/apiClient.ts
 var import_core = require("@trigger.dev/core");
@@ -221,7 +359,8 @@ var ApiClient = class {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+        Authorization: `Bearer ${apiKey}`,
+        "Trigger-Version": import_core.API_VERSIONS.SERIALIZED_TASK_OUTPUT
       },
       body: JSON.stringify(task)
     });
@@ -259,6 +398,23 @@ var ApiClient = class {
       })
     });
   }
+  async sendEvents(events, options = {}) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Sending multiple events", {
+      events
+    });
+    return await zodfetch(import_core.ApiEventLogSchema.array(), `${__privateGet(this, _apiUrl)}/api/v1/events/bulk`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        events,
+        options
+      })
+    });
+  }
   async cancelEvent(eventId) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
     __privateGet(this, _logger).debug("Cancelling event", {
@@ -447,6 +603,46 @@ var ApiClient = class {
       }
     });
   }
+  async invokeJob(jobId, payload, options = {}) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Invoking Job", {
+      jobId
+    });
+    const body = {
+      payload,
+      context: options.context ?? {},
+      options: {
+        accountId: options.accountId,
+        callbackUrl: options.callbackUrl
+      }
+    };
+    return await zodfetch(import_core.InvokeJobResponseSchema, `${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobId}/invoke`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        ...options.idempotencyKey ? {
+          "Idempotency-Key": options.idempotencyKey
+        } : {}
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  async createEphemeralEventDispatcher(payload) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Creating ephemeral event dispatcher", {
+      payload
+    });
+    const response = await zodfetch(import_core.EphemeralEventDispatcherResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/event-dispatchers/ephemeral`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+    return response;
+  }
 };
 __name(ApiClient, "ApiClient");
 _apiUrl = new WeakMap();
@@ -482,8 +678,11 @@ function getApiKey(key) {
   };
 }
 __name(getApiKey, "getApiKey");
-async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options) {
-  const response = await fetch(url, requestInit);
+async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount = 0) {
+  const response = await fetch(url, {
+    ...requestInit,
+    cache: "no-cache"
+  });
   if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
     return;
   }
@@ -491,6 +690,11 @@ async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url,
     const body = await response.json();
     throw new Error(body.error);
   }
+  if (response.status >= 500 && retryCount < 6) {
+    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount + 1);
+  }
   if (response.status !== 200) {
     throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
   }
@@ -512,8 +716,11 @@ async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url,
   };
 }
 __name(zodfetchWithVersions, "zodfetchWithVersions");
-async function zodfetch(schema, url, requestInit, options) {
-  const response = await fetch(url, requestInit);
+async function zodfetch(schema, url, requestInit, options, retryCount = 0) {
+  const response = await fetch(url, {
+    ...requestInit,
+    cache: "no-cache"
+  });
   if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
     return;
   }
@@ -521,6 +728,11 @@ async function zodfetch(schema, url, requestInit, options) {
     const body = await response.json();
     throw new Error(body.error);
   }
+  if (response.status >= 500 && retryCount < 6) {
+    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return zodfetch(schema, url, requestInit, options, retryCount + 1);
+  }
   if (response.status !== 200) {
     throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
   }
@@ -528,6 +740,12 @@ async function zodfetch(schema, url, requestInit, options) {
   return schema.parse(jsonBody);
 }
 __name(zodfetch, "zodfetch");
+function exponentialBackoff(retryCount, exponential, minDelay, maxDelay, jitter) {
+  const delay = Math.min(Math.pow(exponential, retryCount) * minDelay, maxDelay);
+  const jitterValue = Math.random() * jitter;
+  return delay + jitterValue;
+}
+__name(exponentialBackoff, "exponentialBackoff");
 
 // src/errors.ts
 var ResumeWithTaskError = class {
@@ -536,6 +754,13 @@ var ResumeWithTaskError = class {
   }
 };
 __name(ResumeWithTaskError, "ResumeWithTaskError");
+var ResumeWithParallelTaskError = class {
+  constructor(task, childErrors) {
+    this.task = task;
+    this.childErrors = childErrors;
+  }
+};
+__name(ResumeWithParallelTaskError, "ResumeWithParallelTaskError");
 var RetryWithTaskError = class {
   constructor(cause, task, retryAt) {
     this.cause = cause;
@@ -565,11 +790,11 @@ var AutoYieldExecutionError = class {
 };
 __name(AutoYieldExecutionError, "AutoYieldExecutionError");
 var AutoYieldWithCompletedTaskExecutionError = class {
-  constructor(id, properties, output, data) {
+  constructor(id, properties, data, output) {
     this.id = id;
     this.properties = properties;
-    this.output = output;
     this.data = data;
+    this.output = output;
   }
 };
 __name(AutoYieldWithCompletedTaskExecutionError, "AutoYieldWithCompletedTaskExecutionError");
@@ -580,18 +805,160 @@ var ParsedPayloadSchemaError = class {
 };
 __name(ParsedPayloadSchemaError, "ParsedPayloadSchemaError");
 function isTriggerError(err) {
-  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError || err instanceof YieldExecutionError || err instanceof AutoYieldExecutionError || err instanceof AutoYieldWithCompletedTaskExecutionError;
+  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 {
+  constructor(cause, message) {
+    super(message);
+    this.cause = cause;
+  }
+};
+__name(ErrorWithTask, "ErrorWithTask");
+
+// src/httpEndpoint.ts
+var import_core2 = require("@trigger.dev/core");
+
+// src/utils/formatSchemaErrors.ts
+function formatSchemaErrors(errors) {
+  return errors.map((error) => {
+    const { path, message } = error;
+    return {
+      path: path.map(String),
+      message
+    };
+  });
+}
+__name(formatSchemaErrors, "formatSchemaErrors");
+
+// src/httpEndpoint.ts
+var HttpEndpoint = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get id() {
+    return this.options.id;
+  }
+  onRequest(options) {
+    return new HttpTrigger({
+      endpointId: this.id,
+      event: this.options.event,
+      filter: options?.filter,
+      verify: this.options.verify
+    });
+  }
+  async handleRequest(request) {
+    if (!this.options.respondWith)
+      return;
+    return this.options.respondWith.handler(request, () => {
+      const clonedRequest = request.clone();
+      return this.options.verify(clonedRequest);
+    });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      icon: this.options.event.icon,
+      version: "1",
+      enabled: this.options.enabled ?? true,
+      event: this.options.event,
+      immediateResponseFilter: this.options.respondWith?.filter,
+      skipTriggeringRuns: this.options.respondWith?.skipTriggeringRuns,
+      source: this.options.event.source
+    };
+  }
+};
+__name(HttpEndpoint, "HttpEndpoint");
+var HttpTrigger = /* @__PURE__ */ __name(class HttpTrigger2 {
+  constructor(options) {
+    this.options = options;
+  }
+  toJSON() {
+    return {
+      type: "static",
+      title: this.options.endpointId,
+      properties: this.options.event.properties,
+      rule: {
+        event: `httpendpoint.${this.options.endpointId}`,
+        payload: this.options.filter ?? {},
+        source: this.options.event.source
+      },
+      link: `http-endpoints/${this.options.endpointId}`,
+      help: {
+        noRuns: {
+          text: "To start triggering runs click here to setup your HTTP Endpoint with the external API service you want to receive webhooks from.",
+          link: `http-endpoints/${this.options.endpointId}`
+        }
+      }
+    };
+  }
+  get event() {
+    return this.options.event;
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  async verifyPayload(payload) {
+    const clonedRequest = payload.clone();
+    return this.options.verify(clonedRequest);
+  }
+}, "HttpTrigger");
+function httpEndpoint(options) {
+  const id = slugifyId(options.id);
+  return new HttpEndpoint({
+    id,
+    enabled: options.enabled,
+    respondWith: options.respondWith,
+    verify: options.verify,
+    event: {
+      name: id,
+      title: options.title ?? "HTTP Trigger",
+      source: options.source,
+      icon: options.icon ?? "webhook",
+      properties: options.properties,
+      examples: options.examples ? options.examples : [
+        {
+          id: "basic-request",
+          name: "Basic Request",
+          icon: "http-post",
+          payload: {
+            url: "https://cloud.trigger.dev",
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            rawBody: JSON.stringify({
+              foo: "bar"
+            })
+          }
+        }
+      ],
+      parsePayload: (rawPayload) => {
+        const result = import_core2.RequestWithRawBodySchema.safeParse(rawPayload);
+        if (!result.success) {
+          throw new ParsedPayloadSchemaError(formatSchemaErrors(result.error.issues));
+        }
+        return new Request(new URL(result.data.url), {
+          method: result.data.method,
+          headers: result.data.headers,
+          body: result.data.rawBody
+        });
+      }
+    }
+  });
+}
+__name(httpEndpoint, "httpEndpoint");
 
 // src/io.ts
-var import_core3 = require("@trigger.dev/core");
+var import_core4 = require("@trigger.dev/core");
 var import_core_backend = require("@trigger.dev/core-backend");
-var import_node_async_hooks = require("async_hooks");
+var import_node_async_hooks2 = require("async_hooks");
 var import_node_crypto = require("crypto");
 
 // src/retry.ts
-var import_core2 = require("@trigger.dev/core");
+var import_core3 = require("@trigger.dev/core");
 var retry = {
   standardBackoff: {
     limit: 8,
@@ -599,6 +966,13 @@ var retry = {
     minTimeoutInMs: 500,
     maxTimeoutInMs: 3e4,
     randomize: true
+  },
+  exponentialBackoff: {
+    limit: 8,
+    factor: 2,
+    minTimeoutInMs: 1e3,
+    maxTimeoutInMs: 3e4,
+    randomize: true
   }
 };
 
@@ -636,7 +1010,38 @@ var TriggerStatus = class {
 };
 __name(TriggerStatus, "TriggerStatus");
 
+// src/types.ts
+var import_zod2 = require("zod");
+var EventSpecificationExampleSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  icon: import_zod2.z.string().optional(),
+  payload: import_zod2.z.any()
+});
+function waitForEventSchema(schema) {
+  return import_zod2.z.object({
+    id: import_zod2.z.string(),
+    name: import_zod2.z.string(),
+    source: import_zod2.z.string(),
+    payload: schema,
+    timestamp: import_zod2.z.coerce.date(),
+    context: import_zod2.z.any().optional(),
+    accountId: import_zod2.z.string().optional()
+  });
+}
+__name(waitForEventSchema, "waitForEventSchema");
+
 // src/io.ts
+var import_zod3 = require("zod");
+var JSONOutputSerializer = class {
+  serialize(value) {
+    return JSON.stringify(value);
+  }
+  deserialize(value) {
+    return value ? JSON.parse(value) : void 0;
+  }
+};
+__name(JSONOutputSerializer, "JSONOutputSerializer");
 var _addToCachedTasks, addToCachedTasks_fn, _detectAutoYield, detectAutoYield_fn, _forceYield, forceYield_fn, _getTimeElapsed, getTimeElapsed_fn, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn;
 var IO = class {
   constructor(options) {
@@ -645,11 +1050,13 @@ var IO = class {
     __privateAdd(this, _forceYield);
     __privateAdd(this, _getTimeElapsed);
     __privateAdd(this, _getRemainingTimeInMillis);
+    __publicField(this, "_outputSerializer", new JSONOutputSerializer());
+    __publicField(this, "_visitedCacheKeys", /* @__PURE__ */ new Set());
     __publicField(this, "brb", this.yield.bind(this));
     this._id = options.id;
     this._apiClient = options.apiClient;
     this._triggerClient = options.client;
-    this._logger = options.logger ?? new import_core3.Logger("trigger.dev", options.logLevel);
+    this._logger = options.logger ?? new import_core4.Logger("trigger.dev", options.logLevel);
     this._cachedTasks = /* @__PURE__ */ new Map();
     this._jobLogger = options.jobLogger;
     this._jobLogLevel = options.jobLogLevel;
@@ -670,7 +1077,7 @@ var IO = class {
       });
       this._stats.initialCachedTasks = options.cachedTasks.length;
     }
-    this._taskStorage = new import_node_async_hooks.AsyncLocalStorage();
+    this._taskStorage = new import_node_async_hooks2.AsyncLocalStorage();
     this._context = options.context;
     this._yieldedExecutions = options.yieldedExecutions ?? [];
     if (options.noopTasksSet) {
@@ -691,7 +1098,7 @@ var IO = class {
   get logger() {
     return new IOLogger(async (level, message, data) => {
       let logLevel = "info";
-      if (import_core3.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
+      if (import_core4.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
         await this.runTask([
           message,
           level
@@ -743,6 +1150,56 @@ var IO = class {
       }
     });
   }
+  async random(cacheKey, { min = 0, max = 1, round = false } = {}) {
+    return await this.runTask(cacheKey, async (task) => {
+      if (min > max) {
+        throw new Error(`Lower bound can't be higher than upper bound - min: ${min}, max: ${max}`);
+      }
+      if (min === max) {
+        await this.logger.warn(`Lower and upper bounds are identical. The return value is not random and will always be: ${min}`);
+      }
+      const withinBounds = (max - min) * Math.random() + min;
+      if (!round) {
+        return withinBounds;
+      }
+      if (!Number.isInteger(min) || !Number.isInteger(max)) {
+        await this.logger.warn("Rounding enabled with floating-point bounds. This may cause unexpected skew and boundary inclusivity.");
+      }
+      const rounded = Math.round(withinBounds);
+      return rounded;
+    }, {
+      name: "random",
+      icon: "dice-5-filled",
+      params: {
+        min,
+        max,
+        round
+      },
+      properties: [
+        ...min === 0 ? [] : [
+          {
+            label: "min",
+            text: String(min)
+          }
+        ],
+        ...max === 1 ? [] : [
+          {
+            label: "max",
+            text: String(max)
+          }
+        ],
+        ...round === false ? [] : [
+          {
+            label: "round",
+            text: String(round)
+          }
+        ]
+      ],
+      style: {
+        style: "minimal"
+      }
+    });
+  }
   async wait(cacheKey, seconds) {
     return await this.runTask(cacheKey, async (task) => {
     }, {
@@ -758,22 +1215,109 @@ var IO = class {
       }
     });
   }
+  async waitForEvent(cacheKey, event, options) {
+    const timeoutInSeconds = options?.timeoutInSeconds ?? 60 * 60;
+    return await this.runTask(cacheKey, async (task, io) => {
+      if (!task.callbackUrl) {
+        throw new Error("No callbackUrl found on task");
+      }
+      await this.triggerClient.createEphemeralEventDispatcher({
+        url: task.callbackUrl,
+        name: event.name,
+        filter: event.filter,
+        contextFilter: event.contextFilter,
+        source: event.source,
+        accountId: event.accountId,
+        timeoutInSeconds
+      });
+      return {};
+    }, {
+      name: "Wait for Event",
+      icon: "custom-event",
+      params: {
+        name: event.name,
+        source: event.source,
+        filter: event.filter,
+        contextFilter: event.contextFilter,
+        accountId: event.accountId
+      },
+      callback: {
+        enabled: true,
+        timeoutInSeconds
+      },
+      properties: [
+        {
+          label: "Event",
+          text: event.name
+        },
+        {
+          label: "Timeout",
+          text: `${timeoutInSeconds}s`
+        },
+        ...event.source ? [
+          {
+            label: "Source",
+            text: event.source
+          }
+        ] : [],
+        ...event.accountId ? [
+          {
+            label: "Account ID",
+            text: event.accountId
+          }
+        ] : []
+      ],
+      parseOutput: (output) => {
+        return waitForEventSchema(event.schema ?? import_zod3.z.any()).parse(output);
+      }
+    });
+  }
+  async waitForRequest(cacheKey, callback, options) {
+    const timeoutInSeconds = options?.timeoutInSeconds ?? 60 * 60;
+    return await this.runTask(cacheKey, async (task, io) => {
+      if (!task.callbackUrl) {
+        throw new Error("No callbackUrl found on task");
+      }
+      task.outputProperties = [
+        {
+          label: "Callback URL",
+          text: task.callbackUrl
+        }
+      ];
+      return callback(task.callbackUrl);
+    }, {
+      name: "Wait for Request",
+      icon: "clock",
+      callback: {
+        enabled: true,
+        timeoutInSeconds: options?.timeoutInSeconds
+      },
+      properties: [
+        {
+          label: "Timeout",
+          text: `${timeoutInSeconds}s`
+        }
+      ]
+    });
+  }
   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;
   }
-  async backgroundFetch(cacheKey, url, requestInit, retry2) {
+  async backgroundFetch(cacheKey, url, requestInit, options) {
     const urlObject = new URL(url);
     return await this.runTask(cacheKey, async (task) => {
+      console.log("task context", task.context);
       return task.output;
     }, {
       name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
       params: {
         url,
         requestInit,
-        retry: retry2
+        retry: options?.retry,
+        timeout: options?.timeout
       },
       operation: "fetch",
       icon: "background",
@@ -791,8 +1335,87 @@ var IO = class {
         {
           label: "background",
           text: "true"
+        },
+        ...options?.timeout ? [
+          {
+            label: "timeout",
+            text: `${options.timeout.durationInMs}ms`
+          }
+        ] : []
+      ],
+      retry: {
+        limit: 0
+      }
+    });
+  }
+  async backgroundPoll(cacheKey, params) {
+    const urlObject = new URL(params.url);
+    return await this.runTask(cacheKey, async (task) => {
+      return task.output;
+    }, {
+      name: `poll ${urlObject.hostname}${urlObject.pathname}`,
+      params,
+      operation: "fetch-poll",
+      icon: "clock-bolt",
+      noop: false,
+      properties: [
+        {
+          label: "url",
+          text: params.url
+        },
+        {
+          label: "interval",
+          text: `${params.interval}s`
+        },
+        {
+          label: "timeout",
+          text: `${params.timeout}s`
         }
-      ]
+      ],
+      retry: {
+        limit: 0
+      }
+    });
+  }
+  async backgroundFetchResponse(cacheKey, url, requestInit, options) {
+    const urlObject = new URL(url);
+    return await this.runTask(cacheKey, async (task) => {
+      return task.output;
+    }, {
+      name: `fetch response ${urlObject.hostname}${urlObject.pathname}`,
+      params: {
+        url,
+        requestInit,
+        retry: options?.retry,
+        timeout: options?.timeout
+      },
+      operation: "fetch-response",
+      icon: "background",
+      noop: false,
+      properties: [
+        {
+          label: "url",
+          text: url,
+          url
+        },
+        {
+          label: "method",
+          text: requestInit?.method ?? "GET"
+        },
+        {
+          label: "background",
+          text: "true"
+        },
+        ...options?.timeout ? [
+          {
+            label: "timeout",
+            text: `${options.timeout.durationInMs}ms`
+          }
+        ] : []
+      ],
+      retry: {
+        limit: 0
+      }
     });
   }
   async sendEvent(cacheKey, event, options) {
@@ -814,7 +1437,26 @@ var IO = class {
             label: "ID",
             text: event.id
           }
-        ] : []
+        ] : [],
+        ...sendEventOptionsProperties(options)
+      ]
+    });
+  }
+  async sendEvents(cacheKey, events, options) {
+    return await this.runTask(cacheKey, async (task) => {
+      return await this._triggerClient.sendEvents(events, options);
+    }, {
+      name: "sendEvents",
+      params: {
+        events,
+        options
+      },
+      properties: [
+        {
+          label: "Total Events",
+          text: String(events.length)
+        },
+        ...sendEventOptionsProperties(options)
       ]
     });
   }
@@ -990,6 +1632,25 @@ var IO = class {
       name: "get-auth"
     });
   }
+  async parallel(cacheKey, items, callback, options) {
+    const results = await this.runTask(cacheKey, async (task) => {
+      const outcomes = await Promise.allSettled(items.map((item, index) => spaceOut(() => callback(item, index), index, 15)));
+      if (outcomes.every((outcome) => outcome.status === "fulfilled")) {
+        return outcomes.map((outcome) => outcome.value);
+      }
+      const nonInternalErrors = outcomes.filter((outcome) => outcome.status === "rejected" && !isTriggerError(outcome.reason)).map((outcome) => outcome);
+      if (nonInternalErrors.length > 0) {
+        throw nonInternalErrors[0].reason;
+      }
+      const internalErrors = outcomes.filter((outcome) => outcome.status === "rejected" && isTriggerError(outcome.reason)).map((outcome) => outcome).map((outcome) => outcome.reason);
+      throw new ResumeWithParallelTaskError(task, internalErrors);
+    }, {
+      name: "parallel",
+      parallel: true,
+      ...options ?? {}
+    });
+    return results;
+  }
   async runTask(cacheKey, callback, options, onError) {
     __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "start_task", 500);
     const parentId = this._taskStorage.getStore()?.taskId;
@@ -1005,13 +1666,21 @@ var IO = class {
       parentId ?? "",
       cacheKey
     ].flat());
+    if (this._visitedCacheKeys.has(idempotencyKey)) {
+      if (typeof cacheKey === "string") {
+        throw new Error(`Task with cacheKey "${cacheKey}" has already been executed in this run. Each task must have a unique cacheKey.`);
+      } else {
+        throw new Error(`Task with cacheKey "${cacheKey.join("-")}" has already been executed in this run. Each task must have a unique cacheKey.`);
+      }
+    }
+    this._visitedCacheKeys.add(idempotencyKey);
     const cachedTask = this._cachedTasks.get(idempotencyKey);
     if (cachedTask && cachedTask.status === "COMPLETED") {
       this._logger.debug("Using completed cached task", {
         idempotencyKey
       });
       this._stats.cachedTaskHits++;
-      return cachedTask.output;
+      return options?.parseOutput ? options.parseOutput(cachedTask.output) : cachedTask.output;
     }
     if (options?.noop && this._noopTasksBloomFilter) {
       if (this._noopTasksBloomFilter.test(idempotencyKey)) {
@@ -1022,23 +1691,27 @@ var IO = class {
         return {};
       }
     }
+    const runOptions = {
+      ...options ?? {},
+      parseOutput: void 0
+    };
     const response = await this._apiClient.runTask(this._id, {
       idempotencyKey,
       displayKey: typeof cacheKey === "string" ? cacheKey : void 0,
       noop: false,
-      ...options ?? {},
+      ...runOptions ?? {},
       parentId
     }, {
       cachedTasksCursor: this._cachedTasksCursor
     });
-    const task = response.version === import_core3.API_VERSIONS.LAZY_LOADED_CACHED_TASKS ? response.body.task : response.body;
+    const task = response.version === import_core4.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_core3.API_VERSIONS.LAZY_LOADED_CACHED_TASKS) {
+    if (response.version === import_core4.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)) {
@@ -1070,14 +1743,14 @@ var IO = class {
         this._stats.cachedTaskMisses++;
         __privateMethod(this, _addToCachedTasks, addToCachedTasks_fn).call(this, task);
       }
-      return task.output;
+      return options?.parseOutput ? options.parseOutput(task.output) : task.output;
     }
     if (task.status === "ERRORED") {
       this._logger.debug("Task errored", {
         idempotencyKey,
         task
       });
-      throw new Error(task.error ?? task?.output ? JSON.stringify(task.output) : "Task errored");
+      throw new ErrorWithTask(task, task.error ?? task?.output ? JSON.stringify(task.output) : "Task errored");
     }
     __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "before_execute_task", 1500);
     const executeTask = /* @__PURE__ */ __name(async () => {
@@ -1090,14 +1763,14 @@ var IO = class {
           });
           return {};
         }
-        const output = import_core3.SerializableJsonSchema.parse(result);
+        const output = this._outputSerializer.serialize(result);
         this._logger.debug("Completing using output", {
           idempotencyKey,
           task
         });
         __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "before_complete_task", 500, task, output);
         const completedTask = await this._apiClient.completeTask(this._id, task.id, {
-          output: output ?? void 0,
+          output,
           properties: task.outputProperties ?? void 0
         });
         if (completedTask.forceYield) {
@@ -1111,7 +1784,8 @@ var IO = class {
           throw new CanceledWithTaskError(completedTask);
         }
         __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "after_complete_task", 500);
-        return output;
+        const deserializedOutput = this._outputSerializer.deserialize(output);
+        return options?.parseOutput ? options.parseOutput(deserializedOutput) : deserializedOutput;
       } catch (error) {
         if (isTriggerError(error)) {
           throw error;
@@ -1126,7 +1800,7 @@ var IO = class {
               } else {
                 skipRetrying = !!onErrorResult.skipRetrying;
                 if (onErrorResult.retryAt && !skipRetrying) {
-                  const parsedError2 = import_core3.ErrorWithStackSchema.safeParse(onErrorResult.error);
+                  const parsedError2 = import_core4.ErrorWithStackSchema.safeParse(onErrorResult.error);
                   throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
                     message: "Unknown error"
                   }, task, onErrorResult.retryAt);
@@ -1140,9 +1814,14 @@ var IO = class {
             error = innerError;
           }
         }
-        const parsedError = import_core3.ErrorWithStackSchema.safeParse(error);
+        if (error instanceof ErrorWithTask) {
+          await this._apiClient.failTask(this._id, task.id, {
+            error: error.cause.output
+          });
+        }
+        const parsedError = import_core4.ErrorWithStackSchema.safeParse(error);
         if (options?.retry && !skipRetrying) {
-          const retryAt = (0, import_core2.calculateRetryAt)(options.retry, task.attempts - 1);
+          const retryAt = (0, import_core3.calculateRetryAt)(options.retry, task.attempts - 1);
           if (retryAt) {
             throw new RetryWithTaskError(parsedError.success ? parsedError.data : {
               message: "Unknown error"
@@ -1189,7 +1868,7 @@ var IO = class {
     }, executeTask);
   }
   yield(cacheKey) {
-    if (!(0, import_core3.supportsFeature)("yieldExecution", this._serverVersion)) {
+    if (!(0, import_core4.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;
     }
@@ -1219,11 +1898,11 @@ detectAutoYield_fn = /* @__PURE__ */ __name(function(location, threshold = 1500,
   const timeRemaining = __privateMethod(this, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn).call(this);
   if (timeRemaining && timeRemaining < threshold) {
     if (task1) {
-      throw new AutoYieldWithCompletedTaskExecutionError(task1.id, task1.outputProperties ?? [], output, {
+      throw new AutoYieldWithCompletedTaskExecutionError(task1.id, task1.outputProperties ?? [], {
         location,
         timeRemaining,
         timeElapsed: __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this)
-      });
+      }, output);
     } else {
       throw new AutoYieldExecutionError(location, timeRemaining, __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this));
     }
@@ -1300,6 +1979,34 @@ var IOLogger = class {
   }
 };
 __name(IOLogger, "IOLogger");
+async function spaceOut(callback, index, delay) {
+  await new Promise((resolve) => setTimeout(resolve, index * delay));
+  return await callback();
+}
+__name(spaceOut, "spaceOut");
+function sendEventOptionsProperties(options) {
+  return [
+    ...options?.accountId ? [
+      {
+        label: "Account ID",
+        text: options.accountId
+      }
+    ] : [],
+    ...options?.deliverAfter ? [
+      {
+        label: "Deliver After",
+        text: `${options.deliverAfter}s`
+      }
+    ] : [],
+    ...options?.deliverAt ? [
+      {
+        label: "Deliver At",
+        text: options.deliverAt.toISOString()
+      }
+    ] : []
+  ];
+}
+__name(sendEventOptionsProperties, "sendEventOptionsProperties");
 
 // src/ioWithIntegrations.ts
 function createIOWithIntegrations(io, auths, integrations) {
@@ -1330,26 +2037,8 @@ function createIOWithIntegrations(io, auths, integrations) {
 }
 __name(createIOWithIntegrations, "createIOWithIntegrations");
 
-// src/utils/typedAsyncLocalStorage.ts
-var import_node_async_hooks2 = require("async_hooks");
-var TypedAsyncLocalStorage = class {
-  constructor() {
-    this.storage = new import_node_async_hooks2.AsyncLocalStorage();
-  }
-  runWith(context, fn) {
-    return this.storage.run(context, fn);
-  }
-  getStore() {
-    return this.storage.getStore();
-  }
-};
-__name(TypedAsyncLocalStorage, "TypedAsyncLocalStorage");
-
-// src/runLocalStorage.ts
-var runLocalStorage = new TypedAsyncLocalStorage();
-
 // src/triggers/dynamic.ts
-var import_core4 = require("@trigger.dev/core");
+var import_core5 = require("@trigger.dev/core");
 var _client, _options2;
 var DynamicTrigger = class {
   constructor(client, options) {
@@ -1378,7 +2067,7 @@ var DynamicTrigger = class {
       rule: {
         event: this.event.name,
         source: this.event.source,
-        payload: (0, import_core4.deepMergeFilters)(this.source.filter(params), this.event.filter ?? {}, options.filter ?? {})
+        payload: (0, import_core5.deepMergeFilters)(this.source.filter(params), this.event.filter ?? {}, options.filter ?? {})
       },
       source: {
         version: "2",
@@ -1431,27 +2120,18 @@ var DynamicTrigger = class {
   get preprocessRuns() {
     return true;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
 };
 __name(DynamicTrigger, "DynamicTrigger");
 _client = new WeakMap();
 _options2 = new WeakMap();
 
 // src/triggers/eventTrigger.ts
-var import_core5 = require("@trigger.dev/core");
-
-// src/utils/formatSchemaErrors.ts
-function formatSchemaErrors(errors) {
-  return errors.map((error) => {
-    const { path, message } = error;
-    return {
-      path: path.map(String),
-      message
-    };
-  });
-}
-__name(formatSchemaErrors, "formatSchemaErrors");
-
-// src/triggers/eventTrigger.ts
+var import_core6 = require("@trigger.dev/core");
 var _options3;
 var EventTrigger = class {
   constructor(options) {
@@ -1465,7 +2145,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_core5.deepMergeFilters)(__privateGet(this, _options3).filter ?? {}, __privateGet(this, _options3).event.filter ?? {})
+        payload: (0, import_core6.deepMergeFilters)(__privateGet(this, _options3).filter ?? {}, __privateGet(this, _options3).event.filter ?? {})
       }
     };
   }
@@ -1477,6 +2157,11 @@ var EventTrigger = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
 };
 __name(EventTrigger, "EventTrigger");
 _options3 = new WeakMap();
@@ -1506,7 +2191,7 @@ function eventTrigger(options) {
 __name(eventTrigger, "eventTrigger");
 
 // src/triggers/scheduled.ts
-var import_core6 = require("@trigger.dev/core");
+var import_core7 = require("@trigger.dev/core");
 var import_cronstrue = __toESM(require("cronstrue"));
 var examples = [
   {
@@ -1514,8 +2199,8 @@ var examples = [
     name: "Now",
     icon: "clock",
     payload: {
-      ts: import_core6.currentDate.marker,
-      lastTimestamp: import_core6.currentDate.marker
+      ts: import_core7.currentDate.marker,
+      lastTimestamp: import_core7.currentDate.marker
     }
   }
 ];
@@ -1530,7 +2215,7 @@ var IntervalTrigger = class {
       source: "trigger.dev",
       icon: "schedule-interval",
       examples,
-      parsePayload: import_core6.ScheduledPayloadSchema.parse,
+      parsePayload: import_core7.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "Interval",
@@ -1544,6 +2229,11 @@ var IntervalTrigger = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "scheduled",
@@ -1575,7 +2265,7 @@ var CronTrigger = class {
       source: "trigger.dev",
       icon: "schedule-cron",
       examples,
-      parsePayload: import_core6.ScheduledPayloadSchema.parse,
+      parsePayload: import_core7.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "cron",
@@ -1593,6 +2283,11 @@ var CronTrigger = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "scheduled",
@@ -1626,7 +2321,7 @@ var DynamicSchedule = class {
       source: "trigger.dev",
       icon: "schedule-dynamic",
       examples,
-      parsePayload: import_core6.ScheduledPayloadSchema.parse
+      parsePayload: import_core7.ScheduledPayloadSchema.parse
     };
   }
   async register(key, metadata) {
@@ -1688,6 +2383,11 @@ var DynamicSchedule = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "dynamic",
@@ -1698,24 +2398,26 @@ var DynamicSchedule = class {
 __name(DynamicSchedule, "DynamicSchedule");
 
 // package.json
-var version = "2.2.4";
+var version = "2.2.6";
 
 // src/triggerClient.ts
 var registerSourceEvent = {
-  name: import_core7.REGISTER_SOURCE_EVENT_V2,
+  name: import_core8.REGISTER_SOURCE_EVENT_V2,
   title: "Register Source",
   source: "internal",
   icon: "register-source",
-  parsePayload: import_core7.RegisterSourceEventSchemaV2.parse
+  parsePayload: import_core8.RegisterSourceEventSchemaV2.parse
 };
-var _options4, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _authResolvers, _client2, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_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;
+var _options4, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _registeredHttpEndpoints, _authResolvers, _client2, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn, _handleHttpEndpointRequestForResponse, handleHttpEndpointRequestForResponse_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;
 var TriggerClient = class {
   constructor(options) {
     __privateAdd(this, _preprocessRun);
     __privateAdd(this, _executeJob);
+    __privateAdd(this, _convertErrorToExecutionResponse);
     __privateAdd(this, _createRunContext);
     __privateAdd(this, _createPreprocessRunContext);
     __privateAdd(this, _handleHttpSourceRequest);
+    __privateAdd(this, _handleHttpEndpointRequestForResponse);
     __privateAdd(this, _resolveConnections);
     __privateAdd(this, _resolveConnection);
     __privateAdd(this, _buildJobsIndex);
@@ -1731,13 +2433,14 @@ var TriggerClient = class {
     __privateAdd(this, _registeredDynamicTriggers, {});
     __privateAdd(this, _jobMetadataByDynamicTriggers, {});
     __privateAdd(this, _registeredSchedules, {});
+    __privateAdd(this, _registeredHttpEndpoints, {});
     __privateAdd(this, _authResolvers, {});
     __privateAdd(this, _client2, void 0);
     __privateAdd(this, _internalLogger, void 0);
     this.id = options.id;
     __privateSet(this, _options4, options);
     __privateSet(this, _client2, new ApiClient(__privateGet(this, _options4)));
-    __privateSet(this, _internalLogger, new import_core7.Logger("trigger.dev", __privateGet(this, _options4).verbose ? "debug" : "log", [
+    __privateSet(this, _internalLogger, new import_core8.Logger("trigger.dev", __privateGet(this, _options4).verbose ? "debug" : "log", [
       "output",
       "noopTasksSet"
     ]));
@@ -1848,7 +2551,8 @@ var TriggerClient = class {
           dynamicSchedules: Object.entries(__privateGet(this, _registeredSchedules)).map(([id, jobs]) => ({
             id,
             jobs
-          }))
+          })),
+          httpEndpoints: Object.entries(__privateGet(this, _registeredHttpEndpoints)).map(([id, endpoint]) => endpoint.toJSON())
         };
         return {
           status: 200,
@@ -1858,7 +2562,7 @@ var TriggerClient = class {
       }
       case "INITIALIZE_TRIGGER": {
         const json = await request.json();
-        const body = import_core7.InitializeTriggerBodySchema.safeParse(json);
+        const body = import_core8.InitializeTriggerBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -1884,7 +2588,7 @@ var TriggerClient = class {
       }
       case "EXECUTE_JOB": {
         const json = await request.json();
-        const execution = import_core7.RunJobBodySchema.safeParse(json);
+        const execution = import_core8.RunJobBodySchema.safeParse(json);
         if (!execution.success) {
           return {
             status: 400,
@@ -1903,6 +2607,12 @@ var TriggerClient = class {
           };
         }
         const results = await __privateMethod(this, _executeJob, executeJob_fn).call(this, execution.data, job, timeOrigin, triggerVersion);
+        __privateGet(this, _internalLogger).debug("executed job", {
+          results,
+          job: job.id,
+          version: job.version,
+          triggerVersion
+        });
         return {
           status: 200,
           body: results,
@@ -1911,7 +2621,7 @@ var TriggerClient = class {
       }
       case "PREPROCESS_RUN": {
         const json = await request.json();
-        const body = import_core7.PreprocessRunBodySchema.safeParse(json);
+        const body = import_core8.PreprocessRunBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -1940,7 +2650,7 @@ var TriggerClient = class {
         };
       }
       case "DELIVER_HTTP_SOURCE_REQUEST": {
-        const headers = import_core7.HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
+        const headers = import_core8.HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
         if (!headers.success) {
           return {
             status: 400,
@@ -1989,6 +2699,39 @@ var TriggerClient = class {
           headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
+      case "DELIVER_HTTP_ENDPOINT_REQUEST_FOR_RESPONSE": {
+        const headers = import_core8.HttpEndpointRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
+        if (!headers.success) {
+          return {
+            status: 400,
+            body: {
+              message: "Invalid headers"
+            }
+          };
+        }
+        const sourceRequestNeedsBody = headers.data["x-ts-http-method"] !== "GET";
+        const sourceRequestInit = {
+          method: headers.data["x-ts-http-method"],
+          headers: headers.data["x-ts-http-headers"],
+          body: sourceRequestNeedsBody ? request.body : void 0
+        };
+        if (sourceRequestNeedsBody) {
+          try {
+            sourceRequestInit.duplex = "half";
+          } catch (error) {
+          }
+        }
+        const sourceRequest = new Request(headers.data["x-ts-http-url"], sourceRequestInit);
+        const key = headers.data["x-ts-key"];
+        const { response } = await __privateMethod(this, _handleHttpEndpointRequestForResponse, handleHttpEndpointRequestForResponse_fn).call(this, {
+          key
+        }, sourceRequest);
+        return {
+          status: 200,
+          body: response,
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
+        };
+      }
       case "VALIDATE": {
         return {
           status: 200,
@@ -2021,6 +2764,10 @@ 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.`));
+    }
     return new Job(this, options);
   }
   defineAuthResolver(integration, resolver) {
@@ -2033,6 +2780,15 @@ var TriggerClient = class {
   defineDynamicTrigger(options) {
     return new DynamicTrigger(this, options);
   }
+  defineHttpEndpoint(options) {
+    const existingHttpEndpoint = __privateGet(this, _registeredHttpEndpoints)[options.id];
+    if (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.`));
+    }
+    const endpoint = httpEndpoint(options);
+    __privateGet(this, _registeredHttpEndpoints)[endpoint.id] = endpoint;
+    return endpoint;
+  }
   attach(job) {
     __privateGet(this, _registeredJobs)[job.id] = job;
     job.trigger.attachToJob(this, job);
@@ -2156,6 +2912,9 @@ var TriggerClient = class {
   async sendEvent(event, options) {
     return __privateGet(this, _client2).sendEvent(event, options);
   }
+  async sendEvents(events, options) {
+    return __privateGet(this, _client2).sendEvents(events, options);
+  }
   async cancelEvent(eventId) {
     return __privateGet(this, _client2).cancelEvent(eventId);
   }
@@ -2186,6 +2945,12 @@ var TriggerClient = class {
   async getRunStatuses(runId) {
     return __privateGet(this, _client2).getRunStatuses(runId);
   }
+  async invokeJob(jobId, payload, options) {
+    return __privateGet(this, _client2).invokeJob(jobId, payload, options);
+  }
+  async createEphemeralEventDispatcher(payload) {
+    return __privateGet(this, _client2).createEphemeralEventDispatcher(payload);
+  }
   authorized(apiKey) {
     if (typeof apiKey !== "string") {
       return "missing-header";
@@ -2208,6 +2973,7 @@ _registeredHttpSourceHandlers = new WeakMap();
 _registeredDynamicTriggers = new WeakMap();
 _jobMetadataByDynamicTriggers = new WeakMap();
 _registeredSchedules = new WeakMap();
+_registeredHttpEndpoints = new WeakMap();
 _authResolvers = new WeakMap();
 _client2 = new WeakMap();
 _internalLogger = new WeakMap();
@@ -2241,7 +3007,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_core7.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info") : void 0,
+    jobLogger: __privateGet(this, _options4).ioLogLocalEnabled ? new import_core8.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info") : void 0,
     serverVersion: triggerVersion,
     timeOrigin,
     executionTimeout: body1.runChunkExecutionLimit
@@ -2255,11 +3021,23 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, timeOrigin, t
   }
   const ioWithConnections = createIOWithIntegrations(io, resolvedConnections.data, job1.options.integrations);
   try {
+    const parsedPayload = job1.trigger.event.parsePayload(body1.event.payload ?? {});
+    if (!context.run.isTest) {
+      const verified = await job1.trigger.verifyPayload(parsedPayload);
+      if (!verified.success) {
+        return {
+          status: "ERROR",
+          error: {
+            message: `Payload verification failed. ${verified.reason}`
+          }
+        };
+      }
+    }
     const output = await runLocalStorage.runWith({
       io,
       ctx: context
     }, () => {
-      return job1.options.run(job1.trigger.event.parsePayload(body1.event.payload ?? {}), ioWithConnections, context);
+      return job1.options.run(parsedPayload, ioWithConnections, context);
     });
     if (__privateGet(this, _options4).verbose) {
       __privateMethod(this, _logIOStats, logIOStats_fn).call(this, io.stats);
@@ -2272,96 +3050,126 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, timeOrigin, t
     if (__privateGet(this, _options4).verbose) {
       __privateMethod(this, _logIOStats, logIOStats_fn).call(this, io.stats);
     }
-    if (error instanceof AutoYieldExecutionError) {
-      return {
-        status: "AUTO_YIELD_EXECUTION",
-        location: error.location,
-        timeRemaining: error.timeRemaining,
-        timeElapsed: error.timeElapsed,
-        limit: body1.runChunkExecutionLimit
-      };
-    }
-    if (error instanceof AutoYieldWithCompletedTaskExecutionError) {
-      return {
-        status: "AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK",
-        id: error.id,
-        properties: error.properties,
-        output: error.output,
-        data: {
-          ...error.data,
-          limit: body1.runChunkExecutionLimit
-        }
-      };
-    }
-    if (error instanceof YieldExecutionError) {
-      return {
-        status: "YIELD_EXECUTION",
-        key: error.key
-      };
-    }
-    if (error instanceof ParsedPayloadSchemaError) {
+    if (error instanceof ResumeWithParallelTaskError) {
       return {
-        status: "INVALID_PAYLOAD",
-        errors: error.schemaErrors
-      };
-    }
-    if (error instanceof ResumeWithTaskError) {
-      return {
-        status: "RESUME_WITH_TASK",
-        task: error.task
-      };
-    }
-    if (error instanceof RetryWithTaskError) {
-      return {
-        status: "RETRY_WITH_TASK",
+        status: "RESUME_WITH_PARALLEL_TASK",
         task: error.task,
-        error: error.cause,
-        retryAt: error.retryAt
-      };
-    }
-    if (error instanceof CanceledWithTaskError) {
-      return {
-        status: "CANCELED",
-        task: error.task
+        childErrors: error.childErrors.map((childError) => {
+          return __privateMethod(this, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn).call(this, childError, body1);
+        })
       };
     }
-    if (error instanceof RetryWithTaskError) {
-      const errorWithStack2 = import_core7.ErrorWithStackSchema.safeParse(error.cause);
-      if (errorWithStack2.success) {
-        return {
-          status: "ERROR",
-          error: errorWithStack2.data,
-          task: error.task
-        };
+    return __privateMethod(this, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn).call(this, error, body1);
+  }
+}, "#executeJob");
+_convertErrorToExecutionResponse = new WeakSet();
+convertErrorToExecutionResponse_fn = /* @__PURE__ */ __name(function(error, body2) {
+  if (error instanceof AutoYieldExecutionError) {
+    return {
+      status: "AUTO_YIELD_EXECUTION",
+      location: error.location,
+      timeRemaining: error.timeRemaining,
+      timeElapsed: error.timeElapsed,
+      limit: body2.runChunkExecutionLimit
+    };
+  }
+  if (error instanceof AutoYieldWithCompletedTaskExecutionError) {
+    return {
+      status: "AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK",
+      id: error.id,
+      properties: error.properties,
+      output: error.output,
+      data: {
+        ...error.data,
+        limit: body2.runChunkExecutionLimit
       }
+    };
+  }
+  if (error instanceof YieldExecutionError) {
+    return {
+      status: "YIELD_EXECUTION",
+      key: error.key
+    };
+  }
+  if (error instanceof ParsedPayloadSchemaError) {
+    return {
+      status: "INVALID_PAYLOAD",
+      errors: error.schemaErrors
+    };
+  }
+  if (error instanceof ResumeWithTaskError) {
+    return {
+      status: "RESUME_WITH_TASK",
+      task: error.task
+    };
+  }
+  if (error instanceof RetryWithTaskError) {
+    return {
+      status: "RETRY_WITH_TASK",
+      task: error.task,
+      error: error.cause,
+      retryAt: error.retryAt
+    };
+  }
+  if (error instanceof CanceledWithTaskError) {
+    return {
+      status: "CANCELED",
+      task: error.task
+    };
+  }
+  if (error instanceof ErrorWithTask) {
+    const errorWithStack2 = import_core8.ErrorWithStackSchema.safeParse(error.cause.output);
+    if (errorWithStack2.success) {
       return {
         status: "ERROR",
-        error: {
-          message: "Unknown error"
-        },
-        task: error.task
+        error: errorWithStack2.data,
+        task: error.cause
       };
     }
-    const errorWithStack = import_core7.ErrorWithStackSchema.safeParse(error);
-    if (errorWithStack.success) {
+    return {
+      status: "ERROR",
+      error: {
+        message: JSON.stringify(error.cause.output)
+      },
+      task: error.cause
+    };
+  }
+  if (error instanceof RetryWithTaskError) {
+    const errorWithStack2 = import_core8.ErrorWithStackSchema.safeParse(error.cause);
+    if (errorWithStack2.success) {
       return {
         status: "ERROR",
-        error: errorWithStack.data
+        error: errorWithStack2.data,
+        task: error.task
       };
     }
-    const message = typeof error === "string" ? error : JSON.stringify(error);
     return {
       status: "ERROR",
       error: {
-        name: "Unknown error",
-        message
-      }
+        message: "Unknown error"
+      },
+      task: error.task
     };
   }
-}, "#executeJob");
+  const errorWithStack = import_core8.ErrorWithStackSchema.safeParse(error);
+  if (errorWithStack.success) {
+    return {
+      status: "ERROR",
+      error: errorWithStack.data
+    };
+  }
+  const message = typeof error === "string" ? error : JSON.stringify(error);
+  return {
+    status: "ERROR",
+    error: {
+      name: "Unknown error",
+      message
+    }
+  };
+}, "#convertErrorToExecutionResponse");
 _createRunContext = new WeakSet();
 createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
-  const { event, organization, environment, job, run, source } = execution;
+  const { event, organization, project, environment, job, run, source } = execution;
   return {
     event: {
       id: event.id,
@@ -2370,6 +3178,11 @@ createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
       timestamp: event.timestamp
     },
     organization,
+    project: project ?? {
+      id: "unknown",
+      name: "unknown",
+      slug: "unknown"
+    },
     environment,
     job,
     run,
@@ -2378,8 +3191,8 @@ createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
   };
 }, "#createRunContext");
 _createPreprocessRunContext = new WeakSet();
-createPreprocessRunContext_fn = /* @__PURE__ */ __name(function(body2) {
-  const { event, organization, environment, job, run, account } = body2;
+createPreprocessRunContext_fn = /* @__PURE__ */ __name(function(body3) {
+  const { event, organization, environment, job, run, account } = body3;
   return {
     event: {
       id: event.id,
@@ -2476,6 +3289,59 @@ handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourc
     metadata: results.metadata
   };
 }, "#handleHttpSourceRequest");
+_handleHttpEndpointRequestForResponse = new WeakSet();
+handleHttpEndpointRequestForResponse_fn = /* @__PURE__ */ __name(async function(data, sourceRequest1) {
+  __privateGet(this, _internalLogger).debug("Handling HTTP Endpoint request for response", {
+    data
+  });
+  const httpEndpoint2 = __privateGet(this, _registeredHttpEndpoints)[data.key];
+  if (!httpEndpoint2) {
+    __privateGet(this, _internalLogger).debug("No handler registered for HTTP Endpoint", {
+      data
+    });
+    return {
+      response: {
+        status: 200,
+        body: {
+          ok: true
+        }
+      }
+    };
+  }
+  const handledResponse = await httpEndpoint2.handleRequest(sourceRequest1);
+  if (!handledResponse) {
+    __privateGet(this, _internalLogger).debug("There's no HTTP Endpoint respondWith.handler()", {
+      data
+    });
+    return {
+      response: {
+        status: 200,
+        body: {
+          ok: true
+        }
+      }
+    };
+  }
+  let body;
+  try {
+    body = await handledResponse.text();
+  } catch (error) {
+    __privateGet(this, _internalLogger).error(`Error reading httpEndpoint ${httpEndpoint2.id} respondWith.handler Response`, {
+      error
+    });
+  }
+  const response = {
+    status: handledResponse.status,
+    headers: handledResponse.headers ? Object.fromEntries(handledResponse.headers.entries()) : void 0,
+    body
+  };
+  __privateGet(this, _internalLogger).info(`httpEndpoint ${httpEndpoint2.id} respondWith.handler response`, {
+    response
+  });
+  return {
+    response
+  };
+}, "#handleHttpEndpointRequestForResponse");
 _resolveConnections = new WeakSet();
 resolveConnections_fn = /* @__PURE__ */ __name(async function(ctx, integrations, connections) {
   if (!integrations) {
@@ -2633,7 +3499,7 @@ logIOStats_fn = /* @__PURE__ */ __name(function(stats) {
 _standardResponseHeaders = new WeakSet();
 standardResponseHeaders_fn = /* @__PURE__ */ __name(function(start) {
   return {
-    "Trigger-Version": import_core7.API_VERSIONS.LAZY_LOADED_CACHED_TASKS,
+    "Trigger-Version": import_core8.API_VERSIONS.LAZY_LOADED_CACHED_TASKS,
     "Trigger-SDK-Version": version,
     "X-Trigger-Request-Timing": `dur=${performance.now() - start / 1e3}`
   };
@@ -2663,7 +3529,7 @@ function deepMergeOptions(obj1, obj2) {
 __name(deepMergeOptions, "deepMergeOptions");
 
 // src/triggers/externalSource.ts
-var import_core8 = require("@trigger.dev/core");
+var import_core9 = require("@trigger.dev/core");
 var ExternalSource = class {
   constructor(channel, options) {
     this.options = options;
@@ -2737,7 +3603,7 @@ var ExternalSourceTrigger = class {
       title: "External Source",
       rule: {
         event: this.event.name,
-        payload: (0, import_core8.deepMergeFilters)(this.options.source.filter(this.options.params, this.options.options), this.event.filter ?? {}, this.options.params.filter ?? {}),
+        payload: (0, import_core9.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)
@@ -2755,6 +3621,11 @@ var ExternalSourceTrigger = class {
   get preprocessRuns() {
     return true;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
 };
 __name(ExternalSourceTrigger, "ExternalSourceTrigger");
 function omit(obj, key) {
@@ -2772,7 +3643,7 @@ function omit(obj, key) {
 __name(omit, "omit");
 
 // src/triggers/notifications.ts
-var import_core9 = require("@trigger.dev/core");
+var import_core10 = require("@trigger.dev/core");
 function missingConnectionNotification(integrations) {
   return new MissingConnectionNotification({
     integrations
@@ -2791,11 +3662,11 @@ var MissingConnectionNotification = class {
   }
   get event() {
     return {
-      name: import_core9.MISSING_CONNECTION_NOTIFICATION,
+      name: import_core10.MISSING_CONNECTION_NOTIFICATION,
       title: "Missing Connection Notification",
       source: "trigger.dev",
       icon: "connection-alert",
-      parsePayload: import_core9.MissingConnectionNotificationPayloadSchema.parse,
+      parsePayload: import_core10.MissingConnectionNotificationPayloadSchema.parse,
       properties: [
         {
           label: "Integrations",
@@ -2809,6 +3680,11 @@ var MissingConnectionNotification = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "static",
@@ -2832,11 +3708,11 @@ var MissingConnectionResolvedNotification = class {
   }
   get event() {
     return {
-      name: import_core9.MISSING_CONNECTION_RESOLVED_NOTIFICATION,
+      name: import_core10.MISSING_CONNECTION_RESOLVED_NOTIFICATION,
       title: "Missing Connection Resolved Notification",
       source: "trigger.dev",
       icon: "connection-alert",
-      parsePayload: import_core9.MissingConnectionResolvedNotificationPayloadSchema.parse,
+      parsePayload: import_core10.MissingConnectionResolvedNotificationPayloadSchema.parse,
       properties: [
         {
           label: "Integrations",
@@ -2850,6 +3726,11 @@ var MissingConnectionResolvedNotification = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "static",
@@ -2868,6 +3749,106 @@ var MissingConnectionResolvedNotification = class {
 };
 __name(MissingConnectionResolvedNotification, "MissingConnectionResolvedNotification");
 
+// src/triggers/invokeTrigger.ts
+var _options5;
+var InvokeTrigger = class {
+  constructor(options) {
+    __privateAdd(this, _options5, void 0);
+    __privateSet(this, _options5, options);
+  }
+  toJSON() {
+    return {
+      type: "invoke"
+    };
+  }
+  get event() {
+    return {
+      name: "invoke",
+      title: "Manual Invoke",
+      source: "trigger.dev",
+      examples: __privateGet(this, _options5).examples ?? [],
+      icon: "trigger",
+      parsePayload: (rawPayload) => {
+        if (__privateGet(this, _options5).schema) {
+          const results = __privateGet(this, _options5).schema.safeParse(rawPayload);
+          if (!results.success) {
+            throw new ParsedPayloadSchemaError(formatSchemaErrors(results.error.issues));
+          }
+          return results.data;
+        }
+        return rawPayload;
+      },
+      parseInvokePayload: (rawPayload) => {
+        if (__privateGet(this, _options5).schema) {
+          const results = __privateGet(this, _options5).schema.safeParse(rawPayload);
+          if (!results.success) {
+            throw new ParsedPayloadSchemaError(formatSchemaErrors(results.error.issues));
+          }
+          return results.data;
+        }
+        return rawPayload;
+      }
+    };
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  async verifyPayload() {
+    return {
+      success: true
+    };
+  }
+};
+__name(InvokeTrigger, "InvokeTrigger");
+_options5 = new WeakMap();
+function invokeTrigger(options) {
+  return new InvokeTrigger(options ?? {});
+}
+__name(invokeTrigger, "invokeTrigger");
+
+// src/security.ts
+var import_crypto = __toESM(require("crypto"));
+async function verifyRequestSignature({ request, headerName, secret, algorithm }) {
+  if (!secret) {
+    return {
+      success: false,
+      reason: "Missing secret \u2013 you've probably not set an environment variable."
+    };
+  }
+  const headerValue = request.headers.get(headerName);
+  if (!headerValue) {
+    return {
+      success: false,
+      reason: "Missing header"
+    };
+  }
+  switch (algorithm) {
+    case "sha256":
+      const success = verifyHmacSha256(headerValue, secret, await request.text());
+      if (success) {
+        return {
+          success
+        };
+      } else {
+        return {
+          success: false,
+          reason: "Failed sha256 verification"
+        };
+      }
+    default:
+      throw new Error(`Unsupported algorithm: ${algorithm}`);
+  }
+}
+__name(verifyRequestSignature, "verifyRequestSignature");
+function verifyHmacSha256(headerValue, secret, body) {
+  const bodyDigest = import_crypto.default.createHmac("sha256", secret).update(body).digest("hex");
+  const signature = headerValue?.replace("sha256=", "") ?? "";
+  return signature === bodyDigest;
+}
+__name(verifyHmacSha256, "verifyHmacSha256");
+
 // src/index.ts
 function redactString(strings, ...interpolations) {
   return {
@@ -2882,12 +3863,15 @@ __name(redactString, "redactString");
   CronTrigger,
   DynamicSchedule,
   DynamicTrigger,
+  EventSpecificationExampleSchema,
   EventTrigger,
   ExternalSource,
   ExternalSourceTrigger,
   IO,
   IOLogger,
   IntervalTrigger,
+  InvokeTrigger,
+  JSONOutputSerializer,
   Job,
   MissingConnectionNotification,
   MissingConnectionResolvedNotification,
@@ -2895,11 +3879,15 @@ __name(redactString, "redactString");
   cronTrigger,
   eventTrigger,
   intervalTrigger,
+  invokeTrigger,
   isTriggerError,
   missingConnectionNotification,
   missingConnectionResolvedNotification,
   omit,
   redactString,
-  retry
+  retry,
+  verifyHmacSha256,
+  verifyRequestSignature,
+  waitForEventSchema
 });
 //# sourceMappingURL=index.js.map