@trigger.dev/sdk 2.0.0-next.0 → 2.0.0-next.10

package/dist/index.js

@@ -1,7 +1,9 @@
 "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) => {
@@ -16,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   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))
@@ -55,16 +61,16 @@ __export(src_exports, {
   Job: () => Job,
   MissingConnectionNotification: () => MissingConnectionNotification,
   MissingConnectionResolvedNotification: () => MissingConnectionResolvedNotification,
-  ResumeWithTask: () => ResumeWithTask,
   TriggerClient: () => TriggerClient,
   authenticatedTask: () => authenticatedTask,
   cronTrigger: () => cronTrigger,
   eventTrigger: () => eventTrigger,
   intervalTrigger: () => intervalTrigger,
+  isTriggerError: () => isTriggerError,
   missingConnectionNotification: () => missingConnectionNotification,
   missingConnectionResolvedNotification: () => missingConnectionResolvedNotification,
   omit: () => omit,
-  secureString: () => secureString
+  redactString: () => redactString
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -104,15 +110,17 @@ var Job = class {
   get integrations() {
     return Object.keys(this.options.integrations ?? {}).reduce((acc, key) => {
       const integration = this.options.integrations[key];
-      if (!integration.client.usesLocalAuth) {
-        acc[key] = {
-          id: integration.id,
-          metadata: integration.metadata
-        };
-      }
+      acc[key] = {
+        id: integration.id,
+        metadata: integration.metadata,
+        authSource: integration.client.usesLocalAuth ? "LOCAL" : "HOSTED"
+      };
       return acc;
     }, {});
   }
+  get logLevel() {
+    return this.options.logLevel;
+  }
   toJSON() {
     const internal = this.options.__internal;
     return {
@@ -146,18 +154,23 @@ var logLevels = [
   "info",
   "debug"
 ];
-var _name, _level, _filteredKeys;
+var _name, _level, _filteredKeys, _jsonReplacer;
 var _Logger = class {
-  constructor(name, level = "info", filteredKeys = []) {
+  constructor(name, level = "info", filteredKeys = [], jsonReplacer) {
     __privateAdd(this, _name, void 0);
     __privateAdd(this, _level, void 0);
     __privateAdd(this, _filteredKeys, []);
+    __privateAdd(this, _jsonReplacer, void 0);
     __privateSet(this, _name, name);
     __privateSet(this, _level, logLevels.indexOf(process.env.TRIGGER_LOG_LEVEL ?? level));
     __privateSet(this, _filteredKeys, filteredKeys);
+    __privateSet(this, _jsonReplacer, jsonReplacer);
   }
   filter(...keys) {
-    return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys);
+    return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys, __privateGet(this, _jsonReplacer));
+  }
+  static satisfiesLogLevel(logLevel, setLevel) {
+    return logLevels.indexOf(logLevel) <= logLevels.indexOf(setLevel);
   }
   log(...args) {
     if (__privateGet(this, _level) < 0)
@@ -188,7 +201,7 @@ var _Logger = class {
       message,
       args: structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys))
     };
-    console.debug(JSON.stringify(structuredLog, bigIntReplacer));
+    console.debug(JSON.stringify(structuredLog, createReplacer(__privateGet(this, _jsonReplacer))));
   }
 };
 var Logger = _Logger;
@@ -196,6 +209,19 @@ __name(Logger, "Logger");
 _name = new WeakMap();
 _level = new WeakMap();
 _filteredKeys = new WeakMap();
+_jsonReplacer = new WeakMap();
+function createReplacer(replacer) {
+  return (key, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (replacer) {
+      return replacer(key, value);
+    }
+    return value;
+  };
+}
+__name(createReplacer, "createReplacer");
 function bigIntReplacer(_key, value) {
   if (typeof value === "bigint") {
     return value.toString();
@@ -254,129 +280,100 @@ __name(filterKeys, "filterKeys");
 
 // ../internal/src/schemas/api.ts
 var import_ulid = require("ulid");
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
-// ../internal/src/schemas/integrations.ts
+// ../internal/src/schemas/errors.ts
 var import_zod = require("zod");
-var ConnectionAuthSchema = import_zod.z.object({
-  type: import_zod.z.enum([
-    "oauth2"
-  ]),
-  accessToken: import_zod.z.string(),
-  scopes: import_zod.z.array(import_zod.z.string()).optional(),
-  additionalFields: import_zod.z.record(import_zod.z.string()).optional()
-});
-var IntegrationMetadataSchema = import_zod.z.object({
-  key: import_zod.z.string(),
-  title: import_zod.z.string(),
-  icon: import_zod.z.string()
-});
-var IntegrationConfigSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  metadata: IntegrationMetadataSchema
+var ErrorWithStackSchema = import_zod.z.object({
+  message: import_zod.z.string(),
+  name: import_zod.z.string().optional(),
+  stack: import_zod.z.string().optional()
 });
 
-// ../internal/src/schemas/properties.ts
+// ../internal/src/schemas/eventFilter.ts
 var import_zod2 = require("zod");
-var DisplayPropertySchema = import_zod2.z.object({
-  label: import_zod2.z.string(),
-  text: import_zod2.z.string(),
-  url: import_zod2.z.string().optional()
-});
-var DisplayPropertiesSchema = import_zod2.z.array(DisplayPropertySchema);
-var StyleSchema = import_zod2.z.object({
-  style: import_zod2.z.enum([
-    "normal",
-    "minimal"
+var EventMatcherSchema = import_zod2.z.union([
+  import_zod2.z.array(import_zod2.z.string()),
+  import_zod2.z.array(import_zod2.z.number()),
+  import_zod2.z.array(import_zod2.z.boolean())
+]);
+var EventFilterSchema = import_zod2.z.lazy(() => import_zod2.z.record(import_zod2.z.union([
+  EventMatcherSchema,
+  EventFilterSchema
+])));
+var EventRuleSchema = import_zod2.z.object({
+  event: import_zod2.z.string(),
+  source: import_zod2.z.string(),
+  payload: EventFilterSchema.optional(),
+  context: EventFilterSchema.optional()
+});
+
+// ../internal/src/schemas/integrations.ts
+var import_zod3 = require("zod");
+var ConnectionAuthSchema = import_zod3.z.object({
+  type: import_zod3.z.enum([
+    "oauth2"
   ]),
-  variant: import_zod2.z.string().optional()
+  accessToken: import_zod3.z.string(),
+  scopes: import_zod3.z.array(import_zod3.z.string()).optional(),
+  additionalFields: import_zod3.z.record(import_zod3.z.string()).optional()
+});
+var IntegrationMetadataSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  instructions: import_zod3.z.string().optional()
+});
+var IntegrationConfigSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  metadata: IntegrationMetadataSchema,
+  authSource: import_zod3.z.enum([
+    "HOSTED",
+    "LOCAL"
+  ])
 });
 
 // ../internal/src/schemas/json.ts
-var import_zod3 = require("zod");
-var LiteralSchema = import_zod3.z.union([
-  import_zod3.z.string(),
-  import_zod3.z.number(),
-  import_zod3.z.boolean(),
-  import_zod3.z.null()
+var import_zod4 = require("zod");
+var LiteralSchema = import_zod4.z.union([
+  import_zod4.z.string(),
+  import_zod4.z.number(),
+  import_zod4.z.boolean(),
+  import_zod4.z.null()
 ]);
-var DeserializedJsonSchema = import_zod3.z.lazy(() => import_zod3.z.union([
+var DeserializedJsonSchema = import_zod4.z.lazy(() => import_zod4.z.union([
   LiteralSchema,
-  import_zod3.z.array(DeserializedJsonSchema),
-  import_zod3.z.record(DeserializedJsonSchema)
+  import_zod4.z.array(DeserializedJsonSchema),
+  import_zod4.z.record(DeserializedJsonSchema)
 ]));
-var SerializableSchema = import_zod3.z.union([
-  import_zod3.z.string(),
-  import_zod3.z.number(),
-  import_zod3.z.boolean(),
-  import_zod3.z.null(),
-  import_zod3.z.date(),
-  import_zod3.z.undefined(),
-  import_zod3.z.symbol()
+var SerializableSchema = import_zod4.z.union([
+  import_zod4.z.string(),
+  import_zod4.z.number(),
+  import_zod4.z.boolean(),
+  import_zod4.z.null(),
+  import_zod4.z.date(),
+  import_zod4.z.undefined(),
+  import_zod4.z.symbol()
 ]);
-var SerializableJsonSchema = import_zod3.z.lazy(() => import_zod3.z.union([
+var SerializableJsonSchema = import_zod4.z.lazy(() => import_zod4.z.union([
   SerializableSchema,
-  import_zod3.z.array(SerializableJsonSchema),
-  import_zod3.z.record(SerializableJsonSchema)
+  import_zod4.z.array(SerializableJsonSchema),
+  import_zod4.z.record(SerializableJsonSchema)
 ]));
 
-// ../internal/src/schemas/tasks.ts
-var import_zod4 = require("zod");
-var TaskStatusSchema = import_zod4.z.enum([
-  "PENDING",
-  "WAITING",
-  "RUNNING",
-  "COMPLETED",
-  "ERRORED"
-]);
-var TaskSchema = import_zod4.z.object({
-  id: import_zod4.z.string(),
-  name: import_zod4.z.string(),
-  icon: import_zod4.z.string().optional().nullable(),
-  noop: import_zod4.z.boolean(),
-  startedAt: import_zod4.z.coerce.date().optional().nullable(),
-  completedAt: import_zod4.z.coerce.date().optional().nullable(),
-  delayUntil: import_zod4.z.coerce.date().optional().nullable(),
-  status: TaskStatusSchema,
-  description: import_zod4.z.string().optional().nullable(),
-  properties: import_zod4.z.array(DisplayPropertySchema).optional().nullable(),
-  params: DeserializedJsonSchema.optional().nullable(),
-  output: DeserializedJsonSchema.optional().nullable(),
-  error: import_zod4.z.string().optional().nullable(),
-  parentId: import_zod4.z.string().optional().nullable(),
-  style: StyleSchema.optional().nullable()
-});
-var ServerTaskSchema = TaskSchema.extend({
-  idempotencyKey: import_zod4.z.string()
-});
-var CachedTaskSchema = import_zod4.z.object({
-  id: import_zod4.z.string(),
-  idempotencyKey: import_zod4.z.string(),
-  status: TaskStatusSchema,
-  noop: import_zod4.z.boolean().default(false),
-  output: DeserializedJsonSchema.optional().nullable(),
-  parentId: import_zod4.z.string().optional().nullable()
-});
-
-// ../internal/src/schemas/triggers.ts
-var import_zod7 = require("zod");
-
-// ../internal/src/schemas/eventFilter.ts
+// ../internal/src/schemas/properties.ts
 var import_zod5 = require("zod");
-var EventMatcherSchema = import_zod5.z.union([
-  import_zod5.z.array(import_zod5.z.string()),
-  import_zod5.z.array(import_zod5.z.number()),
-  import_zod5.z.array(import_zod5.z.boolean())
-]);
-var EventFilterSchema = import_zod5.z.lazy(() => import_zod5.z.record(import_zod5.z.union([
-  EventMatcherSchema,
-  EventFilterSchema
-])));
-var EventRuleSchema = import_zod5.z.object({
-  event: import_zod5.z.string(),
-  source: import_zod5.z.string(),
-  payload: EventFilterSchema.optional(),
-  context: EventFilterSchema.optional()
+var DisplayPropertySchema = import_zod5.z.object({
+  label: import_zod5.z.string(),
+  text: import_zod5.z.string(),
+  url: import_zod5.z.string().optional()
+});
+var DisplayPropertiesSchema = import_zod5.z.array(DisplayPropertySchema);
+var StyleSchema = import_zod5.z.object({
+  style: import_zod5.z.enum([
+    "normal",
+    "minimal"
+  ]),
+  variant: import_zod5.z.string().optional()
 });
 
 // ../internal/src/schemas/schedules.ts
@@ -413,310 +410,400 @@ var RegisterDynamicSchedulePayloadSchema = import_zod6.z.object({
   }))
 });
 
-// ../internal/src/schemas/triggers.ts
-var EventSpecificationSchema = import_zod7.z.object({
+// ../internal/src/schemas/tasks.ts
+var import_zod7 = require("zod");
+var TaskStatusSchema = import_zod7.z.enum([
+  "PENDING",
+  "WAITING",
+  "RUNNING",
+  "COMPLETED",
+  "ERRORED"
+]);
+var TaskSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
   name: import_zod7.z.string(),
-  title: import_zod7.z.string(),
-  source: import_zod7.z.string(),
-  icon: import_zod7.z.string(),
+  icon: import_zod7.z.string().optional().nullable(),
+  noop: import_zod7.z.boolean(),
+  startedAt: import_zod7.z.coerce.date().optional().nullable(),
+  completedAt: import_zod7.z.coerce.date().optional().nullable(),
+  delayUntil: import_zod7.z.coerce.date().optional().nullable(),
+  status: TaskStatusSchema,
+  description: import_zod7.z.string().optional().nullable(),
+  properties: import_zod7.z.array(DisplayPropertySchema).optional().nullable(),
+  params: DeserializedJsonSchema.optional().nullable(),
+  output: DeserializedJsonSchema.optional().nullable(),
+  error: import_zod7.z.string().optional().nullable(),
+  parentId: import_zod7.z.string().optional().nullable(),
+  style: StyleSchema.optional().nullable(),
+  operation: import_zod7.z.string().optional().nullable()
+});
+var ServerTaskSchema = TaskSchema.extend({
+  idempotencyKey: import_zod7.z.string(),
+  attempts: import_zod7.z.number()
+});
+var CachedTaskSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  idempotencyKey: import_zod7.z.string(),
+  status: TaskStatusSchema,
+  noop: import_zod7.z.boolean().default(false),
+  output: DeserializedJsonSchema.optional().nullable(),
+  parentId: import_zod7.z.string().optional().nullable()
+});
+
+// ../internal/src/schemas/triggers.ts
+var import_zod8 = require("zod");
+var EventExampleSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  icon: import_zod8.z.string().optional(),
+  name: import_zod8.z.string(),
+  payload: import_zod8.z.any()
+});
+var EventSpecificationSchema = import_zod8.z.object({
+  name: import_zod8.z.string(),
+  title: import_zod8.z.string(),
+  source: import_zod8.z.string(),
+  icon: import_zod8.z.string(),
   filter: EventFilterSchema.optional(),
-  properties: import_zod7.z.array(DisplayPropertySchema).optional(),
-  schema: import_zod7.z.any().optional(),
-  examples: import_zod7.z.array(import_zod7.z.any()).optional()
-});
-var DynamicTriggerMetadataSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("dynamic"),
-  id: import_zod7.z.string()
-});
-var StaticTriggerMetadataSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("static"),
-  title: import_zod7.z.string(),
-  properties: import_zod7.z.array(DisplayPropertySchema).optional(),
+  properties: import_zod8.z.array(DisplayPropertySchema).optional(),
+  schema: import_zod8.z.any().optional(),
+  examples: import_zod8.z.array(EventExampleSchema).optional()
+});
+var DynamicTriggerMetadataSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("dynamic"),
+  id: import_zod8.z.string()
+});
+var StaticTriggerMetadataSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("static"),
+  title: import_zod8.z.string(),
+  properties: import_zod8.z.array(DisplayPropertySchema).optional(),
   rule: EventRuleSchema
 });
-var ScheduledTriggerMetadataSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("scheduled"),
+var ScheduledTriggerMetadataSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("scheduled"),
   schedule: ScheduleMetadataSchema
 });
