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

package/dist/index.js

@@ -1,14 +1,12 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -18,10 +16,6 @@ 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))
@@ -49,849 +43,174 @@ var __privateMethod = (obj, member, method) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  Trigger: () => Trigger,
-  customEvent: () => customEvent,
-  fetch: () => fetch2,
-  getTriggerRun: () => getTriggerRun,
-  scheduleEvent: () => scheduleEvent,
-  secureString: () => secureString,
-  sendEvent: () => sendEvent,
-  webhookEvent: () => webhookEvent
+  CronTrigger: () => CronTrigger,
+  DynamicSchedule: () => DynamicSchedule,
+  DynamicTrigger: () => DynamicTrigger,
+  EventTrigger: () => EventTrigger,
+  ExternalSource: () => ExternalSource,
+  ExternalSourceTrigger: () => ExternalSourceTrigger,
+  IO: () => IO,
+  IOLogger: () => IOLogger,
+  IntervalTrigger: () => IntervalTrigger,
+  Job: () => Job,
+  MissingConnectionNotification: () => MissingConnectionNotification,
+  MissingConnectionResolvedNotification: () => MissingConnectionResolvedNotification,
+  ResumeWithTask: () => ResumeWithTask,
+  TriggerClient: () => TriggerClient,
+  authenticatedTask: () => authenticatedTask,
+  cronTrigger: () => cronTrigger,
+  eventTrigger: () => eventTrigger,
+  intervalTrigger: () => intervalTrigger,
+  missingConnectionNotification: () => missingConnectionNotification,
+  missingConnectionResolvedNotification: () => missingConnectionResolvedNotification,
+  omit: () => omit,
+  secureString: () => secureString
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../common-schemas/src/json.ts
-var import_zod = require("zod");
-var LiteralSchema = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.number(),
-  import_zod.z.boolean(),
-  import_zod.z.null()
-]);
-var JsonSchema = import_zod.z.lazy(() => import_zod.z.union([
-  LiteralSchema,
-  import_zod.z.array(JsonSchema),
-  import_zod.z.record(JsonSchema)
-]));
-var SerializableSchema = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.number(),
-  import_zod.z.boolean(),
-  import_zod.z.null(),
-  import_zod.z.date(),
-  import_zod.z.undefined()
-]);
-var SerializableJsonSchema = import_zod.z.lazy(() => import_zod.z.union([
-  SerializableSchema,
-  import_zod.z.array(SerializableJsonSchema),
-  import_zod.z.record(SerializableJsonSchema)
-]));
-
-// ../common-schemas/src/error.ts
-var import_zod2 = require("zod");
-var ErrorSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  message: import_zod2.z.string(),
-  stackTrace: import_zod2.z.string().optional()
-});
-
-// ../common-schemas/src/logs.ts
-var import_zod3 = require("zod");
-var LogMessageSchema = import_zod3.z.object({
-  level: import_zod3.z.enum([
-    "DEBUG",
-    "INFO",
-    "WARN",
-    "ERROR"
-  ]),
-  message: import_zod3.z.string(),
-  properties: JsonSchema.default({})
-});
-
-// ../common-schemas/src/waits.ts
-var import_zod4 = require("zod");
-var DelaySchema = import_zod4.z.object({
-  type: import_zod4.z.literal("DELAY"),
-  seconds: import_zod4.z.number().optional(),
-  minutes: import_zod4.z.number().optional(),
-  hours: import_zod4.z.number().optional(),
-  days: import_zod4.z.number().optional()
-});
-var ScheduledForSchema = import_zod4.z.object({
-  type: import_zod4.z.literal("SCHEDULE_FOR"),
-  scheduledFor: import_zod4.z.string().datetime()
-});
-var WaitSchema = import_zod4.z.discriminatedUnion("type", [
-  DelaySchema,
-  ScheduledForSchema
-]);
-
-// ../common-schemas/src/events.ts
-var import_zod5 = require("zod");
-var CustomEventSchema = import_zod5.z.object({
-  name: import_zod5.z.string(),
-  payload: JsonSchema,
-  context: JsonSchema.optional(),
-  timestamp: import_zod5.z.string().datetime().optional(),
-  delay: import_zod5.z.union([
-    import_zod5.z.object({
-      seconds: import_zod5.z.number().int()
-    }),
-    import_zod5.z.object({
-      minutes: import_zod5.z.number().int()
-    }),
-    import_zod5.z.object({
-      hours: import_zod5.z.number().int()
-    }),
-    import_zod5.z.object({
-      days: import_zod5.z.number().int()
-    }),
-    import_zod5.z.object({
-      until: import_zod5.z.string().datetime()
-    })
-  ]).optional()
-});
-var SerializableCustomEventSchema = import_zod5.z.object({
-  name: import_zod5.z.string(),
-  payload: SerializableJsonSchema,
-  context: SerializableJsonSchema.optional(),
-  timestamp: import_zod5.z.string().datetime().optional(),
-  delay: import_zod5.z.union([
-    import_zod5.z.object({
-      seconds: import_zod5.z.number().int()
-    }),
-    import_zod5.z.object({
-      minutes: import_zod5.z.number().int()
-    }),
-    import_zod5.z.object({
-      hours: import_zod5.z.number().int()
-    }),
-    import_zod5.z.object({
-      days: import_zod5.z.number().int()
-    }),
-    import_zod5.z.object({
-      until: import_zod5.z.date()
-    })
-  ]).optional()
-});
-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 ScheduledEventPayloadSchema = import_zod5.z.object({
-  lastRunAt: import_zod5.z.coerce.date().optional(),
-  scheduledTime: import_zod5.z.coerce.date()
-});
-var ScheduleSourceRateSchema = import_zod5.z.object({
-  rateOf: import_zod5.z.union([
-    import_zod5.z.object({
-      minutes: import_zod5.z.number().min(1).max(1440).int()
-    }),
-    import_zod5.z.object({
-      hours: import_zod5.z.number().min(1).max(720).int()
-    }),
-    import_zod5.z.object({
-      days: import_zod5.z.number().min(1).max(365).int()
-    })
-  ])
-});
-var ScheduleSourceCronSchema = import_zod5.z.object({
-  cron: import_zod5.z.string()
-});
-var ScheduleSourceSchema = import_zod5.z.union([
-  ScheduleSourceRateSchema,
-  ScheduleSourceCronSchema
-]);
-var ManualWebhookSourceSchema = import_zod5.z.object({
-  verifyPayload: import_zod5.z.object({
-    enabled: import_zod5.z.boolean(),
-    header: import_zod5.z.string().optional()
-  }),
-  event: import_zod5.z.string()
-});
-var SlackBlockInteractionSourceSchema = import_zod5.z.object({
-  type: import_zod5.z.literal("block_action"),
-  blockId: import_zod5.z.string(),
-  actionIds: import_zod5.z.array(import_zod5.z.string())
-});
-var SlackViewSubmissionInteractionSourceSchema = import_zod5.z.object({
-  type: import_zod5.z.literal("view_submission"),
-  callbackIds: import_zod5.z.array(import_zod5.z.string())
-});
-var SlackInteractionSourceSchema = import_zod5.z.discriminatedUnion("type", [
-  SlackBlockInteractionSourceSchema,
-  SlackViewSubmissionInteractionSourceSchema
-]);
-
-// ../common-schemas/src/triggers.ts
-var import_zod6 = require("zod");
-var CustomEventTriggerSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("CUSTOM_EVENT"),
-  service: import_zod6.z.literal("trigger"),
-  name: import_zod6.z.string(),
-  filter: EventFilterSchema,
-  schema: JsonSchema.optional()
-});
-var WebhookEventTriggerSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("WEBHOOK"),
-  service: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  filter: EventFilterSchema,
-  source: JsonSchema.optional(),
-  manualRegistration: import_zod6.z.boolean().default(false),
-  schema: JsonSchema.optional()
-});
-var HttpEventTriggerSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("HTTP_ENDPOINT"),
-  service: import_zod6.z.literal("trigger"),
-  name: import_zod6.z.string(),
-  filter: EventFilterSchema
-});
-var ScheduledEventTriggerSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("SCHEDULE"),
-  service: import_zod6.z.literal("scheduler"),
-  name: import_zod6.z.string(),
-  source: ScheduleSourceSchema
-});
-var SlackInteractionTriggerSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("SLACK_INTERACTION"),
-  service: import_zod6.z.literal("slack"),
-  name: import_zod6.z.string(),
-  filter: EventFilterSchema,
-  source: SlackInteractionSourceSchema
-});
-var TriggerMetadataSchema = import_zod6.z.discriminatedUnion("type", [
-  CustomEventTriggerSchema,
-  WebhookEventTriggerSchema,
-  HttpEventTriggerSchema,
-  ScheduledEventTriggerSchema,
-  SlackInteractionTriggerSchema
-]);
-
-// ../common-schemas/src/fetch.ts
-var import_zod7 = require("zod");
-var SecureStringSchema = import_zod7.z.object({
-  __secureString: import_zod7.z.literal(true),
-  strings: import_zod7.z.array(import_zod7.z.string()),
-  interpolations: import_zod7.z.array(import_zod7.z.string())
-});
-var RetrySchema = import_zod7.z.object({
-  enabled: import_zod7.z.boolean().default(true),
-  factor: import_zod7.z.number().default(1.8),
-  maxTimeout: import_zod7.z.number().default(6e4),
-  minTimeout: import_zod7.z.number().default(1e3),
-  maxAttempts: import_zod7.z.number().default(10),
-  statusCodes: import_zod7.z.array(import_zod7.z.number()).default([
-    408,
-    429,
-    500,
-    502,
-    503,
-    504
-  ])
-});
-var FetchRequestSchema = import_zod7.z.object({
-  url: import_zod7.z.string(),
-  headers: import_zod7.z.record(import_zod7.z.union([
-    import_zod7.z.string(),
-    SecureStringSchema
-  ])).optional(),
-  method: import_zod7.z.enum([
-    "GET",
-    "POST",
-    "PUT",
-    "DELETE",
-    "PATCH",
-    "HEAD",
-    "OPTIONS",
-    "TRACE"
-  ]),
-  body: import_zod7.z.any(),
-  retry: RetrySchema.optional()
-});
-var FetchOutputSchema = import_zod7.z.object({
-  status: import_zod7.z.number(),
-  ok: import_zod7.z.boolean(),
-  headers: import_zod7.z.record(import_zod7.z.string()),
-  body: import_zod7.z.any().optional()
-});
-var FetchResponseSchema = import_zod7.z.object({
-  status: import_zod7.z.number(),
-  headers: import_zod7.z.record(import_zod7.z.string()),
-  body: import_zod7.z.any().optional()
-});
-
-// ../common-schemas/src/runOnce.ts
-var import_zod8 = require("zod");
-var InitializeRunOnceSchema = import_zod8.z.object({
-  type: import_zod8.z.enum([
-    "REMOTE",
-    "LOCAL_ONLY"
-  ])
-});
-var CompleteRunOnceSchema = import_zod8.z.object({
-  type: import_zod8.z.enum([
-    "REMOTE",
-    "LOCAL_ONLY"
-  ]),
-  idempotencyKey: import_zod8.z.string(),
-  output: import_zod8.z.string().optional()
-});
-var ResolveRunOnceOuputSchema = import_zod8.z.object({
-  idempotencyKey: import_zod8.z.string(),
-  hasRun: import_zod8.z.boolean(),
-  output: SerializableJsonSchema.optional()
-});
-
-// ../common-schemas/src/kv.ts
-var import_zod9 = require("zod");
-var KVGetSchema = import_zod9.z.object({
-  key: import_zod9.z.string(),
-  namespace: import_zod9.z.string()
-});
-var KVDeleteSchema = import_zod9.z.object({
-  key: import_zod9.z.string(),
-  namespace: import_zod9.z.string()
-});
-var KVSetSchema = import_zod9.z.object({
-  key: import_zod9.z.string(),
-  namespace: import_zod9.z.string(),
-  value: SerializableJsonSchema
-});
-
-// src/events.ts
-var import_zod10 = require("zod");
-var import_slug = __toESM(require("slug"));
-var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
-function customEvent(options) {
-  const schema = options.schema ?? import_zod10.z.any();
-  return {
-    metadata: {
-      type: "CUSTOM_EVENT",
-      service: "trigger",
-      name: options.name,
-      filter: {
-        event: [
-          options.name
-        ],
-        payload: options.filter ?? {}
-      },
-      schema: (0, import_zod_to_json_schema.default)(schema)
-    },
-    schema
-  };
-}
-__name(customEvent, "customEvent");
-function scheduleEvent(options) {
-  return {
-    metadata: {
-      type: "SCHEDULE",
-      service: "scheduler",
-      name: "scheduled-event",
-      source: options
-    },
-    schema: ScheduledEventPayloadSchema
-  };
-}
-__name(scheduleEvent, "scheduleEvent");
-function webhookEvent(options) {
-  const schema = options.schema ?? import_zod10.z.any();
-  return {
-    metadata: {
-      type: "WEBHOOK",
-      service: (0, import_slug.default)(options.service),
-      name: options.eventName,
-      filter: {
-        service: [
-          (0, import_slug.default)(options.service)
-        ],
-        payload: options.filter ?? {},
-        event: [
-          options.eventName
-        ]
-      },
-      source: {
-        verifyPayload: options.verifyPayload ?? {
-          enabled: false
-        },
-        event: options.eventName
-      },
-      manualRegistration: true,
-      schema: (0, import_zod_to_json_schema.default)(schema)
-    },
-    schema
-  };
+// src/utils.ts
+function slugifyId(input) {
+  const replaceSpacesWithDash = input.toLowerCase().replace(/\s+/g, "-");
+  const removeNonUrlSafeChars = replaceSpacesWithDash.replace(/[^a-zA-Z0-9-._~]/g, "");
+  return removeNonUrlSafeChars;
 }
-__name(webhookEvent, "webhookEvent");
+__name(slugifyId, "slugifyId");
 
-// ../internal-bridge/src/schemas/host.ts
-var import_zod11 = require("zod");
-var HostRPCSchema = {
-  TRIGGER_WORKFLOW: {
-    request: import_zod11.z.object({
-      id: import_zod11.z.string(),
-      trigger: import_zod11.z.object({
-        input: JsonSchema.default({}),
-        context: JsonSchema.default({})
-      }),
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        isTest: import_zod11.z.boolean().default(false),
-        appOrigin: import_zod11.z.string(),
-        attempt: import_zod11.z.number().optional()
-      })
-    }),
-    response: import_zod11.z.boolean()
-  },
-  RESOLVE_REQUEST: {
-    request: import_zod11.z.object({
-      id: import_zod11.z.string(),
-      key: import_zod11.z.string(),
-      output: JsonSchema.default({}),
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        runId: import_zod11.z.string()
-      })
-    }),
-    response: import_zod11.z.boolean()
-  },
-  RESOLVE_DELAY: {
-    request: import_zod11.z.object({
-      id: import_zod11.z.string(),
-      key: import_zod11.z.string(),
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        runId: import_zod11.z.string()
-      })
-    }),
-    response: import_zod11.z.boolean()
-  },
-  REJECT_REQUEST: {
-    request: import_zod11.z.object({
-      id: import_zod11.z.string(),
-      key: import_zod11.z.string(),
-      error: JsonSchema.default({}),
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        runId: import_zod11.z.string()
-      })
-    }),
-    response: import_zod11.z.boolean()
-  },
-  RESOLVE_FETCH_REQUEST: {
-    request: import_zod11.z.object({
-      id: import_zod11.z.string(),
-      key: import_zod11.z.string(),
-      output: FetchOutputSchema,
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        runId: import_zod11.z.string()
-      })
-    }),
-    response: import_zod11.z.boolean()
-  },
-  REJECT_FETCH_REQUEST: {
-    request: import_zod11.z.object({
-      id: import_zod11.z.string(),
-      key: import_zod11.z.string(),
-      error: JsonSchema.default({}),
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        runId: import_zod11.z.string()
-      })
-    }),
-    response: import_zod11.z.boolean()
-  },
-  RESOLVE_RUN_ONCE: {
-    request: import_zod11.z.object({
-      id: import_zod11.z.string(),
-      key: import_zod11.z.string(),
-      output: ResolveRunOnceOuputSchema,
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        runId: import_zod11.z.string()
-      })
-    }),
-    response: import_zod11.z.boolean()
-  },
-  RESOLVE_KV_GET: {
-    request: import_zod11.z.object({
-      key: import_zod11.z.string(),
-      output: SerializableJsonSchema,
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        runId: import_zod11.z.string()
-      })
-    }),
-    response: import_zod11.z.boolean()
-  },
-  RESOLVE_KV_SET: {
-    request: import_zod11.z.object({
-      key: import_zod11.z.string(),
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        runId: import_zod11.z.string()
-      })
-    }),
-    response: import_zod11.z.boolean()
-  },
-  RESOLVE_KV_DELETE: {
-    request: import_zod11.z.object({
-      key: import_zod11.z.string(),
-      meta: import_zod11.z.object({
-        environment: import_zod11.z.string(),
-        workflowId: import_zod11.z.string(),
-        organizationId: import_zod11.z.string(),
-        apiKey: import_zod11.z.string(),
-        runId: import_zod11.z.string()
-      })
-    }),
-    response: import_zod11.z.boolean()
+// src/job.ts
+var _validate, validate_fn;
+var Job = class {
+  constructor(client, options) {
+    __privateAdd(this, _validate);
+    this.client = client;
+    this.options = options;
+    __privateMethod(this, _validate, validate_fn).call(this);
+    client.attach(this);
   }
-};
-
-// ../internal-bridge/src/schemas/server.ts
-var import_zod12 = require("zod");
-var ServerRPCSchema = {
-  INITIALIZE_DELAY: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      wait: WaitSchema,
-      timestamp: import_zod12.z.string()
-    }),
-    response: import_zod12.z.boolean()
-  },
-  SEND_REQUEST: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      request: import_zod12.z.object({
-        service: import_zod12.z.string(),
-        endpoint: import_zod12.z.string(),
-        params: import_zod12.z.any(),
-        version: import_zod12.z.string().optional()
-      }),
-      timestamp: import_zod12.z.string()
-    }),
-    response: import_zod12.z.boolean()
-  },
-  SEND_FETCH: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      fetch: FetchRequestSchema,
-      timestamp: import_zod12.z.string()
-    }),
-    response: import_zod12.z.boolean()
-  },
-  SEND_LOG: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      log: import_zod12.z.object({
-        message: import_zod12.z.string(),
-        level: import_zod12.z.enum([
-          "DEBUG",
-          "INFO",
-          "WARN",
-          "ERROR"
-        ]),
-        properties: import_zod12.z.string().optional()
-      }),
-      timestamp: import_zod12.z.string()
-    }),
-    response: import_zod12.z.boolean()
-  },
-  SEND_EVENT: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      event: CustomEventSchema,
-      timestamp: import_zod12.z.string()
-    }),
-    response: import_zod12.z.boolean()
-  },
-  INITIALIZE_HOST: {
-    request: import_zod12.z.object({
-      apiKey: import_zod12.z.string(),
-      workflowId: import_zod12.z.string(),
-      workflowName: import_zod12.z.string(),
-      trigger: TriggerMetadataSchema,
-      packageVersion: import_zod12.z.string(),
-      packageName: import_zod12.z.string(),
-      triggerTTL: import_zod12.z.number().optional()
-    }),
-    response: import_zod12.z.discriminatedUnion("type", [
-      import_zod12.z.object({
-        type: import_zod12.z.literal("success")
-      }),
-      import_zod12.z.object({
-        type: import_zod12.z.literal("error"),
-        message: import_zod12.z.string()
-      })
-    ]).nullable()
-  },
-  INITIALIZE_HOST_V2: {
-    request: import_zod12.z.object({
-      apiKey: import_zod12.z.string(),
-      workflowId: import_zod12.z.string(),
-      workflowName: import_zod12.z.string(),
-      trigger: TriggerMetadataSchema,
-      packageVersion: import_zod12.z.string(),
-      packageName: import_zod12.z.string(),
-      triggerTTL: import_zod12.z.number().optional(),
-      metadata: SerializableJsonSchema.optional()
-    }),
-    response: import_zod12.z.discriminatedUnion("type", [
-      import_zod12.z.object({
-        type: import_zod12.z.literal("success"),
-        data: import_zod12.z.object({
-          workflow: import_zod12.z.object({
-            id: import_zod12.z.string(),
-            slug: import_zod12.z.string()
-          }),
-          environment: import_zod12.z.object({
-            id: import_zod12.z.string(),
-            slug: import_zod12.z.string()
-          }),
-          organization: import_zod12.z.object({
-            id: import_zod12.z.string(),
-            slug: import_zod12.z.string()
-          }),
-          isNew: import_zod12.z.boolean(),
-          url: import_zod12.z.string()
-        })
-      }),
-      import_zod12.z.object({
-        type: import_zod12.z.literal("error"),
-        message: import_zod12.z.string()
-      })
-    ]).nullable()
-  },
-  START_WORKFLOW_RUN: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      timestamp: import_zod12.z.string()
-    }),
-    response: import_zod12.z.boolean()
-  },
-  COMPLETE_WORKFLOW_RUN: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      output: import_zod12.z.string().optional(),
-      timestamp: import_zod12.z.string()
-    }),
-    response: import_zod12.z.boolean()
-  },
-  SEND_WORKFLOW_ERROR: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      error: import_zod12.z.object({
-        name: import_zod12.z.string(),
-        message: import_zod12.z.string(),
-        stackTrace: import_zod12.z.string().optional()
-      }),
-      timestamp: import_zod12.z.string()
-    }),
-    response: import_zod12.z.boolean()
-  },
-  INITIALIZE_RUN_ONCE: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      timestamp: import_zod12.z.string(),
-      runOnce: InitializeRunOnceSchema
-    }),
-    response: import_zod12.z.boolean()
-  },
-  COMPLETE_RUN_ONCE: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      timestamp: import_zod12.z.string(),
-      runOnce: CompleteRunOnceSchema
-    }),
-    response: import_zod12.z.boolean()
-  },
-  SEND_KV_GET: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      timestamp: import_zod12.z.string(),
-      get: import_zod12.z.object({
-        namespace: import_zod12.z.string(),
-        key: import_zod12.z.string()
-      })
-    }),
-    response: import_zod12.z.boolean()
-  },
-  SEND_KV_SET: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      timestamp: import_zod12.z.string(),
-      set: import_zod12.z.object({
-        namespace: import_zod12.z.string(),
-        key: import_zod12.z.string(),
-        value: SerializableJsonSchema
-      })
-    }),
-    response: import_zod12.z.boolean()
-  },
-  SEND_KV_DELETE: {
-    request: import_zod12.z.object({
-      runId: import_zod12.z.string(),
-      key: import_zod12.z.string(),
-      timestamp: import_zod12.z.string(),
-      delete: import_zod12.z.object({
-        namespace: import_zod12.z.string(),
-        key: import_zod12.z.string()
-      })
-    }),
-    response: import_zod12.z.boolean()
+  get id() {
+    return slugifyId(this.options.id);
+  }
+  get enabled() {
+    return typeof this.options.enabled === "boolean" ? this.options.enabled : true;
+  }
+  get name() {
+    return this.options.name;
+  }
+  get trigger() {
+    return this.options.trigger;
+  }
+  get version() {
+    return this.options.version;
+  }
+  get integrations() {
+    return Object.keys(this.options.integrations ?? {}).reduce((acc, key) => {
+      const integration = this.options.integrations[key];
+      if (!integration.client.usesLocalAuth) {
+        acc[key] = {
+          id: integration.id,
+          metadata: integration.metadata
+        };
+      }
+      return acc;
+    }, {});
+  }
+  toJSON() {
+    const internal = this.options.__internal;
+    return {
+      id: this.id,
+      name: this.name,
+      version: this.version,
+      event: this.trigger.event,
+      trigger: this.trigger.toJSON(),
+      integrations: this.integrations,
+      queue: this.options.queue,
+      startPosition: this.options.startPosition ?? "latest",
+      enabled: typeof this.options.enabled === "boolean" ? this.options.enabled : true,
+      preprocessRuns: this.trigger.preprocessRuns,
+      internal
+    };
   }
 };
