@trigger.dev/core 2.2.3 → 2.2.5

package/dist/index.js

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -18,10 +17,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -51,12 +46,13 @@ __export(src_exports, {
   API_VERSIONS: () => API_VERSIONS,
   ApiEventLogSchema: () => ApiEventLogSchema,
   AutoYieldConfigSchema: () => AutoYieldConfigSchema,
-  BloomFilter: () => BloomFilter,
+  AutoYieldMetadataSchema: () => AutoYieldMetadataSchema,
   CachedTaskSchema: () => CachedTaskSchema,
   CancelRunsForEventSchema: () => CancelRunsForEventSchema,
   CommonMissingConnectionNotificationPayloadSchema: () => CommonMissingConnectionNotificationPayloadSchema,
   CommonMissingConnectionNotificationResolvedPayloadSchema: () => CommonMissingConnectionNotificationResolvedPayloadSchema,
   CompleteTaskBodyInputSchema: () => CompleteTaskBodyInputSchema,
+  CompleteTaskBodyV2InputSchema: () => CompleteTaskBodyV2InputSchema,
   ConnectionAuthSchema: () => ConnectionAuthSchema,
   CreateExternalConnectionBodySchema: () => CreateExternalConnectionBodySchema,
   CreateRunResponseBodySchema: () => CreateRunResponseBodySchema,
@@ -82,14 +78,16 @@ __export(src_exports, {
   FetchRetryHeadersStrategySchema: () => FetchRetryHeadersStrategySchema,
   FetchRetryOptionsSchema: () => FetchRetryOptionsSchema,
   FetchRetryStrategySchema: () => FetchRetryStrategySchema,
+  FetchTimeoutOptionsSchema: () => FetchTimeoutOptionsSchema,
   GetEndpointIndexResponseSchema: () => GetEndpointIndexResponseSchema,
   GetEventSchema: () => GetEventSchema,
   GetRunSchema: () => GetRunSchema,
   GetRunStatusesSchema: () => GetRunStatusesSchema,
   GetRunsSchema: () => GetRunsSchema,
+  HTTPMethodUnionSchema: () => HTTPMethodUnionSchema,
   HandleTriggerSourceSchema: () => HandleTriggerSourceSchema,
+  HttpEndpointRequestHeadersSchema: () => HttpEndpointRequestHeadersSchema,
   HttpSourceRequestHeadersSchema: () => HttpSourceRequestHeadersSchema,
-  HttpSourceRequestSchema: () => HttpSourceRequestSchema,
   HttpSourceResponseSchema: () => HttpSourceResponseSchema,
   IndexEndpointResponseSchema: () => IndexEndpointResponseSchema,
   InitializeCronScheduleBodySchema: () => InitializeCronScheduleBodySchema,
@@ -98,6 +96,10 @@ __export(src_exports, {
   IntegrationMetadataSchema: () => IntegrationMetadataSchema,
   IntervalMetadataSchema: () => IntervalMetadataSchema,
   IntervalOptionsSchema: () => IntervalOptionsSchema,
+  InvokeJobRequestBodySchema: () => InvokeJobRequestBodySchema,
+  InvokeJobResponseSchema: () => InvokeJobResponseSchema,
+  InvokeOptionsSchema: () => InvokeOptionsSchema,
+  InvokeTriggerMetadataSchema: () => InvokeTriggerMetadataSchema,
   JobMetadataSchema: () => JobMetadataSchema,
   JobRunStatusRecordSchema: () => JobRunStatusRecordSchema,
   LogMessageSchema: () => LogMessageSchema,
@@ -137,14 +139,18 @@ __export(src_exports, {
   RegisterTriggerBodySchemaV1: () => RegisterTriggerBodySchemaV1,
   RegisterTriggerBodySchemaV2: () => RegisterTriggerBodySchemaV2,
   RegisterTriggerSourceSchema: () => RegisterTriggerSourceSchema,
+  RequestFilterSchema: () => RequestFilterSchema,
+  RequestWithRawBodySchema: () => RequestWithRawBodySchema,
   RetryOptionsSchema: () => RetryOptionsSchema,
   RunJobAutoYieldExecutionErrorSchema: () => RunJobAutoYieldExecutionErrorSchema,
   RunJobAutoYieldWithCompletedTaskExecutionErrorSchema: () => RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
   RunJobBodySchema: () => RunJobBodySchema,
   RunJobCanceledWithTaskSchema: () => RunJobCanceledWithTaskSchema,
+  RunJobErrorResponseSchema: () => RunJobErrorResponseSchema,
   RunJobErrorSchema: () => RunJobErrorSchema,
   RunJobInvalidPayloadErrorSchema: () => RunJobInvalidPayloadErrorSchema,
   RunJobResponseSchema: () => RunJobResponseSchema,
+  RunJobResumeWithParallelTaskSchema: () => RunJobResumeWithParallelTaskSchema,
   RunJobResumeWithTaskSchema: () => RunJobResumeWithTaskSchema,
   RunJobRetryWithTaskSchema: () => RunJobRetryWithTaskSchema,
   RunJobSuccessSchema: () => RunJobSuccessSchema,
@@ -175,6 +181,7 @@ __export(src_exports, {
   StyleSchema: () => StyleSchema,
   TaskSchema: () => TaskSchema,
   TaskStatusSchema: () => TaskStatusSchema,
+  TriggerHelpSchema: () => TriggerHelpSchema,
   TriggerMetadataSchema: () => TriggerMetadataSchema,
   TriggerSourceSchema: () => TriggerSourceSchema,
   UpdateTriggerSourceBodyV1Schema: () => UpdateTriggerSourceBodyV1Schema,
@@ -191,6 +198,8 @@ __export(src_exports, {
   eventFilterMatches: () => eventFilterMatches,
   parseEndpointIndexStats: () => parseEndpointIndexStats,
   replacements: () => replacements,
+  requestFilterMatches: () => requestFilterMatches,
+  stringPatternMatchers: () => stringPatternMatchers,
   supportsFeature: () => supportsFeature,
   urlWithSearchParams: () => urlWithSearchParams
 });
@@ -228,27 +237,27 @@ var _Logger = class _Logger {
   log(message, ...args) {
     if (__privateGet(this, _level) < 0)
       return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, ...args);
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
   }
   error(message, ...args) {
     if (__privateGet(this, _level) < 1)
       return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, ...args);
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
   }
   warn(message, ...args) {
     if (__privateGet(this, _level) < 2)
       return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, ...args);
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
   }
   info(message, ...args) {
     if (__privateGet(this, _level) < 3)
       return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, ...args);
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
   }
   debug(message, ...args) {
     if (__privateGet(this, _level) < 4)
       return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, ...args);
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, "debug", ...args);
   }
 };
 _name = new WeakMap();
@@ -256,12 +265,13 @@ _level = new WeakMap();
 _filteredKeys = new WeakMap();
 _jsonReplacer = new WeakMap();
 _structuredLog = new WeakSet();
-structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, ...args) {
+structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
   const structuredLog = {
     ...structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys)),
     timestamp: /* @__PURE__ */ new Date(),
     name: __privateGet(this, _name),
-    message
+    message,
+    level
   };
   loggerFunction(JSON.stringify(structuredLog, createReplacer(__privateGet(this, _jsonReplacer))));
 }, "#structuredLog");
