@trigger.dev/sdk 0.0.0-background-tasks-20230906212613

package/dist/index.js

@@ -0,0 +1,2275 @@
+"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 __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 __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,
+  EventTrigger: () => EventTrigger,
+  ExternalSource: () => ExternalSource,
+  ExternalSourceTrigger: () => ExternalSourceTrigger,
+  IO: () => IO,
+  IOLogger: () => IOLogger,
+  IntervalTrigger: () => IntervalTrigger,
+  Job: () => Job,
+  MissingConnectionNotification: () => MissingConnectionNotification,
+  MissingConnectionResolvedNotification: () => MissingConnectionResolvedNotification,
+  TriggerClient: () => TriggerClient,
+  cronTrigger: () => cronTrigger,
+  eventTrigger: () => eventTrigger,
+  intervalTrigger: () => intervalTrigger,
+  isTriggerError: () => isTriggerError,
+  missingConnectionNotification: () => missingConnectionNotification,
+  missingConnectionResolvedNotification: () => missingConnectionResolvedNotification,
+  omit: () => omit,
+  redactString: () => redactString,
+  retry: () => retry
+});
+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/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 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;
+    }, {});
+  }
+  get logLevel() {
+    return this.options.logLevel;
+  }
+  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
+    };
+  }
+};
+__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_core5 = require("@trigger.dev/core");
+
+// src/apiClient.ts
+var import_core = require("@trigger.dev/core");
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_zod = require("zod");
+var _apiUrl, _options, _logger, _apiKey, apiKey_fn;
+var ApiClient = class {
+  constructor(options) {
+    __privateAdd(this, _apiKey);
+    __privateAdd(this, _apiUrl, void 0);
+    __privateAdd(this, _options, void 0);
+    __privateAdd(this, _logger, void 0);
+    __privateSet(this, _options, options);
+    __privateSet(this, _apiUrl, __privateGet(this, _options).apiUrl ?? process.env.TRIGGER_API_URL ?? "https://api.trigger.dev");
+    __privateSet(this, _logger, new import_core.Logger("trigger.dev", __privateGet(this, _options).logLevel));
+  }
+  async registerEndpoint(options) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Registering endpoint", {
+      url: options.url,
+      name: options.name
+    });
+    const response = await (0, import_node_fetch.default)(`${__privateGet(this, _apiUrl)}/api/v1/endpoints`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        url: options.url,
+        name: options.name
+      })
+    });
+    if (response.status >= 400 && response.status < 500) {
+      const body = await response.json();
+      throw new Error(body.error);
+    }
+    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) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Running Task", {
+      task
+    });
+    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        "Idempotency-Key": task.idempotencyKey
+      },
+      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_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      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_core.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_core.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        event,
+        options
+      })
+    });
+  }
+  async cancelEvent(eventId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Cancelling event", {
+      eventId
+    });
+    return await zodfetch(import_core.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async updateSource(client, key, source) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("activating http source", {
+      source
+    });
+    const response = await zodfetch(import_core.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v2/${client}/sources/${key}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(source)
+    });
+    return response;
+  }
+  async registerTrigger(client, id, key, payload) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("registering trigger", {
+      id,
+      payload
+    });
+    const response = await zodfetch(import_core.RegisterSourceEventSchemaV2, `${__privateGet(this, _apiUrl)}/api/v2/${client}/triggers/${id}/registrations/${key}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+    return response;
+  }
+  async registerSchedule(client, id, key, payload) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("registering schedule", {
+      id,
+      payload
+    });
+    const response = await zodfetch(import_core.RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        id: key,
+        ...payload
+      })
+    });
+    return response;
+  }
+  async unregisterSchedule(client, id, key) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("unregistering schedule", {
+      id
+    });
+    const response = await zodfetch(import_zod.z.object({
+      ok: import_zod.z.boolean()
+    }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    return response;
+  }
+  async getAuth(client, id) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("getting auth", {
+      id
+    });
+    const response = await zodfetch(import_core.ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    }, {
+      optional: true
+    });
+    return response;
+  }
+  async getEvent(eventId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Getting Event", {
+      eventId
+    });
+    return await zodfetch(import_core.GetEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async getRun(runId, options) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Getting Run", {
+      runId
+    });
+    return await zodfetch(import_core.GetRunSchema, (0, import_core.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}`, options), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async getRuns(jobSlug, options) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Getting Runs", {
+      jobSlug
+    });
+    return await zodfetch(import_core.GetRunsSchema, (0, import_core.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobSlug}/runs`, options), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+};
+__name(ApiClient, "ApiClient");
+_apiUrl = new WeakMap();
+_options = new WeakMap();
+_logger = new WeakMap();
+_apiKey = new WeakSet();
+apiKey_fn = /* @__PURE__ */ __name(async function() {
+  const apiKey = getApiKey(__privateGet(this, _options).apiKey);
+  if (apiKey.status === "invalid") {
+    throw new Error("Invalid API key");
+  } else if (apiKey.status === "missing") {
+    throw new Error("Missing API key");
+  }
+  return apiKey.apiKey;
+}, "#apiKey");
+function getApiKey(key) {
+  const apiKey = key ?? process.env.TRIGGER_API_KEY;
+  if (!apiKey) {
+    return {
+      status: "missing"
+    };
+  }
+  const isValid = apiKey.match(/^tr_[a-z]+_[a-zA-Z0-9]+$/);
+  if (!isValid) {
+    return {
+      status: "invalid",
+      apiKey
+    };
+  }
+  return {
+    status: "valid",
+    apiKey
+  };
+}
+__name(getApiKey, "getApiKey");
+async function zodfetch(schema, url, requestInit, options) {
+  const response = await (0, import_node_fetch.default)(url, requestInit);
+  if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
+    return;
+  }
+  if (response.status >= 400 && response.status < 500) {
+    const body = await response.json();
+    throw new Error(body.error);
+  }
+  if (response.status !== 200) {
+    throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
+  }
+  const jsonBody = await response.json();
+  return schema.parse(jsonBody);
+}
+__name(zodfetch, "zodfetch");
+
+// src/errors.ts
+var ResumeWithTaskError = class {
+  constructor(task) {
+    this.task = task;
+  }
+};
+__name(ResumeWithTaskError, "ResumeWithTaskError");
+var RetryWithTaskError = class {
+  constructor(cause, task, retryAt) {
+    this.cause = cause;
+    this.task = task;
+    this.retryAt = retryAt;
+  }
+};
+__name(RetryWithTaskError, "RetryWithTaskError");
+var CanceledWithTaskError = class {
+  constructor(task) {
+    this.task = task;
+  }
+};
+__name(CanceledWithTaskError, "CanceledWithTaskError");
+function isTriggerError(err) {
+  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError;
+}
+__name(isTriggerError, "isTriggerError");
+
+// src/io.ts
+var import_core3 = require("@trigger.dev/core");
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+
+// src/retry.ts
+var import_core2 = require("@trigger.dev/core");
+var retry = {
+  standardBackoff: {
+    limit: 8,
+    factor: 1.8,
+    minTimeoutInMs: 500,
+    maxTimeoutInMs: 3e4,
+    randomize: true
+  }
+};
+
+// src/io.ts
+var _addToCachedTasks, addToCachedTasks_fn;
+var IO = class {
+  constructor(options) {
+    __privateAdd(this, _addToCachedTasks);
+    this._id = options.id;
+    this._apiClient = options.apiClient;
+    this._triggerClient = options.client;
+    this._logger = options.logger ?? new import_core3.Logger("trigger.dev", options.logLevel);
+    this._cachedTasks = /* @__PURE__ */ new Map();
+    this._jobLogger = options.jobLogger;
+    this._jobLogLevel = options.jobLogLevel;
+    if (options.cachedTasks) {
+      options.cachedTasks.forEach((task) => {
+        this._cachedTasks.set(task.idempotencyKey, task);
+      });
+    }
+    this._taskStorage = new import_node_async_hooks.AsyncLocalStorage();
+    this._context = options.context;
+  }
+  get logger() {
+    return new IOLogger(async (level, message, data) => {
+      let logLevel = "info";
+      switch (level) {
+        case "LOG": {
+          this._jobLogger?.log(message, data);
+          logLevel = "log";
+          break;
+        }
+        case "DEBUG": {
+          this._jobLogger?.debug(message, data);
+          logLevel = "debug";
+          break;
+        }
+        case "INFO": {
+          this._jobLogger?.info(message, data);
+          logLevel = "info";
+          break;
+        }
+        case "WARN": {
+          this._jobLogger?.warn(message, data);
+          logLevel = "warn";
+          break;
+        }
+        case "ERROR": {
+          this._jobLogger?.error(message, data);
+          logLevel = "error";
+          break;
+        }
+      }
+      if (import_core3.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
+        await this.runTask([
+          message,
+          level
+        ], async (task) => {
+        }, {
+          name: "log",
+          icon: "log",
+          description: message,
+          params: data,
+          properties: [
+            {
+              label: "Level",
+              text: level
+            }
+          ],
+          style: {
+            style: "minimal",
+            variant: level.toLowerCase()
+          },
+          noop: true
+        });
+      }
+    });
+  }
+  async wait(key, seconds) {
+    return await this.runTask(key, async (task) => {
+    }, {
+      name: "wait",
+      icon: "clock",
+      params: {
+        seconds
+      },
+      noop: true,
+      delayUntil: new Date(Date.now() + seconds * 1e3),
+      style: {
+        style: "minimal"
+      }
+    });
+  }
+  async backgroundFetch(key, url, requestInit, retry2) {
+    const urlObject = new URL(url);
+    return await this.runTask(key, async (task) => {
+      return task.output;
+    }, {
+      name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
+      params: {
+        url,
+        requestInit,
+        retry: retry2
+      },
+      operation: "fetch",
+      icon: "background",
+      noop: false,
+      properties: [
+        {
+          label: "url",
+          text: url,
+          url
+        },
+        {
+          label: "method",
+          text: requestInit?.method ?? "GET"
+        },
+        {
+          label: "background",
+          text: "true"
+        }
+      ]
+    });
+  }
+  async sendEvent(key, event, options) {
+    return await this.runTask(key, async (task) => {
+      return await this._triggerClient.sendEvent(event, options);
+    }, {
+      name: "sendEvent",
+      params: {
+        event,
+        options
+      },
+      properties: [
+        {
+          label: "name",
+          text: event.name
+        },
+        ...event?.id ? [
+          {
+            label: "ID",
+            text: event.id
+          }
+        ] : []
+      ]
+    });
+  }
+  async getEvent(key, id) {
+    return await this.runTask(key, async (task) => {
+      return await this._triggerClient.getEvent(id);
+    }, {
+      name: "getEvent",
+      params: {
+        id
+      },
+      properties: [
+        {
+          label: "id",
+          text: id
+        }
+      ]
+    });
+  }
+  async cancelEvent(key, eventId) {
+    return await this.runTask(key, async (task) => {
+      return await this._triggerClient.cancelEvent(eventId);
+    }, {
+      name: "cancelEvent",
+      params: {
+        eventId
+      },
+      properties: [
+        {
+          label: "id",
+          text: eventId
+        }
+      ]
+    });
+  }
+  async updateSource(key, options) {
+    return this.runTask(key, 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 registerInterval(key, dynamicSchedule, id, options) {
+    return await this.runTask(key, 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(key, dynamicSchedule, id) {
+    return await this.runTask(key, async (task) => {
+      return dynamicSchedule.unregister(id);
+    }, {
+      name: "unregister-interval",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        }
+      ]
+    });
+  }
+  async registerCron(key, dynamicSchedule, id, options) {
+    return await this.runTask(key, 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(key, dynamicSchedule, id) {
+    return await this.runTask(key, async (task) => {
+      return dynamicSchedule.unregister(id);
+    }, {
+      name: "unregister-cron",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        }
+      ]
+    });
+  }
+  async registerTrigger(key, trigger, id, params) {
+    return await this.runTask(key, 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(key, clientId) {
+    if (!clientId) {
+      return;
+    }
+    return this.runTask(key, async (task) => {
+      return await this._triggerClient.getAuth(clientId);
+    }, {
+      name: "get-auth"
+    });
+  }
+  async runTask(key, callback, options, onError) {
+    const parentId = this._taskStorage.getStore()?.taskId;
+    if (parentId) {
+      this._logger.debug("Using parent task", {
+        parentId,
+        key,
+        options
+      });
+    }
+    const idempotencyKey = await generateIdempotencyKey([
+      this._id,
+      parentId ?? "",
+      key
+    ].flat());
+    const cachedTask = this._cachedTasks.get(idempotencyKey);
+    if (cachedTask && cachedTask.status === "COMPLETED") {
+      this._logger.debug("Using completed cached task", {
+        idempotencyKey,
+        cachedTask
+      });
+      return cachedTask.output;
+    }
+    const task = await this._apiClient.runTask(this._id, {
+      idempotencyKey,
+      displayKey: typeof key === "string" ? key : void 0,
+      noop: false,
+      ...options ?? {},
+      parentId
+    });
+    if (task.status === "CANCELED") {
+      this._logger.debug("Task canceled", {
+        idempotencyKey,
+        task
+      });
+      throw new CanceledWithTaskError(task);
+    }
+    if (task.status === "COMPLETED") {
+      this._logger.debug("Using task output", {
+        idempotencyKey,
+        task
+      });
+      __privateMethod(this, _addToCachedTasks, addToCachedTasks_fn).call(this, task);
+      return task.output;
+    }
+    if (task.status === "ERRORED") {
+      this._logger.debug("Task errored", {
+        idempotencyKey,
+        task
+      });
+      throw new Error(task.error ?? "Task errored");
+    }
+    if (task.status === "WAITING") {
+      this._logger.debug("Task waiting", {
+        idempotencyKey,
+        task
+      });
+      throw new ResumeWithTaskError(task);
+    }
+    if (task.status === "RUNNING" && typeof task.operation === "string") {
+      this._logger.debug("Task running operation", {
+        idempotencyKey,
+        task
+      });
+      throw new ResumeWithTaskError(task);
+    }
+    const executeTask = /* @__PURE__ */ __name(async () => {
+      try {
+        const result = await callback(task, this);
+        const output = import_core3.SerializableJsonSchema.parse(result);
+        this._logger.debug("Completing using output", {
+          idempotencyKey,
+          task
+        });
+        const completedTask = await this._apiClient.completeTask(this._id, task.id, {
+          output: output ?? void 0,
+          properties: task.outputProperties ?? void 0
+        });
+        if (completedTask.status === "CANCELED") {
+          throw new CanceledWithTaskError(completedTask);
+        }
+        return output;
+      } catch (error) {
+        if (isTriggerError(error)) {
+          throw error;
+        }
+        if (onError) {
+          try {
+            const onErrorResult = onError(error, task, this);
+            if (onErrorResult) {
+              if (onErrorResult instanceof Error) {
+                error = onErrorResult;
+              } else {
+                const parsedError2 = import_core3.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;
+          }
+        }
+        const parsedError = import_core3.ErrorWithStackSchema.safeParse(error);
+        if (options?.retry) {
+          const retryAt = (0, import_core2.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 {
+          await this._apiClient.failTask(this._id, task.id, {
+            error: {
+              message: JSON.stringify(error),
+              name: "Unknown Error"
+            }
+          });
+        }
+        throw error;
+      }
+    }, "executeTask");
+    return this._taskStorage.run({
+      taskId: task.id
+    }, executeTask);
+  }
+  async try(tryCallback, catchCallback) {
+    try {
+      return await tryCallback();
+    } catch (error) {
+      if (isTriggerError(error)) {
+        throw error;
+      }
+      return await catchCallback(error);
+    }
+  }
+};
+__name(IO, "IO");
+_addToCachedTasks = new WeakSet();
+addToCachedTasks_fn = /* @__PURE__ */ __name(function(task) {
+  this._cachedTasks.set(task.idempotencyKey, task);
+}, "#addToCachedTasks");
+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");
+
+// 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/eventTrigger.ts
+var import_core4 = require("@trigger.dev/core");
+var _options2;
+var EventTrigger = class {
+  constructor(options) {
+    __privateAdd(this, _options2, void 0);
+    __privateSet(this, _options2, options);
+  }
+  toJSON() {
+    return {
+      type: "static",
+      title: __privateGet(this, _options2).name ?? __privateGet(this, _options2).event.title,
+      rule: {
+        event: __privateGet(this, _options2).name ?? __privateGet(this, _options2).event.name,
+        source: __privateGet(this, _options2).source ?? "trigger.dev",
+        payload: (0, import_core4.deepMergeFilters)(__privateGet(this, _options2).filter ?? {}, __privateGet(this, _options2).event.filter ?? {})
+      }
+    };
+  }
+  get event() {
+    return __privateGet(this, _options2).event;
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+};
+__name(EventTrigger, "EventTrigger");
+_options2 = 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) {
+          return options.schema.parse(rawPayload);
+        }
+        return rawPayload;
+      }
+    }
+  });
+}
+__name(eventTrigger, "eventTrigger");
+
+// src/backgroundTask.ts
+var _validate2, validate_fn2;
+var BackgroundTask = class {
+  constructor(client, options) {
+    __privateAdd(this, _validate2);
+    this.client = client;
+    this.options = options;
+    __privateMethod(this, _validate2, validate_fn2).call(this);
+    client.attachBackgroundTask(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 schema() {
+    return this.options.schema;
+  }
+  get version() {
+    return this.options.version;
+  }
+  get logLevel() {
+    return this.options.logLevel;
+  }
+  async invoke(key, payload) {
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      version: this.version,
+      enabled: this.enabled,
+      cpu: this.options.cpu ?? 1,
+      memory: this.options.memory ?? 256,
+      concurrency: this.options.concurrency ?? 1,
+      secrets: this.options.secrets ?? {}
+    };
+  }
+};
+__name(BackgroundTask, "BackgroundTask");
+_validate2 = new WeakSet();
+validate_fn2 = /* @__PURE__ */ __name(function() {
+  if (!this.version.match(/^(\d+)\.(\d+)\.(\d+)$/)) {
+    throw new Error(`Invalid job version: "${this.version}". BackgroundTask versions must be valid semver versions.`);
+  }
+}, "#validate");
+
+// src/triggerClient.ts
+var registerSourceEvent = {
+  name: import_core5.REGISTER_SOURCE_EVENT_V2,
+  title: "Register Source",
+  source: "internal",
+  icon: "register-source",
+  parsePayload: import_core5.RegisterSourceEventSchemaV2.parse
+};
+var _options3, _registeredJobs, _registeredSources, _registeredBackgroundTasks, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _client, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn;
+var TriggerClient = class {
+  constructor(options) {
+    __privateAdd(this, _preprocessRun);
+    __privateAdd(this, _executeJob);
+    __privateAdd(this, _createRunContext);
+    __privateAdd(this, _createPreprocessRunContext);
+    __privateAdd(this, _handleHttpSourceRequest);
+    __privateAdd(this, _options3, void 0);
+    __privateAdd(this, _registeredJobs, {});
+    __privateAdd(this, _registeredSources, {});
+    __privateAdd(this, _registeredBackgroundTasks, {});
+    __privateAdd(this, _registeredHttpSourceHandlers, {});
+    __privateAdd(this, _registeredDynamicTriggers, {});
+    __privateAdd(this, _jobMetadataByDynamicTriggers, {});
+    __privateAdd(this, _registeredSchedules, {});
+    __privateAdd(this, _client, void 0);
+    __privateAdd(this, _internalLogger, void 0);
+    this.id = options.id;
+    __privateSet(this, _options3, options);
+    __privateSet(this, _client, new ApiClient(__privateGet(this, _options3)));
+    __privateSet(this, _internalLogger, new import_core5.Logger("trigger.dev", __privateGet(this, _options3).verbose ? "debug" : "log"));
+  }
+  async handleRequest(request) {
+    __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 authorization = this.authorized(apiKey);
+    switch (authorization) {
+      case "authorized": {
+        break;
+      }
+      case "missing-client": {
+        return {
+          status: 401,
+          body: {
+            message: "Unauthorized: client missing apiKey"
+          }
+        };
+      }
+      case "missing-header": {
+        return {
+          status: 401,
+          body: {
+            message: "Unauthorized: missing x-trigger-api-key header"
+          }
+        };
+      }
+      case "unauthorized": {
+        return {
+          status: 401,
+          body: {
+            message: `Forbidden: client apiKey mismatch: Make sure you are using the correct API Key for your environment`
+          }
+        };
+      }
+    }
+    if (request.method !== "POST") {
+      return {
+        status: 405,
+        body: {
+          message: "Method not allowed (only POST is allowed)"
+        }
+      };
+    }
+    const action = request.headers.get("x-trigger-action");
+    if (!action) {
+      return {
+        status: 400,
+        body: {
+          message: "Missing x-trigger-action header"
+        }
+      };
+    }
+    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"
+            }
+          };
+        }
+        if (this.id !== endpointId) {
+          return {
+            status: 200,
+            body: {
+              ok: false,
+              error: `Endpoint ID mismatch error. Expected ${this.id}, got ${endpointId}`
+            }
+          };
+        }
+        return {
+          status: 200,
+          body: {
+            ok: true
+          }
+        };
+      }
+      case "INDEX_ENDPOINT": {
+        const jobId = request.headers.get("x-trigger-job-id");
+        if (jobId) {
+          const job = __privateGet(this, _registeredJobs)[jobId];
+          if (!job) {
+            return {
+              status: 404,
+              body: {
+                message: "Job not found"
+              }
+            };
+          }
+          return {
+            status: 200,
+            body: job.toJSON()
+          };
+        }
+        const body = {
+          jobs: Object.values(__privateGet(this, _registeredJobs)).map((job) => job.toJSON()),
+          backgroundTasks: Object.values(__privateGet(this, _registeredBackgroundTasks)).map((task) => task.toJSON()),
+          sources: Object.values(__privateGet(this, _registeredSources)),
+          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
+          }))
+        };
+        return {
+          status: 200,
+          body
+        };
+      }
+      case "INITIALIZE_TRIGGER": {
+        const json = await request.json();
+        const body = import_core5.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)
+        };
+      }
+      case "EXECUTE_JOB": {
+        const json = await request.json();
+        const execution = import_core5.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);
+        return {
+          status: 200,
+          body: results
+        };
+      }
+      case "PREPROCESS_RUN": {
+        const json = await request.json();
+        const body = import_core5.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
+          }
+        };
+      }
+      case "DELIVER_HTTP_SOURCE_REQUEST": {
+        const headers = import_core5.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
+          }
+        };
+      }
+      case "VALIDATE": {
+        return {
+          status: 200,
+          body: {
+            ok: true,
+            endpointId: this.id
+          }
+        };
+      }
+    }
+    return {
+      status: 405,
+      body: {
+        message: "Method not allowed"
+      }
+    };
+  }
+  attach(job) {
+    __privateGet(this, _registeredJobs)[job.id] = job;
+    job.trigger.attachToJob(this, job);
+  }
+  attachBackgroundTask(task) {
+    __privateGet(this, _registeredBackgroundTasks)[task.id] = task;
+  }
+  attachDynamicTrigger(trigger) {
+    __privateGet(this, _registeredDynamicTriggers)[trigger.id] = trigger;
+    new Job(this, {
+      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, job) {
+    const jobs = __privateGet(this, _registeredSchedules)[key] ?? [];
+    jobs.push({
+      id: job.id,
+      version: job.version
+    });
+    __privateGet(this, _registeredSchedules)[key] = jobs;
+  }
+  async registerTrigger(id, key, options) {
+    return __privateGet(this, _client).registerTrigger(this.id, id, key, options);
+  }
+  async getAuth(id) {
+    return __privateGet(this, _client).getAuth(this.id, id);
+  }
+  async sendEvent(event, options) {
+    return __privateGet(this, _client).sendEvent(event, options);
+  }
+  async cancelEvent(eventId) {
+    return __privateGet(this, _client).cancelEvent(eventId);
+  }
+  async registerSchedule(id, key, schedule) {
+    return __privateGet(this, _client).registerSchedule(this.id, id, key, schedule);
+  }
+  async unregisterSchedule(id, key) {
+    return __privateGet(this, _client).unregisterSchedule(this.id, id, key);
+  }
+  async getEvent(eventId) {
+    return __privateGet(this, _client).getEvent(eventId);
+  }
+  async getRun(runId, options) {
+    return __privateGet(this, _client).getRun(runId, options);
+  }
+  async getRuns(jobSlug, options) {
+    return __privateGet(this, _client).getRuns(jobSlug, options);
+  }
+  authorized(apiKey) {
+    if (typeof apiKey !== "string") {
+      return "missing-header";
+    }
+    const localApiKey = __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
+    if (!localApiKey) {
+      return "missing-client";
+    }
+    return apiKey === localApiKey ? "authorized" : "unauthorized";
+  }
+  apiKey() {
+    return __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
+  }
+  defineJob(options) {
+    return new Job(this, options);
+  }
+  defineBackgroundTask(options) {
+    return new BackgroundTask(this, options);
+  }
+};
+__name(TriggerClient, "TriggerClient");
+_options3 = new WeakMap();
+_registeredJobs = new WeakMap();
+_registeredSources = new WeakMap();
+_registeredBackgroundTasks = new WeakMap();
+_registeredHttpSourceHandlers = new WeakMap();
+_registeredDynamicTriggers = new WeakMap();
+_jobMetadataByDynamicTriggers = new WeakMap();
+_registeredSchedules = new WeakMap();
+_client = 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) {
+  __privateGet(this, _internalLogger).debug("executing job", {
+    execution: body1,
+    job: job1.toJSON()
+  });
+  const context = __privateMethod(this, _createRunContext, createRunContext_fn).call(this, body1);
+  const io = new IO({
+    id: body1.run.id,
+    cachedTasks: body1.tasks,
+    apiClient: __privateGet(this, _client),
+    logger: __privateGet(this, _internalLogger),
+    client: this,
+    context,
+    jobLogLevel: job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info",
+    jobLogger: __privateGet(this, _options3).ioLogLocalEnabled ? new import_core5.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info") : void 0
+  });
+  const ioWithConnections = createIOWithIntegrations(io, body1.connections, job1.options.integrations);
+  try {
+    const output = await job1.options.run(job1.trigger.event.parsePayload(body1.event.payload ?? {}), ioWithConnections, context);
+    return {
+      status: "SUCCESS",
+      output
+    };
+  } catch (error) {
+    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 RetryWithTaskError) {
+      const errorWithStack2 = import_core5.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_core5.ErrorWithStackSchema.safeParse(error);
+    if (errorWithStack.success) {
+      return {
+        status: "ERROR",
+        error: errorWithStack.data
+      };
+    }
+    return {
+      status: "ERROR",
+      error: {
+        message: "Unknown error"
+      }
+    };
+  }
+}, "#executeJob");
+_createRunContext = new WeakSet();
+createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
+  const { event, organization, environment, job, run, source } = execution;
+  return {
+    event: {
+      id: event.id,
+      name: event.name,
+      context: event.context,
+      timestamp: event.timestamp
+    },
+    organization,
+    environment,
+    job,
+    run,
+    account: execution.account,
+    source
+  };
+}, "#createRunContext");
+_createPreprocessRunContext = new WeakSet();
+createPreprocessRunContext_fn = /* @__PURE__ */ __name(function(body2) {
+  const { event, organization, environment, job, run, account } = body2;
+  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");
+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_core6 = 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_core6.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;
+  }
+};
+__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/dynamic.ts
+var import_core7 = require("@trigger.dev/core");
+var _client2, _options4;
+var DynamicTrigger = class {
+  constructor(client, options) {
+    __privateAdd(this, _client2, void 0);
+    __privateAdd(this, _options4, void 0);
+    __privateSet(this, _client2, client);
+    __privateSet(this, _options4, options);
+    this.source = options.source;
+    client.attachDynamicTrigger(this);
+  }
+  toJSON() {
+    return {
+      type: "dynamic",
+      id: __privateGet(this, _options4).id
+    };
+  }
+  get id() {
+    return __privateGet(this, _options4).id;
+  }
+  get event() {
+    return __privateGet(this, _options4).event;
+  }
+  registeredTriggerForParams(params) {
+    const key = slugifyId(this.source.key(params));
+    return {
+      rule: {
+        event: this.event.name,
+        source: this.event.source,
+        payload: (0, import_core7.deepMergeFilters)(this.source.filter(params), this.event.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
+        }
+      }
+    };
+  }
+  async register(key, params) {
+    return __privateGet(this, _client2).registerTrigger(this.id, key, this.registeredTriggerForParams(params));
+  }
+  attachToJob(triggerClient, job) {
+    triggerClient.attachJobToDynamicTrigger(job, this);
+  }
+  get preprocessRuns() {
+    return true;
+  }
+};
+__name(DynamicTrigger, "DynamicTrigger");
+_client2 = new WeakMap();
+_options4 = new WeakMap();
+
+// src/triggers/scheduled.ts
+var import_core8 = require("@trigger.dev/core");
+var import_cronstrue = __toESM(require("cronstrue"));
+var examples = [
+  {
+    id: "now",
+    name: "Now",
+    icon: "clock",
+    payload: {
+      ts: import_core8.currentDate.marker,
+      lastTimestamp: import_core8.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_core8.ScheduledPayloadSchema.parse,
+      properties: [
+        {
+          label: "Interval",
+          text: `${this.options.seconds}s`
+        }
+      ]
+    };
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  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_core8.ScheduledPayloadSchema.parse,
+      properties: [
+        {
+          label: "cron",
+          text: this.options.cron
+        },
+        {
+          label: "Schedule",
+          text: humanReadable
+        }
+      ]
+    };
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  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;
+  }
+  get id() {
+    return this.options.id;
+  }
+  get event() {
+    return {
+      name: "trigger.scheduled",
+      title: "Dynamic Schedule",
+      source: "trigger.dev",
+      icon: "schedule-dynamic",
+      examples,
+      parsePayload: import_core8.ScheduledPayloadSchema.parse
+    };
+  }
+  async register(key, metadata) {
+    return this.client.registerSchedule(this.id, key, metadata);
+  }
+  async unregister(key) {
+    return this.client.unregisterSchedule(this.id, key);
+  }
+  attachToJob(triggerClient, job) {
+    triggerClient.attachDynamicSchedule(this.options.id, job);
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  toJSON() {
+    return {
+      type: "dynamic",
+      id: this.options.id
+    };
+  }
+};
+__name(DynamicSchedule, "DynamicSchedule");
+
+// src/triggers/notifications.ts
+var import_core9 = 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_core9.MISSING_CONNECTION_NOTIFICATION,
+      title: "Missing Connection Notification",
+      source: "trigger.dev",
+      icon: "connection-alert",
+      parsePayload: import_core9.MissingConnectionNotificationPayloadSchema.parse,
+      properties: [
+        {
+          label: "Integrations",
+          text: this.options.integrations.map((i) => i.id).join(", ")
+        }
+      ]
+    };
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  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_core9.MISSING_CONNECTION_RESOLVED_NOTIFICATION,
+      title: "Missing Connection Resolved Notification",
+      source: "trigger.dev",
+      icon: "connection-alert",
+      parsePayload: import_core9.MissingConnectionResolvedNotificationPayloadSchema.parse,
+      properties: [
+        {
+          label: "Integrations",
+          text: this.options.integrations.map((i) => i.id).join(", ")
+        }
+      ]
+    };
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  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/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,
+  EventTrigger,
+  ExternalSource,
+  ExternalSourceTrigger,
+  IO,
+  IOLogger,
+  IntervalTrigger,
+  Job,
+  MissingConnectionNotification,
+  MissingConnectionResolvedNotification,
+  TriggerClient,
+  cronTrigger,
+  eventTrigger,
+  intervalTrigger,
+  isTriggerError,
+  missingConnectionNotification,
+  missingConnectionResolvedNotification,
+  omit,
+  redactString,
+  retry
+});
+//# sourceMappingURL=index.js.map