@trigger.dev/sdk 0.0.0-cliframeworks-20230929110149 → 0.0.0-cross-runtime-20231201105801

package/dist/index.js

@@ -5,6 +5,7 @@ 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)
@@ -23,6 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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;
+};
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -52,25 +57,35 @@ __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
+  retry: () => retry,
+  slugifyId: () => slugifyId,
+  verifyHmacSha256: () => verifyHmacSha256,
+  verifyRequestSignature: () => verifyRequestSignature,
+  waitForEventSchema: () => waitForEventSchema
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -82,6 +97,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 {
@@ -133,9 +166,125 @@ var Job = class {
       startPosition: "latest",
       enabled: this.enabled,
       preprocessRuns: this.trigger.preprocessRuns,
-      internal
+      internal,
+      concurrencyLimit: typeof this.options.concurrencyLimit === "number" ? this.options.concurrencyLimit : typeof this.options.concurrencyLimit === "object" ? {
+        id: this.options.concurrencyLimit.id,
+        limit: this.options.concurrencyLimit.limit
+      } : void 0
     };
   }
+  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();
@@ -146,518 +295,679 @@ 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_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");
+
+// src/errors.ts
+var ResumeWithTaskError = class {
+  constructor(task) {
+    this.task = task;
+  }
+};
+__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;
+    this.task = task;
+    this.retryAt = retryAt;
+  }
+};
+__name(RetryWithTaskError, "RetryWithTaskError");
+var CanceledWithTaskError = class {
+  constructor(task) {
+    this.task = task;
+  }
+};
+__name(CanceledWithTaskError, "CanceledWithTaskError");
+var YieldExecutionError = class {
+  constructor(key) {
+    this.key = key;
+  }
+};
+__name(YieldExecutionError, "YieldExecutionError");
+var AutoYieldExecutionError = class {
+  constructor(location, timeRemaining, timeElapsed) {
+    this.location = location;
+    this.timeRemaining = timeRemaining;
+    this.timeElapsed = timeElapsed;
+  }
+};
+__name(AutoYieldExecutionError, "AutoYieldExecutionError");
+var AutoYieldWithCompletedTaskExecutionError = class {
+  constructor(id, properties, data, output) {
+    this.id = id;
+    this.properties = properties;
+    this.data = data;
+    this.output = output;
+  }
+};
+__name(AutoYieldWithCompletedTaskExecutionError, "AutoYieldWithCompletedTaskExecutionError");
+var ParsedPayloadSchemaError = class {
+  constructor(schemaErrors) {
+    this.schemaErrors = schemaErrors;
+  }
+};
+__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 || err instanceof ResumeWithParallelTaskError;
+}
+__name(isTriggerError, "isTriggerError");
+var ErrorWithTask = class extends Error {
+  constructor(cause, message) {
+    super(message);
+    this.cause = cause;
+  }
+};
+__name(ErrorWithTask, "ErrorWithTask");
+
+// src/retry.ts
 var import_core = require("@trigger.dev/core");
-var import_node_fetch = __toESM(require("node-fetch"));
-var import_zod = require("zod");
-var _apiUrl, _options, _logger, _apiKey, apiKey_fn;
-var ApiClient = class {
-  constructor(options) {
-    __privateAdd(this, _apiKey);
-    __privateAdd(this, _apiUrl, void 0);
-    __privateAdd(this, _options, void 0);
-    __privateAdd(this, _logger, 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_core.Logger("trigger.dev", __privateGet(this, _options).logLevel));
+var retry = {
+  standardBackoff: {
+    limit: 8,
+    factor: 1.8,
+    minTimeoutInMs: 500,
+    maxTimeoutInMs: 3e4,
+    randomize: true
+  },
+  exponentialBackoff: {
+    limit: 8,
+    factor: 2,
+    minTimeoutInMs: 1e3,
+    maxTimeoutInMs: 3e4,
+    randomize: true
   }
-  async registerEndpoint(options) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Registering endpoint", {
-      url: options.url,
-      name: options.name
-    });
-    const response = await (0, import_node_fetch.default)(`${__privateGet(this, _apiUrl)}/api/v1/endpoints`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        url: options.url,
-        name: options.name
-      })
-    });
-    if (response.status >= 400 && response.status < 500) {
-      const body = await response.json();
-      throw new Error(body.error);
+};
+
+// src/status.ts
+var TriggerStatus = class {
+  constructor(id, io) {
+    this.id = id;
+    this.io = io;
+  }
+  async update(key, status) {
+    const properties = [];
+    if (status.label) {
+      properties.push({
+        label: "Label",
+        text: status.label
+      });
     }
-    if (response.status !== 200) {
-      throw new Error(`Failed to register entry point, got status code ${response.status}`);
+    if (status.state) {
+      properties.push({
+        label: "State",
+        text: status.state
+      });
     }
-    return await response.json();
-  }
-  async runTask(runId, task) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Running Task", {
-      task
-    });
-    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`,
-        "Idempotency-Key": task.idempotencyKey
+    return await this.io.runTask(key, async (task) => {
+      return await this.io.triggerClient.updateStatus(this.io.runId, this.id, status);
+    }, {
+      name: status.label ?? `Status update`,
+      icon: "bell",
+      params: {
+        ...status
       },
-      body: JSON.stringify(task)
+      properties
     });
   }
-  async completeTask(runId, id, task) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Complete Task", {
-      task
-    });
-    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+};
+__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()
+});
+function waitForEventSchema(schema) {
+  return import_zod.z.object({
+    id: import_zod.z.string(),
+    name: import_zod.z.string(),
+    source: import_zod.z.string(),
+    payload: schema,
+    timestamp: import_zod.z.coerce.date(),
+    context: import_zod.z.any().optional(),
+    accountId: import_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 {
+  constructor(apiClient, type = null, namespace = "") {
+    __privateAdd(this, _namespacedKey);
+    __privateAdd(this, _sharedProperties);
+    this.apiClient = apiClient;
+    this.type = type;
+    this.namespace = namespace;
+  }
+  async delete(param1, param2) {
+    const runStore = runLocalStorage.getStore();
+    if (!runStore) {
+      if (typeof param1 !== "string") {
+        throw new Error("Please use the store without a cacheKey when accessing from outside a run.");
+      }
+      return await this.apiClient.store.delete(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param1));
+    }
+    const { io } = runStore;
+    if (!param2) {
+      throw new Error("Please provide a non-empty key when accessing the store from inside a run.");
+    }
+    return await io.runTask(param1, async (task) => {
+      return await this.apiClient.store.delete(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param2));
+    }, {
+      name: "Key-Value Store Delete",
+      icon: "database-minus",
+      params: {
+        key: param2
       },
-      body: JSON.stringify(task)
+      properties: __privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
+      style: {
+        style: "minimal"
+      }
     });
   }
-  async failTask(runId, id, body) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Fail Task", {
-      id,
-      runId,
-      body
-    });
-    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/fail`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+  async get(param1, param2) {
+    const runStore = runLocalStorage.getStore();
+    if (!runStore) {
+      if (typeof param1 !== "string") {
+        throw new Error("Please use the store without a cacheKey when accessing from outside a run.");
+      }
+      return await this.apiClient.store.get(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param1));
+    }
+    const { io } = runStore;
+    if (!param2) {
+      throw new Error("Please provide a non-empty key when accessing the store from inside a run.");
+    }
+    return await io.runTask(param1, async (task) => {
+      return await this.apiClient.store.get(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param2));
+    }, {
+      name: "Key-Value Store Get",
+      icon: "database-export",
+      params: {
+        key: param2
       },
-      body: JSON.stringify(body)
+      properties: __privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
+      style: {
+        style: "minimal"
+      }
     });
   }
-  async sendEvent(event, options = {}) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Sending event", {
-      event
-    });
-    return await zodfetch(import_core.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+  async has(param1, param2) {
+    const runStore = runLocalStorage.getStore();
+    if (!runStore) {
+      if (typeof param1 !== "string") {
+        throw new Error("Please use the store without a cacheKey when accessing from outside a run.");
+      }
+      return await this.apiClient.store.has(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param1));
+    }
+    const { io } = runStore;
+    if (!param2) {
+      throw new Error("Please provide a non-empty key when accessing the store from inside a run.");
+    }
+    return await io.runTask(param1, async (task) => {
+      return await this.apiClient.store.has(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param2));
+    }, {
+      name: "Key-Value Store Has",
+      icon: "database-search",
+      params: {
+        key: param2
       },
-      body: JSON.stringify({
-        event,
-        options
-      })
-    });
-  }
-  async cancelEvent(eventId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Cancelling event", {
-      eventId
-    });
-    return await zodfetch(import_core.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+      properties: __privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
+      style: {
+        style: "minimal"
       }
     });
   }