+__name(Job, "Job");
+_validate = new WeakSet();
+validate_fn = /* @__PURE__ */ __name(function() {
+  if (!this.version.match(/^(\d+)\.(\d+)\.(\d+)$/)) {
+    throw new Error(`Invalid job version: "${this.version}". Job versions must be valid semver versions.`);
+  }
+}, "#validate");
 
-// ../internal-bridge/src/schemas/common.ts
-var import_zod13 = require("zod");
-var MESSAGE_META = import_zod13.z.object({
-  data: import_zod13.z.any(),
-  id: import_zod13.z.string(),
-  type: import_zod13.z.union([
-    import_zod13.z.literal("ACK"),
-    import_zod13.z.literal("MESSAGE")
-  ])
-});
-var TriggerEnvironmentSchema = import_zod13.z.enum([
-  "live",
-  "development"
-]);
-
-// ../internal-bridge/src/zodRPC.ts
-var import_zod14 = require("zod");
-var import_node_crypto = require("crypto");
-
-// ../internal-bridge/src/logger.ts
+// ../internal/src/logger.ts
 var logLevels = [
-  "disabled",
-  "error",
   "log",
+  "error",
   "warn",
   "info",
   "debug"
 ];
-var _name, _tags, _level, _formatName, formatName_fn, _formatTags, formatTags_fn;
-var Logger = class {
-  constructor(name2, level = "log") {
-    __privateAdd(this, _formatName);
-    __privateAdd(this, _formatTags);
+var _name, _level, _filteredKeys;
+var _Logger = class {
+  constructor(name, level = "info", filteredKeys = []) {
     __privateAdd(this, _name, void 0);
-    __privateAdd(this, _tags, void 0);
     __privateAdd(this, _level, void 0);
-    if (typeof name2 === "string") {
-      __privateSet(this, _name, name2);
-      __privateSet(this, _tags, []);
-    } else {
-      const [n, ...tags] = name2;
-      __privateSet(this, _name, n);
-      __privateSet(this, _tags, tags);
-    }
+    __privateAdd(this, _filteredKeys, []);
+    __privateSet(this, _name, name);
     __privateSet(this, _level, logLevels.indexOf(process.env.TRIGGER_LOG_LEVEL ?? level));
+    __privateSet(this, _filteredKeys, filteredKeys);
+  }
+  filter(...keys) {
+    return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys);
   }
   log(...args) {
-    if (__privateGet(this, _level) < 1)
+    if (__privateGet(this, _level) < 0)
       return;
-    console.log(`${__privateMethod(this, _formatName, formatName_fn).call(this)} `, ...[
-      ...args,
-      ...__privateMethod(this, _formatTags, formatTags_fn).call(this)
-    ]);
+    console.log(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
   }
-  logClean(...args) {
+  error(...args) {
     if (__privateGet(this, _level) < 1)
       return;
-    console.log(`${__privateMethod(this, _formatName, formatName_fn).call(this)} `, ...args);
+    console.error(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
   }
-  error(...args) {
+  warn(...args) {
     if (__privateGet(this, _level) < 2)
       return;
-    console.error(`[${formattedDateTime()}] ${__privateMethod(this, _formatName, formatName_fn).call(this)} `, ...[
-      ...args,
-      ...__privateMethod(this, _formatTags, formatTags_fn).call(this)
-    ]);
+    console.warn(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
   }
-  warn(...args) {
+  info(...args) {
     if (__privateGet(this, _level) < 3)
       return;
-    console.warn(`[${formattedDateTime()}] ${__privateMethod(this, _formatName, formatName_fn).call(this)} `, ...[
-      ...args,
-      ...__privateMethod(this, _formatTags, formatTags_fn).call(this)
-    ]);
+    console.info(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
   }
-  info(...args) {
+  debug(message, ...args) {
     if (__privateGet(this, _level) < 4)
       return;
-    console.info(`[${formattedDateTime()}] ${__privateMethod(this, _formatName, formatName_fn).call(this)} `, ...[
-      ...args,
-      ...__privateMethod(this, _formatTags, formatTags_fn).call(this)
-    ]);
-  }
-  debug(...args) {
-    if (__privateGet(this, _level) < 5)
-      return;
-    console.debug(`[${formattedDateTime()}] ${__privateMethod(this, _formatName, formatName_fn).call(this)} `, ...[
-      ...args,
-      ...__privateMethod(this, _formatTags, formatTags_fn).call(this)
-    ]);
+    const structuredLog = {
+      timestamp: new Date(),
+      name: __privateGet(this, _name),
+      message,
+      args: structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys))
+    };
+    console.debug(JSON.stringify(structuredLog, bigIntReplacer));
   }
 };
+var Logger = _Logger;
 __name(Logger, "Logger");
 _name = new WeakMap();
-_tags = new WeakMap();
 _level = new WeakMap();
-_formatName = new WeakSet();
-formatName_fn = /* @__PURE__ */ __name(function() {
-  if (Array.isArray(__privateGet(this, _name))) {
-    return __privateGet(this, _name).map((name2) => `[${name2}]`).join("");
-  }
-  return `[${__privateGet(this, _name)}]`;
-}, "#formatName");
-_formatTags = new WeakSet();
-formatTags_fn = /* @__PURE__ */ __name(function() {
-  return __privateGet(this, _tags).map((tag) => `[${tag}]`);
-}, "#formatTags");
+_filteredKeys = new WeakMap();
+function bigIntReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+__name(bigIntReplacer, "bigIntReplacer");
+function safeJsonClone(obj) {
+  try {
+    return JSON.parse(JSON.stringify(obj, bigIntReplacer));
+  } catch (e) {
+    return obj;
+  }
+}
+__name(safeJsonClone, "safeJsonClone");
 function formattedDateTime() {
   const date = new Date();
   const hours = date.getHours();
@@ -905,1287 +224,2337 @@ function formattedDateTime() {
   return `${formattedHours}:${formattedMinutes}:${formattedSeconds}.${formattedMilliseconds}`;
 }
 __name(formattedDateTime, "formattedDateTime");
-
-// ../internal-bridge/src/zodRPC.ts
-var RPCMessageSchema = import_zod14.z.object({
-  id: import_zod14.z.string(),
-  methodName: import_zod14.z.string(),
-  data: import_zod14.z.any(),
-  kind: import_zod14.z.enum([
-    "CALL",
-    "RESPONSE"
-  ])
-});
-var _connection, _sender, _receiver, _handlers, _pendingCalls, _logger, _onMessage, onMessage_fn, _onCall, onCall_fn, _onResponse, onResponse_fn, _handleCall, handleCall_fn, _handleResponse, handleResponse_fn;
-var ZodRPC = class {
-  constructor(options) {
-    __privateAdd(this, _onMessage);
-    __privateAdd(this, _onCall);
-    __privateAdd(this, _onResponse);
-    __privateAdd(this, _handleCall);
-    __privateAdd(this, _handleResponse);
-    __privateAdd(this, _connection, void 0);
-    __privateAdd(this, _sender, void 0);
-    __privateAdd(this, _receiver, void 0);
-    __privateAdd(this, _handlers, void 0);
-    __privateAdd(this, _pendingCalls, /* @__PURE__ */ new Map());
-    __privateAdd(this, _logger, new Logger("ZodRPC"));
-    __privateSet(this, _connection, options.connection);
-    __privateSet(this, _sender, options.sender);
-    __privateSet(this, _receiver, options.receiver);
-    __privateSet(this, _handlers, options.handlers);
-    __privateGet(this, _connection).onMessage.attach(__privateMethod(this, _onMessage, onMessage_fn).bind(this));
-  }
-  resetConnection(connection) {
-    __privateGet(this, _connection).onMessage.detach();
-    __privateSet(this, _connection, connection);
-    __privateGet(this, _connection).onMessage.attach(__privateMethod(this, _onMessage, onMessage_fn).bind(this));
-  }
-  send(key, data) {
-    __privateGet(this, _logger).debug("Sending call", {
-      key,
-      data
-    });
-    const id = generateStableId(__privateGet(this, _connection).id, key, data);
-    const message = packageMessage({
-      id,
-      methodName: key,
-      data
-    });
-    return new Promise((resolve, reject) => {
-      __privateGet(this, _pendingCalls).set(id, (rawResponseText) => {
-        try {
-          const parsed = __privateGet(this, _sender)[key]["response"].parse(rawResponseText);
-          return resolve(parsed);
-        } catch (err) {
-          reject(err);
-        }
-      });
-      __privateGet(this, _connection).send(message).catch((err) => reject(err));
-    });
+function structureArgs(args, filteredKeys = []) {
+  if (args.length === 0) {
+    return;
   }
-};
-__name(ZodRPC, "ZodRPC");
-_connection = new WeakMap();
-_sender = new WeakMap();
-_receiver = new WeakMap();
-_handlers = new WeakMap();
-_pendingCalls = new WeakMap();
-_logger = new WeakMap();
-_onMessage = new WeakSet();
-onMessage_fn = /* @__PURE__ */ __name(async function(rawData) {
-  try {
-    const data = RPCMessageSchema.parse(JSON.parse(rawData));
-    if (data.kind === "CALL") {
-      await __privateMethod(this, _onCall, onCall_fn).call(this, data);
-    }
-    if (data.kind === "RESPONSE") {
-      await __privateMethod(this, _onResponse, onResponse_fn).call(this, data);
-    }
-  } catch (err) {
-    __privateGet(this, _logger).error(err);
+  if (args.length === 1 && typeof args[0] === "object") {
+    return filterKeys(JSON.parse(JSON.stringify(args[0], bigIntReplacer)), filteredKeys);
   }
-}, "#onMessage");
-_onCall = new WeakSet();
-onCall_fn = /* @__PURE__ */ __name(async function(message) {
-  try {
-    await __privateMethod(this, _handleCall, handleCall_fn).call(this, message);
-  } catch (callError) {
-    if (callError instanceof import_zod14.ZodError) {
-      __privateGet(this, _logger).error(`[ZodRPC] Received invalid call:
-${JSON.stringify(message)}: `, callError.errors);
-    } else {
-      __privateGet(this, _logger).error(`[ZodRPC] Error handling call:
-${JSON.stringify(message)}: `, callError);
-    }
+  return args;
+}
+__name(structureArgs, "structureArgs");
+function filterKeys(obj, keys) {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
   }
-}, "#onCall");
-_onResponse = new WeakSet();
-onResponse_fn = /* @__PURE__ */ __name(async function(message1) {
-  try {
-    await __privateMethod(this, _handleResponse, handleResponse_fn).call(this, message1);
-  } catch (callError) {
-    if (callError instanceof import_zod14.ZodError) {
-      __privateGet(this, _logger).error(`[ZodRPC] Received invalid response
-
-${JSON.stringify(message1)}: `, callError.flatten());
-    } else {
-      __privateGet(this, _logger).error(`[ZodRPC] Error handling response
-
-${JSON.stringify(message1)}: `, callError);
+  if (Array.isArray(obj)) {
+    return obj.map((item) => filterKeys(item, keys));
+  }
+  const filteredObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (keys.includes(key)) {
+      continue;
     }
+    filteredObj[key] = filterKeys(value, keys);
   }
-}, "#onResponse");
-_handleCall = new WeakSet();
-handleCall_fn = /* @__PURE__ */ __name(async function(message2) {
-  const receiver = __privateGet(this, _receiver);
-  const methodName = message2.methodName;
-  const method = __privateGet(this, _receiver)[methodName];
-  if (!method) {
-    throw new Error(`There is no method for ${message2.methodName}`);
-  }
-  __privateGet(this, _logger).debug("Received call", {
-    message: message2
-  });
-  const inputs = method.request.parse(message2.data);
-  const handler = __privateGet(this, _handlers)[methodName];
-  const returnValue = await handler(inputs);
-  const preparedResponseText = packageResponse({
-    id: message2.id,
-    methodName,
-    data: returnValue
-  });
-  try {
-    await __privateGet(this, _connection).send(preparedResponseText);
-  } catch (err) {
-    __privateGet(this, _logger).error("Failed sending response", preparedResponseText, err);
-  }
-  return;
-}, "#handleCall");
-_handleResponse = new WeakSet();
-handleResponse_fn = /* @__PURE__ */ __name(async function(message3) {
-  const responseCallback = __privateGet(this, _pendingCalls).get(message3.id);
-  if (!responseCallback)
-    return;
-  responseCallback(message3.data);
-  __privateGet(this, _pendingCalls).delete(message3.id);
-}, "#handleResponse");
-function generateStableId(connId, reqKey, reqData) {
-  const serializedData = JSON.stringify(reqData);
-  const inputString = connId + reqKey + serializedData;
-  const hash = (0, import_node_crypto.createHash)("sha256").update(inputString).digest("hex");
-  return hash;
-}
-__name(generateStableId, "generateStableId");
-function packageMessage({ id, methodName, data }) {
-  const callerData = {
-    id,
-    kind: "CALL",
-    data,
-    methodName
-  };
-  return JSON.stringify(callerData);
-}
-__name(packageMessage, "packageMessage");
-function packageResponse({ id, methodName, data }) {
-  const preparedResponseText = {
-    id,
-    kind: "RESPONSE",
-    methodName,
-    data
-  };
-  return JSON.stringify(preparedResponseText);
+  return filteredObj;
 }
-__name(packageResponse, "packageResponse");
+__name(filterKeys, "filterKeys");
 
-// src/client.ts
-var import_uuid2 = require("uuid");
-var import_ws = require("ws");
-var import_zod15 = require("zod");
+// ../internal/src/schemas/api.ts
+var import_ulid = require("ulid");
+var import_zod8 = require("zod");
 
-// package.json
-var name = "@trigger.dev/sdk";
-var version = "0.2.22-next.0";
+// ../internal/src/schemas/integrations.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
+});
 
-// src/connection.ts
-var import_uuid = require("uuid");
-var import_evt = require("evt");
-var TimeoutError = class extends Error {
-};
-__name(TimeoutError, "TimeoutError");
-var NotConnectedError = class extends Error {
-};
-__name(NotConnectedError, "NotConnectedError");
-var _socket, _connectTimeout, _sendTimeout, _pingTimeout, _isAuthenticated, _timeouts, _isClosed, _pendingMessages, _logger2, _pingIntervalHandle, _pingIntervalMs, _closeUnresponsiveConnectionTimeoutMs, _startPingInterval, startPingInterval_fn, _ping, ping_fn;
-var HostConnection = class {
-  constructor(socket, options) {
-    __privateAdd(this, _startPingInterval);
-    __privateAdd(this, _ping);
-    __privateAdd(this, _socket, void 0);
-    __privateAdd(this, _connectTimeout, void 0);
-    __privateAdd(this, _sendTimeout, void 0);
-    __privateAdd(this, _pingTimeout, void 0);
-    __privateAdd(this, _isAuthenticated, false);
-    __privateAdd(this, _timeouts, void 0);
-    __privateAdd(this, _isClosed, false);
-    __privateAdd(this, _pendingMessages, /* @__PURE__ */ new Map());
-    __privateAdd(this, _logger2, void 0);
-    __privateAdd(this, _pingIntervalHandle, void 0);
-    __privateAdd(this, _pingIntervalMs, 3e4);
-    __privateAdd(this, _closeUnresponsiveConnectionTimeoutMs, 3 * 60 * 1e3);
-    __privateSet(this, _socket, socket);
-    this.id = options?.id ?? (0, import_uuid.v4)();
-    this.onMessage = new import_evt.Evt();
-    this.onAuthenticated = new import_evt.Evt();
-    this.onClose = new import_evt.Evt();
-    this.onOpen = new import_evt.Evt();
-    this.onError = new import_evt.Evt();
-    __privateSet(this, _connectTimeout, options?.connectTimeout ?? 5e3);
-    __privateSet(this, _sendTimeout, options?.sendTimeout ?? 5e3);
-    __privateSet(this, _pingTimeout, options?.pingTimeout ?? 5e3);
-    __privateSet(this, _timeouts, /* @__PURE__ */ new Set());
-    __privateSet(this, _logger2, new Logger("trigger.dev connection"));
-    this.onClose.attach(() => {
-      __privateSet(this, _isClosed, true);
-      if (__privateGet(this, _pingIntervalHandle)) {
-        clearInterval(__privateGet(this, _pingIntervalHandle));
-        __privateSet(this, _pingIntervalHandle, void 0);
-      }
-      for (const timeout of __privateGet(this, _timeouts)) {
-        clearTimeout(timeout);
-      }
-      __privateGet(this, _timeouts).clear();
-    });
-    __privateGet(this, _socket).onopen = () => {
-      __privateSet(this, _isClosed, false);
-      this.onOpen.post();
-      __privateMethod(this, _startPingInterval, startPingInterval_fn).call(this);
-    };
-    __privateGet(this, _socket).onclose = (ev) => {
-      this.onClose.post([
-        ev.code,
-        ev.reason
-      ]);
-    };
-    __privateGet(this, _socket).onerror = (ev) => {
-      const message = "message" in ev ? ev.message : "Unknown error";
-      this.onError.post(new Error(message));
-    };
-    __privateGet(this, _socket).onmessage = (event) => {
-      if (__privateGet(this, _isClosed))
-        return;
-      const data = JSON.parse(event.data.toString());
-      const metadata = MESSAGE_META.parse(data);
-      if (metadata.type === "ACK") {
-        const pendingMessage = __privateGet(this, _pendingMessages).get(metadata.id);
-        if (pendingMessage) {
-          pendingMessage.onAckReceived();
-          __privateGet(this, _pendingMessages).delete(metadata.id);
+// ../internal/src/schemas/properties.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"
+  ]),
+  variant: import_zod2.z.string().optional()
+});
+
+// ../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 DeserializedJsonSchema = import_zod3.z.lazy(() => import_zod3.z.union([
+  LiteralSchema,
+  import_zod3.z.array(DeserializedJsonSchema),
+  import_zod3.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 SerializableJsonSchema = import_zod3.z.lazy(() => import_zod3.z.union([
+  SerializableSchema,
+  import_zod3.z.array(SerializableJsonSchema),
+  import_zod3.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
+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()
+});
+
+// ../internal/src/schemas/schedules.ts
+var import_zod6 = require("zod");
+var ScheduledPayloadSchema = import_zod6.z.object({
+  ts: import_zod6.z.coerce.date(),
+  lastTimestamp: import_zod6.z.coerce.date().optional()
+});
+var IntervalOptionsSchema = import_zod6.z.object({
+  seconds: import_zod6.z.number().int().positive().min(60).max(86400)
+});
+var CronOptionsSchema = import_zod6.z.object({
+  cron: import_zod6.z.string()
+});
+var CronMetadataSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("cron"),
+  options: CronOptionsSchema,
+  metadata: import_zod6.z.any()
+});
+var IntervalMetadataSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("interval"),
+  options: IntervalOptionsSchema,
+  metadata: import_zod6.z.any()
+});
+var ScheduleMetadataSchema = import_zod6.z.discriminatedUnion("type", [
+  IntervalMetadataSchema,
+  CronMetadataSchema
+]);
+var RegisterDynamicSchedulePayloadSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  jobs: import_zod6.z.array(import_zod6.z.object({
+    id: import_zod6.z.string(),
+    version: import_zod6.z.string()
+  }))
+});
+
+// ../internal/src/schemas/triggers.ts
+var EventSpecificationSchema = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  title: import_zod7.z.string(),
+  source: import_zod7.z.string(),
+  icon: import_zod7.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(),
+  rule: EventRuleSchema
+});
+var ScheduledTriggerMetadataSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("scheduled"),
+  schedule: ScheduleMetadataSchema
+});
+var TriggerMetadataSchema = import_zod7.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(),
+  data: SerializableJsonSchema.optional()
+});
+var HttpEventSourceSchema = UpdateTriggerSourceBodySchema.extend({
+  id: import_zod8.z.string(),
+  active: import_zod8.z.boolean(),
+  url: import_zod8.z.string().url()
+});
+var RegisterHTTPTriggerSourceBodySchema = import_zod8.z.object({
+  type: import_zod8.z.literal("HTTP"),
+  url: import_zod8.z.string().url()
+});
+var RegisterSMTPTriggerSourceBodySchema = import_zod8.z.object({
+  type: import_zod8.z.literal("SMTP")
+});
+var RegisterSQSTriggerSourceBodySchema = import_zod8.z.object({
+  type: import_zod8.z.literal("SQS")
+});
+var RegisterSourceChannelBodySchema = import_zod8.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(),
+  data: DeserializedJsonSchema.optional(),
+  channel: RegisterSourceChannelBodySchema,
+  clientId: import_zod8.z.string().optional()
+});
+var RegisterSourceEventSchema = import_zod8.z.object({
+  id: import_zod8.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(),
+  event: EventSpecificationSchema,
+  trigger: TriggerMetadataSchema,
+  integrations: import_zod8.z.record(IntegrationConfigSchema),
+  internal: import_zod8.z.boolean().default(false),
+  queue: import_zod8.z.union([
+    QueueOptionsSchema,
+    import_zod8.z.string()
+  ]).optional(),
+  startPosition: import_zod8.z.enum([
+    "initial",
+    "latest"
+  ]),
+  enabled: import_zod8.z.boolean(),
+  preprocessRuns: import_zod8.z.boolean()
+});
+var SourceMetadataSchema = import_zod8.z.object({
+  channel: import_zod8.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({
+    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(),
+  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()
+});
+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 SendEventBodySchema = import_zod8.z.object({
+  event: RawEventSchema,
+  options: SendEventOptionsSchema.optional()
+});
+var DeliverEventResponseSchema = import_zod8.z.object({
+  deliveredAt: import_zod8.z.string().datetime()
+});
+var RuntimeEnvironmentTypeSchema = import_zod8.z.enum([
+  "PRODUCTION",
+  "STAGING",
+  "DEVELOPMENT",
+  "PREVIEW"
+]);
+var RunJobBodySchema = import_zod8.z.object({
+  event: ApiEventLogSchema,
+  job: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    version: import_zod8.z.string()
+  }),
+  run: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    isTest: import_zod8.z.boolean(),
+    startedAt: import_zod8.z.coerce.date()
+  }),
+  environment: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    slug: import_zod8.z.string(),
+    type: RuntimeEnvironmentTypeSchema
+  }),
+  organization: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    title: import_zod8.z.string(),
+    slug: import_zod8.z.string()
+  }),
+  account: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    metadata: import_zod8.z.any()
+  }).optional(),
+  tasks: import_zod8.z.array(CachedTaskSchema).optional(),
+  connections: import_zod8.z.record(ConnectionAuthSchema).optional()
+});
+var RunJobResponseSchema = import_zod8.z.object({
+  executionId: import_zod8.z.string(),
+  completed: import_zod8.z.boolean(),
+  output: DeserializedJsonSchema.optional(),
+  task: TaskSchema.optional()
+});
+var PreprocessRunBodySchema = import_zod8.z.object({
+  event: ApiEventLogSchema,
+  job: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    version: import_zod8.z.string()
+  }),
+  run: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    isTest: import_zod8.z.boolean()
+  }),
+  environment: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    slug: import_zod8.z.string(),
+    type: RuntimeEnvironmentTypeSchema
+  }),
+  organization: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    title: import_zod8.z.string(),
+    slug: import_zod8.z.string()
+  }),
+  account: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    metadata: import_zod8.z.any()
+  }).optional()
+});
+var PreprocessRunResponseSchema = import_zod8.z.object({
+  abort: import_zod8.z.boolean(),
+  properties: import_zod8.z.array(DisplayPropertySchema).optional()
+});
+var CreateRunBodySchema = import_zod8.z.object({
+  client: import_zod8.z.string(),
+  job: JobMetadataSchema,
+  event: ApiEventLogSchema,
+  properties: import_zod8.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 CreateRunResponseErrorSchema = import_zod8.z.object({
+  ok: import_zod8.z.literal(false),
+  error: import_zod8.z.string()
+});
+var CreateRunResponseBodySchema = import_zod8.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 LogMessageSchema = import_zod8.z.object({
+  level: import_zod8.z.enum([
+    "DEBUG",
+    "INFO",
+    "WARN",
+    "ERROR"
+  ]),
+  message: import_zod8.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(),
+  redact: RedactSchema.optional(),
+  connectionKey: import_zod8.z.string().optional(),
+  style: StyleSchema.optional()
+});
+var RunTaskBodyInputSchema = RunTaskOptionsSchema.extend({
+  idempotencyKey: import_zod8.z.string(),
+  parentId: import_zod8.z.string().optional()
+});
+var RunTaskBodyOutputSchema = RunTaskBodyInputSchema.extend({
+  params: DeserializedJsonSchema.optional().nullable()
+});
+var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
+  properties: true,
+  description: true,
+  params: true
+}).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 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 HttpSourceResponseSchema = import_zod8.z.object({
+  response: NormalizedResponseSchema,
+  events: import_zod8.z.array(RawEventSchema)
+});
+var RegisterTriggerBodySchema = import_zod8.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 RegisterCommonScheduleBodySchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  metadata: import_zod8.z.any(),
+  accountId: import_zod8.z.string().optional()
+});
+var RegisterIntervalScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(IntervalMetadataSchema);
+var InitializeCronScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(CronMetadataSchema);
+var RegisterScheduleBodySchema = import_zod8.z.discriminatedUnion("type", [
+  RegisterIntervalScheduleBodySchema,
+  InitializeCronScheduleBodySchema
+]);
+var RegisterScheduleResponseBodySchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  schedule: ScheduleMetadataSchema,
+  metadata: import_zod8.z.any(),
+  active: import_zod8.z.boolean()
+});
+var CreateExternalConnectionBodySchema = import_zod8.z.object({
+  accessToken: import_zod8.z.string(),
+  type: import_zod8.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()
+});
+
+// ../internal/src/schemas/notifications.ts
+var import_zod10 = require("zod");
+var MISSING_CONNECTION_NOTIFICATION = "dev.trigger.notifications.missingConnection";
+var MISSING_CONNECTION_RESOLVED_NOTIFICATION = "dev.trigger.notifications.missingConnectionResolved";
+var CommonMissingConnectionNotificationPayloadSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  client: import_zod10.z.object({
+    id: import_zod10.z.string(),
+    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()
+  }),
+  authorizationUrl: import_zod10.z.string()
+});
+var MissingDeveloperConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
+  type: import_zod10.z.literal("DEVELOPER")
+});
+var MissingExternalConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
+  type: import_zod10.z.literal("EXTERNAL"),
+  account: import_zod10.z.object({
+    id: import_zod10.z.string(),
+    metadata: import_zod10.z.any()
+  })
+});
+var MissingConnectionNotificationPayloadSchema = import_zod10.z.discriminatedUnion("type", [
+  MissingDeveloperConnectionNotificationPayloadSchema,
+  MissingExternalConnectionNotificationPayloadSchema
+]);
+var CommonMissingConnectionNotificationResolvedPayloadSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  client: import_zod10.z.object({
+    id: import_zod10.z.string(),
+    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()
+  }),
+  expiresAt: import_zod10.z.coerce.date()
+});
+var MissingDeveloperConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
+  type: import_zod10.z.literal("DEVELOPER")
+});
+var MissingExternalConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
+  type: import_zod10.z.literal("EXTERNAL"),
+  account: import_zod10.z.object({
+    id: import_zod10.z.string(),
+    metadata: import_zod10.z.any()
+  })
+});
+var MissingConnectionResolvedNotificationPayloadSchema = import_zod10.z.discriminatedUnion("type", [
+  MissingDeveloperConnectionResolvedNotificationPayloadSchema,
+  MissingExternalConnectionResolvedNotificationPayloadSchema
+]);
+
+// ../internal/src/utils.ts
+function deepMergeFilters(filter, other) {
+  const result = {
+    ...filter
+  };
+  for (const key in other) {
+    if (other.hasOwnProperty(key)) {
+      const otherValue = other[key];
+      if (typeof otherValue === "object" && !Array.isArray(otherValue) && otherValue !== null) {
+        const filterValue = filter[key];
+        if (filterValue && typeof filterValue === "object" && !Array.isArray(filterValue)) {
+          result[key] = deepMergeFilters(filterValue, otherValue);
+        } else {
+          result[key] = {
+            ...other[key]
+          };
+        }
+      } else {
+        result[key] = other[key];
+      }
+    }
+  }
+  return result;
+}
+__name(deepMergeFilters, "deepMergeFilters");
+
+// src/apiClient.ts
+var import_zod11 = require("zod");
+var _apiUrl, _options, _logger, _apiKey, apiKey_fn;
+var ApiClient = class {
+  constructor(options) {
+    __privateAdd(this, _apiKey);
+    __privateAdd(this, _apiUrl, void 0);
+    __privateAdd(this, _options, void 0);
+    __privateAdd(this, _logger, void 0);
+    __privateSet(this, _options, options);
+    __privateSet(this, _apiUrl, __privateGet(this, _options).apiUrl ?? process.env.TRIGGER_API_URL ?? "https://api.trigger.dev");
+    __privateSet(this, _logger, new Logger("trigger.dev", __privateGet(this, _options).logLevel));
+  }
+  async registerEndpoint(options) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Registering endpoint", {
+      url: options.url,
+      name: options.name
+    });
+    const response = await 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 createRun(params) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Creating run", {
+      params
+    });
+    return await zodfetch(CreateRunResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/runs`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(params)
+    });
+  }
+  async runTask(runId, task) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Running Task", {
+      task
+    });
+    return await zodfetch(ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        "Idempotency-Key": task.idempotencyKey
+      },
+      body: JSON.stringify(task)
+    });
+  }
+  async completeTask(runId, id, task) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Complete Task", {
+      task
+    });
+    return await zodfetch(ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(task)
+    });
+  }
+  async sendEvent(event, options = {}) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Sending event", {
+      event
+    });
+    return await zodfetch(ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        event,
+        options
+      })
+    });
+  }
+  async updateSource(client, key, source) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("activating http source", {
+      source
+    });
+    const response = await zodfetch(TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/sources/${key}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(source)
+    });
+    return response;
+  }
+  async registerTrigger(client, id, key, payload) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("registering trigger", {
+      id,
+      payload
+    });
+    const response = await zodfetch(RegisterSourceEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/triggers/${id}/registrations/${key}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+    return response;
+  }
+  async registerSchedule(client, id, key, payload) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("registering schedule", {
+      id,
+      payload
+    });
+    const response = await zodfetch(RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        id: key,
+        ...payload
+      })
+    });
+    return response;
+  }
+  async unregisterSchedule(client, id, key) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("unregistering schedule", {
+      id
+    });
+    const response = await zodfetch(import_zod11.z.object({
+      ok: import_zod11.z.boolean()
+    }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    return response;
+  }
+  async getAuth(client, id) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("getting auth", {
+      id
+    });
+    const response = await zodfetch(ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    }, {
+      optional: true
+    });
+    return response;
+  }
+};
+__name(ApiClient, "ApiClient");
+_apiUrl = new WeakMap();
+_options = new WeakMap();
+_logger = new WeakMap();
+_apiKey = new WeakSet();
+apiKey_fn = /* @__PURE__ */ __name(async function() {
+  const apiKey = getApiKey(__privateGet(this, _options).apiKey);
+  if (apiKey.status === "invalid") {
+    throw new Error("Invalid API key");
+  } else if (apiKey.status === "missing") {
+    throw new Error("Missing API key");
+  }
+  return apiKey.apiKey;
+}, "#apiKey");
+function getApiKey(key) {
+  const apiKey = key ?? process.env.TRIGGER_API_KEY;
+  if (!apiKey) {
+    return {
+      status: "missing"
+    };
+  }
+  const isValid = apiKey.match(/^tr_[a-z]+_[a-zA-Z0-9]+$/);
+  if (!isValid) {
+    return {
+      status: "invalid",
+      apiKey
+    };
+  }
+  return {
+    status: "valid",
+    apiKey
+  };
+}
+__name(getApiKey, "getApiKey");
+async function zodfetch(schema, 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();
+  return schema.parse(jsonBody);
+}
+__name(zodfetch, "zodfetch");
+
+// src/io.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+
+// src/ioWithIntegrations.ts
+function createIOWithIntegrations(io, auths, integrations) {
+  if (!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;
+    if (!client) {
+      return acc;
+    }
+    const ioConnection = {
+      client
+    };
+    if (integration.client.tasks) {
+      const tasks = integration.client.tasks;
+      Object.keys(tasks).forEach((taskName) => {
+        const authenticatedTask2 = tasks[taskName];
+        ioConnection[taskName] = async (key, params) => {
+          const options = authenticatedTask2.init(params);
+          options.connectionKey = connectionKey;
+          return await io.runTask(key, options, async (ioTask) => {
+            return authenticatedTask2.run(params, client, ioTask, io);
+          });
+        };
+      });
+    }
+    acc[connectionKey] = ioConnection;
+    return acc;
+  }, {});
+  return new Proxy(io, {
+    get(target, prop, receiver) {
+      if (prop === "__io") {
+        return io;
+      }
+      if (prop in connections) {
+        return connections[prop];
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value == "function" ? value.bind(target) : value;
+    }
+  });
+}
+__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) {
+    __privateAdd(this, _addToCachedTasks);
+    this._id = options.id;
+    this._apiClient = options.apiClient;
+    this._triggerClient = options.client;
+    this._logger = options.logger ?? new Logger("trigger.dev", options.logLevel);
+    this._cachedTasks = /* @__PURE__ */ new Map();
+    if (options.cachedTasks) {
+      options.cachedTasks.forEach((task) => {
+        this._cachedTasks.set(task.id, task);
+      });
+    }
+    this._taskStorage = new import_node_async_hooks.AsyncLocalStorage();
+    this._context = options.context;
+  }
+  get logger() {
+    return new IOLogger(async (level, message, data) => {
+      switch (level) {
+        case "DEBUG": {
+          this._logger.debug(message, data);
+          break;
+        }
+        case "INFO": {
+          this._logger.info(message, data);
+          break;
+        }
+        case "WARN": {
+          this._logger.warn(message, data);
+          break;
+        }
+        case "ERROR": {
+          this._logger.error(message, data);
+          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) => {
+      });
+    });
+  }
+  async wait(key, seconds) {
+    return await this.runTask(key, {
+      name: "wait",
+      icon: "clock",
+      params: {
+        seconds
+      },
+      noop: true,
+      delayUntil: new Date(Date.now() + seconds * 1e3),
+      style: {
+        style: "minimal"
+      }
+    }, async (task) => {
+    });
+  }
+  async sendEvent(key, event, options) {
+    return await this.runTask(key, {
+      name: "sendEvent",
+      params: {
+        event,
+        options
+      }
+    }, async (task) => {
+      return await this._triggerClient.sendEvent(event, options);
+    });
+  }
+  async updateSource(key, options) {
+    return this.runTask(key, {
+      name: "Update Source",
+      description: `Update Source ${options.key}`,
+      properties: [
+        {
+          label: "key",
+          text: options.key
+        }
+      ],
+      redact: {
+        paths: [
+          "secret"
+        ]
+      }
+    }, async (task) => {
+      return await this._apiClient.updateSource(this._triggerClient.id, options.key, options);
+    });
+  }
+  async registerInterval(key, dynamicSchedule, id, options) {
+    return await this.runTask(key, {
+      name: "register-interval",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        },
+        {
+          label: "seconds",
+          text: options.seconds.toString()
+        }
+      ],
+      params: options
+    }, async (task) => {
+      return dynamicSchedule.register(id, {
+        type: "interval",
+        options
+      });
+    });
+  }
+  async unregisterInterval(key, dynamicSchedule, id) {
+    return await this.runTask(key, {
+      name: "unregister-interval",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        }
+      ]
+    }, async (task) => {
+      return dynamicSchedule.unregister(id);
+    });
+  }
+  async registerCron(key, dynamicSchedule, id, options) {
+    return await this.runTask(key, {
+      name: "register-cron",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        },
+        {
+          label: "cron",
+          text: options.cron
+        }
+      ],
+      params: options
+    }, async (task) => {
+      return dynamicSchedule.register(id, {
+        type: "cron",
+        options
+      });
+    });
+  }
+  async unregisterCron(key, dynamicSchedule, id) {
+    return await this.runTask(key, {
+      name: "unregister-cron",
+      properties: [
+        {
+          label: "schedule",
+          text: dynamicSchedule.id
+        },
+        {
+          label: "id",
+          text: id
+        }
+      ]
+    }, async (task) => {
+      return dynamicSchedule.unregister(id);
+    });
+  }
+  async registerTrigger(key, trigger, id, params) {
+    return await this.runTask(key, {
+      name: "register-trigger",
+      properties: [
+        {
+          label: "trigger",
+          text: trigger.id
+        },
+        {
+          label: "id",
+          text: id
+        }
+      ],
+      params
+    }, async (task) => {
+      const registration = await this.runTask("register-source", {
+        name: "register-source"
+      }, async (subtask1) => {
+        return trigger.register(id, params);
+      });
+      const connection = await this.getAuth("get-auth", registration.source.clientId);
+      const io = createIOWithIntegrations(
+        this,
+        {
+          integration: connection
+        },
+        {
+          integration: trigger.source.integration
+        }
+      );
+      const updates = await trigger.source.register(params, registration, io, this._context);
+      if (!updates) {
+        return;
+      }
+      return await this.updateSource("update-source", {
+        key: registration.source.key,
+        ...updates
+      });
+    });
+  }
+  async getAuth(key, clientId) {
+    if (!clientId) {
+      return;
+    }
+    return this.runTask(key, {
+      name: "get-auth"
+    }, async (task) => {
+      return await this._triggerClient.getAuth(clientId);
+    });
+  }
+  async runTask(key, options, callback) {
+    const parentId = this._taskStorage.getStore()?.taskId;
+    if (parentId) {
+      this._logger.debug("Using parent task", {
+        parentId,
+        key,
+        options
+      });
+    }
+    const idempotencyKey = await generateIdempotencyKey([
+      this._id,
+      parentId ?? "",
+      key
+    ].flat());
+    const cachedTask = this._cachedTasks.get(idempotencyKey);
+    if (cachedTask) {
+      this._logger.debug("Using cached task", {
+        idempotencyKey,
+        cachedTask
+      });
+      return cachedTask.output;
+    }
+    const task = await this._apiClient.runTask(this._id, {
+      idempotencyKey,
+      displayKey: typeof key === "string" ? key : void 0,
+      noop: false,
+      ...options,
+      parentId
+    });
+    if (task.status === "COMPLETED") {
+      this._logger.debug("Using task output", {
+        idempotencyKey,
+        task
+      });
+      __privateMethod(this, _addToCachedTasks, addToCachedTasks_fn).call(this, task);
+      return task.output;
+    }
+    if (task.status === "ERRORED") {
+      this._logger.debug("Task errored", {
+        idempotencyKey,
+        task
+      });
+      throw new Error(task.error ?? "Task errored");
+    }
+    if (task.status === "WAITING") {
+      this._logger.debug("Task waiting", {
+        idempotencyKey,
+        task
+      });
+      throw new ResumeWithTask(task);
+    }
+    const executeTask = /* @__PURE__ */ __name(async () => {
+      try {
+        const result = await callback(task, this);
+        this._logger.debug("Completing using output", {
+          idempotencyKey,
+          task
+        });
+        await this._apiClient.completeTask(this._id, task.id, {
+          output: result ?? void 0
+        });
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    }, "executeTask");
+    return this._taskStorage.run({
+      taskId: task.id
+    }, executeTask);
+  }
+};
+__name(IO, "IO");
+_addToCachedTasks = new WeakSet();
+addToCachedTasks_fn = /* @__PURE__ */ __name(function(task) {
+  this._cachedTasks.set(task.idempotencyKey, task);
+}, "#addToCachedTasks");
+async function generateIdempotencyKey(keyMaterial) {
+  const keys = keyMaterial.map((key2) => {
+    if (typeof key2 === "string") {
+      return key2;
+    }
+    return stableStringify(key2);
+  });
+  const key = keys.join(":");
+  const hash = await import_node_crypto.webcrypto.subtle.digest("SHA-256", Buffer.from(key));
+  return Buffer.from(hash).toString("hex");
+}
+__name(generateIdempotencyKey, "generateIdempotencyKey");
+function stableStringify(obj) {
+  function sortKeys(obj2) {
+    if (typeof obj2 !== "object" || obj2 === null) {
+      return obj2;
+    }
+    if (Array.isArray(obj2)) {
+      return obj2.map(sortKeys);
+    }
+    const sortedKeys = Object.keys(obj2).sort();
+    const sortedObj2 = {};
+    for (const key of sortedKeys) {
+      sortedObj2[key] = sortKeys(obj2[key]);
+    }
+    return sortedObj2;
+  }
+  __name(sortKeys, "sortKeys");
+  const sortedObj = sortKeys(obj);
+  return JSON.stringify(sortedObj);
+}
+__name(stableStringify, "stableStringify");
+var IOLogger = class {
+  constructor(callback) {
+    this.callback = callback;
+  }
+  debug(message, properties) {
+    return this.callback("DEBUG", message, properties);
+  }
+  info(message, properties) {
+    return this.callback("INFO", message, properties);
+  }
+  warn(message, properties) {
+    return this.callback("WARN", message, properties);
+  }
+  error(message, properties) {
+    return this.callback("ERROR", message, properties);
+  }
+};
+__name(IOLogger, "IOLogger");
+
+// src/triggers/eventTrigger.ts
+var _options2;
+var EventTrigger = class {
+  constructor(options) {
+    __privateAdd(this, _options2, void 0);
+    __privateSet(this, _options2, options);
+  }
+  toJSON() {
+    return {
+      type: "static",
+      title: __privateGet(this, _options2).name ?? __privateGet(this, _options2).event.title,
+      rule: {
+        event: __privateGet(this, _options2).name ?? __privateGet(this, _options2).event.name,
+        source: __privateGet(this, _options2).source ?? "trigger.dev",
+        payload: deepMergeFilters(__privateGet(this, _options2).filter ?? {}, __privateGet(this, _options2).event.filter ?? {})
+      }
+    };
+  }
+  get event() {
+    return __privateGet(this, _options2).event;
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+};
+__name(EventTrigger, "EventTrigger");
+_options2 = new WeakMap();
+function eventTrigger(options) {
+  return new EventTrigger({
+    name: "Event Trigger",
+    filter: options.filter,
+    event: {
+      name: options.name,
+      title: "Event",
+      source: options.source ?? "trigger.dev",
+      icon: "custom-event",
+      parsePayload: (rawPayload) => {
+        if (options.schema) {
+          return options.schema.parse(rawPayload);
+        }
+        return rawPayload;
+      }
+    }
+  });
+}
+__name(eventTrigger, "eventTrigger");
+
+// src/triggerClient.ts
+var registerSourceEvent = {
+  name: REGISTER_SOURCE_EVENT,
+  title: "Register Source",
+  source: "internal",
+  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 TriggerClient = class {
+  constructor(options) {
+    __privateAdd(this, _preprocessRun);
+    __privateAdd(this, _executeJob);
+    __privateAdd(this, _createRunContext);
+    __privateAdd(this, _createPreprocessRunContext);
+    __privateAdd(this, _handleHttpSourceRequest);
+    __privateAdd(this, _options3, void 0);
+    __privateAdd(this, _registeredJobs, {});
+    __privateAdd(this, _registeredSources, {});
+    __privateAdd(this, _registeredHttpSourceHandlers, {});
+    __privateAdd(this, _registeredDynamicTriggers, {});
+    __privateAdd(this, _jobMetadataByDynamicTriggers, {});
+    __privateAdd(this, _registeredSchedules, {});
+    __privateAdd(this, _client, void 0);
+    __privateAdd(this, _logger2, 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}` : ""}`;
+  }
+  async handleRequest(request) {
+    __privateGet(this, _logger2).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"
+        }
+      };
+    }
+    if (request.method !== "POST") {
+      return {
+        status: 405,
+        body: {
+          message: "Method not allowed"
+        }
+      };
+    }
+    const action = request.headers.get("x-trigger-action");
+    if (!action) {
+      return {
+        status: 400,
+        body: {
+          message: "Missing x-trigger-action header"
+        }
+      };
+    }
+    switch (action) {
+      case "PING": {
+        return {
+          status: 200,
+          body: {
+            message: "PONG"
+          }
+        };
+      }
+      case "GET_ENDPOINT_DATA": {
+        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()),
+          sources: Object.values(__privateGet(this, _registeredSources)),
+          dynamicTriggers: Object.values(__privateGet(this, _registeredDynamicTriggers)).map((trigger) => ({
+            id: trigger.id,
+            jobs: __privateGet(this, _jobMetadataByDynamicTriggers)[trigger.id] ?? []
+          })),
+          dynamicSchedules: Object.entries(__privateGet(this, _registeredSchedules)).map(([id, jobs]) => ({
+            id,
+            jobs
+          }))
+        };
+        return {
+          status: 200,
+          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);
+        if (!body.success) {
+          return {
+            status: 400,
+            body: {
+              message: "Invalid trigger body"
+            }
+          };
+        }
+        const dynamicTrigger = __privateGet(this, _registeredDynamicTriggers)[body.data.id];
+        if (!dynamicTrigger) {
+          return {
+            status: 404,
+            body: {
+              message: "Dynamic trigger not found"
+            }
+          };
+        }
+        return {
+          status: 200,
+          body: dynamicTrigger.registeredTriggerForParams(body.data.params)
+        };
+      }
+      case "EXECUTE_JOB": {
+        const json = await request.json();
+        const execution = RunJobBodySchema.safeParse(json);
+        if (!execution.success) {
+          return {
+            status: 400,
+            body: {
+              message: "Invalid execution"
+            }
+          };
+        }
+        const job = __privateGet(this, _registeredJobs)[execution.data.job.id];
+        if (!job) {
+          return {
+            status: 404,
+            body: {
+              message: "Job not found"
+            }
+          };
+        }
+        const results = await __privateMethod(this, _executeJob, executeJob_fn).call(this, execution.data, job);
+        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
+          }
+        };
+      }
+      case "PREPROCESS_RUN": {
+        const json = await request.json();
+        const body = PreprocessRunBodySchema.safeParse(json);
+        if (!body.success) {
+          return {
+            status: 400,
+            body: {
+              message: "Invalid body"
+            }
+          };
+        }
+        const job = __privateGet(this, _registeredJobs)[body.data.job.id];
+        if (!job) {
+          return {
+            status: 404,
+            body: {
+              message: "Job not found"
+            }
+          };
+        }
+        const results = await __privateMethod(this, _preprocessRun, preprocessRun_fn).call(this, body.data, job);
+        return {
+          status: 200,
+          body: {
+            abort: results.abort,
+            properties: results.properties
+          }
+        };
+      }
+      case "DELIVER_HTTP_SOURCE_REQUEST": {
+        const headers = HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
+        if (!headers.success) {
+          return {
+            status: 400,
+            body: {
+              message: "Invalid headers"
+            }
+          };
+        }
+        const sourceRequest = new Request(headers.data["x-ts-http-url"], {
+          method: headers.data["x-ts-http-method"],
+          headers: headers.data["x-ts-http-headers"],
+          body: headers.data["x-ts-http-method"] !== "GET" ? request.body : void 0
+        });
+        const key = headers.data["x-ts-key"];
+        const dynamicId = headers.data["x-ts-dynamic-id"];
+        const secret = headers.data["x-ts-secret"];
+        const params = headers.data["x-ts-params"];
+        const data = headers.data["x-ts-data"];
+        const source = {
+          key,
+          dynamicId,
+          secret,
+          params,
+          data
+        };
+        const { response, events } = await __privateMethod(this, _handleHttpSourceRequest, handleHttpSourceRequest_fn).call(this, source, sourceRequest);
+        return {
+          status: 200,
+          body: {
+            events,
+            response
+          }
+        };
+      }
+    }
+    return {
+      status: 405,
+      body: {
+        message: "Method not allowed"
+      }
+    };
+  }
+  attach(job) {
+    if (!job.enabled) {
+      return;
+    }
+    __privateGet(this, _registeredJobs)[job.id] = job;
+    job.trigger.attachToJob(this, job);
+  }
+  attachDynamicTrigger(trigger) {
+    __privateGet(this, _registeredDynamicTriggers)[trigger.id] = trigger;
+    new Job(this, {
+      id: `register-dynamic-trigger-${trigger.id}`,
+      name: `Register dynamic trigger ${trigger.id}`,
+      version: trigger.source.version,
+      trigger: new EventTrigger({
+        event: registerSourceEvent,
+        filter: {
+          dynamicTriggerId: [
+            trigger.id
+          ]
+        }
+      }),
+      integrations: {
+        integration: trigger.source.integration
+      },
+      run: async (event, io, ctx) => {
+        const updates = await trigger.source.register(event.source.params, event, io, ctx);
+        if (!updates) {
+          return;
+        }
+        return await io.updateSource("update-source", {
+          key: event.source.key,
+          ...updates
+        });
+      },
+      __internal: true
+    });
+  }
+  attachJobToDynamicTrigger(job, trigger) {
+    const jobs = __privateGet(this, _jobMetadataByDynamicTriggers)[trigger.id] ?? [];
+    jobs.push({
+      id: job.id,
+      version: job.version
+    });
+    __privateGet(this, _jobMetadataByDynamicTriggers)[trigger.id] = jobs;
+  }
+  attachSource(options) {
+    __privateGet(this, _registeredHttpSourceHandlers)[options.key] = async (s, r) => {
+      return await options.source.handle(s, r, __privateGet(this, _logger2));
+    };
+    let registeredSource = __privateGet(this, _registeredSources)[options.key];
+    if (!registeredSource) {
+      registeredSource = {
+        channel: options.source.channel,
+        key: options.key,
+        params: options.params,
+        events: [],
+        clientId: !options.source.integration.usesLocalAuth ? options.source.integration.id : void 0
+      };
+    }
+    registeredSource.events = Array.from(/* @__PURE__ */ new Set([
+      ...registeredSource.events,
+      options.event.name
+    ]));
+    __privateGet(this, _registeredSources)[options.key] = registeredSource;
+    new Job(this, {
+      id: options.key,
+      name: options.key,
+      version: options.source.version,
+      trigger: new EventTrigger({
+        event: registerSourceEvent,
+        filter: {
+          source: {
+            key: [
+              options.key
+            ]
+          }
+        }
+      }),
+      integrations: {
+        integration: options.source.integration
+      },
+      queue: {
+        name: options.key,
+        maxConcurrent: 1
+      },
+      startPosition: "initial",
+      run: async (event, io, ctx) => {
+        const updates = await options.source.register(options.params, event, io, ctx);
+        if (!updates) {
+          return;
+        }
+        return await io.updateSource("update-source", {
+          key: options.key,
+          ...updates
+        });
+      },
+      __internal: true
+    });
+  }
+  attachDynamicSchedule(key, job) {
+    const jobs = __privateGet(this, _registeredSchedules)[key] ?? [];
+    jobs.push({
+      id: job.id,
+      version: job.version
+    });
+    __privateGet(this, _registeredSchedules)[key] = jobs;
+  }
+  async registerTrigger(id, key, options) {
+    return __privateGet(this, _client).registerTrigger(this.id, id, key, options);
+  }
+  async getAuth(id) {
+    return __privateGet(this, _client).getAuth(this.id, id);
+  }
+  async sendEvent(event, options) {
+    return __privateGet(this, _client).sendEvent(event, options);
+  }
+  async registerSchedule(id, key, schedule) {
+    return __privateGet(this, _client).registerSchedule(this.id, id, key, schedule);
+  }
+  async unregisterSchedule(id, key) {
+    return __privateGet(this, _client).unregisterSchedule(this.id, id, key);
+  }
+  authorized(apiKey) {
+    const localApiKey = __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
+    if (!localApiKey) {
+      return false;
+    }
+    return apiKey === localApiKey;
+  }
+  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();
+_registeredJobs = new WeakMap();
+_registeredSources = new WeakMap();
+_registeredHttpSourceHandlers = new WeakMap();
+_registeredDynamicTriggers = new WeakMap();
+_jobMetadataByDynamicTriggers = new WeakMap();
+_registeredSchedules = new WeakMap();
+_client = new WeakMap();
+_logger2 = new WeakMap();
+_preprocessRun = new WeakSet();
+preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
+  const context = __privateMethod(this, _createPreprocessRunContext, createPreprocessRunContext_fn).call(this, body);
+  const parsedPayload = job.trigger.event.parsePayload(body.event.payload ?? {});
+  const properties = job.trigger.event.runProperties?.(parsedPayload) ?? [];
+  return {
+    abort: false,
+    properties
+  };
+}, "#preprocessRun");
+_executeJob = new WeakSet();
+executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
+  __privateGet(this, _logger2).debug("executing job", {
+    execution: body1,
+    job: job1.toJSON()
+  });
+  const context = __privateMethod(this, _createRunContext, createRunContext_fn).call(this, body1);
+  const io = new IO({
+    id: body1.run.id,
+    cachedTasks: body1.tasks,
+    apiClient: __privateGet(this, _client),
+    logger: __privateGet(this, _logger2),
+    client: this,
+    context
+  });
+  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,
+      output
+    };
+  } catch (error) {
+    if (error instanceof ResumeWithTask) {
+      return {
+        completed: false,
+        task: error.task
+      };
+    }
+    const errorWithStack = ErrorWithStackSchema.safeParse(error);
+    if (errorWithStack.success) {
+      return {
+        completed: true,
+        error: errorWithStack.data
+      };
+    }
+    const errorWithMessage = ErrorWithMessage.safeParse(error);
+    if (errorWithMessage.success) {
+      return {
+        completed: true,
+        error: errorWithMessage.data
+      };
+    }
+    return {
+      completed: true,
+      error: {
+        message: "Unknown error"
+      }
+    };
+  }
+}, "#executeJob");
+_createRunContext = new WeakSet();
+createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
+  const { event, organization, environment, job, run } = execution;
+  return {
+    event: {
+      id: event.id,
+      name: event.name,
+      context: event.context,
+      timestamp: event.timestamp
+    },
+    organization,
+    environment,
+    job,
+    run,
+    account: execution.account
+  };
+}, "#createRunContext");
+_createPreprocessRunContext = new WeakSet();
+createPreprocessRunContext_fn = /* @__PURE__ */ __name(function(body2) {
+  const { event, organization, environment, job, run, account } = body2;
+  return {
+    event: {
+      id: event.id,
+      name: event.name,
+      context: event.context,
+      timestamp: event.timestamp
+    },
+    organization,
+    environment,
+    job,
+    run,
+    account
+  };
+}, "#createPreprocessRunContext");
+_handleHttpSourceRequest = new WeakSet();
+handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourceRequest) {
+  __privateGet(this, _logger2).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", {
+        source
+      });
+      return {
+        response: {
+          status: 200,
+          body: {
+            ok: true
+          }
+        },
+        events: []
+      };
+    }
+    const results2 = await dynamicTrigger.source.handle(source, sourceRequest, __privateGet(this, _logger2));
+    if (!results2) {
+      return {
+        events: [],
+        response: {
+          status: 200,
+          body: {
+            ok: true
+          }
         }
-      }
-      if (metadata.type === "MESSAGE") {
-        socket.send(JSON.stringify({
-          type: "ACK",
-          id: metadata.id
-        }));
-        if (metadata.data === "AUTHENTICATED") {
-          __privateSet(this, _isAuthenticated, true);
-          this.onAuthenticated.post();
-          return;
+      };
+    }
+    return {
+      events: results2.events,
+      response: results2.response ?? {
+        status: 200,
+        body: {
+          ok: true
         }
-        this.onMessage.post(metadata.data);
       }
     };
-    if ("pong" in socket) {
-      socket.on("pong", (buf) => {
-        const id = buf.toString();
-        const pendingMessage = __privateGet(this, _pendingMessages).get(id);
-        if (pendingMessage?.data === "ping") {
-          pendingMessage.onAckReceived();
-        }
-      });
-    }
   }
-  async connect() {
-    __privateGet(this, _logger2).debug("[connect] Attempting to connect");
-    return new Promise((resolve, reject) => {
-      if (__privateGet(this, _socket).readyState === __privateGet(this, _socket).OPEN && __privateGet(this, _isAuthenticated)) {
-        __privateGet(this, _logger2).debug("[connect] Already connected, resolving");
-        return resolve();
-      }
-      const failTimeout = setTimeout(() => {
-        __privateGet(this, _logger2).debug("[connect] Connection timed out, rejecting");
-        reject(new TimeoutError());
-      }, __privateGet(this, _connectTimeout));
-      __privateGet(this, _timeouts).add(failTimeout);
-      this.onAuthenticated.attach(() => {
-        clearTimeout(failTimeout);
-        __privateGet(this, _timeouts).delete(failTimeout);
-        __privateGet(this, _logger2).debug("[connect] Connected, resolving");
-        resolve();
-      });
+  const handler = __privateGet(this, _registeredHttpSourceHandlers)[source.key];
+  if (!handler) {
+    __privateGet(this, _logger2).debug("No handler registered for HTTP source", {
+      source
     });
-  }
-  async send(data) {
-    if (__privateGet(this, _isClosed))
-      throw new NotConnectedError();
-    return new Promise((resolve, reject) => {
-      const id = (0, import_uuid.v4)();
-      const failTimeout = setTimeout(() => {
-        reject(new TimeoutError());
-      }, __privateGet(this, _sendTimeout));
-      __privateGet(this, _timeouts).add(failTimeout);
-      __privateGet(this, _pendingMessages).set(id, {
-        data,
-        onAckReceived: () => {
-          clearTimeout(failTimeout);
-          __privateGet(this, _timeouts).delete(failTimeout);
-          resolve();
+    return {
+      response: {
+        status: 200,
+        body: {
+          ok: true
         }
-      });
-      __privateGet(this, _socket).send(JSON.stringify({
-        id,
-        data,
-        type: "MESSAGE"
-      }));
-    });
+      },
+      events: []
+    };
   }
-  close(code, reason) {
-    __privateSet(this, _isClosed, true);
-    this.onMessage.detach();
-    return __privateGet(this, _socket).close(code, reason);
+  const results = await handler(source, sourceRequest);
+  if (!results) {
+    return {
+      events: [],
+      response: {
+        status: 200,
+        body: {
+          ok: true
+        }
+      }
+    };
   }
-};
-__name(HostConnection, "HostConnection");
-_socket = new WeakMap();
-_connectTimeout = new WeakMap();
-_sendTimeout = new WeakMap();
-_pingTimeout = new WeakMap();
-_isAuthenticated = new WeakMap();
-_timeouts = new WeakMap();
-_isClosed = new WeakMap();
-_pendingMessages = new WeakMap();
-_logger2 = new WeakMap();
-_pingIntervalHandle = new WeakMap();
-_pingIntervalMs = new WeakMap();
-_closeUnresponsiveConnectionTimeoutMs = new WeakMap();
-_startPingInterval = new WeakSet();
-startPingInterval_fn = /* @__PURE__ */ __name(function() {
-  let lastSuccessfulPing = new Date();
-  __privateSet(this, _pingIntervalHandle, setInterval(async () => {
-    if (!__privateGet(this, _socket).OPEN) {
-      if (__privateGet(this, _pingIntervalHandle)) {
-        clearInterval(__privateGet(this, _pingIntervalHandle));
-        __privateSet(this, _pingIntervalHandle, void 0);
+  return {
+    events: results.events,
+    response: results.response ?? {
+      status: 200,
+      body: {
+        ok: true
       }
-      return;
     }
-    try {
-      await __privateMethod(this, _ping, ping_fn).call(this);
-      lastSuccessfulPing = new Date();
-    } catch (err) {
-      __privateGet(this, _logger2).warn("Pong not received in time");
-      if (!(err instanceof TimeoutError)) {
-        __privateGet(this, _logger2).error(err);
-      }
-      if (lastSuccessfulPing.getTime() < new Date().getTime() - __privateGet(this, _closeUnresponsiveConnectionTimeoutMs)) {
-        __privateGet(this, _logger2).error("No pong received in last three minutes, closing connection to Trigger.dev and retrying...");
-        if (__privateGet(this, _pingIntervalHandle)) {
-          clearInterval(__privateGet(this, _pingIntervalHandle));
-          __privateSet(this, _pingIntervalHandle, void 0);
-        }
-        __privateGet(this, _socket).close();
-      }
+  };
+}, "#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;
     }
-  }, __privateGet(this, _pingIntervalMs)));
-}, "#startPingInterval");
-_ping = new WeakSet();
-ping_fn = /* @__PURE__ */ __name(async function() {
-  if (!__privateGet(this, _socket).OPEN) {
-    throw new NotConnectedError();
-  }
-  if (!("ping" in __privateGet(this, _socket))) {
-    throw new Error("ping not supported in this underlying websocket connection");
-  }
-  const socket = __privateGet(this, _socket);
-  return new Promise((resolve, reject) => {
-    const id = (0, import_uuid.v4)();
-    const failTimeout = setTimeout(() => {
-      reject(new TimeoutError("Pong not received in time"));
-    }, __privateGet(this, _pingTimeout));
-    __privateGet(this, _timeouts).add(failTimeout);
-    __privateGet(this, _pendingMessages).set(id, {
-      data: "ping",
-      onAckReceived: () => {
-        clearTimeout(failTimeout);
-        __privateGet(this, _timeouts).delete(failTimeout);
-        __privateGet(this, _logger2).debug(`Resolving ping`);
-        resolve();
-      }
-    });
-    __privateGet(this, _logger2).debug(`Sending ping ${id} to ${socket.url}`);
-    socket.ping(id, void 0, (err) => {
-      if (err) {
-        reject(err);
-      }
-    });
-  });
-}, "#ping");
+    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/localStorage.ts
-var import_node_async_hooks = require("async_hooks");
-var triggerRunLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+// src/integrations.ts
+function authenticatedTask(options) {
+  return options;
+}
+__name(authenticatedTask, "authenticatedTask");
 
-// src/logger.ts
-var ContextLogger = class {
-  constructor(callback) {
-    this.callback = callback;
+// src/triggers/externalSource.ts
+var ExternalSource = class {
+  constructor(channel, options) {
+    this.options = options;
+    this.channel = channel;
   }
-  debug(message, properties) {
-    return this.callback("DEBUG", message, properties);
+  async handle(source, rawEvent, logger) {
+    return this.options.handler({
+      source: {
+        ...source,
+        params: source.params
+      },
+      rawEvent
+    }, logger);
   }
-  info(message, properties) {
-    return this.callback("INFO", message, properties);
+  filter(params) {
+    return this.options.filter(params);
   }
-  warn(message, properties) {
-    return this.callback("WARN", message, properties);
+  properties(params) {
+    return this.options.properties?.(params) ?? [];
   }
-  error(message, properties) {
-    return this.callback("ERROR", message, properties);
+  async register(params, registerEvent, io, ctx) {
+    const { result: event, ommited: source } = omit(registerEvent, "source");
+    const { result: sourceWithoutChannel, ommited: channel } = omit(source, "channel");
+    const { result: channelWithoutType } = omit(channel, "type");
+    const updates = await this.options.register({
+      ...event,
+      source: {
+        ...sourceWithoutChannel,
+        ...channelWithoutType
+      },
+      params
+    }, io, ctx);
+    return updates;
   }
-};
-__name(ContextLogger, "ContextLogger");
-
-// src/client.ts
-var import_zod_error = require("zod-error");
-var import_promises = require("fs/promises");
-
-// src/keyValueStorage.ts
-var ContextKeyValueStorage = class {
-  constructor(namespace, onGet, onSet, onDelete) {
-    this.namespace = namespace;
-    this.onGet = onGet;
-    this.onSet = onSet;
-    this.onDelete = onDelete;
-    this.getCount = 0;
-    this.setCount = 0;
-    this.deleteCount = 0;
-  }
-  get(key) {
-    const operation = {
-      key,
-      namespace: this.namespace,
-      idempotencyKey: `get:${this.namespace}:${key}:${this.getCount++}`
-    };
-    return this.onGet(operation);
-  }
-  set(key, value) {
-    const operation = {
-      key,
-      namespace: this.namespace,
-      idempotencyKey: `set:${this.namespace}:${key}:${this.setCount++}`,
-      value
-    };
-    return this.onSet(operation);
+  key(params) {
+    const parts = [
+      this.options.id,
+      this.channel
+    ];
+    parts.push(this.options.key(params));
+    parts.push(this.integration.id);
+    return parts.join("-");
+  }
+  get integration() {
+    return this.options.integration;
   }
-  delete(key) {
-    const operation = {
-      key,
-      namespace: this.namespace,
-      idempotencyKey: `delete:${this.namespace}:${key}:${this.deleteCount++}`
+  get integrationConfig() {
+    return {
+      id: this.integration.id,
+      metadata: this.integration.metadata
     };
-    return this.onDelete(operation);
   }
-};
-__name(ContextKeyValueStorage, "ContextKeyValueStorage");
-
-// src/client.ts
-var zodErrorMessageOptions = {
-  delimiter: {
-    error: " \u{1F525} "
+  get id() {
+    return this.options.id;
+  }
+  get version() {
+    return this.options.version;
   }
 };
-var _trigger, _options, _connection2, _serverRPC, _apiKey, _endpoint, _isConnected, _retryIntervalMs, _logger3, _closedByUser, _registerResponse, _responseCompleteCallbacks, _waitForCallbacks, _fetchCallbacks, _runOnceCallbacks, _kvGetCallbacks, _kvSetCallbacks, _kvDeleteCallbacks, _initializeConnection, initializeConnection_fn, _initializeRPC, initializeRPC_fn, _initializeHost, initializeHost_fn, _send, send_fn;
-var TriggerClient = class {
-  constructor(trigger, options) {
-    __privateAdd(this, _initializeConnection);
-    __privateAdd(this, _initializeRPC);
-    __privateAdd(this, _initializeHost);
-    __privateAdd(this, _send);
-    __privateAdd(this, _trigger, void 0);
-    __privateAdd(this, _options, void 0);
-    __privateAdd(this, _connection2, void 0);
-    __privateAdd(this, _serverRPC, void 0);
-    __privateAdd(this, _apiKey, void 0);
-    __privateAdd(this, _endpoint, void 0);
-    __privateAdd(this, _isConnected, false);
-    __privateAdd(this, _retryIntervalMs, 3e3);
-    __privateAdd(this, _logger3, void 0);
-    __privateAdd(this, _closedByUser, false);
-    __privateAdd(this, _registerResponse, void 0);
-    __privateAdd(this, _responseCompleteCallbacks, /* @__PURE__ */ new Map());
-    __privateAdd(this, _waitForCallbacks, /* @__PURE__ */ new Map());
-    __privateAdd(this, _fetchCallbacks, /* @__PURE__ */ new Map());
-    __privateAdd(this, _runOnceCallbacks, /* @__PURE__ */ new Map());
-    __privateAdd(this, _kvGetCallbacks, /* @__PURE__ */ new Map());
-    __privateAdd(this, _kvSetCallbacks, /* @__PURE__ */ new Map());
-    __privateAdd(this, _kvDeleteCallbacks, /* @__PURE__ */ new Map());
-    __privateSet(this, _trigger, trigger);
-    __privateSet(this, _options, options);
-    const apiKey = __privateGet(this, _options).apiKey ?? process.env.TRIGGER_API_KEY;
-    if (!apiKey) {
-      throw new Error("Cannot connect to Trigger because of invalid API Key: Please include an API Key in the `apiKey` option or in the `TRIGGER_API_KEY` environment variable.");
-    }
-    __privateSet(this, _apiKey, apiKey);
-    __privateSet(this, _endpoint, __privateGet(this, _options).endpoint ?? process.env.TRIGGER_WSS_URL ?? "wss://wss.trigger.dev/ws");
-    __privateSet(this, _logger3, new Logger([
-      "trigger.dev",
-      __privateGet(this, _options).id
-    ], __privateGet(this, _options).logLevel));
-  }
-  async listen(instanceId) {
-    try {
-      await __privateMethod(this, _initializeConnection, initializeConnection_fn).call(this, instanceId);
-      __privateMethod(this, _initializeRPC, initializeRPC_fn).call(this);
-      await __privateMethod(this, _initializeHost, initializeHost_fn).call(this);
-      const terminalLink = (await import("terminal-link")).default;
-      if (__privateGet(this, _registerResponse)?.isNew) {
-        __privateGet(this, _logger3).logClean(`\u{1F389} Successfully registered "${__privateGet(this, _trigger).name}" to trigger.dev \u{1F449} ${terminalLink("View on dashboard", __privateGet(this, _registerResponse).url, {
-          fallback: (text, url) => `${text}: (${url})`
-        })}. Listening for events...`);
-      } else {
-        __privateGet(this, _logger3).log(`\u2728 Connected and listening for events \u{1F449} ${terminalLink("View on dashboard", __privateGet(this, _registerResponse).url, {
-          fallback: (text, url) => `${text}: (${url})`
-        })}`);
-      }
-    } catch (error) {
-      __privateGet(this, _logger3).log(`\u{1F6A9} Could not connect to trigger.dev`);
-      this.close();
-    }
+__name(ExternalSource, "ExternalSource");
+var ExternalSourceTrigger = class {
+  constructor(options) {
+    this.options = options;
   }
-  close() {
-    __privateSet(this, _closedByUser, true);
-    if (__privateGet(this, _serverRPC)) {
-      __privateSet(this, _serverRPC, void 0);
-    }
-    __privateGet(this, _connection2)?.close();
-    __privateSet(this, _isConnected, false);
+  get event() {
+    return this.options.event;
+  }
+  toJSON() {
+    return {
+      type: "static",
+      title: "External Source",
+      rule: {
+        event: this.event.name,
+        payload: deepMergeFilters(this.options.source.filter(this.options.params), this.event.filter ?? {}),
+        source: this.event.source
+      },
+      properties: this.options.source.properties(this.options.params)
+    };
+  }
+  attachToJob(triggerClient, job) {
+    triggerClient.attachSource({
+      key: slugifyId(this.options.source.key(this.options.params)),
+      source: this.options.source,
+      event: this.options.event,
+      params: this.options.params
+    });
+  }
+  get preprocessRuns() {
+    return true;
   }
 };
-__name(TriggerClient, "TriggerClient");
-_trigger = new WeakMap();
-_options = new WeakMap();
-_connection2 = new WeakMap();
-_serverRPC = new WeakMap();
-_apiKey = new WeakMap();
-_endpoint = new WeakMap();
-_isConnected = new WeakMap();
-_retryIntervalMs = new WeakMap();
-_logger3 = new WeakMap();
-_closedByUser = new WeakMap();
-_registerResponse = new WeakMap();
-_responseCompleteCallbacks = new WeakMap();
-_waitForCallbacks = new WeakMap();
-_fetchCallbacks = new WeakMap();
-_runOnceCallbacks = new WeakMap();
-_kvGetCallbacks = new WeakMap();
-_kvSetCallbacks = new WeakMap();
-_kvDeleteCallbacks = new WeakMap();
-_initializeConnection = new WeakSet();
-initializeConnection_fn = /* @__PURE__ */ __name(async function(instanceId) {
-  const id = instanceId ?? (0, import_uuid2.v4)();
-  __privateGet(this, _logger3).debug("Initializing connection", {
-    id,
-    endpoint: __privateGet(this, _endpoint)
-  });
-  const headers = {
-    Authorization: `Bearer ${__privateGet(this, _apiKey)}`
+__name(ExternalSourceTrigger, "ExternalSourceTrigger");
+function omit(obj, key) {
+  const result = {};
+  for (const k of Object.keys(obj)) {
+    if (k === key)
+      continue;
+    result[k] = obj[k];
+  }
+  return {
+    result,
+    ommited: obj[key]
   };
-  const connection = new HostConnection(new import_ws.WebSocket(__privateGet(this, _endpoint), {
-    headers,
-    followRedirects: true
-  }), {
-    id
-  });
-  connection.onClose.attach(async ([code, reason]) => {
-    if (__privateGet(this, _closedByUser)) {
-      __privateGet(this, _logger3).debug("Connection closed by user, so we won't reconnect");
-      __privateSet(this, _closedByUser, false);
-      return;
-    }
-    const chalk = (await import("chalk")).default;
-    __privateGet(this, _logger3).error(`${chalk.red("error")} Could not connect to trigger.dev${reason ? `: ${reason}` : `(code ${code})`}`);
-    if (!__privateGet(this, _isConnected))
-      return;
-    __privateGet(this, _logger3).log("\u{1F50C} Reconnecting to trigger.dev...");
-    __privateSet(this, _isConnected, false);
-    while (!__privateGet(this, _isConnected)) {
-      __privateMethod(this, _initializeConnection, initializeConnection_fn).call(this, id).then(() => {
-        __privateGet(this, _logger3).log("\u26A1 Reconnection successful");
-      }).catch(() => {
-      });
-      __privateGet(this, _logger3).debug(`Reconnection failed, retrying in ${Math.round(__privateGet(this, _retryIntervalMs) / 1e3)} seconds`, id);
-      await new Promise((resolve) => setTimeout(resolve, __privateGet(this, _retryIntervalMs)));
-    }
-  });
-  await connection.connect();
-  __privateGet(this, _logger3).debug("Connection initialized", id);
-  __privateSet(this, _connection2, connection);
-  __privateSet(this, _isConnected, true);
-  if (__privateGet(this, _serverRPC)) {
-    __privateGet(this, _serverRPC).resetConnection(connection);
-    await __privateMethod(this, _initializeHost, initializeHost_fn).call(this);
-  }
-}, "#initializeConnection");
-_initializeRPC = new WeakSet();
-initializeRPC_fn = /* @__PURE__ */ __name(async function() {
-  if (!__privateGet(this, _connection2)) {
-    throw new Error("Cannot initialize RPC without a connection");
-  }
-  const serverRPC = new ZodRPC({
-    connection: __privateGet(this, _connection2),
-    sender: ServerRPCSchema,
-    receiver: HostRPCSchema,
-    handlers: {
-      RESOLVE_DELAY: async (data) => {
-        __privateGet(this, _logger3).debug("Handling RESOLVE_DELAY", data);
-        const waitCallbacks = __privateGet(this, _waitForCallbacks).get(messageKey(data.meta.runId, data.key));
-        if (!waitCallbacks) {
-          __privateGet(this, _logger3).debug(`Could not find wait callbacks for wait ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
-          return true;
-        }
-        const { resolve } = waitCallbacks;
-        resolve();
-        return true;
-      },
-      RESOLVE_RUN_ONCE: async (data) => {
-        __privateGet(this, _logger3).debug("Handling RESOLVE_RUN_ONCE", data);
-        const runOnceCallbacks = __privateGet(this, _runOnceCallbacks).get(messageKey(data.meta.runId, data.key));
-        if (!runOnceCallbacks) {
-          __privateGet(this, _logger3).debug(`Could not find runOnce callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
-          return true;
-        }
-        const { resolve } = runOnceCallbacks;
-        resolve(data.output);
-        return true;
-      },
-      RESOLVE_REQUEST: async (data) => {
-        __privateGet(this, _logger3).debug("Handling RESOLVE_REQUEST", data);
-        const requestCallbacks = __privateGet(this, _responseCompleteCallbacks).get(messageKey(data.meta.runId, data.key));
-        if (!requestCallbacks) {
-          __privateGet(this, _logger3).debug(`Could not find request callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
-          return true;
-        }
-        const { resolve } = requestCallbacks;
-        resolve(data.output);
-        return true;
-      },
-      REJECT_REQUEST: async (data) => {
-        __privateGet(this, _logger3).debug("Handling REJECT_REQUEST", data);
-        const requestCallbacks = __privateGet(this, _responseCompleteCallbacks).get(messageKey(data.meta.runId, data.key));
-        if (!requestCallbacks) {
-          __privateGet(this, _logger3).debug(`Could not find request callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
-          return true;
-        }
-        const { reject } = requestCallbacks;
-        reject(data.error);
-        return true;
-      },
-      RESOLVE_FETCH_REQUEST: async (data) => {
-        __privateGet(this, _logger3).debug("Handling RESOLVE_FETCH_REQUEST", data);
-        const fetchCallbacks = __privateGet(this, _fetchCallbacks).get(messageKey(data.meta.runId, data.key));
-        if (!fetchCallbacks) {
-          __privateGet(this, _logger3).debug(`Could not find fetch callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
-          return true;
-        }
-        const { resolve } = fetchCallbacks;
-        resolve(data.output);
-        return true;
-      },
-      REJECT_FETCH_REQUEST: async (data) => {
-        __privateGet(this, _logger3).debug("Handling REJECT_FETCH_REQUEST", data);
-        const fetchCallbacks = __privateGet(this, _fetchCallbacks).get(messageKey(data.meta.runId, data.key));
-        if (!fetchCallbacks) {
-          __privateGet(this, _logger3).debug(`Could not find fetch callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
-          return true;
-        }
-        const { reject } = fetchCallbacks;
-        reject(data.error);
-        return true;
-      },
-      RESOLVE_KV_GET: async (data) => {
-        __privateGet(this, _logger3).debug("Handling RESOLVE_KV_GET", data);
-        const getCallbacks = __privateGet(this, _kvGetCallbacks).get(messageKey(data.meta.runId, data.key));
-        if (!getCallbacks) {
-          __privateGet(this, _logger3).debug(`Could not find kvGet callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
-          return true;
-        }
-        const { resolve } = getCallbacks;
-        resolve(data.output);
-        return true;
-      },
-      RESOLVE_KV_SET: async (data) => {
-        __privateGet(this, _logger3).debug("Handling RESOLVE_KV_SET", data);
-        const setCallbacks = __privateGet(this, _kvSetCallbacks).get(messageKey(data.meta.runId, data.key));
-        if (!setCallbacks) {
-          __privateGet(this, _logger3).debug(`Could not find kvSet callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
-          return true;
-        }
-        const { resolve } = setCallbacks;
-        resolve();
-        return true;
-      },
-      RESOLVE_KV_DELETE: async (data) => {
-        __privateGet(this, _logger3).debug("Handling RESOLVE_KV_DELETE", data);
-        const deleteCallbacks = __privateGet(this, _kvDeleteCallbacks).get(messageKey(data.meta.runId, data.key));
-        if (!deleteCallbacks) {
-          __privateGet(this, _logger3).debug(`Could not find kvDelete callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
-          return true;
-        }
-        const { resolve } = deleteCallbacks;
-        resolve();
-        return true;
+}
+__name(omit, "omit");
+
+// src/triggers/dynamic.ts
+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) {
+    return {
+      rule: {
+        event: this.event.name,
+        source: this.event.source,
+        payload: deepMergeFilters(this.source.filter(params), this.event.filter ?? {})
       },
-      TRIGGER_WORKFLOW: async (data) => {
-        __privateGet(this, _logger3).debug("Handling TRIGGER_WORKFLOW", data);
-        const parsedEventData = __privateGet(this, _options).on.schema.safeParse(data.trigger.input);
-        if (!parsedEventData.success) {
-          await serverRPC.send("SEND_WORKFLOW_ERROR", {
-            runId: data.id,
-            timestamp: String(highPrecisionTimestamp()),
-            error: {
-              name: "Event validation error",
-              message: (0, import_zod_error.generateErrorMessage)(parsedEventData.error.issues, zodErrorMessageOptions)
-            }
-          });
-          return true;
-        }
-        const fetchFunction = /* @__PURE__ */ __name(async (key, url, options) => {
-          const result = new Promise((resolve, reject) => {
-            __privateGet(this, _fetchCallbacks).set(messageKey(data.id, key), {
-              resolve,
-              reject
-            });
-          });
-          await serverRPC.send("SEND_FETCH", {
-            runId: data.id,
-            key,
-            fetch: {
-              url: url.toString(),
-              method: options.method ?? "GET",
-              headers: options.headers,
-              body: options.body,
-              retry: options.retry
-            },
-            timestamp: String(highPrecisionTimestamp())
-          });
-          const response = await result;
-          return {
-            status: response.status,
-            ok: response.ok,
-            headers: response.headers,
-            body: response.body ? (options.responseSchema ?? import_zod15.z.any()).parse(response.body) : void 0
-          };
-        }, "fetchFunction");
-        const kvGetFunction = /* @__PURE__ */ __name(async (op) => {
-          const result = new Promise((resolve, reject) => {
-            __privateGet(this, _kvGetCallbacks).set(messageKey(data.id, op.idempotencyKey), {
-              resolve,
-              reject
-            });
-          });
-          await serverRPC.send("SEND_KV_GET", {
-            runId: data.id,
-            key: op.idempotencyKey,
-            get: {
-              namespace: op.namespace,
-              key: op.key
-            },
-            timestamp: String(highPrecisionTimestamp())
-          });
-          const output = await result;
-          return output;
-        }, "kvGetFunction");
-        const kvSetFunction = /* @__PURE__ */ __name(async (op) => {
-          const result = new Promise((resolve, reject) => {
-            __privateGet(this, _kvSetCallbacks).set(messageKey(data.id, op.idempotencyKey), {
-              resolve,
-              reject
-            });
-          });
-          await serverRPC.send("SEND_KV_SET", {
-            runId: data.id,
-            key: op.idempotencyKey,
-            set: {
-              namespace: op.namespace,
-              key: op.key,
-              value: op.value
-            },
-            timestamp: String(highPrecisionTimestamp())
-          });
-          await result;
-          return;
-        }, "kvSetFunction");
-        const kvDeleteFunction = /* @__PURE__ */ __name(async (op) => {
-          const result = new Promise((resolve, reject) => {
-            __privateGet(this, _kvDeleteCallbacks).set(messageKey(data.id, op.idempotencyKey), {
-              resolve,
-              reject
-            });
-          });
-          await serverRPC.send("SEND_KV_DELETE", {
-            runId: data.id,
-            key: op.idempotencyKey,
-            delete: {
-              namespace: op.namespace,
-              key: op.key
-            },
-            timestamp: String(highPrecisionTimestamp())
-          });
-          await result;
-          return;
-        }, "kvDeleteFunction");
-        const ctx = {
-          id: data.id,
-          environment: data.meta.environment,
-          apiKey: data.meta.apiKey,
-          organizationId: data.meta.organizationId,
-          isTest: data.meta.isTest,
-          kv: new ContextKeyValueStorage(`workflow:${data.meta.workflowId}`, kvGetFunction, kvSetFunction, kvDeleteFunction),
-          globalKv: new ContextKeyValueStorage(`org:${data.meta.organizationId}`, kvGetFunction, kvSetFunction, kvDeleteFunction),
-          runKv: new ContextKeyValueStorage(`run:${data.id}`, kvGetFunction, kvSetFunction, kvDeleteFunction),
-          logger: new ContextLogger(async (level, message, properties) => {
-            await serverRPC.send("SEND_LOG", {
-              runId: data.id,
-              key: message,
-              log: {
-                level,
-                message,
-                properties: JSON.stringify(properties ?? {})
-              },
-              timestamp: String(highPrecisionTimestamp())
-            });
-          }),
-          sendEvent: async (key, event) => {
-            await serverRPC.send("SEND_EVENT", {
-              runId: data.id,
-              key,
-              event: JSON.parse(JSON.stringify(event)),
-              timestamp: String(highPrecisionTimestamp())
-            });
-          },
-          waitFor: async (key, options) => {
-            const result = new Promise((resolve, reject) => {
-              __privateGet(this, _waitForCallbacks).set(messageKey(data.id, key), {
-                resolve,
-                reject
-              });
-            });
-            await serverRPC.send("INITIALIZE_DELAY", {
-              runId: data.id,
-              key,
-              wait: {
-                type: "DELAY",
-                seconds: options.seconds,
-                minutes: options.minutes,
-                hours: options.hours,
-                days: options.days
-              },
-              timestamp: String(highPrecisionTimestamp())
-            });
-            await result;
-            return;
-          },
-          waitUntil: async (key, date) => {
-            const result = new Promise((resolve, reject) => {
-              __privateGet(this, _waitForCallbacks).set(messageKey(data.id, key), {
-                resolve,
-                reject
-              });
-            });
-            await serverRPC.send("INITIALIZE_DELAY", {
-              runId: data.id,
-              key,
-              wait: {
-                type: "SCHEDULE_FOR",
-                scheduledFor: date.toISOString()
-              },
-              timestamp: String(highPrecisionTimestamp())
-            });
-            await result;
-            return;
-          },
-          runOnce: async (key, callback) => {
-            const result = new Promise((resolve, reject) => {
-              __privateGet(this, _runOnceCallbacks).set(messageKey(data.id, key), {
-                resolve,
-                reject
-              });
-            });
-            await serverRPC.send("INITIALIZE_RUN_ONCE", {
-              runId: data.id,
-              key,
-              runOnce: {
-                type: "REMOTE"
-              },
-              timestamp: String(highPrecisionTimestamp())
-            });
-            const { idempotencyKey, hasRun, output } = await result;
-            if (hasRun) {
-              return output;
-            }
-            const callbackResult = await callback(idempotencyKey);
-            await serverRPC.send("COMPLETE_RUN_ONCE", {
-              runId: data.id,
-              key,
-              runOnce: {
-                type: "REMOTE",
-                idempotencyKey,
-                output: callbackResult ? JSON.stringify(callbackResult) : void 0
-              },
-              timestamp: String(highPrecisionTimestamp())
-            });
-            return callbackResult;
-          },
-          runOnceLocalOnly: async (key, callback) => {
-            const result = new Promise((resolve, reject) => {
-              __privateGet(this, _runOnceCallbacks).set(messageKey(data.id, key), {
-                resolve,
-                reject
-              });
-            });
-            await serverRPC.send("INITIALIZE_RUN_ONCE", {
-              runId: data.id,
-              key,
-              runOnce: {
-                type: "LOCAL_ONLY"
-              },
-              timestamp: String(highPrecisionTimestamp())
-            });
-            const { idempotencyKey } = await result;
-            return callback(idempotencyKey);
-          },
-          fetch: fetchFunction
-        };
-        const eventData = parsedEventData.data;
-        __privateGet(this, _logger3).debug("Parsed event data", eventData);
-        const terminalLink = (await import("terminal-link")).default;
-        triggerRunLocalStorage.run({
-          performRequest: async (key, options) => {
-            const result = new Promise((resolve, reject) => {
-              __privateGet(this, _responseCompleteCallbacks).set(messageKey(data.id, key), {
-                resolve,
-                reject
-              });
-            });
-            await serverRPC.send("SEND_REQUEST", {
-              runId: data.id,
-              key,
-              request: {
-                service: options.service,
-                endpoint: options.endpoint,
-                params: options.params,
-                version: options.version
-              },
-              timestamp: String(highPrecisionTimestamp())
-            });
-            const output = await result;
-            if (!options.response?.schema) {
-              return output;
-            }
-            return options.response.schema.parse(output);
-          },
-          sendEvent: async (key, event) => {
-            await serverRPC.send("SEND_EVENT", {
-              runId: data.id,
-              key,
-              event: JSON.parse(JSON.stringify(event)),
-              timestamp: String(highPrecisionTimestamp())
-            });
-          },
-          fetch: fetchFunction,
-          workflowId: data.meta.workflowId,
-          appOrigin: data.meta.appOrigin,
-          id: data.id
-        }, () => {
-          __privateGet(this, _logger3).debug("Running trigger...");
-          if (typeof data.meta.attempt === "number" && data.meta.attempt === 0) {
-            __privateGet(this, _logger3).log(`Run ${data.id} started \u{1F449} ${terminalLink("View on dashboard", `${__privateGet(this, _registerResponse).url}/runs/${data.id}`, {
-              fallback: (text, url) => `${text}: (${url})`
-            })}`);
-          }
-          serverRPC.send("START_WORKFLOW_RUN", {
-            runId: data.id,
-            timestamp: String(highPrecisionTimestamp())
-          }).then(() => {
-            return __privateGet(this, _trigger).options.run(eventData, ctx).then((output) => {
-              __privateGet(this, _logger3).log(`Run ${data.id} complete \u{1F449} ${terminalLink("View on dashboard", `${__privateGet(this, _registerResponse).url}/runs/${data.id}`, {
-                fallback: (text, url) => `${text}: (${url})`
-              })}`);
-              return serverRPC.send("COMPLETE_WORKFLOW_RUN", {
-                runId: data.id,
-                output: JSON.stringify(output),
-                timestamp: String(highPrecisionTimestamp())
-              });
-            }).catch((anyError) => {
-              const parseAnyError = /* @__PURE__ */ __name((error2) => {
-                if (error2 instanceof Error) {
-                  return {
-                    name: error2.name,
-                    message: error2.message,
-                    stackTrace: error2.stack
-                  };
-                }
-                const parsedError = import_zod15.z.object({
-                  name: import_zod15.z.string(),
-                  message: import_zod15.z.string()
-                }).passthrough().safeParse(error2);
-                if (parsedError.success) {
-                  return parsedError.data;
-                }
-                return {
-                  name: "UnknownError",
-                  message: "An unknown error occurred"
-                };
-              }, "parseAnyError");
-              const error = parseAnyError(anyError);
-              return serverRPC.send("SEND_WORKFLOW_ERROR", {
-                runId: data.id,
-                error,
-                timestamp: String(highPrecisionTimestamp())
-              });
-            });
-          }).catch((anyError) => {
-            return serverRPC.send("SEND_WORKFLOW_ERROR", {
-              runId: data.id,
-              error: anyError,
-              timestamp: String(highPrecisionTimestamp())
-            });
-          });
-        });
-        return true;
-      }
-    }
-  });
-  __privateGet(this, _logger3).debug("Successfully initialized RPC with server");
-  __privateSet(this, _serverRPC, serverRPC);
-}, "#initializeRPC");
-_initializeHost = new WeakSet();
-initializeHost_fn = /* @__PURE__ */ __name(async function() {
-  if (!__privateGet(this, _connection2)) {
-    throw new Error("Cannot initialize host without a connection");
-  }
-  if (!__privateGet(this, _serverRPC)) {
-    throw new Error("Cannot initialize host without an RPC connection");
-  }
-  const repoInfo = await safeGetRepoInfo();
-  const remoteUrl = repoInfo ? await getRemoteUrl(repoInfo.commonGitDir) : void 0;
-  const packageMetadata = await getTriggerPackageEnvVars(process.env);
-  const response = await __privateMethod(this, _send, send_fn).call(this, "INITIALIZE_HOST_V2", {
-    apiKey: __privateGet(this, _apiKey),
-    workflowId: __privateGet(this, _trigger).id,
-    workflowName: __privateGet(this, _trigger).name,
-    trigger: __privateGet(this, _trigger).on.metadata,
-    packageVersion: version,
-    packageName: name,
-    triggerTTL: __privateGet(this, _options).triggerTTL,
-    metadata: {
-      git: repoInfo ? {
-        sha: repoInfo.sha,
-        branch: repoInfo.branch,
-        committer: repoInfo.committer,
-        committerDate: repoInfo.committerDate,
-        commitMessage: repoInfo.commitMessage,
-        origin: remoteUrl
-      } : void 0,
-      packageMetadata,
-      env: gatherEnvVars(process.env)
-    }
-  });
-  if (!response) {
-    throw new Error("Could not initialize workflow with server");
-  }
-  if (response?.type === "error") {
-    throw new Error(response.message);
-  }
-  __privateSet(this, _registerResponse, response.data);
-  __privateGet(this, _logger3).debug("Successfully initialized workflow with server");
-}, "#initializeHost");
-_send = new WeakSet();
-send_fn = /* @__PURE__ */ __name(async function(methodName, request) {
-  if (!__privateGet(this, _serverRPC))
-    throw new Error("serverRPC not initialized");
-  while (true) {
-    try {
-      __privateGet(this, _logger3).debug(`Sending RPC request to server: ${methodName}`, request);
-      return await __privateGet(this, _serverRPC).send(methodName, request);
-    } catch (err) {
-      if (err instanceof TimeoutError) {
-        __privateGet(this, _logger3).log(`RPC call timed out, retrying in ${Math.round(__privateGet(this, _retryIntervalMs) / 1e3)}s...`);
-        __privateGet(this, _logger3).error(err);
-        await sleep(__privateGet(this, _retryIntervalMs));
-      } else {
-        throw err;
+      source: {
+        key: slugifyId(this.source.key(params)),
+        channel: this.source.channel,
+        params,
+        events: [
+          this.event.name
+        ],
+        clientId: !this.source.integration.usesLocalAuth ? this.source.integration.id : void 0
       }
-    }
+    };
   }
-}, "#send");
-var sleep = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "sleep");
-var messageKey = /* @__PURE__ */ __name((runId, key) => `${runId}:${key}`, "messageKey");
-function highPrecisionTimestamp() {
-  const [seconds, nanoseconds] = process.hrtime();
-  return seconds * 1e9 + nanoseconds;
-}
-__name(highPrecisionTimestamp, "highPrecisionTimestamp");
-async function getTriggerPackageEnvVars(env) {
-  if (!env) {
-    return {};
-  }
-  if (env.npm_package_json) {
-    try {
-      const packageJson = JSON.parse(await (0, import_promises.readFile)(env.npm_package_json, "utf8"));
-      if (packageJson.triggerdotdev) {
-        return packageJson.triggerdotdev;
-      }
-    } catch (err) {
-    }
+  async register(key, params) {
+    return __privateGet(this, _client2).registerTrigger(this.id, key, this.registeredTriggerForParams(params));
   }
-  const envVars = Object.entries(env).filter(([key]) => key.startsWith("npm_package_triggerdotdev_")).map(([key, value]) => [
-    key.replace("npm_package_triggerdotdev_", ""),
-    value
-  ]);
-  return Object.fromEntries(envVars);
-}
-__name(getTriggerPackageEnvVars, "getTriggerPackageEnvVars");
-async function getRemoteUrl(cwd) {
-  try {
-    const gitRemoteOriginUrl = (await import("git-remote-origin-url")).default;
-    return await gitRemoteOriginUrl({
-      cwd
-    });
-  } catch (err) {
-    return;
+  attachToJob(triggerClient, job) {
+    triggerClient.attachJobToDynamicTrigger(job, this);
   }
-}
-__name(getRemoteUrl, "getRemoteUrl");
-async function safeGetRepoInfo() {
-  try {
-    const gitRepoInfo = (await import("git-repo-info")).default;
-    return gitRepoInfo();
-  } catch (err) {
-    return;
+  get preprocessRuns() {
+    return false;
   }
-}
-__name(safeGetRepoInfo, "safeGetRepoInfo");
-function gatherEnvVars(env) {
-  if (!env) {
-    return {};
-  }
-  const envVars = Object.entries(env).filter(([key]) => key.startsWith("TRIGGER_") && key !== "TRIGGER_API_KEY").map(([key, value]) => [
-    key.replace("TRIGGER_", ""),
-    `${value}`
-  ]);
-  return Object.fromEntries(envVars);
-}
-__name(gatherEnvVars, "gatherEnvVars");
+};
+__name(DynamicTrigger, "DynamicTrigger");
+_client2 = new WeakMap();
+_options4 = new WeakMap();
 
-// src/trigger/index.ts
-var _client, _getApiKey, getApiKey_fn;
-var Trigger = class {
+// src/triggers/scheduled.ts
+var IntervalTrigger = class {
   constructor(options) {
-    __privateAdd(this, _getApiKey);
-    __privateAdd(this, _client, void 0);
     this.options = options;
   }
-  async listen() {
-    const apiKey = __privateMethod(this, _getApiKey, getApiKey_fn).call(this);
-    const chalk = (await import("chalk")).default;
-    const terminalLink = (await import("terminal-link")).default;
-    if (apiKey.status === "invalid") {
-      console.log(`${chalk.red("Trigger.dev error")}: ${chalk.bold(this.id)} is has an invalid API key ("${chalk.italic(apiKey.apiKey)}"), please set the TRIGGER_API_KEY environment variable or pass the apiKey option to a valid value. ${terminalLink("Get your API key here", "https://app.trigger.dev", {
-        fallback(text, url) {
-          return `${text} \u{1F449} ${url}`;
+  get event() {
+    return {
+      name: "trigger.scheduled",
+      title: "Schedule",
+      source: "trigger.dev",
+      icon: "schedule-interval",
+      parsePayload: ScheduledPayloadSchema.parse,
+      properties: [
+        {
+          label: "Interval",
+          text: `${this.options.seconds}s`
         }
-      })}`);
-      return;
-    } else if (apiKey.status === "missing") {
-      console.log(`${chalk.red("Trigger.dev error")}: ${chalk.bold(this.id)} is missing an API key, please set the TRIGGER_API_KEY environment variable or pass the apiKey option to the Trigger constructor. ${terminalLink("Get your API key here", "https://app.trigger.dev", {
-        fallback(text, url) {
-          return `${text} \u{1F449} ${url}`;
+      ]
+    };
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  toJSON() {
+    return {
+      type: "scheduled",
+      schedule: {
+        type: "interval",
+        options: {
+          seconds: this.options.seconds
         }
-      })}`);
-      return;
-    }
-    if (!__privateGet(this, _client)) {
-      __privateSet(this, _client, new TriggerClient(this, this.options));
-    }
-    return __privateGet(this, _client).listen();
+      }
+    };
   }
-  get id() {
-    return this.options.id;
+};
+__name(IntervalTrigger, "IntervalTrigger");
+function intervalTrigger(options) {
+  return new IntervalTrigger(options);
+}
+__name(intervalTrigger, "intervalTrigger");
+var CronTrigger = class {
+  constructor(options) {
+    this.options = options;
   }
-  get name() {
-    return this.options.name;
+  get event() {
+    return {
+      name: "trigger.scheduled",
+      title: "Cron Schedule",
+      source: "trigger.dev",
+      icon: "schedule-cron",
+      parsePayload: ScheduledPayloadSchema.parse,
+      properties: [
+        {
+          label: "Expression",
+          text: this.options.cron
+        }
+      ]
+    };
+  }
+  attachToJob(triggerClient, job) {
   }
-  get endpoint() {
-    return this.options.endpoint;
+  get preprocessRuns() {
+    return false;
   }
-  get on() {
-    return this.options.on;
+  toJSON() {
+    return {
+      type: "scheduled",
+      schedule: {
+        type: "cron",
+        options: {
+          cron: this.options.cron
+        }
+      }
+    };
   }
 };
-__name(Trigger, "Trigger");
-_client = new WeakMap();
-_getApiKey = new WeakSet();
-getApiKey_fn = /* @__PURE__ */ __name(function() {
-  const apiKey = this.options.apiKey ?? process.env.TRIGGER_API_KEY;
-  if (!apiKey) {
+__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 {
-      status: "missing"
+      name: "trigger.scheduled",
+      title: "Dynamic Schedule",
+      source: "trigger.dev",
+      icon: "schedule-dynamic",
+      parsePayload: ScheduledPayloadSchema.parse
     };
   }
-  const isValid = apiKey.match(/^trigger_[a-z]+_[a-zA-Z0-9]+$/);
-  if (!isValid) {
+  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 {
-      status: "invalid",
-      apiKey
+      type: "dynamic",
+      id: this.options.id
     };
   }
-  return {
-    status: "valid",
-    apiKey
-  };
-}, "#getApiKey");
+};
+__name(DynamicSchedule, "DynamicSchedule");
 
-// src/customEvents.ts
-var import_node_fetch = __toESM(require("node-fetch"));
-function sendEvent(idOrKey, event) {
-  const triggerRun = triggerRunLocalStorage.getStore();
-  if (!triggerRun) {
-    return sendEventFetch(idOrKey, event);
-  }
-  return triggerRun.sendEvent(idOrKey, event);
+// src/triggers/notifications.ts
+function missingConnectionNotification(integrations) {
+  return new MissingConnectionNotification({
+    integrations
+  });
 }
-__name(sendEvent, "sendEvent");
-async function sendEventFetch(id, event) {
-  if (!process.env.TRIGGER_API_KEY) {
-    throw new Error(`There was a problem sending a custom event: the TRIGGER_API_KEY environment variable is not set`);
-  }
-  const baseUrl = process.env.TRIGGER_API_URL || "https://app.trigger.dev";
-  const url = `${baseUrl}/api/v1/events`;
-  const response = await (0, import_node_fetch.default)(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${process.env.TRIGGER_API_KEY}`
-    },
-    body: JSON.stringify({
-      id,
-      event
-    })
+__name(missingConnectionNotification, "missingConnectionNotification");
+function missingConnectionResolvedNotification(integrations) {
+  return new MissingConnectionResolvedNotification({
+    integrations
   });
-  if (!response.ok) {
-    throw new Error(`There was a problem sending a custom event: ${response.statusText}`);
-  }
-  return;
 }
-__name(sendEventFetch, "sendEventFetch");
-
-// src/fetch.ts
-function fetch2(key, url, options) {
-  const triggerRun = triggerRunLocalStorage.getStore();
-  if (!triggerRun) {
-    throw new Error("Cannot call fetch outside of a trigger run");
+__name(missingConnectionResolvedNotification, "missingConnectionResolvedNotification");
+var MissingConnectionNotification = class {
+  constructor(options) {
+    this.options = options;
   }
-  return triggerRun.fetch(key, url, options);
-}
-__name(fetch2, "fetch");
+  get event() {
+    return {
+      name: MISSING_CONNECTION_NOTIFICATION,
+      title: "Missing Connection Notification",
+      source: "trigger.dev",
+      icon: "connection-alert",
+      parsePayload: MissingConnectionNotificationPayloadSchema.parse,
+      properties: [
+        {
+          label: "Integrations",
+          text: this.options.integrations.map((i) => i.id).join(", ")
+        }
+      ]
+    };
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  toJSON() {
+    return {
+      type: "static",
+      title: this.event.title,
+      rule: {
+        event: this.event.name,
+        source: "trigger.dev",
+        payload: {
+          client: {
+            id: this.options.integrations.map((i) => i.id)
+          }
+        }
+      }
+    };
+  }
+};
+__name(MissingConnectionNotification, "MissingConnectionNotification");
+var MissingConnectionResolvedNotification = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get event() {
+    return {
+      name: MISSING_CONNECTION_RESOLVED_NOTIFICATION,
+      title: "Missing Connection Resolved Notification",
+      source: "trigger.dev",
+      icon: "connection-alert",
+      parsePayload: MissingConnectionResolvedNotificationPayloadSchema.parse,
+      properties: [
+        {
+          label: "Integrations",
+          text: this.options.integrations.map((i) => i.id).join(", ")
+        }
+      ]
+    };
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+  toJSON() {
+    return {
+      type: "static",
+      title: this.event.title,
+      rule: {
+        event: this.event.name,
+        source: "trigger.dev",
+        payload: {
+          client: {
+            id: this.options.integrations.map((i) => i.id)
+          }
+        }
+      }
+    };
+  }
+};
+__name(MissingConnectionResolvedNotification, "MissingConnectionResolvedNotification");
 
 // src/index.ts
-function getTriggerRun() {
-  return triggerRunLocalStorage.getStore();
-}
-__name(getTriggerRun, "getTriggerRun");
 function secureString(strings, ...interpolations) {
   return {
     __secureString: true,
@@ -2196,13 +2565,27 @@ function secureString(strings, ...interpolations) {
 __name(secureString, "secureString");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Trigger,
-  customEvent,
-  fetch,
-  getTriggerRun,
-  scheduleEvent,
-  secureString,
-  sendEvent,
-  webhookEvent
+  CronTrigger,
+  DynamicSchedule,
+  DynamicTrigger,
+  EventTrigger,
+  ExternalSource,
+  ExternalSourceTrigger,
+  IO,
+  IOLogger,
+  IntervalTrigger,
+  Job,
+  MissingConnectionNotification,
+  MissingConnectionResolvedNotification,
+  ResumeWithTask,
+  TriggerClient,
+  authenticatedTask,
+  cronTrigger,
+  eventTrigger,
+  intervalTrigger,
+  missingConnectionNotification,
+  missingConnectionResolvedNotification,
+  omit,
+  secureString
 });
 //# sourceMappingURL=index.js.map