@trigger.dev/sdk 2.2.6 → 2.2.8

package/dist/index.js

@@ -70,6 +70,8 @@ __export(src_exports, {
   MissingConnectionNotification: () => MissingConnectionNotification,
   MissingConnectionResolvedNotification: () => MissingConnectionResolvedNotification,
   TriggerClient: () => TriggerClient,
+  WebhookSource: () => WebhookSource,
+  WebhookTrigger: () => WebhookTrigger,
   cronTrigger: () => cronTrigger,
   eventTrigger: () => eventTrigger,
   intervalTrigger: () => intervalTrigger,
@@ -80,6 +82,7 @@ __export(src_exports, {
   omit: () => omit,
   redactString: () => redactString,
   retry: () => retry,
+  slugifyId: () => slugifyId,
   verifyHmacSha256: () => verifyHmacSha256,
   verifyRequestSignature: () => verifyRequestSignature,
   waitForEventSchema: () => waitForEventSchema
@@ -292,1721 +295,2067 @@ 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_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 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);
+};
+
+// 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, options = {}) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Running Task", {
-      task
-    });
-    return await zodfetchWithVersions({
-      [import_core.API_VERSIONS.LAZY_LOADED_CACHED_TASKS]: import_core.RunTaskResponseWithCachedTasksBodySchema
-    }, 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,
-        "X-Cached-Tasks-Cursor": options.cachedTasksCursor ?? "",
-        "Trigger-Version": import_core.API_VERSIONS.LAZY_LOADED_CACHED_TASKS
+    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}`,
-        "Trigger-Version": import_core.API_VERSIONS.SERIALIZED_TASK_OUTPUT
+};
+__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
-      })
+      properties: __privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
+      style: {
+        style: "minimal"
+      }
     });
   }
-  async sendEvents(events, options = {}) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Sending multiple events", {
-      events
-    });
-    return await zodfetch(import_core.ApiEventLogSchema.array(), `${__privateGet(this, _apiUrl)}/api/v1/events/bulk`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        events,
-        options
-      })
-    });
-  }
-  async cancelEvent(eventId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Cancelling event", {
-      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}`
+  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.");
       }
-    });
-  }
-  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_core.CancelRunsForEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel-runs`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+      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
+      },
+      properties: [
+        ...__privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
+        ...typeof value !== "object" || value === null ? [
+          {
+            label: "value",
+            text: String(value) ?? "undefined"
+          }
+        ] : []
+      ],
+      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}`
-      },
-      body: JSON.stringify(status)
-    });
+};
+__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 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;
+  deserialize(value) {
+    return value ? JSON.parse(value) : void 0;
   }
-  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}`
+};
+__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 (idempotencyKey) {
-      headers["Idempotency-Key"] = idempotencyKey;
+    if (options.cachedTasks) {
+      options.cachedTasks.forEach((task) => {
+        this._cachedTasks.set(task.idempotencyKey, task);
+      });
+      this._stats.initialCachedTasks = options.cachedTasks.length;
     }
-    const response = await zodfetch(import_core.RegisterSourceEventSchemaV2, `${__privateGet(this, _apiUrl)}/api/v2/${client}/triggers/${id}/registrations/${key}`, {
-      method: "PUT",
-      headers,
-      body: JSON.stringify(payload)
-    });
-    return response;
+    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 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;
+  get stats() {
+    return this._stats;
   }
-  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}`
-      }
-    });
-    return response;
+  get runId() {
+    return this._id;
   }
-  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}`
-      }
-    }, {
-      optional: true
-    });
-    return response;
+  get triggerClient() {
+    return this._triggerClient;
   }
-  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}`
+  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
+        });
       }
     });
   }
-  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 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}`);
       }
-    });
-  }
-  async cancelRun(runId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Cancelling Run", {
-      runId
-    });
-    return await zodfetch(import_core.GetRunSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/cancel`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+      if (min === max) {
+        await this.logger.warn(`Lower and upper bounds are identical. The return value is not random and will always be: ${min}`);
+      }
+      const withinBounds = (max - min) * Math.random() + min;
+      if (!round) {
+        return withinBounds;
+      }
+      if (!Number.isInteger(min) || !Number.isInteger(max)) {
+        await this.logger.warn("Rounding enabled with floating-point bounds. This may cause unexpected skew and boundary inclusivity.");
+      }
+      const rounded = Math.round(withinBounds);
+      return rounded;
+    }, {
+      name: "random",
+      icon: "dice-5-filled",
+      params: {
+        min,
+        max,
+        round
+      },
+      properties: [
+        ...min === 0 ? [] : [
+          {
+            label: "min",
+            text: String(min)
+          }
+        ],
+        ...max === 1 ? [] : [
+          {
+            label: "max",
+            text: String(max)
+          }
+        ],
+        ...round === false ? [] : [
+          {
+            label: "round",
+            text: String(round)
+          }
+        ]
+      ],
+      style: {
+        style: "minimal"
       }
     });
   }
-  async 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 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 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 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 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
+  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");
       }
-    };
-    return await zodfetch(import_core.InvokeJobResponseSchema, `${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobId}/invoke`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`,
-        ...options.idempotencyKey ? {
-          "Idempotency-Key": options.idempotencyKey
-        } : {}
+      task.outputProperties = [
+        {
+          label: "Callback URL",
+          text: task.callbackUrl
+        }
+      ];
+      return callback(task.callbackUrl);
+    }, {
+      name: "Wait for Request",
+      icon: "clock",
+      callback: {
+        enabled: true,
+        timeoutInSeconds: options?.timeoutInSeconds
       },
-      body: JSON.stringify(body)
+      properties: [
+        {
+          label: "Timeout",
+          text: `${timeoutInSeconds}s`
+        }
+      ]
     });
   }
-  async createEphemeralEventDispatcher(payload) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Creating ephemeral event dispatcher", {
-      payload
-    });
-    const response = await zodfetch(import_core.EphemeralEventDispatcherResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/event-dispatchers/ephemeral`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+  async createStatus(cacheKey, initialStatus) {
+    const id = typeof cacheKey === "string" ? cacheKey : cacheKey.join("-");
+    const status = new TriggerStatus(id, this);
+    await status.update(cacheKey, initialStatus);
+    return status;
+  }
+  async backgroundFetch(cacheKey, url, requestInit, options) {
+    const urlObject = new URL(url);
+    return await this.runTask(cacheKey, async (task) => {
+      console.log("task context", task.context);
+      return task.output;
+    }, {
+      name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
+      params: {
+        url,
+        requestInit,
+        retry: options?.retry,
+        timeout: options?.timeout
       },
-      body: JSON.stringify(payload)
+      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
+      }
     });
-    return response;
   }