-  async updateStatus(runId, id, status) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Update status", {
-      id,
-      status
-    });
-    return await zodfetch(import_core.JobRunStatusRecordSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses/${id}`, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+  async set(param1, param2, param3) {
+    const runStore = runLocalStorage.getStore();
+    if (!runStore) {
+      if (typeof param1 !== "string") {
+        throw new Error("Please use the store without a cacheKey when accessing from outside a run.");
+      }
+      return await this.apiClient.store.set(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param1), param2);
+    }
+    const { io } = runStore;
+    if (!param2 || typeof param2 !== "string") {
+      throw new Error("Please provide a non-empty key when accessing the store from inside a run.");
+    }
+    const value = param3;
+    return await io.runTask(param1, async (task) => {
+      return await this.apiClient.store.set(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param2), value);
+    }, {
+      name: "Key-Value Store Set",
+      icon: "database-plus",
+      params: {
+        key: param2,
+        value
       },
-      body: JSON.stringify(status)
+      properties: [
+        ...__privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
+        ...typeof value !== "object" || value === null ? [
+          {
+            label: "value",
+            text: String(value) ?? "undefined"
+          }
+        ] : []
+      ],
+      style: {
+        style: "minimal"
+      }
     });
   }
-  async updateSource(client, key, source) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("activating http source", {
-      source
-    });
-    const response = await zodfetch(import_core.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v2/${client}/sources/${key}`, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(source)
-    });
-    return response;
+};
+__name(KeyValueStore, "KeyValueStore");
+_namespacedKey = new WeakSet();
+namespacedKey_fn = /* @__PURE__ */ __name(function(key) {
+  const parts = [];
+  if (this.type) {
+    parts.push(this.type);
+  }
+  if (this.namespace) {
+    parts.push(this.namespace);
+  }
+  parts.push(key);
+  return parts.join(":");
+}, "#namespacedKey");
+_sharedProperties = new WeakSet();
+sharedProperties_fn = /* @__PURE__ */ __name(function(key1) {
+  return [
+    {
+      label: "namespace",
+      text: this.type ?? "env"
+    },
+    {
+      label: "key",
+      text: key1
+    }
+  ];
+}, "#sharedProperties");
+
+// src/io.ts
+var JSONOutputSerializer = class {
+  serialize(value) {
+    return JSON.stringify(value);
   }
-  async registerTrigger(client, id, key, payload) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("registering trigger", {
-      id,
-      payload
-    });
-    const response = await zodfetch(import_core.RegisterSourceEventSchemaV2, `${__privateGet(this, _apiUrl)}/api/v2/${client}/triggers/${id}/registrations/${key}`, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(payload)
-    });
-    return response;
+  deserialize(value) {
+    return value ? JSON.parse(value) : void 0;
   }
