@trigger.dev/sdk 2.0.0 → 2.0.1

package/dist/index.js

@@ -146,935 +146,13 @@ validate_fn = /* @__PURE__ */ __name(function() {
   }
 }, "#validate");
 
-// ../core/src/logger.ts
-var logLevels = [
-  "log",
-  "error",
-  "warn",
-  "info",
-  "debug"
-];
-var _name, _level, _filteredKeys, _jsonReplacer, _structuredLog, structuredLog_fn;
-var _Logger = class {
-  constructor(name, level = "info", filteredKeys = [], jsonReplacer) {
-    __privateAdd(this, _structuredLog);
-    __privateAdd(this, _name, void 0);
-    __privateAdd(this, _level, void 0);
-    __privateAdd(this, _filteredKeys, []);
-    __privateAdd(this, _jsonReplacer, void 0);
-    __privateSet(this, _name, name);
-    __privateSet(this, _level, logLevels.indexOf(process.env.TRIGGER_LOG_LEVEL ?? level));
-    __privateSet(this, _filteredKeys, filteredKeys);
-    __privateSet(this, _jsonReplacer, jsonReplacer);
-  }
-  filter(...keys) {
-    return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys, __privateGet(this, _jsonReplacer));
-  }
-  static satisfiesLogLevel(logLevel, setLevel) {
-    return logLevels.indexOf(logLevel) <= logLevels.indexOf(setLevel);
-  }
-  log(message, ...args) {
-    if (__privateGet(this, _level) < 0)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, ...args);
-  }
-  error(message, ...args) {
-    if (__privateGet(this, _level) < 1)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, ...args);
-  }
-  warn(message, ...args) {
-    if (__privateGet(this, _level) < 2)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, ...args);
-  }
-  info(message, ...args) {
-    if (__privateGet(this, _level) < 3)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, ...args);
-  }
-  debug(message, ...args) {
-    if (__privateGet(this, _level) < 4)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, ...args);
-  }
-};
-var Logger = _Logger;
-__name(Logger, "Logger");
-_name = new WeakMap();
-_level = new WeakMap();
-_filteredKeys = new WeakMap();
-_jsonReplacer = new WeakMap();
-_structuredLog = new WeakSet();
-structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, ...args) {
-  const structuredLog = {
-    ...structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys)),
-    timestamp: new Date(),
-    name: __privateGet(this, _name),
-    message
-  };
-  loggerFunction(JSON.stringify(structuredLog, createReplacer(__privateGet(this, _jsonReplacer))));
-}, "#structuredLog");
-function createReplacer(replacer) {
-  return (key, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    if (replacer) {
-      return replacer(key, value);
-    }
-    return value;
-  };
-}
-__name(createReplacer, "createReplacer");
-function bigIntReplacer(_key, value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  return value;
-}
-__name(bigIntReplacer, "bigIntReplacer");
-function safeJsonClone(obj) {
-  try {
-    return JSON.parse(JSON.stringify(obj, bigIntReplacer));
-  } catch (e) {
-    return obj;
-  }
-}
-__name(safeJsonClone, "safeJsonClone");
-function structureArgs(args, filteredKeys = []) {
-  if (args.length === 0) {
-    return;
-  }
-  if (args.length === 1 && typeof args[0] === "object") {
-    return filterKeys(JSON.parse(JSON.stringify(args[0], bigIntReplacer)), filteredKeys);
-  }
-  return args;
-}
-__name(structureArgs, "structureArgs");
-function filterKeys(obj, keys) {
-  if (typeof obj !== "object" || obj === null) {
-    return obj;
-  }
-  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);
-  }
-  return filteredObj;
-}
-__name(filterKeys, "filterKeys");
-
-// ../core/src/schemas/api.ts
-var import_ulid = require("ulid");
-var import_zod9 = require("zod");
-
-// ../core/src/schemas/errors.ts
-var import_zod = require("zod");
-var ErrorWithStackSchema = import_zod.z.object({
-  message: import_zod.z.string(),
-  name: import_zod.z.string().optional(),
-  stack: import_zod.z.string().optional()
-});
-
-// ../core/src/schemas/eventFilter.ts
-var import_zod2 = require("zod");
-var EventMatcherSchema = import_zod2.z.union([
-  import_zod2.z.array(import_zod2.z.string()),
-  import_zod2.z.array(import_zod2.z.number()),
-  import_zod2.z.array(import_zod2.z.boolean())
-]);
-var EventFilterSchema = import_zod2.z.lazy(() => import_zod2.z.record(import_zod2.z.union([
-  EventMatcherSchema,
-  EventFilterSchema
-])));
-var EventRuleSchema = import_zod2.z.object({
-  event: import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string())),
-  source: import_zod2.z.string(),
-  payload: EventFilterSchema.optional(),
-  context: EventFilterSchema.optional()
-});
-
-// ../core/src/schemas/integrations.ts
-var import_zod3 = require("zod");
-var ConnectionAuthSchema = import_zod3.z.object({
-  type: import_zod3.z.enum([
-    "oauth2"
-  ]),
-  accessToken: import_zod3.z.string(),
-  scopes: import_zod3.z.array(import_zod3.z.string()).optional(),
-  additionalFields: import_zod3.z.record(import_zod3.z.string()).optional()
-});
-var IntegrationMetadataSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  name: import_zod3.z.string(),
-  instructions: import_zod3.z.string().optional()
-});
-var IntegrationConfigSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  metadata: IntegrationMetadataSchema,
-  authSource: import_zod3.z.enum([
-    "HOSTED",
-    "LOCAL"
-  ])
-});
-
-// ../core/src/schemas/json.ts
-var import_zod4 = require("zod");
-var LiteralSchema = import_zod4.z.union([
-  import_zod4.z.string(),
-  import_zod4.z.number(),
-  import_zod4.z.boolean(),
-  import_zod4.z.null()
-]);
-var DeserializedJsonSchema = import_zod4.z.lazy(() => import_zod4.z.union([
-  LiteralSchema,
-  import_zod4.z.array(DeserializedJsonSchema),
-  import_zod4.z.record(DeserializedJsonSchema)
-]));
-var SerializableSchema = import_zod4.z.union([
-  import_zod4.z.string(),
-  import_zod4.z.number(),
-  import_zod4.z.boolean(),
-  import_zod4.z.null(),
-  import_zod4.z.date(),
-  import_zod4.z.undefined(),
-  import_zod4.z.symbol()
-]);
-var SerializableJsonSchema = import_zod4.z.lazy(() => import_zod4.z.union([
-  SerializableSchema,
-  import_zod4.z.array(SerializableJsonSchema),
-  import_zod4.z.record(SerializableJsonSchema)
-]));
-
-// ../core/src/schemas/properties.ts
-var import_zod5 = require("zod");
-var DisplayPropertySchema = import_zod5.z.object({
-  label: import_zod5.z.string(),
-  text: import_zod5.z.string(),
-  url: import_zod5.z.string().optional()
-});
-var DisplayPropertiesSchema = import_zod5.z.array(DisplayPropertySchema);
-var StyleSchema = import_zod5.z.object({
-  style: import_zod5.z.enum([
-    "normal",
-    "minimal"
-  ]),
-  variant: import_zod5.z.string().optional()
-});
-
-// ../core/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()
-  }))
-});
-
-// ../core/src/schemas/tasks.ts
-var import_zod7 = require("zod");
-var TaskStatusSchema = import_zod7.z.enum([
-  "PENDING",
-  "WAITING",
-  "RUNNING",
-  "COMPLETED",
-  "ERRORED",
-  "CANCELED"
-]);
-var TaskSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  icon: import_zod7.z.string().optional().nullable(),
-  noop: import_zod7.z.boolean(),
-  startedAt: import_zod7.z.coerce.date().optional().nullable(),
-  completedAt: import_zod7.z.coerce.date().optional().nullable(),
-  delayUntil: import_zod7.z.coerce.date().optional().nullable(),
-  status: TaskStatusSchema,
-  description: import_zod7.z.string().optional().nullable(),
-  properties: import_zod7.z.array(DisplayPropertySchema).optional().nullable(),
-  outputProperties: import_zod7.z.array(DisplayPropertySchema).optional().nullable(),
-  params: DeserializedJsonSchema.optional().nullable(),
-  output: DeserializedJsonSchema.optional().nullable(),
-  error: import_zod7.z.string().optional().nullable(),
-  parentId: import_zod7.z.string().optional().nullable(),
-  style: StyleSchema.optional().nullable(),
-  operation: import_zod7.z.string().optional().nullable()
-});
-var ServerTaskSchema = TaskSchema.extend({
-  idempotencyKey: import_zod7.z.string(),
-  attempts: import_zod7.z.number()
-});
-var CachedTaskSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  idempotencyKey: import_zod7.z.string(),
-  status: TaskStatusSchema,
-  noop: import_zod7.z.boolean().default(false),
-  output: DeserializedJsonSchema.optional().nullable(),
-  parentId: import_zod7.z.string().optional().nullable()
-});
-
-// ../core/src/schemas/triggers.ts
-var import_zod8 = require("zod");
-var EventExampleSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  icon: import_zod8.z.string().optional(),
-  name: import_zod8.z.string(),
-  payload: import_zod8.z.any()
-});
-var EventSpecificationSchema = import_zod8.z.object({
-  name: import_zod8.z.string().or(import_zod8.z.array(import_zod8.z.string())),
-  title: import_zod8.z.string(),
-  source: import_zod8.z.string(),
-  icon: import_zod8.z.string(),
-  filter: EventFilterSchema.optional(),
-  properties: import_zod8.z.array(DisplayPropertySchema).optional(),
-  schema: import_zod8.z.any().optional(),
-  examples: import_zod8.z.array(EventExampleSchema).optional()
-});
-var DynamicTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("dynamic"),
-  id: import_zod8.z.string()
-});
-var StaticTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("static"),
-  title: import_zod8.z.union([
-    import_zod8.z.string(),
-    import_zod8.z.array(import_zod8.z.string())
-  ]),
-  properties: import_zod8.z.array(DisplayPropertySchema).optional(),
-  rule: EventRuleSchema
-});
-var ScheduledTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("scheduled"),
-  schedule: ScheduleMetadataSchema
-});
-var TriggerMetadataSchema = import_zod8.z.discriminatedUnion("type", [
-  DynamicTriggerMetadataSchema,
-  StaticTriggerMetadataSchema,
-  ScheduledTriggerMetadataSchema
-]);
-
-// ../core/src/schemas/api.ts
-var UpdateTriggerSourceBodySchema = import_zod9.z.object({
-  registeredEvents: import_zod9.z.array(import_zod9.z.string()),
-  secret: import_zod9.z.string().optional(),
-  data: SerializableJsonSchema.optional()
-});
-var HttpEventSourceSchema = UpdateTriggerSourceBodySchema.extend({
-  id: import_zod9.z.string(),
-  active: import_zod9.z.boolean(),
-  url: import_zod9.z.string().url()
-});
-var RegisterHTTPTriggerSourceBodySchema = import_zod9.z.object({
-  type: import_zod9.z.literal("HTTP"),
-  url: import_zod9.z.string().url()
-});
-var RegisterSMTPTriggerSourceBodySchema = import_zod9.z.object({
-  type: import_zod9.z.literal("SMTP")
-});
-var RegisterSQSTriggerSourceBodySchema = import_zod9.z.object({
-  type: import_zod9.z.literal("SQS")
-});
-var RegisterSourceChannelBodySchema = import_zod9.z.discriminatedUnion("type", [
-  RegisterHTTPTriggerSourceBodySchema,
-  RegisterSMTPTriggerSourceBodySchema,
-  RegisterSQSTriggerSourceBodySchema
-]);
-var REGISTER_SOURCE_EVENT = "dev.trigger.source.register";
-var RegisterTriggerSourceSchema = import_zod9.z.object({
-  key: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  active: import_zod9.z.boolean(),
-  secret: import_zod9.z.string(),
-  data: DeserializedJsonSchema.optional(),
-  channel: RegisterSourceChannelBodySchema,
-  clientId: import_zod9.z.string().optional()
-});
-var RegisterSourceEventSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  source: RegisterTriggerSourceSchema,
-  events: import_zod9.z.array(import_zod9.z.string()),
-  missingEvents: import_zod9.z.array(import_zod9.z.string()),
-  orphanedEvents: import_zod9.z.array(import_zod9.z.string()),
-  dynamicTriggerId: import_zod9.z.string().optional()
-});
-var TriggerSourceSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  key: import_zod9.z.string()
-});
-var HandleTriggerSourceSchema = import_zod9.z.object({
-  key: import_zod9.z.string(),
-  secret: import_zod9.z.string(),
-  data: import_zod9.z.any(),
-  params: import_zod9.z.any()
-});
-var HttpSourceRequestSchema = import_zod9.z.object({
-  url: import_zod9.z.string().url(),
-  method: import_zod9.z.string(),
-  headers: import_zod9.z.record(import_zod9.z.string()),
-  rawBody: import_zod9.z.instanceof(Buffer).optional().nullable()
-});
-var HttpSourceRequestHeadersSchema = import_zod9.z.object({
-  "x-ts-key": import_zod9.z.string(),
-  "x-ts-dynamic-id": import_zod9.z.string().optional(),
-  "x-ts-secret": import_zod9.z.string(),
-  "x-ts-data": import_zod9.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-params": import_zod9.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-http-url": import_zod9.z.string(),
-  "x-ts-http-method": import_zod9.z.string(),
-  "x-ts-http-headers": import_zod9.z.string().transform((s) => import_zod9.z.record(import_zod9.z.string()).parse(JSON.parse(s)))
-});
-var PongSuccessResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(true)
-});
-var PongErrorResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(false),
-  error: import_zod9.z.string()
-});
-var PongResponseSchema = import_zod9.z.discriminatedUnion("ok", [
-  PongSuccessResponseSchema,
-  PongErrorResponseSchema
-]);
-var QueueOptionsSchema = import_zod9.z.object({
-  name: import_zod9.z.string(),
-  maxConcurrent: import_zod9.z.number().optional()
-});
-var JobMetadataSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  version: import_zod9.z.string(),
-  event: EventSpecificationSchema,
-  trigger: TriggerMetadataSchema,
-  integrations: import_zod9.z.record(IntegrationConfigSchema),
-  internal: import_zod9.z.boolean().default(false),
-  queue: import_zod9.z.union([
-    QueueOptionsSchema,
-    import_zod9.z.string()
-  ]).optional(),
-  startPosition: import_zod9.z.enum([
-    "initial",
-    "latest"
-  ]),
-  enabled: import_zod9.z.boolean(),
-  preprocessRuns: import_zod9.z.boolean()
-});
-var SourceMetadataSchema = import_zod9.z.object({
-  channel: import_zod9.z.enum([
-    "HTTP",
-    "SQS",
-    "SMTP"
-  ]),
-  integration: IntegrationConfigSchema,
-  key: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  events: import_zod9.z.array(import_zod9.z.string()),
-  registerSourceJob: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }).optional()
-});
-var DynamicTriggerEndpointMetadataSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  jobs: import_zod9.z.array(JobMetadataSchema.pick({
-    id: true,
-    version: true
-  })),
-  registerSourceJob: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }).optional()
-});
-var IndexEndpointResponseSchema = import_zod9.z.object({
-  jobs: import_zod9.z.array(JobMetadataSchema),
-  sources: import_zod9.z.array(SourceMetadataSchema),
-  dynamicTriggers: import_zod9.z.array(DynamicTriggerEndpointMetadataSchema),
-  dynamicSchedules: import_zod9.z.array(RegisterDynamicSchedulePayloadSchema)
-});
-var RawEventSchema = import_zod9.z.object({
-  name: import_zod9.z.string(),
-  payload: import_zod9.z.any(),
-  context: import_zod9.z.any().optional(),
-  id: import_zod9.z.string().default(() => (0, import_ulid.ulid)()),
-  timestamp: import_zod9.z.coerce.date().optional(),
-  source: import_zod9.z.string().optional()
-});
-var ApiEventLogSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  payload: DeserializedJsonSchema,
-  context: DeserializedJsonSchema.optional().nullable(),
-  timestamp: import_zod9.z.coerce.date(),
-  deliverAt: import_zod9.z.coerce.date().optional().nullable(),
-  deliveredAt: import_zod9.z.coerce.date().optional().nullable()
-});
-var SendEventOptionsSchema = import_zod9.z.object({
-  deliverAt: import_zod9.z.coerce.date().optional(),
-  deliverAfter: import_zod9.z.number().int().optional(),
-  accountId: import_zod9.z.string().optional()
-});
-var SendEventBodySchema = import_zod9.z.object({
-  event: RawEventSchema,
-  options: SendEventOptionsSchema.optional()
-});
-var DeliverEventResponseSchema = import_zod9.z.object({
-  deliveredAt: import_zod9.z.string().datetime()
-});
-var RuntimeEnvironmentTypeSchema = import_zod9.z.enum([
-  "PRODUCTION",
-  "STAGING",
-  "DEVELOPMENT",
-  "PREVIEW"
-]);
-var RunSourceContextSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  metadata: import_zod9.z.any()
-});
-var RunJobBodySchema = import_zod9.z.object({
-  event: ApiEventLogSchema,
-  job: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }),
-  run: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    isTest: import_zod9.z.boolean(),
-    isRetry: import_zod9.z.boolean().default(false),
-    startedAt: import_zod9.z.coerce.date()
-  }),
-  environment: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    slug: import_zod9.z.string(),
-    type: RuntimeEnvironmentTypeSchema
-  }),
-  organization: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    title: import_zod9.z.string(),
-    slug: import_zod9.z.string()
-  }),
-  account: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    metadata: import_zod9.z.any()
-  }).optional(),
-  source: RunSourceContextSchema.optional(),
-  tasks: import_zod9.z.array(CachedTaskSchema).optional(),
-  connections: import_zod9.z.record(ConnectionAuthSchema).optional()
-});
-var RunJobErrorSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("ERROR"),
-  error: ErrorWithStackSchema,
-  task: TaskSchema.optional()
-});
-var RunJobResumeWithTaskSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("RESUME_WITH_TASK"),
-  task: TaskSchema
-});
-var RunJobRetryWithTaskSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("RETRY_WITH_TASK"),
-  task: TaskSchema,
-  error: ErrorWithStackSchema,
-  retryAt: import_zod9.z.coerce.date()
-});
-var RunJobCanceledWithTaskSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("CANCELED"),
-  task: TaskSchema
-});
-var RunJobSuccessSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("SUCCESS"),
-  output: DeserializedJsonSchema.optional()
-});
-var RunJobResponseSchema = import_zod9.z.discriminatedUnion("status", [
-  RunJobErrorSchema,
-  RunJobResumeWithTaskSchema,
-  RunJobRetryWithTaskSchema,
-  RunJobCanceledWithTaskSchema,
-  RunJobSuccessSchema
-]);
-var PreprocessRunBodySchema = import_zod9.z.object({
-  event: ApiEventLogSchema,
-  job: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }),
-  run: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    isTest: import_zod9.z.boolean()
-  }),
-  environment: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    slug: import_zod9.z.string(),
-    type: RuntimeEnvironmentTypeSchema
-  }),
-  organization: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    title: import_zod9.z.string(),
-    slug: import_zod9.z.string()
-  }),
-  account: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    metadata: import_zod9.z.any()
-  }).optional()
-});
-var PreprocessRunResponseSchema = import_zod9.z.object({
-  abort: import_zod9.z.boolean(),
-  properties: import_zod9.z.array(DisplayPropertySchema).optional()
-});
-var CreateRunBodySchema = import_zod9.z.object({
-  client: import_zod9.z.string(),
-  job: JobMetadataSchema,
-  event: ApiEventLogSchema,
-  properties: import_zod9.z.array(DisplayPropertySchema).optional()
-});
-var CreateRunResponseOkSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(true),
-  data: import_zod9.z.object({
-    id: import_zod9.z.string()
-  })
-});
-var CreateRunResponseErrorSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(false),
-  error: import_zod9.z.string()
-});
-var CreateRunResponseBodySchema = import_zod9.z.discriminatedUnion("ok", [
-  CreateRunResponseOkSchema,
-  CreateRunResponseErrorSchema
-]);
-var RedactStringSchema = import_zod9.z.object({
-  __redactedString: import_zod9.z.literal(true),
-  strings: import_zod9.z.array(import_zod9.z.string()),
-  interpolations: import_zod9.z.array(import_zod9.z.string())
-});
-var LogMessageSchema = import_zod9.z.object({
-  level: import_zod9.z.enum([
-    "DEBUG",
-    "INFO",
-    "WARN",
-    "ERROR"
-  ]),
-  message: import_zod9.z.string(),
-  data: SerializableJsonSchema.optional()
-});
-var RedactSchema = import_zod9.z.object({
-  paths: import_zod9.z.array(import_zod9.z.string())
-});
-var RetryOptionsSchema = import_zod9.z.object({
-  limit: import_zod9.z.number().optional(),
-  factor: import_zod9.z.number().optional(),
-  minTimeoutInMs: import_zod9.z.number().optional(),
-  maxTimeoutInMs: import_zod9.z.number().optional(),
-  randomize: import_zod9.z.boolean().optional()
-});
-var RunTaskOptionsSchema = import_zod9.z.object({
-  name: import_zod9.z.string(),
-  delayUntil: import_zod9.z.coerce.date().optional(),
-  retry: RetryOptionsSchema.optional(),
-  icon: import_zod9.z.string().optional(),
-  displayKey: import_zod9.z.string().optional(),
-  description: import_zod9.z.string().optional(),
-  properties: import_zod9.z.array(DisplayPropertySchema).optional(),
-  params: import_zod9.z.any(),
-  style: StyleSchema.optional(),
-  connectionKey: import_zod9.z.string().optional(),
-  operation: import_zod9.z.enum([
-    "fetch"
-  ]).optional(),
-  noop: import_zod9.z.boolean().default(false),
-  redact: RedactSchema.optional(),
-  trigger: TriggerMetadataSchema.optional()
-});
-var RunTaskBodyInputSchema = RunTaskOptionsSchema.extend({
-  idempotencyKey: import_zod9.z.string(),
-  parentId: import_zod9.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 FailTaskBodyInputSchema = import_zod9.z.object({
-  error: ErrorWithStackSchema
-});
-var NormalizedRequestSchema = import_zod9.z.object({
-  headers: import_zod9.z.record(import_zod9.z.string()),
-  method: import_zod9.z.string(),
-  query: import_zod9.z.record(import_zod9.z.string()),
-  url: import_zod9.z.string(),
-  body: import_zod9.z.any()
-});
-var NormalizedResponseSchema = import_zod9.z.object({
-  status: import_zod9.z.number(),
-  body: import_zod9.z.any(),
-  headers: import_zod9.z.record(import_zod9.z.string()).optional()
-});
-var HttpSourceResponseSchema = import_zod9.z.object({
-  response: NormalizedResponseSchema,
-  events: import_zod9.z.array(RawEventSchema)
-});
-var RegisterTriggerBodySchema = import_zod9.z.object({
-  rule: EventRuleSchema,
-  source: SourceMetadataSchema
-});
-var InitializeTriggerBodySchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  accountId: import_zod9.z.string().optional(),
-  metadata: import_zod9.z.any().optional()
-});
-var RegisterCommonScheduleBodySchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  metadata: import_zod9.z.any(),
-  accountId: import_zod9.z.string().optional()
-});
-var RegisterIntervalScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(IntervalMetadataSchema);
-var InitializeCronScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(CronMetadataSchema);
-var RegisterScheduleBodySchema = import_zod9.z.discriminatedUnion("type", [
-  RegisterIntervalScheduleBodySchema,
-  InitializeCronScheduleBodySchema
-]);
-var RegisterScheduleResponseBodySchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  schedule: ScheduleMetadataSchema,
-  metadata: import_zod9.z.any(),
-  active: import_zod9.z.boolean()
-});
-var CreateExternalConnectionBodySchema = import_zod9.z.object({
-  accessToken: import_zod9.z.string(),
-  type: import_zod9.z.enum([
-    "oauth2"
-  ]),
-  scopes: import_zod9.z.array(import_zod9.z.string()).optional(),
-  metadata: import_zod9.z.any()
-});
-
-// ../core/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()
-  }),
-  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
-]);
-
-// ../core/src/schemas/events.ts
-var import_zod12 = require("zod");
-
-// ../core/src/schemas/runs.ts
-var import_zod11 = require("zod");
-var RunStatusSchema = import_zod11.z.union([
-  import_zod11.z.literal("PENDING"),
-  import_zod11.z.literal("QUEUED"),
-  import_zod11.z.literal("WAITING_ON_CONNECTIONS"),
-  import_zod11.z.literal("PREPROCESSING"),
-  import_zod11.z.literal("STARTED"),
-  import_zod11.z.literal("SUCCESS"),
-  import_zod11.z.literal("FAILURE"),
-  import_zod11.z.literal("TIMED_OUT"),
-  import_zod11.z.literal("ABORTED"),
-  import_zod11.z.literal("CANCELED")
-]);
-var RunTaskSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  displayKey: import_zod11.z.string().nullable(),
-  status: TaskStatusSchema,
-  name: import_zod11.z.string(),
-  icon: import_zod11.z.string().nullable(),
-  startedAt: import_zod11.z.coerce.date().nullable(),
-  completedAt: import_zod11.z.coerce.date().nullable()
-});
-var GetRunOptionsSchema = import_zod11.z.object({
-  subtasks: import_zod11.z.boolean().optional(),
-  cursor: import_zod11.z.string().optional(),
-  take: import_zod11.z.number().optional()
-});
-var GetRunOptionsWithTaskDetailsSchema = GetRunOptionsSchema.extend({
-  taskdetails: import_zod11.z.boolean().optional()
-});
-var RunSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  status: RunStatusSchema,
-  startedAt: import_zod11.z.coerce.date().nullable(),
-  updatedAt: import_zod11.z.coerce.date().nullable(),
-  completedAt: import_zod11.z.coerce.date().nullable()
-});
-var GetRunSchema = RunSchema.extend({
-  output: import_zod11.z.any().optional(),
-  tasks: import_zod11.z.array(RunTaskSchema),
-  nextCursor: import_zod11.z.string().optional()
-});
-var GetRunsOptionsSchema = import_zod11.z.object({
-  cursor: import_zod11.z.string().optional(),
-  take: import_zod11.z.number().optional()
-});
-var GetRunsSchema = import_zod11.z.object({
-  runs: RunSchema.array(),
-  nextCursor: import_zod11.z.string().optional()
-});
-
-// ../core/src/schemas/events.ts
-var GetEventSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  createdAt: import_zod12.z.coerce.date(),
-  updatedAt: import_zod12.z.coerce.date(),
-  runs: import_zod12.z.array(import_zod12.z.object({
-    id: import_zod12.z.string(),
-    status: RunStatusSchema,
-    startedAt: import_zod12.z.coerce.date().optional().nullable(),
-    completedAt: import_zod12.z.coerce.date().optional().nullable()
-  }))
-});
-
-// ../core/src/utils.ts
-function deepMergeFilters(...filters) {
-  const result = {};
-  for (const filter of filters) {
-    for (const key in filter) {
-      if (filter.hasOwnProperty(key)) {
-        const filterValue = filter[key];
-        const existingValue = result[key];
-        if (existingValue && typeof existingValue === "object" && typeof filterValue === "object" && !Array.isArray(existingValue) && !Array.isArray(filterValue) && existingValue !== null && filterValue !== null) {
-          result[key] = deepMergeFilters(existingValue, filterValue);
-        } else {
-          result[key] = filterValue;
-        }
-      }
-    }
-  }
-  return result;
-}
-__name(deepMergeFilters, "deepMergeFilters");
-
-// ../core/src/retry.ts
-var DEFAULT_RETRY_OPTIONS = {
-  limit: 5,
-  factor: 1.8,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
-};
-function calculateRetryAt(retryOptions, attempts) {
-  const options = {
-    ...DEFAULT_RETRY_OPTIONS,
-    ...retryOptions
-  };
-  const retryCount = attempts + 1;
-  if (retryCount >= options.limit) {
-    return;
-  }
-  const random = options.randomize ? Math.random() + 1 : 1;
-  let timeoutInMs = Math.round(random * Math.max(options.minTimeoutInMs, 1) * Math.pow(options.factor, Math.max(attempts - 1, 0)));
-  timeoutInMs = Math.min(timeoutInMs, options.maxTimeoutInMs);
-  return new Date(Date.now() + timeoutInMs);
-}
-__name(calculateRetryAt, "calculateRetryAt");
-
-// ../core/src/replacements.ts
-var currentDate = {
-  marker: "__CURRENT_DATE__",
-  replace({ data: { now } }) {
-    return now.toISOString();
-  }
-};
-
-// ../core/src/searchParams.ts
-function urlWithSearchParams(url, params) {
-  if (!params) {
-    return url;
-  }
-  const urlObj = new URL(url);
-  for (const [key, value] of Object.entries(params)) {
-    urlObj.searchParams.append(key, String(value));
-  }
-  return urlObj.toString();
-}
-__name(urlWithSearchParams, "urlWithSearchParams");
+// src/triggerClient.ts
+var import_core5 = require("@trigger.dev/core");
 
 // src/apiClient.ts