-var TriggerMetadataSchema = import_zod7.z.discriminatedUnion("type", [
+var TriggerMetadataSchema = import_zod8.z.discriminatedUnion("type", [
   DynamicTriggerMetadataSchema,
   StaticTriggerMetadataSchema,
   ScheduledTriggerMetadataSchema
 ]);
 
 // ../internal/src/schemas/api.ts
-var UpdateTriggerSourceBodySchema = import_zod8.z.object({
-  registeredEvents: import_zod8.z.array(import_zod8.z.string()),
-  secret: import_zod8.z.string().optional(),
+var UpdateTriggerSourceBodySchema = import_zod9.z.object({
+  registeredEvents: import_zod9.z.array(import_zod9.z.string()),
+  secret: import_zod9.z.string().optional(),
   data: SerializableJsonSchema.optional()
 });
 var HttpEventSourceSchema = UpdateTriggerSourceBodySchema.extend({
-  id: import_zod8.z.string(),
-  active: import_zod8.z.boolean(),
-  url: import_zod8.z.string().url()
+  id: import_zod9.z.string(),
+  active: import_zod9.z.boolean(),
+  url: import_zod9.z.string().url()
 });
-var RegisterHTTPTriggerSourceBodySchema = import_zod8.z.object({
-  type: import_zod8.z.literal("HTTP"),
-  url: import_zod8.z.string().url()
+var RegisterHTTPTriggerSourceBodySchema = import_zod9.z.object({
+  type: import_zod9.z.literal("HTTP"),
+  url: import_zod9.z.string().url()
 });
-var RegisterSMTPTriggerSourceBodySchema = import_zod8.z.object({
-  type: import_zod8.z.literal("SMTP")
+var RegisterSMTPTriggerSourceBodySchema = import_zod9.z.object({
+  type: import_zod9.z.literal("SMTP")
 });
-var RegisterSQSTriggerSourceBodySchema = import_zod8.z.object({
-  type: import_zod8.z.literal("SQS")
+var RegisterSQSTriggerSourceBodySchema = import_zod9.z.object({
+  type: import_zod9.z.literal("SQS")
 });
-var RegisterSourceChannelBodySchema = import_zod8.z.discriminatedUnion("type", [
+var RegisterSourceChannelBodySchema = import_zod9.z.discriminatedUnion("type", [
   RegisterHTTPTriggerSourceBodySchema,
   RegisterSMTPTriggerSourceBodySchema,
   RegisterSQSTriggerSourceBodySchema
 ]);
 var REGISTER_SOURCE_EVENT = "dev.trigger.source.register";
-var RegisterTriggerSourceSchema = import_zod8.z.object({
-  key: import_zod8.z.string(),
-  params: import_zod8.z.any(),
-  active: import_zod8.z.boolean(),
-  secret: import_zod8.z.string(),
+var RegisterTriggerSourceSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  params: import_zod9.z.any(),
+  active: import_zod9.z.boolean(),
+  secret: import_zod9.z.string(),
   data: DeserializedJsonSchema.optional(),
   channel: RegisterSourceChannelBodySchema,
-  clientId: import_zod8.z.string().optional()
+  clientId: import_zod9.z.string().optional()
 });
-var RegisterSourceEventSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
+var RegisterSourceEventSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
   source: RegisterTriggerSourceSchema,
-  events: import_zod8.z.array(import_zod8.z.string()),
-  missingEvents: import_zod8.z.array(import_zod8.z.string()),
-  orphanedEvents: import_zod8.z.array(import_zod8.z.string()),
-  dynamicTriggerId: import_zod8.z.string().optional()
-});
-var TriggerSourceSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  key: import_zod8.z.string()
-});
-var HandleTriggerSourceSchema = import_zod8.z.object({
-  key: import_zod8.z.string(),
-  secret: import_zod8.z.string(),
-  data: import_zod8.z.any(),
-  params: import_zod8.z.any()
-});
-var HttpSourceRequestSchema = import_zod8.z.object({
-  url: import_zod8.z.string().url(),
-  method: import_zod8.z.string(),
-  headers: import_zod8.z.record(import_zod8.z.string()),
-  rawBody: import_zod8.z.instanceof(Buffer).optional().nullable()
-});
-var HttpSourceRequestHeadersSchema = import_zod8.z.object({
-  "x-ts-key": import_zod8.z.string(),
-  "x-ts-dynamic-id": import_zod8.z.string().optional(),
-  "x-ts-secret": import_zod8.z.string(),
-  "x-ts-data": import_zod8.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-params": import_zod8.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-http-url": import_zod8.z.string(),
-  "x-ts-http-method": import_zod8.z.string(),
-  "x-ts-http-headers": import_zod8.z.string().transform((s) => import_zod8.z.record(import_zod8.z.string()).parse(JSON.parse(s)))
-});
-var PongResponseSchema = import_zod8.z.object({
-  message: import_zod8.z.literal("PONG")
-});
-var QueueOptionsSchema = import_zod8.z.object({
-  name: import_zod8.z.string(),
-  maxConcurrent: import_zod8.z.number().optional()
-});
-var JobMetadataSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  version: import_zod8.z.string(),
+  events: import_zod9.z.array(import_zod9.z.string()),
+  missingEvents: import_zod9.z.array(import_zod9.z.string()),
+  orphanedEvents: import_zod9.z.array(import_zod9.z.string()),
+  dynamicTriggerId: import_zod9.z.string().optional()
+});
+var TriggerSourceSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  key: import_zod9.z.string()
+});
+var HandleTriggerSourceSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  secret: import_zod9.z.string(),
+  data: import_zod9.z.any(),
+  params: import_zod9.z.any()
+});
+var HttpSourceRequestSchema = import_zod9.z.object({
+  url: import_zod9.z.string().url(),
+  method: import_zod9.z.string(),
+  headers: import_zod9.z.record(import_zod9.z.string()),
+  rawBody: import_zod9.z.instanceof(Buffer).optional().nullable()
+});
+var HttpSourceRequestHeadersSchema = import_zod9.z.object({
+  "x-ts-key": import_zod9.z.string(),
+  "x-ts-dynamic-id": import_zod9.z.string().optional(),
+  "x-ts-secret": import_zod9.z.string(),
+  "x-ts-data": import_zod9.z.string().transform((s) => JSON.parse(s)),
+  "x-ts-params": import_zod9.z.string().transform((s) => JSON.parse(s)),
+  "x-ts-http-url": import_zod9.z.string(),
+  "x-ts-http-method": import_zod9.z.string(),
+  "x-ts-http-headers": import_zod9.z.string().transform((s) => import_zod9.z.record(import_zod9.z.string()).parse(JSON.parse(s)))
+});
+var PongSuccessResponseSchema = import_zod9.z.object({
+  ok: import_zod9.z.literal(true)
+});
+var PongErrorResponseSchema = import_zod9.z.object({
+  ok: import_zod9.z.literal(false),
+  error: import_zod9.z.string()
+});
+var PongResponseSchema = import_zod9.z.discriminatedUnion("ok", [
+  PongSuccessResponseSchema,
+  PongErrorResponseSchema
+]);
+var QueueOptionsSchema = import_zod9.z.object({
+  name: import_zod9.z.string(),
+  maxConcurrent: import_zod9.z.number().optional()
+});
+var JobMetadataSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  version: import_zod9.z.string(),
   event: EventSpecificationSchema,
   trigger: TriggerMetadataSchema,
-  integrations: import_zod8.z.record(IntegrationConfigSchema),
-  internal: import_zod8.z.boolean().default(false),
-  queue: import_zod8.z.union([
+  integrations: import_zod9.z.record(IntegrationConfigSchema),
+  internal: import_zod9.z.boolean().default(false),
+  queue: import_zod9.z.union([
     QueueOptionsSchema,
-    import_zod8.z.string()
+    import_zod9.z.string()
   ]).optional(),
-  startPosition: import_zod8.z.enum([
+  startPosition: import_zod9.z.enum([
     "initial",
     "latest"
   ]),
-  enabled: import_zod8.z.boolean(),
-  preprocessRuns: import_zod8.z.boolean()
+  enabled: import_zod9.z.boolean(),
+  preprocessRuns: import_zod9.z.boolean()
 });
-var SourceMetadataSchema = import_zod8.z.object({
-  channel: import_zod8.z.enum([
+var SourceMetadataSchema = import_zod9.z.object({
+  channel: import_zod9.z.enum([
     "HTTP",
     "SQS",
     "SMTP"
   ]),
-  key: import_zod8.z.string(),
-  params: import_zod8.z.any(),
-  events: import_zod8.z.array(import_zod8.z.string()),
-  clientId: import_zod8.z.string().optional()
-});
-var DynamicTriggerEndpointMetadataSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  jobs: import_zod8.z.array(JobMetadataSchema.pick({
+  integration: IntegrationConfigSchema,
+  key: import_zod9.z.string(),
+  params: import_zod9.z.any(),
+  events: import_zod9.z.array(import_zod9.z.string())
+});
+var DynamicTriggerEndpointMetadataSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  jobs: import_zod9.z.array(JobMetadataSchema.pick({
     id: true,
     version: true
   }))
 });
-var GetEndpointDataResponseSchema = import_zod8.z.object({
-  jobs: import_zod8.z.array(JobMetadataSchema),
-  sources: import_zod8.z.array(SourceMetadataSchema),
-  dynamicTriggers: import_zod8.z.array(DynamicTriggerEndpointMetadataSchema),
-  dynamicSchedules: import_zod8.z.array(RegisterDynamicSchedulePayloadSchema)
-});
-var RawEventSchema = import_zod8.z.object({
-  id: import_zod8.z.string().default(() => (0, import_ulid.ulid)()),
-  name: import_zod8.z.string(),
-  source: import_zod8.z.string().optional(),
-  payload: import_zod8.z.any(),
-  context: import_zod8.z.any().optional(),
-  timestamp: import_zod8.z.string().datetime().optional()
-});
-var ApiEventLogSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  name: import_zod8.z.string(),
+var IndexEndpointResponseSchema = import_zod9.z.object({
+  jobs: import_zod9.z.array(JobMetadataSchema),
+  sources: import_zod9.z.array(SourceMetadataSchema),
+  dynamicTriggers: import_zod9.z.array(DynamicTriggerEndpointMetadataSchema),
+  dynamicSchedules: import_zod9.z.array(RegisterDynamicSchedulePayloadSchema)
+});
+var RawEventSchema = import_zod9.z.object({
+  name: import_zod9.z.string(),
+  payload: import_zod9.z.any(),
+  context: import_zod9.z.any().optional(),
+  id: import_zod9.z.string().default(() => (0, import_ulid.ulid)()),
+  timestamp: import_zod9.z.coerce.date().optional(),
+  source: import_zod9.z.string().optional()
+});
+var ApiEventLogSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
   payload: DeserializedJsonSchema,
   context: DeserializedJsonSchema.optional().nullable(),
-  timestamp: import_zod8.z.coerce.date(),
-  deliverAt: import_zod8.z.coerce.date().optional().nullable(),
-  deliveredAt: import_zod8.z.coerce.date().optional().nullable()
+  timestamp: import_zod9.z.coerce.date(),
+  deliverAt: import_zod9.z.coerce.date().optional().nullable(),
+  deliveredAt: import_zod9.z.coerce.date().optional().nullable()
 });
-var SendEventOptionsSchema = import_zod8.z.object({
-  deliverAt: import_zod8.z.string().datetime().optional(),
-  deliverAfter: import_zod8.z.number().int().optional(),
-  accountId: import_zod8.z.string().optional()
+var SendEventOptionsSchema = import_zod9.z.object({
+  deliverAt: import_zod9.z.coerce.date().optional(),
+  deliverAfter: import_zod9.z.number().int().optional(),
+  accountId: import_zod9.z.string().optional()
 });
-var SendEventBodySchema = import_zod8.z.object({
+var SendEventBodySchema = import_zod9.z.object({
   event: RawEventSchema,
   options: SendEventOptionsSchema.optional()
 });
-var DeliverEventResponseSchema = import_zod8.z.object({
-  deliveredAt: import_zod8.z.string().datetime()
+var DeliverEventResponseSchema = import_zod9.z.object({
+  deliveredAt: import_zod9.z.string().datetime()
 });
-var RuntimeEnvironmentTypeSchema = import_zod8.z.enum([
+var RuntimeEnvironmentTypeSchema = import_zod9.z.enum([
   "PRODUCTION",
   "STAGING",
   "DEVELOPMENT",
   "PREVIEW"
 ]);
-var RunJobBodySchema = import_zod8.z.object({
+var RunSourceContextSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  metadata: import_zod9.z.any()
+});
+var RunJobBodySchema = import_zod9.z.object({
   event: ApiEventLogSchema,
-  job: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    version: import_zod8.z.string()
+  job: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    version: import_zod9.z.string()
   }),
-  run: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    isTest: import_zod8.z.boolean(),
-    startedAt: import_zod8.z.coerce.date()
+  run: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    isTest: import_zod9.z.boolean(),
+    startedAt: import_zod9.z.coerce.date()
   }),
-  environment: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    slug: import_zod8.z.string(),
+  environment: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    slug: import_zod9.z.string(),
     type: RuntimeEnvironmentTypeSchema
   }),
-  organization: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    title: import_zod8.z.string(),
-    slug: import_zod8.z.string()
+  organization: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    title: import_zod9.z.string(),
+    slug: import_zod9.z.string()
   }),
-  account: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    metadata: import_zod8.z.any()
+  account: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    metadata: import_zod9.z.any()
   }).optional(),
-  tasks: import_zod8.z.array(CachedTaskSchema).optional(),
-  connections: import_zod8.z.record(ConnectionAuthSchema).optional()
+  source: RunSourceContextSchema.optional(),
+  tasks: import_zod9.z.array(CachedTaskSchema).optional(),
+  connections: import_zod9.z.record(ConnectionAuthSchema).optional()
 });
-var RunJobResponseSchema = import_zod8.z.object({
-  executionId: import_zod8.z.string(),
-  completed: import_zod8.z.boolean(),
-  output: DeserializedJsonSchema.optional(),
+var RunJobErrorSchema = import_zod9.z.object({
+  status: import_zod9.z.literal("ERROR"),
+  error: ErrorWithStackSchema,
   task: TaskSchema.optional()
 });
-var PreprocessRunBodySchema = import_zod8.z.object({
+var RunJobResumeWithTaskSchema = import_zod9.z.object({
+  status: import_zod9.z.literal("RESUME_WITH_TASK"),
+  task: TaskSchema
+});
+var RunJobRetryWithTaskSchema = import_zod9.z.object({
+  status: import_zod9.z.literal("RETRY_WITH_TASK"),
+  task: TaskSchema,
+  error: ErrorWithStackSchema,
+  retryAt: import_zod9.z.coerce.date()
+});
+var RunJobSuccessSchema = import_zod9.z.object({
+  status: import_zod9.z.literal("SUCCESS"),
+  output: DeserializedJsonSchema.optional()
+});
+var RunJobResponseSchema = import_zod9.z.discriminatedUnion("status", [
+  RunJobErrorSchema,
+  RunJobResumeWithTaskSchema,
+  RunJobRetryWithTaskSchema,
+  RunJobSuccessSchema
+]);
+var PreprocessRunBodySchema = import_zod9.z.object({
   event: ApiEventLogSchema,
-  job: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    version: import_zod8.z.string()
+  job: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    version: import_zod9.z.string()
   }),
-  run: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    isTest: import_zod8.z.boolean()
+  run: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    isTest: import_zod9.z.boolean()
   }),
-  environment: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    slug: import_zod8.z.string(),
+  environment: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    slug: import_zod9.z.string(),
     type: RuntimeEnvironmentTypeSchema
   }),
-  organization: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    title: import_zod8.z.string(),
-    slug: import_zod8.z.string()
+  organization: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    title: import_zod9.z.string(),
+    slug: import_zod9.z.string()
   }),
-  account: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    metadata: import_zod8.z.any()
+  account: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    metadata: import_zod9.z.any()
   }).optional()
 });