-  async registerSchedule(client, id, key, payload) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("registering schedule", {
-      id,
-      payload
-    });
-    const response = await zodfetch(import_core.RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        id: key,
-        ...payload
-      })
-    });
-    return response;
+};
+__name(JSONOutputSerializer, "JSONOutputSerializer");
+var _addToCachedTasks, addToCachedTasks_fn, _detectAutoYield, detectAutoYield_fn, _forceYield, forceYield_fn, _getTimeElapsed, getTimeElapsed_fn, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn;
+var IO = class {
+  constructor(options) {
+    __privateAdd(this, _addToCachedTasks);
+    __privateAdd(this, _detectAutoYield);
+    __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._jobId = options.jobId;
+    this._apiClient = options.apiClient;
+    this._triggerClient = options.client;
+    this._logger = options.logger ?? new import_core2.Logger("trigger.dev", options.logLevel);
+    this._cachedTasks = /* @__PURE__ */ new Map();
+    this._jobLogger = options.jobLogger;
+    this._jobLogLevel = options.jobLogLevel;
+    this._timeOrigin = options.timeOrigin;
+    this._executionTimeout = options.executionTimeout;
+    this._envStore = new KeyValueStore(options.apiClient);
+    this._jobStore = new KeyValueStore(options.apiClient, "job", options.jobId);
+    this._runStore = new KeyValueStore(options.apiClient, "run", options.id);
+    this._stats = {
+      initialCachedTasks: 0,
+      lazyLoadedCachedTasks: 0,
+      executedTasks: 0,
+      cachedTaskHits: 0,
+      cachedTaskMisses: 0,
+      noopCachedTaskHits: 0,
+      noopCachedTaskMisses: 0
+    };
+    if (options.cachedTasks) {
+      options.cachedTasks.forEach((task) => {
+        this._cachedTasks.set(task.idempotencyKey, task);
+      });
+      this._stats.initialCachedTasks = options.cachedTasks.length;
+    }
+    this._taskStorage = new import_node_async_hooks2.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._cachedTasksCursor = options.cachedTasksCursor;
+    this._serverVersion = options.serverVersion ?? "unversioned";
   }
-  async unregisterSchedule(client, id, key) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("unregistering schedule", {
-      id
-    });
-    const response = await zodfetch(import_zod.z.object({
-      ok: import_zod.z.boolean()
-    }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+  get stats() {
+    return this._stats;
+  }
+  get runId() {
+    return this._id;
+  }
+  get triggerClient() {
+    return this._triggerClient;
+  }
+  get logger() {
+    return new IOLogger(async (level, message, data) => {
+      let logLevel = "info";
+      if (import_core2.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
+        await this.runTask([
+          message,
+          level
+        ], async (task) => {
+          switch (level) {
+            case "LOG": {
+              this._jobLogger?.log(message, data);
+              logLevel = "log";
+              break;
+            }
+            case "DEBUG": {
+              this._jobLogger?.debug(message, data);
+              logLevel = "debug";
+              break;
+            }
+            case "INFO": {
+              this._jobLogger?.info(message, data);
+              logLevel = "info";
+              break;
+            }
+            case "WARN": {
+              this._jobLogger?.warn(message, data);
+              logLevel = "warn";
+              break;
+            }
+            case "ERROR": {
+              this._jobLogger?.error(message, data);
+              logLevel = "error";
+              break;
+            }
+          }
+        }, {
+          name: "log",
+          icon: "log",
+          description: message,
+          params: data,
+          properties: [
+            {
+              label: "Level",
+              text: level
+            }
+          ],
+          style: {
+            style: "minimal",
+            variant: level.toLowerCase()
+          },
+          noop: true
+        });
       }
     });
-    return response;
   }
-  async getAuth(client, id) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("getting auth", {
-      id
-    });
-    const response = await zodfetch(import_core.ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
-      method: "GET",
-      headers: {
-        Accept: "application/json",
-        Authorization: `Bearer ${apiKey}`
+  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;
     }, {
-      optional: true
-    });
-    return response;
-  }
-  async getEvent(eventId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Getting Event", {
-      eventId
-    });
-    return await zodfetch(import_core.GetEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
+      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 getRun(runId, options) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Getting Run", {
-      runId
-    });
-    return await zodfetch(import_core.GetRunSchema, (0, import_core.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}`, options), {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
+  async wait(cacheKey, seconds) {
+    return await this.runTask(cacheKey, async (task) => {
+    }, {
+      name: "wait",
+      icon: "clock",
+      params: {
+        seconds
+      },
+      noop: true,
+      delayUntil: new Date(Date.now() + seconds * 1e3),
+      style: {
+        style: "minimal"
       }
     });
   }
-  async getRunStatuses(runId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Getting Run statuses", {
-      runId
-    });
-    return await zodfetch(import_core.GetRunStatusesSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
+  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_zod2.z.any()).parse(output);
       }
     });
   }
-  async getRuns(jobSlug, options) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Getting Runs", {
-      jobSlug
-    });
-    return await zodfetch(import_core.GetRunsSchema, (0, import_core.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobSlug}/runs`, options), {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
+  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`
+        }
+      ]
     });
   }
-};
-__name(ApiClient, "ApiClient");
-_apiUrl = new WeakMap();
-_options = new WeakMap();
-_logger = new WeakMap();
-_apiKey = new WeakSet();
-apiKey_fn = /* @__PURE__ */ __name(async function() {
-  const apiKey = getApiKey(__privateGet(this, _options).apiKey);
-  if (apiKey.status === "invalid") {
-    throw new Error("Invalid API key");
-  } else if (apiKey.status === "missing") {
-    throw new Error("Missing API key");
-  }
-  return apiKey.apiKey;
-}, "#apiKey");
-function getApiKey(key) {
-  const apiKey = key ?? process.env.TRIGGER_API_KEY;
-  if (!apiKey) {
-    return {
-      status: "missing"
-    };
-  }
-  const isValid = apiKey.match(/^tr_[a-z]+_[a-zA-Z0-9]+$/);
-  if (!isValid) {
-    return {
-      status: "invalid",
-      apiKey
-    };
-  }
-  return {
-    status: "valid",
-    apiKey
-  };
-}
-__name(getApiKey, "getApiKey");
-async function zodfetch(schema, url, requestInit, options) {
-  const response = await (0, import_node_fetch.default)(url, requestInit);
-  if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
-    return;
-  }
-  if (response.status >= 400 && response.status < 500) {
-    const body = await response.json();
-    throw new Error(body.error);
-  }
-  if (response.status !== 200) {
-    throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
-  }
-  const jsonBody = await response.json();
-  return schema.parse(jsonBody);
-}
-__name(zodfetch, "zodfetch");
-
-// src/errors.ts
-var ResumeWithTaskError = class {
-  constructor(task) {
-    this.task = task;
-  }
-};
-__name(ResumeWithTaskError, "ResumeWithTaskError");
-var RetryWithTaskError = class {
-  constructor(cause, task, retryAt) {
-    this.cause = cause;
-    this.task = task;
-    this.retryAt = retryAt;
-  }
-};
-__name(RetryWithTaskError, "RetryWithTaskError");
-var CanceledWithTaskError = class {
-  constructor(task) {
-    this.task = task;
-  }
-};
-__name(CanceledWithTaskError, "CanceledWithTaskError");
-var ParsedPayloadSchemaError = class {
-  constructor(schemaErrors) {
-    this.schemaErrors = schemaErrors;
-  }
-};
-__name(ParsedPayloadSchemaError, "ParsedPayloadSchemaError");
-function isTriggerError(err) {
-  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError;
-}
-__name(isTriggerError, "isTriggerError");
-
-// src/io.ts
-var import_core3 = require("@trigger.dev/core");
-var import_node_async_hooks = require("async_hooks");
-var import_node_crypto = require("crypto");
-
-// src/retry.ts
-var import_core2 = require("@trigger.dev/core");
-var retry = {
-  standardBackoff: {
-    limit: 8,
-    factor: 1.8,
-    minTimeoutInMs: 500,
-    maxTimeoutInMs: 3e4,
-    randomize: true
-  }
-};
-
-// src/status.ts
-var TriggerStatus = class {
-  constructor(id, io) {
-    this.id = id;
-    this.io = io;
+  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 update(key, status) {
-    const properties = [];
-    if (status.label) {
-      properties.push({
-        label: "Label",
-        text: status.label
-      });
-    }
-    if (status.state) {
-      properties.push({
-        label: "State",
-        text: status.state
-      });
-    }
-    return await this.io.runTask(key, async (task) => {
-      return await this.io.triggerClient.updateStatus(this.io.runId, this.id, status);
+  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: status.label ?? `Status update`,
-      icon: "bell",
+      name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
       params: {
-        ...status
+        url,
+        requestInit,
+        retry: options?.retry,
+        timeout: options?.timeout
       },
-      properties
-    });
-  }
-};
-__name(TriggerStatus, "TriggerStatus");
-
-// src/io.ts
-var _addToCachedTasks, addToCachedTasks_fn;
-var IO = class {
-  constructor(options) {
-    __privateAdd(this, _addToCachedTasks);
-    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._cachedTasks = /* @__PURE__ */ new Map();
-    this._jobLogger = options.jobLogger;
-    this._jobLogLevel = options.jobLogLevel;
-    if (options.cachedTasks) {
-      options.cachedTasks.forEach((task) => {
-        this._cachedTasks.set(task.idempotencyKey, task);
-      });
-    }
-    this._taskStorage = new import_node_async_hooks.AsyncLocalStorage();
-    this._context = options.context;
-  }
-  get runId() {
-    return this._id;
-  }
-  get triggerClient() {
-    return this._triggerClient;
-  }
-  get logger() {
-    return new IOLogger(async (level, message, data) => {
-      let logLevel = "info";
-      switch (level) {
-        case "LOG": {
-          this._jobLogger?.log(message, data);
-          logLevel = "log";
-          break;
-        }
-        case "DEBUG": {
-          this._jobLogger?.debug(message, data);
-          logLevel = "debug";
-          break;
-        }
-        case "INFO": {
-          this._jobLogger?.info(message, data);
-          logLevel = "info";
-          break;
-        }
-        case "WARN": {
-          this._jobLogger?.warn(message, data);
-          logLevel = "warn";
-          break;
-        }
-        case "ERROR": {
-          this._jobLogger?.error(message, data);
-          logLevel = "error";
-          break;
-        }
-      }
-      if (import_core3.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
-        await this.runTask([
-          message,
-          level
-        ], async (task) => {
-        }, {
-          name: "log",
-          icon: "log",
-          description: message,
-          params: data,
-          properties: [
-            {
-              label: "Level",
-              text: level
-            }
-          ],
-          style: {
-            style: "minimal",
-            variant: level.toLowerCase()
-          },
-          noop: true
-        });
+      operation: "fetch",
+      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 wait(key, seconds) {
-    return await this.runTask(key, async (task) => {
+  async backgroundPoll(cacheKey, params) {
+    const urlObject = new URL(params.url);
+    return await this.runTask(cacheKey, async (task) => {
+      return task.output;
     }, {
-      name: "wait",
-      icon: "clock",
-      params: {
-        seconds
-      },
-      noop: true,
-      delayUntil: new Date(Date.now() + seconds * 1e3),
-      style: {
-        style: "minimal"
+      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 createStatus(key, initialStatus) {
-    const id = typeof key === "string" ? key : key.join("-");
-    const status = new TriggerStatus(id, this);
-    await status.update(key, initialStatus);
-    return status;
-  }
-  async backgroundFetch(key, url, requestInit, retry2) {
+  async backgroundFetchResponse(cacheKey, url, requestInit, options) {
     const urlObject = new URL(url);
-    return await this.runTask(key, async (task) => {
+    return await this.runTask(cacheKey, async (task) => {
       return task.output;
     }, {
-      name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
+      name: `fetch response ${urlObject.hostname}${urlObject.pathname}`,
       params: {
         url,
         requestInit,
-        retry: retry2
+        retry: options?.retry,
+        timeout: options?.timeout
       },
-      operation: "fetch",
+      operation: "fetch-response",
       icon: "background",
       noop: false,
       properties: [
@@ -673,19 +983,29 @@ var IO = class {
         {
           label: "background",
           text: "true"
-        }
-      ]
+        },
+        ...options?.timeout ? [
+          {
+            label: "timeout",
+            text: `${options.timeout.durationInMs}ms`
+          }
+        ] : []
+      ],
+      retry: {
+        limit: 0
+      }
     });
   }
-  async sendEvent(key, event, options) {
-    return await this.runTask(key, async (task) => {
+  async sendEvent(cacheKey, event, options) {
+    return await this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.sendEvent(event, options);
     }, {
-      name: "sendEvent",
+      name: "Send Event",
       params: {
         event,
         options
       },
+      icon: "send",
       properties: [
         {
           label: "name",
@@ -696,28 +1016,48 @@ var IO = class {
             label: "ID",
             text: event.id
           }
-        ] : []
+        ] : [],
+        ...sendEventOptionsProperties(options)
       ]
     });
   }
-  async getEvent(key, id) {
-    return await this.runTask(key, async (task) => {
-      return await this._triggerClient.getEvent(id);
+  async sendEvents(cacheKey, events, options) {
+    return await this.runTask(cacheKey, async (task) => {
+      return await this._triggerClient.sendEvents(events, options);
     }, {
-      name: "getEvent",
+      name: "Send Multiple Events",
       params: {
-        id
+        events,
+        options
       },
+      icon: "send",
       properties: [
         {
-          label: "id",
+          label: "Total Events",
+          text: String(events.length)
+        },
+        ...sendEventOptionsProperties(options)
+      ]
+    });
+  }
+  async getEvent(cacheKey, id) {
+    return await this.runTask(cacheKey, async (task) => {
+      return await this._triggerClient.getEvent(id);
+    }, {
+      name: "getEvent",
+      params: {
+        id
+      },
+      properties: [
+        {
+          label: "id",
           text: id
         }
       ]
     });
   }
-  async cancelEvent(key, eventId) {
-    return await this.runTask(key, async (task) => {
+  async cancelEvent(cacheKey, eventId) {
+    return await this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.cancelEvent(eventId);
     }, {
       name: "cancelEvent",
@@ -732,8 +1072,8 @@ var IO = class {
       ]
     });
   }
-  async updateSource(key, options) {
-    return this.runTask(key, async (task) => {
+  async updateSource(cacheKey, options) {
+    return this.runTask(cacheKey, async (task) => {
       return await this._apiClient.updateSource(this._triggerClient.id, options.key, options);
     }, {
       name: "Update Source",
@@ -752,8 +1092,23 @@ var IO = class {
       }
     });
   }
-  async registerInterval(key, dynamicSchedule, id, options) {
-    return await this.runTask(key, async (task) => {
+  async updateWebhook(cacheKey, options) {
+    return this.runTask(cacheKey, async (task) => {
+      return await this._apiClient.updateWebhook(options.key, options);
+    }, {
+      name: "Update Webhook Source",
+      icon: "refresh",
+      properties: [
+        {
+          label: "key",
+          text: options.key
+        }
+      ],
+      params: options
+    });
+  }
+  async registerInterval(cacheKey, dynamicSchedule, id, options) {
+    return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.register(id, {
         type: "interval",
         options
@@ -777,8 +1132,8 @@ var IO = class {
       params: options
     });
   }
-  async unregisterInterval(key, dynamicSchedule, id) {
-    return await this.runTask(key, async (task) => {
+  async unregisterInterval(cacheKey, dynamicSchedule, id) {
+    return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.unregister(id);
     }, {
       name: "unregister-interval",
@@ -794,8 +1149,8 @@ var IO = class {
       ]
     });
   }
-  async registerCron(key, dynamicSchedule, id, options) {
-    return await this.runTask(key, async (task) => {
+  async registerCron(cacheKey, dynamicSchedule, id, options) {
+    return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.register(id, {
         type: "cron",
         options
@@ -819,8 +1174,8 @@ var IO = class {
       params: options
     });
   }
-  async unregisterCron(key, dynamicSchedule, id) {
-    return await this.runTask(key, async (task) => {
+  async unregisterCron(cacheKey, dynamicSchedule, id) {
+    return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.unregister(id);
     }, {
       name: "unregister-cron",
@@ -836,8 +1191,8 @@ var IO = class {
       ]
     });
   }
-  async registerTrigger(key, trigger, id, params) {
-    return await this.runTask(key, async (task) => {
+  async registerTrigger(cacheKey, trigger, id, params) {
+    return await this.runTask(cacheKey, async (task) => {
       const registration = await this.runTask("register-source", async (subtask1) => {
         return trigger.register(id, params);
       }, {
@@ -862,45 +1217,107 @@ var IO = class {
       params
     });
   }
-  async getAuth(key, clientId) {
+  async getAuth(cacheKey, clientId) {
     if (!clientId) {
       return;
     }
-    return this.runTask(key, async (task) => {
+    return this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.getAuth(clientId);
     }, {
       name: "get-auth"
     });
   }
-  async runTask(key, callback, options, onError) {
+  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;
     if (parentId) {
       this._logger.debug("Using parent task", {
         parentId,
-        key,
+        cacheKey,
         options
       });
     }
     const idempotencyKey = await generateIdempotencyKey([
       this._id,
       parentId ?? "",
-      key
+      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,
-        cachedTask
+        idempotencyKey
       });
-      return cachedTask.output;
+      this._stats.cachedTaskHits++;
+      return options?.parseOutput ? options.parseOutput(cachedTask.output) : cachedTask.output;
+    }
+    if (options?.noop && this._noopTasksBloomFilter) {
+      if (this._noopTasksBloomFilter.test(idempotencyKey)) {
+        this._logger.debug("task idempotency key exists in noopTasksBloomFilter", {
+          idempotencyKey
+        });
+        this._stats.noopCachedTaskHits++;
+        return {};
+      }
     }
-    const task = await this._apiClient.runTask(this._id, {
+    const runOptions = {
+      ...options ?? {},
+      parseOutput: void 0
+    };
+    const response = await this._apiClient.runTask(this._id, {
       idempotencyKey,
-      displayKey: typeof key === "string" ? key : key.join("."),
+      displayKey: typeof cacheKey === "string" ? cacheKey : void 0,
       noop: false,
-      ...options ?? {},
+      ...runOptions ?? {},
       parentId
+    }, {
+      cachedTasksCursor: this._cachedTasksCursor
     });
+    const task = response.version === import_core2.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) {
+      this._cachedTasksCursor = response.body.cachedTasks?.cursor;
+      for (const cachedTask2 of response.body.cachedTasks?.tasks ?? []) {
+        if (!this._cachedTasks.has(cachedTask2.idempotencyKey)) {
+          this._cachedTasks.set(cachedTask2.idempotencyKey, cachedTask2);
+          this._logger.debug("Injecting lazy loaded task into task cache", {
+            idempotencyKey: cachedTask2.idempotencyKey
+          });
+          this._stats.lazyLoadedCachedTasks++;
+        }
+      }
+    }
     if (task.status === "CANCELED") {
       this._logger.debug("Task canceled", {
         idempotencyKey,
@@ -909,50 +1326,61 @@ var IO = class {
       throw new CanceledWithTaskError(task);
     }
     if (task.status === "COMPLETED") {
-      this._logger.debug("Using task output", {
-        idempotencyKey,
-        task
-      });
-      __privateMethod(this, _addToCachedTasks, addToCachedTasks_fn).call(this, task);
-      return task.output;
+      if (task.noop) {
+        this._logger.debug("Noop Task completed", {
+          idempotencyKey
+        });
+        this._noopTasksBloomFilter?.add(task.idempotencyKey);
+      } else {
+        this._logger.debug("Cache miss", {
+          idempotencyKey
+        });
+        this._stats.cachedTaskMisses++;
+        __privateMethod(this, _addToCachedTasks, addToCachedTasks_fn).call(this, task);
+      }
+      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");
-    }
-    if (task.status === "WAITING") {
-      this._logger.debug("Task waiting", {
-        idempotencyKey,
-        task
-      });
-      throw new ResumeWithTaskError(task);
-    }
-    if (task.status === "RUNNING" && typeof task.operation === "string") {
-      this._logger.debug("Task running operation", {
-        idempotencyKey,
-        task
-      });
-      throw new ResumeWithTaskError(task);
+      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 () => {
       try {
         const result = await callback(task, this);
-        const output = import_core3.SerializableJsonSchema.parse(result);
+        if (task.status === "WAITING" && task.callbackUrl) {
+          this._logger.debug("Waiting for remote callback", {
+            idempotencyKey,
+            task
+          });
+          return {};
+        }
+        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) {
+          this._logger.debug("Forcing yield after task completed", {
+            idempotencyKey
+          });
+          __privateMethod(this, _forceYield, forceYield_fn).call(this, "after_complete_task");
+        }
+        this._stats.executedTasks++;
         if (completedTask.status === "CANCELED") {
           throw new CanceledWithTaskError(completedTask);
         }
-        return output;
+        __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "after_complete_task", 500);
+        const deserializedOutput = this._outputSerializer.deserialize(output);
+        return options?.parseOutput ? options.parseOutput(deserializedOutput) : deserializedOutput;
       } catch (error) {
         if (isTriggerError(error)) {
           throw error;
@@ -967,7 +1395,7 @@ var IO = class {
               } else {
                 skipRetrying = !!onErrorResult.skipRetrying;
                 if (onErrorResult.retryAt && !skipRetrying) {
-                  const parsedError2 = import_core3.ErrorWithStackSchema.safeParse(onErrorResult.error);
+                  const parsedError2 = import_core2.ErrorWithStackSchema.safeParse(onErrorResult.error);
                   throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
                     message: "Unknown error"
                   }, task, onErrorResult.retryAt);
@@ -981,9 +1409,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_core2.ErrorWithStackSchema.safeParse(error);
         if (options?.retry && !skipRetrying) {
-          const retryAt = (0, import_core2.calculateRetryAt)(options.retry, task.attempts - 1);
+          const retryAt = (0, import_core.calculateRetryAt)(options.retry, task.attempts - 1);
           if (retryAt) {
             throw new RetryWithTaskError(parsedError.success ? parsedError.data : {
               message: "Unknown error"
@@ -995,20 +1428,50 @@ var IO = class {
             error: parsedError.data
           });
         } else {
+          const message = typeof error === "string" ? error : JSON.stringify(error);
           await this._apiClient.failTask(this._id, task.id, {
             error: {
-              message: JSON.stringify(error),
-              name: "Unknown Error"
+              name: "Unknown error",
+              message
             }
           });
         }
         throw error;
       }
     }, "executeTask");
+    if (task.status === "WAITING") {
+      this._logger.debug("Task waiting", {
+        idempotencyKey,
+        task
+      });
+      if (task.callbackUrl) {
+        await this._taskStorage.run({
+          taskId: task.id
+        }, executeTask);
+      }
+      throw new ResumeWithTaskError(task);
+    }
+    if (task.status === "RUNNING" && typeof task.operation === "string") {
+      this._logger.debug("Task running operation", {
+        idempotencyKey,
+        task
+      });
+      throw new ResumeWithTaskError(task);
+    }
     return this._taskStorage.run({
       taskId: task.id
     }, executeTask);
   }
+  yield(cacheKey) {
+    if (!(0, import_core2.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;
+    }
+    if (this._yieldedExecutions.includes(cacheKey)) {
+      return;
+    }
+    throw new YieldExecutionError(cacheKey);
+  }
   async try(tryCallback, catchCallback) {
     try {
       return await tryCallback();
@@ -1019,12 +1482,52 @@ var IO = class {
       return await catchCallback(error);
     }
   }
+  get store() {
+    return {
+      env: this._envStore,
+      job: this._jobStore,
+      run: this._runStore
+    };
+  }
 };
 __name(IO, "IO");
 _addToCachedTasks = new WeakSet();
 addToCachedTasks_fn = /* @__PURE__ */ __name(function(task) {
   this._cachedTasks.set(task.idempotencyKey, task);
 }, "#addToCachedTasks");
+_detectAutoYield = new WeakSet();
+detectAutoYield_fn = /* @__PURE__ */ __name(function(location, threshold = 1500, task1, output) {
+  const timeRemaining = __privateMethod(this, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn).call(this);
+  if (timeRemaining && timeRemaining < threshold) {
+    if (task1) {
+      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));
+    }
+  }
+}, "#detectAutoYield");
+_forceYield = new WeakSet();
+forceYield_fn = /* @__PURE__ */ __name(function(location1) {
+  const timeRemaining = __privateMethod(this, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn).call(this);
+  if (timeRemaining) {
+    throw new AutoYieldExecutionError(location1, timeRemaining, __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this));
+  }
+}, "#forceYield");
+_getTimeElapsed = new WeakSet();
+getTimeElapsed_fn = /* @__PURE__ */ __name(function() {
+  return performance.now() - this._timeOrigin;
+}, "#getTimeElapsed");
+_getRemainingTimeInMillis = new WeakSet();
+getRemainingTimeInMillis_fn = /* @__PURE__ */ __name(function() {
+  if (this._executionTimeout) {
+    return this._executionTimeout - (performance.now() - this._timeOrigin);
+  }
+  return void 0;
+}, "#getRemainingTimeInMillis");
 async function generateIdempotencyKey(keyMaterial) {
   const keys = keyMaterial.map((key2) => {
     if (typeof key2 === "string") {
@@ -1061,23 +1564,803 @@ var IOLogger = class {
   constructor(callback) {
     this.callback = callback;
   }
-  log(message, properties) {
-    return this.callback("LOG", message, properties);
+  log(message, properties) {
+    return this.callback("LOG", message, properties);
+  }
+  debug(message, properties) {
+    return this.callback("DEBUG", message, properties);
+  }
+  info(message, properties) {
+    return this.callback("INFO", message, properties);
+  }
+  warn(message, properties) {
+    return this.callback("WARN", message, properties);
+  }
+  error(message, properties) {
+    return this.callback("ERROR", message, properties);
+  }
+};
+__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/store/keyValueStoreClient.ts
+var _serializer, _namespacedKey2, namespacedKey_fn2;
+var KeyValueStoreClient = class {
+  constructor(queryStore, type = null, namespace = "") {
+    __privateAdd(this, _namespacedKey2);
+    __privateAdd(this, _serializer, void 0);
+    this.queryStore = queryStore;
+    this.type = type;
+    this.namespace = namespace;
+    __privateSet(this, _serializer, new JSONOutputSerializer());
+  }
+  async delete(key) {
+    const result = await this.queryStore("DELETE", {
+      key: __privateMethod(this, _namespacedKey2, namespacedKey_fn2).call(this, key)
+    });
+    if (result.action !== "DELETE") {
+      throw new Error(`Unexpected key-value store response: ${result.action}`);
+    }
+    return result.deleted;
+  }
+  async get(key) {
+    const result = await this.queryStore("GET", {
+      key: __privateMethod(this, _namespacedKey2, namespacedKey_fn2).call(this, key)
+    });
+    if (result.action !== "GET") {
+      throw new Error(`Unexpected key-value store response: ${result.action}`);
+    }
+    return __privateGet(this, _serializer).deserialize(result.value);
+  }
+  async has(key) {
+    const result = await this.queryStore("HAS", {
+      key: __privateMethod(this, _namespacedKey2, namespacedKey_fn2).call(this, key)
+    });
+    if (result.action !== "HAS") {
+      throw new Error(`Unexpected key-value store response: ${result.action}`);
+    }
+    return result.has;
+  }
+  async set(key, value) {
+    const result = await this.queryStore("SET", {
+      key: __privateMethod(this, _namespacedKey2, namespacedKey_fn2).call(this, key),
+      value: __privateGet(this, _serializer).serialize(value)
+    });
+    if (result.action !== "SET") {
+      throw new Error(`Unexpected key-value store response: ${result.action}`);
+    }
+    return __privateGet(this, _serializer).deserialize(result.value);
+  }
+};
+__name(KeyValueStoreClient, "KeyValueStoreClient");
+_serializer = new WeakMap();
+_namespacedKey2 = new WeakSet();
+namespacedKey_fn2 = /* @__PURE__ */ __name(function(key) {
+  const parts = [];
+  if (this.type) {
+    parts.push(this.type);
+  }
+  if (this.namespace) {
+    parts.push(this.namespace);
+  }
+  parts.push(key);
+  return parts.join(":");
+}, "#namespacedKey");
+
+// src/apiClient.ts
+var _apiUrl, _options, _logger, _storeClient, _queryKeyValueStore, queryKeyValueStore_fn, _apiKey, apiKey_fn;
+var ApiClient = class {
+  constructor(options) {
+    __privateAdd(this, _queryKeyValueStore);
+    __privateAdd(this, _apiKey);
+    __privateAdd(this, _apiUrl, void 0);
+    __privateAdd(this, _options, void 0);
+    __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, _storeClient, new KeyValueStoreClient(__privateMethod(this, _queryKeyValueStore, queryKeyValueStore_fn).bind(this)));
+  }
+  async registerEndpoint(options) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Registering endpoint", {
+      url: options.url,
+      name: options.name
+    });
+    const response = await fetch(`${__privateGet(this, _apiUrl)}/api/v1/endpoints`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        url: options.url,
+        name: options.name
+      })
+    });
+    if (response.status >= 400 && response.status < 500) {
+      const body = await response.json();
+      throw new Error(body.error);
+    }
+    if (response.status !== 200) {
+      throw new Error(`Failed to register entry point, got status code ${response.status}`);
+    }
+    return await response.json();
+  }
+  async runTask(runId, task, options = {}) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Running Task", {
+      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`, {
+      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
+      },
+      body: JSON.stringify(task)
+    });
+  }
+  async completeTask(runId, id, task) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Complete Task", {
+      task
+    });
+    return await zodfetch(import_core3.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
+      },
+      body: JSON.stringify(task)
+    });
+  }
+  async failTask(runId, id, body) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Fail Task", {
+      id,
+      runId,
+      body
+    });
+    return await zodfetch(import_core3.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/fail`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  async sendEvent(event, options = {}) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Sending event", {
+      event
+    });
+    return await zodfetch(import_core3.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        event,
+        options
+      })
+    });
+  }
+  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_core3.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", {
+      eventId
+    });
+    return await zodfetch(import_core3.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async cancelRunsForEvent(eventId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Cancelling runs for event", {
+      eventId
+    });
+    return await zodfetch(import_core3.CancelRunsForEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel-runs`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async updateStatus(runId, id, status) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Update status", {
+      id,
+      status
+    });
+    return await zodfetch(import_core3.JobRunStatusRecordSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses/${id}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(status)
+    });
+  }
+  async updateSource(client, key, source) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("activating http source", {
+      source
+    });
+    const response = await zodfetch(import_core3.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v2/${client}/sources/${key}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(source)
+    });
+    return response;
+  }
+  async updateWebhook(key, webhookData) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("activating webhook", {
+      webhookData
+    });
+    const response = await zodfetch(import_core3.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v1/webhooks/${key}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(webhookData)
+    });
+    return response;
+  }
+  async registerTrigger(client, id, key, payload, idempotencyKey) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("registering trigger", {
+      id,
+      payload
+    });
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    };
+    if (idempotencyKey) {
+      headers["Idempotency-Key"] = idempotencyKey;
+    }
+    const response = await zodfetch(import_core3.RegisterSourceEventSchemaV2, `${__privateGet(this, _apiUrl)}/api/v2/${client}/triggers/${id}/registrations/${key}`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify(payload)
+    });
+    return response;
+  }
+  async registerSchedule(client, id, key, payload) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("registering schedule", {
+      id,
+      payload
+    });
+    const response = await zodfetch(import_core3.RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        id: key,
+        ...payload
+      })
+    });
+    return response;
+  }
+  async unregisterSchedule(client, id, key) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("unregistering schedule", {
+      id
+    });
+    const response = await zodfetch(import_zod3.z.object({
+      ok: import_zod3.z.boolean()
+    }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    return response;
+  }
+  async getAuth(client, id) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("getting auth", {
+      id
+    });
+    const response = await zodfetch(import_core3.ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    }, {
+      optional: true
+    });
+    return response;
+  }
+  async getEvent(eventId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Getting Event", {
+      eventId
+    });
+    return await zodfetch(import_core3.GetEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async getRun(runId, options) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __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), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async cancelRun(runId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Cancelling Run", {
+      runId
+    });
+    return await zodfetch(import_core3.GetRunSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/cancel`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async getRunStatuses(runId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Getting Run statuses", {
+      runId
+    });
+    return await zodfetch(import_core3.GetRunStatusesSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async getRuns(jobSlug, options) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __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), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  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_core3.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_core3.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;
+  }
+  get store() {
+    return __privateGet(this, _storeClient);
+  }
+};
+__name(ApiClient, "ApiClient");
+_apiUrl = new WeakMap();
+_options = new WeakMap();
+_logger = new WeakMap();
+_storeClient = new WeakMap();
+_queryKeyValueStore = new WeakSet();
+queryKeyValueStore_fn = /* @__PURE__ */ __name(async function(action, data) {
+  const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+  __privateGet(this, _logger).debug("accessing key-value store", {
+    action,
+    data
+  });
+  const encodedKey = encodeURIComponent(data.key);
+  const STORE_URL = `${__privateGet(this, _apiUrl)}/api/v1/store/${encodedKey}`;
+  const authHeader = {
+    Authorization: `Bearer ${apiKey}`
+  };
+  let requestInit;
+  switch (action) {
+    case "DELETE": {
+      requestInit = {
+        method: "DELETE",
+        headers: authHeader
+      };
+      break;
+    }
+    case "GET": {
+      requestInit = {
+        method: "GET",
+        headers: authHeader
+      };
+      break;
+    }
+    case "HAS": {
+      const headResponse = await fetchHead(STORE_URL, {
+        headers: authHeader
+      });
+      return {
+        action: "HAS",
+        key: encodedKey,
+        has: !!headResponse.ok
+      };
+    }
+    case "SET": {
+      const MAX_BODY_BYTE_LENGTH = 256 * 1024;
+      if ((data.value?.length ?? 0) > MAX_BODY_BYTE_LENGTH) {
+        throw new Error(`Max request body size exceeded: ${MAX_BODY_BYTE_LENGTH} bytes`);
+      }
+      requestInit = {
+        method: "PUT",
+        headers: {
+          ...authHeader,
+          "Content-Type": "text/plain"
+        },
+        body: data.value
+      };
+      break;
+    }
+    default: {
+      (0, import_core3.assertExhaustive)(action);
+    }
+  }
+  const response = await zodfetch(import_core3.KeyValueStoreResponseBodySchema, STORE_URL, requestInit);
+  return response;
+}, "#queryKeyValueStore");
+_apiKey = new WeakSet();
+apiKey_fn = /* @__PURE__ */ __name(async function() {
+  const apiKey = getApiKey(__privateGet(this, _options).apiKey);
+  if (apiKey.status === "invalid") {
+    throw new Error("Invalid API key");
+  } else if (apiKey.status === "missing") {
+    throw new Error("Missing API key");
+  }
+  return apiKey.apiKey;
+}, "#apiKey");
+function getApiKey(key) {
+  const apiKey = key ?? process.env.TRIGGER_API_KEY;
+  if (!apiKey) {
+    return {
+      status: "missing"
+    };
+  }
+  const isValid = apiKey.match(/^tr_[a-z]+_[a-zA-Z0-9]+$/);
+  if (!isValid) {
+    return {
+      status: "invalid",
+      apiKey
+    };
+  }
+  return {
+    status: "valid",
+    apiKey
+  };
+}
+__name(getApiKey, "getApiKey");
+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;
+  }
+  if (response.status >= 400 && response.status < 500) {
+    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}`);
+  }
+  const jsonBody = await response.json();
+  const version2 = response.headers.get("trigger-version");
+  if (!version2) {
+    return {
+      version: "unversioned",
+      body: unversionedSchema.parse(jsonBody)
+    };
+  }
+  const versionedSchema = versionedSchemaMap[version2];
+  if (!versionedSchema) {
+    throw new Error(`Unknown version ${version2}`);
+  }
+  return {
+    version: version2,
+    body: versionedSchema.parse(jsonBody)
+  };
+}
+__name(zodfetchWithVersions, "zodfetchWithVersions");
+async function fetchHead(url, requestInitWithoutMethod, retryCount = 0) {
+  const requestInit = {
+    ...requestInitWithoutMethod,
+    method: "HEAD"
+  };
+  const response = await fetch(url, {
+    ...requestInit,
+    cache: "no-cache"
+  });
+  if (response.status >= 500 && retryCount < 6) {
+    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return fetchHead(url, requestInitWithoutMethod, retryCount + 1);
+  }
+  return response;
+}
+__name(fetchHead, "fetchHead");
+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;
+  }
+  if (response.status >= 400 && response.status < 500) {
+    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}`);
+  }
+  const jsonBody = await response.json();
+  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/httpEndpoint.ts
+var import_core4 = 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
+    };
   }
-  debug(message, properties) {
-    return this.callback("DEBUG", message, properties);
+};
+__name(HttpEndpoint, "HttpEndpoint");
+var HttpTrigger = /* @__PURE__ */ __name(class HttpTrigger2 {
+  constructor(options) {
+    this.options = options;
   }
-  info(message, properties) {
-    return this.callback("INFO", message, properties);
+  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}`
+        }
+      }
+    };
   }