+var import_core = require("@trigger.dev/core");
 var import_node_fetch = __toESM(require("node-fetch"));
-var import_zod13 = require("zod");
+var import_zod = require("zod");
 var _apiUrl, _options, _logger, _apiKey, apiKey_fn;
 var ApiClient = class {
   constructor(options) {
@@ -1084,7 +162,7 @@ var ApiClient = class {
     __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));
+    __privateSet(this, _logger, new import_core.Logger("trigger.dev", __privateGet(this, _options).logLevel));
   }
   async registerEndpoint(options) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
@@ -1117,7 +195,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Creating run", {
       params
     });
-    return await zodfetch(CreateRunResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/runs`, {
+    return await zodfetch(import_core.CreateRunResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/runs`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1131,7 +209,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Running Task", {
       task
     });
-    return await zodfetch(ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
+    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1146,7 +224,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Complete Task", {
       task
     });
-    return await zodfetch(ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
+    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1162,7 +240,7 @@ var ApiClient = class {
       runId,
       body
     });
-    return await zodfetch(ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/fail`, {
+    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/fail`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1176,7 +254,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Sending event", {
       event
     });
-    return await zodfetch(ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
+    return await zodfetch(import_core.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1193,7 +271,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("activating http source", {
       source
     });
-    const response = await zodfetch(TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/sources/${key}`, {
+    const response = await zodfetch(import_core.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/sources/${key}`, {
       method: "PUT",
       headers: {
         "Content-Type": "application/json",
@@ -1209,7 +287,7 @@ var ApiClient = class {
       id,
       payload
     });
-    const response = await zodfetch(RegisterSourceEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/triggers/${id}/registrations/${key}`, {
+    const response = await zodfetch(import_core.RegisterSourceEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/triggers/${id}/registrations/${key}`, {
       method: "PUT",
       headers: {
         "Content-Type": "application/json",
@@ -1225,7 +303,7 @@ var ApiClient = class {
       id,
       payload
     });
-    const response = await zodfetch(RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
+    const response = await zodfetch(import_core.RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1243,8 +321,8 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("unregistering schedule", {
       id
     });
-    const response = await zodfetch(import_zod13.z.object({
-      ok: import_zod13.z.boolean()
+    const response = await zodfetch(import_zod.z.object({
+      ok: import_zod.z.boolean()
     }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
       method: "DELETE",
       headers: {
@@ -1259,7 +337,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("getting auth", {
       id
     });
-    const response = await zodfetch(ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
+    const response = await zodfetch(import_core.ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
       method: "GET",
       headers: {
         Accept: "application/json",
@@ -1275,7 +353,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Getting Event", {
       eventId
     });
-    return await zodfetch(GetEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}`, {
+    return await zodfetch(import_core.GetEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}`, {
       method: "GET",
       headers: {
         Authorization: `Bearer ${apiKey}`
@@ -1287,7 +365,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Getting Run", {
       runId
     });
-    return await zodfetch(GetRunSchema, urlWithSearchParams(`${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}`, options), {
+    return await zodfetch(import_core.GetRunSchema, (0, import_core.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}`, options), {
       method: "GET",
       headers: {
         Authorization: `Bearer ${apiKey}`
@@ -1299,7 +377,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Getting Runs", {
       jobSlug
     });
-    return await zodfetch(GetRunsSchema, urlWithSearchParams(`${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobSlug}/runs`, options), {
+    return await zodfetch(import_core.GetRunsSchema, (0, import_core.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobSlug}/runs`, options), {
       method: "GET",
       headers: {
         Authorization: `Bearer ${apiKey}`
@@ -1385,6 +463,7 @@ function isTriggerError(err) {
 __name(isTriggerError, "isTriggerError");
 
 // src/io.ts
+var import_core3 = require("@trigger.dev/core");
 var import_node_async_hooks = require("async_hooks");
 var import_node_crypto = require("crypto");
 
@@ -1450,6 +529,9 @@ function createIOWithIntegrations(io, auths, integrations) {
 }
 __name(createIOWithIntegrations, "createIOWithIntegrations");
 
+// src/retry.ts
+var import_core2 = require("@trigger.dev/core");
+
 // src/io.ts
 var _addToCachedTasks, addToCachedTasks_fn;
 var IO = class {
@@ -1458,7 +540,7 @@ var IO = class {
     this._id = options.id;
     this._apiClient = options.apiClient;
     this._triggerClient = options.client;
-    this._logger = options.logger ?? new Logger("trigger.dev", options.logLevel);
+    this._logger = options.logger ?? new import_core3.Logger("trigger.dev", options.logLevel);
     this._cachedTasks = /* @__PURE__ */ new Map();
     this._jobLogger = options.jobLogger;
     this._jobLogLevel = options.jobLogLevel;
@@ -1500,7 +582,7 @@ var IO = class {
           break;
         }
       }
-      if (Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
+      if (import_core3.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
         await this.runTask([
           message,
           level
@@ -1839,7 +921,7 @@ var IO = class {
               if (onErrorResult instanceof Error) {
                 error = onErrorResult;
               } else {
-                const parsedError2 = ErrorWithStackSchema.safeParse(onErrorResult.error);
+                const parsedError2 = import_core3.ErrorWithStackSchema.safeParse(onErrorResult.error);
                 throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
                   message: "Unknown error"
                 }, task, onErrorResult.retryAt);
@@ -1852,9 +934,9 @@ var IO = class {
             error = innerError;
           }
         }
-        const parsedError = ErrorWithStackSchema.safeParse(error);
+        const parsedError = import_core3.ErrorWithStackSchema.safeParse(error);
         if (options.retry) {
-          const retryAt = calculateRetryAt(options.retry, task.attempts - 1);
+          const retryAt = (0, import_core2.calculateRetryAt)(options.retry, task.attempts - 1);
           if (retryAt) {
             throw new RetryWithTaskError(parsedError.success ? parsedError.data : {
               message: "Unknown error"
@@ -1951,6 +1033,7 @@ var IOLogger = class {
 __name(IOLogger, "IOLogger");
 
 // src/triggers/eventTrigger.ts
+var import_core4 = require("@trigger.dev/core");
 var _options2;
 var EventTrigger = class {
   constructor(options) {
@@ -1964,7 +1047,7 @@ var EventTrigger = class {
       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 ?? {})
+        payload: (0, import_core4.deepMergeFilters)(__privateGet(this, _options2).filter ?? {}, __privateGet(this, _options2).event.filter ?? {})
       }
     };
   }
@@ -2002,11 +1085,11 @@ __name(eventTrigger, "eventTrigger");
 
 // src/triggerClient.ts
 var registerSourceEvent = {
-  name: REGISTER_SOURCE_EVENT,
+  name: import_core5.REGISTER_SOURCE_EVENT,
   title: "Register Source",
   source: "internal",
   icon: "register-source",
-  parsePayload: RegisterSourceEventSchema.parse
+  parsePayload: import_core5.RegisterSourceEventSchema.parse
 };
 var _options3, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _client, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn;
 var TriggerClient = class {
@@ -2028,7 +1111,7 @@ var TriggerClient = class {
     this.id = options.id;
     __privateSet(this, _options3, options);
     __privateSet(this, _client, new ApiClient(__privateGet(this, _options3)));
-    __privateSet(this, _internalLogger, new Logger("trigger.dev", __privateGet(this, _options3).verbose ? "debug" : "log"));
+    __privateSet(this, _internalLogger, new import_core5.Logger("trigger.dev", __privateGet(this, _options3).verbose ? "debug" : "log"));
   }
   async handleRequest(request) {
     __privateGet(this, _internalLogger).debug("handling request", {
@@ -2152,7 +1235,7 @@ var TriggerClient = class {
       }
       case "INITIALIZE_TRIGGER": {
         const json = await request.json();
-        const body = InitializeTriggerBodySchema.safeParse(json);
+        const body = import_core5.InitializeTriggerBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -2177,7 +1260,7 @@ var TriggerClient = class {
       }
       case "EXECUTE_JOB": {
         const json = await request.json();
-        const execution = RunJobBodySchema.safeParse(json);
+        const execution = import_core5.RunJobBodySchema.safeParse(json);
         if (!execution.success) {
           return {
             status: 400,
@@ -2203,7 +1286,7 @@ var TriggerClient = class {
       }
       case "PREPROCESS_RUN": {
         const json = await request.json();
-        const body = PreprocessRunBodySchema.safeParse(json);
+        const body = import_core5.PreprocessRunBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -2231,7 +1314,7 @@ var TriggerClient = class {
         };
       }
       case "DELIVER_HTTP_SOURCE_REQUEST": {
-        const headers = HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
+        const headers = import_core5.HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
         if (!headers.success) {
           return {
             status: 400,
@@ -2475,7 +1558,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
     client: this,
     context,
     jobLogLevel: job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info",
-    jobLogger: __privateGet(this, _options3).ioLogLocalEnabled ? new Logger(job1.id, job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info") : void 0
+    jobLogger: __privateGet(this, _options3).ioLogLocalEnabled ? new import_core5.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info") : void 0
   });
   const ioWithConnections = createIOWithIntegrations(io, body1.connections, job1.options.integrations);
   try {
@@ -2506,7 +1589,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
       };
     }
     if (error instanceof RetryWithTaskError) {
-      const errorWithStack2 = ErrorWithStackSchema.safeParse(error.cause);
+      const errorWithStack2 = import_core5.ErrorWithStackSchema.safeParse(error.cause);
       if (errorWithStack2.success) {
         return {
           status: "ERROR",
@@ -2522,7 +1605,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
         task: error.task
       };
     }
-    const errorWithStack = ErrorWithStackSchema.safeParse(error);
+    const errorWithStack = import_core5.ErrorWithStackSchema.safeParse(error);
     if (errorWithStack.success) {
       return {
         status: "ERROR",
@@ -2664,6 +1747,7 @@ function authenticatedTask(options) {
 __name(authenticatedTask, "authenticatedTask");
 
 // src/triggers/externalSource.ts
+var import_core6 = require("@trigger.dev/core");
 var ExternalSource = class {
   constructor(channel, options) {
     this.options = options;
@@ -2737,7 +1821,7 @@ var ExternalSourceTrigger = class {
       title: "External Source",
       rule: {
         event: this.event.name,
-        payload: deepMergeFilters(this.options.source.filter(this.options.params), this.event.filter ?? {}, this.options.params.filter ?? {}),
+        payload: (0, import_core6.deepMergeFilters)(this.options.source.filter(this.options.params), this.event.filter ?? {}, this.options.params.filter ?? {}),
         source: this.event.source
       },
       properties: this.options.source.properties(this.options.params)
@@ -2771,6 +1855,7 @@ function omit(obj, key) {
 __name(omit, "omit");
 
 // src/triggers/dynamic.ts
+var import_core7 = require("@trigger.dev/core");
 var _client2, _options4;
 var DynamicTrigger = class {
   constructor(client, options) {
@@ -2799,7 +1884,7 @@ var DynamicTrigger = class {
       rule: {
         event: this.event.name,
         source: this.event.source,
-        payload: deepMergeFilters(this.source.filter(params), this.event.filter ?? {})
+        payload: (0, import_core7.deepMergeFilters)(this.source.filter(params), this.event.filter ?? {})
       },
       source: {
         key,
@@ -2831,6 +1916,7 @@ _client2 = new WeakMap();
 _options4 = new WeakMap();
 
 // src/triggers/scheduled.ts
+var import_core8 = require("@trigger.dev/core");
 var import_cronstrue = __toESM(require("cronstrue"));
 var examples = [
   {
@@ -2838,8 +1924,8 @@ var examples = [
     name: "Now",
     icon: "clock",
     payload: {
-      ts: currentDate.marker,
-      lastTimestamp: currentDate.marker
+      ts: import_core8.currentDate.marker,
+      lastTimestamp: import_core8.currentDate.marker
     }
   }
 ];
@@ -2854,7 +1940,7 @@ var IntervalTrigger = class {
       source: "trigger.dev",
       icon: "schedule-interval",
       examples,
-      parsePayload: ScheduledPayloadSchema.parse,
+      parsePayload: import_core8.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "Interval",
@@ -2899,7 +1985,7 @@ var CronTrigger = class {
       source: "trigger.dev",
       icon: "schedule-cron",
       examples,
-      parsePayload: ScheduledPayloadSchema.parse,
+      parsePayload: import_core8.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "cron",
@@ -2949,7 +2035,7 @@ var DynamicSchedule = class {
       source: "trigger.dev",
       icon: "schedule-dynamic",
       examples,
-      parsePayload: ScheduledPayloadSchema.parse
+      parsePayload: import_core8.ScheduledPayloadSchema.parse
     };
   }
   async register(key, metadata) {
@@ -2974,6 +2060,7 @@ var DynamicSchedule = class {
 __name(DynamicSchedule, "DynamicSchedule");
 
 // src/triggers/notifications.ts
+var import_core9 = require("@trigger.dev/core");
 function missingConnectionNotification(integrations) {
   return new MissingConnectionNotification({
     integrations
@@ -2992,11 +2079,11 @@ var MissingConnectionNotification = class {
   }
   get event() {
     return {
-      name: MISSING_CONNECTION_NOTIFICATION,
+      name: import_core9.MISSING_CONNECTION_NOTIFICATION,
       title: "Missing Connection Notification",
       source: "trigger.dev",
       icon: "connection-alert",
-      parsePayload: MissingConnectionNotificationPayloadSchema.parse,
+      parsePayload: import_core9.MissingConnectionNotificationPayloadSchema.parse,
       properties: [
         {
           label: "Integrations",
@@ -3033,11 +2120,11 @@ var MissingConnectionResolvedNotification = class {
   }
   get event() {
     return {
-      name: MISSING_CONNECTION_RESOLVED_NOTIFICATION,
+      name: import_core9.MISSING_CONNECTION_RESOLVED_NOTIFICATION,
       title: "Missing Connection Resolved Notification",
       source: "trigger.dev",
       icon: "connection-alert",
-      parsePayload: MissingConnectionResolvedNotificationPayloadSchema.parse,
+      parsePayload: import_core9.MissingConnectionResolvedNotificationPayloadSchema.parse,
       properties: [
         {
           label: "Integrations",