-};
-__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 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;
+  async backgroundPoll(cacheKey, params) {
+    const urlObject = new URL(params.url);
+    return await this.runTask(cacheKey, async (task) => {
+      return task.output;
+    }, {
+      name: `poll ${urlObject.hostname}${urlObject.pathname}`,
+      params,
+      operation: "fetch-poll",
+      icon: "clock-bolt",
+      noop: false,
+      properties: [
+        {
+          label: "url",
+          text: params.url
+        },
+        {
+          label: "interval",
+          text: `${params.interval}s`
+        },
+        {
+          label: "timeout",
+          text: `${params.timeout}s`
+        }
+      ],
+      retry: {
+        limit: 0
+      }
+    });
   }
-  if (response.status >= 400 && response.status < 500) {
-    const body = await response.json();
-    throw new Error(body.error);
+  async backgroundFetchResponse(cacheKey, url, requestInit, options) {
+    const urlObject = new URL(url);
+    return await this.runTask(cacheKey, async (task) => {
+      return task.output;
+    }, {
+      name: `fetch response ${urlObject.hostname}${urlObject.pathname}`,
+      params: {
+        url,
+        requestInit,
+        retry: options?.retry,
+        timeout: options?.timeout
+      },
+      operation: "fetch-response",
+      icon: "background",
+      noop: false,
+      properties: [
+        {
+          label: "url",
+          text: url,
+          url
+        },
+        {
+          label: "method",
+          text: requestInit?.method ?? "GET"
+        },
+        {
+          label: "background",
+          text: "true"
+        },
+        ...options?.timeout ? [
+          {
+            label: "timeout",
+            text: `${options.timeout.durationInMs}ms`
+          }
+        ] : []
+      ],
+      retry: {
+        limit: 0
+      }
+    });
   }
-  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);
+  async sendEvent(cacheKey, event, options) {
+    return await this.runTask(cacheKey, async (task) => {
+      return await this._triggerClient.sendEvent(event, options);
+    }, {
+      name: "Send Event",
+      params: {
+        event,
+        options
+      },
+      icon: "send",
+      properties: [
+        {
+          label: "name",
+          text: event.name
+        },
+        ...event?.id ? [
+          {
+            label: "ID",
+            text: event.id
+          }
+        ] : [],
+        ...sendEventOptionsProperties(options)
+      ]
+    });
   }
-  if (response.status !== 200) {
-    throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
+  async sendEvents(cacheKey, events, options) {
+    return await this.runTask(cacheKey, async (task) => {
+      return await this._triggerClient.sendEvents(events, options);
+    }, {
+      name: "Send Multiple Events",
+      params: {
+        events,
+        options
+      },
+      icon: "send",
+      properties: [
+        {
+          label: "Total Events",
+          text: String(events.length)
+        },
+        ...sendEventOptionsProperties(options)
+      ]
+    });
   }
-  const jsonBody = await response.json();
-  const version2 = response.headers.get("trigger-version");
-  if (!version2) {
-    return {
-      version: "unversioned",
-      body: unversionedSchema.parse(jsonBody)
-    };
+  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
+        }
+      ]
+    });
   }
-  const versionedSchema = versionedSchemaMap[version2];
-  if (!versionedSchema) {
-    throw new Error(`Unknown version ${version2}`);
+  async cancelEvent(cacheKey, eventId) {
+    return await this.runTask(cacheKey, async (task) => {
+      return await this._triggerClient.cancelEvent(eventId);
+    }, {
+      name: "cancelEvent",
+      params: {
+        eventId
+      },
+      properties: [
+        {
+          label: "id",
+          text: eventId
+        }
+      ]
+    });
   }
-  return {
-    version: version2,
-    body: versionedSchema.parse(jsonBody)
-  };
-}
-__name(zodfetchWithVersions, "zodfetchWithVersions");
-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;
+  async updateSource(cacheKey, options) {
+    return this.runTask(cacheKey, async (task) => {
+      return await this._apiClient.updateSource(this._triggerClient.id, options.key, options);
+    }, {
+      name: "Update Source",
+      description: "Update Source",
+      properties: [
+        {
+          label: "key",
+          text: options.key
+        }
+      ],
+      params: options,
+      redact: {
+        paths: [
+          "secret"
+        ]
+      }
+    });
   }
-  if (response.status >= 400 && response.status < 500) {
-    const body = await response.json();
-    throw new Error(body.error);
+  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
+    });
   }
-  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);
+  async registerInterval(cacheKey, dynamicSchedule, id, options) {
+    return await this.runTask(cacheKey, async (task) => {
+      return dynamicSchedule.register(id, {
+        type: "interval",
+        options
+      });
+    }, {
+      name: "register-interval",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        },
+        {
+          label: "seconds",
+          text: options.seconds.toString()
+        }
+      ],
+      params: options
+    });
   }
-  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/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;
+  async unregisterInterval(cacheKey, dynamicSchedule, id) {
+    return await this.runTask(cacheKey, async (task) => {
+      return dynamicSchedule.unregister(id);
+    }, {
+      name: "unregister-interval",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        }
+      ]
+    });
   }
-};
-__name(ErrorWithTask, "ErrorWithTask");
-
-// src/httpEndpoint.ts
-var import_core2 = require("@trigger.dev/core");
-
-// src/utils/formatSchemaErrors.ts
-function formatSchemaErrors(errors) {
-  return errors.map((error) => {
-    const { path, message } = error;
-    return {
-      path: path.map(String),
-      message
-    };
-  });
-}
-__name(formatSchemaErrors, "formatSchemaErrors");
-
-// src/httpEndpoint.ts
-var HttpEndpoint = class {
-  constructor(options) {
-    this.options = options;
+  async registerCron(cacheKey, dynamicSchedule, id, options) {
+    return await this.runTask(cacheKey, async (task) => {
+      return dynamicSchedule.register(id, {
+        type: "cron",
+        options
+      });
+    }, {
+      name: "register-cron",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        },
+        {
+          label: "cron",
+          text: options.cron
+        }
+      ],
+      params: options
+    });
   }
-  get id() {
-    return this.options.id;
+  async unregisterCron(cacheKey, dynamicSchedule, id) {
+    return await this.runTask(cacheKey, async (task) => {
+      return dynamicSchedule.unregister(id);
+    }, {
+      name: "unregister-cron",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        }
+      ]
+    });
   }
