@trigger.dev/sdk 0.0.0-canary-20231129101350 → 0.0.0-cli-e2e-20240910161832

package/dist/index.js

@@ -1,4674 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  CronTrigger: () => CronTrigger,
-  DynamicSchedule: () => DynamicSchedule,
-  DynamicTrigger: () => DynamicTrigger,
-  EventSpecificationExampleSchema: () => EventSpecificationExampleSchema,
-  EventTrigger: () => EventTrigger,
-  ExternalSource: () => ExternalSource,
-  ExternalSourceTrigger: () => ExternalSourceTrigger,
-  IO: () => IO,
-  IOLogger: () => IOLogger,
-  IntervalTrigger: () => IntervalTrigger,
-  InvokeTrigger: () => InvokeTrigger,
-  JSONOutputSerializer: () => JSONOutputSerializer,
-  Job: () => Job,
-  MissingConnectionNotification: () => MissingConnectionNotification,
-  MissingConnectionResolvedNotification: () => MissingConnectionResolvedNotification,
-  TriggerClient: () => TriggerClient,
-  WebhookSource: () => WebhookSource,
-  WebhookTrigger: () => WebhookTrigger,
-  cronTrigger: () => cronTrigger,
-  eventTrigger: () => eventTrigger,
-  intervalTrigger: () => intervalTrigger,
-  invokeTrigger: () => invokeTrigger,
-  isTriggerError: () => isTriggerError,
-  missingConnectionNotification: () => missingConnectionNotification,
-  missingConnectionResolvedNotification: () => missingConnectionResolvedNotification,
-  omit: () => omit,
-  redactString: () => redactString,
-  retry: () => retry,
-  slugifyId: () => slugifyId,
-  verifyHmacSha256: () => verifyHmacSha256,
-  verifyRequestSignature: () => verifyRequestSignature,
-  waitForEventSchema: () => waitForEventSchema
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/utils.ts
-function slugifyId(input) {
-  const replaceSpacesWithDash = input.toLowerCase().replace(/\s+/g, "-");
-  const removeNonUrlSafeChars = replaceSpacesWithDash.replace(/[^a-zA-Z0-9-._~]/g, "");
-  return removeNonUrlSafeChars;
-}
-__name(slugifyId, "slugifyId");
-
-// src/utils/typedAsyncLocalStorage.ts
-var import_node_async_hooks = require("async_hooks");
-var TypedAsyncLocalStorage = class {
-  constructor() {
-    this.storage = new import_node_async_hooks.AsyncLocalStorage();
-  }
-  runWith(context, fn) {
-    return this.storage.run(context, fn);
-  }
-  getStore() {
-    return this.storage.getStore();
-  }
-};
-__name(TypedAsyncLocalStorage, "TypedAsyncLocalStorage");
-
-// src/runLocalStorage.ts
-var runLocalStorage = new TypedAsyncLocalStorage();
-
-// src/job.ts
-var _validate, validate_fn;
-var Job = class {
-  constructor(client, options) {
-    __privateAdd(this, _validate);
-    this.client = client;
-    this.options = options;
-    __privateMethod(this, _validate, validate_fn).call(this);
-    client.attach(this);
-  }
-  get id() {
-    return slugifyId(this.options.id);
-  }
-  get enabled() {
-    return typeof this.options.enabled === "boolean" ? this.options.enabled : true;
-  }
-  get name() {
-    return this.options.name;
-  }
-  get trigger() {
-    return this.options.trigger;
-  }
-  get version() {
-    return this.options.version;
-  }
-  get logLevel() {
-    return this.options.logLevel;
-  }
-  get integrations() {
-    return Object.keys(this.options.integrations ?? {}).reduce((acc, key) => {
-      const integration = this.options.integrations[key];
-      acc[key] = {
-        id: integration.id,
-        metadata: integration.metadata,
-        authSource: integration.authSource
-      };
-      return acc;
-    }, {});
-  }
-  toJSON() {
-    const internal = this.options.__internal;
-    return {
-      id: this.id,
-      name: this.name,
-      version: this.version,
-      event: this.trigger.event,
-      trigger: this.trigger.toJSON(),
-      integrations: this.integrations,
-      startPosition: "latest",
-      enabled: this.enabled,
-      preprocessRuns: this.trigger.preprocessRuns,
-      internal,
-      concurrencyLimit: typeof this.options.concurrencyLimit === "number" ? this.options.concurrencyLimit : typeof this.options.concurrencyLimit === "object" ? {
-        id: this.options.concurrencyLimit.id,
-        limit: this.options.concurrencyLimit.limit
-      } : void 0
-    };
-  }
-  async invoke(param1, param2 = void 0, param3 = void 0) {
-    const runStore = runLocalStorage.getStore();
-    if (typeof param1 === "string") {
-      if (!runStore) {
-        throw new Error("Cannot invoke a job from outside of a run when passing a cacheKey. Make sure you are running the job from within a run or use the invoke method without the cacheKey.");
-      }
-      const options = param3 ?? {};
-      return await runStore.io.runTask(param1, async (task) => {
-        const result = await this.client.invokeJob(this.id, param2, {
-          idempotencyKey: task.idempotencyKey,
-          ...options
-        });
-        task.outputProperties = [
-          {
-            label: "Run",
-            text: result.id,
-            url: `/orgs/${runStore.ctx.organization.slug}/projects/${runStore.ctx.project.slug}/jobs/${this.id}/runs/${result.id}/trigger`
-          }
-        ];
-        return result;
-      }, {
-        name: `Manually Invoke '${this.name}'`,
-        params: param2,
-        properties: [
-          {
-            label: "Job",
-            text: this.id,
-            url: `/orgs/${runStore.ctx.organization.slug}/projects/${runStore.ctx.project.slug}/jobs/${this.id}`
-          },
-          {
-            label: "Env",
-            text: runStore.ctx.environment.slug
-          }
-        ]
-      });
-    }
-    if (runStore) {
-      throw new Error("Cannot invoke a job from within a run without a cacheKey.");
-    }
-    return await this.client.invokeJob(this.id, param1, param3);
-  }
-  async invokeAndWaitForCompletion(cacheKey, payload, timeoutInSeconds = 60 * 60, options = {}) {
-    const runStore = runLocalStorage.getStore();
-    if (!runStore) {
-      throw new Error("Cannot invoke a job from outside of a run using invokeAndWaitForCompletion. Make sure you are running the job from within a run or use the invoke method instead.");
-    }
-    const { io, ctx } = runStore;
-    return await io.runTask(cacheKey, async (task) => {
-      const parsedPayload = this.trigger.event.parseInvokePayload ? this.trigger.event.parseInvokePayload(payload) ? payload : void 0 : payload;
-      const result = await this.client.invokeJob(this.id, parsedPayload, {
-        idempotencyKey: task.idempotencyKey,
-        callbackUrl: task.callbackUrl ?? void 0,
-        ...options
-      });
-      task.outputProperties = [
-        {
-          label: "Run",
-          text: result.id,
-          url: `/orgs/${ctx.organization.slug}/projects/${ctx.project.slug}/jobs/${this.id}/runs/${result.id}/trigger`
-        }
-      ];
-      return {};
-    }, {
-      name: `Manually Invoke '${this.name}' and wait for completion`,
-      params: payload,
-      properties: [
-        {
-          label: "Job",
-          text: this.id,
-          url: `/orgs/${ctx.organization.slug}/projects/${ctx.project.slug}/jobs/${this.id}`
-        },
-        {
-          label: "Env",
-          text: ctx.environment.slug
-        }
-      ],
-      callback: {
-        enabled: true,
-        timeoutInSeconds
-      }
-    });
-  }
-  async batchInvokeAndWaitForCompletion(cacheKey, batch) {
-    const runStore = runLocalStorage.getStore();
-    if (!runStore) {
-      throw new Error("Cannot invoke a job from outside of a run using batchInvokeAndWaitForCompletion.");
-    }
-    if (batch.length === 0) {
-      return [];
-    }
-    if (batch.length > 25) {
-      throw new Error(`Cannot batch invoke more than 25 items. You tried to batch invoke ${batch.length} items.`);
-    }
-    const { io, ctx } = runStore;
-    const results = await io.parallel(cacheKey, batch, async (item, index) => {
-      return await this.invokeAndWaitForCompletion(String(index), item.payload, item.timeoutInSeconds ?? 60 * 60, item.options);
-    }, {
-      name: `Batch Invoke '${this.name}'`,
-      properties: [
-        {
-          label: "Job",
-          text: this.id,
-          url: `/orgs/${ctx.organization.slug}/projects/${ctx.project.slug}/jobs/${this.id}`
-        },
-        {
-          label: "Env",
-          text: ctx.environment.slug
-        }
-      ]
-    });
-    return results;
-  }
-};
-__name(Job, "Job");
-_validate = new WeakSet();
-validate_fn = /* @__PURE__ */ __name(function() {
-  if (!this.version.match(/^(\d+)\.(\d+)\.(\d+)$/)) {
-    throw new Error(`Invalid job version: "${this.version}". Job versions must be valid semver versions.`);
-  }
-}, "#validate");
-
-// src/triggerClient.ts
-var import_core8 = require("@trigger.dev/core");
-var import_colorette = require("colorette");
-
-// src/apiClient.ts
-var import_core3 = require("@trigger.dev/core");
-var import_zod3 = require("zod");
-
-// src/io.ts
-var import_core2 = require("@trigger.dev/core");
-var import_core_backend = require("@trigger.dev/core-backend");
-var import_node_async_hooks2 = require("async_hooks");
-var import_node_crypto = require("crypto");
-
-// 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 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 (status.state) {
-      properties.push({
-        label: "State",
-        text: status.state
-      });
-    }
-    return await this.io.runTask(key, async (task) => {
-      return await this.io.triggerClient.updateStatus(this.io.runId, this.id, status);
-    }, {
-      name: status.label ?? `Status update`,
-      icon: "bell",
-      params: {
-        ...status
-      },
-      properties
-    });
-  }
-};
-__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
-      },
-      properties: __privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
-      style: {
-        style: "minimal"
-      }
-    });
-  }
-  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
-      },
-      properties: __privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
-      style: {
-        style: "minimal"
-      }
-    });
-  }
-  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
-      },
-      properties: __privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
-      style: {
-        style: "minimal"
-      }
-    });
-  }
-  async set(param1, param2, param3) {
-    const runStore = runLocalStorage.getStore();
-    if (!runStore) {
-      if (typeof param1 !== "string") {
-        throw new Error("Please use the store without a cacheKey when accessing from outside a run.");
-      }
-      return await this.apiClient.store.set(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param1), param2);
-    }
-    const { io } = runStore;
-    if (!param2 || typeof param2 !== "string") {
-      throw new Error("Please provide a non-empty key when accessing the store from inside a run.");
-    }
-    const value = param3;
-    return await io.runTask(param1, async (task) => {
-      return await this.apiClient.store.set(__privateMethod(this, _namespacedKey, namespacedKey_fn).call(this, param2), value);
-    }, {
-      name: "Key-Value Store Set",
-      icon: "database-plus",
-      params: {
-        key: param2,
-        value
-      },
-      properties: [
-        ...__privateMethod(this, _sharedProperties, sharedProperties_fn).call(this, param2),
-        ...typeof value !== "object" || value === null ? [
-          {
-            label: "value",
-            text: String(value) ?? "undefined"
-          }
-        ] : []
-      ],
-      style: {
-        style: "minimal"
-      }
-    });
-  }
-};
-__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);
-  }
-  deserialize(value) {
-    return value ? JSON.parse(value) : void 0;
-  }
-};
-__name(JSONOutputSerializer, "JSONOutputSerializer");
-var _addToCachedTasks, addToCachedTasks_fn, _detectAutoYield, detectAutoYield_fn, _forceYield, forceYield_fn, _getTimeElapsed, getTimeElapsed_fn, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn;
-var IO = class {
-  constructor(options) {
-    __privateAdd(this, _addToCachedTasks);
-    __privateAdd(this, _detectAutoYield);
-    __privateAdd(this, _forceYield);
-    __privateAdd(this, _getTimeElapsed);
-    __privateAdd(this, _getRemainingTimeInMillis);
-    __publicField(this, "_outputSerializer", new JSONOutputSerializer());
-    __publicField(this, "_visitedCacheKeys", /* @__PURE__ */ new Set());
-    __publicField(this, "brb", this.yield.bind(this));
-    this._id = options.id;
-    this._jobId = options.jobId;
-    this._apiClient = options.apiClient;
-    this._triggerClient = options.client;
-    this._logger = options.logger ?? new import_core2.Logger("trigger.dev", options.logLevel);
-    this._cachedTasks = /* @__PURE__ */ new Map();
-    this._jobLogger = options.jobLogger;
-    this._jobLogLevel = options.jobLogLevel;
-    this._timeOrigin = options.timeOrigin;
-    this._executionTimeout = options.executionTimeout;
-    this._envStore = new KeyValueStore(options.apiClient);
-    this._jobStore = new KeyValueStore(options.apiClient, "job", options.jobId);
-    this._runStore = new KeyValueStore(options.apiClient, "run", options.id);
-    this._stats = {
-      initialCachedTasks: 0,
-      lazyLoadedCachedTasks: 0,
-      executedTasks: 0,
-      cachedTaskHits: 0,
-      cachedTaskMisses: 0,
-      noopCachedTaskHits: 0,
-      noopCachedTaskMisses: 0
-    };
-    if (options.cachedTasks) {
-      options.cachedTasks.forEach((task) => {
-        this._cachedTasks.set(task.idempotencyKey, task);
-      });
-      this._stats.initialCachedTasks = options.cachedTasks.length;
-    }
-    this._taskStorage = new import_node_async_hooks2.AsyncLocalStorage();
-    this._context = options.context;
-    this._yieldedExecutions = options.yieldedExecutions ?? [];
-    if (options.noopTasksSet) {
-      this._noopTasksBloomFilter = import_core_backend.BloomFilter.deserialize(options.noopTasksSet, import_core_backend.BloomFilter.NOOP_TASK_SET_SIZE);
-    }
-    this._cachedTasksCursor = options.cachedTasksCursor;
-    this._serverVersion = options.serverVersion ?? "unversioned";
-  }
-  get stats() {
-    return this._stats;
-  }
-  get runId() {
-    return this._id;
-  }
-  get triggerClient() {
-    return this._triggerClient;
-  }
-  get logger() {
-    return new IOLogger(async (level, message, data) => {
-      let logLevel = "info";
-      if (import_core2.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
-        await this.runTask([
-          message,
-          level
-        ], async (task) => {
-          switch (level) {
-            case "LOG": {
-              this._jobLogger?.log(message, data);
-              logLevel = "log";
-              break;
-            }
-            case "DEBUG": {
-              this._jobLogger?.debug(message, data);
-              logLevel = "debug";
-              break;
-            }
-            case "INFO": {
-              this._jobLogger?.info(message, data);
-              logLevel = "info";
-              break;
-            }
-            case "WARN": {
-              this._jobLogger?.warn(message, data);
-              logLevel = "warn";
-              break;
-            }
-            case "ERROR": {
-              this._jobLogger?.error(message, data);
-              logLevel = "error";
-              break;
-            }
-          }
-        }, {
-          name: "log",
-          icon: "log",
-          description: message,
-          params: data,
-          properties: [
-            {
-              label: "Level",
-              text: level
-            }
-          ],
-          style: {
-            style: "minimal",
-            variant: level.toLowerCase()
-          },
-          noop: true
-        });
-      }
-    });
-  }
-  async random(cacheKey, { min = 0, max = 1, round = false } = {}) {
-    return await this.runTask(cacheKey, async (task) => {
-      if (min > max) {
-        throw new Error(`Lower bound can't be higher than upper bound - min: ${min}, max: ${max}`);
-      }
-      if (min === max) {
-        await this.logger.warn(`Lower and upper bounds are identical. The return value is not random and will always be: ${min}`);
-      }
-      const withinBounds = (max - min) * Math.random() + min;
-      if (!round) {
-        return withinBounds;
-      }
-      if (!Number.isInteger(min) || !Number.isInteger(max)) {
-        await this.logger.warn("Rounding enabled with floating-point bounds. This may cause unexpected skew and boundary inclusivity.");
-      }
-      const rounded = Math.round(withinBounds);
-      return rounded;
-    }, {
-      name: "random",
-      icon: "dice-5-filled",
-      params: {
-        min,
-        max,
-        round
-      },
-      properties: [
-        ...min === 0 ? [] : [
-          {
-            label: "min",
-            text: String(min)
-          }
-        ],
-        ...max === 1 ? [] : [
-          {
-            label: "max",
-            text: String(max)
-          }
-        ],
-        ...round === false ? [] : [
-          {
-            label: "round",
-            text: String(round)
-          }
-        ]
-      ],
-      style: {
-        style: "minimal"
-      }
-    });
-  }
-  async wait(cacheKey, seconds) {
-    return await this.runTask(cacheKey, async (task) => {
-    }, {
-      name: "wait",
-      icon: "clock",
-      params: {
-        seconds
-      },
-      noop: true,
-      delayUntil: new Date(Date.now() + seconds * 1e3),
-      style: {
-        style: "minimal"
-      }
-    });
-  }
-  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 waitForRequest(cacheKey, callback, options) {
-    const timeoutInSeconds = options?.timeoutInSeconds ?? 60 * 60;
-    return await this.runTask(cacheKey, async (task, io) => {
-      if (!task.callbackUrl) {
-        throw new Error("No callbackUrl found on task");
-      }
-      task.outputProperties = [
-        {
-          label: "Callback URL",
-          text: task.callbackUrl
-        }
-      ];
-      return callback(task.callbackUrl);
-    }, {
-      name: "Wait for Request",
-      icon: "clock",
-      callback: {
-        enabled: true,
-        timeoutInSeconds: options?.timeoutInSeconds
-      },
-      properties: [
-        {
-          label: "Timeout",
-          text: `${timeoutInSeconds}s`
-        }
-      ]
-    });
-  }
-  async createStatus(cacheKey, initialStatus) {
-    const id = typeof cacheKey === "string" ? cacheKey : cacheKey.join("-");
-    const status = new TriggerStatus(id, this);
-    await status.update(cacheKey, initialStatus);
-    return status;
-  }
-  async backgroundFetch(cacheKey, url, requestInit, 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 backgroundPoll(cacheKey, params) {
-    const urlObject = new URL(params.url);
-    return await this.runTask(cacheKey, async (task) => {
-      return task.output;
-    }, {
-      name: `poll ${urlObject.hostname}${urlObject.pathname}`,
-      params,
-      operation: "fetch-poll",
-      icon: "clock-bolt",
-      noop: false,
-      properties: [
-        {
-          label: "url",
-          text: params.url
-        },
-        {
-          label: "interval",
-          text: `${params.interval}s`
-        },
-        {
-          label: "timeout",
-          text: `${params.timeout}s`
-        }
-      ],
-      retry: {
-        limit: 0
-      }
-    });
-  }
-  async backgroundFetchResponse(cacheKey, url, requestInit, options) {
-    const urlObject = new URL(url);
-    return await this.runTask(cacheKey, async (task) => {
-      return task.output;
-    }, {
-      name: `fetch response ${urlObject.hostname}${urlObject.pathname}`,
-      params: {
-        url,
-        requestInit,
-        retry: options?.retry,
-        timeout: options?.timeout
-      },
-      operation: "fetch-response",
-      icon: "background",
-      noop: false,
-      properties: [
-        {
-          label: "url",
-          text: url,
-          url
-        },
-        {
-          label: "method",
-          text: requestInit?.method ?? "GET"
-        },
-        {
-          label: "background",
-          text: "true"
-        },
-        ...options?.timeout ? [
-          {
-            label: "timeout",
-            text: `${options.timeout.durationInMs}ms`
-          }
-        ] : []
-      ],
-      retry: {
-        limit: 0
-      }
-    });
-  }
-  async sendEvent(cacheKey, event, options) {
-    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)
-      ]
-    });
-  }
-  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)
-      ]
-    });
-  }
-  async getEvent(cacheKey, id) {
-    return await this.runTask(cacheKey, async (task) => {
-      return await this._triggerClient.getEvent(id);
-    }, {
-      name: "getEvent",
-      params: {
-        id
-      },
-      properties: [
-        {
-          label: "id",
-          text: id
-        }
-      ]
-    });
-  }
-  async cancelEvent(cacheKey, eventId) {
-    return await this.runTask(cacheKey, async (task) => {
-      return await this._triggerClient.cancelEvent(eventId);
-    }, {
-      name: "cancelEvent",
-      params: {
-        eventId
-      },
-      properties: [
-        {
-          label: "id",
-          text: eventId
-        }
-      ]
-    });
-  }
-  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 updateWebhook(cacheKey, options) {
-    return this.runTask(cacheKey, async (task) => {
-      return await this._apiClient.updateWebhook(options.key, options);
-    }, {
-      name: "Update Webhook Source",
-      icon: "refresh",
-      properties: [
-        {
-          label: "key",
-          text: options.key
-        }
-      ],
-      params: options
-    });
-  }
-  async registerInterval(cacheKey, dynamicSchedule, id, options) {
-    return await this.runTask(cacheKey, async (task) => {
-      return dynamicSchedule.register(id, {
-        type: "interval",
-        options
-      });
-    }, {
-      name: "register-interval",
-      properties: [
-        {
-          label: "schedule",
-          text: dynamicSchedule.id
-        },
-        {
-          label: "id",
-          text: id
-        },
-        {
-          label: "seconds",
-          text: options.seconds.toString()
-        }
-      ],
-      params: options
-    });
-  }
-  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 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
-    });
-  }
-  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 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 getAuth(cacheKey, clientId) {
-    if (!clientId) {
-      return;
-    }
-    return this.runTask(cacheKey, async (task) => {
-      return await this._triggerClient.getAuth(clientId);
-    }, {
-      name: "get-auth"
-    });
-  }
-  async parallel(cacheKey, items, callback, options) {
-    const results = await this.runTask(cacheKey, async (task) => {
-      const outcomes = await Promise.allSettled(items.map((item, index) => spaceOut(() => callback(item, index), index, 15)));
-      if (outcomes.every((outcome) => outcome.status === "fulfilled")) {
-        return outcomes.map((outcome) => outcome.value);
-      }
-      const nonInternalErrors = outcomes.filter((outcome) => outcome.status === "rejected" && !isTriggerError(outcome.reason)).map((outcome) => outcome);
-      if (nonInternalErrors.length > 0) {
-        throw nonInternalErrors[0].reason;
-      }
-      const internalErrors = outcomes.filter((outcome) => outcome.status === "rejected" && isTriggerError(outcome.reason)).map((outcome) => outcome).map((outcome) => outcome.reason);
-      throw new ResumeWithParallelTaskError(task, internalErrors);
-    }, {
-      name: "parallel",
-      parallel: true,
-      ...options ?? {}
-    });
-    return results;
-  }
-  async runTask(cacheKey, callback, options, onError) {
-    __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "start_task", 500);
-    const parentId = this._taskStorage.getStore()?.taskId;
-    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
-    };
-    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++;
-        }
-      }
-    }
-    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;
-    }
-    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 (task.status === "RUNNING" && typeof task.operation === "string") {
-      this._logger.debug("Task running operation", {
-        idempotencyKey,
-        task
-      });
-      throw new ResumeWithTaskError(task);
-    }
-    return this._taskStorage.run({
-      taskId: task.id
-    }, executeTask);
-  }
-  yield(cacheKey) {
-    if (!(0, import_core2.supportsFeature)("yieldExecution", this._serverVersion)) {
-      console.warn("[trigger.dev] io.yield() is not support by the version of the Trigger.dev server you are using, you will need to upgrade your self-hosted Trigger.dev instance.");
-      return;
-    }
-    if (this._yieldedExecutions.includes(cacheKey)) {
-      return;
-    }
-    throw new YieldExecutionError(cacheKey);
-  }
-  async try(tryCallback, catchCallback) {
-    try {
-      return await tryCallback();
-    } catch (error) {
-      if (isTriggerError(error)) {
-        throw error;
-      }
-      return await catchCallback(error);
-    }
-  }
-  get store() {
-    return {
-      env: this._envStore,
-      job: this._jobStore,
-      run: this._runStore
-    };
-  }
-};
-__name(IO, "IO");
-_addToCachedTasks = new WeakSet();
-addToCachedTasks_fn = /* @__PURE__ */ __name(function(task) {
-  this._cachedTasks.set(task.idempotencyKey, task);
-}, "#addToCachedTasks");
-_detectAutoYield = new WeakSet();
-detectAutoYield_fn = /* @__PURE__ */ __name(function(location, threshold = 1500, task1, output) {
-  const timeRemaining = __privateMethod(this, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn).call(this);
-  if (timeRemaining && timeRemaining < threshold) {
-    if (task1) {
-      throw new AutoYieldWithCompletedTaskExecutionError(task1.id, task1.outputProperties ?? [], {
-        location,
-        timeRemaining,
-        timeElapsed: __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this)
-      }, output);
-    } else {
-      throw new AutoYieldExecutionError(location, timeRemaining, __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this));
-    }
-  }
-}, "#detectAutoYield");
-_forceYield = new WeakSet();
-forceYield_fn = /* @__PURE__ */ __name(function(location1) {
-  const timeRemaining = __privateMethod(this, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn).call(this);
-  if (timeRemaining) {
-    throw new AutoYieldExecutionError(location1, timeRemaining, __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this));
-  }
-}, "#forceYield");
-_getTimeElapsed = new WeakSet();
-getTimeElapsed_fn = /* @__PURE__ */ __name(function() {
-  return performance.now() - this._timeOrigin;
-}, "#getTimeElapsed");
-_getRemainingTimeInMillis = new WeakSet();
-getRemainingTimeInMillis_fn = /* @__PURE__ */ __name(function() {
-  if (this._executionTimeout) {
-    return this._executionTimeout - (performance.now() - this._timeOrigin);
-  }
-  return void 0;
-}, "#getRemainingTimeInMillis");
-async function generateIdempotencyKey(keyMaterial) {
-  const keys = keyMaterial.map((key2) => {
-    if (typeof key2 === "string") {
-      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;
-  }
-  __name(sortKeys, "sortKeys");
-  const sortedObj = sortKeys(obj);
-  return JSON.stringify(sortedObj);
-}
-__name(stableStringify, "stableStringify");
-var IOLogger = class {
-  constructor(callback) {
-    this.callback = callback;
-  }
-  log(message, properties) {
-    return this.callback("LOG", message, properties);
-  }
-  debug(message, properties) {
-    return this.callback("DEBUG", message, properties);
-  }
-  info(message, properties) {
-    return this.callback("INFO", message, properties);
-  }
-  warn(message, properties) {
-    return this.callback("WARN", message, properties);
-  }
-  error(message, properties) {
-    return this.callback("ERROR", message, properties);
-  }
-};
-__name(IOLogger, "IOLogger");
-async function spaceOut(callback, index, delay) {
-  await new Promise((resolve) => setTimeout(resolve, index * delay));
-  return await callback();
-}
-__name(spaceOut, "spaceOut");
-function sendEventOptionsProperties(options) {
-  return [
-    ...options?.accountId ? [
-      {
-        label: "Account ID",
-        text: options.accountId
-      }
-    ] : [],
-    ...options?.deliverAfter ? [
-      {
-        label: "Deliver After",
-        text: `${options.deliverAfter}s`
-      }
-    ] : [],
-    ...options?.deliverAt ? [
-      {
-        label: "Deliver At",
-        text: options.deliverAt.toISOString()
-      }
-    ] : []
-  ];
-}
-__name(sendEventOptionsProperties, "sendEventOptionsProperties");
-
-// src/store/keyValueStoreClient.ts
-var _serializer, _namespacedKey2, namespacedKey_fn2;
-var KeyValueStoreClient = class {
-  constructor(queryStore, type = null, namespace = "") {
-    __privateAdd(this, _namespacedKey2);
-    __privateAdd(this, _serializer, void 0);
-    this.queryStore = queryStore;
-    this.type = type;
-    this.namespace = namespace;
-    __privateSet(this, _serializer, new JSONOutputSerializer());
-  }
-  async delete(key) {
-    const result = await this.queryStore("DELETE", {
-      key: __privateMethod(this, _namespacedKey2, namespacedKey_fn2).call(this, key)
-    });
-    if (result.action !== "DELETE") {
-      throw new Error(`Unexpected key-value store response: ${result.action}`);
-    }
-    return result.deleted;
-  }
-  async get(key) {
-    const result = await this.queryStore("GET", {
-      key: __privateMethod(this, _namespacedKey2, namespacedKey_fn2).call(this, key)
-    });
-    if (result.action !== "GET") {
-      throw new Error(`Unexpected key-value store response: ${result.action}`);
-    }
-    return __privateGet(this, _serializer).deserialize(result.value);
-  }
-  async has(key) {
-    const result = await this.queryStore("HAS", {
-      key: __privateMethod(this, _namespacedKey2, namespacedKey_fn2).call(this, key)
-    });
-    if (result.action !== "HAS") {
-      throw new Error(`Unexpected key-value store response: ${result.action}`);
-    }
-    return result.has;
-  }
-  async set(key, value) {
-    const result = await this.queryStore("SET", {
-      key: __privateMethod(this, _namespacedKey2, namespacedKey_fn2).call(this, key),
-      value: __privateGet(this, _serializer).serialize(value)
-    });
-    if (result.action !== "SET") {
-      throw new Error(`Unexpected key-value store response: ${result.action}`);
-    }
-    return __privateGet(this, _serializer).deserialize(result.value);
-  }
-};
-__name(KeyValueStoreClient, "KeyValueStoreClient");
-_serializer = new WeakMap();
-_namespacedKey2 = new WeakSet();
-namespacedKey_fn2 = /* @__PURE__ */ __name(function(key) {
-  const parts = [];
-  if (this.type) {
-    parts.push(this.type);
-  }
-  if (this.namespace) {
-    parts.push(this.namespace);
-  }
-  parts.push(key);
-  return parts.join(":");
-}, "#namespacedKey");
-
-// src/apiClient.ts
-var _apiUrl, _options, _logger, _storeClient, _queryKeyValueStore, queryKeyValueStore_fn, _apiKey, apiKey_fn;
-var ApiClient = class {
-  constructor(options) {
-    __privateAdd(this, _queryKeyValueStore);
-    __privateAdd(this, _apiKey);
-    __privateAdd(this, _apiUrl, void 0);
-    __privateAdd(this, _options, void 0);
-    __privateAdd(this, _logger, void 0);
-    __privateAdd(this, _storeClient, void 0);
-    __privateSet(this, _options, options);
-    __privateSet(this, _apiUrl, __privateGet(this, _options).apiUrl ?? process.env.TRIGGER_API_URL ?? "https://api.trigger.dev");
-    __privateSet(this, _logger, new import_core3.Logger("trigger.dev", __privateGet(this, _options).logLevel));
-    __privateSet(this, _storeClient, new KeyValueStoreClient(__privateMethod(this, _queryKeyValueStore, queryKeyValueStore_fn).bind(this)));
-  }
-  async registerEndpoint(options) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Registering endpoint", {
-      url: options.url,
-      name: options.name
-    });
-    const response = await fetch(`${__privateGet(this, _apiUrl)}/api/v1/endpoints`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        url: options.url,
-        name: options.name
-      })
-    });
-    if (response.status >= 400 && response.status < 500) {
-      const body = await response.json();
-      throw new Error(body.error);
-    }
-    if (response.status !== 200) {
-      throw new Error(`Failed to register entry point, got status code ${response.status}`);
-    }
-    return await response.json();
-  }
-  async runTask(runId, task, options = {}) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Running Task", {
-      task
-    });
-    return await zodfetchWithVersions({
-      [import_core3.API_VERSIONS.LAZY_LOADED_CACHED_TASKS]: import_core3.RunTaskResponseWithCachedTasksBodySchema
-    }, import_core3.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`,
-        "Idempotency-Key": task.idempotencyKey,
-        "X-Cached-Tasks-Cursor": options.cachedTasksCursor ?? "",
-        "Trigger-Version": import_core3.API_VERSIONS.LAZY_LOADED_CACHED_TASKS
-      },
-      body: JSON.stringify(task)
-    });
-  }
-  async completeTask(runId, id, task) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Complete Task", {
-      task
-    });
-    return await zodfetch(import_core3.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`,
-        "Trigger-Version": import_core3.API_VERSIONS.SERIALIZED_TASK_OUTPUT
-      },
-      body: JSON.stringify(task)
-    });
-  }
-  async failTask(runId, id, body) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Fail Task", {
-      id,
-      runId,
-      body
-    });
-    return await zodfetch(import_core3.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/fail`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-  }
-  async sendEvent(event, options = {}) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Sending event", {
-      event
-    });
-    return await zodfetch(import_core3.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        event,
-        options
-      })
-    });
-  }
-  async sendEvents(events, options = {}) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Sending multiple events", {
-      events
-    });
-    return await zodfetch(import_core3.ApiEventLogSchema.array(), `${__privateGet(this, _apiUrl)}/api/v1/events/bulk`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        events,
-        options
-      })
-    });
-  }
-  async cancelEvent(eventId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Cancelling event", {
-      eventId
-    });
-    return await zodfetch(import_core3.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-  }
-  async cancelRunsForEvent(eventId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Cancelling runs for event", {
-      eventId
-    });
-    return await zodfetch(import_core3.CancelRunsForEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel-runs`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-  }
-  async updateStatus(runId, id, status) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Update status", {
-      id,
-      status
-    });
-    return await zodfetch(import_core3.JobRunStatusRecordSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses/${id}`, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(status)
-    });
-  }
-  async updateSource(client, key, source) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("activating http source", {
-      source
-    });
-    const response = await zodfetch(import_core3.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v2/${client}/sources/${key}`, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(source)
-    });
-    return response;
-  }
-  async updateWebhook(key, webhookData) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("activating webhook", {
-      webhookData
-    });
-    const response = await zodfetch(import_core3.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v1/webhooks/${key}`, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(webhookData)
-    });
-    return response;
-  }
-  async registerTrigger(client, id, key, payload, idempotencyKey) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("registering trigger", {
-      id,
-      payload
-    });
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    };
-    if (idempotencyKey) {
-      headers["Idempotency-Key"] = idempotencyKey;
-    }
-    const response = await zodfetch(import_core3.RegisterSourceEventSchemaV2, `${__privateGet(this, _apiUrl)}/api/v2/${client}/triggers/${id}/registrations/${key}`, {
-      method: "PUT",
-      headers,
-      body: JSON.stringify(payload)
-    });
-    return response;
-  }
-  async registerSchedule(client, id, key, payload) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("registering schedule", {
-      id,
-      payload
-    });
-    const response = await zodfetch(import_core3.RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        id: key,
-        ...payload
-      })
-    });
-    return response;
-  }
-  async unregisterSchedule(client, id, key) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("unregistering schedule", {
-      id
-    });
-    const response = await zodfetch(import_zod3.z.object({
-      ok: import_zod3.z.boolean()
-    }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-    return response;
-  }
-  async getAuth(client, id) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("getting auth", {
-      id
-    });
-    const response = await zodfetch(import_core3.ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
-      method: "GET",
-      headers: {
-        Accept: "application/json",
-        Authorization: `Bearer ${apiKey}`
-      }
-    }, {
-      optional: true
-    });
-    return response;
-  }
-  async getEvent(eventId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Getting Event", {
-      eventId
-    });
-    return await zodfetch(import_core3.GetEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-  }
-  async getRun(runId, options) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Getting Run", {
-      runId
-    });
-    return await zodfetch(import_core3.GetRunSchema, (0, import_core3.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}`, options), {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-  }
-  async cancelRun(runId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Cancelling Run", {
-      runId
-    });
-    return await zodfetch(import_core3.GetRunSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/cancel`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-  }
-  async getRunStatuses(runId) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Getting Run statuses", {
-      runId
-    });
-    return await zodfetch(import_core3.GetRunStatusesSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-  }
-  async getRuns(jobSlug, options) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Getting Runs", {
-      jobSlug
-    });
-    return await zodfetch(import_core3.GetRunsSchema, (0, import_core3.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobSlug}/runs`, options), {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-  }
-  async invokeJob(jobId, payload, options = {}) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Invoking Job", {
-      jobId
-    });
-    const body = {
-      payload,
-      context: options.context ?? {},
-      options: {
-        accountId: options.accountId,
-        callbackUrl: options.callbackUrl
-      }
-    };
-    return await zodfetch(import_core3.InvokeJobResponseSchema, `${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobId}/invoke`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`,
-        ...options.idempotencyKey ? {
-          "Idempotency-Key": options.idempotencyKey
-        } : {}
-      },
-      body: JSON.stringify(body)
-    });
-  }
-  async createEphemeralEventDispatcher(payload) {
-    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Creating ephemeral event dispatcher", {
-      payload
-    });
-    const response = await zodfetch(import_core3.EphemeralEventDispatcherResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/event-dispatchers/ephemeral`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(payload)
-    });
-    return response;
-  }
-  get store() {
-    return __privateGet(this, _storeClient);
-  }
-};
-__name(ApiClient, "ApiClient");
-_apiUrl = new WeakMap();
-_options = new WeakMap();
-_logger = new WeakMap();
-_storeClient = new WeakMap();
-_queryKeyValueStore = new WeakSet();
-queryKeyValueStore_fn = /* @__PURE__ */ __name(async function(action, data) {
-  const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-  __privateGet(this, _logger).debug("accessing key-value store", {
-    action,
-    data
-  });
-  const encodedKey = encodeURIComponent(data.key);
-  const STORE_URL = `${__privateGet(this, _apiUrl)}/api/v1/store/${encodedKey}`;
-  const authHeader = {
-    Authorization: `Bearer ${apiKey}`
-  };
-  let requestInit;
-  switch (action) {
-    case "DELETE": {
-      requestInit = {
-        method: "DELETE",
-        headers: authHeader
-      };
-      break;
-    }
-    case "GET": {
-      requestInit = {
-        method: "GET",
-        headers: authHeader
-      };
-      break;
-    }
-    case "HAS": {
-      const headResponse = await fetchHead(STORE_URL, {
-        headers: authHeader
-      });
-      return {
-        action: "HAS",
-        key: encodedKey,
-        has: !!headResponse.ok
-      };
-    }
-    case "SET": {
-      const MAX_BODY_BYTE_LENGTH = 256 * 1024;
-      if ((data.value?.length ?? 0) > MAX_BODY_BYTE_LENGTH) {
-        throw new Error(`Max request body size exceeded: ${MAX_BODY_BYTE_LENGTH} bytes`);
-      }
-      requestInit = {
-        method: "PUT",
-        headers: {
-          ...authHeader,
-          "Content-Type": "text/plain"
-        },
-        body: data.value
-      };
-      break;
-    }
-    default: {
-      (0, import_core3.assertExhaustive)(action);
-    }
-  }
-  const response = await zodfetch(import_core3.KeyValueStoreResponseBodySchema, STORE_URL, requestInit);
-  return response;
-}, "#queryKeyValueStore");
-_apiKey = new WeakSet();
-apiKey_fn = /* @__PURE__ */ __name(async function() {
-  const apiKey = getApiKey(__privateGet(this, _options).apiKey);
-  if (apiKey.status === "invalid") {
-    throw new Error("Invalid API key");
-  } else if (apiKey.status === "missing") {
-    throw new Error("Missing API key");
-  }
-  return apiKey.apiKey;
-}, "#apiKey");
-function getApiKey(key) {
-  const apiKey = key ?? process.env.TRIGGER_API_KEY;
-  if (!apiKey) {
-    return {
-      status: "missing"
-    };
-  }
-  const isValid = apiKey.match(/^tr_[a-z]+_[a-zA-Z0-9]+$/);
-  if (!isValid) {
-    return {
-      status: "invalid",
-      apiKey
-    };
-  }
-  return {
-    status: "valid",
-    apiKey
-  };
-}
-__name(getApiKey, "getApiKey");
-async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount = 0) {
-  const response = await fetch(url, {
-    ...requestInit,
-    cache: "no-cache"
-  });
-  if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
-    return;
-  }
-  if (response.status >= 400 && response.status < 500) {
-    const body = await response.json();
-    throw new Error(body.error);
-  }
-  if (response.status >= 500 && retryCount < 6) {
-    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    return zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount + 1);
-  }
-  if (response.status !== 200) {
-    throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
-  }
-  const jsonBody = await response.json();
-  const version2 = response.headers.get("trigger-version");
-  if (!version2) {
-    return {
-      version: "unversioned",
-      body: unversionedSchema.parse(jsonBody)
-    };
-  }
-  const versionedSchema = versionedSchemaMap[version2];
-  if (!versionedSchema) {
-    throw new Error(`Unknown version ${version2}`);
-  }
-  return {
-    version: version2,
-    body: versionedSchema.parse(jsonBody)
-  };
-}
-__name(zodfetchWithVersions, "zodfetchWithVersions");
-async function fetchHead(url, requestInitWithoutMethod, retryCount = 0) {
-  const requestInit = {
-    ...requestInitWithoutMethod,
-    method: "HEAD"
-  };
-  const response = await fetch(url, {
-    ...requestInit,
-    cache: "no-cache"
-  });
-  if (response.status >= 500 && retryCount < 6) {
-    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    return fetchHead(url, requestInitWithoutMethod, retryCount + 1);
-  }
-  return response;
-}
-__name(fetchHead, "fetchHead");
-async function zodfetch(schema, url, requestInit, options, retryCount = 0) {
-  const response = await fetch(url, {
-    ...requestInit,
-    cache: "no-cache"
-  });
-  if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
-    return;
-  }
-  if (response.status >= 400 && response.status < 500) {
-    const body = await response.json();
-    throw new Error(body.error);
-  }
-  if (response.status >= 500 && retryCount < 6) {
-    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    return zodfetch(schema, url, requestInit, options, retryCount + 1);
-  }
-  if (response.status !== 200) {
-    throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
-  }
-  const jsonBody = await response.json();
-  return schema.parse(jsonBody);
-}
-__name(zodfetch, "zodfetch");
-function exponentialBackoff(retryCount, exponential, minDelay, maxDelay, jitter) {
-  const delay = Math.min(Math.pow(exponential, retryCount) * minDelay, maxDelay);
-  const jitterValue = Math.random() * jitter;
-  return delay + jitterValue;
-}
-__name(exponentialBackoff, "exponentialBackoff");
-
-// src/httpEndpoint.ts
-var import_core4 = require("@trigger.dev/core");
-
-// src/utils/formatSchemaErrors.ts
-function formatSchemaErrors(errors) {
-  return errors.map((error) => {
-    const { path, message } = error;
-    return {
-      path: path.map(String),
-      message
-    };
-  });
-}
-__name(formatSchemaErrors, "formatSchemaErrors");
-
-// src/httpEndpoint.ts
-var HttpEndpoint = class {
-  constructor(options) {
-    this.options = options;
-  }
-  get id() {
-    return this.options.id;
-  }
-  onRequest(options) {
-    return new HttpTrigger({
-      endpointId: this.id,
-      event: this.options.event,
-      filter: options?.filter,
-      verify: this.options.verify
-    });
-  }
-  async handleRequest(request) {
-    if (!this.options.respondWith)
-      return;
-    return this.options.respondWith.handler(request, () => {
-      const clonedRequest = request.clone();
-      return this.options.verify(clonedRequest);
-    });
-  }
-  toJSON() {
-    return {
-      id: this.id,
-      icon: this.options.event.icon,
-      version: "1",
-      enabled: this.options.enabled ?? true,
-      event: this.options.event,
-      immediateResponseFilter: this.options.respondWith?.filter,
-      skipTriggeringRuns: this.options.respondWith?.skipTriggeringRuns,
-      source: this.options.event.source
-    };
-  }
-};
-__name(HttpEndpoint, "HttpEndpoint");
-var HttpTrigger = /* @__PURE__ */ __name(class HttpTrigger2 {
-  constructor(options) {
-    this.options = options;
-  }
-  toJSON() {
-    return {
-      type: "static",
-      title: this.options.endpointId,
-      properties: this.options.event.properties,
-      rule: {
-        event: `httpendpoint.${this.options.endpointId}`,
-        payload: this.options.filter ?? {},
-        source: this.options.event.source
-      },
-      link: `http-endpoints/${this.options.endpointId}`,
-      help: {
-        noRuns: {
-          text: "To start triggering runs click here to setup your HTTP Endpoint with the external API service you want to receive webhooks from.",
-          link: `http-endpoints/${this.options.endpointId}`
-        }
-      }
-    };
-  }
-  get event() {
-    return this.options.event;
-  }
-  attachToJob(triggerClient, job) {
-  }
-  get preprocessRuns() {
-    return false;
-  }
-  async verifyPayload(payload) {
-    const clonedRequest = payload.clone();
-    return this.options.verify(clonedRequest);
-  }
-}, "HttpTrigger");
-function httpEndpoint(options) {
-  const id = slugifyId(options.id);
-  return new HttpEndpoint({
-    id,
-    enabled: options.enabled,
-    respondWith: options.respondWith,
-    verify: options.verify,
-    event: {
-      name: id,
-      title: options.title ?? "HTTP Trigger",
-      source: options.source,
-      icon: options.icon ?? "webhook",
-      properties: options.properties,
-      examples: options.examples ? options.examples : [
-        {
-          id: "basic-request",
-          name: "Basic Request",
-          icon: "http-post",
-          payload: {
-            url: "https://cloud.trigger.dev",
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json"
-            },
-            rawBody: JSON.stringify({
-              foo: "bar"
-            })
-          }
-        }
-      ],
-      parsePayload: (rawPayload) => {
-        const result = import_core4.RequestWithRawBodySchema.safeParse(rawPayload);
-        if (!result.success) {
-          throw new ParsedPayloadSchemaError(formatSchemaErrors(result.error.issues));
-        }
-        return new Request(new URL(result.data.url), {
-          method: result.data.method,
-          headers: result.data.headers,
-          body: result.data.rawBody
-        });
-      }
-    }
-  });
-}
-__name(httpEndpoint, "httpEndpoint");
-
-// src/ioWithIntegrations.ts
-function createIOWithIntegrations(io, auths, integrations) {
-  if (!integrations) {
-    return io;
-  }
-  const connections = Object.entries(integrations).reduce((acc, [connectionKey, integration]) => {
-    let auth = auths?.[connectionKey];
-    acc[connectionKey] = {
-      integration,
-      auth
-    };
-    return acc;
-  }, {});
-  return new Proxy(io, {
-    get(target, prop, receiver) {
-      if (prop === "__io") {
-        return io;
-      }
-      if (typeof prop === "string" && prop in connections) {
-        const { integration, auth } = connections[prop];
-        return integration.cloneForRun(io, prop, auth);
-      }
-      const value = Reflect.get(target, prop, receiver);
-      return typeof value == "function" ? value.bind(target) : value;
-    }
-  });
-}
-__name(createIOWithIntegrations, "createIOWithIntegrations");
-
-// src/triggers/dynamic.ts
-var import_core5 = require("@trigger.dev/core");
-var _client, _options2;
-var DynamicTrigger = class {
-  constructor(client, options) {
-    __privateAdd(this, _client, void 0);
-    __privateAdd(this, _options2, void 0);
-    __privateSet(this, _client, client);
-    __privateSet(this, _options2, options);
-    this.source = options.source;
-    client.attachDynamicTrigger(this);
-  }
-  toJSON() {
-    return {
-      type: "dynamic",
-      id: __privateGet(this, _options2).id
-    };
-  }
-  get id() {
-    return __privateGet(this, _options2).id;
-  }
-  get event() {
-    return __privateGet(this, _options2).event;
-  }
-  registeredTriggerForParams(params, options = {}) {
-    const key = slugifyId(this.source.key(params));
-    return {
-      rule: {
-        event: this.event.name,
-        source: this.event.source,
-        payload: (0, import_core5.deepMergeFilters)(this.source.filter(params), this.event.filter ?? {}, options.filter ?? {})
-      },
-      source: {
-        version: "2",
-        key,
-        channel: this.source.channel,
-        params,
-        options: {
-          event: typeof this.event.name === "string" ? [
-            this.event.name
-          ] : this.event.name
-        },
-        integration: {
-          id: this.source.integration.id,
-          metadata: this.source.integration.metadata,
-          authSource: this.source.integration.authSource
-        }
-      },
-      accountId: options.accountId
-    };
-  }
-  async register(key, params, options = {}) {
-    const runStore = runLocalStorage.getStore();
-    if (!runStore) {
-      return __privateGet(this, _client).registerTrigger(this.id, key, this.registeredTriggerForParams(params, options));
-    }
-    const { io } = runStore;
-    return await io.runTask([
-      key,
-      "register"
-    ], async (task) => {
-      return __privateGet(this, _client).registerTrigger(this.id, key, this.registeredTriggerForParams(params, options), task.idempotencyKey);
-    }, {
-      name: "Register Dynamic Trigger",
-      properties: [
-        {
-          label: "Dynamic Trigger ID",
-          text: this.id
-        },
-        {
-          label: "ID",
-          text: key
-        }
-      ],
-      params
-    });
-  }
-  attachToJob(triggerClient, job) {
-    triggerClient.attachJobToDynamicTrigger(job, this);
-  }
-  get preprocessRuns() {
-    return true;
-  }
-  async verifyPayload(payload) {
-    return {
-      success: true
-    };
-  }
-};
-__name(DynamicTrigger, "DynamicTrigger");
-_client = new WeakMap();
-_options2 = new WeakMap();
-
-// src/triggers/eventTrigger.ts
-var import_core6 = require("@trigger.dev/core");
-var _options3;
-var EventTrigger = class {
-  constructor(options) {
-    __privateAdd(this, _options3, void 0);
-    __privateSet(this, _options3, options);
-  }
-  toJSON() {
-    return {
-      type: "static",
-      title: __privateGet(this, _options3).name ?? __privateGet(this, _options3).event.title,
-      rule: {
-        event: __privateGet(this, _options3).name ?? __privateGet(this, _options3).event.name,
-        source: __privateGet(this, _options3).source ?? "trigger.dev",
-        payload: (0, import_core6.deepMergeFilters)(__privateGet(this, _options3).filter ?? {}, __privateGet(this, _options3).event.filter ?? {})
-      }
-    };
-  }
-  get event() {
-    return __privateGet(this, _options3).event;
-  }
-  attachToJob(triggerClient, job) {
-  }
-  get preprocessRuns() {
-    return false;
-  }
-  async verifyPayload(payload) {
-    if (__privateGet(this, _options3).verify) {
-      if (payload instanceof Request) {
-        const clonedRequest = payload.clone();
-        return __privateGet(this, _options3).verify(clonedRequest);
-      }
-    }
-    return {
-      success: true
-    };
-  }
-};
-__name(EventTrigger, "EventTrigger");
-_options3 = new WeakMap();
-function eventTrigger(options) {
-  return new EventTrigger({
-    name: options.name,
-    filter: options.filter,
-    event: {
-      name: options.name,
-      title: "Event",
-      source: options.source ?? "trigger.dev",
-      icon: "custom-event",
-      examples: options.examples,
-      parsePayload: (rawPayload) => {
-        if (options.schema) {
-          const results = options.schema.safeParse(rawPayload);
-          if (!results.success) {
-            throw new ParsedPayloadSchemaError(formatSchemaErrors(results.error.issues));
-          }
-          return results.data;
-        }
-        return rawPayload;
-      }
-    }
-  });
-}
-__name(eventTrigger, "eventTrigger");
-
-// src/triggers/scheduled.ts
-var import_core7 = require("@trigger.dev/core");
-var import_cronstrue = __toESM(require("cronstrue"));
-var examples = [
-  {
-    id: "now",
-    name: "Now",
-    icon: "clock",
-    payload: {
-      ts: import_core7.currentDate.marker,
-      lastTimestamp: import_core7.currentDate.marker
-    }
-  }
-];
-var IntervalTrigger = class {
-  constructor(options) {
-    this.options = options;
-  }
-  get event() {
-    return {
-      name: "trigger.scheduled",
-      title: "Schedule",
-      source: "trigger.dev",
-      icon: "schedule-interval",
-      examples,
-      parsePayload: import_core7.ScheduledPayloadSchema.parse,
-      properties: [
-        {
-          label: "Interval",
-          text: `${this.options.seconds}s`
-        }
-      ]
-    };
-  }
-  attachToJob(triggerClient, job) {
-  }
-  get preprocessRuns() {
-    return false;
-  }
-  async verifyPayload(payload) {
-    return {
-      success: true
-    };
-  }
-  toJSON() {
-    return {
-      type: "scheduled",
-      schedule: {
-        type: "interval",
-        options: {
-          seconds: this.options.seconds
-        }
-      }
-    };
-  }
-};
-__name(IntervalTrigger, "IntervalTrigger");
-function intervalTrigger(options) {
-  return new IntervalTrigger(options);
-}
-__name(intervalTrigger, "intervalTrigger");
-var CronTrigger = class {
-  constructor(options) {
-    this.options = options;
-  }
-  get event() {
-    const humanReadable = import_cronstrue.default.toString(this.options.cron, {
-      throwExceptionOnParseError: false
-    });
-    return {
-      name: "trigger.scheduled",
-      title: "Cron Schedule",
-      source: "trigger.dev",
-      icon: "schedule-cron",
-      examples,
-      parsePayload: import_core7.ScheduledPayloadSchema.parse,
-      properties: [
-        {
-          label: "cron",
-          text: this.options.cron
-        },
-        {
-          label: "Schedule",
-          text: humanReadable
-        }
-      ]
-    };
-  }
-  attachToJob(triggerClient, job) {
-  }
-  get preprocessRuns() {
-    return false;
-  }
-  async verifyPayload(payload) {
-    return {
-      success: true
-    };
-  }
-  toJSON() {
-    return {
-      type: "scheduled",
-      schedule: {
-        type: "cron",
-        options: {
-          cron: this.options.cron
-        }
-      }
-    };
-  }
-};
-__name(CronTrigger, "CronTrigger");
-function cronTrigger(options) {
-  return new CronTrigger(options);
-}
-__name(cronTrigger, "cronTrigger");
-var DynamicSchedule = class {
-  constructor(client, options) {
-    this.client = client;
-    this.options = options;
-    client.attachDynamicSchedule(this.options.id);
-  }
-  get id() {
-    return this.options.id;
-  }
-  get event() {
-    return {
-      name: "trigger.scheduled",
-      title: "Dynamic Schedule",
-      source: "trigger.dev",
-      icon: "schedule-dynamic",
-      examples,
-      parsePayload: import_core7.ScheduledPayloadSchema.parse
-    };
-  }
-  async register(key, metadata) {
-    const runStore = runLocalStorage.getStore();
-    if (!runStore) {
-      return this.client.registerSchedule(this.id, key, metadata);
-    }
-    const { io } = runStore;
-    return await io.runTask([
-      key,
-      "register"
-    ], async (task) => {
-      return this.client.registerSchedule(this.id, key, metadata);
-    }, {
-      name: "Register Schedule",
-      icon: metadata.type === "cron" ? "schedule-cron" : "schedule-interval",
-      properties: [
-        {
-          label: "Dynamic Schedule",
-          text: this.id
-        },
-        {
-          label: "Schedule ID",
-          text: key
-        }
-      ],
-      params: metadata
-    });
-  }
-  async unregister(key) {
-    const runStore = runLocalStorage.getStore();
-    if (!runStore) {
-      return this.client.unregisterSchedule(this.id, key);
-    }
-    const { io } = runStore;
-    return await io.runTask([
-      key,
-      "unregister"
-    ], async (task) => {
-      return this.client.unregisterSchedule(this.id, key);
-    }, {
-      name: "Unregister Schedule",
-      icon: "schedule",
-      properties: [
-        {
-          label: "Dynamic Schedule",
-          text: this.id
-        },
-        {
-          label: "Schedule ID",
-          text: key
-        }
-      ]
-    });
-  }
-  attachToJob(triggerClient, job) {
-    triggerClient.attachDynamicScheduleToJob(this.options.id, job);
-  }
-  get preprocessRuns() {
-    return false;
-  }
-  async verifyPayload(payload) {
-    return {
-      success: true
-    };
-  }
-  toJSON() {
-    return {
-      type: "dynamic",
-      id: this.options.id
-    };
-  }
-};
-__name(DynamicSchedule, "DynamicSchedule");
-
-// src/triggerClient.ts
-var import_node_events = __toESM(require("events"));
-
-// package.json
-var version = "0.0.0-canary-20231129101350";
-
-// src/concurrencyLimit.ts
-var ConcurrencyLimit = class {
-  constructor(options) {
-    this.options = options;
-  }
-  get id() {
-    return this.options.id;
-  }
-  get limit() {
-    return this.options.limit;
-  }
-};
-__name(ConcurrencyLimit, "ConcurrencyLimit");
-
-// src/triggerClient.ts
-var registerWebhookEvent = /* @__PURE__ */ __name((key) => ({
-  name: `${import_core8.REGISTER_WEBHOOK}.${key}`,
-  title: "Register Webhook",
-  source: "internal",
-  icon: "webhook",
-  parsePayload: import_core8.RegisterWebhookPayloadSchema.parse
-}), "registerWebhookEvent");
-var registerSourceEvent = {
-  name: import_core8.REGISTER_SOURCE_EVENT_V2,
-  title: "Register Source",
-  source: "internal",
-  icon: "register-source",
-  parsePayload: import_core8.RegisterSourceEventSchemaV2.parse
-};
-var _options4, _registeredJobs, _registeredSources, _registeredWebhooks, _registeredHttpSourceHandlers, _registeredWebhookSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _registeredHttpEndpoints, _authResolvers, _envStore, _eventEmitter, _client2, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn, _handleHttpEndpointRequestForResponse, handleHttpEndpointRequestForResponse_fn, _handleWebhookRequest, handleWebhookRequest_fn, _resolveConnections, resolveConnections_fn, _resolveConnection, resolveConnection_fn, _buildJobsIndex, buildJobsIndex_fn, _buildJobIndex, buildJobIndex_fn, _buildJobIntegrations, buildJobIntegrations_fn, _buildJobIntegration, buildJobIntegration_fn, _logIOStats, logIOStats_fn, _standardResponseHeaders, standardResponseHeaders_fn, _serializeRunMetadata, serializeRunMetadata_fn, _deliverSuccessfulRunNotification, deliverSuccessfulRunNotification_fn, _deliverFailedRunNotification, deliverFailedRunNotification_fn;
-var TriggerClient = class {
-  constructor(options) {
-    __privateAdd(this, _preprocessRun);
-    __privateAdd(this, _executeJob);
-    __privateAdd(this, _convertErrorToExecutionResponse);
-    __privateAdd(this, _createRunContext);
-    __privateAdd(this, _createPreprocessRunContext);
-    __privateAdd(this, _handleHttpSourceRequest);
-    __privateAdd(this, _handleHttpEndpointRequestForResponse);
-    __privateAdd(this, _handleWebhookRequest);
-    __privateAdd(this, _resolveConnections);
-    __privateAdd(this, _resolveConnection);
-    __privateAdd(this, _buildJobsIndex);
-    __privateAdd(this, _buildJobIndex);
-    __privateAdd(this, _buildJobIntegrations);
-    __privateAdd(this, _buildJobIntegration);
-    __privateAdd(this, _logIOStats);
-    __privateAdd(this, _standardResponseHeaders);
-    __privateAdd(this, _serializeRunMetadata);
-    __privateAdd(this, _deliverSuccessfulRunNotification);
-    __privateAdd(this, _deliverFailedRunNotification);
-    __privateAdd(this, _options4, void 0);
-    __privateAdd(this, _registeredJobs, {});
-    __privateAdd(this, _registeredSources, {});
-    __privateAdd(this, _registeredWebhooks, {});
-    __privateAdd(this, _registeredHttpSourceHandlers, {});
-    __privateAdd(this, _registeredWebhookSourceHandlers, {});
-    __privateAdd(this, _registeredDynamicTriggers, {});
-    __privateAdd(this, _jobMetadataByDynamicTriggers, {});
-    __privateAdd(this, _registeredSchedules, {});
-    __privateAdd(this, _registeredHttpEndpoints, {});
-    __privateAdd(this, _authResolvers, {});
-    __privateAdd(this, _envStore, void 0);
-    __privateAdd(this, _eventEmitter, new import_node_events.default());
-    __privateAdd(this, _client2, void 0);
-    __privateAdd(this, _internalLogger, void 0);
-    __publicField(this, "on", __privateGet(this, _eventEmitter).on.bind(__privateGet(this, _eventEmitter)));
-    this.id = options.id;
-    __privateSet(this, _options4, options);
-    __privateSet(this, _client2, new ApiClient(__privateGet(this, _options4)));
-    __privateSet(this, _internalLogger, new import_core8.Logger("trigger.dev", __privateGet(this, _options4).verbose ? "debug" : "log", [
-      "output",
-      "noopTasksSet"
-    ]));
-    __privateSet(this, _envStore, new KeyValueStore(__privateGet(this, _client2)));
-  }
-  async handleRequest(request, timeOrigin = performance.now()) {
-    __privateGet(this, _internalLogger).debug("handling request", {
-      url: request.url,
-      headers: Object.fromEntries(request.headers.entries()),
-      method: request.method
-    });
-    const apiKey = request.headers.get("x-trigger-api-key");
-    const triggerVersion = request.headers.get("x-trigger-version");
-    const authorization = this.authorized(apiKey);
-    switch (authorization) {
-      case "authorized": {
-        break;
-      }
-      case "missing-client": {
-        return {
-          status: 401,
-          body: {
-            message: "Unauthorized: client missing apiKey"
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "missing-header": {
-        return {
-          status: 401,
-          body: {
-            message: "Unauthorized: missing x-trigger-api-key header"
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "unauthorized": {
-        return {
-          status: 401,
-          body: {
-            message: `Forbidden: client apiKey mismatch: Make sure you are using the correct API Key for your environment`
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-    }
-    if (request.method !== "POST") {
-      return {
-        status: 405,
-        body: {
-          message: "Method not allowed (only POST is allowed)"
-        },
-        headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-      };
-    }
-    const action = request.headers.get("x-trigger-action");
-    if (!action) {
-      return {
-        status: 400,
-        body: {
-          message: "Missing x-trigger-action header"
-        },
-        headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-      };
-    }
-    switch (action) {
-      case "PING": {
-        const endpointId = request.headers.get("x-trigger-endpoint-id");
-        if (!endpointId) {
-          return {
-            status: 200,
-            body: {
-              ok: false,
-              error: "Missing endpoint ID"
-            },
-            headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-          };
-        }
-        if (this.id !== endpointId) {
-          return {
-            status: 200,
-            body: {
-              ok: false,
-              error: `Endpoint ID mismatch error. Expected ${this.id}, got ${endpointId}`
-            },
-            headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-          };
-        }
-        return {
-          status: 200,
-          body: {
-            ok: true
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "INDEX_ENDPOINT": {
-        const body = {
-          jobs: __privateMethod(this, _buildJobsIndex, buildJobsIndex_fn).call(this),
-          sources: Object.values(__privateGet(this, _registeredSources)),
-          webhooks: Object.values(__privateGet(this, _registeredWebhooks)),
-          dynamicTriggers: Object.values(__privateGet(this, _registeredDynamicTriggers)).map((trigger) => ({
-            id: trigger.id,
-            jobs: __privateGet(this, _jobMetadataByDynamicTriggers)[trigger.id] ?? [],
-            registerSourceJob: {
-              id: dynamicTriggerRegisterSourceJobId(trigger.id),
-              version: trigger.source.version
-            }
-          })),
-          dynamicSchedules: Object.entries(__privateGet(this, _registeredSchedules)).map(([id, jobs]) => ({
-            id,
-            jobs
-          })),
-          httpEndpoints: Object.entries(__privateGet(this, _registeredHttpEndpoints)).map(([id, endpoint]) => endpoint.toJSON())
-        };
-        return {
-          status: 200,
-          body,
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "INITIALIZE_TRIGGER": {
-        const json = await request.json();
-        const body = import_core8.InitializeTriggerBodySchema.safeParse(json);
-        if (!body.success) {
-          return {
-            status: 400,
-            body: {
-              message: "Invalid trigger body"
-            }
-          };
-        }
-        const dynamicTrigger = __privateGet(this, _registeredDynamicTriggers)[body.data.id];
-        if (!dynamicTrigger) {
-          return {
-            status: 404,
-            body: {
-              message: "Dynamic trigger not found"
-            }
-          };
-        }
-        return {
-          status: 200,
-          body: dynamicTrigger.registeredTriggerForParams(body.data.params),
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "EXECUTE_JOB": {
-        const json = await request.json();
-        const execution = import_core8.RunJobBodySchema.safeParse(json);
-        if (!execution.success) {
-          return {
-            status: 400,
-            body: {
-              message: "Invalid execution"
-            }
-          };
-        }
-        const job = __privateGet(this, _registeredJobs)[execution.data.job.id];
-        if (!job) {
-          return {
-            status: 404,
-            body: {
-              message: "Job not found"
-            }
-          };
-        }
-        const results = await __privateMethod(this, _executeJob, executeJob_fn).call(this, execution.data, job, timeOrigin, triggerVersion);
-        __privateGet(this, _internalLogger).debug("executed job", {
-          results,
-          job: job.id,
-          version: job.version,
-          triggerVersion
-        });
-        const standardHeaders = __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin);
-        standardHeaders["x-trigger-run-metadata"] = __privateMethod(this, _serializeRunMetadata, serializeRunMetadata_fn).call(this, job);
-        return {
-          status: 200,
-          body: results,
-          headers: standardHeaders
-        };
-      }
-      case "PREPROCESS_RUN": {
-        const json = await request.json();
-        const body = import_core8.PreprocessRunBodySchema.safeParse(json);
-        if (!body.success) {
-          return {
-            status: 400,
-            body: {
-              message: "Invalid body"
-            }
-          };
-        }
-        const job = __privateGet(this, _registeredJobs)[body.data.job.id];
-        if (!job) {
-          return {
-            status: 404,
-            body: {
-              message: "Job not found"
-            }
-          };
-        }
-        const results = await __privateMethod(this, _preprocessRun, preprocessRun_fn).call(this, body.data, job);
-        return {
-          status: 200,
-          body: {
-            abort: results.abort,
-            properties: results.properties
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "DELIVER_HTTP_SOURCE_REQUEST": {
-        const headers = import_core8.HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
-        if (!headers.success) {
-          return {
-            status: 400,
-            body: {
-              message: "Invalid headers"
-            }
-          };
-        }
-        const sourceRequestNeedsBody = headers.data["x-ts-http-method"] !== "GET";
-        const sourceRequestInit = {
-          method: headers.data["x-ts-http-method"],
-          headers: headers.data["x-ts-http-headers"],
-          body: sourceRequestNeedsBody ? request.body : void 0
-        };
-        if (sourceRequestNeedsBody) {
-          try {
-            sourceRequestInit.duplex = "half";
-          } catch (error) {
-          }
-        }
-        const sourceRequest = new Request(headers.data["x-ts-http-url"], sourceRequestInit);
-        const key = headers.data["x-ts-key"];
-        const dynamicId = headers.data["x-ts-dynamic-id"];
-        const secret = headers.data["x-ts-secret"];
-        const params = headers.data["x-ts-params"];
-        const data = headers.data["x-ts-data"];
-        const auth = headers.data["x-ts-auth"];
-        const inputMetadata = headers.data["x-ts-metadata"];
-        const source = {
-          key,
-          dynamicId,
-          secret,
-          params,
-          data,
-          auth,
-          metadata: inputMetadata
-        };
-        const { response, events, metadata } = await __privateMethod(this, _handleHttpSourceRequest, handleHttpSourceRequest_fn).call(this, source, sourceRequest);
-        return {
-          status: 200,
-          body: {
-            events,
-            response,
-            metadata
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "DELIVER_HTTP_ENDPOINT_REQUEST_FOR_RESPONSE": {
-        const headers = import_core8.HttpEndpointRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
-        if (!headers.success) {
-          return {
-            status: 400,
-            body: {
-              message: "Invalid headers"
-            }
-          };
-        }
-        const sourceRequestNeedsBody = headers.data["x-ts-http-method"] !== "GET";
-        const sourceRequestInit = {
-          method: headers.data["x-ts-http-method"],
-          headers: headers.data["x-ts-http-headers"],
-          body: sourceRequestNeedsBody ? request.body : void 0
-        };
-        if (sourceRequestNeedsBody) {
-          try {
-            sourceRequestInit.duplex = "half";
-          } catch (error) {
-          }
-        }
-        const sourceRequest = new Request(headers.data["x-ts-http-url"], sourceRequestInit);
-        const key = headers.data["x-ts-key"];
-        const { response } = await __privateMethod(this, _handleHttpEndpointRequestForResponse, handleHttpEndpointRequestForResponse_fn).call(this, {
-          key
-        }, sourceRequest);
-        return {
-          status: 200,
-          body: response,
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "DELIVER_WEBHOOK_REQUEST": {
-        const headers = import_core8.WebhookSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
-        if (!headers.success) {
-          return {
-            status: 400,
-            body: {
-              message: "Invalid headers"
-            }
-          };
-        }
-        const sourceRequestNeedsBody = headers.data["x-ts-http-method"] !== "GET";
-        const sourceRequestInit = {
-          method: headers.data["x-ts-http-method"],
-          headers: headers.data["x-ts-http-headers"],
-          body: sourceRequestNeedsBody ? request.body : void 0
-        };
-        if (sourceRequestNeedsBody) {
-          try {
-            sourceRequestInit.duplex = "half";
-          } catch (error2) {
-          }
-        }
-        const webhookRequest = new Request(headers.data["x-ts-http-url"], sourceRequestInit);
-        const key = headers.data["x-ts-key"];
-        const secret = headers.data["x-ts-secret"];
-        const params = headers.data["x-ts-params"];
-        const ctx = {
-          key,
-          secret,
-          params
-        };
-        const { response, verified, error } = await __privateMethod(this, _handleWebhookRequest, handleWebhookRequest_fn).call(this, webhookRequest, ctx);
-        return {
-          status: 200,
-          body: {
-            response,
-            verified,
-            error
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "VALIDATE": {
-        return {
-          status: 200,
-          body: {
-            ok: true,
-            endpointId: this.id
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "PROBE_EXECUTION_TIMEOUT": {
-        const json = await request.json();
-        const timeout = json?.timeout ?? 15 * 60 * 1e3;
-        await new Promise((resolve) => setTimeout(resolve, timeout));
-        return {
-          status: 200,
-          body: {
-            ok: true
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-      case "RUN_NOTIFICATION": {
-        const rawJson = await request.json();
-        const runNotification = rawJson;
-        if (runNotification.ok) {
-          await __privateMethod(this, _deliverSuccessfulRunNotification, deliverSuccessfulRunNotification_fn).call(this, runNotification);
-        } else {
-          await __privateMethod(this, _deliverFailedRunNotification, deliverFailedRunNotification_fn).call(this, runNotification);
-        }
-        return {
-          status: 200,
-          body: {
-            ok: true
-          },
-          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-        };
-      }
-    }
-    return {
-      status: 405,
-      body: {
-        message: "Method not allowed"
-      },
-      headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
-    };
-  }
-  defineJob(options) {
-    const existingRegisteredJob = __privateGet(this, _registeredJobs)[options.id];
-    if (existingRegisteredJob) {
-      console.warn((0, import_colorette.yellow)(`[@trigger.dev/sdk] Warning: The Job "${existingRegisteredJob.id}" you're attempting to define has already been defined. Please assign a different ID to the job.`));
-    }
-    return new Job(this, options);
-  }
-  defineAuthResolver(integration, resolver) {
-    __privateGet(this, _authResolvers)[integration.id] = resolver;
-    return this;
-  }
-  defineDynamicSchedule(options) {
-    return new DynamicSchedule(this, options);
-  }
-  defineDynamicTrigger(options) {
-    return new DynamicTrigger(this, options);
-  }
-  defineHttpEndpoint(options, suppressWarnings = false) {
-    const existingHttpEndpoint = __privateGet(this, _registeredHttpEndpoints)[options.id];
-    if (!suppressWarnings && existingHttpEndpoint) {
-      console.warn((0, import_colorette.yellow)(`[@trigger.dev/sdk] Warning: The HttpEndpoint "${existingHttpEndpoint.id}" you're attempting to define has already been defined. Please assign a different ID to the HttpEndpoint.`));
-    }
-    const endpoint = httpEndpoint(options);
-    __privateGet(this, _registeredHttpEndpoints)[endpoint.id] = endpoint;
-    return endpoint;
-  }
-  defineConcurrencyLimit(options) {
-    return new ConcurrencyLimit(options);
-  }
-  attach(job) {
-    __privateGet(this, _registeredJobs)[job.id] = job;
-    job.trigger.attachToJob(this, job);
-  }
-  attachDynamicTrigger(trigger) {
-    __privateGet(this, _registeredDynamicTriggers)[trigger.id] = trigger;
-    this.defineJob({
-      id: dynamicTriggerRegisterSourceJobId(trigger.id),
-      name: `Register dynamic trigger ${trigger.id}`,
-      version: trigger.source.version,
-      trigger: new EventTrigger({
-        event: registerSourceEvent,
-        filter: {
-          dynamicTriggerId: [
-            trigger.id
-          ]
-        }
-      }),
-      integrations: {
-        integration: trigger.source.integration
-      },
-      run: async (event, io, ctx) => {
-        const updates = await trigger.source.register(event.source.params, event, io, ctx);
-        if (!updates) {
-          return;
-        }
-        return await io.updateSource("update-source", {
-          key: event.source.key,
-          ...updates
-        });
-      },
-      __internal: true
-    });
-  }
-  attachJobToDynamicTrigger(job, trigger) {
-    const jobs = __privateGet(this, _jobMetadataByDynamicTriggers)[trigger.id] ?? [];
-    jobs.push({
-      id: job.id,
-      version: job.version
-    });
-    __privateGet(this, _jobMetadataByDynamicTriggers)[trigger.id] = jobs;
-  }
-  attachSource(options) {
-    __privateGet(this, _registeredHttpSourceHandlers)[options.key] = async (s, r) => {
-      return await options.source.handle(s, r, __privateGet(this, _internalLogger));
-    };
-    let registeredSource = __privateGet(this, _registeredSources)[options.key];
-    if (!registeredSource) {
-      registeredSource = {
-        version: "2",
-        channel: options.source.channel,
-        key: options.key,
-        params: options.params,
-        options: {},
-        integration: {
-          id: options.source.integration.id,
-          metadata: options.source.integration.metadata,
-          authSource: options.source.integration.authSource
-        },
-        registerSourceJob: {
-          id: options.key,
-          version: options.source.version
-        }
-      };
-    }
-    const newOptions = deepMergeOptions({
-      event: typeof options.event.name === "string" ? [
-        options.event.name
-      ] : options.event.name
-    }, options.options ?? {});
-    registeredSource.options = deepMergeOptions(registeredSource.options, newOptions);
-    __privateGet(this, _registeredSources)[options.key] = registeredSource;
-    new Job(this, {
-      id: options.key,
-      name: options.key,
-      version: options.source.version,
-      trigger: new EventTrigger({
-        event: registerSourceEvent,
-        filter: {
-          source: {
-            key: [
-              options.key
-            ]
-          }
-        }
-      }),
-      integrations: {
-        integration: options.source.integration
-      },
-      run: async (event, io, ctx) => {
-        const updates = await options.source.register(options.params, event, io, ctx);
-        if (!updates) {
-          return;
-        }
-        return await io.updateSource("update-source", {
-          key: options.key,
-          ...updates
-        });
-      },
-      __internal: true
-    });
-  }
-  attachDynamicSchedule(key) {
-    const jobs = __privateGet(this, _registeredSchedules)[key] ?? [];
-    __privateGet(this, _registeredSchedules)[key] = jobs;
-  }
-  attachDynamicScheduleToJob(key, job) {
-    const jobs = __privateGet(this, _registeredSchedules)[key] ?? [];
-    jobs.push({
-      id: job.id,
-      version: job.version
-    });
-    __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);
-  }
-  async getAuth(id) {
-    return __privateGet(this, _client2).getAuth(this.id, id);
-  }
-  async sendEvent(event, options) {
-    return __privateGet(this, _client2).sendEvent(event, options);
-  }
-  async sendEvents(events, options) {
-    return __privateGet(this, _client2).sendEvents(events, options);
-  }
-  async cancelEvent(eventId) {
-    return __privateGet(this, _client2).cancelEvent(eventId);
-  }
-  async cancelRunsForEvent(eventId) {
-    return __privateGet(this, _client2).cancelRunsForEvent(eventId);
-  }
-  async updateStatus(runId, id, status) {
-    return __privateGet(this, _client2).updateStatus(runId, id, status);
-  }
-  async registerSchedule(id, key, schedule) {
-    return __privateGet(this, _client2).registerSchedule(this.id, id, key, schedule);
-  }
-  async unregisterSchedule(id, key) {
-    return __privateGet(this, _client2).unregisterSchedule(this.id, id, key);
-  }
-  async getEvent(eventId) {
-    return __privateGet(this, _client2).getEvent(eventId);
-  }
-  async getRun(runId, options) {
-    return __privateGet(this, _client2).getRun(runId, options);
-  }
-  async cancelRun(runId) {
-    return __privateGet(this, _client2).cancelRun(runId);
-  }
-  async getRuns(jobSlug, options) {
-    return __privateGet(this, _client2).getRuns(jobSlug, options);
-  }
-  async getRunStatuses(runId) {
-    return __privateGet(this, _client2).getRunStatuses(runId);
-  }
-  async invokeJob(jobId, payload, options) {
-    return __privateGet(this, _client2).invokeJob(jobId, payload, options);
-  }
-  async createEphemeralEventDispatcher(payload) {
-    return __privateGet(this, _client2).createEphemeralEventDispatcher(payload);
-  }
-  get store() {
-    return {
-      env: __privateGet(this, _envStore)
-    };
-  }
-  authorized(apiKey) {
-    if (typeof apiKey !== "string") {
-      return "missing-header";
-    }
-    const localApiKey = __privateGet(this, _options4).apiKey ?? process.env.TRIGGER_API_KEY;
-    if (!localApiKey) {
-      return "missing-client";
-    }
-    return apiKey === localApiKey ? "authorized" : "unauthorized";
-  }
-  apiKey() {
-    return __privateGet(this, _options4).apiKey ?? process.env.TRIGGER_API_KEY;
-  }
-};
-__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();
-preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
-  const context = __privateMethod(this, _createPreprocessRunContext, createPreprocessRunContext_fn).call(this, body);
-  const parsedPayload = job.trigger.event.parsePayload(body.event.payload ?? {});
-  const properties = job.trigger.event.runProperties?.(parsedPayload) ?? [];
-  return {
-    abort: false,
-    properties
-  };
-}, "#preprocessRun");
-_executeJob = new WeakSet();
-executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, timeOrigin, triggerVersion) {
-  __privateGet(this, _internalLogger).debug("executing job", {
-    execution: body1,
-    job: job1.id,
-    version: job1.version,
-    triggerVersion
-  });
-  const context = __privateMethod(this, _createRunContext, createRunContext_fn).call(this, body1);
-  const io = new IO({
-    id: body1.run.id,
-    jobId: job1.id,
-    cachedTasks: body1.tasks,
-    cachedTasksCursor: body1.cachedTaskCursor,
-    yieldedExecutions: body1.yieldedExecutions ?? [],
-    noopTasksSet: body1.noopTasksSet,
-    apiClient: __privateGet(this, _client2),
-    logger: __privateGet(this, _internalLogger),
-    client: this,
-    context,
-    jobLogLevel: job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info",
-    jobLogger: __privateGet(this, _options4).ioLogLocalEnabled ? new import_core8.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info") : void 0,
-    serverVersion: triggerVersion,
-    timeOrigin,
-    executionTimeout: body1.runChunkExecutionLimit
-  });
-  const resolvedConnections = await __privateMethod(this, _resolveConnections, resolveConnections_fn).call(this, context, job1.options.integrations, body1.connections);
-  if (!resolvedConnections.ok) {
-    return {
-      status: "UNRESOLVED_AUTH_ERROR",
-      issues: resolvedConnections.issues
-    };
-  }
-  const ioWithConnections = createIOWithIntegrations(io, resolvedConnections.data, job1.options.integrations);
-  try {
-    const parsedPayload = job1.trigger.event.parsePayload(body1.event.payload ?? {});
-    if (!context.run.isTest) {
-      const verified = await job1.trigger.verifyPayload(parsedPayload);
-      if (!verified.success) {
-        return {
-          status: "ERROR",
-          error: {
-            message: `Payload verification failed. ${verified.reason}`
-          }
-        };
-      }
-    }
-    const output = await runLocalStorage.runWith({
-      io,
-      ctx: context
-    }, () => {
-      return job1.options.run(parsedPayload, ioWithConnections, context);
-    });
-    if (__privateGet(this, _options4).verbose) {
-      __privateMethod(this, _logIOStats, logIOStats_fn).call(this, io.stats);
-    }
-    return {
-      status: "SUCCESS",
-      output
-    };
-  } catch (error) {
-    if (__privateGet(this, _options4).verbose) {
-      __privateMethod(this, _logIOStats, logIOStats_fn).call(this, io.stats);
-    }
-    if (error instanceof ResumeWithParallelTaskError) {
-      return {
-        status: "RESUME_WITH_PARALLEL_TASK",
-        task: error.task,
-        childErrors: error.childErrors.map((childError) => {
-          return __privateMethod(this, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn).call(this, childError, body1);
-        })
-      };
-    }
-    return __privateMethod(this, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn).call(this, error, body1);
-  }
-}, "#executeJob");
-_convertErrorToExecutionResponse = new WeakSet();
-convertErrorToExecutionResponse_fn = /* @__PURE__ */ __name(function(error, body2) {
-  if (error instanceof AutoYieldExecutionError) {
-    return {
-      status: "AUTO_YIELD_EXECUTION",
-      location: error.location,
-      timeRemaining: error.timeRemaining,
-      timeElapsed: error.timeElapsed,
-      limit: body2.runChunkExecutionLimit
-    };
-  }
-  if (error instanceof AutoYieldWithCompletedTaskExecutionError) {
-    return {
-      status: "AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK",
-      id: error.id,
-      properties: error.properties,
-      output: error.output,
-      data: {
-        ...error.data,
-        limit: body2.runChunkExecutionLimit
-      }
-    };
-  }
-  if (error instanceof YieldExecutionError) {
-    return {
-      status: "YIELD_EXECUTION",
-      key: error.key
-    };
-  }
-  if (error instanceof ParsedPayloadSchemaError) {
-    return {
-      status: "INVALID_PAYLOAD",
-      errors: error.schemaErrors
-    };
-  }
-  if (error instanceof ResumeWithTaskError) {
-    return {
-      status: "RESUME_WITH_TASK",
-      task: error.task
-    };
-  }
-  if (error instanceof RetryWithTaskError) {
-    return {
-      status: "RETRY_WITH_TASK",
-      task: error.task,
-      error: error.cause,
-      retryAt: error.retryAt
-    };
-  }
-  if (error instanceof CanceledWithTaskError) {
-    return {
-      status: "CANCELED",
-      task: error.task
-    };
-  }
-  if (error instanceof ErrorWithTask) {
-    const errorWithStack2 = import_core8.ErrorWithStackSchema.safeParse(error.cause.output);
-    if (errorWithStack2.success) {
-      return {
-        status: "ERROR",
-        error: errorWithStack2.data,
-        task: error.cause
-      };
-    }
-    return {
-      status: "ERROR",
-      error: {
-        message: JSON.stringify(error.cause.output)
-      },
-      task: error.cause
-    };
-  }
-  if (error instanceof RetryWithTaskError) {
-    const errorWithStack2 = import_core8.ErrorWithStackSchema.safeParse(error.cause);
-    if (errorWithStack2.success) {
-      return {
-        status: "ERROR",
-        error: errorWithStack2.data,
-        task: error.task
-      };
-    }
-    return {
-      status: "ERROR",
-      error: {
-        message: "Unknown error"
-      },
-      task: error.task
-    };
-  }
-  const errorWithStack = import_core8.ErrorWithStackSchema.safeParse(error);
-  if (errorWithStack.success) {
-    return {
-      status: "ERROR",
-      error: errorWithStack.data
-    };
-  }
-  const message = typeof error === "string" ? error : JSON.stringify(error);
-  return {
-    status: "ERROR",
-    error: {
-      name: "Unknown error",
-      message
-    }
-  };
-}, "#convertErrorToExecutionResponse");
-_createRunContext = new WeakSet();
-createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
-  const { event, organization, project, environment, job, run, source } = execution;
-  return {
-    event: {
-      id: event.id,
-      name: event.name,
-      context: event.context,
-      timestamp: event.timestamp
-    },
-    organization,
-    project: project ?? {
-      id: "unknown",
-      name: "unknown",
-      slug: "unknown"
-    },
-    environment,
-    job,
-    run,
-    account: execution.account,
-    source
-  };
-}, "#createRunContext");
-_createPreprocessRunContext = new WeakSet();
-createPreprocessRunContext_fn = /* @__PURE__ */ __name(function(body3) {
-  const { event, organization, environment, job, run, account } = body3;
-  return {
-    event: {
-      id: event.id,
-      name: event.name,
-      context: event.context,
-      timestamp: event.timestamp
-    },
-    organization,
-    environment,
-    job,
-    run,
-    account
-  };
-}, "#createPreprocessRunContext");
-_handleHttpSourceRequest = new WeakSet();
-handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourceRequest) {
-  __privateGet(this, _internalLogger).debug("Handling HTTP source request", {
-    source
-  });
-  if (source.dynamicId) {
-    const dynamicTrigger = __privateGet(this, _registeredDynamicTriggers)[source.dynamicId];
-    if (!dynamicTrigger) {
-      __privateGet(this, _internalLogger).debug("No dynamic trigger registered for HTTP source", {
-        source
-      });
-      return {
-        response: {
-          status: 200,
-          body: {
-            ok: true
-          }
-        },
-        events: []
-      };
-    }
-    const results2 = await dynamicTrigger.source.handle(source, sourceRequest, __privateGet(this, _internalLogger));
-    if (!results2) {
-      return {
-        events: [],
-        response: {
-          status: 200,
-          body: {
-            ok: true
-          }
-        }
-      };
-    }
-    return {
-      events: results2.events,
-      response: results2.response ?? {
-        status: 200,
-        body: {
-          ok: true
-        }
-      },
-      metadata: results2.metadata
-    };
-  }
-  const handler = __privateGet(this, _registeredHttpSourceHandlers)[source.key];
-  if (!handler) {
-    __privateGet(this, _internalLogger).debug("No handler registered for HTTP source", {
-      source
-    });
-    return {
-      response: {
-        status: 200,
-        body: {
-          ok: true
-        }
-      },
-      events: []
-    };
-  }
-  const results = await handler(source, sourceRequest);
-  if (!results) {
-    return {
-      events: [],
-      response: {
-        status: 200,
-        body: {
-          ok: true
-        }
-      }
-    };
-  }
-  return {
-    events: results.events,
-    response: results.response ?? {
-      status: 200,
-      body: {
-        ok: true
-      }
-    },
-    metadata: results.metadata
-  };
-}, "#handleHttpSourceRequest");
-_handleHttpEndpointRequestForResponse = new WeakSet();
-handleHttpEndpointRequestForResponse_fn = /* @__PURE__ */ __name(async function(data, sourceRequest1) {
-  __privateGet(this, _internalLogger).debug("Handling HTTP Endpoint request for response", {
-    data
-  });
-  const httpEndpoint2 = __privateGet(this, _registeredHttpEndpoints)[data.key];
-  if (!httpEndpoint2) {
-    __privateGet(this, _internalLogger).debug("No handler registered for HTTP Endpoint", {
-      data
-    });
-    return {
-      response: {
-        status: 200,
-        body: {
-          ok: true
-        }
-      }
-    };
-  }
-  const handledResponse = await httpEndpoint2.handleRequest(sourceRequest1);
-  if (!handledResponse) {
-    __privateGet(this, _internalLogger).debug("There's no HTTP Endpoint respondWith.handler()", {
-      data
-    });
-    return {
-      response: {
-        status: 200,
-        body: {
-          ok: true
-        }
-      }
-    };
-  }
-  let body;
-  try {
-    body = await handledResponse.text();
-  } catch (error) {
-    __privateGet(this, _internalLogger).error(`Error reading httpEndpoint ${httpEndpoint2.id} respondWith.handler Response`, {
-      error
-    });
-  }
-  const response = {
-    status: handledResponse.status,
-    headers: handledResponse.headers ? Object.fromEntries(handledResponse.headers.entries()) : void 0,
-    body
-  };
-  __privateGet(this, _internalLogger).info(`httpEndpoint ${httpEndpoint2.id} respondWith.handler response`, {
-    response
-  });
-  return {
-    response
-  };
-}, "#handleHttpEndpointRequestForResponse");
-_handleWebhookRequest = new WeakSet();
-handleWebhookRequest_fn = /* @__PURE__ */ __name(async function(request, ctx) {
-  __privateGet(this, _internalLogger).debug("Handling webhook request", {
-    ctx
-  });
-  const okResponse = {
-    status: 200,
-    body: {
-      ok: true
-    }
-  };
-  const handlers = __privateGet(this, _registeredWebhookSourceHandlers)[ctx.key];
-  if (!handlers) {
-    __privateGet(this, _internalLogger).debug("No handler registered for webhook", {
-      ctx
-    });
-    return {
-      response: okResponse,
-      verified: false
-    };
-  }
-  const { verify, generateEvents } = handlers;
-  const verifyResult = await verify(request, this, ctx);
-  if (!verifyResult.success) {
-    return {
-      response: okResponse,
-      verified: false,
-      error: verifyResult.reason
-    };
-  }
-  await generateEvents(request, this, ctx);
-  return {
-    response: okResponse,
-    verified: true
-  };
-}, "#handleWebhookRequest");
-_resolveConnections = new WeakSet();
-resolveConnections_fn = /* @__PURE__ */ __name(async function(ctx1, integrations, connections) {
-  if (!integrations) {
-    return {
-      ok: true,
-      data: {}
-    };
-  }
-  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, ctx1, integration, auth);
-    if (result.ok) {
-      return {
-        ok: true,
-        auth: result.auth,
-        key
-      };
-    } else {
-      return {
-        ok: false,
-        error: result.error,
-        key
-      };
-    }
-  }));
-  const allResolved = resolvedAuthResults.every((result) => result.ok);
-  if (allResolved) {
-    return {
-      ok: true,
-      data: resolvedAuthResults.reduce((acc, result) => {
-        acc[result.key] = result.auth;
-        return acc;
-      }, {})
-    };
-  } else {
-    return {
-      ok: false,
-      issues: resolvedAuthResults.reduce((acc, result) => {
-        if (result.ok) {
-          return acc;
-        }
-        const integration = integrations[result.key];
-        acc[result.key] = {
-          id: integration.id,
-          error: result.error
-        };
-        return acc;
-      }, {})
-    };
-  }
-}, "#resolveConnections");
-_resolveConnection = new WeakSet();
-resolveConnection_fn = /* @__PURE__ */ __name(async function(ctx2, integration, auth) {
-  if (auth) {
-    return {
-      ok: true,
-      auth
-    };
-  }
-  const authResolver = __privateGet(this, _authResolvers)[integration.id];
-  if (!authResolver) {
-    if (integration.authSource === "HOSTED") {
-      return {
-        ok: false,
-        error: `Something went wrong: Integration ${integration.id} is missing auth credentials from Trigger.dev`
-      };
-    }
-    return {
-      ok: true,
-      auth: void 0
-    };
-  }
-  try {
-    const resolvedAuth = await authResolver(ctx2, integration);
-    if (!resolvedAuth) {
-      return {
-        ok: false,
-        error: `Auth could not be resolved for ${integration.id}: auth resolver returned null or undefined`
-      };
-    }
-    return {
-      ok: true,
-      auth: resolvedAuth.type === "apiKey" ? {
-        type: "apiKey",
-        accessToken: resolvedAuth.token,
-        additionalFields: resolvedAuth.additionalFields
-      } : {
-        type: "oauth2",
-        accessToken: resolvedAuth.token,
-        additionalFields: resolvedAuth.additionalFields
-      }
-    };
-  } catch (resolverError) {
-    if (resolverError instanceof Error) {
-      return {
-        ok: false,
-        error: `Auth could not be resolved for ${integration.id}: auth resolver threw. ${resolverError.name}: ${resolverError.message}`
-      };
-    } else if (typeof resolverError === "string") {
-      return {
-        ok: false,
-        error: `Auth could not be resolved for ${integration.id}: auth resolver threw an error: ${resolverError}`
-      };
-    }
-    return {
-      ok: false,
-      error: `Auth could not be resolved for ${integration.id}: auth resolver threw an unknown error: ${JSON.stringify(resolverError)}`
-    };
-  }
-}, "#resolveConnection");
-_buildJobsIndex = new WeakSet();
-buildJobsIndex_fn = /* @__PURE__ */ __name(function() {
-  return Object.values(__privateGet(this, _registeredJobs)).map((job) => __privateMethod(this, _buildJobIndex, buildJobIndex_fn).call(this, job));
-}, "#buildJobsIndex");
-_buildJobIndex = new WeakSet();
-buildJobIndex_fn = /* @__PURE__ */ __name(function(job2) {
-  const internal = job2.options.__internal;
-  return {
-    id: job2.id,
-    name: job2.name,
-    version: job2.version,
-    event: job2.trigger.event,
-    trigger: job2.trigger.toJSON(),
-    integrations: __privateMethod(this, _buildJobIntegrations, buildJobIntegrations_fn).call(this, job2),
-    startPosition: "latest",
-    enabled: job2.enabled,
-    preprocessRuns: job2.trigger.preprocessRuns,
-    internal,
-    concurrencyLimit: typeof job2.options.concurrencyLimit === "number" ? job2.options.concurrencyLimit : typeof job2.options.concurrencyLimit === "object" ? {
-      id: job2.options.concurrencyLimit.id,
-      limit: job2.options.concurrencyLimit.limit
-    } : void 0
-  };
-}, "#buildJobIndex");
-_buildJobIntegrations = new WeakSet();
-buildJobIntegrations_fn = /* @__PURE__ */ __name(function(job3) {
-  return Object.keys(job3.options.integrations ?? {}).reduce((acc, key) => {
-    const integration = job3.options.integrations[key];
-    acc[key] = __privateMethod(this, _buildJobIntegration, buildJobIntegration_fn).call(this, integration);
-    return acc;
-  }, {});
-}, "#buildJobIntegrations");
-_buildJobIntegration = new WeakSet();
-buildJobIntegration_fn = /* @__PURE__ */ __name(function(integration1) {
-  const authSource = __privateGet(this, _authResolvers)[integration1.id] ? "RESOLVER" : integration1.authSource;
-  return {
-    id: integration1.id,
-    metadata: integration1.metadata,
-    authSource
-  };
-}, "#buildJobIntegration");
-_logIOStats = new WeakSet();
-logIOStats_fn = /* @__PURE__ */ __name(function(stats) {
-  __privateGet(this, _internalLogger).debug("IO stats", {
-    stats
-  });
-}, "#logIOStats");
-_standardResponseHeaders = new WeakSet();
-standardResponseHeaders_fn = /* @__PURE__ */ __name(function(start) {
-  return {
-    "Trigger-Version": import_core8.API_VERSIONS.LAZY_LOADED_CACHED_TASKS,
-    "Trigger-SDK-Version": version,
-    "X-Trigger-Request-Timing": `dur=${performance.now() - start / 1e3}`
-  };
-}, "#standardResponseHeaders");
-_serializeRunMetadata = new WeakSet();
-serializeRunMetadata_fn = /* @__PURE__ */ __name(function(job4) {
-  const metadata = {};
-  if (__privateGet(this, _eventEmitter).listenerCount("runSucceeeded") > 0 || typeof job4.options.onSuccess === "function") {
-    metadata["successSubscription"] = true;
-  }
-  if (__privateGet(this, _eventEmitter).listenerCount("runFailed") > 0 || typeof job4.options.onFailure === "function") {
-    metadata["failedSubscription"] = true;
-  }
-  return JSON.stringify(metadata);
-}, "#serializeRunMetadata");
-_deliverSuccessfulRunNotification = new WeakSet();
-deliverSuccessfulRunNotification_fn = /* @__PURE__ */ __name(async function(notification) {
-  __privateGet(this, _internalLogger).debug("delivering successful run notification", {
-    notification
-  });
-  __privateGet(this, _eventEmitter).emit("runSucceeeded", notification);
-  const job = __privateGet(this, _registeredJobs)[notification.job.id];
-  if (!job) {
-    return;
-  }
-  if (typeof job.options.onSuccess === "function") {
-    await job.options.onSuccess(notification);
-  }
-}, "#deliverSuccessfulRunNotification");
-_deliverFailedRunNotification = new WeakSet();
-deliverFailedRunNotification_fn = /* @__PURE__ */ __name(async function(notification1) {
-  __privateGet(this, _internalLogger).debug("delivering failed run notification", {
-    notification: notification1
-  });
-  __privateGet(this, _eventEmitter).emit("runFailed", notification1);
-  const job = __privateGet(this, _registeredJobs)[notification1.job.id];
-  if (!job) {
-    return;
-  }
-  if (typeof job.options.onFailure === "function") {
-    await job.options.onFailure(notification1);
-  }
-}, "#deliverFailedRunNotification");
-function dynamicTriggerRegisterSourceJobId(id) {
-  return `register-dynamic-trigger-${id}`;
-}
-__name(dynamicTriggerRegisterSourceJobId, "dynamicTriggerRegisterSourceJobId");
-function deepMergeOptions(obj1, obj2) {
-  const mergedOptions = {
-    ...obj1
-  };
-  for (const key in obj2) {
-    if (obj2.hasOwnProperty(key)) {
-      if (key in mergedOptions) {
-        mergedOptions[key] = [
-          ...mergedOptions[key],
-          ...obj2[key]
-        ];
-      } else {
-        mergedOptions[key] = obj2[key];
-      }
-    }
-  }
-  return mergedOptions;
-}
-__name(deepMergeOptions, "deepMergeOptions");
-
-// src/triggers/externalSource.ts
-var import_core9 = require("@trigger.dev/core");
-var ExternalSource = class {
-  constructor(channel, options) {
-    this.options = options;
-    this.channel = channel;
-  }
-  async handle(source, rawEvent, logger) {
-    return this.options.handler({
-      source: {
-        ...source,
-        params: source.params
-      },
-      rawEvent
-    }, logger, this.options.integration);
-  }
-  filter(params, options) {
-    return this.options.filter?.(params, options) ?? {};
-  }
-  properties(params) {
-    return this.options.properties?.(params) ?? [];
-  }
-  async register(params, registerEvent, io, ctx) {
-    const { result: event, ommited: source } = omit(registerEvent, "source");
-    const { result: sourceWithoutChannel, ommited: channel } = omit(source, "channel");
-    const { result: channelWithoutType } = omit(channel, "type");
-    const updates = await this.options.register({
-      ...event,
-      source: {
-        ...sourceWithoutChannel,
-        ...channelWithoutType
-      },
-      params
-    }, io, ctx);
-    return updates;
-  }
-  key(params) {
-    const parts = [
-      this.options.id,
-      this.channel
-    ];
-    parts.push(this.options.key(params));
-    parts.push(this.integration.id);
-    return 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(ExternalSource, "ExternalSource");
-var ExternalSourceTrigger = class {
-  constructor(options) {
-    this.options = options;
-  }
-  get event() {
-    return this.options.event;
-  }
-  toJSON() {
-    return {
-      type: "static",
-      title: "External Source",
-      rule: {
-        event: this.event.name,
-        payload: (0, import_core9.deepMergeFilters)(this.options.source.filter(this.options.params, this.options.options), this.event.filter ?? {}, this.options.params.filter ?? {}),
-        source: this.event.source
-      },
-      properties: this.options.source.properties(this.options.params)
-    };
-  }
-  attachToJob(triggerClient, job) {
-    triggerClient.attachSource({
-      key: slugifyId(this.options.source.key(this.options.params)),
-      source: this.options.source,
-      event: this.options.event,
-      params: this.options.params,
-      options: this.options.options
-    });
-  }
-  get preprocessRuns() {
-    return true;
-  }
-  async verifyPayload(payload) {
-    return {
-      success: true
-    };
-  }
-};
-__name(ExternalSourceTrigger, "ExternalSourceTrigger");
-function omit(obj, key) {
-  const result = {};
-  for (const k of Object.keys(obj)) {
-    if (k === key)
-      continue;
-    result[k] = obj[k];
-  }
-  return {
-    result,
-    ommited: obj[key]
-  };
-}
-__name(omit, "omit");
-
-// src/triggers/notifications.ts
-var import_core10 = require("@trigger.dev/core");
-function missingConnectionNotification(integrations) {
-  return new MissingConnectionNotification({
-    integrations
-  });
-}
-__name(missingConnectionNotification, "missingConnectionNotification");
-function missingConnectionResolvedNotification(integrations) {
-  return new MissingConnectionResolvedNotification({
-    integrations
-  });
-}
-__name(missingConnectionResolvedNotification, "missingConnectionResolvedNotification");
-var MissingConnectionNotification = class {
-  constructor(options) {
-    this.options = options;
-  }
-  get event() {
-    return {
-      name: import_core10.MISSING_CONNECTION_NOTIFICATION,
-      title: "Missing Connection Notification",
-      source: "trigger.dev",
-      icon: "connection-alert",
-      parsePayload: import_core10.MissingConnectionNotificationPayloadSchema.parse,
-      properties: [
-        {
-          label: "Integrations",
-          text: this.options.integrations.map((i) => i.id).join(", ")
-        }
-      ]
-    };
-  }
-  attachToJob(triggerClient, job) {
-  }
-  get preprocessRuns() {
-    return false;
-  }
-  async verifyPayload(payload) {
-    return {
-      success: true
-    };
-  }
-  toJSON() {
-    return {
-      type: "static",
-      title: this.event.title,
-      rule: {
-        event: this.event.name,
-        source: "trigger.dev",
-        payload: {
-          client: {
-            id: this.options.integrations.map((i) => i.id)
-          }
-        }
-      }
-    };
-  }
-};
-__name(MissingConnectionNotification, "MissingConnectionNotification");
-var MissingConnectionResolvedNotification = class {
-  constructor(options) {
-    this.options = options;
-  }
-  get event() {
-    return {
-      name: import_core10.MISSING_CONNECTION_RESOLVED_NOTIFICATION,
-      title: "Missing Connection Resolved Notification",
-      source: "trigger.dev",
-      icon: "connection-alert",
-      parsePayload: import_core10.MissingConnectionResolvedNotificationPayloadSchema.parse,
-      properties: [
-        {
-          label: "Integrations",
-          text: this.options.integrations.map((i) => i.id).join(", ")
-        }
-      ]
-    };
-  }
-  attachToJob(triggerClient, job) {
-  }
-  get preprocessRuns() {
-    return false;
-  }
-  async verifyPayload(payload) {
-    return {
-      success: true
-    };
-  }
-  toJSON() {
-    return {
-      type: "static",
-      title: this.event.title,
-      rule: {
-        event: this.event.name,
-        source: "trigger.dev",
-        payload: {
-          client: {
-            id: this.options.integrations.map((i) => i.id)
-          }
-        }
-      }
-    };
-  }
-};
-__name(MissingConnectionResolvedNotification, "MissingConnectionResolvedNotification");
-
-// src/triggers/invokeTrigger.ts
-var _options5;
-var InvokeTrigger = class {
-  constructor(options) {
-    __privateAdd(this, _options5, void 0);
-    __privateSet(this, _options5, options);
-  }
-  toJSON() {
-    return {
-      type: "invoke"
-    };
-  }
-  get event() {
-    return {
-      name: "invoke",
-      title: "Manual Invoke",
-      source: "trigger.dev",
-      examples: __privateGet(this, _options5).examples ?? [],
-      icon: "trigger",
-      parsePayload: (rawPayload) => {
-        if (__privateGet(this, _options5).schema) {
-          const results = __privateGet(this, _options5).schema.safeParse(rawPayload);
-          if (!results.success) {
-            throw new ParsedPayloadSchemaError(formatSchemaErrors(results.error.issues));
-          }
-          return results.data;
-        }
-        return rawPayload;
-      },
-      parseInvokePayload: (rawPayload) => {
-        if (__privateGet(this, _options5).schema) {
-          const results = __privateGet(this, _options5).schema.safeParse(rawPayload);
-          if (!results.success) {
-            throw new ParsedPayloadSchemaError(formatSchemaErrors(results.error.issues));
-          }
-          return results.data;
-        }
-        return rawPayload;
-      }
-    };
-  }
-  attachToJob(triggerClient, job) {
-  }
-  get preprocessRuns() {
-    return false;
-  }
-  async verifyPayload() {
-    return {
-      success: true
-    };
-  }
-};
-__name(InvokeTrigger, "InvokeTrigger");
-_options5 = new WeakMap();
-function invokeTrigger(options) {
-  return new InvokeTrigger(options ?? {});
-}
-__name(invokeTrigger, "invokeTrigger");
-
-// src/triggers/webhook.ts
-var import_core11 = require("@trigger.dev/core");
-var import_node_crypto2 = require("crypto");
-var _shortHash, shortHash_fn;
-var WebhookSource = class {
-  constructor(options) {
-    __privateAdd(this, _shortHash);
-    this.options = options;
-  }
-  async generateEvents(request, client, ctx) {
-    return this.options.generateEvents({
-      request,
-      client,
-      ctx
-    });
-  }
-  filter(params, config) {
-    return this.options.filter?.(params, config) ?? {};
-  }
-  properties(params) {
-    return this.options.properties?.(params) ?? [];
-  }
-  get crud() {
-    return this.options.crud;
-  }
-  async register(params, registerEvent, io, ctx) {
-    if (!this.options.register) {
-      return;
-    }
-    const updates = await this.options.register({
-      ...registerEvent,
-      params
-    }, io, ctx);
-    return updates;
-  }
-  async verify(request, client, ctx) {
-    if (this.options.verify) {
-      const clonedRequest = request.clone();
-      return this.options.verify({
-        request: clonedRequest,
-        client,
-        ctx
-      });
-    }
-    return {
-      success: true
-    };
-  }
-  key(params) {
-    const parts = [
-      "webhook"
-    ];
-    parts.push(this.options.key(params));
-    parts.push(this.integration.id);
-    return `${this.options.id}-${__privateMethod(this, _shortHash, shortHash_fn).call(this, parts.join(""))}`;
-  }
-  get integration() {
-    return this.options.integration;
-  }
-  get integrationConfig() {
-    return {
-      id: this.integration.id,
-      metadata: this.integration.metadata
-    };
-  }
-  get id() {
-    return this.options.id;
-  }
-  get version() {
-    return this.options.version;
-  }
-};
-__name(WebhookSource, "WebhookSource");
-_shortHash = new WeakSet();
-shortHash_fn = /* @__PURE__ */ __name(function(str) {
-  const hash = (0, import_node_crypto2.createHash)("sha1").update(str).digest("hex");
-  return hash.slice(0, 7);
-}, "#shortHash");
-var WebhookTrigger = class {
-  constructor(options) {
-    this.options = options;
-  }
-  get event() {
-    return this.options.event;
-  }
-  get source() {
-    return this.options.source;
-  }
-  get key() {
-    return slugifyId(this.options.source.key(this.options.params));
-  }
-  toJSON() {
-    return {
-      type: "static",
-      title: "Webhook",
-      rule: {
-        event: this.event.name,
-        payload: (0, import_core11.deepMergeFilters)(this.options.source.filter(this.options.params, this.options.config), this.event.filter ?? {}),
-        source: this.event.source
-      },
-      properties: this.options.source.properties(this.options.params),
-      link: `http-endpoints/${this.key}`
-    };
-  }
-  filter(eventFilter) {
-    const { event, ...optionsWithoutEvent } = this.options;
-    const { filter, ...eventWithoutFilter } = event;
-    return new WebhookTrigger({
-      ...optionsWithoutEvent,
-      event: {
-        ...eventWithoutFilter,
-        filter: (0, import_core11.deepMergeFilters)(filter ?? {}, eventFilter)
-      }
-    });
-  }
-  attachToJob(triggerClient, job) {
-    triggerClient.defineHttpEndpoint({
-      id: this.key,
-      source: "trigger.dev",
-      icon: this.event.icon,
-      verify: async () => ({
-        success: true
-      })
-    }, true);
-    triggerClient.attachWebhook({
-      key: this.key,
-      source: this.options.source,
-      event: this.options.event,
-      params: this.options.params,
-      config: this.options.config
-    });
-  }
-  get preprocessRuns() {
-    return true;
-  }
-  async verifyPayload(payload) {
-    return {
-      success: true
-    };
-  }
-};
-__name(WebhookTrigger, "WebhookTrigger");
-
-// src/security.ts
-var import_crypto = __toESM(require("crypto"));
-async function verifyRequestSignature({ request, headerName, headerEncoding = "hex", secret, algorithm }) {
-  if (!secret) {
-    return {
-      success: false,
-      reason: "Missing secret \u2013 you've probably not set an environment variable."
-    };
-  }
-  const headerValue = request.headers.get(headerName);
-  if (!headerValue) {
-    return {
-      success: false,
-      reason: "Missing header"
-    };
-  }
-  switch (algorithm) {
-    case "sha256":
-      const success = verifyHmacSha256(headerValue, headerEncoding, secret, await request.text());
-      if (success) {
-        return {
-          success
-        };
-      } else {
-        return {
-          success: false,
-          reason: "Failed sha256 verification"
-        };
-      }
-    default:
-      throw new Error(`Unsupported algorithm: ${algorithm}`);
-  }
-}
-__name(verifyRequestSignature, "verifyRequestSignature");
-function verifyHmacSha256(headerValue, headerEncoding, secret, body) {
-  const bodyDigest = import_crypto.default.createHmac("sha256", secret).update(body).digest(headerEncoding);
-  const signature = headerValue?.replace("hmac-sha256=", "").replace("sha256=", "") ?? "";
-  return signature === bodyDigest;
-}
-__name(verifyHmacSha256, "verifyHmacSha256");
-
-// src/index.ts
-function redactString(strings, ...interpolations) {
-  return {
-    __redactedString: true,
-    strings: strings.raw,
-    interpolations
-  };
-}
-__name(redactString, "redactString");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CronTrigger,
-  DynamicSchedule,
-  DynamicTrigger,
-  EventSpecificationExampleSchema,
-  EventTrigger,
-  ExternalSource,
-  ExternalSourceTrigger,
-  IO,
-  IOLogger,
-  IntervalTrigger,
-  InvokeTrigger,
-  JSONOutputSerializer,
-  Job,
-  MissingConnectionNotification,
-  MissingConnectionResolvedNotification,
-  TriggerClient,
-  WebhookSource,
-  WebhookTrigger,
-  cronTrigger,
-  eventTrigger,
-  intervalTrigger,
-  invokeTrigger,
-  isTriggerError,
-  missingConnectionNotification,
-  missingConnectionResolvedNotification,
-  omit,
-  redactString,
-  retry,
-  slugifyId,
-  verifyHmacSha256,
-  verifyRequestSignature,
-  waitForEventSchema
-});
-//# sourceMappingURL=index.js.map