-  warn(message, properties) {
-    return this.callback("WARN", message, properties);
+  get event() {
+    return this.options.event;
   }
-  error(message, properties) {
-    return this.callback("ERROR", message, properties);
+  attachToJob(triggerClient, job) {
   }
-};
-__name(IOLogger, "IOLogger");
+  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_core4.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/ioWithIntegrations.ts
 function createIOWithIntegrations(io, auths, integrations) {
@@ -1108,26 +2391,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) {
@@ -1156,7 +2421,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",
@@ -1187,7 +2452,7 @@ var DynamicTrigger = class {
       key,
       "register"
     ], async (task) => {
-      return __privateGet(this, _client).registerTrigger(this.id, key, this.registeredTriggerForParams(params, options));
+      return __privateGet(this, _client).registerTrigger(this.id, key, this.registeredTriggerForParams(params, options), task.idempotencyKey);
     }, {
       name: "Register Dynamic Trigger",
       properties: [
@@ -1209,27 +2474,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) {
@@ -1243,7 +2499,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 ?? {})
       }
     };
   }
@@ -1255,6 +2511,17 @@ var EventTrigger = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    if (__privateGet(this, _options3).verify) {
+      if (payload instanceof Request) {
+        const clonedRequest = payload.clone();
+        return __privateGet(this, _options3).verify(clonedRequest);
+      }
+    }
+    return {
+      success: true
+    };
+  }
 };
 __name(EventTrigger, "EventTrigger");
 _options3 = new WeakMap();