-  onRequest(options) {
-    return new HttpTrigger({
-      endpointId: this.id,
-      event: this.options.event,
-      filter: options?.filter,
-      verify: this.options.verify
+  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);
+      }, {
+        name: "register-source"
+      });
+      return {
+        id: registration.id,
+        key: registration.source.key
+      };
+    }, {
+      name: "register-trigger",
+      properties: [
+        {
+          label: "trigger",
+          text: trigger.id
+        },
+        {
+          label: "id",
+          text: id
+        }
+      ],
+      params
     });
   }
-  async handleRequest(request) {
-    if (!this.options.respondWith)
+  async getAuth(cacheKey, clientId) {
+    if (!clientId) {
       return;
-    return this.options.respondWith.handler(request, () => {
-      const clonedRequest = request.clone();
-      return this.options.verify(clonedRequest);
+    }
+    return this.runTask(cacheKey, async (task) => {
+      return await this._triggerClient.getAuth(clientId);
+    }, {
+      name: "get-auth"
     });
   }
-  toJSON() {
-    return {
-      id: this.id,
-      icon: this.options.event.icon,
-      version: "1",
-      enabled: this.options.enabled ?? true,
-      event: this.options.event,
-      immediateResponseFilter: this.options.respondWith?.filter,
-      skipTriggeringRuns: this.options.respondWith?.skipTriggeringRuns,
-      source: this.options.event.source
-    };
-  }
-};
-__name(HttpEndpoint, "HttpEndpoint");
-var HttpTrigger = /* @__PURE__ */ __name(class HttpTrigger2 {
-  constructor(options) {
-    this.options = options;
+  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;
   }
-  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}`
-        }
+  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,
+        cacheKey,
+        options
+      });
+    }
+    const idempotencyKey = await generateIdempotencyKey([
+      this._id,
+      parentId ?? "",
+      cacheKey
+    ].flat());
+    if (this._visitedCacheKeys.has(idempotencyKey)) {
+      if (typeof cacheKey === "string") {
+        throw new Error(`Task with cacheKey "${cacheKey}" has already been executed in this run. Each task must have a unique cacheKey.`);
+      } else {
+        throw new Error(`Task with cacheKey "${cacheKey.join("-")}" has already been executed in this run. Each task must have a unique cacheKey.`);
       }
+    }
+    this._visitedCacheKeys.add(idempotencyKey);
+    const cachedTask = this._cachedTasks.get(idempotencyKey);
+    if (cachedTask && cachedTask.status === "COMPLETED") {
+      this._logger.debug("Using completed cached task", {
+        idempotencyKey
+      });
+      this._stats.cachedTaskHits++;
+      return 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 runOptions = {
+      ...options ?? {},
+      parseOutput: void 0
     };
-  }
-  get event() {
-    return this.options.event;
-  }
-  attachToJob(triggerClient, job) {
-  }
-  get preprocessRuns() {
-    return false;
-  }
-  async verifyPayload(payload) {
-    const clonedRequest = payload.clone();
-    return this.options.verify(clonedRequest);
-  }
-}, "HttpTrigger");
-function httpEndpoint(options) {
-  const id = slugifyId(options.id);
-  return new HttpEndpoint({
-    id,
-    enabled: options.enabled,
-    respondWith: options.respondWith,
-    verify: options.verify,
-    event: {
-      name: id,
-      title: options.title ?? "HTTP Trigger",
-      source: options.source,
-      icon: options.icon ?? "webhook",
-      properties: options.properties,
-      examples: options.examples ? options.examples : [
-        {
-          id: "basic-request",
-          name: "Basic Request",
-          icon: "http-post",
-          payload: {
-            url: "https://cloud.trigger.dev",
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json"
-            },
-            rawBody: JSON.stringify({
-              foo: "bar"
-            })
-          }
-        }
-      ],
-      parsePayload: (rawPayload) => {
-        const result = import_core2.RequestWithRawBodySchema.safeParse(rawPayload);
-        if (!result.success) {
-          throw new ParsedPayloadSchemaError(formatSchemaErrors(result.error.issues));
+    const response = await this._apiClient.runTask(this._id, {
+      idempotencyKey,
+      displayKey: typeof cacheKey === "string" ? cacheKey : void 0,
+      noop: false,
+      ...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++;
         }
-        return new Request(new URL(result.data.url), {
-          method: result.data.method,
-          headers: result.data.headers,
-          body: result.data.rawBody
+      }
+    }
+    if (task.status === "CANCELED") {
+      this._logger.debug("Task canceled", {
+        idempotencyKey,
+        task
+      });
+      throw new CanceledWithTaskError(task);
+    }
+    if (task.status === "COMPLETED") {
+      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;
     }
-  });
-}
-__name(httpEndpoint, "httpEndpoint");
-
-// src/io.ts
-var import_core4 = 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/retry.ts
-var import_core3 = require("@trigger.dev/core");
-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
-  }
-};
-
-// 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 (task.status === "ERRORED") {
+      this._logger.debug("Task errored", {
+        idempotencyKey,
+        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);
+        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,
+          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);
+        }
+        __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;
+        }
+        let skipRetrying = false;
+        if (onError) {
+          try {
+            const onErrorResult = onError(error, task, this);
+            if (onErrorResult) {
+              if (onErrorResult instanceof Error) {
+                error = onErrorResult;
+              } else {
+                skipRetrying = !!onErrorResult.skipRetrying;
+                if (onErrorResult.retryAt && !skipRetrying) {
+                  const parsedError2 = import_core2.ErrorWithStackSchema.safeParse(onErrorResult.error);
+                  throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
+                    message: "Unknown error"
+                  }, task, onErrorResult.retryAt);
+                }
+              }
+            }
+          } catch (innerError) {
+            if (isTriggerError(innerError)) {
+              throw innerError;
+            }
+            error = innerError;
+          }
+        }
+        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_core.calculateRetryAt)(options.retry, task.attempts - 1);
+          if (retryAt) {
+            throw new RetryWithTaskError(parsedError.success ? parsedError.data : {
+              message: "Unknown error"
+            }, task, retryAt);
+          }
+        }
+        if (parsedError.success) {
+          await this._apiClient.failTask(this._id, task.id, {
+            error: parsedError.data
+          });
+        } else {
+          const message = typeof error === "string" ? error : JSON.stringify(error);
+          await this._apiClient.failTask(this._id, task.id, {
+            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 (status.state) {
-      properties.push({
-        label: "State",
-        text: status.state
+    if (task.status === "RUNNING" && typeof task.operation === "string") {
+      this._logger.debug("Task running operation", {
+        idempotencyKey,
+        task
       });
+      throw new ResumeWithTaskError(task);
     }
-    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
-      },
-      properties
-    });
+    return this._taskStorage.run({
+      taskId: task.id
+    }, executeTask);
   }
-};
-__name(TriggerStatus, "TriggerStatus");
-
-// src/types.ts
-var import_zod2 = require("zod");
-var EventSpecificationExampleSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  name: import_zod2.z.string(),
-  icon: import_zod2.z.string().optional(),
-  payload: import_zod2.z.any()
-});
-function waitForEventSchema(schema) {
-  return import_zod2.z.object({
-    id: import_zod2.z.string(),
-    name: import_zod2.z.string(),
-    source: import_zod2.z.string(),
-    payload: schema,
-    timestamp: import_zod2.z.coerce.date(),
-    context: import_zod2.z.any().optional(),
-    accountId: import_zod2.z.string().optional()
-  });
-}
-__name(waitForEventSchema, "waitForEventSchema");
-
-// src/io.ts
-var import_zod3 = require("zod");
-var JSONOutputSerializer = class {
-  serialize(value) {
-    return JSON.stringify(value);
+  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);
   }
-  deserialize(value) {
-    return value ? JSON.parse(value) : void 0;
+  async try(tryCallback, catchCallback) {
+    try {
+      return await tryCallback();
+    } catch (error) {
+      if (isTriggerError(error)) {
+        throw error;
+      }
+      return await catchCallback(error);
+    }
   }
-};
-__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._apiClient = options.apiClient;
-    this._triggerClient = options.client;
-    this._logger = options.logger ?? new import_core4.Logger("trigger.dev", options.logLevel);
-    this._cachedTasks = /* @__PURE__ */ new Map();
-    this._jobLogger = options.jobLogger;
-    this._jobLogLevel = options.jobLogLevel;
-    this._timeOrigin = options.timeOrigin;
-    this._executionTimeout = options.executionTimeout;
-    this._stats = {
-      initialCachedTasks: 0,
-      lazyLoadedCachedTasks: 0,
-      executedTasks: 0,
-      cachedTaskHits: 0,
-      cachedTaskMisses: 0,
-      noopCachedTaskHits: 0,
-      noopCachedTaskMisses: 0
+  get store() {
+    return {
+      env: this._envStore,
+      job: this._jobStore,
+      run: this._runStore
     };
-    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);
+  }
+};
+__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));
     }
-    this._cachedTasksCursor = options.cachedTasksCursor;
-    this._serverVersion = options.serverVersion ?? "unversioned";
   }
-  get stats() {
-    return this._stats;
+}, "#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));
   }
-  get runId() {
-    return this._id;
+}, "#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);
   }
-  get triggerClient() {
-    return this._triggerClient;
+  return void 0;
+}, "#getRemainingTimeInMillis");
+async function generateIdempotencyKey(keyMaterial) {
+  const keys = keyMaterial.map((key2) => {
+    if (typeof key2 === "string") {
+      return key2;
+    }
+    return stableStringify(key2);
+  });
+  const key = keys.join(":");
+  const hash = await import_node_crypto.webcrypto.subtle.digest("SHA-256", Buffer.from(key));
+  return Buffer.from(hash).toString("hex");
+}
+__name(generateIdempotencyKey, "generateIdempotencyKey");
+function stableStringify(obj) {
+  function sortKeys(obj2) {
+    if (typeof obj2 !== "object" || obj2 === null) {
+      return obj2;
+    }
+    if (Array.isArray(obj2)) {
+      return obj2.map(sortKeys);
+    }
+    const sortedKeys = Object.keys(obj2).sort();
+    const sortedObj2 = {};
+    for (const key of sortedKeys) {
+      sortedObj2[key] = sortKeys(obj2[key]);
+    }
+    return sortedObj2;
   }
-  get logger() {
-    return new IOLogger(async (level, message, data) => {
-      let logLevel = "info";
-      if (import_core4.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
-        });
-      }
-    });
+  __name(sortKeys, "sortKeys");
+  const sortedObj = sortKeys(obj);
+  return JSON.stringify(sortedObj);
+}
+__name(stableStringify, "stableStringify");
+var IOLogger = class {
+  constructor(callback) {
+    this.callback = callback;
   }
-  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;
+  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
       }
-      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.");
+    ] : [],
+    ...options?.deliverAfter ? [
+      {
+        label: "Deliver After",
+        text: `${options.deliverAfter}s`
       }
-      const rounded = Math.round(withinBounds);
-      return rounded;
-    }, {
-      name: "random",
-      icon: "dice-5-filled",
-      params: {
-        min,
-        max,
-        round
-      },
-      properties: [
-        ...min === 0 ? [] : [
-          {
-            label: "min",
-            text: String(min)
-          }
-        ],
-        ...max === 1 ? [] : [
-          {
-            label: "max",
-            text: String(max)
-          }
-        ],
-        ...round === false ? [] : [
-          {
-            label: "round",
-            text: String(round)
-          }
-        ]
-      ],
-      style: {
-        style: "minimal"
+    ] : [],
+    ...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 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 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 waitForEvent(cacheKey, event, options) {
-    const timeoutInSeconds = options?.timeoutInSeconds ?? 60 * 60;
-    return await this.runTask(cacheKey, async (task, io) => {
-      if (!task.callbackUrl) {
-        throw new Error("No callbackUrl found on task");
-      }
-      await this.triggerClient.createEphemeralEventDispatcher({
-        url: task.callbackUrl,
-        name: event.name,
-        filter: event.filter,
-        contextFilter: event.contextFilter,
-        source: event.source,
-        accountId: event.accountId,
-        timeoutInSeconds
-      });
-      return {};
-    }, {
-      name: "Wait for Event",
-      icon: "custom-event",
-      params: {
-        name: event.name,
-        source: event.source,
-        filter: event.filter,
-        contextFilter: event.contextFilter,
-        accountId: event.accountId
-      },
-      callback: {
-        enabled: true,
-        timeoutInSeconds
-      },
-      properties: [
-        {
-          label: "Event",
-          text: event.name
-        },
-        {
-          label: "Timeout",
-          text: `${timeoutInSeconds}s`
-        },
-        ...event.source ? [
-          {
-            label: "Source",
-            text: event.source
-          }
-        ] : [],
-        ...event.accountId ? [
-          {
-            label: "Account ID",
-            text: event.accountId
-          }
-        ] : []
-      ],
-      parseOutput: (output) => {
-        return waitForEventSchema(event.schema ?? import_zod3.z.any()).parse(output);
-      }
+  async 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 waitForRequest(cacheKey, callback, options) {
-    const timeoutInSeconds = options?.timeoutInSeconds ?? 60 * 60;
-    return await this.runTask(cacheKey, async (task, io) => {
-      if (!task.callbackUrl) {
-        throw new Error("No callbackUrl found on task");
-      }
-      task.outputProperties = [
-        {
-          label: "Callback URL",
-          text: task.callbackUrl
-        }
-      ];
-      return callback(task.callbackUrl);
-    }, {
-      name: "Wait for Request",
-      icon: "clock",
-      callback: {
-        enabled: true,
-        timeoutInSeconds: options?.timeoutInSeconds
-      },
-      properties: [
-        {
-          label: "Timeout",
-          text: `${timeoutInSeconds}s`
-        }
-      ]
+  async 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);
   }
-  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;
+};
+__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 backgroundFetch(cacheKey, url, requestInit, options) {
-    const urlObject = new URL(url);
-    return await this.runTask(cacheKey, async (task) => {
-      console.log("task context", task.context);
-      return task.output;
-    }, {
-      name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
-      params: {
-        url,
-        requestInit,
-        retry: options?.retry,
-        timeout: options?.timeout
-      },
-      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 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 backgroundPoll(cacheKey, params) {
-    const urlObject = new URL(params.url);
-    return await this.runTask(cacheKey, async (task) => {
-      return task.output;
-    }, {
-      name: `poll ${urlObject.hostname}${urlObject.pathname}`,
-      params,
-      operation: "fetch-poll",
-      icon: "clock-bolt",
-      noop: false,
-      properties: [
-        {
-          label: "url",
-          text: params.url
-        },
-        {
-          label: "interval",
-          text: `${params.interval}s`
-        },
-        {
-          label: "timeout",
-          text: `${params.timeout}s`
-        }
-      ],
-      retry: {
-        limit: 0
-      }
+  async runTask(runId, task, options = {}) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Running Task", {
+      task
     });
-  }
-  async backgroundFetchResponse(cacheKey, url, requestInit, options) {
-    const urlObject = new URL(url);
-    return await this.runTask(cacheKey, async (task) => {
-      return task.output;
-    }, {
-      name: `fetch response ${urlObject.hostname}${urlObject.pathname}`,
-      params: {
-        url,
-        requestInit,
-        retry: options?.retry,
-        timeout: options?.timeout
+    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
       },
-      operation: "fetch-response",
-      icon: "background",
-      noop: false,
-      properties: [
-        {
-          label: "url",
-          text: url,
-          url
-        },
-        {
-          label: "method",
-          text: requestInit?.method ?? "GET"
-        },
-        {
-          label: "background",
-          text: "true"
-        },
-        ...options?.timeout ? [
-          {
-            label: "timeout",
-            text: `${options.timeout.durationInMs}ms`
-          }
-        ] : []
-      ],
-      retry: {
-        limit: 0
-      }
+      body: JSON.stringify(task)
     });
   }
-  async sendEvent(cacheKey, event, options) {
-    return await this.runTask(cacheKey, async (task) => {
-      return await this._triggerClient.sendEvent(event, options);
-    }, {
-      name: "sendEvent",
-      params: {
-        event,
-        options
+  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
       },
-      properties: [
-        {
-          label: "name",
-          text: event.name
-        },
-        ...event?.id ? [
-          {
-            label: "ID",
-            text: event.id
-          }
-        ] : [],
-        ...sendEventOptionsProperties(options)
-      ]
+      body: JSON.stringify(task)
     });
   }
-  async sendEvents(cacheKey, events, options) {
-    return await this.runTask(cacheKey, async (task) => {
-      return await this._triggerClient.sendEvents(events, options);
-    }, {
-      name: "sendEvents",
-      params: {
-        events,
-        options
+  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}`
       },
-      properties: [
-        {
-          label: "Total Events",
-          text: String(events.length)
-        },
-        ...sendEventOptionsProperties(options)
-      ]
+      body: JSON.stringify(body)
     });
   }
