@trigger.dev/sdk 0.0.0-isomorphic-sdk-20230918150523 → 0.0.0-node-18-20231010094401

package/dist/index.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -23,6 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -107,6 +112,9 @@ var Job = class {
   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];
@@ -118,9 +126,6 @@ var Job = class {
       return acc;
     }, {});
   }
-  get logLevel() {
-    return this.options.logLevel;
-  }
   toJSON() {
     const internal = this.options.__internal;
     return {
@@ -146,7 +151,7 @@ validate_fn = /* @__PURE__ */ __name(function() {
 }, "#validate");
 
 // src/triggerClient.ts
-var import_core5 = require("@trigger.dev/core");
+var import_core7 = require("@trigger.dev/core");
 
 // src/apiClient.ts
 var import_core = require("@trigger.dev/core");
@@ -162,17 +167,47 @@ var ApiClient = class {
     __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 runTask(runId, task) {
+  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 zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
+    return await zodfetchWithVersions({
+      [import_core.API_VERSIONS.LAZY_LOADED_CACHED_TASKS]: import_core.RunTaskResponseWithCachedTasksBodySchema
+    }, import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${apiKey}`,
-        "Idempotency-Key": task.idempotencyKey
+        "Idempotency-Key": task.idempotencyKey,
+        "X-Cached-Tasks-Cursor": options.cachedTasksCursor ?? "",
+        "Trigger-Version": import_core.API_VERSIONS.LAZY_LOADED_CACHED_TASKS
       },
       body: JSON.stringify(task)
     });
@@ -237,6 +272,21 @@ var ApiClient = class {
       }
     });
   }
+  async updateStatus(runId, id, status) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Update status", {
+      id,
+      status
+    });
+    return await zodfetch(import_core.JobRunStatusRecordSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses/${id}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(status)
+    });
+  }
   async updateSource(client, key, source) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
     __privateGet(this, _logger).debug("activating http source", {
@@ -343,6 +393,31 @@ var ApiClient = class {
       }
     });
   }
+  async cancelRun(runId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Cancelling Run", {
+      runId
+    });
+    return await zodfetch(import_core.GetRunSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/cancel`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async getRunStatuses(runId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Getting Run statuses", {
+      runId
+    });
+    return await zodfetch(import_core.GetRunStatusesSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/statuses`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
   async getRuns(jobSlug, options) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
     __privateGet(this, _logger).debug("Getting Runs", {
@@ -390,6 +465,36 @@ function getApiKey(key) {
   };
 }
 __name(getApiKey, "getApiKey");
+async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options) {
+  const response = await fetch(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();
+  const version = response.headers.get("trigger-version");
+  if (!version) {
+    return {
+      version: "unversioned",
+      body: unversionedSchema.parse(jsonBody)
+    };
+  }
+  const versionedSchema = versionedSchemaMap[version];
+  if (!versionedSchema) {
+    throw new Error(`Unknown version ${version}`);
+  }
+  return {
+    version,
+    body: versionedSchema.parse(jsonBody)
+  };
+}
+__name(zodfetchWithVersions, "zodfetchWithVersions");
 async function zodfetch(schema, url, requestInit, options) {
   const response = await fetch(url, requestInit);
   if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
@@ -428,14 +533,27 @@ var CanceledWithTaskError = class {
   }
 };
 __name(CanceledWithTaskError, "CanceledWithTaskError");
+var YieldExecutionError = class {
+  constructor(key) {
+    this.key = key;
+  }
+};
+__name(YieldExecutionError, "YieldExecutionError");
+var ParsedPayloadSchemaError = class {
+  constructor(schemaErrors) {
+    this.schemaErrors = schemaErrors;
+  }
+};
+__name(ParsedPayloadSchemaError, "ParsedPayloadSchemaError");
 function isTriggerError(err) {
-  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError;
+  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError || err instanceof YieldExecutionError;
 }
 __name(isTriggerError, "isTriggerError");
 
 // src/io.ts
 var import_core3 = require("@trigger.dev/core");
-var import_node_async_hooks = require("node:async_hooks");
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
 
 // src/retry.ts
 var import_core2 = require("@trigger.dev/core");
@@ -449,11 +567,46 @@ var retry = {
   }
 };
 
+// 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/io.ts
 var _addToCachedTasks, addToCachedTasks_fn;
 var IO = class {
   constructor(options) {
     __privateAdd(this, _addToCachedTasks);
+    __publicField(this, "brb", this.yield.bind(this));
     this._id = options.id;
     this._apiClient = options.apiClient;
     this._triggerClient = options.client;
@@ -461,49 +614,74 @@ var IO = class {
     this._cachedTasks = /* @__PURE__ */ new Map();
     this._jobLogger = options.jobLogger;
     this._jobLogLevel = options.jobLogLevel;
+    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_hooks.AsyncLocalStorage();
     this._context = options.context;
+    this._yieldedExecutions = options.yieldedExecutions ?? [];
+    if (options.noopTasksSet) {
+      this._noopTasksBloomFilter = import_core3.BloomFilter.deserialize(options.noopTasksSet, import_core3.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";
-      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) => {
+          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",
@@ -539,6 +717,12 @@ var IO = class {
       }
     });
   }
+  async createStatus(key, initialStatus) {
+    const id = typeof key === "string" ? key : key.join("-");
+    const status = new TriggerStatus(id, this);
+    await status.update(key, initialStatus);
+    return status;
+  }
   async backgroundFetch(key, url, requestInit, retry2) {
     const urlObject = new URL(url);
     return await this.runTask(key, async (task) => {
@@ -782,18 +966,42 @@ var IO = class {
     const cachedTask = this._cachedTasks.get(idempotencyKey);
     if (cachedTask && cachedTask.status === "COMPLETED") {
       this._logger.debug("Using completed cached task", {
-        idempotencyKey,
-        cachedTask
+        idempotencyKey
       });
+      this._stats.cachedTaskHits++;
       return cachedTask.output;
     }
-    const task = await this._apiClient.runTask(this._id, {
+    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 response = await this._apiClient.runTask(this._id, {
       idempotencyKey,
       displayKey: typeof key === "string" ? key : void 0,
       noop: false,
       ...options ?? {},
       parentId
+    }, {
+      cachedTasksCursor: this._cachedTasksCursor
     });
+    const task = response.version === import_core3.API_VERSIONS.LAZY_LOADED_CACHED_TASKS ? response.body.task : response.body;
+    if (response.version === import_core3.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,
@@ -802,11 +1010,18 @@ var IO = class {
       throw new CanceledWithTaskError(task);
     }
     if (task.status === "COMPLETED") {
-      this._logger.debug("Using task output", {
-        idempotencyKey,
-        task
-      });
-      __privateMethod(this, _addToCachedTasks, addToCachedTasks_fn).call(this, task);
+      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 task.output;
     }
     if (task.status === "ERRORED") {
@@ -816,23 +1031,16 @@ var IO = class {
       });
       throw new Error(task.error ?? task?.output ? JSON.stringify(task.output) : "Task errored");
     }
-    if (task.status === "WAITING") {
-      this._logger.debug("Task waiting", {
-        idempotencyKey,
-        task
-      });
-      throw new ResumeWithTaskError(task);
-    }
-    if (task.status === "RUNNING" && typeof task.operation === "string") {
-      this._logger.debug("Task running operation", {
-        idempotencyKey,
-        task
-      });
-      throw new ResumeWithTaskError(task);
-    }
     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 = import_core3.SerializableJsonSchema.parse(result);
         this._logger.debug("Completing using output", {
           idempotencyKey,
@@ -842,6 +1050,7 @@ var IO = class {
           output: output ?? void 0,
           properties: task.outputProperties ?? void 0
         });
+        this._stats.executedTasks++;
         if (completedTask.status === "CANCELED") {
           throw new CanceledWithTaskError(completedTask);
         }
@@ -850,6 +1059,7 @@ var IO = class {
         if (isTriggerError(error)) {
           throw error;
         }
+        let skipRetrying = false;
         if (onError) {
           try {
             const onErrorResult = onError(error, task, this);
@@ -857,10 +1067,13 @@ var IO = class {
               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);
+                skipRetrying = !!onErrorResult.skipRetrying;
+                if (onErrorResult.retryAt && !skipRetrying) {
+                  const parsedError2 = import_core3.ErrorWithStackSchema.safeParse(onErrorResult.error);
+                  throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
+                    message: "Unknown error"
+                  }, task, onErrorResult.retryAt);
+                }
               }
             }
           } catch (innerError) {
@@ -871,7 +1084,7 @@ var IO = class {
           }
         }
         const parsedError = import_core3.ErrorWithStackSchema.safeParse(error);
-        if (options?.retry) {
+        if (options?.retry && !skipRetrying) {
           const retryAt = (0, import_core2.calculateRetryAt)(options.retry, task.attempts - 1);
           if (retryAt) {
             throw new RetryWithTaskError(parsedError.success ? parsedError.data : {
@@ -894,10 +1107,39 @@ var IO = class {
         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(key) {
+    if (!(0, import_core3.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(key)) {
+      return;
+    }
+    throw new YieldExecutionError(key);
+  }
   async try(tryCallback, catchCallback) {
     try {
       return await tryCallback();
@@ -922,7 +1164,7 @@ async function generateIdempotencyKey(keyMaterial) {
     return stableStringify(key2);
   });
   const key = keys.join(":");
-  const hash = await crypto.subtle.digest("SHA-256", Buffer.from(key));
+  const hash = await import_node_crypto.webcrypto.subtle.digest("SHA-256", Buffer.from(key));
   return Buffer.from(hash).toString("hex");
 }
 __name(generateIdempotencyKey, "generateIdempotencyKey");
@@ -997,27 +1239,147 @@ function createIOWithIntegrations(io, auths, integrations) {
 }
 __name(createIOWithIntegrations, "createIOWithIntegrations");
 
-// src/triggers/eventTrigger.ts
+// src/utils/typedAsyncLocalStorage.ts
+var import_node_async_hooks2 = require("async_hooks");
+var TypedAsyncLocalStorage = class {
+  constructor() {
+    this.storage = new import_node_async_hooks2.AsyncLocalStorage();
+  }
+  runWith(context, fn) {
+    return this.storage.run(context, fn);
+  }
+  getStore() {
+    return this.storage.getStore();
+  }
+};
+__name(TypedAsyncLocalStorage, "TypedAsyncLocalStorage");
+
+// src/runLocalStorage.ts
+var runLocalStorage = new TypedAsyncLocalStorage();
+
+// src/triggers/dynamic.ts
 var import_core4 = require("@trigger.dev/core");
-var _options2;
-var EventTrigger = class {
-  constructor(options) {
+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_core4.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));
+    }, {
+      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;
+  }
+};
+__name(DynamicTrigger, "DynamicTrigger");
+_client = new WeakMap();
+_options2 = new WeakMap();
+
+// src/triggers/eventTrigger.ts
+var import_core5 = require("@trigger.dev/core");
+
+// src/utils/formatSchemaErrors.ts
+function formatSchemaErrors(errors) {
+  return errors.map((error) => {
+    const { path, message } = error;
+    return {
+      path: path.map(String),
+      message
+    };
+  });
+}
+__name(formatSchemaErrors, "formatSchemaErrors");
+
+// src/triggers/eventTrigger.ts
+var _options3;
+var EventTrigger = class {
+  constructor(options) {
+    __privateAdd(this, _options3, void 0);
+    __privateSet(this, _options3, options);
   }
   toJSON() {
     return {
       type: "static",
-      title: __privateGet(this, _options2).name ?? __privateGet(this, _options2).event.title,
+      title: __privateGet(this, _options3).name ?? __privateGet(this, _options3).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 ?? {})
+        event: __privateGet(this, _options3).name ?? __privateGet(this, _options3).event.name,
+        source: __privateGet(this, _options3).source ?? "trigger.dev",
+        payload: (0, import_core5.deepMergeFilters)(__privateGet(this, _options3).filter ?? {}, __privateGet(this, _options3).event.filter ?? {})
       }
     };
   }
   get event() {
-    return __privateGet(this, _options2).event;
+    return __privateGet(this, _options3).event;
   }
   attachToJob(triggerClient, job) {
   }
@@ -1026,7 +1388,7 @@ var EventTrigger = class {
   }
 };
 __name(EventTrigger, "EventTrigger");
-_options2 = new WeakMap();
+_options3 = new WeakMap();
 function eventTrigger(options) {
   return new EventTrigger({
     name: options.name,
@@ -1039,7 +1401,11 @@ function eventTrigger(options) {
       examples: options.examples,
       parsePayload: (rawPayload) => {
         if (options.schema) {
-          return options.schema.parse(rawPayload);
+          const results = options.schema.safeParse(rawPayload);
+          if (!results.success) {
+            throw new ParsedPayloadSchemaError(formatSchemaErrors(results.error.issues));
+          }
+          return results.data;
         }
         return rawPayload;
       }
@@ -1048,35 +1414,239 @@ function eventTrigger(options) {
 }
 __name(eventTrigger, "eventTrigger");
 
-// 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, _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);
+// src/triggers/scheduled.ts
+var import_core6 = require("@trigger.dev/core");
+var import_cronstrue = __toESM(require("cronstrue"));
+var examples = [
+  {
+    id: "now",
+    name: "Now",
+    icon: "clock",
+    payload: {
+      ts: import_core6.currentDate.marker,
+      lastTimestamp: import_core6.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_core6.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_core6.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;
+    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_core6.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;
+  }
+  toJSON() {
+    return {
+      type: "dynamic",
+      id: this.options.id
+    };
+  }
+};
+__name(DynamicSchedule, "DynamicSchedule");
+
+// src/triggerClient.ts
+var registerSourceEvent = {
+  name: import_core7.REGISTER_SOURCE_EVENT_V2,
+  title: "Register Source",
+  source: "internal",
+  icon: "register-source",
+  parsePayload: import_core7.RegisterSourceEventSchemaV2.parse
+};
+var _options4, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _authResolvers, _client2, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn, _resolveConnections, resolveConnections_fn, _resolveConnection, resolveConnection_fn, _buildJobsIndex, buildJobsIndex_fn, _buildJobIndex, buildJobIndex_fn, _buildJobIntegrations, buildJobIntegrations_fn, _buildJobIntegration, buildJobIntegration_fn, _logIOStats, logIOStats_fn, _standardResponseHeaders, standardResponseHeaders_get;
+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, _resolveConnections);
+    __privateAdd(this, _resolveConnection);
+    __privateAdd(this, _buildJobsIndex);
+    __privateAdd(this, _buildJobIndex);
+    __privateAdd(this, _buildJobIntegrations);
+    __privateAdd(this, _buildJobIntegration);
+    __privateAdd(this, _logIOStats);
+    __privateAdd(this, _standardResponseHeaders);
+    __privateAdd(this, _options4, void 0);
     __privateAdd(this, _registeredJobs, {});
     __privateAdd(this, _registeredSources, {});
     __privateAdd(this, _registeredHttpSourceHandlers, {});
     __privateAdd(this, _registeredDynamicTriggers, {});
     __privateAdd(this, _jobMetadataByDynamicTriggers, {});
     __privateAdd(this, _registeredSchedules, {});
-    __privateAdd(this, _client, void 0);
+    __privateAdd(this, _authResolvers, {});
+    __privateAdd(this, _client2, 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"));
+    __privateSet(this, _options4, options);
+    __privateSet(this, _client2, new ApiClient(__privateGet(this, _options4)));
+    __privateSet(this, _internalLogger, new import_core7.Logger("trigger.dev", __privateGet(this, _options4).verbose ? "debug" : "log", [
+      "output",
+      "noopTasksSet"
+    ]));
   }
   async handleRequest(request) {
     __privateGet(this, _internalLogger).debug("handling request", {
@@ -1085,6 +1655,7 @@ var TriggerClient = class {
       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": {
@@ -1095,7 +1666,8 @@ var TriggerClient = class {
           status: 401,
           body: {
             message: "Unauthorized: client missing apiKey"
-          }
+          },
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
       case "missing-header": {
@@ -1103,7 +1675,8 @@ var TriggerClient = class {
           status: 401,
           body: {
             message: "Unauthorized: missing x-trigger-api-key header"
-          }
+          },
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
       case "unauthorized": {
@@ -1111,7 +1684,8 @@ var TriggerClient = class {
           status: 401,
           body: {
             message: `Forbidden: client apiKey mismatch: Make sure you are using the correct API Key for your environment`
-          }
+          },
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
     }
@@ -1120,7 +1694,8 @@ var TriggerClient = class {
         status: 405,
         body: {
           message: "Method not allowed (only POST is allowed)"
-        }
+        },
+        headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
       };
     }
     const action = request.headers.get("x-trigger-action");
@@ -1129,7 +1704,8 @@ var TriggerClient = class {
         status: 400,
         body: {
           message: "Missing x-trigger-action header"
-        }
+        },
+        headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
       };
     }
     switch (action) {
@@ -1141,7 +1717,8 @@ var TriggerClient = class {
             body: {
               ok: false,
               error: "Missing endpoint ID"
-            }
+            },
+            headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
           };
         }
         if (this.id !== endpointId) {
@@ -1150,35 +1727,21 @@ var TriggerClient = class {
             body: {
               ok: false,
               error: `Endpoint ID mismatch error. Expected ${this.id}, got ${endpointId}`
-            }
+            },
+            headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
           };
         }
         return {
           status: 200,
           body: {
             ok: true
-          }
+          },
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
       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()),
+          jobs: __privateMethod(this, _buildJobsIndex, buildJobsIndex_fn).call(this),
           sources: Object.values(__privateGet(this, _registeredSources)),
           dynamicTriggers: Object.values(__privateGet(this, _registeredDynamicTriggers)).map((trigger) => ({
             id: trigger.id,
@@ -1195,12 +1758,13 @@ var TriggerClient = class {
         };
         return {
           status: 200,
-          body
+          body,
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
       case "INITIALIZE_TRIGGER": {
         const json = await request.json();
-        const body = import_core5.InitializeTriggerBodySchema.safeParse(json);
+        const body = import_core7.InitializeTriggerBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -1220,12 +1784,13 @@ var TriggerClient = class {
         }
         return {
           status: 200,
-          body: dynamicTrigger.registeredTriggerForParams(body.data.params)
+          body: dynamicTrigger.registeredTriggerForParams(body.data.params),
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
       case "EXECUTE_JOB": {
         const json = await request.json();
-        const execution = import_core5.RunJobBodySchema.safeParse(json);
+        const execution = import_core7.RunJobBodySchema.safeParse(json);
         if (!execution.success) {
           return {
             status: 400,
@@ -1243,15 +1808,16 @@ var TriggerClient = class {
             }
           };
         }
-        const results = await __privateMethod(this, _executeJob, executeJob_fn).call(this, execution.data, job);
+        const results = await __privateMethod(this, _executeJob, executeJob_fn).call(this, execution.data, job, triggerVersion);
         return {
           status: 200,
-          body: results
+          body: results,
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
       case "PREPROCESS_RUN": {
         const json = await request.json();
-        const body = import_core5.PreprocessRunBodySchema.safeParse(json);
+        const body = import_core7.PreprocessRunBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -1275,11 +1841,12 @@ var TriggerClient = class {
           body: {
             abort: results.abort,
             properties: results.properties
-          }
+          },
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
       case "DELIVER_HTTP_SOURCE_REQUEST": {
-        const headers = import_core5.HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
+        const headers = import_core7.HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
         if (!headers.success) {
           return {
             status: 400,
@@ -1324,7 +1891,8 @@ var TriggerClient = class {
             events,
             response,
             metadata
-          }
+          },
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
       case "VALIDATE": {
@@ -1333,7 +1901,8 @@ var TriggerClient = class {
           body: {
             ok: true,
             endpointId: this.id
-          }
+          },
+          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
         };
       }
     }
@@ -1341,16 +1910,30 @@ var TriggerClient = class {
       status: 405,
       body: {
         message: "Method not allowed"
-      }
+      },
+      headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
     };
   }
+  defineJob(options) {
+    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);
+  }
   attach(job) {
     __privateGet(this, _registeredJobs)[job.id] = job;
     job.trigger.attachToJob(this, job);
   }
   attachDynamicTrigger(trigger) {
     __privateGet(this, _registeredDynamicTriggers)[trigger.id] = trigger;
-    new Job(this, {
+    this.defineJob({
       id: dynamicTriggerRegisterSourceJobId(trigger.id),
       name: `Register dynamic trigger ${trigger.id}`,
       version: trigger.source.version,
@@ -1446,7 +2029,11 @@ var TriggerClient = class {
       __internal: true
     });
   }
-  attachDynamicSchedule(key, job) {
+  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,
@@ -1455,58 +2042,65 @@ var TriggerClient = class {
     __privateGet(this, _registeredSchedules)[key] = jobs;
   }
   async registerTrigger(id, key, options) {
-    return __privateGet(this, _client).registerTrigger(this.id, id, key, options);
+    return __privateGet(this, _client2).registerTrigger(this.id, id, key, options);
   }
   async getAuth(id) {
-    return __privateGet(this, _client).getAuth(this.id, id);
+    return __privateGet(this, _client2).getAuth(this.id, id);
   }
   async sendEvent(event, options) {
-    return __privateGet(this, _client).sendEvent(event, options);
+    return __privateGet(this, _client2).sendEvent(event, options);
   }
   async cancelEvent(eventId) {
-    return __privateGet(this, _client).cancelEvent(eventId);
+    return __privateGet(this, _client2).cancelEvent(eventId);
+  }
+  async updateStatus(runId, id, status) {
+    return __privateGet(this, _client2).updateStatus(runId, id, status);
   }
   async registerSchedule(id, key, schedule) {
-    return __privateGet(this, _client).registerSchedule(this.id, id, key, schedule);
+    return __privateGet(this, _client2).registerSchedule(this.id, id, key, schedule);
   }
   async unregisterSchedule(id, key) {
-    return __privateGet(this, _client).unregisterSchedule(this.id, id, key);
+    return __privateGet(this, _client2).unregisterSchedule(this.id, id, key);
   }
   async getEvent(eventId) {
-    return __privateGet(this, _client).getEvent(eventId);
+    return __privateGet(this, _client2).getEvent(eventId);
   }
   async getRun(runId, options) {
-    return __privateGet(this, _client).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, _client).getRuns(jobSlug, options);
+    return __privateGet(this, _client2).getRuns(jobSlug, options);
+  }
+  async getRunStatuses(runId) {
+    return __privateGet(this, _client2).getRunStatuses(runId);
   }
   authorized(apiKey) {
     if (typeof apiKey !== "string") {
       return "missing-header";
     }
-    const localApiKey = __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
+    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, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
-  }
-  defineJob(options) {
-    return new Job(this, options);
+    return __privateGet(this, _options4).apiKey ?? process.env.TRIGGER_API_KEY;
   }
 };
 __name(TriggerClient, "TriggerClient");
-_options3 = new WeakMap();
+_options4 = new WeakMap();
 _registeredJobs = new WeakMap();
 _registeredSources = new WeakMap();
 _registeredHttpSourceHandlers = new WeakMap();
 _registeredDynamicTriggers = new WeakMap();
 _jobMetadataByDynamicTriggers = new WeakMap();
 _registeredSchedules = new WeakMap();
-_client = new WeakMap();
+_authResolvers = new WeakMap();
+_client2 = new WeakMap();
 _internalLogger = new WeakMap();
 _preprocessRun = new WeakSet();
 preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
@@ -1519,30 +2113,66 @@ preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
   };
 }, "#preprocessRun");
 _executeJob = new WeakSet();
-executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
+executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, triggerVersion) {
   __privateGet(this, _internalLogger).debug("executing job", {
     execution: body1,
-    job: job1.toJSON()
+    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,
     cachedTasks: body1.tasks,
-    apiClient: __privateGet(this, _client),
+    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, _options3).logLevel ?? "info",
-    jobLogger: __privateGet(this, _options3).ioLogLocalEnabled ? new import_core5.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info") : void 0
+    jobLogLevel: job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info",
+    jobLogger: __privateGet(this, _options4).ioLogLocalEnabled ? new import_core7.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info") : void 0,
+    serverVersion: triggerVersion
   });
-  const ioWithConnections = createIOWithIntegrations(io, body1.connections, job1.options.integrations);
+  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 output = await job1.options.run(job1.trigger.event.parsePayload(body1.event.payload ?? {}), ioWithConnections, context);
+    const output = await runLocalStorage.runWith({
+      io,
+      ctx: context
+    }, () => {
+      return job1.options.run(job1.trigger.event.parsePayload(body1.event.payload ?? {}), 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 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",
@@ -1564,7 +2194,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
       };
     }
     if (error instanceof RetryWithTaskError) {
-      const errorWithStack2 = import_core5.ErrorWithStackSchema.safeParse(error.cause);
+      const errorWithStack2 = import_core7.ErrorWithStackSchema.safeParse(error.cause);
       if (errorWithStack2.success) {
         return {
           status: "ERROR",
@@ -1580,7 +2210,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
         task: error.task
       };
     }
-    const errorWithStack = import_core5.ErrorWithStackSchema.safeParse(error);
+    const errorWithStack = import_core7.ErrorWithStackSchema.safeParse(error);
     if (errorWithStack.success) {
       return {
         status: "ERROR",
@@ -1712,6 +2342,166 @@ handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourc
     metadata: results.metadata
   };
 }, "#handleHttpSourceRequest");
+_resolveConnections = new WeakSet();
+resolveConnections_fn = /* @__PURE__ */ __name(async function(ctx, 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, ctx, 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(ctx1, 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(ctx1, 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
+  };
+}, "#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_get = /* @__PURE__ */ __name(function() {
+  return {
+    "Trigger-Version": import_core7.API_VERSIONS.LAZY_LOADED_CACHED_TASKS
+  };
+}, "#standardResponseHeaders");
 function dynamicTriggerRegisterSourceJobId(id) {
   return `register-dynamic-trigger-${id}`;
 }
@@ -1737,7 +2527,7 @@ function deepMergeOptions(obj1, obj2) {
 __name(deepMergeOptions, "deepMergeOptions");
 
 // src/triggers/externalSource.ts
-var import_core6 = require("@trigger.dev/core");
+var import_core8 = require("@trigger.dev/core");
 var ExternalSource = class {
   constructor(channel, options) {
     this.options = options;
@@ -1811,7 +2601,7 @@ var ExternalSourceTrigger = class {
       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 ?? {}),
+        payload: (0, import_core8.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)
@@ -1845,214 +2635,6 @@ function omit(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) {