@@ -330,7 +340,7 @@ function prettyPrintBytes(value) {
   if (process.env.NODE_ENV === "production") {
     return "skipped size";
   }
-  const sizeInBytes = Buffer.byteLength(JSON.stringify(value), "utf8");
+  const sizeInBytes = getSizeInBytes(value);
   if (sizeInBytes < 1024) {
     return `${sizeInBytes} bytes`;
   }
@@ -343,10 +353,19 @@ function prettyPrintBytes(value) {
   return `${(sizeInBytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
 }
 __name(prettyPrintBytes, "prettyPrintBytes");
+function getSizeInBytes(value) {
+  const jsonString = JSON.stringify(value);
+  if (typeof window === "undefined") {
+    return Buffer.byteLength(jsonString, "utf8");
+  } else {
+    return new TextEncoder().encode(jsonString).length;
+  }
+}
+__name(getSizeInBytes, "getSizeInBytes");
 
 // src/schemas/api.ts
 var import_ulid = require("ulid");
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 
 // src/schemas/addMissingVersionField.ts
 function addMissingVersionField(val) {
@@ -374,6 +393,17 @@ var SchemaErrorSchema = import_zod.z.object({
 
 // src/schemas/eventFilter.ts
 var import_zod2 = require("zod");
+var stringPatternMatchers = [
+  import_zod2.z.object({
+    $endsWith: import_zod2.z.string()
+  }),
+  import_zod2.z.object({
+    $startsWith: import_zod2.z.string()
+  }),
+  import_zod2.z.object({
+    $ignoreCaseEquals: import_zod2.z.string()
+  })
+];
 var EventMatcherSchema = import_zod2.z.union([
   /** Match against a string */
   import_zod2.z.array(import_zod2.z.string()),
@@ -382,12 +412,7 @@ var EventMatcherSchema = import_zod2.z.union([
   /** Match against a boolean */
   import_zod2.z.array(import_zod2.z.boolean()),
   import_zod2.z.array(import_zod2.z.union([
-    import_zod2.z.object({
-      $endsWith: import_zod2.z.string()
-    }),
-    import_zod2.z.object({
-      $startsWith: import_zod2.z.string()
-    }),
+    ...stringPatternMatchers,
     import_zod2.z.object({
       $exists: import_zod2.z.boolean()
     }),
@@ -432,9 +457,6 @@ var EventMatcherSchema = import_zod2.z.union([
         import_zod2.z.number(),
         import_zod2.z.boolean()
       ])
-    }),
-    import_zod2.z.object({
-      $ignoreCaseEquals: import_zod2.z.string()
     })
   ]))
 ]);
@@ -598,7 +620,11 @@ var TaskSchema = import_zod7.z.object({
   parentId: import_zod7.z.string().optional().nullable(),
   style: StyleSchema.optional().nullable(),
   operation: import_zod7.z.string().optional().nullable(),
-  callbackUrl: import_zod7.z.string().optional().nullable()
+  callbackUrl: import_zod7.z.string().optional().nullable(),
+  childExecutionMode: import_zod7.z.enum([
+    "SEQUENTIAL",
+    "PARALLEL"
+  ]).optional().nullable()
 });
 var ServerTaskSchema = TaskSchema.extend({
   idempotencyKey: import_zod7.z.string(),
@@ -636,6 +662,12 @@ var DynamicTriggerMetadataSchema = import_zod8.z.object({
   type: import_zod8.z.literal("dynamic"),
   id: import_zod8.z.string()
 });
+var TriggerHelpSchema = import_zod8.z.object({
+  noRuns: import_zod8.z.object({
+    text: import_zod8.z.string(),
+    link: import_zod8.z.string().optional()
+  }).optional()
+});
 var StaticTriggerMetadataSchema = import_zod8.z.object({
   type: import_zod8.z.literal("static"),
   title: import_zod8.z.union([
@@ -643,7 +675,12 @@ var StaticTriggerMetadataSchema = import_zod8.z.object({
     import_zod8.z.array(import_zod8.z.string())
   ]),
   properties: import_zod8.z.array(DisplayPropertySchema).optional(),
-  rule: EventRuleSchema
+  rule: EventRuleSchema,
+  link: import_zod8.z.string().optional(),
+  help: TriggerHelpSchema.optional()
+});
+var InvokeTriggerMetadataSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("invoke")
 });
 var ScheduledTriggerMetadataSchema = import_zod8.z.object({
   type: import_zod8.z.literal("scheduled"),
@@ -652,7 +689,8 @@ var ScheduledTriggerMetadataSchema = import_zod8.z.object({
 var TriggerMetadataSchema = import_zod8.z.discriminatedUnion("type", [
   DynamicTriggerMetadataSchema,
   StaticTriggerMetadataSchema,
-  ScheduledTriggerMetadataSchema
+  ScheduledTriggerMetadataSchema,
+  InvokeTriggerMetadataSchema
 ]);
 
 // src/schemas/runs.ts
@@ -763,225 +801,289 @@ var GetRunsSchema = import_zod10.z.object({
   nextCursor: import_zod10.z.string().optional()
 });
 
+// src/schemas/requestFilter.ts
+var import_zod11 = require("zod");
+var StringMatchSchema = import_zod11.z.union([
+  /** Match against a string */
+  import_zod11.z.array(import_zod11.z.string()),
+  import_zod11.z.array(import_zod11.z.union(stringPatternMatchers))
+]);
+var HTTPMethodUnionSchema = import_zod11.z.union([
+  import_zod11.z.literal("GET"),
+  import_zod11.z.literal("POST"),
+  import_zod11.z.literal("PUT"),
+  import_zod11.z.literal("PATCH"),
+  import_zod11.z.literal("DELETE"),
+  import_zod11.z.literal("HEAD"),
+  import_zod11.z.literal("OPTIONS")
+]);
+var RequestFilterSchema = import_zod11.z.object({
+  /** An array of HTTP methods to match.
+  * For example, `["GET", "POST"]` will match both `GET` and `POST` Requests. */
+  method: import_zod11.z.array(HTTPMethodUnionSchema).optional(),
+  /** An object of header key/values to match. 
+     * This uses the [EventFilter matching syntax](https://trigger.dev/docs/documentation/guides/event-filter).
+  
+      @example
+    ```ts
+    filter: {
+      header: {
+        "content-type": ["application/json"],
+      },
+    },
+    ``` */
+  headers: import_zod11.z.record(StringMatchSchema).optional(),
+  /** An object of query parameters to match. 
+     * This uses the [EventFilter matching syntax](https://trigger.dev/docs/documentation/guides/event-filter).
+  
+    @example
+    ```ts
+    filter: {
+      query: {
+        "hub.mode": [{ $startsWith: "sub" }],
+      },
+    },
+    ``` */
+  query: import_zod11.z.record(StringMatchSchema).optional(),
+  /** An object of key/values to match.
+  * This uses the [EventFilter matching syntax](https://trigger.dev/docs/documentation/guides/event-filter).
+  */
+  body: EventFilterSchema.optional()
+});
+
 // src/schemas/api.ts
-var UpdateTriggerSourceBodyV1Schema = import_zod11.z.object({
-  registeredEvents: import_zod11.z.array(import_zod11.z.string()),
-  secret: import_zod11.z.string().optional(),
+var UpdateTriggerSourceBodyV1Schema = import_zod12.z.object({
+  registeredEvents: import_zod12.z.array(import_zod12.z.string()),
+  secret: import_zod12.z.string().optional(),
   data: SerializableJsonSchema.optional()
 });
-var UpdateTriggerSourceBodyV2Schema = import_zod11.z.object({
-  secret: import_zod11.z.string().optional(),
+var UpdateTriggerSourceBodyV2Schema = import_zod12.z.object({
+  secret: import_zod12.z.string().optional(),
   data: SerializableJsonSchema.optional(),
-  options: import_zod11.z.object({
-    event: import_zod11.z.array(import_zod11.z.string())
-  }).and(import_zod11.z.record(import_zod11.z.string(), import_zod11.z.array(import_zod11.z.string())).optional())
+  options: import_zod12.z.object({
+    event: import_zod12.z.array(import_zod12.z.string())
+  }).and(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.array(import_zod12.z.string())).optional())
 });
-var RegisterHTTPTriggerSourceBodySchema = import_zod11.z.object({
-  type: import_zod11.z.literal("HTTP"),
-  url: import_zod11.z.string().url()
+var RegisterHTTPTriggerSourceBodySchema = import_zod12.z.object({
+  type: import_zod12.z.literal("HTTP"),
+  url: import_zod12.z.string().url()
 });
-var RegisterSMTPTriggerSourceBodySchema = import_zod11.z.object({
-  type: import_zod11.z.literal("SMTP")
+var RegisterSMTPTriggerSourceBodySchema = import_zod12.z.object({
+  type: import_zod12.z.literal("SMTP")
 });
-var RegisterSQSTriggerSourceBodySchema = import_zod11.z.object({
-  type: import_zod11.z.literal("SQS")
+var RegisterSQSTriggerSourceBodySchema = import_zod12.z.object({
+  type: import_zod12.z.literal("SQS")
 });
-var RegisterSourceChannelBodySchema = import_zod11.z.discriminatedUnion("type", [
+var RegisterSourceChannelBodySchema = import_zod12.z.discriminatedUnion("type", [
   RegisterHTTPTriggerSourceBodySchema,
   RegisterSMTPTriggerSourceBodySchema,
   RegisterSQSTriggerSourceBodySchema
 ]);
 var REGISTER_SOURCE_EVENT_V1 = "dev.trigger.source.register";
 var REGISTER_SOURCE_EVENT_V2 = "dev.trigger.source.register.v2";
-var RegisterTriggerSourceSchema = import_zod11.z.object({
-  key: import_zod11.z.string(),
-  params: import_zod11.z.any(),
-  active: import_zod11.z.boolean(),
-  secret: import_zod11.z.string(),
+var RegisterTriggerSourceSchema = import_zod12.z.object({
+  key: import_zod12.z.string(),
+  params: import_zod12.z.any(),
+  active: import_zod12.z.boolean(),
+  secret: import_zod12.z.string(),
   data: DeserializedJsonSchema.optional(),
   channel: RegisterSourceChannelBodySchema,
-  clientId: import_zod11.z.string().optional()
+  clientId: import_zod12.z.string().optional()
 });
-var SourceEventOptionSchema = import_zod11.z.object({
-  name: import_zod11.z.string(),
-  value: import_zod11.z.string()
+var SourceEventOptionSchema = import_zod12.z.object({
+  name: import_zod12.z.string(),
+  value: import_zod12.z.string()
 });
-var RegisterSourceEventSchemaV1 = import_zod11.z.object({
+var RegisterSourceEventSchemaV1 = import_zod12.z.object({
   /** The id of the source */
-  id: import_zod11.z.string(),
+  id: import_zod12.z.string(),
   source: RegisterTriggerSourceSchema,
-  events: import_zod11.z.array(import_zod11.z.string()),
-  missingEvents: import_zod11.z.array(import_zod11.z.string()),
-  orphanedEvents: import_zod11.z.array(import_zod11.z.string()),
-  dynamicTriggerId: import_zod11.z.string().optional()
+  events: import_zod12.z.array(import_zod12.z.string()),
+  missingEvents: import_zod12.z.array(import_zod12.z.string()),
+  orphanedEvents: import_zod12.z.array(import_zod12.z.string()),
+  dynamicTriggerId: import_zod12.z.string().optional()
 });
-var RegisteredOptionsDiffSchema = import_zod11.z.object({
-  desired: import_zod11.z.array(import_zod11.z.string()),
-  missing: import_zod11.z.array(import_zod11.z.string()),
-  orphaned: import_zod11.z.array(import_zod11.z.string())
+var RegisteredOptionsDiffSchema = import_zod12.z.object({
+  desired: import_zod12.z.array(import_zod12.z.string()),
+  missing: import_zod12.z.array(import_zod12.z.string()),
+  orphaned: import_zod12.z.array(import_zod12.z.string())
 });
-var RegisterSourceEventOptionsSchema = import_zod11.z.object({
+var RegisterSourceEventOptionsSchema = import_zod12.z.object({
   event: RegisteredOptionsDiffSchema
-}).and(import_zod11.z.record(import_zod11.z.string(), RegisteredOptionsDiffSchema));
-var RegisterSourceEventSchemaV2 = import_zod11.z.object({
+}).and(import_zod12.z.record(import_zod12.z.string(), RegisteredOptionsDiffSchema));
+var RegisterSourceEventSchemaV2 = import_zod12.z.object({
   /** The id of the source */
-  id: import_zod11.z.string(),
+  id: import_zod12.z.string(),
   source: RegisterTriggerSourceSchema,
   options: RegisterSourceEventOptionsSchema,
-  dynamicTriggerId: import_zod11.z.string().optional()
+  dynamicTriggerId: import_zod12.z.string().optional()
 });
-var TriggerSourceSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  key: import_zod11.z.string()
+var TriggerSourceSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  key: import_zod12.z.string()
 });
 var HttpSourceResponseMetadataSchema = DeserializedJsonSchema;
-var HandleTriggerSourceSchema = import_zod11.z.object({
-  key: import_zod11.z.string(),
-  secret: import_zod11.z.string(),
-  data: import_zod11.z.any(),
-  params: import_zod11.z.any(),
+var HandleTriggerSourceSchema = import_zod12.z.object({
+  key: import_zod12.z.string(),
+  secret: import_zod12.z.string(),
+  data: import_zod12.z.any(),
+  params: import_zod12.z.any(),
   auth: ConnectionAuthSchema.optional(),
   metadata: HttpSourceResponseMetadataSchema.optional()
 });
-var HttpSourceRequestSchema = import_zod11.z.object({
-  url: import_zod11.z.string().url(),
-  method: import_zod11.z.string(),
-  headers: import_zod11.z.record(import_zod11.z.string()),
-  rawBody: import_zod11.z.instanceof(Buffer).optional().nullable()
-});
-var HttpSourceRequestHeadersSchema = import_zod11.z.object({
-  "x-ts-key": import_zod11.z.string(),
-  "x-ts-dynamic-id": import_zod11.z.string().optional(),
-  "x-ts-secret": import_zod11.z.string(),
-  "x-ts-data": import_zod11.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-params": import_zod11.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-http-url": import_zod11.z.string(),
-  "x-ts-http-method": import_zod11.z.string(),
-  "x-ts-http-headers": import_zod11.z.string().transform((s) => import_zod11.z.record(import_zod11.z.string()).parse(JSON.parse(s))),
-  "x-ts-auth": import_zod11.z.string().optional().transform((s) => {
+var HttpSourceRequestHeadersSchema = import_zod12.z.object({
+  "x-ts-key": import_zod12.z.string(),
+  "x-ts-dynamic-id": import_zod12.z.string().optional(),
+  "x-ts-secret": import_zod12.z.string(),
+  "x-ts-data": import_zod12.z.string().transform((s) => JSON.parse(s)),
+  "x-ts-params": import_zod12.z.string().transform((s) => JSON.parse(s)),
+  "x-ts-http-url": import_zod12.z.string(),
+  "x-ts-http-method": import_zod12.z.string(),
+  "x-ts-http-headers": import_zod12.z.string().transform((s) => import_zod12.z.record(import_zod12.z.string()).parse(JSON.parse(s))),
+  "x-ts-auth": import_zod12.z.string().optional().transform((s) => {
     if (s === void 0)
       return;
     const json = JSON.parse(s);
     return ConnectionAuthSchema.parse(json);
   }),
-  "x-ts-metadata": import_zod11.z.string().optional().transform((s) => {
+  "x-ts-metadata": import_zod12.z.string().optional().transform((s) => {
     if (s === void 0)
       return;
     const json = JSON.parse(s);
     return DeserializedJsonSchema.parse(json);
   })
 });
-var PongSuccessResponseSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(true),
-  triggerVersion: import_zod11.z.string().optional(),
-  triggerSdkVersion: import_zod11.z.string().optional()
+var HttpEndpointRequestHeadersSchema = import_zod12.z.object({
+  "x-ts-key": import_zod12.z.string(),
+  "x-ts-http-url": import_zod12.z.string(),
+  "x-ts-http-method": import_zod12.z.string(),
+  "x-ts-http-headers": import_zod12.z.string().transform((s) => import_zod12.z.record(import_zod12.z.string()).parse(JSON.parse(s)))
 });
-var PongErrorResponseSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(false),
-  error: import_zod11.z.string(),
-  triggerVersion: import_zod11.z.string().optional(),
-  triggerSdkVersion: import_zod11.z.string().optional()
+var PongSuccessResponseSchema = import_zod12.z.object({
+  ok: import_zod12.z.literal(true),
+  triggerVersion: import_zod12.z.string().optional(),
+  triggerSdkVersion: import_zod12.z.string().optional()
 });
-var PongResponseSchema = import_zod11.z.discriminatedUnion("ok", [
+var PongErrorResponseSchema = import_zod12.z.object({
+  ok: import_zod12.z.literal(false),
+  error: import_zod12.z.string(),
+  triggerVersion: import_zod12.z.string().optional(),
+  triggerSdkVersion: import_zod12.z.string().optional()
+});
+var PongResponseSchema = import_zod12.z.discriminatedUnion("ok", [
   PongSuccessResponseSchema,
   PongErrorResponseSchema
 ]);
-var ValidateSuccessResponseSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(true),
-  endpointId: import_zod11.z.string(),
-  triggerVersion: import_zod11.z.string().optional()
+var ValidateSuccessResponseSchema = import_zod12.z.object({
+  ok: import_zod12.z.literal(true),
+  endpointId: import_zod12.z.string(),
+  triggerVersion: import_zod12.z.string().optional()
 });
-var ValidateErrorResponseSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(false),
-  error: import_zod11.z.string(),
-  triggerVersion: import_zod11.z.string().optional()
+var ValidateErrorResponseSchema = import_zod12.z.object({
+  ok: import_zod12.z.literal(false),
+  error: import_zod12.z.string(),
+  triggerVersion: import_zod12.z.string().optional()
 });
-var ValidateResponseSchema = import_zod11.z.discriminatedUnion("ok", [
+var ValidateResponseSchema = import_zod12.z.discriminatedUnion("ok", [
   ValidateSuccessResponseSchema,
   ValidateErrorResponseSchema
 ]);
-var QueueOptionsSchema = import_zod11.z.object({
-  name: import_zod11.z.string(),
-  maxConcurrent: import_zod11.z.number().optional()
-});
-var JobMetadataSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  version: import_zod11.z.string(),
+var QueueOptionsSchema = import_zod12.z.object({
+  name: import_zod12.z.string(),
+  maxConcurrent: import_zod12.z.number().optional()
+});
+var JobMetadataSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  version: import_zod12.z.string(),
   event: EventSpecificationSchema,
   trigger: TriggerMetadataSchema,
-  integrations: import_zod11.z.record(IntegrationConfigSchema),
-  internal: import_zod11.z.boolean().default(false),
-  enabled: import_zod11.z.boolean(),
-  startPosition: import_zod11.z.enum([
+  integrations: import_zod12.z.record(IntegrationConfigSchema),
+  internal: import_zod12.z.boolean().default(false),
+  enabled: import_zod12.z.boolean(),
+  startPosition: import_zod12.z.enum([
     "initial",
     "latest"
   ]),
-  preprocessRuns: import_zod11.z.boolean()
+  preprocessRuns: import_zod12.z.boolean()
 });
-var SourceMetadataV1Schema = import_zod11.z.object({
-  version: import_zod11.z.literal("1"),
-  channel: import_zod11.z.enum([
+var SourceMetadataV1Schema = import_zod12.z.object({
+  version: import_zod12.z.literal("1"),
+  channel: import_zod12.z.enum([
     "HTTP",
     "SQS",
     "SMTP"
   ]),
   integration: IntegrationConfigSchema,
-  key: import_zod11.z.string(),
-  params: import_zod11.z.any(),
-  events: import_zod11.z.array(import_zod11.z.string()),
-  registerSourceJob: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.z.string()
+  key: import_zod12.z.string(),
+  params: import_zod12.z.any(),
+  events: import_zod12.z.array(import_zod12.z.string()),
+  registerSourceJob: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    version: import_zod12.z.string()
   }).optional()
 });
-var SourceMetadataV2Schema = import_zod11.z.object({
-  version: import_zod11.z.literal("2"),
-  channel: import_zod11.z.enum([
+var SourceMetadataV2Schema = import_zod12.z.object({
+  version: import_zod12.z.literal("2"),
+  channel: import_zod12.z.enum([
     "HTTP",
     "SQS",
     "SMTP"
   ]),
   integration: IntegrationConfigSchema,
-  key: import_zod11.z.string(),
-  params: import_zod11.z.any(),
-  options: import_zod11.z.record(import_zod11.z.array(import_zod11.z.string())),
-  registerSourceJob: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.z.string()
+  key: import_zod12.z.string(),
+  params: import_zod12.z.any(),
+  options: import_zod12.z.record(import_zod12.z.array(import_zod12.z.string())),
+  registerSourceJob: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    version: import_zod12.z.string()
   }).optional()
 });
-var SourceMetadataSchema = import_zod11.z.preprocess(addMissingVersionField, import_zod11.z.discriminatedUnion("version", [
+var SourceMetadataSchema = import_zod12.z.preprocess(addMissingVersionField, import_zod12.z.discriminatedUnion("version", [
   SourceMetadataV1Schema,
   SourceMetadataV2Schema
 ]));
-var DynamicTriggerEndpointMetadataSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  jobs: import_zod11.z.array(JobMetadataSchema.pick({
+var DynamicTriggerEndpointMetadataSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  jobs: import_zod12.z.array(JobMetadataSchema.pick({
     id: true,
     version: true
   })),
-  registerSourceJob: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.z.string()
+  registerSourceJob: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    version: import_zod12.z.string()
   }).optional()
 });
-var IndexEndpointResponseSchema = import_zod11.z.object({
-  jobs: import_zod11.z.array(JobMetadataSchema),
-  sources: import_zod11.z.array(SourceMetadataSchema),
-  dynamicTriggers: import_zod11.z.array(DynamicTriggerEndpointMetadataSchema),
-  dynamicSchedules: import_zod11.z.array(RegisterDynamicSchedulePayloadSchema)
-});
-var EndpointIndexErrorSchema = import_zod11.z.object({
-  message: import_zod11.z.string(),
-  raw: import_zod11.z.any().optional()
-});
-var IndexEndpointStatsSchema = import_zod11.z.object({
-  jobs: import_zod11.z.number(),
-  sources: import_zod11.z.number(),
-  dynamicTriggers: import_zod11.z.number(),
-  dynamicSchedules: import_zod11.z.number(),
-  disabledJobs: import_zod11.z.number().default(0)
+var HttpEndpointMetadataSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  version: import_zod12.z.string(),
+  enabled: import_zod12.z.boolean(),
+  title: import_zod12.z.string().optional(),
+  icon: import_zod12.z.string().optional(),
+  properties: import_zod12.z.array(DisplayPropertySchema).optional(),
+  event: EventSpecificationSchema,
+  immediateResponseFilter: RequestFilterSchema.optional(),
+  skipTriggeringRuns: import_zod12.z.boolean().optional(),
+  source: import_zod12.z.string()
+});
+var IndexEndpointResponseSchema = import_zod12.z.object({
+  jobs: import_zod12.z.array(JobMetadataSchema),
+  sources: import_zod12.z.array(SourceMetadataSchema),
+  dynamicTriggers: import_zod12.z.array(DynamicTriggerEndpointMetadataSchema),
+  dynamicSchedules: import_zod12.z.array(RegisterDynamicSchedulePayloadSchema),
+  httpEndpoints: import_zod12.z.array(HttpEndpointMetadataSchema).optional()
+});
+var EndpointIndexErrorSchema = import_zod12.z.object({
+  message: import_zod12.z.string(),
+  raw: import_zod12.z.any().optional()
+});
+var IndexEndpointStatsSchema = import_zod12.z.object({
+  jobs: import_zod12.z.number(),
+  sources: import_zod12.z.number(),
+  dynamicTriggers: import_zod12.z.number(),
+  dynamicSchedules: import_zod12.z.number(),
+  disabledJobs: import_zod12.z.number().default(0),
+  httpEndpoints: import_zod12.z.number().default(0)
 });
 function parseEndpointIndexStats(stats) {
   if (stats === null || stats === void 0) {
@@ -990,208 +1092,216 @@ function parseEndpointIndexStats(stats) {
   return IndexEndpointStatsSchema.parse(stats);
 }
 __name(parseEndpointIndexStats, "parseEndpointIndexStats");
-var GetEndpointIndexResponseSchema = import_zod11.z.discriminatedUnion("status", [
-  import_zod11.z.object({
-    status: import_zod11.z.literal("PENDING"),
-    updatedAt: import_zod11.z.coerce.date()
+var GetEndpointIndexResponseSchema = import_zod12.z.discriminatedUnion("status", [
+  import_zod12.z.object({
+    status: import_zod12.z.literal("PENDING"),
+    updatedAt: import_zod12.z.coerce.date()
   }),
-  import_zod11.z.object({
-    status: import_zod11.z.literal("STARTED"),
-    updatedAt: import_zod11.z.coerce.date()
+  import_zod12.z.object({
+    status: import_zod12.z.literal("STARTED"),
+    updatedAt: import_zod12.z.coerce.date()
   }),
-  import_zod11.z.object({
-    status: import_zod11.z.literal("SUCCESS"),
+  import_zod12.z.object({
+    status: import_zod12.z.literal("SUCCESS"),
     stats: IndexEndpointStatsSchema,
-    updatedAt: import_zod11.z.coerce.date()
+    updatedAt: import_zod12.z.coerce.date()
   }),
-  import_zod11.z.object({
-    status: import_zod11.z.literal("FAILURE"),
+  import_zod12.z.object({
+    status: import_zod12.z.literal("FAILURE"),
     error: EndpointIndexErrorSchema,
-    updatedAt: import_zod11.z.coerce.date()
+    updatedAt: import_zod12.z.coerce.date()
   })
 ]);
-var EndpointHeadersSchema = import_zod11.z.object({
-  "trigger-version": import_zod11.z.string().optional(),
-  "trigger-sdk-version": import_zod11.z.string().optional()
+var EndpointHeadersSchema = import_zod12.z.object({
+  "trigger-version": import_zod12.z.string().optional(),
+  "trigger-sdk-version": import_zod12.z.string().optional()
 });
-var RawEventSchema = import_zod11.z.object({
+var RawEventSchema = import_zod12.z.object({
   /** The `name` property must exactly match any subscriptions you want to
     trigger. */
-  name: import_zod11.z.string(),
+  name: import_zod12.z.string(),
   /** The `payload` property will be sent to any matching Jobs and will appear
     as the `payload` param of the `run()` function. You can leave this
     parameter out if you just want to trigger a Job without any input data. */
-  payload: import_zod11.z.any(),
+  payload: import_zod12.z.any(),
   /** The optional `context` property will be sent to any matching Jobs and will
     be passed through as the `context.event.context` param of the `run()`
     function. This is optional but can be useful if you want to pass through
     some additional context to the Job. */
-  context: import_zod11.z.any().optional(),
+  context: import_zod12.z.any().optional(),
   /** The `id` property uniquely identify this particular event. If unset it
     will be set automatically using `ulid`. */
-  id: import_zod11.z.string().default(() => (0, import_ulid.ulid)()),
+  id: import_zod12.z.string().default(() => (0, import_ulid.ulid)()),
   /** This is optional, it defaults to the current timestamp. Usually you would
     only set this if you have a timestamp that you wish to pass through, e.g.
     you receive a timestamp from a service and you want the same timestamp to
     be used in your Job. */
-  timestamp: import_zod11.z.coerce.date().optional(),
+  timestamp: import_zod12.z.coerce.date().optional(),
   /** This is optional, it defaults to "trigger.dev". It can be useful to set
     this as you can filter events using this in the `eventTrigger()`. */
-  source: import_zod11.z.string().optional()
+  source: import_zod12.z.string().optional(),
+  /** This is optional, it defaults to "JSON". If your event is actually a request,
+    with a url, headers, method and rawBody you can use "REQUEST" */
+  payloadType: import_zod12.z.union([
+    import_zod12.z.literal("JSON"),
+    import_zod12.z.literal("REQUEST")
+  ]).optional()
 });
-var ApiEventLogSchema = import_zod11.z.object({
+var ApiEventLogSchema = import_zod12.z.object({
   /** The `id` of the event that was sent.
   */
-  id: import_zod11.z.string(),
+  id: import_zod12.z.string(),
   /** The `name` of the event that was sent. */
-  name: import_zod11.z.string(),
+  name: import_zod12.z.string(),
   /** The `payload` of the event that was sent */
   payload: DeserializedJsonSchema,
   /** The `context` of the event that was sent. Is `undefined` if no context was
     set when sending the event. */
   context: DeserializedJsonSchema.optional().nullable(),
   /** The `timestamp` of the event that was sent */
-  timestamp: import_zod11.z.coerce.date(),
+  timestamp: import_zod12.z.coerce.date(),
   /** The timestamp when the event will be delivered to any matching Jobs. Is
     `undefined` if `deliverAt` or `deliverAfter` wasn't set when sending the
     event. */
-  deliverAt: import_zod11.z.coerce.date().optional().nullable(),
+  deliverAt: import_zod12.z.coerce.date().optional().nullable(),
   /** The timestamp when the event was delivered. Is `undefined` if `deliverAt`
     or `deliverAfter` were set when sending the event. */
-  deliveredAt: import_zod11.z.coerce.date().optional().nullable(),
+  deliveredAt: import_zod12.z.coerce.date().optional().nullable(),
   /** The timestamp when the event was cancelled. Is `undefined` if the event
   * wasn't cancelled. */
-  cancelledAt: import_zod11.z.coerce.date().optional().nullable()
+  cancelledAt: import_zod12.z.coerce.date().optional().nullable()
 });
-var SendEventOptionsSchema = import_zod11.z.object({
+var SendEventOptionsSchema = import_zod12.z.object({
   /** An optional Date when you want the event to trigger Jobs. The event will
     be sent to the platform immediately but won't be acted upon until the
     specified time. */
-  deliverAt: import_zod11.z.coerce.date().optional(),
+  deliverAt: import_zod12.z.coerce.date().optional(),
   /** An optional number of seconds you want to wait for the event to trigger
     any relevant Jobs. The event will be sent to the platform immediately but
     won't be delivered until after the elapsed number of seconds. */
-  deliverAfter: import_zod11.z.number().int().optional(),
+  deliverAfter: import_zod12.z.number().int().optional(),
   /** This optional param will be used by Trigger.dev Connect, which
     is coming soon. */
-  accountId: import_zod11.z.string().optional()
+  accountId: import_zod12.z.string().optional()
 });
-var SendEventBodySchema = import_zod11.z.object({
+var SendEventBodySchema = import_zod12.z.object({
   event: RawEventSchema,
   options: SendEventOptionsSchema.optional()
 });
-var DeliverEventResponseSchema = import_zod11.z.object({
-  deliveredAt: import_zod11.z.string().datetime()
+var DeliverEventResponseSchema = import_zod12.z.object({
+  deliveredAt: import_zod12.z.string().datetime()
 });
-var RuntimeEnvironmentTypeSchema = import_zod11.z.enum([
+var RuntimeEnvironmentTypeSchema = import_zod12.z.enum([
   "PRODUCTION",
   "STAGING",
   "DEVELOPMENT",
   "PREVIEW"
 ]);
-var RunSourceContextSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  metadata: import_zod11.z.any()
+var RunSourceContextSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  metadata: import_zod12.z.any()
 });
-var AutoYieldConfigSchema = import_zod11.z.object({
-  startTaskThreshold: import_zod11.z.number(),
-  beforeExecuteTaskThreshold: import_zod11.z.number(),
-  beforeCompleteTaskThreshold: import_zod11.z.number(),
-  afterCompleteTaskThreshold: import_zod11.z.number()
+var AutoYieldConfigSchema = import_zod12.z.object({
+  startTaskThreshold: import_zod12.z.number(),
+  beforeExecuteTaskThreshold: import_zod12.z.number(),
+  beforeCompleteTaskThreshold: import_zod12.z.number(),
+  afterCompleteTaskThreshold: import_zod12.z.number()
 });
-var RunJobBodySchema = import_zod11.z.object({
+var RunJobBodySchema = import_zod12.z.object({
   event: ApiEventLogSchema,
-  job: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.z.string()
+  job: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    version: import_zod12.z.string()
   }),
-  run: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    isTest: import_zod11.z.boolean(),
-    isRetry: import_zod11.z.boolean().default(false),
-    startedAt: import_zod11.z.coerce.date()
+  run: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    isTest: import_zod12.z.boolean(),
+    isRetry: import_zod12.z.boolean().default(false),
+    startedAt: import_zod12.z.coerce.date()
   }),
-  environment: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    slug: import_zod11.z.string(),
+  environment: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    slug: import_zod12.z.string(),
     type: RuntimeEnvironmentTypeSchema
   }),
-  organization: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    title: import_zod11.z.string(),
-    slug: import_zod11.z.string()
+  organization: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    title: import_zod12.z.string(),
+    slug: import_zod12.z.string()
   }),
-  account: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    metadata: import_zod11.z.any()
+  project: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    name: import_zod12.z.string(),
+    slug: import_zod12.z.string()
+  }).optional(),
+  account: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    metadata: import_zod12.z.any()
   }).optional(),
   source: RunSourceContextSchema.optional(),
-  tasks: import_zod11.z.array(CachedTaskSchema).optional(),
-  cachedTaskCursor: import_zod11.z.string().optional(),
-  noopTasksSet: import_zod11.z.string().optional(),
-  connections: import_zod11.z.record(ConnectionAuthSchema).optional(),
-  yieldedExecutions: import_zod11.z.string().array().optional(),
-  runChunkExecutionLimit: import_zod11.z.number().optional(),
+  tasks: import_zod12.z.array(CachedTaskSchema).optional(),
+  cachedTaskCursor: import_zod12.z.string().optional(),
+  noopTasksSet: import_zod12.z.string().optional(),
+  connections: import_zod12.z.record(ConnectionAuthSchema).optional(),
+  yieldedExecutions: import_zod12.z.string().array().optional(),
+  runChunkExecutionLimit: import_zod12.z.number().optional(),
   autoYieldConfig: AutoYieldConfigSchema.optional()
 });
-var RunJobErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("ERROR"),
+var RunJobErrorSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("ERROR"),
   error: ErrorWithStackSchema,
   task: TaskSchema.optional()
 });
-var RunJobYieldExecutionErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("YIELD_EXECUTION"),
-  key: import_zod11.z.string()
-});
-var RunJobAutoYieldExecutionErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("AUTO_YIELD_EXECUTION"),
-  location: import_zod11.z.string(),
-  timeRemaining: import_zod11.z.number(),
-  timeElapsed: import_zod11.z.number(),
-  limit: import_zod11.z.number().optional()
-});
-var RunJobAutoYieldWithCompletedTaskExecutionErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK"),
-  id: import_zod11.z.string(),
-  properties: import_zod11.z.array(DisplayPropertySchema).optional(),
-  output: import_zod11.z.any(),
-  data: import_zod11.z.object({
-    location: import_zod11.z.string(),
-    timeRemaining: import_zod11.z.number(),
-    timeElapsed: import_zod11.z.number(),
-    limit: import_zod11.z.number().optional()
-  })
+var RunJobYieldExecutionErrorSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("YIELD_EXECUTION"),
+  key: import_zod12.z.string()
 });
-var RunJobInvalidPayloadErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("INVALID_PAYLOAD"),
-  errors: import_zod11.z.array(SchemaErrorSchema)
+var AutoYieldMetadataSchema = import_zod12.z.object({
+  location: import_zod12.z.string(),
+  timeRemaining: import_zod12.z.number(),
+  timeElapsed: import_zod12.z.number(),
+  limit: import_zod12.z.number().optional()
 });
-var RunJobUnresolvedAuthErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("UNRESOLVED_AUTH_ERROR"),
-  issues: import_zod11.z.record(import_zod11.z.object({
-    id: import_zod11.z.string(),
-    error: import_zod11.z.string()
+var RunJobAutoYieldExecutionErrorSchema = AutoYieldMetadataSchema.extend({
+  status: import_zod12.z.literal("AUTO_YIELD_EXECUTION")
+});
+var RunJobAutoYieldWithCompletedTaskExecutionErrorSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK"),
+  id: import_zod12.z.string(),
+  properties: import_zod12.z.array(DisplayPropertySchema).optional(),
+  output: import_zod12.z.string().optional(),
+  data: AutoYieldMetadataSchema
+});
+var RunJobInvalidPayloadErrorSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("INVALID_PAYLOAD"),
+  errors: import_zod12.z.array(SchemaErrorSchema)
+});
+var RunJobUnresolvedAuthErrorSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("UNRESOLVED_AUTH_ERROR"),
+  issues: import_zod12.z.record(import_zod12.z.object({
+    id: import_zod12.z.string(),
+    error: import_zod12.z.string()
   }))
 });
-var RunJobResumeWithTaskSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("RESUME_WITH_TASK"),
+var RunJobResumeWithTaskSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("RESUME_WITH_TASK"),
   task: TaskSchema
 });
-var RunJobRetryWithTaskSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("RETRY_WITH_TASK"),
+var RunJobRetryWithTaskSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("RETRY_WITH_TASK"),
   task: TaskSchema,
   error: ErrorWithStackSchema,
-  retryAt: import_zod11.z.coerce.date()
+  retryAt: import_zod12.z.coerce.date()
 });
-var RunJobCanceledWithTaskSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("CANCELED"),
+var RunJobCanceledWithTaskSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("CANCELED"),
   task: TaskSchema
 });
-var RunJobSuccessSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("SUCCESS"),
+var RunJobSuccessSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("SUCCESS"),
   output: DeserializedJsonSchema.optional()
 });
-var RunJobResponseSchema = import_zod11.z.discriminatedUnion("status", [
+var RunJobErrorResponseSchema = import_zod12.z.union([
   RunJobAutoYieldExecutionErrorSchema,
   RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
   RunJobYieldExecutionErrorSchema,
@@ -1200,138 +1310,156 @@ var RunJobResponseSchema = import_zod11.z.discriminatedUnion("status", [
   RunJobInvalidPayloadErrorSchema,
   RunJobResumeWithTaskSchema,
   RunJobRetryWithTaskSchema,
+  RunJobCanceledWithTaskSchema
+]);
+var RunJobResumeWithParallelTaskSchema = import_zod12.z.object({
+  status: import_zod12.z.literal("RESUME_WITH_PARALLEL_TASK"),
+  task: TaskSchema,
+  childErrors: import_zod12.z.array(RunJobErrorResponseSchema)
+});
+var RunJobResponseSchema = import_zod12.z.discriminatedUnion("status", [
+  RunJobAutoYieldExecutionErrorSchema,
+  RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
+  RunJobYieldExecutionErrorSchema,
+  RunJobErrorSchema,
+  RunJobUnresolvedAuthErrorSchema,
+  RunJobInvalidPayloadErrorSchema,
+  RunJobResumeWithTaskSchema,
+  RunJobResumeWithParallelTaskSchema,
+  RunJobRetryWithTaskSchema,
   RunJobCanceledWithTaskSchema,
   RunJobSuccessSchema
 ]);
-var PreprocessRunBodySchema = import_zod11.z.object({
+var PreprocessRunBodySchema = import_zod12.z.object({
   event: ApiEventLogSchema,
-  job: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.z.string()
+  job: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    version: import_zod12.z.string()
   }),
-  run: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    isTest: import_zod11.z.boolean()
+  run: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    isTest: import_zod12.z.boolean()
   }),
-  environment: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    slug: import_zod11.z.string(),
+  environment: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    slug: import_zod12.z.string(),
     type: RuntimeEnvironmentTypeSchema
   }),
-  organization: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    title: import_zod11.z.string(),
-    slug: import_zod11.z.string()
+  organization: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    title: import_zod12.z.string(),
+    slug: import_zod12.z.string()
   }),
-  account: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    metadata: import_zod11.z.any()
+  account: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    metadata: import_zod12.z.any()
   }).optional()
 });
-var PreprocessRunResponseSchema = import_zod11.z.object({
-  abort: import_zod11.z.boolean(),
-  properties: import_zod11.z.array(DisplayPropertySchema).optional()
+var PreprocessRunResponseSchema = import_zod12.z.object({
+  abort: import_zod12.z.boolean(),
+  properties: import_zod12.z.array(DisplayPropertySchema).optional()
 });
-var CreateRunResponseOkSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(true),
-  data: import_zod11.z.object({
-    id: import_zod11.z.string()
+var CreateRunResponseOkSchema = import_zod12.z.object({
+  ok: import_zod12.z.literal(true),
+  data: import_zod12.z.object({
+    id: import_zod12.z.string()
   })
 });
-var CreateRunResponseErrorSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(false),
-  error: import_zod11.z.string()
+var CreateRunResponseErrorSchema = import_zod12.z.object({
+  ok: import_zod12.z.literal(false),
+  error: import_zod12.z.string()
 });
-var CreateRunResponseBodySchema = import_zod11.z.discriminatedUnion("ok", [
+var CreateRunResponseBodySchema = import_zod12.z.discriminatedUnion("ok", [
   CreateRunResponseOkSchema,
   CreateRunResponseErrorSchema
 ]);
-var RedactStringSchema = import_zod11.z.object({
-  __redactedString: import_zod11.z.literal(true),
-  strings: import_zod11.z.array(import_zod11.z.string()),
-  interpolations: import_zod11.z.array(import_zod11.z.string())
+var RedactStringSchema = import_zod12.z.object({
+  __redactedString: import_zod12.z.literal(true),
+  strings: import_zod12.z.array(import_zod12.z.string()),
+  interpolations: import_zod12.z.array(import_zod12.z.string())
 });
-var LogMessageSchema = import_zod11.z.object({
-  level: import_zod11.z.enum([
+var LogMessageSchema = import_zod12.z.object({
+  level: import_zod12.z.enum([
     "DEBUG",
     "INFO",
     "WARN",
     "ERROR"
   ]),
-  message: import_zod11.z.string(),
+  message: import_zod12.z.string(),
   data: SerializableJsonSchema.optional()
 });
-var RedactSchema = import_zod11.z.object({
-  paths: import_zod11.z.array(import_zod11.z.string())
+var RedactSchema = import_zod12.z.object({
+  paths: import_zod12.z.array(import_zod12.z.string())
 });
-var RetryOptionsSchema = import_zod11.z.object({
+var RetryOptionsSchema = import_zod12.z.object({
   /** The maximum number of times to retry the request. */
-  limit: import_zod11.z.number().optional(),
+  limit: import_zod12.z.number().optional(),
   /** The exponential factor to use when calculating the next retry time. */
-  factor: import_zod11.z.number().optional(),
+  factor: import_zod12.z.number().optional(),
   /** The minimum amount of time to wait before retrying the request. */
-  minTimeoutInMs: import_zod11.z.number().optional(),
+  minTimeoutInMs: import_zod12.z.number().optional(),
   /** The maximum amount of time to wait before retrying the request. */
-  maxTimeoutInMs: import_zod11.z.number().optional(),
+  maxTimeoutInMs: import_zod12.z.number().optional(),
   /** Whether to randomize the retry time. */
-  randomize: import_zod11.z.boolean().optional()
+  randomize: import_zod12.z.boolean().optional()
 });
-var RunTaskOptionsSchema = import_zod11.z.object({
+var RunTaskOptionsSchema = import_zod12.z.object({
   /** The name of the Task is required. This is displayed on the Task in the logs. */
-  name: import_zod11.z.string().optional(),
+  name: import_zod12.z.string().optional(),
   /** The Task will wait and only start at the specified Date  */
-  delayUntil: import_zod11.z.coerce.date().optional(),
+  delayUntil: import_zod12.z.coerce.date().optional(),
   /** Retry options */
   retry: RetryOptionsSchema.optional(),
   /** The icon for the Task, it will appear in the logs.
   *  You can use the name of a company in lowercase, e.g. "github".
   *  Or any icon name that [Tabler Icons](https://tabler-icons.io/) supports. */
-  icon: import_zod11.z.string().optional(),
+  icon: import_zod12.z.string().optional(),
   /** The key for the Task that you want to appear in the logs */
-  displayKey: import_zod11.z.string().optional(),
+  displayKey: import_zod12.z.string().optional(),
   /** A description of the Task */
-  description: import_zod11.z.string().optional(),
+  description: import_zod12.z.string().optional(),
   /** Properties that are displayed in the logs */
-  properties: import_zod11.z.array(DisplayPropertySchema).optional(),
+  properties: import_zod12.z.array(DisplayPropertySchema).optional(),
   /** The input params to the Task, will be displayed in the logs  */
-  params: import_zod11.z.any(),
+  params: import_zod12.z.any(),
   /** The style of the log entry. */
   style: StyleSchema.optional(),
   /** Allows you to expose a `task.callbackUrl` to use in your tasks. Enabling this feature will cause the task to return the data sent to the callbackUrl instead of the usual async callback result. */
-  callback: import_zod11.z.object({
+  callback: import_zod12.z.object({
     /** Causes the task to wait for and return the data of the first request sent to `task.callbackUrl`. */
-    enabled: import_zod11.z.boolean(),
+    enabled: import_zod12.z.boolean(),
     /** Time to wait for the first request to `task.callbackUrl`. Default: One hour. */
-    timeoutInSeconds: import_zod11.z.number()
+    timeoutInSeconds: import_zod12.z.number()
   }).partial().optional(),
   /** Allows you to link the Integration connection in the logs. This is handled automatically in integrations.  */
-  connectionKey: import_zod11.z.string().optional(),
+  connectionKey: import_zod12.z.string().optional(),
   /** An operation you want to perform on the Trigger.dev platform, current only "fetch" is supported. If you wish to `fetch` use [`io.backgroundFetch()`](https://trigger.dev/docs/sdk/io/backgroundfetch) instead. */
-  operation: import_zod11.z.enum([
+  operation: import_zod12.z.enum([
     "fetch"
   ]).optional(),
   /** A No Operation means that the code won't be executed. This is used internally to implement features like [io.wait()](https://trigger.dev/docs/sdk/io/wait).  */
-  noop: import_zod11.z.boolean().default(false),
+  noop: import_zod12.z.boolean().default(false),
   redact: RedactSchema.optional(),
-  trigger: TriggerMetadataSchema.optional()
+  trigger: TriggerMetadataSchema.optional(),
+  parallel: import_zod12.z.boolean().optional()
 });
 var RunTaskBodyInputSchema = RunTaskOptionsSchema.extend({
-  idempotencyKey: import_zod11.z.string(),
-  parentId: import_zod11.z.string().optional()
+  idempotencyKey: import_zod12.z.string(),
+  parentId: import_zod12.z.string().optional()
 });
 var RunTaskBodyOutputSchema = RunTaskBodyInputSchema.extend({
-  properties: import_zod11.z.array(DisplayPropertySchema.partial()).optional(),
+  properties: import_zod12.z.array(DisplayPropertySchema.partial()).optional(),
   params: DeserializedJsonSchema.optional().nullable(),
-  callback: import_zod11.z.object({
-    enabled: import_zod11.z.boolean(),
-    timeoutInSeconds: import_zod11.z.number().default(3600)
+  callback: import_zod12.z.object({
+    enabled: import_zod12.z.boolean(),
+    timeoutInSeconds: import_zod12.z.number().default(3600)
   }).optional()
 });
-var RunTaskResponseWithCachedTasksBodySchema = import_zod11.z.object({
+var RunTaskResponseWithCachedTasksBodySchema = import_zod12.z.object({
   task: ServerTaskSchema,
-  cachedTasks: import_zod11.z.object({
-    tasks: import_zod11.z.array(CachedTaskSchema),
-    cursor: import_zod11.z.string().optional()
+  cachedTasks: import_zod12.z.object({
+    tasks: import_zod12.z.array(CachedTaskSchema),
+    cursor: import_zod12.z.string().optional()
   }).optional()
 });
 var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
@@ -1341,202 +1469,240 @@ var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
 }).extend({
   output: SerializableJsonSchema.optional().transform((v) => v ? DeserializedJsonSchema.parse(JSON.parse(JSON.stringify(v))) : {})
 });
-var FailTaskBodyInputSchema = import_zod11.z.object({
+var CompleteTaskBodyV2InputSchema = RunTaskBodyInputSchema.pick({
+  properties: true,
+  description: true,
+  params: true
+}).extend({
+  output: import_zod12.z.string().optional()
+});
+var FailTaskBodyInputSchema = import_zod12.z.object({
   error: ErrorWithStackSchema
 });
-var NormalizedRequestSchema = import_zod11.z.object({
-  headers: import_zod11.z.record(import_zod11.z.string()),
-  method: import_zod11.z.string(),
-  query: import_zod11.z.record(import_zod11.z.string()),
-  url: import_zod11.z.string(),
-  body: import_zod11.z.any()
+var NormalizedRequestSchema = import_zod12.z.object({
+  headers: import_zod12.z.record(import_zod12.z.string()),
+  method: import_zod12.z.string(),
+  query: import_zod12.z.record(import_zod12.z.string()),
+  url: import_zod12.z.string(),
+  body: import_zod12.z.any()
 });
-var NormalizedResponseSchema = import_zod11.z.object({
-  status: import_zod11.z.number(),
-  body: import_zod11.z.any(),
-  headers: import_zod11.z.record(import_zod11.z.string()).optional()
+var NormalizedResponseSchema = import_zod12.z.object({
+  status: import_zod12.z.number(),
+  body: import_zod12.z.any(),
+  headers: import_zod12.z.record(import_zod12.z.string()).optional()
 });
-var HttpSourceResponseSchema = import_zod11.z.object({
+var HttpSourceResponseSchema = import_zod12.z.object({
   response: NormalizedResponseSchema,
-  events: import_zod11.z.array(RawEventSchema),
+  events: import_zod12.z.array(RawEventSchema),
   metadata: HttpSourceResponseMetadataSchema.optional()
 });
-var RegisterTriggerBodySchemaV1 = import_zod11.z.object({
+var RegisterTriggerBodySchemaV1 = import_zod12.z.object({
   rule: EventRuleSchema,
   source: SourceMetadataV1Schema
 });
-var RegisterTriggerBodySchemaV2 = import_zod11.z.object({
+var RegisterTriggerBodySchemaV2 = import_zod12.z.object({
   rule: EventRuleSchema,
   source: SourceMetadataV2Schema,
-  accountId: import_zod11.z.string().optional()
+  accountId: import_zod12.z.string().optional()
 });
-var InitializeTriggerBodySchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  params: import_zod11.z.any(),
-  accountId: import_zod11.z.string().optional(),
-  metadata: import_zod11.z.any().optional()
+var InitializeTriggerBodySchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  params: import_zod12.z.any(),
+  accountId: import_zod12.z.string().optional(),
+  metadata: import_zod12.z.any().optional()
 });
-var RegisterCommonScheduleBodySchema = import_zod11.z.object({
+var RegisterCommonScheduleBodySchema = import_zod12.z.object({
   /** A unique id for the schedule. This is used to identify and unregister the schedule later. */
-  id: import_zod11.z.string(),
+  id: import_zod12.z.string(),
   /** Any additional metadata about the schedule. */
-  metadata: import_zod11.z.any(),
+  metadata: import_zod12.z.any(),
   /** An optional Account ID to associate with runs triggered by this schedule */
-  accountId: import_zod11.z.string().optional()
+  accountId: import_zod12.z.string().optional()
 });
 var RegisterIntervalScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(IntervalMetadataSchema);
 var InitializeCronScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(CronMetadataSchema);
-var RegisterScheduleBodySchema = import_zod11.z.discriminatedUnion("type", [
+var RegisterScheduleBodySchema = import_zod12.z.discriminatedUnion("type", [
   RegisterIntervalScheduleBodySchema,
   InitializeCronScheduleBodySchema
 ]);
-var RegisterScheduleResponseBodySchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
+var RegisterScheduleResponseBodySchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
   schedule: ScheduleMetadataSchema,
-  metadata: import_zod11.z.any(),
-  active: import_zod11.z.boolean()
+  metadata: import_zod12.z.any(),
+  active: import_zod12.z.boolean()
 });
-var CreateExternalConnectionBodySchema = import_zod11.z.object({
-  accessToken: import_zod11.z.string(),
-  type: import_zod11.z.enum([
+var CreateExternalConnectionBodySchema = import_zod12.z.object({
+  accessToken: import_zod12.z.string(),
+  type: import_zod12.z.enum([
     "oauth2"
   ]),
-  scopes: import_zod11.z.array(import_zod11.z.string()).optional(),
-  metadata: import_zod11.z.any()
+  scopes: import_zod12.z.array(import_zod12.z.string()).optional(),
+  metadata: import_zod12.z.any()
 });
-var GetRunStatusesSchema = import_zod11.z.object({
-  run: import_zod11.z.object({
-    id: import_zod11.z.string(),
+var GetRunStatusesSchema = import_zod12.z.object({
+  run: import_zod12.z.object({
+    id: import_zod12.z.string(),
     status: RunStatusSchema,
-    output: import_zod11.z.any().optional()
+    output: import_zod12.z.any().optional()
   }),
-  statuses: import_zod11.z.array(JobRunStatusRecordSchema)
+  statuses: import_zod12.z.array(JobRunStatusRecordSchema)
+});
+var InvokeJobResponseSchema = import_zod12.z.object({
+  id: import_zod12.z.string()
+});
+var InvokeJobRequestBodySchema = import_zod12.z.object({
+  payload: import_zod12.z.any(),
+  context: import_zod12.z.any().optional(),
+  options: import_zod12.z.object({
+    accountId: import_zod12.z.string().optional(),
+    callbackUrl: import_zod12.z.string().optional()
+  }).optional()
+});
+var InvokeOptionsSchema = import_zod12.z.object({
+  accountId: import_zod12.z.string().optional(),
+  idempotencyKey: import_zod12.z.string().optional(),
+  context: import_zod12.z.any().optional(),
+  callbackUrl: import_zod12.z.string().optional()
 });
 
 // src/schemas/notifications.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var MISSING_CONNECTION_NOTIFICATION = "dev.trigger.notifications.missingConnection";
 var MISSING_CONNECTION_RESOLVED_NOTIFICATION = "dev.trigger.notifications.missingConnectionResolved";
-var CommonMissingConnectionNotificationPayloadSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  client: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    title: import_zod12.z.string(),
-    scopes: import_zod12.z.array(import_zod12.z.string()),
-    createdAt: import_zod12.z.coerce.date(),
-    updatedAt: import_zod12.z.coerce.date()
+var CommonMissingConnectionNotificationPayloadSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  client: import_zod13.z.object({
+    id: import_zod13.z.string(),
+    title: import_zod13.z.string(),
+    scopes: import_zod13.z.array(import_zod13.z.string()),
+    createdAt: import_zod13.z.coerce.date(),
+    updatedAt: import_zod13.z.coerce.date()
   }),
-  authorizationUrl: import_zod12.z.string()
+  authorizationUrl: import_zod13.z.string()
 });
 var MissingDeveloperConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod12.z.literal("DEVELOPER")
+  type: import_zod13.z.literal("DEVELOPER")
 });
 var MissingExternalConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod12.z.literal("EXTERNAL"),
-  account: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    metadata: import_zod12.z.any()
+  type: import_zod13.z.literal("EXTERNAL"),
+  account: import_zod13.z.object({
+    id: import_zod13.z.string(),
+    metadata: import_zod13.z.any()
   })
 });
-var MissingConnectionNotificationPayloadSchema = import_zod12.z.discriminatedUnion("type", [
+var MissingConnectionNotificationPayloadSchema = import_zod13.z.discriminatedUnion("type", [
   MissingDeveloperConnectionNotificationPayloadSchema,
   MissingExternalConnectionNotificationPayloadSchema
 ]);
-var CommonMissingConnectionNotificationResolvedPayloadSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  client: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    title: import_zod12.z.string(),
-    scopes: import_zod12.z.array(import_zod12.z.string()),
-    createdAt: import_zod12.z.coerce.date(),
-    updatedAt: import_zod12.z.coerce.date(),
-    integrationIdentifier: import_zod12.z.string(),
-    integrationAuthMethod: import_zod12.z.string()
+var CommonMissingConnectionNotificationResolvedPayloadSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  client: import_zod13.z.object({
+    id: import_zod13.z.string(),
+    title: import_zod13.z.string(),
+    scopes: import_zod13.z.array(import_zod13.z.string()),
+    createdAt: import_zod13.z.coerce.date(),
+    updatedAt: import_zod13.z.coerce.date(),
+    integrationIdentifier: import_zod13.z.string(),
+    integrationAuthMethod: import_zod13.z.string()
   }),
-  expiresAt: import_zod12.z.coerce.date()
+  expiresAt: import_zod13.z.coerce.date()
 });
 var MissingDeveloperConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod12.z.literal("DEVELOPER")
+  type: import_zod13.z.literal("DEVELOPER")
 });
 var MissingExternalConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod12.z.literal("EXTERNAL"),
-  account: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    metadata: import_zod12.z.any()
+  type: import_zod13.z.literal("EXTERNAL"),
+  account: import_zod13.z.object({
+    id: import_zod13.z.string(),
+    metadata: import_zod13.z.any()
   })
 });
-var MissingConnectionResolvedNotificationPayloadSchema = import_zod12.z.discriminatedUnion("type", [
+var MissingConnectionResolvedNotificationPayloadSchema = import_zod13.z.discriminatedUnion("type", [
   MissingDeveloperConnectionResolvedNotificationPayloadSchema,
   MissingExternalConnectionResolvedNotificationPayloadSchema
 ]);
 
 // src/schemas/fetch.ts
-var import_zod13 = require("zod");
-var FetchRetryHeadersStrategySchema = import_zod13.z.object({
+var import_zod14 = require("zod");
+var FetchRetryHeadersStrategySchema = import_zod14.z.object({
   /** The `headers` strategy retries the request using info from the response headers. */
-  strategy: import_zod13.z.literal("headers"),
+  strategy: import_zod14.z.literal("headers"),
   /** The header to use to determine the maximum number of times to retry the request. */
-  limitHeader: import_zod13.z.string(),
+  limitHeader: import_zod14.z.string(),
   /** The header to use to determine the number of remaining retries. */
-  remainingHeader: import_zod13.z.string(),
+  remainingHeader: import_zod14.z.string(),
   /** The header to use to determine the time when the number of remaining retries will be reset. */
-  resetHeader: import_zod13.z.string()
+  resetHeader: import_zod14.z.string()
 });
 var FetchRetryBackoffStrategySchema = RetryOptionsSchema.extend({
   /** The `backoff` strategy retries the request with an exponential backoff. */
-  strategy: import_zod13.z.literal("backoff")
+  strategy: import_zod14.z.literal("backoff")
 });
-var FetchRetryStrategySchema = import_zod13.z.discriminatedUnion("strategy", [
+var FetchRetryStrategySchema = import_zod14.z.discriminatedUnion("strategy", [
   FetchRetryHeadersStrategySchema,
   FetchRetryBackoffStrategySchema
 ]);
-var FetchRequestInitSchema = import_zod13.z.object({
+var FetchRequestInitSchema = import_zod14.z.object({
   /** The HTTP method to use for the request. */
-  method: import_zod13.z.string().optional(),
+  method: import_zod14.z.string().optional(),
   /** Any headers to send with the request. Note that you can use [redactString](https://trigger.dev/docs/sdk/redactString) to prevent sensitive information from being stored (e.g. in the logs), like API keys and tokens. */
-  headers: import_zod13.z.record(import_zod13.z.union([
-    import_zod13.z.string(),
+  headers: import_zod14.z.record(import_zod14.z.union([
+    import_zod14.z.string(),
     RedactStringSchema
   ])).optional(),
   /** The body of the request. */
-  body: import_zod13.z.union([
-    import_zod13.z.string(),
-    import_zod13.z.instanceof(ArrayBuffer)
+  body: import_zod14.z.union([
+    import_zod14.z.string(),
+    import_zod14.z.instanceof(ArrayBuffer)
   ]).optional()
 });
-var FetchRetryOptionsSchema = import_zod13.z.record(FetchRetryStrategySchema);
-var FetchOperationSchema = import_zod13.z.object({
-  url: import_zod13.z.string(),
+var FetchRetryOptionsSchema = import_zod14.z.record(FetchRetryStrategySchema);
+var FetchTimeoutOptionsSchema = import_zod14.z.object({
+  durationInMs: import_zod14.z.number(),
+  retry: RetryOptionsSchema.optional()
+});
+var FetchOperationSchema = import_zod14.z.object({
+  url: import_zod14.z.string(),
   requestInit: FetchRequestInitSchema.optional(),
-  retry: import_zod13.z.record(FetchRetryStrategySchema).optional()
+  retry: import_zod14.z.record(FetchRetryStrategySchema).optional(),
+  timeout: FetchTimeoutOptionsSchema.optional()
 });
 
 // src/schemas/events.ts
-var import_zod14 = require("zod");
-var GetEventSchema = import_zod14.z.object({
+var import_zod15 = require("zod");
+var GetEventSchema = import_zod15.z.object({
   /** The event id */
-  id: import_zod14.z.string(),
+  id: import_zod15.z.string(),
   /** The event name */
-  name: import_zod14.z.string(),
+  name: import_zod15.z.string(),
   /** When the event was created */
-  createdAt: import_zod14.z.coerce.date(),
+  createdAt: import_zod15.z.coerce.date(),
   /** When the event was last updated */
-  updatedAt: import_zod14.z.coerce.date(),
+  updatedAt: import_zod15.z.coerce.date(),
   /** The runs that were triggered by the event */
-  runs: import_zod14.z.array(import_zod14.z.object({
+  runs: import_zod15.z.array(import_zod15.z.object({
     /** The Run id */
-    id: import_zod14.z.string(),
+    id: import_zod15.z.string(),
     /** The Run status */
     status: RunStatusSchema,
     /** When the run started */
-    startedAt: import_zod14.z.coerce.date().optional().nullable(),
+    startedAt: import_zod15.z.coerce.date().optional().nullable(),
     /** When the run completed */
-    completedAt: import_zod14.z.coerce.date().optional().nullable()
+    completedAt: import_zod15.z.coerce.date().optional().nullable()
   }))
 });
-var CancelRunsForEventSchema = import_zod14.z.object({
-  cancelledRunIds: import_zod14.z.array(import_zod14.z.string()),
-  failedToCancelRunIds: import_zod14.z.array(import_zod14.z.string())
+var CancelRunsForEventSchema = import_zod15.z.object({
+  cancelledRunIds: import_zod15.z.array(import_zod15.z.string()),
+  failedToCancelRunIds: import_zod15.z.array(import_zod15.z.string())
+});
+
+// src/schemas/request.ts
+var import_zod16 = require("zod");
+var RequestWithRawBodySchema = import_zod16.z.object({
+  url: import_zod16.z.string(),
+  method: import_zod16.z.string(),
+  headers: import_zod16.z.record(import_zod16.z.string()),
+  rawBody: import_zod16.z.string()
 });
 
 // src/utils.ts
@@ -1623,6 +1789,13 @@ __name(urlWithSearchParams, "urlWithSearchParams");
 
 // src/eventFilterMatches.ts
 function eventFilterMatches(payload, filter) {
+  if (payload === void 0 || payload === null) {
+    if (Object.entries(filter).length === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
   for (const [patternKey, patternValue] of Object.entries(filter)) {
     const payloadValue = payload[patternKey];
     if (Array.isArray(patternValue)) {
@@ -1763,61 +1936,48 @@ function contentFilterMatches(actualValue, contentFilter) {
 }
 __name(contentFilterMatches, "contentFilterMatches");
 
-// src/bloom.ts
-var import_node_buffer = require("buffer");
-var _BloomFilter = class _BloomFilter {
-  constructor(size) {
-    this.size = size;
-    this.bitArray = new Uint8Array(Math.ceil(size / 8));
+// src/requestFilterMatches.ts
+async function requestFilterMatches(request, filter) {
+  const clonedRequest = request.clone();
+  if (!requestMethodMatches(clonedRequest.method, filter.method)) {
+    return false;
   }
-  add(item) {
-    const index = murmurHash3(item) % this.size;
-    this.bitArray[Math.floor(index / 8)] |= 1 << index % 8;
+  if (filter.headers && !eventFilterMatches(clonedRequest.headers, filter.headers)) {
+    return false;
   }
-  test(item) {
-    const index = murmurHash3(item) % this.size;
-    return (this.bitArray[Math.floor(index / 8)] & 1 << index % 8) !== 0;
+  const searchParams = new URL(clonedRequest.url).searchParams;
+  const searchParamsObject = {};
+  for (const [key, value] of searchParams.entries()) {
+    searchParamsObject[key] = value;
   }
-  // Serialize to a Base64 string
-  serialize() {
-    return import_node_buffer.Buffer.from(this.bitArray).toString("base64");
+  if (filter.query && !eventFilterMatches(searchParamsObject, filter.query)) {
+    return false;
   }
-  // Deserialize from a Base64 string
-  static deserialize(str, size) {
-    const filter = new _BloomFilter(size);
-    filter.bitArray = Uint8Array.from(import_node_buffer.Buffer.from(str, "base64"));
-    return filter;
+  try {
+    const json = await clonedRequest.json();
+    if (filter.body && !eventFilterMatches(json, filter.body)) {
+      return false;
+    }
+  } catch (e) {
+    if (filter.body) {
+      return false;
+    }
   }
-};
-__name(_BloomFilter, "BloomFilter");
-__publicField(_BloomFilter, "NOOP_TASK_SET_SIZE", 32768);
-var BloomFilter = _BloomFilter;
-function murmurHash3(str, seed = 0) {
-  let h1 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
-  for (let i = 0, ch; i < str.length; i++) {
-    ch = str.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 3432918353);
-    h1 = h1 << 15 | h1 >>> 17;
-    h1 = Math.imul(h1, 461845907);
-    h2 = Math.imul(h2 ^ ch, 2246822507);
-    h2 = h2 << 13 | h2 >>> 19;
-    h2 = Math.imul(h2, 3266489909);
+  return true;
+}
+__name(requestFilterMatches, "requestFilterMatches");
+function requestMethodMatches(method, filter) {
+  if (!filter) {
+    return true;
   }
-  h1 ^= str.length;
-  h2 ^= str.length;
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
-  h1 = Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  h1 ^= h1 >>> 16;
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
-  h2 = Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 ^= h2 >>> 16;
-  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+  return filter.includes(method);
 }
-__name(murmurHash3, "murmurHash3");
+__name(requestMethodMatches, "requestMethodMatches");
 
 // src/index.ts
 var API_VERSIONS = {
-  LAZY_LOADED_CACHED_TASKS: "2023-09-29"
+  LAZY_LOADED_CACHED_TASKS: "2023-09-29",
+  SERIALIZED_TASK_OUTPUT: "2023-11-01"
 };
 var PLATFORM_FEATURES = {
   yieldExecution: API_VERSIONS.LAZY_LOADED_CACHED_TASKS,