-  async getEvent(cacheKey, id) {
-    return await this.runTask(cacheKey, async (task) => {
-      return await this._triggerClient.getEvent(id);
-    }, {
-      name: "getEvent",
-      params: {
-        id
+  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}`
       },
-      properties: [
-        {
-          label: "id",
-          text: id
-        }
-      ]
+      body: JSON.stringify({
+        event,
+        options
+      })
     });
   }
-  async cancelEvent(cacheKey, eventId) {
-    return await this.runTask(cacheKey, async (task) => {
-      return await this._triggerClient.cancelEvent(eventId);
-    }, {
-      name: "cancelEvent",
-      params: {
-        eventId
+  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}`
       },
-      properties: [
-        {
-          label: "id",
-          text: eventId
-        }
-      ]
+      body: JSON.stringify({
+        events,
+        options
+      })
     });
   }
-  async updateSource(cacheKey, options) {
-    return this.runTask(cacheKey, async (task) => {
-      return await this._apiClient.updateSource(this._triggerClient.id, options.key, options);
-    }, {
-      name: "Update Source",
-      description: "Update Source",
-      properties: [
-        {
-          label: "key",
-          text: options.key
-        }
-      ],
-      params: options,
-      redact: {
-        paths: [
-          "secret"
-        ]
+  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 registerInterval(cacheKey, dynamicSchedule, id, options) {
-    return await this.runTask(cacheKey, async (task) => {
-      return dynamicSchedule.register(id, {
-        type: "interval",
-        options
-      });
-    }, {
-      name: "register-interval",
-      properties: [
-        {
-          label: "schedule",
-          text: dynamicSchedule.id
-        },
-        {
-          label: "id",
-          text: id
-        },
-        {
-          label: "seconds",
-          text: options.seconds.toString()
-        }
-      ],
-      params: options
+  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 unregisterInterval(cacheKey, dynamicSchedule, id) {
-    return await this.runTask(cacheKey, async (task) => {
-      return dynamicSchedule.unregister(id);
-    }, {
-      name: "unregister-interval",
-      properties: [
-        {
-          label: "schedule",
-          text: dynamicSchedule.id
-        },
-        {
-          label: "id",
-          text: id
-        }
-      ]
+  async updateStatus(runId, id, status) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Update status", {
+      id,
+      status
     });
-  }
-  async registerCron(cacheKey, dynamicSchedule, id, options) {
-    return await this.runTask(cacheKey, async (task) => {
-      return dynamicSchedule.register(id, {
-        type: "cron",
-        options
-      });
-    }, {
-      name: "register-cron",
-      properties: [
-        {
-          label: "schedule",
-          text: dynamicSchedule.id
-        },
-        {
-          label: "id",
-          text: id
-        },
-        {
-          label: "cron",
-          text: options.cron
-        }
-      ],
-      params: options
+    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 unregisterCron(cacheKey, dynamicSchedule, id) {
-    return await this.runTask(cacheKey, async (task) => {
-      return dynamicSchedule.unregister(id);
-    }, {
-      name: "unregister-cron",
-      properties: [
-        {
-          label: "schedule",
-          text: dynamicSchedule.id
-        },
-        {
-          label: "id",
-          text: id
-        }
-      ]
+  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 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);
-      }, {
-        name: "register-source"
-      });
-      return {
-        id: registration.id,
-        key: registration.source.key
-      };
-    }, {
-      name: "register-trigger",
-      properties: [
-        {
-          label: "trigger",
-          text: trigger.id
-        },
-        {
-          label: "id",
-          text: id
-        }
-      ],
-      params
+  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 getAuth(cacheKey, clientId) {
-    if (!clientId) {
-      return;
+  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;
     }
-    return this.runTask(cacheKey, async (task) => {
-      return await this._triggerClient.getAuth(clientId);
-    }, {
-      name: "get-auth"
+    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 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);
+  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}`
       }
-      const nonInternalErrors = outcomes.filter((outcome) => outcome.status === "rejected" && !isTriggerError(outcome.reason)).map((outcome) => outcome);
-      if (nonInternalErrors.length > 0) {
-        throw nonInternalErrors[0].reason;
+    });
+    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}`
       }
-      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 ?? {}
+      optional: true
     });
-    return results;
+    return response;
   }
-  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,
-        cacheKey,
-        options
-      });
-    }
-    const idempotencyKey = await generateIdempotencyKey([
-      this._id,
-      parentId ?? "",
-      cacheKey
-    ].flat());
-    if (this._visitedCacheKeys.has(idempotencyKey)) {
-      if (typeof cacheKey === "string") {
-        throw new Error(`Task with cacheKey "${cacheKey}" has already been executed in this run. Each task must have a unique cacheKey.`);
-      } else {
-        throw new Error(`Task with cacheKey "${cacheKey.join("-")}" has already been executed in this run. Each task must have a unique cacheKey.`);
-      }
-    }
-    this._visitedCacheKeys.add(idempotencyKey);
-    const cachedTask = this._cachedTasks.get(idempotencyKey);
-    if (cachedTask && cachedTask.status === "COMPLETED") {
-      this._logger.debug("Using completed cached task", {
-        idempotencyKey
-      });
-      this._stats.cachedTaskHits++;
-      return 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 {};
+  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}`
       }
-    }
-    const runOptions = {
-      ...options ?? {},
-      parseOutput: void 0
-    };
-    const response = await this._apiClient.runTask(this._id, {
-      idempotencyKey,
-      displayKey: typeof cacheKey === "string" ? cacheKey : void 0,
-      noop: false,
-      ...runOptions ?? {},
-      parentId
-    }, {
-      cachedTasksCursor: this._cachedTasksCursor
     });
-    const task = response.version === import_core4.API_VERSIONS.LAZY_LOADED_CACHED_TASKS ? response.body.task : response.body;
-    if (task.forceYield) {
-      this._logger.debug("Forcing yield after run task", {
-        idempotencyKey
-      });
-      __privateMethod(this, _forceYield, forceYield_fn).call(this, "after_run_task");
-    }
-    if (response.version === import_core4.API_VERSIONS.LAZY_LOADED_CACHED_TASKS) {
-      this._cachedTasksCursor = response.body.cachedTasks?.cursor;
-      for (const cachedTask2 of response.body.cachedTasks?.tasks ?? []) {
-        if (!this._cachedTasks.has(cachedTask2.idempotencyKey)) {
-          this._cachedTasks.set(cachedTask2.idempotencyKey, cachedTask2);
-          this._logger.debug("Injecting lazy loaded task into task cache", {
-            idempotencyKey: cachedTask2.idempotencyKey
-          });
-          this._stats.lazyLoadedCachedTasks++;
-        }
+  }
+  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}`
       }
-    }
-    if (task.status === "CANCELED") {
-      this._logger.debug("Task canceled", {
-        idempotencyKey,
-        task
-      });
-      throw new CanceledWithTaskError(task);
-    }
-    if (task.status === "COMPLETED") {
-      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);
+    });
+  }
+  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}`
       }
-      return options?.parseOutput ? options.parseOutput(task.output) : task.output;
-    }
-    if (task.status === "ERRORED") {
-      this._logger.debug("Task errored", {
-        idempotencyKey,
-        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);
-        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,
-          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);
-        }
-        __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;
-        }
-        let skipRetrying = false;
-        if (onError) {
-          try {
-            const onErrorResult = onError(error, task, this);
-            if (onErrorResult) {
-              if (onErrorResult instanceof Error) {
-                error = onErrorResult;
-              } else {
-                skipRetrying = !!onErrorResult.skipRetrying;
-                if (onErrorResult.retryAt && !skipRetrying) {
-                  const parsedError2 = import_core4.ErrorWithStackSchema.safeParse(onErrorResult.error);
-                  throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
-                    message: "Unknown error"
-                  }, task, onErrorResult.retryAt);
-                }
-              }
-            }
-          } catch (innerError) {
-            if (isTriggerError(innerError)) {
-              throw innerError;
-            }
-            error = innerError;
-          }
-        }
-        if (error instanceof ErrorWithTask) {
-          await this._apiClient.failTask(this._id, task.id, {
-            error: error.cause.output
-          });
-        }
-        const parsedError = import_core4.ErrorWithStackSchema.safeParse(error);
-        if (options?.retry && !skipRetrying) {
-          const retryAt = (0, import_core3.calculateRetryAt)(options.retry, task.attempts - 1);
-          if (retryAt) {
-            throw new RetryWithTaskError(parsedError.success ? parsedError.data : {
-              message: "Unknown error"
-            }, task, retryAt);
-          }
-        }
-        if (parsedError.success) {
-          await this._apiClient.failTask(this._id, task.id, {
-            error: parsedError.data
-          });
-        } else {
-          const message = typeof error === "string" ? error : JSON.stringify(error);
-          await this._apiClient.failTask(this._id, task.id, {
-            error: {
-              name: "Unknown error",
-              message
-            }
-          });
-        }
-        throw error;
+    });
+  }
+  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}`
       }