@@ -1284,7 +2551,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 = [
   {
@@ -1292,8 +2559,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
     }
   }
 ];
@@ -1308,7 +2575,7 @@ var IntervalTrigger = class {
       source: "trigger.dev",
       icon: "schedule-interval",
       examples,
-      parsePayload: import_core6.ScheduledPayloadSchema.parse,
+      parsePayload: import_core7.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "Interval",
@@ -1322,6 +2589,11 @@ var IntervalTrigger = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "scheduled",
@@ -1353,7 +2625,7 @@ var CronTrigger = class {
       source: "trigger.dev",
       icon: "schedule-cron",
       examples,
-      parsePayload: import_core6.ScheduledPayloadSchema.parse,
+      parsePayload: import_core7.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "cron",
@@ -1371,6 +2643,11 @@ var CronTrigger = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "scheduled",
@@ -1404,7 +2681,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) {
@@ -1466,6 +2743,11 @@ var DynamicSchedule = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "dynamic",
@@ -1476,49 +2758,95 @@ var DynamicSchedule = class {
 __name(DynamicSchedule, "DynamicSchedule");
 
 // src/triggerClient.ts
+var import_node_events = __toESM(require("events"));
+
+// package.json
+var version = "0.0.0-cross-runtime-20231201105801";
+
+// src/concurrencyLimit.ts
+var ConcurrencyLimit = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get id() {
+    return this.options.id;
+  }
+  get limit() {
+    return this.options.limit;
+  }
+};
+__name(ConcurrencyLimit, "ConcurrencyLimit");
+
+// src/triggerClient.ts
+var registerWebhookEvent = /* @__PURE__ */ __name((key) => ({
+  name: `${import_core8.REGISTER_WEBHOOK}.${key}`,
+  title: "Register Webhook",
+  source: "internal",
+  icon: "webhook",
+  parsePayload: import_core8.RegisterWebhookPayloadSchema.parse
+}), "registerWebhookEvent");
 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;
+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 {
   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, _handleWebhookRequest);
     __privateAdd(this, _resolveConnections);
     __privateAdd(this, _resolveConnection);
     __privateAdd(this, _buildJobsIndex);
     __privateAdd(this, _buildJobIndex);
     __privateAdd(this, _buildJobIntegrations);
     __privateAdd(this, _buildJobIntegration);
+    __privateAdd(this, _logIOStats);
+    __privateAdd(this, _standardResponseHeaders);
+    __privateAdd(this, _serializeRunMetadata);
+    __privateAdd(this, _deliverSuccessfulRunNotification);
+    __privateAdd(this, _deliverFailedRunNotification);
     __privateAdd(this, _options4, void 0);
     __privateAdd(this, _registeredJobs, {});
     __privateAdd(this, _registeredSources, {});
+    __privateAdd(this, _registeredWebhooks, {});
     __privateAdd(this, _registeredHttpSourceHandlers, {});
+    __privateAdd(this, _registeredWebhookSourceHandlers, {});
     __privateAdd(this, _registeredDynamicTriggers, {});
     __privateAdd(this, _jobMetadataByDynamicTriggers, {});
     __privateAdd(this, _registeredSchedules, {});
+    __privateAdd(this, _registeredHttpEndpoints, {});
     __privateAdd(this, _authResolvers, {});
+    __privateAdd(this, _envStore, void 0);
+    __privateAdd(this, _eventEmitter, new import_node_events.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_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"
+    ]));
+    __privateSet(this, _envStore, new KeyValueStore(__privateGet(this, _client2)));
   }