-var PreprocessRunResponseSchema = import_zod8.z.object({
-  abort: import_zod8.z.boolean(),
-  properties: import_zod8.z.array(DisplayPropertySchema).optional()
+var PreprocessRunResponseSchema = import_zod9.z.object({
+  abort: import_zod9.z.boolean(),
+  properties: import_zod9.z.array(DisplayPropertySchema).optional()
 });
-var CreateRunBodySchema = import_zod8.z.object({
-  client: import_zod8.z.string(),
+var CreateRunBodySchema = import_zod9.z.object({
+  client: import_zod9.z.string(),
   job: JobMetadataSchema,
   event: ApiEventLogSchema,
-  properties: import_zod8.z.array(DisplayPropertySchema).optional()
+  properties: import_zod9.z.array(DisplayPropertySchema).optional()
 });
-var CreateRunResponseOkSchema = import_zod8.z.object({
-  ok: import_zod8.z.literal(true),
-  data: import_zod8.z.object({
-    id: import_zod8.z.string()
+var CreateRunResponseOkSchema = import_zod9.z.object({
+  ok: import_zod9.z.literal(true),
+  data: import_zod9.z.object({
+    id: import_zod9.z.string()
   })
 });
-var CreateRunResponseErrorSchema = import_zod8.z.object({
-  ok: import_zod8.z.literal(false),
-  error: import_zod8.z.string()
+var CreateRunResponseErrorSchema = import_zod9.z.object({
+  ok: import_zod9.z.literal(false),
+  error: import_zod9.z.string()
 });
-var CreateRunResponseBodySchema = import_zod8.z.discriminatedUnion("ok", [
+var CreateRunResponseBodySchema = import_zod9.z.discriminatedUnion("ok", [
   CreateRunResponseOkSchema,
   CreateRunResponseErrorSchema
 ]);
-var SecureStringSchema = import_zod8.z.object({
-  __secureString: import_zod8.z.literal(true),
-  strings: import_zod8.z.array(import_zod8.z.string()),
-  interpolations: import_zod8.z.array(import_zod8.z.string())
+var RedactStringSchema = import_zod9.z.object({
+  __redactedString: import_zod9.z.literal(true),
+  strings: import_zod9.z.array(import_zod9.z.string()),
+  interpolations: import_zod9.z.array(import_zod9.z.string())
 });
-var LogMessageSchema = import_zod8.z.object({
-  level: import_zod8.z.enum([
+var LogMessageSchema = import_zod9.z.object({
+  level: import_zod9.z.enum([
     "DEBUG",
     "INFO",
     "WARN",
     "ERROR"
   ]),
-  message: import_zod8.z.string(),
+  message: import_zod9.z.string(),
   data: SerializableJsonSchema.optional()
 });
-var RedactSchema = import_zod8.z.object({
-  paths: import_zod8.z.array(import_zod8.z.string())
-});
-var RunTaskOptionsSchema = import_zod8.z.object({
-  name: import_zod8.z.string(),
-  icon: import_zod8.z.string().optional(),
-  displayKey: import_zod8.z.string().optional(),
-  noop: import_zod8.z.boolean().default(false),
-  delayUntil: import_zod8.z.coerce.date().optional(),
-  description: import_zod8.z.string().optional(),
-  properties: import_zod8.z.array(DisplayPropertySchema).optional(),
-  params: SerializableJsonSchema.optional(),
-  trigger: TriggerMetadataSchema.optional(),
+var RedactSchema = import_zod9.z.object({
+  paths: import_zod9.z.array(import_zod9.z.string())
+});
+var RetryOptionsSchema = import_zod9.z.object({
+  limit: import_zod9.z.number().optional(),
+  factor: import_zod9.z.number().optional(),
+  minTimeoutInMs: import_zod9.z.number().optional(),
+  maxTimeoutInMs: import_zod9.z.number().optional(),
+  randomize: import_zod9.z.boolean().optional()
+});
+var RunTaskOptionsSchema = import_zod9.z.object({
+  name: import_zod9.z.string(),
+  delayUntil: import_zod9.z.coerce.date().optional(),
+  retry: RetryOptionsSchema.optional(),
+  icon: import_zod9.z.string().optional(),
+  displayKey: import_zod9.z.string().optional(),
+  description: import_zod9.z.string().optional(),
+  properties: import_zod9.z.array(DisplayPropertySchema).optional(),
+  params: import_zod9.z.any(),
+  style: StyleSchema.optional(),
+  connectionKey: import_zod9.z.string().optional(),
+  operation: import_zod9.z.enum([
+    "fetch"
+  ]).optional(),
+  noop: import_zod9.z.boolean().default(false),
   redact: RedactSchema.optional(),
-  connectionKey: import_zod8.z.string().optional(),
-  style: StyleSchema.optional()
+  trigger: TriggerMetadataSchema.optional()
 });
 var RunTaskBodyInputSchema = RunTaskOptionsSchema.extend({
-  idempotencyKey: import_zod8.z.string(),
-  parentId: import_zod8.z.string().optional()
+  idempotencyKey: import_zod9.z.string(),
+  parentId: import_zod9.z.string().optional()
 });
 var RunTaskBodyOutputSchema = RunTaskBodyInputSchema.extend({
   params: DeserializedJsonSchema.optional().nullable()
@@ -728,64 +815,59 @@ var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
 }).extend({
   output: SerializableJsonSchema.optional().transform((v) => v ? DeserializedJsonSchema.parse(JSON.parse(JSON.stringify(v))) : {})
 });
-var NormalizedRequestSchema = import_zod8.z.object({
-  headers: import_zod8.z.record(import_zod8.z.string()),
-  method: import_zod8.z.string(),
-  query: import_zod8.z.record(import_zod8.z.string()),
-  url: import_zod8.z.string(),
-  body: import_zod8.z.any()
+var FailTaskBodyInputSchema = import_zod9.z.object({
+  error: ErrorWithStackSchema
+});
+var NormalizedRequestSchema = import_zod9.z.object({
+  headers: import_zod9.z.record(import_zod9.z.string()),
+  method: import_zod9.z.string(),
+  query: import_zod9.z.record(import_zod9.z.string()),
+  url: import_zod9.z.string(),
+  body: import_zod9.z.any()
 });
-var NormalizedResponseSchema = import_zod8.z.object({
-  status: import_zod8.z.number(),
-  body: import_zod8.z.any(),
-  headers: import_zod8.z.record(import_zod8.z.string()).optional()
+var NormalizedResponseSchema = import_zod9.z.object({
+  status: import_zod9.z.number(),
+  body: import_zod9.z.any(),
+  headers: import_zod9.z.record(import_zod9.z.string()).optional()
 });
-var HttpSourceResponseSchema = import_zod8.z.object({
+var HttpSourceResponseSchema = import_zod9.z.object({
   response: NormalizedResponseSchema,
-  events: import_zod8.z.array(RawEventSchema)
+  events: import_zod9.z.array(RawEventSchema)
 });
-var RegisterTriggerBodySchema = import_zod8.z.object({
+var RegisterTriggerBodySchema = import_zod9.z.object({
   rule: EventRuleSchema,
   source: SourceMetadataSchema
 });
-var InitializeTriggerBodySchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  params: import_zod8.z.any(),
-  accountId: import_zod8.z.string().optional()
+var InitializeTriggerBodySchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  params: import_zod9.z.any(),
+  accountId: import_zod9.z.string().optional(),
+  metadata: import_zod9.z.any().optional()
 });
-var RegisterCommonScheduleBodySchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  metadata: import_zod8.z.any(),
-  accountId: import_zod8.z.string().optional()
+var RegisterCommonScheduleBodySchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  metadata: import_zod9.z.any(),
+  accountId: import_zod9.z.string().optional()
 });
 var RegisterIntervalScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(IntervalMetadataSchema);
 var InitializeCronScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(CronMetadataSchema);
-var RegisterScheduleBodySchema = import_zod8.z.discriminatedUnion("type", [
+var RegisterScheduleBodySchema = import_zod9.z.discriminatedUnion("type", [
   RegisterIntervalScheduleBodySchema,
   InitializeCronScheduleBodySchema
 ]);
-var RegisterScheduleResponseBodySchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
+var RegisterScheduleResponseBodySchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
   schedule: ScheduleMetadataSchema,
-  metadata: import_zod8.z.any(),
-  active: import_zod8.z.boolean()
+  metadata: import_zod9.z.any(),
+  active: import_zod9.z.boolean()
 });
-var CreateExternalConnectionBodySchema = import_zod8.z.object({
-  accessToken: import_zod8.z.string(),
-  type: import_zod8.z.enum([
+var CreateExternalConnectionBodySchema = import_zod9.z.object({
+  accessToken: import_zod9.z.string(),
+  type: import_zod9.z.enum([
     "oauth2"
   ]),
-  scopes: import_zod8.z.array(import_zod8.z.string()).optional(),
-  metadata: import_zod8.z.any()
-});
-
-// ../internal/src/schemas/errors.ts
-var import_zod9 = require("zod");
-var ErrorWithMessage = import_zod9.z.object({
-  message: import_zod9.z.string()
-});
-var ErrorWithStackSchema = ErrorWithMessage.extend({
-  stack: import_zod9.z.string().optional()
+  scopes: import_zod9.z.array(import_zod9.z.string()).optional(),
+  metadata: import_zod9.z.any()
 });
 
 // ../internal/src/schemas/notifications.ts
@@ -799,9 +881,7 @@ var CommonMissingConnectionNotificationPayloadSchema = import_zod10.z.object({
     title: import_zod10.z.string(),
     scopes: import_zod10.z.array(import_zod10.z.string()),
     createdAt: import_zod10.z.coerce.date(),
-    updatedAt: import_zod10.z.coerce.date(),
-    integrationIdentifier: import_zod10.z.string(),
-    integrationAuthMethod: import_zod10.z.string()
+    updatedAt: import_zod10.z.coerce.date()
   }),
   authorizationUrl: import_zod10.z.string()
 });
@@ -847,6 +927,39 @@ var MissingConnectionResolvedNotificationPayloadSchema = import_zod10.z.discrimi
   MissingExternalConnectionResolvedNotificationPayloadSchema
 ]);
 
+// ../internal/src/schemas/fetch.ts
+var import_zod11 = require("zod");
+var FetchRetryHeadersStrategySchema = import_zod11.z.object({
+  strategy: import_zod11.z.literal("headers"),
+  limitHeader: import_zod11.z.string(),
+  remainingHeader: import_zod11.z.string(),
+  resetHeader: import_zod11.z.string()
+});
+var FetchRetryBackoffStrategySchema = RetryOptionsSchema.extend({
+  strategy: import_zod11.z.literal("backoff")
+});
+var FetchRetryStrategySchema = import_zod11.z.discriminatedUnion("strategy", [
+  FetchRetryHeadersStrategySchema,
+  FetchRetryBackoffStrategySchema
+]);
+var FetchRequestInitSchema = import_zod11.z.object({
+  method: import_zod11.z.string().optional(),
+  headers: import_zod11.z.record(import_zod11.z.union([
+    import_zod11.z.string(),
+    RedactStringSchema
+  ])).optional(),
+  body: import_zod11.z.union([
+    import_zod11.z.string(),
+    import_zod11.z.instanceof(ArrayBuffer)
+  ]).optional()
+});
+var FetchRetryOptionsSchema = import_zod11.z.record(FetchRetryStrategySchema);
+var FetchOperationSchema = import_zod11.z.object({
+  url: import_zod11.z.string(),
+  requestInit: FetchRequestInitSchema.optional(),
+  retry: import_zod11.z.record(FetchRetryStrategySchema).optional()
+});
+
 // ../internal/src/utils.ts
 function deepMergeFilters(filter, other) {
   const result = {
@@ -873,8 +986,40 @@ function deepMergeFilters(filter, other) {
 }
 __name(deepMergeFilters, "deepMergeFilters");
 
+// ../internal/src/retry.ts
+var DEFAULT_RETRY_OPTIONS = {
+  limit: 5,
+  factor: 1.8,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+function calculateRetryAt(retryOptions, attempts) {
+  const options = {
+    ...DEFAULT_RETRY_OPTIONS,
+    ...retryOptions
+  };
+  const retryCount = attempts + 1;
+  if (retryCount >= options.limit) {
+    return;
+  }
+  const random = options.randomize ? Math.random() + 1 : 1;
+  let timeoutInMs = Math.round(random * Math.max(options.minTimeoutInMs, 1) * Math.pow(options.factor, Math.max(attempts - 1, 0)));
+  timeoutInMs = Math.min(timeoutInMs, options.maxTimeoutInMs);
+  return new Date(Date.now() + timeoutInMs);
+}
+__name(calculateRetryAt, "calculateRetryAt");
+
+// ../internal/src/replacements.ts
+var currentDate = {
+  marker: "__CURRENT_DATE__",
+  replace({ data: { now } }) {
+    return now.toISOString();
+  }
+};
+
 // src/apiClient.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var _apiUrl, _options, _logger, _apiKey, apiKey_fn;
 var ApiClient = class {
   constructor(options) {
@@ -955,6 +1100,22 @@ var ApiClient = class {
       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(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", {
@@ -1027,8 +1188,8 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("unregistering schedule", {
       id
     });
-    const response = await zodfetch(import_zod11.z.object({
-      ok: import_zod11.z.boolean()
+    const response = await zodfetch(import_zod12.z.object({
+      ok: import_zod12.z.boolean()
     }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
       method: "DELETE",
       headers: {
@@ -1106,6 +1267,26 @@ async function zodfetch(schema, url, requestInit, options) {
 }
 __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");
+function isTriggerError(err) {
+  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError;
+}
+__name(isTriggerError, "isTriggerError");
+
 // src/io.ts
 var import_node_async_hooks = require("async_hooks");
 var import_node_crypto = require("crypto");
@@ -1116,11 +1297,12 @@ function createIOWithIntegrations(io, auths, integrations) {
     return io;
   }
   const connections = Object.entries(integrations).reduce((acc, [connectionKey, integration]) => {
-    const connection = auths?.[connectionKey];
-    const client = "client" in integration.client ? integration.client.client : connection ? integration.client.clientFactory?.(connection) : void 0;
+    let auth = auths?.[connectionKey];
+    const client = integration.client.usesLocalAuth ? integration.client.client : auth ? integration.client.clientFactory?.(auth) : void 0;
     if (!client) {
       return acc;
     }
+    auth = integration.client.usesLocalAuth ? integration.client.auth : auth;
     const ioConnection = {
       client
     };
@@ -1132,8 +1314,8 @@ function createIOWithIntegrations(io, auths, integrations) {
           const options = authenticatedTask2.init(params);
           options.connectionKey = connectionKey;
           return await io.runTask(key, options, async (ioTask) => {
-            return authenticatedTask2.run(params, client, ioTask, io);
-          });
+            return authenticatedTask2.run(params, client, ioTask, io, auth);
+          }, authenticatedTask2.onError);
         };
       });
     }
@@ -1156,12 +1338,6 @@ function createIOWithIntegrations(io, auths, integrations) {
 __name(createIOWithIntegrations, "createIOWithIntegrations");
 
 // src/io.ts
-var ResumeWithTask = class {
-  constructor(task) {
-    this.task = task;
-  }
-};
-__name(ResumeWithTask, "ResumeWithTask");
 var _addToCachedTasks, addToCachedTasks_fn;
 var IO = class {
   constructor(options) {
@@ -1171,6 +1347,8 @@ var IO = class {
     this._triggerClient = options.client;
     this._logger = options.logger ?? new 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.id, task);
@@ -1181,45 +1359,57 @@ var IO = class {
   }
   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._logger.debug(message, data);
+          this._jobLogger?.debug(message, data);
+          logLevel = "debug";
           break;
         }
         case "INFO": {
-          this._logger.info(message, data);
+          this._jobLogger?.info(message, data);
+          logLevel = "info";
           break;
         }
         case "WARN": {
-          this._logger.warn(message, data);
+          this._jobLogger?.warn(message, data);
+          logLevel = "warn";
           break;
         }
         case "ERROR": {
-          this._logger.error(message, data);
+          this._jobLogger?.error(message, data);
+          logLevel = "error";
           break;
         }
       }
-      await this.runTask([
-        message,
-        level
-      ], {
-        name: "log",
-        icon: "log",
-        description: message,
-        params: data,
-        properties: [
-          {
-            label: "Level",
-            text: level
-          }
-        ],
-        style: {
-          style: "minimal",
-          variant: level.toLowerCase()
-        },
-        noop: true
-      }, async (task) => {
-      });
+      if (Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
+        await this.runTask([
+          message,
+          level
+        ], {
+          name: "log",
+          icon: "log",
+          description: message,
+          params: data,
+          properties: [
+            {
+              label: "Level",
+              text: level
+            }
+          ],
+          style: {
+            style: "minimal",
+            variant: level.toLowerCase()
+          },
+          noop: true
+        }, async (task) => {
+        });
+      }
     });
   }
   async wait(key, seconds) {
@@ -1237,13 +1427,56 @@ var IO = class {
     }, async (task) => {
     });
   }
+  async backgroundFetch(key, url, requestInit, retry) {
+    const urlObject = new URL(url);
+    return await this.runTask(key, {
+      name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
+      params: {
+        url,
+        requestInit,
+        retry
+      },
+      operation: "fetch",
+      icon: "background",
+      noop: false,
+      properties: [
+        {
+          label: "url",
+          text: url,
+          url
+        },
+        {
+          label: "method",
+          text: requestInit?.method ?? "GET"
+        },
+        {
+          label: "background",
+          text: "true"
+        }
+      ]
+    }, async (task) => {
+      return task.output;
+    });
+  }
   async sendEvent(key, event, options) {
     return await this.runTask(key, {
       name: "sendEvent",
       params: {
         event,
         options
-      }
+      },
+      properties: [
+        {
+          label: "name",
+          text: event.name
+        },
+        ...event?.id ? [
+          {
+            label: "ID",
+            text: event.id
+          }
+        ] : []
+      ]
     }, async (task) => {
       return await this._triggerClient.sendEvent(event, options);
     });
@@ -1401,7 +1634,7 @@ var IO = class {
       return await this._triggerClient.getAuth(clientId);
     });
   }
-  async runTask(key, options, callback) {
+  async runTask(key, options, callback, onError) {
     const parentId = this._taskStorage.getStore()?.taskId;
     if (parentId) {
       this._logger.debug("Using parent task", {
@@ -1450,7 +1683,14 @@ var IO = class {
         idempotencyKey,
         task
       });
-      throw new ResumeWithTask(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 {
@@ -1464,6 +1704,39 @@ var IO = class {
         });
         return result;
       } catch (error) {
+        if (isTriggerError(error)) {
+          throw error;
+        }
+        if (onError) {
+          const onErrorResult = onError(error, task, this);
+          if (onErrorResult) {
+            const parsedError2 = ErrorWithStackSchema.safeParse(onErrorResult.error);
+            throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
+              message: "Unknown error"
+            }, task, onErrorResult.retryAt);
+          }
+        }
+        const parsedError = ErrorWithStackSchema.safeParse(error);
+        if (options.retry) {
+          const retryAt = 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");
@@ -1471,6 +1744,16 @@ var IO = class {
       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();
@@ -1513,6 +1796,9 @@ 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);
   }
@@ -1559,7 +1845,7 @@ __name(EventTrigger, "EventTrigger");
 _options2 = new WeakMap();
 function eventTrigger(options) {
   return new EventTrigger({
-    name: "Event Trigger",
+    name: options.name,
     filter: options.filter,
     event: {
       name: options.name,
@@ -1585,7 +1871,7 @@ var registerSourceEvent = {
   icon: "register-source",
   parsePayload: RegisterSourceEventSchema.parse
 };
-var _options3, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _client, _logger2, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn;
+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);
@@ -1601,36 +1887,54 @@ var TriggerClient = class {
     __privateAdd(this, _jobMetadataByDynamicTriggers, {});
     __privateAdd(this, _registeredSchedules, {});
     __privateAdd(this, _client, void 0);
-    __privateAdd(this, _logger2, void 0);
+    __privateAdd(this, _internalLogger, void 0);
     this.id = options.id;
-    this._url = buildClientUrl(options.url);
     __privateSet(this, _options3, options);
     __privateSet(this, _client, new ApiClient(__privateGet(this, _options3)));
-    __privateSet(this, _logger2, new Logger("trigger.dev", __privateGet(this, _options3).logLevel));
-  }
-  get url() {
-    return `${this._url}${this.path ? `${this.path.startsWith("/") ? "" : "/"}${this.path}` : ""}`;
+    __privateSet(this, _internalLogger, new Logger("trigger.dev", __privateGet(this, _options3).verbose ? "debug" : "log"));
   }
   async handleRequest(request) {
-    __privateGet(this, _logger2).debug("handling 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");
-    if (!this.authorized(apiKey)) {
-      return {
-        status: 401,
-        body: {
-          message: "Unauthorized"
-        }
-      };
+    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: Expected ${__privateGet(this, _options3).apiKey}, got ${apiKey}`
+          }
+        };
+      }
     }
     if (request.method !== "POST") {
       return {
         status: 405,
         body: {
-          message: "Method not allowed"
+          message: "Method not allowed (only POST is allowed)"
         }
       };
     }
@@ -1645,14 +1949,33 @@ var TriggerClient = class {
     }
     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: {
-            message: "PONG"
+            ok: true
           }
         };
       }
-      case "GET_ENDPOINT_DATA": {
+      case "INDEX_ENDPOINT": {
         const jobId = request.headers.get("x-trigger-job-id");
         if (jobId) {
           const job = __privateGet(this, _registeredJobs)[jobId];
@@ -1686,15 +2009,6 @@ var TriggerClient = class {
           body
         };
       }
-      case "INITIALIZE": {
-        await this.listen();
-        return {
-          status: 200,
-          body: {
-            message: "Initialized"
-          }
-        };
-      }
       case "INITIALIZE_TRIGGER": {
         const json = await request.json();
         const body = InitializeTriggerBodySchema.safeParse(json);
@@ -1741,20 +2055,9 @@ var TriggerClient = class {
           };
         }
         const results = await __privateMethod(this, _executeJob, executeJob_fn).call(this, execution.data, job);
-        if (results.error) {
-          return {
-            status: 500,
-            body: results.error
-          };
-        }
         return {
           status: 200,
-          body: {
-            completed: results.completed,
-            output: results.output,
-            executionId: execution.data.run.id,
-            task: results.task
-          }
+          body: results
         };
       }
       case "PREPROCESS_RUN": {
@@ -1877,7 +2180,7 @@ var TriggerClient = class {
   }
   attachSource(options) {
     __privateGet(this, _registeredHttpSourceHandlers)[options.key] = async (s, r) => {
-      return await options.source.handle(s, r, __privateGet(this, _logger2));
+      return await options.source.handle(s, r, __privateGet(this, _internalLogger));
     };
     let registeredSource = __privateGet(this, _registeredSources)[options.key];
     if (!registeredSource) {
@@ -1886,7 +2189,11 @@ var TriggerClient = class {
         key: options.key,
         params: options.params,
         events: [],
-        clientId: !options.source.integration.usesLocalAuth ? options.source.integration.id : void 0
+        integration: {
+          id: options.source.integration.id,
+          metadata: options.source.integration.metadata,
+          authSource: options.source.integration.client.usesLocalAuth ? "LOCAL" : "HOSTED"
+        }
       };
     }
     registeredSource.events = Array.from(/* @__PURE__ */ new Set([
@@ -1953,21 +2260,18 @@ var TriggerClient = class {
     return __privateGet(this, _client).unregisterSchedule(this.id, id, key);
   }
   authorized(apiKey) {
+    if (typeof apiKey !== "string") {
+      return "missing-header";
+    }
     const localApiKey = __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
     if (!localApiKey) {
-      return false;
+      return "missing-client";
     }
-    return apiKey === localApiKey;
+    return apiKey === localApiKey ? "authorized" : "unauthorized";
   }
   apiKey() {
     return __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
   }
-  async listen() {
-    await __privateGet(this, _client).registerEndpoint({
-      url: this.url,
-      name: this.id
-    });
-  }
 };
 __name(TriggerClient, "TriggerClient");
 _options3 = new WeakMap();
@@ -1978,7 +2282,7 @@ _registeredDynamicTriggers = new WeakMap();
 _jobMetadataByDynamicTriggers = new WeakMap();
 _registeredSchedules = new WeakMap();
 _client = new WeakMap();
-_logger2 = 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);
@@ -1991,7 +2295,7 @@ preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
 }, "#preprocessRun");
 _executeJob = new WeakSet();
 executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
-  __privateGet(this, _logger2).debug("executing job", {
+  __privateGet(this, _internalLogger).debug("executing job", {
     execution: body1,
     job: job1.toJSON()
   });
@@ -2000,40 +2304,60 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
     id: body1.run.id,
     cachedTasks: body1.tasks,
     apiClient: __privateGet(this, _client),
-    logger: __privateGet(this, _logger2),
+    logger: __privateGet(this, _internalLogger),
     client: this,
-    context
+    context,
+    jobLogLevel: job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info",
+    jobLogger: __privateGet(this, _options3).ioLogLocalEnabled ? new 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 {
-      completed: true,
+      status: "SUCCESS",
       output
     };
   } catch (error) {
-    if (error instanceof ResumeWithTask) {
+    if (error instanceof ResumeWithTaskError) {
       return {
-        completed: false,
+        status: "RESUME_WITH_TASK",
         task: error.task
       };
     }
-    const errorWithStack = ErrorWithStackSchema.safeParse(error);
-    if (errorWithStack.success) {
+    if (error instanceof RetryWithTaskError) {
       return {
-        completed: true,
-        error: errorWithStack.data
+        status: "RETRY_WITH_TASK",
+        task: error.task,
+        error: error.cause,
+        retryAt: error.retryAt
       };
     }
-    const errorWithMessage = ErrorWithMessage.safeParse(error);
-    if (errorWithMessage.success) {
+    if (error instanceof RetryWithTaskError) {
+      const errorWithStack2 = ErrorWithStackSchema.safeParse(error.cause);
+      if (errorWithStack2.success) {
+        return {
+          status: "ERROR",
+          error: errorWithStack2.data,
+          task: error.task
+        };
+      }
       return {
-        completed: true,
-        error: errorWithMessage.data
+        status: "ERROR",
+        error: {
+          message: "Unknown error"
+        },
+        task: error.task
+      };
+    }
+    const errorWithStack = ErrorWithStackSchema.safeParse(error);
+    if (errorWithStack.success) {
+      return {
+        status: "ERROR",
+        error: errorWithStack.data
       };
     }
     return {
-      completed: true,
+      status: "ERROR",
       error: {
         message: "Unknown error"
       }
@@ -2042,7 +2366,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
 }, "#executeJob");
 _createRunContext = new WeakSet();
 createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
-  const { event, organization, environment, job, run } = execution;
+  const { event, organization, environment, job, run, source } = execution;
   return {
     event: {
       id: event.id,
@@ -2054,7 +2378,8 @@ createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
     environment,
     job,
     run,
-    account: execution.account
+    account: execution.account,
+    source
   };
 }, "#createRunContext");
 _createPreprocessRunContext = new WeakSet();
@@ -2076,13 +2401,13 @@ createPreprocessRunContext_fn = /* @__PURE__ */ __name(function(body2) {
 }, "#createPreprocessRunContext");
 _handleHttpSourceRequest = new WeakSet();
 handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourceRequest) {
-  __privateGet(this, _logger2).debug("Handling HTTP source request", {
+  __privateGet(this, _internalLogger).debug("Handling HTTP source request", {
     source
   });
   if (source.dynamicId) {
     const dynamicTrigger = __privateGet(this, _registeredDynamicTriggers)[source.dynamicId];
     if (!dynamicTrigger) {
-      __privateGet(this, _logger2).debug("No dynamic trigger registered for HTTP source", {
+      __privateGet(this, _internalLogger).debug("No dynamic trigger registered for HTTP source", {
         source
       });
       return {
@@ -2095,7 +2420,7 @@ handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourc
         events: []
       };
     }
-    const results2 = await dynamicTrigger.source.handle(source, sourceRequest, __privateGet(this, _logger2));
+    const results2 = await dynamicTrigger.source.handle(source, sourceRequest, __privateGet(this, _internalLogger));
     if (!results2) {
       return {
         events: [],
@@ -2119,7 +2444,7 @@ handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourc
   }
   const handler = __privateGet(this, _registeredHttpSourceHandlers)[source.key];
   if (!handler) {
-    __privateGet(this, _logger2).debug("No handler registered for HTTP source", {
+    __privateGet(this, _internalLogger).debug("No handler registered for HTTP source", {
       source
     });
     return {
@@ -2154,20 +2479,6 @@ handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourc
     }
   };
 }, "#handleHttpSourceRequest");
-function buildClientUrl(url) {
-  if (!url) {
-    const host = process.env.TRIGGER_CLIENT_HOST ?? process.env.HOST ?? process.env.HOSTNAME ?? process.env.NOW_URL ?? process.env.VERCEL_URL;
-    if (host) {
-      return "https://" + host;
-    }
-    throw new Error("Could not determine the url for this TriggerClient. Please set the TRIGGER_CLIENT_HOST environment variable or pass in the `url` option to the TriggerClient constructor.");
-  }
-  if (!url.startsWith("http")) {
-    return "https://" + url;
-  }
-  return url;
-}
-__name(buildClientUrl, "buildClientUrl");
 
 // src/integrations.ts
 function authenticatedTask(options) {
@@ -2319,7 +2630,11 @@ var DynamicTrigger = class {
         events: [
           this.event.name
         ],
-        clientId: !this.source.integration.usesLocalAuth ? this.source.integration.id : void 0
+        integration: {
+          id: this.source.integration.id,
+          metadata: this.source.integration.metadata,
+          authSource: this.source.integration.client.usesLocalAuth ? "LOCAL" : "HOSTED"
+        }
       }
     };
   }
@@ -2330,7 +2645,7 @@ var DynamicTrigger = class {
     triggerClient.attachJobToDynamicTrigger(job, this);
   }
   get preprocessRuns() {
-    return false;
+    return true;
   }
 };
 __name(DynamicTrigger, "DynamicTrigger");
@@ -2338,6 +2653,18 @@ _client2 = new WeakMap();
 _options4 = new WeakMap();
 
 // src/triggers/scheduled.ts
+var import_cronstrue = __toESM(require("cronstrue"));
+var examples = [
+  {
+    id: "now",
+    name: "Now",
+    icon: "clock",
+    payload: {
+      ts: currentDate.marker,
+      lastTimestamp: currentDate.marker
+    }
+  }
+];
 var IntervalTrigger = class {
   constructor(options) {
     this.options = options;
@@ -2348,6 +2675,7 @@ var IntervalTrigger = class {
       title: "Schedule",
       source: "trigger.dev",
       icon: "schedule-interval",
+      examples,
       parsePayload: ScheduledPayloadSchema.parse,
       properties: [
         {
@@ -2384,16 +2712,24 @@ var CronTrigger = class {
     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: ScheduledPayloadSchema.parse,
       properties: [
         {
-          label: "Expression",
+          label: "cron",
           text: this.options.cron
+        },
+        {
+          label: "Schedule",
+          text: humanReadable
         }
       ]
     };
@@ -2434,6 +2770,7 @@ var DynamicSchedule = class {
       title: "Dynamic Schedule",
       source: "trigger.dev",
       icon: "schedule-dynamic",
+      examples,
       parsePayload: ScheduledPayloadSchema.parse
     };
   }
@@ -2555,14 +2892,14 @@ var MissingConnectionResolvedNotification = class {
 __name(MissingConnectionResolvedNotification, "MissingConnectionResolvedNotification");
 
 // src/index.ts
-function secureString(strings, ...interpolations) {
+function redactString(strings, ...interpolations) {
   return {
-    __secureString: true,
+    __redactedString: true,
     strings: strings.raw,
     interpolations
   };
 }
-__name(secureString, "secureString");
+__name(redactString, "redactString");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CronTrigger,
@@ -2577,15 +2914,15 @@ __name(secureString, "secureString");
   Job,
   MissingConnectionNotification,
   MissingConnectionResolvedNotification,
-  ResumeWithTask,
   TriggerClient,
   authenticatedTask,
   cronTrigger,
   eventTrigger,
   intervalTrigger,
+  isTriggerError,
   missingConnectionNotification,
   missingConnectionResolvedNotification,
   omit,
-  secureString
+  redactString
 });
 //# sourceMappingURL=index.js.map