-    }, "executeTask");
-    if (task.status === "WAITING") {
-      this._logger.debug("Task waiting", {
-        idempotencyKey,
-        task
-      });
-      if (task.callbackUrl) {
-        await this._taskStorage.run({
-          taskId: task.id
-        }, executeTask);
+    });
+  }
+  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
       }
-      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);
+    };
+    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)
+    });
   }
-  yield(cacheKey) {
-    if (!(0, import_core4.supportsFeature)("yieldExecution", this._serverVersion)) {
-      console.warn("[trigger.dev] io.yield() is not support by the version of the Trigger.dev server you are using, you will need to upgrade your self-hosted Trigger.dev instance.");
-      return;
+  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 STORE_URL = `${__privateGet(this, _apiUrl)}/api/v1/store/${data.key}`;
+  const authHeader = {
+    Authorization: `Bearer ${apiKey}`
+  };
+  let requestInit;
+  switch (action) {
+    case "DELETE": {
+      requestInit = {
+        method: "DELETE",
+        headers: authHeader
+      };
+      break;
     }
-    if (this._yieldedExecutions.includes(cacheKey)) {
-      return;
+    case "GET": {
+      requestInit = {
+        method: "GET",
+        headers: authHeader
+      };
+      break;
     }
-    throw new YieldExecutionError(cacheKey);
-  }
-  async try(tryCallback, catchCallback) {
-    try {
-      return await tryCallback();
-    } catch (error) {
-      if (isTriggerError(error)) {
-        throw error;
+    case "HAS": {
+      const headResponse = await fetchHead(STORE_URL, {
+        headers: authHeader
+      });
+      return {
+        action: "HAS",
+        key: data.key,
+        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`);
       }
-      return await catchCallback(error);
+      requestInit = {
+        method: "PUT",
+        headers: {
+          ...authHeader,
+          "Content-Type": "text/plain"
+        },
+        body: data.value
+      };
+      break;
     }
-  }
-};
-__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));
+    default: {
+      (0, import_core3.assertExhaustive)(action);
     }
   }
-}, "#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));
+  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");
   }
-}, "#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 apiKey.apiKey;
+}, "#apiKey");
+function getApiKey(key) {
+  const apiKey = key ?? process.env.TRIGGER_API_KEY;
+  if (!apiKey) {
+    return {
+      status: "missing"
+    };
   }
-  return void 0;
-}, "#getRemainingTimeInMillis");
-async function generateIdempotencyKey(keyMaterial) {
-  const keys = keyMaterial.map((key2) => {
-    if (typeof key2 === "string") {
-      return key2;
-    }
-    return stableStringify(key2);
+  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"
   });
-  const key = keys.join(":");
-  const hash = await import_node_crypto.webcrypto.subtle.digest("SHA-256", Buffer.from(key));
-  return Buffer.from(hash).toString("hex");
+  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(generateIdempotencyKey, "generateIdempotencyKey");
-function stableStringify(obj) {
-  function sortKeys(obj2) {
-    if (typeof obj2 !== "object" || obj2 === null) {
-      return obj2;
-    }
-    if (Array.isArray(obj2)) {
-      return obj2.map(sortKeys);
-    }
-    const sortedKeys = Object.keys(obj2).sort();
-    const sortedObj2 = {};
-    for (const key of sortedKeys) {
-      sortedObj2[key] = sortKeys(obj2[key]);
-    }
-    return sortedObj2;
+__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);
   }
-  __name(sortKeys, "sortKeys");
-  const sortedObj = sortKeys(obj);
-  return JSON.stringify(sortedObj);
+  return response;
 }
-__name(stableStringify, "stableStringify");
-var IOLogger = class {
-  constructor(callback) {
-    this.callback = callback;
+__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;
   }
-  log(message, properties) {
-    return this.callback("LOG", message, properties);
+  if (response.status >= 400 && response.status < 500) {
+    const body = await response.json();
+    throw new Error(body.error);
   }
-  debug(message, properties) {
-    return this.callback("DEBUG", message, properties);
+  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);
   }
-  info(message, properties) {
-    return this.callback("INFO", message, properties);
+  if (response.status !== 200) {
+    throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
   }
-  warn(message, properties) {
-    return this.callback("WARN", message, properties);
+  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;
   }
-  error(message, properties) {
-    return this.callback("ERROR", message, properties);
+  get id() {
+    return this.options.id;
+  }
+  onRequest(options) {
+    return new HttpTrigger({
+      endpointId: this.id,
+      event: this.options.event,
+      filter: options?.filter,
+      verify: this.options.verify
+    });
+  }
+  async handleRequest(request) {
+    if (!this.options.respondWith)
+      return;
+    return this.options.respondWith.handler(request, () => {
+      const clonedRequest = request.clone();
+      return this.options.verify(clonedRequest);
+    });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      icon: this.options.event.icon,
+      version: "1",
+      enabled: this.options.enabled ?? true,
+      event: this.options.event,
+      immediateResponseFilter: this.options.respondWith?.filter,
+      skipTriggeringRuns: this.options.respondWith?.skipTriggeringRuns,
+      source: this.options.event.source
+    };
   }
 };
-__name(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`
+__name(HttpEndpoint, "HttpEndpoint");
+var HttpTrigger = /* @__PURE__ */ __name(class HttpTrigger2 {
+  constructor(options) {
+    this.options = options;
+  }
+  toJSON() {
+    return {
+      type: "static",
+      title: this.options.endpointId,
+      properties: this.options.event.properties,
+      rule: {
+        event: `httpendpoint.${this.options.endpointId}`,
+        payload: this.options.filter ?? {},
+        source: this.options.event.source
+      },
+      link: `http-endpoints/${this.options.endpointId}`,
+      help: {
+        noRuns: {
+          text: "To start triggering runs click here to setup your HTTP Endpoint with the external API service you want to receive webhooks from.",
+          link: `http-endpoints/${this.options.endpointId}`
+        }
       }
-    ] : [],
-    ...options?.deliverAt ? [
-      {
-        label: "Deliver At",
-        text: options.deliverAt.toISOString()
+    };
+  }
+  get event() {
+    return this.options.event;
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  async verifyPayload(payload) {
+    const clonedRequest = payload.clone();
+    return this.options.verify(clonedRequest);
+  }
+}, "HttpTrigger");
+function httpEndpoint(options) {
+  const id = slugifyId(options.id);
+  return new HttpEndpoint({
+    id,
+    enabled: options.enabled,
+    respondWith: options.respondWith,
+    verify: options.verify,
+    event: {
+      name: id,
+      title: options.title ?? "HTTP Trigger",
+      source: options.source,
+      icon: options.icon ?? "webhook",
+      properties: options.properties,
+      examples: options.examples ? options.examples : [
+        {
+          id: "basic-request",
+          name: "Basic Request",
+          icon: "http-post",
+          payload: {
+            url: "https://cloud.trigger.dev",
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            rawBody: JSON.stringify({
+              foo: "bar"
+            })
+          }
+        }
+      ],
+      parsePayload: (rawPayload) => {
+        const result = import_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(sendEventOptionsProperties, "sendEventOptionsProperties");
+__name(httpEndpoint, "httpEndpoint");
 
 // src/ioWithIntegrations.ts
 function createIOWithIntegrations(io, auths, integrations) {
@@ -2158,6 +2507,12 @@ var EventTrigger = class {
     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
     };
@@ -2397,10 +2752,20 @@ var DynamicSchedule = class {
 };
 __name(DynamicSchedule, "DynamicSchedule");
 
+// src/triggerClient.ts
+var import_node_events = __toESM(require("events"));
+
 // package.json
-var version = "2.2.6";
+var version = "2.2.8";
 
 // 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_core8.REGISTER_SOURCE_EVENT_V2,
   title: "Register Source",
@@ -2408,7 +2773,7 @@ var registerSourceEvent = {
   icon: "register-source",
   parsePayload: import_core8.RegisterSourceEventSchemaV2.parse
 };
-var _options4, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _registeredHttpEndpoints, _authResolvers, _client2, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn, _handleHttpEndpointRequestForResponse, handleHttpEndpointRequestForResponse_fn, _resolveConnections, resolveConnections_fn, _resolveConnection, resolveConnection_fn, _buildJobsIndex, buildJobsIndex_fn, _buildJobIndex, buildJobIndex_fn, _buildJobIntegrations, buildJobIntegrations_fn, _buildJobIntegration, buildJobIntegration_fn, _logIOStats, logIOStats_fn, _standardResponseHeaders, standardResponseHeaders_fn;
+var _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);
@@ -2418,6 +2783,7 @@ var TriggerClient = class {
     __privateAdd(this, _createPreprocessRunContext);
     __privateAdd(this, _handleHttpSourceRequest);
     __privateAdd(this, _handleHttpEndpointRequestForResponse);
+    __privateAdd(this, _handleWebhookRequest);
     __privateAdd(this, _resolveConnections);
     __privateAdd(this, _resolveConnection);
     __privateAdd(this, _buildJobsIndex);
@@ -2426,17 +2792,25 @@ var TriggerClient = class {
     __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)));
@@ -2444,6 +2818,7 @@ var TriggerClient = class {
       "output",
       "noopTasksSet"
     ]));
+    __privateSet(this, _envStore, new KeyValueStore(__privateGet(this, _client2)));
   }
   async handleRequest(request, timeOrigin = performance.now()) {
     __privateGet(this, _internalLogger).debug("handling request", {
@@ -2540,6 +2915,7 @@ var TriggerClient = class {
         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] ?? [],
@@ -2613,10 +2989,12 @@ var TriggerClient = class {
           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,
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
+          headers: standardHeaders
         };
       }
       case "PREPROCESS_RUN": {
@@ -2732,6 +3110,48 @@ var TriggerClient = class {
           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": {
         return {
           status: 200,
@@ -2754,6 +3174,22 @@ var TriggerClient = class {
           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)
+        };
+      }
     }
     return {
       status: 405,
@@ -2780,9 +3216,9 @@ var TriggerClient = class {
   defineDynamicTrigger(options) {
     return new DynamicTrigger(this, options);
   }
-  defineHttpEndpoint(options) {
+  defineHttpEndpoint(options, suppressWarnings = false) {
     const existingHttpEndpoint = __privateGet(this, _registeredHttpEndpoints)[options.id];
-    if (existingHttpEndpoint) {
+    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);
@@ -2903,6 +3339,94 @@ var TriggerClient = class {
     });
     __privateGet(this, _registeredSchedules)[key] = jobs;
   }
+  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);
   }
@@ -2951,6 +3475,11 @@ var TriggerClient = class {
   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";
@@ -2969,12 +3498,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();
@@ -2998,6 +3531,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, timeOrigin, t
   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 ?? [],
@@ -3342,8 +3876,44 @@ handleHttpEndpointRequestForResponse_fn = /* @__PURE__ */ __name(async function(
     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,
@@ -3353,7 +3923,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,
@@ -3395,7 +3965,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,
@@ -3416,7 +3986,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,
@@ -3504,6 +4074,45 @@ standardResponseHeaders_fn = /* @__PURE__ */ __name(function(start) {
     "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}`;
 }
@@ -3808,9 +4417,152 @@ function 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, secret, algorithm }) {
+async function verifyRequestSignature({ request, headerName, headerEncoding = "hex", secret, algorithm }) {
   if (!secret) {
     return {
       success: false,
@@ -3826,7 +4578,7 @@ async function verifyRequestSignature({ request, headerName, secret, algorithm }
   }
   switch (algorithm) {
     case "sha256":
-      const success = verifyHmacSha256(headerValue, secret, await request.text());
+      const success = verifyHmacSha256(headerValue, headerEncoding, secret, await request.text());
       if (success) {
         return {
           success
@@ -3842,9 +4594,9 @@ async function verifyRequestSignature({ request, headerName, secret, algorithm }
   }
 }
 __name(verifyRequestSignature, "verifyRequestSignature");
-function verifyHmacSha256(headerValue, secret, body) {
-  const bodyDigest = import_crypto.default.createHmac("sha256", secret).update(body).digest("hex");
-  const signature = headerValue?.replace("sha256=", "") ?? "";
+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");
@@ -3876,6 +4628,8 @@ __name(redactString, "redactString");
   MissingConnectionNotification,
   MissingConnectionResolvedNotification,
   TriggerClient,
+  WebhookSource,
+  WebhookTrigger,
   cronTrigger,
   eventTrigger,
   intervalTrigger,
@@ -3886,6 +4640,7 @@ __name(redactString, "redactString");
   omit,
   redactString,
   retry,
+  slugifyId,
   verifyHmacSha256,
   verifyRequestSignature,
   waitForEventSchema