-  async handleRequest(request) {
+  async handleRequest(request, timeOrigin = performance.now()) {
     __privateGet(this, _internalLogger).debug("handling request", {
       url: request.url,
       headers: Object.fromEntries(request.headers.entries()),
       method: request.method
     });
     const apiKey = request.headers.get("x-trigger-api-key");
+    const triggerVersion = request.headers.get("x-trigger-version");
     const authorization = this.authorized(apiKey);
     switch (authorization) {
       case "authorized": {
@@ -1529,7 +2857,8 @@ var TriggerClient = class {
           status: 401,
           body: {
             message: "Unauthorized: client missing apiKey"
-          }
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "missing-header": {
@@ -1537,7 +2866,8 @@ var TriggerClient = class {
           status: 401,
           body: {
             message: "Unauthorized: missing x-trigger-api-key header"
-          }
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "unauthorized": {
@@ -1545,7 +2875,8 @@ var TriggerClient = class {
           status: 401,
           body: {
             message: `Forbidden: client apiKey mismatch: Make sure you are using the correct API Key for your environment`
-          }
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
     }
@@ -1554,7 +2885,8 @@ var TriggerClient = class {
         status: 405,
         body: {
           message: "Method not allowed (only POST is allowed)"
-        }
+        },
+        headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
       };
     }
     const action = request.headers.get("x-trigger-action");
@@ -1563,7 +2895,8 @@ var TriggerClient = class {
         status: 400,
         body: {
           message: "Missing x-trigger-action header"
-        }
+        },
+        headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
       };
     }
     switch (action) {
@@ -1575,7 +2908,8 @@ var TriggerClient = class {
             body: {
               ok: false,
               error: "Missing endpoint ID"
-            }
+            },
+            headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
           };
         }
         if (this.id !== endpointId) {
@@ -1584,20 +2918,23 @@ var TriggerClient = class {
             body: {
               ok: false,
               error: `Endpoint ID mismatch error. Expected ${this.id}, got ${endpointId}`
-            }
+            },
+            headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
           };
         }
         return {
           status: 200,
           body: {
             ok: true
-          }
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "INDEX_ENDPOINT": {
         const body = {
           jobs: __privateMethod(this, _buildJobsIndex, buildJobsIndex_fn).call(this),
           sources: Object.values(__privateGet(this, _registeredSources)),
+          webhooks: Object.values(__privateGet(this, _registeredWebhooks)),
           dynamicTriggers: Object.values(__privateGet(this, _registeredDynamicTriggers)).map((trigger) => ({
             id: trigger.id,
             jobs: __privateGet(this, _jobMetadataByDynamicTriggers)[trigger.id] ?? [],
@@ -1609,16 +2946,18 @@ 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,
-          body
+          body,
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       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,
@@ -1638,12 +2977,13 @@ var TriggerClient = class {
         }
         return {
           status: 200,
-          body: dynamicTrigger.registeredTriggerForParams(body.data.params)
+          body: dynamicTrigger.registeredTriggerForParams(body.data.params),
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       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,
@@ -1661,15 +3001,24 @@ var TriggerClient = class {
             }
           };
         }
-        const results = await __privateMethod(this, _executeJob, executeJob_fn).call(this, execution.data, job);
+        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
+        });
+        const standardHeaders = __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin);
+        standardHeaders["x-trigger-run-metadata"] = __privateMethod(this, _serializeRunMetadata, serializeRunMetadata_fn).call(this, job);
         return {
           status: 200,
-          body: results
+          body: results,
+          headers: standardHeaders
         };
       }
       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,
@@ -1693,11 +3042,12 @@ var TriggerClient = class {
           body: {
             abort: results.abort,
             properties: results.properties
-          }
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       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,
@@ -1742,7 +3092,83 @@ var TriggerClient = class {
             events,
             response,
             metadata
+          },
+          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 "DELIVER_WEBHOOK_REQUEST": {
+        const headers = import_core8.WebhookSourceRequestHeadersSchema.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 (error2) {
           }
+        }
+        const webhookRequest = new Request(headers.data["x-ts-http-url"], sourceRequestInit);
+        const key = headers.data["x-ts-key"];
+        const secret = headers.data["x-ts-secret"];
+        const params = headers.data["x-ts-params"];
+        const ctx = {
+          key,
+          secret,
+          params
+        };
+        const { response, verified, error } = await __privateMethod(this, _handleWebhookRequest, handleWebhookRequest_fn).call(this, webhookRequest, ctx);
+        return {
+          status: 200,
+          body: {
+            response,
+            verified,
+            error
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "VALIDATE": {
@@ -1751,7 +3177,36 @@ var TriggerClient = class {
           body: {
             ok: true,
             endpointId: this.id
-          }
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
+        };
+      }
+      case "PROBE_EXECUTION_TIMEOUT": {
+        const json = await request.json();
+        const timeout = json?.timeout ?? 15 * 60 * 1e3;
+        await new Promise((resolve) => setTimeout(resolve, timeout));
+        return {
+          status: 200,
+          body: {
+            ok: true
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
+        };
+      }
+      case "RUN_NOTIFICATION": {
+        const rawJson = await request.json();
+        const runNotification = rawJson;
+        if (runNotification.ok) {
+          await __privateMethod(this, _deliverSuccessfulRunNotification, deliverSuccessfulRunNotification_fn).call(this, runNotification);
+        } else {
+          await __privateMethod(this, _deliverFailedRunNotification, deliverFailedRunNotification_fn).call(this, runNotification);
+        }
+        return {
+          status: 200,
+          body: {
+            ok: true
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
     }
@@ -1759,10 +3214,15 @@ var TriggerClient = class {
       status: 405,
       body: {
         message: "Method not allowed"
-      }
+      },
+      headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
     };
   }
   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) {
@@ -1775,6 +3235,18 @@ var TriggerClient = class {
   defineDynamicTrigger(options) {
     return new DynamicTrigger(this, options);
   }
+  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.`));
+    }
+    const endpoint = httpEndpoint(options);
+    __privateGet(this, _registeredHttpEndpoints)[endpoint.id] = endpoint;
+    return endpoint;
+  }
+  defineConcurrencyLimit(options) {
+    return new ConcurrencyLimit(options);
+  }
   attach(job) {
     __privateGet(this, _registeredJobs)[job.id] = job;
     job.trigger.attachToJob(this, job);
@@ -1889,8 +3361,96 @@ var TriggerClient = class {
     });
     __privateGet(this, _registeredSchedules)[key] = jobs;
   }
-  async registerTrigger(id, key, options) {
-    return __privateGet(this, _client2).registerTrigger(this.id, id, key, options);
+  attachWebhook(options) {
+    const { source } = options;
+    __privateGet(this, _registeredWebhookSourceHandlers)[options.key] = {
+      verify: source.verify.bind(source),
+      generateEvents: source.generateEvents.bind(source)
+    };
+    let registeredWebhook = __privateGet(this, _registeredWebhooks)[options.key];
+    if (!registeredWebhook) {
+      registeredWebhook = {
+        key: options.key,
+        params: options.params,
+        config: options.config,
+        integration: {
+          id: source.integration.id,
+          metadata: source.integration.metadata,
+          authSource: source.integration.authSource
+        },
+        httpEndpoint: {
+          id: options.key
+        }
+      };
+    } else {
+      registeredWebhook.config = deepMergeOptions(registeredWebhook.config, options.config);
+    }
+    __privateGet(this, _registeredWebhooks)[options.key] = registeredWebhook;
+    new Job(this, {
+      id: `webhook.register.${options.key}`,
+      name: `webhook.register.${options.key}`,
+      version: source.version,
+      trigger: new EventTrigger({
+        event: registerWebhookEvent(options.key)
+      }),
+      integrations: {
+        integration: source.integration
+      },
+      run: async (registerPayload, io, ctx) => {
+        return await io.try(async () => {
+          __privateGet(this, _internalLogger).debug("[webhook.register] Start");
+          const crudOptions = {
+            io,
+            ctx: registerPayload
+          };
+          if (!registerPayload.active) {
+            __privateGet(this, _internalLogger).debug("[webhook.register] Not active, run create");
+            await io.try(async () => {
+              await source.crud.create(crudOptions);
+            }, async (error) => {
+              __privateGet(this, _internalLogger).debug("[webhook.register] Error during create, re-trying with delete first", {
+                error
+              });
+              await io.runTask("create-retry", async () => {
+                await source.crud.delete(crudOptions);
+                await source.crud.create(crudOptions);
+              });
+            });
+            return await io.updateWebhook("update-webhook-success", {
+              key: options.key,
+              active: true,
+              config: registerPayload.config.desired
+            });
+          }
+          __privateGet(this, _internalLogger).debug("[webhook.register] Already active, run update");
+          if (source.crud.update) {
+            await source.crud.update(crudOptions);
+          } else {
+            __privateGet(this, _internalLogger).debug("[webhook.register] Run delete and create instead of update");
+            await source.crud.delete(crudOptions);
+            await source.crud.create(crudOptions);
+          }
+          return await io.updateWebhook("update-webhook-success", {
+            key: options.key,
+            active: true,
+            config: registerPayload.config.desired
+          });
+        }, async (error) => {
+          __privateGet(this, _internalLogger).debug("[webhook.register] Error", {
+            error
+          });
+          await io.updateWebhook("update-webhook-error", {
+            key: options.key,
+            active: false
+          });
+          throw error;
+        });
+      },
+      __internal: true
+    });
+  }
+  async registerTrigger(id, key, options, idempotencyKey) {
+    return __privateGet(this, _client2).registerTrigger(this.id, id, key, options, idempotencyKey);
   }
   async getAuth(id) {
     return __privateGet(this, _client2).getAuth(this.id, id);
@@ -1898,9 +3458,15 @@ 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);
   }
+  async cancelRunsForEvent(eventId) {
+    return __privateGet(this, _client2).cancelRunsForEvent(eventId);
+  }
   async updateStatus(runId, id, status) {
     return __privateGet(this, _client2).updateStatus(runId, id, status);
   }
@@ -1916,12 +3482,26 @@ var TriggerClient = class {
   async getRun(runId, options) {
     return __privateGet(this, _client2).getRun(runId, options);
   }
+  async cancelRun(runId) {
+    return __privateGet(this, _client2).cancelRun(runId);
+  }
   async getRuns(jobSlug, options) {
     return __privateGet(this, _client2).getRuns(jobSlug, options);
   }
   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);
+  }
+  get store() {
+    return {
+      env: __privateGet(this, _envStore)
+    };
+  }
   authorized(apiKey) {
     if (typeof apiKey !== "string") {
       return "missing-header";
@@ -1940,11 +3520,16 @@ __name(TriggerClient, "TriggerClient");
 _options4 = new WeakMap();
 _registeredJobs = new WeakMap();
 _registeredSources = new WeakMap();
+_registeredWebhooks = new WeakMap();
 _registeredHttpSourceHandlers = new WeakMap();
+_registeredWebhookSourceHandlers = new WeakMap();
 _registeredDynamicTriggers = new WeakMap();
 _jobMetadataByDynamicTriggers = new WeakMap();
 _registeredSchedules = new WeakMap();
+_registeredHttpEndpoints = new WeakMap();
 _authResolvers = new WeakMap();
+_envStore = new WeakMap();
+_eventEmitter = new WeakMap();
 _client2 = new WeakMap();
 _internalLogger = new WeakMap();
 _preprocessRun = new WeakSet();
@@ -1958,22 +3543,30 @@ preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
   };
 }, "#preprocessRun");
 _executeJob = new WeakSet();
-executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
+executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, timeOrigin, triggerVersion) {
   __privateGet(this, _internalLogger).debug("executing job", {
     execution: body1,
     job: job1.id,
-    version: job1.version
+    version: job1.version,
+    triggerVersion
   });
   const context = __privateMethod(this, _createRunContext, createRunContext_fn).call(this, body1);
   const io = new IO({
     id: body1.run.id,
+    jobId: job1.id,
     cachedTasks: body1.tasks,
+    cachedTasksCursor: body1.cachedTaskCursor,
+    yieldedExecutions: body1.yieldedExecutions ?? [],
+    noopTasksSet: body1.noopTasksSet,
     apiClient: __privateGet(this, _client2),
     logger: __privateGet(this, _internalLogger),
     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
   });
   const resolvedConnections = await __privateMethod(this, _resolveConnections, resolveConnections_fn).call(this, context, job1.options.integrations, body1.connections);
   if (!resolvedConnections.ok) {
@@ -1984,78 +3577,155 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
   }
   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);
+    }
     return {
       status: "SUCCESS",
       output
     };
   } catch (error) {
-    if (error instanceof ParsedPayloadSchemaError) {
-      return {
-        status: "INVALID_PAYLOAD",
-        errors: error.schemaErrors
-      };
-    }
-    if (error instanceof ResumeWithTaskError) {
-      return {
-        status: "RESUME_WITH_TASK",
-        task: error.task
-      };
+    if (__privateGet(this, _options4).verbose) {
+      __privateMethod(this, _logIOStats, logIOStats_fn).call(this, io.stats);
     }
-    if (error instanceof RetryWithTaskError) {
+    if (error instanceof ResumeWithParallelTaskError) {
       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
       };
     }
     return {
       status: "ERROR",
       error: {
         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,
@@ -2064,6 +3734,11 @@ createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
       timestamp: event.timestamp
     },
     organization,
+    project: project ?? {
+      id: "unknown",
+      name: "unknown",
+      slug: "unknown"
+    },
     environment,
     job,
     run,
@@ -2072,8 +3747,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,
@@ -2170,8 +3845,97 @@ 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");
+_handleWebhookRequest = new WeakSet();
+handleWebhookRequest_fn = /* @__PURE__ */ __name(async function(request, ctx) {
+  __privateGet(this, _internalLogger).debug("Handling webhook request", {
+    ctx
+  });
+  const okResponse = {
+    status: 200,
+    body: {
+      ok: true
+    }
+  };
+  const handlers = __privateGet(this, _registeredWebhookSourceHandlers)[ctx.key];
+  if (!handlers) {
+    __privateGet(this, _internalLogger).debug("No handler registered for webhook", {
+      ctx
+    });
+    return {
+      response: okResponse,
+      verified: false
+    };
+  }
+  const { verify, generateEvents } = handlers;
+  const verifyResult = await verify(request, this, ctx);
+  if (!verifyResult.success) {
+    return {
+      response: okResponse,
+      verified: false,
+      error: verifyResult.reason
+    };
+  }
+  await generateEvents(request, this, ctx);
+  return {
+    response: okResponse,
+    verified: true
+  };
+}, "#handleWebhookRequest");
 _resolveConnections = new WeakSet();
-resolveConnections_fn = /* @__PURE__ */ __name(async function(ctx, integrations, connections) {
+resolveConnections_fn = /* @__PURE__ */ __name(async function(ctx1, integrations, connections) {
   if (!integrations) {
     return {
       ok: true,
@@ -2181,7 +3945,7 @@ resolveConnections_fn = /* @__PURE__ */ __name(async function(ctx, integrations,
   const resolvedAuthResults = await Promise.all(Object.keys(integrations).map(async (key) => {
     const integration = integrations[key];
     const auth = (connections ?? {})[key];
-    const result = await __privateMethod(this, _resolveConnection, resolveConnection_fn).call(this, ctx, integration, auth);
+    const result = await __privateMethod(this, _resolveConnection, resolveConnection_fn).call(this, ctx1, integration, auth);
     if (result.ok) {
       return {
         ok: true,
@@ -2223,7 +3987,7 @@ resolveConnections_fn = /* @__PURE__ */ __name(async function(ctx, integrations,
   }
 }, "#resolveConnections");
 _resolveConnection = new WeakSet();
-resolveConnection_fn = /* @__PURE__ */ __name(async function(ctx1, integration, auth) {
+resolveConnection_fn = /* @__PURE__ */ __name(async function(ctx2, integration, auth) {
   if (auth) {
     return {
       ok: true,
@@ -2244,7 +4008,7 @@ resolveConnection_fn = /* @__PURE__ */ __name(async function(ctx1, integration,
     };
   }
   try {
-    const resolvedAuth = await authResolver(ctx1, integration);
+    const resolvedAuth = await authResolver(ctx2, integration);
     if (!resolvedAuth) {
       return {
         ok: false,
@@ -2298,7 +4062,11 @@ buildJobIndex_fn = /* @__PURE__ */ __name(function(job2) {
     startPosition: "latest",
     enabled: job2.enabled,
     preprocessRuns: job2.trigger.preprocessRuns,
-    internal
+    internal,
+    concurrencyLimit: typeof job2.options.concurrencyLimit === "number" ? job2.options.concurrencyLimit : typeof job2.options.concurrencyLimit === "object" ? {
+      id: job2.options.concurrencyLimit.id,
+      limit: job2.options.concurrencyLimit.limit
+    } : void 0
   };
 }, "#buildJobIndex");
 _buildJobIntegrations = new WeakSet();
@@ -2318,6 +4086,59 @@ buildJobIntegration_fn = /* @__PURE__ */ __name(function(integration1) {
     authSource
   };
 }, "#buildJobIntegration");
+_logIOStats = new WeakSet();
+logIOStats_fn = /* @__PURE__ */ __name(function(stats) {
+  __privateGet(this, _internalLogger).debug("IO stats", {
+    stats
+  });
+}, "#logIOStats");
+_standardResponseHeaders = new WeakSet();
+standardResponseHeaders_fn = /* @__PURE__ */ __name(function(start) {
+  return {
+    "Trigger-Version": import_core8.API_VERSIONS.LAZY_LOADED_CACHED_TASKS,
+    "Trigger-SDK-Version": version,
+    "X-Trigger-Request-Timing": `dur=${performance.now() - start / 1e3}`
+  };
+}, "#standardResponseHeaders");
+_serializeRunMetadata = new WeakSet();
+serializeRunMetadata_fn = /* @__PURE__ */ __name(function(job4) {
+  const metadata = {};
+  if (__privateGet(this, _eventEmitter).listenerCount("runSucceeeded") > 0 || typeof job4.options.onSuccess === "function") {
+    metadata["successSubscription"] = true;
+  }
+  if (__privateGet(this, _eventEmitter).listenerCount("runFailed") > 0 || typeof job4.options.onFailure === "function") {
+    metadata["failedSubscription"] = true;
+  }
+  return JSON.stringify(metadata);
+}, "#serializeRunMetadata");
+_deliverSuccessfulRunNotification = new WeakSet();
+deliverSuccessfulRunNotification_fn = /* @__PURE__ */ __name(async function(notification) {
+  __privateGet(this, _internalLogger).debug("delivering successful run notification", {
+    notification
+  });
+  __privateGet(this, _eventEmitter).emit("runSucceeeded", notification);
+  const job = __privateGet(this, _registeredJobs)[notification.job.id];
+  if (!job) {
+    return;
+  }
+  if (typeof job.options.onSuccess === "function") {
+    await job.options.onSuccess(notification);
+  }
+}, "#deliverSuccessfulRunNotification");
+_deliverFailedRunNotification = new WeakSet();
+deliverFailedRunNotification_fn = /* @__PURE__ */ __name(async function(notification1) {
+  __privateGet(this, _internalLogger).debug("delivering failed run notification", {
+    notification: notification1
+  });
+  __privateGet(this, _eventEmitter).emit("runFailed", notification1);
+  const job = __privateGet(this, _registeredJobs)[notification1.job.id];
+  if (!job) {
+    return;
+  }
+  if (typeof job.options.onFailure === "function") {
+    await job.options.onFailure(notification1);
+  }
+}, "#deliverFailedRunNotification");
 function dynamicTriggerRegisterSourceJobId(id) {
   return `register-dynamic-trigger-${id}`;
 }
@@ -2343,7 +4164,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;
@@ -2417,7 +4238,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)
@@ -2435,6 +4256,11 @@ var ExternalSourceTrigger = class {
   get preprocessRuns() {
     return true;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
 };
 __name(ExternalSourceTrigger, "ExternalSourceTrigger");
 function omit(obj, key) {
@@ -2452,7 +4278,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
@@ -2471,11 +4297,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",
@@ -2489,6 +4315,11 @@ var MissingConnectionNotification = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "static",
@@ -2512,11 +4343,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",
@@ -2530,6 +4361,11 @@ var MissingConnectionResolvedNotification = class {
   get preprocessRuns() {
     return false;
   }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
   toJSON() {
     return {
       type: "static",
@@ -2548,6 +4384,249 @@ 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/triggers/webhook.ts
+var import_core11 = require("@trigger.dev/core");
+var import_node_crypto2 = require("crypto");
+var _shortHash, shortHash_fn;
+var WebhookSource = class {
+  constructor(options) {
+    __privateAdd(this, _shortHash);
+    this.options = options;
+  }
+  async generateEvents(request, client, ctx) {
+    return this.options.generateEvents({
+      request,
+      client,
+      ctx
+    });
+  }
+  filter(params, config) {
+    return this.options.filter?.(params, config) ?? {};
+  }
+  properties(params) {
+    return this.options.properties?.(params) ?? [];
+  }
+  get crud() {
+    return this.options.crud;
+  }
+  async register(params, registerEvent, io, ctx) {
+    if (!this.options.register) {
+      return;
+    }
+    const updates = await this.options.register({
+      ...registerEvent,
+      params
+    }, io, ctx);
+    return updates;
+  }
+  async verify(request, client, ctx) {
+    if (this.options.verify) {
+      const clonedRequest = request.clone();
+      return this.options.verify({
+        request: clonedRequest,
+        client,
+        ctx
+      });
+    }
+    return {
+      success: true
+    };
+  }
+  key(params) {
+    const parts = [
+      "webhook"
+    ];
+    parts.push(this.options.key(params));
+    parts.push(this.integration.id);
+    return `${this.options.id}-${__privateMethod(this, _shortHash, shortHash_fn).call(this, parts.join(""))}`;
+  }
+  get integration() {
+    return this.options.integration;
+  }
+  get integrationConfig() {
+    return {
+      id: this.integration.id,
+      metadata: this.integration.metadata
+    };
+  }
+  get id() {
+    return this.options.id;
+  }
+  get version() {
+    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");
+  return hash.slice(0, 7);
+}, "#shortHash");
+var WebhookTrigger = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get event() {
+    return this.options.event;
+  }
+  get source() {
+    return this.options.source;
+  }
+  get key() {
+    return slugifyId(this.options.source.key(this.options.params));
+  }
+  toJSON() {
+    return {
+      type: "static",
+      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 ?? {}),
+        source: this.event.source
+      },
+      properties: this.options.source.properties(this.options.params),
+      link: `http-endpoints/${this.key}`
+    };
+  }
+  filter(eventFilter) {
+    const { event, ...optionsWithoutEvent } = this.options;
+    const { filter, ...eventWithoutFilter } = event;
+    return new WebhookTrigger({
+      ...optionsWithoutEvent,
+      event: {
+        ...eventWithoutFilter,
+        filter: (0, import_core11.deepMergeFilters)(filter ?? {}, eventFilter)
+      }
+    });
+  }
+  attachToJob(triggerClient, job) {
+    triggerClient.defineHttpEndpoint({
+      id: this.key,
+      source: "trigger.dev",
+      icon: this.event.icon,
+      verify: async () => ({
+        success: true
+      })
+    }, true);
+    triggerClient.attachWebhook({
+      key: this.key,
+      source: this.options.source,
+      event: this.options.event,
+      params: this.options.params,
+      config: this.options.config
+    });
+  }
+  get preprocessRuns() {
+    return true;
+  }
+  async verifyPayload(payload) {
+    return {
+      success: true
+    };
+  }
+};
+__name(WebhookTrigger, "WebhookTrigger");
+
+// src/security.ts
+var import_crypto = __toESM(require("crypto"));
+async function verifyRequestSignature({ request, headerName, headerEncoding = "hex", 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, headerEncoding, 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, headerEncoding, secret, body) {
+  const bodyDigest = import_crypto.default.createHmac("sha256", secret).update(body).digest(headerEncoding);
+  const signature = headerValue?.replace("hmac-sha256=", "").replace("sha256=", "") ?? "";
+  return signature === bodyDigest;
+}
+__name(verifyHmacSha256, "verifyHmacSha256");
+
 // src/index.ts
 function redactString(strings, ...interpolations) {
   return {
@@ -2562,24 +4641,34 @@ __name(redactString, "redactString");
   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
+  retry,
+  slugifyId,
+  verifyHmacSha256,
+  verifyRequestSignature,
+  waitForEventSchema
 });
 //# sourceMappingURL=index.js.map