@trigger.dev/core 0.0.0-prerelease-20240219135254 → 0.0.0-prerelease-20240408121557

package/dist/v3/index.js

@@ -2,12 +2,27 @@
 
 var zod = require('zod');
 var api = require('@opentelemetry/api');
-var node_async_hooks = require('node:async_hooks');
+var async_hooks = require('async_hooks');
+var socket_ioClient = require('socket.io-client');
+var crypto = require('crypto');
+var nodePath = require('path');
 var apiLogs = require('@opentelemetry/api-logs');
-var util = require('node:util');
+var preciseDate = require('@google-cloud/precise-date');
+var humanizeDuration = require('humanize-duration');
+var promises = require('timers/promises');
+var util = require('util');
+var exporterLogsOtlpHttp = require('@opentelemetry/exporter-logs-otlp-http');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var instrumentation = require('@opentelemetry/instrumentation');
+var resources = require('@opentelemetry/resources');
+var sdkLogs = require('@opentelemetry/sdk-logs');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var nodePath__default = /*#__PURE__*/_interopDefault(nodePath);
+var humanizeDuration__default = /*#__PURE__*/_interopDefault(humanizeDuration);
 var util__default = /*#__PURE__*/_interopDefault(util);
 
 var __defProp = Object.defineProperty;
@@ -35,6 +50,14 @@ var __privateSet = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
 var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
@@ -52,48 +75,6 @@ var GetPersonalAccessTokenResponseSchema = zod.z.object({
     obfuscatedToken: zod.z.string()
   }).nullable()
 });
-var TaskResource = zod.z.object({
-  id: zod.z.string(),
-  filePath: zod.z.string(),
-  exportName: zod.z.string()
-});
-var BackgroundWorkerMetadata = zod.z.object({
-  packageVersion: zod.z.string(),
-  contentHash: zod.z.string(),
-  cliPackageVersion: zod.z.string(),
-  tasks: zod.z.array(TaskResource)
-});
-
-// src/v3/schemas/api.ts
-var WhoAmIResponseSchema = zod.z.object({
-  userId: zod.z.string(),
-  email: zod.z.string().email()
-});
-var GetProjectDevResponse = zod.z.object({
-  apiKey: zod.z.string(),
-  name: zod.z.string()
-});
-var CreateBackgroundWorkerRequestBody = zod.z.object({
-  localOnly: zod.z.boolean(),
-  metadata: BackgroundWorkerMetadata
-});
-var CreateBackgroundWorkerResponse = zod.z.object({
-  id: zod.z.string(),
-  version: zod.z.string(),
-  contentHash: zod.z.string()
-});
-var BackgroundWorkerRecord = CreateBackgroundWorkerResponse;
-var TriggerTaskRequestBody = zod.z.object({
-  payload: zod.z.any(),
-  context: zod.z.any(),
-  options: zod.z.object({
-    parentAttempt: zod.z.string().optional(),
-    lockToCurrentVersion: zod.z.boolean().optional()
-  }).optional()
-});
-var TriggerTaskResponse = zod.z.object({
-  id: zod.z.string()
-});
 var TaskRunBuiltInError = zod.z.object({
   type: zod.z.literal("BUILT_IN_ERROR"),
   name: zod.z.string(),
@@ -109,13 +90,30 @@ var TaskRunStringError = zod.z.object({
   raw: zod.z.string()
 });
 var TaskRunErrorCodes = {
-  COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR"
+  COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR",
+  CONFIGURED_INCORRECTLY: "CONFIGURED_INCORRECTLY",
+  TASK_ALREADY_RUNNING: "TASK_ALREADY_RUNNING",
+  TASK_EXECUTION_FAILED: "TASK_EXECUTION_FAILED",
+  TASK_EXECUTION_ABORTED: "TASK_EXECUTION_ABORTED",
+  TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE: "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+  TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
+  TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
+  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR"
 };
 var TaskRunInternalError = zod.z.object({
   type: zod.z.literal("INTERNAL_ERROR"),
   code: zod.z.enum([
-    "COULD_NOT_FIND_EXECUTOR"
-  ])
+    "COULD_NOT_FIND_EXECUTOR",
+    "CONFIGURED_INCORRECTLY",
+    "TASK_ALREADY_RUNNING",
+    "TASK_EXECUTION_FAILED",
+    "TASK_EXECUTION_ABORTED",
+    "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+    "TASK_RUN_CANCELLED",
+    "TASK_OUTPUT_ERROR",
+    "HANDLE_ERROR_ERROR"
+  ]),
+  message: zod.z.string().optional()
 });
 var TaskRunError = zod.z.discriminatedUnion("type", [
   TaskRunBuiltInError,
@@ -129,6 +127,7 @@ var TaskRun = zod.z.object({
   payloadType: zod.z.string(),
   context: zod.z.any(),
   tags: zod.z.array(zod.z.string()),
+  isTest: zod.z.boolean().default(false),
   createdAt: zod.z.coerce.date()
 });
 var TaskRunExecutionTask = zod.z.object({
@@ -165,13 +164,22 @@ var TaskRunExecutionProject = zod.z.object({
   slug: zod.z.string(),
   name: zod.z.string()
 });
+var TaskRunExecutionQueue = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string()
+});
+var TaskRunExecutionBatch = zod.z.object({
+  id: zod.z.string()
+});
 var TaskRunExecution = zod.z.object({
   task: TaskRunExecutionTask,
   attempt: TaskRunExecutionAttempt,
   run: TaskRun,
+  queue: TaskRunExecutionQueue,
   environment: TaskRunExecutionEnvironment,
   organization: TaskRunExecutionOrganization,
-  project: TaskRunExecutionProject
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional()
 });
 var TaskRunContext = zod.z.object({
   task: TaskRunExecutionTask,
@@ -183,33 +191,105 @@ var TaskRunContext = zod.z.object({
     payload: true,
     payloadType: true
   }),
+  queue: TaskRunExecutionQueue,
   environment: TaskRunExecutionEnvironment,
   organization: TaskRunExecutionOrganization,
-  project: TaskRunExecutionProject
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional()
+});
+var TaskRunExecutionRetry = zod.z.object({
+  timestamp: zod.z.number(),
+  delay: zod.z.number(),
+  error: zod.z.unknown().optional()
 });
 var TaskRunFailedExecutionResult = zod.z.object({
   ok: zod.z.literal(false),
   id: zod.z.string(),
-  error: TaskRunError
+  error: TaskRunError,
+  retry: TaskRunExecutionRetry.optional(),
+  skippedRetrying: zod.z.boolean().optional()
 });
 var TaskRunSuccessfulExecutionResult = zod.z.object({
   ok: zod.z.literal(true),
   id: zod.z.string(),
-  output: zod.z.string(),
+  output: zod.z.string().optional(),
   outputType: zod.z.string()
 });
 var TaskRunExecutionResult = zod.z.discriminatedUnion("ok", [
   TaskRunSuccessfulExecutionResult,
   TaskRunFailedExecutionResult
 ]);
+var BatchTaskRunExecutionResult = zod.z.object({
+  id: zod.z.string(),
+  items: TaskRunExecutionResult.array()
+});
+
+// src/v3/schemas/messages.ts
+var EnvironmentType = zod.z.enum([
+  "PRODUCTION",
+  "STAGING",
+  "DEVELOPMENT",
+  "PREVIEW"
+]);
+var MachineCpu = zod.z.union([
+  zod.z.literal(0.25),
+  zod.z.literal(0.5),
+  zod.z.literal(1),
+  zod.z.literal(2),
+  zod.z.literal(4)
+]).default(0.5);
+var MachineMemory = zod.z.union([
+  zod.z.literal(0.25),
+  zod.z.literal(0.5),
+  zod.z.literal(1),
+  zod.z.literal(2),
+  zod.z.literal(4),
+  zod.z.literal(8)
+]).default(1);
+var Machine = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  cpu: MachineCpu,
+  memory: MachineMemory
+});
 var TaskRunExecutionPayload = zod.z.object({
   execution: TaskRunExecution,
-  traceContext: zod.z.record(zod.z.unknown())
+  traceContext: zod.z.record(zod.z.unknown()),
+  environment: zod.z.record(zod.z.string()).optional()
+});
+var ProdTaskRunExecution = TaskRunExecution.extend({
+  worker: zod.z.object({
+    id: zod.z.string(),
+    contentHash: zod.z.string(),
+    version: zod.z.string()
+  })
+});
+var ProdTaskRunExecutionPayload = zod.z.object({
+  execution: ProdTaskRunExecution,
+  traceContext: zod.z.record(zod.z.unknown()),
+  environment: zod.z.record(zod.z.string()).optional()
 });
 var BackgroundWorkerServerMessages = zod.z.discriminatedUnion("type", [
   zod.z.object({
     type: zod.z.literal("EXECUTE_RUNS"),
     payloads: zod.z.array(TaskRunExecutionPayload)
+  }),
+  zod.z.object({
+    type: zod.z.literal("CANCEL_ATTEMPT"),
+    taskAttemptId: zod.z.string(),
+    taskRunId: zod.z.string()
+  }),
+  zod.z.object({
+    type: zod.z.literal("SCHEDULE_ATTEMPT"),
+    image: zod.z.string(),
+    version: zod.z.string(),
+    machine: Machine,
+    // identifiers
+    id: zod.z.string(),
+    envId: zod.z.string(),
+    envType: EnvironmentType,
+    orgId: zod.z.string(),
+    projectId: zod.z.string(),
+    runId: zod.z.string()
   })
 ]);
 var serverWebsocketMessages = {
@@ -227,15 +307,26 @@ var BackgroundWorkerClientMessages = zod.z.discriminatedUnion("type", [
   zod.z.object({
     version: zod.z.literal("v1").default("v1"),
     type: zod.z.literal("TASK_RUN_COMPLETED"),
-    completion: TaskRunExecutionResult
+    completion: TaskRunExecutionResult,
+    execution: TaskRunExecution
+  }),
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_HEARTBEAT"),
+    id: zod.z.string()
   })
 ]);
+var BackgroundWorkerProperties = zod.z.object({
+  id: zod.z.string(),
+  version: zod.z.string(),
+  contentHash: zod.z.string()
+});
 var clientWebsocketMessages = {
   READY_FOR_TASKS: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
     backgroundWorkerId: zod.z.string()
   }),
-  WORKER_DEPRECATED: zod.z.object({
+  BACKGROUND_WORKER_DEPRECATED: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
     backgroundWorkerId: zod.z.string()
   }),
@@ -250,40 +341,1112 @@ var workerToChildMessages = {
     version: zod.z.literal("v1").default("v1"),
     execution: TaskRunExecution,
     traceContext: zod.z.record(zod.z.unknown()),
-    metadata: BackgroundWorkerRecord
+    metadata: BackgroundWorkerProperties
   }),
-  TASK_RUN_COMPLETED: zod.z.object({
+  TASK_RUN_COMPLETED_NOTIFICATION: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
     completion: TaskRunExecutionResult,
     execution: TaskRunExecution
   }),
   CLEANUP: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
-    flush: zod.z.boolean().default(false)
+    flush: zod.z.boolean().default(false),
+    kill: zod.z.boolean().default(true)
   })
 };
+var FixedWindowRateLimit = zod.z.object({
+  type: zod.z.literal("fixed-window"),
+  limit: zod.z.number(),
+  window: zod.z.union([
+    zod.z.object({
+      seconds: zod.z.number()
+    }),
+    zod.z.object({
+      minutes: zod.z.number()
+    }),
+    zod.z.object({
+      hours: zod.z.number()
+    })
+  ])
+});
+var SlidingWindowRateLimit = zod.z.object({
+  type: zod.z.literal("sliding-window"),
+  limit: zod.z.number(),
+  window: zod.z.union([
+    zod.z.object({
+      seconds: zod.z.number()
+    }),
+    zod.z.object({
+      minutes: zod.z.number()
+    }),
+    zod.z.object({
+      hours: zod.z.number()
+    })
+  ])
+});
+var RateLimitOptions = zod.z.discriminatedUnion("type", [
+  FixedWindowRateLimit,
+  SlidingWindowRateLimit
+]);
+var RetryOptions = zod.z.object({
+  /** The number of attempts before giving up */
+  maxAttempts: zod.z.number().int().optional(),
+  /** The exponential factor to use when calculating the next retry time.
+  *
+  * Each subsequent retry will be calculated as `previousTimeout * factor`
+  */
+  factor: zod.z.number().optional(),
+  /** The minimum time to wait before retrying */
+  minTimeoutInMs: zod.z.number().int().optional(),
+  /** The maximum time to wait before retrying */
+  maxTimeoutInMs: zod.z.number().int().optional(),
+  /** Randomize the timeout between retries.
+  *
+  * This can be useful to prevent the thundering herd problem where all retries happen at the same time.
+  */
+  randomize: zod.z.boolean().optional()
+});
+var QueueOptions = zod.z.object({
+  /** You can define a shared queue and then pass the name in to your task.
+     * 
+     * @example
+     * 
+     * ```ts
+     * const myQueue = queue({
+        name: "my-queue",
+        concurrencyLimit: 1,
+      });
+  
+      export const task1 = task({
+        id: "task-1",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+  
+      export const task2 = task({
+        id: "task-2",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+     * ```
+     */
+  name: zod.z.string().optional(),
+  /** An optional property that specifies the maximum number of concurrent run executions.
+  *
+  * If this property is omitted, the task can potentially use up the full concurrency of an environment. */
+  concurrencyLimit: zod.z.number().int().min(0).max(1e3).optional(),
+  /** @deprecated This feature is coming soon */
+  rateLimit: RateLimitOptions.optional()
+});
 var TaskMetadata = zod.z.object({
   id: zod.z.string(),
   exportName: zod.z.string(),
-  packageVersion: zod.z.string()
+  packageVersion: zod.z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional()
 });
 var TaskMetadataWithFilePath = TaskMetadata.extend({
   filePath: zod.z.string()
 });
+var UncaughtExceptionMessage = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  error: zod.z.object({
+    name: zod.z.string(),
+    message: zod.z.string(),
+    stack: zod.z.string().optional()
+  }),
+  origin: zod.z.enum([
+    "uncaughtException",
+    "unhandledRejection"
+  ])
+});
+var TaskMetadataFailedToParseData = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  tasks: zod.z.unknown(),
+  zodIssues: zod.z.custom((v) => {
+    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
+  })
+});
 var childToWorkerMessages = {
   TASK_RUN_COMPLETED: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
     result: TaskRunExecutionResult
   }),
   TASKS_READY: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
     tasks: TaskMetadataWithFilePath.array()
   }),
-  READY_TO_DISPOSE: zod.z.undefined()
+  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
+  TASK_HEARTBEAT: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  READY_TO_DISPOSE: zod.z.undefined(),
+  WAIT_FOR_DURATION: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    ms: zod.z.number()
+  }),
+  WAIT_FOR_TASK: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  WAIT_FOR_BATCH: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string(),
+    runs: zod.z.string().array()
+  }),
+  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
+};
+var ProdChildToWorkerMessages = {
+  TASK_RUN_COMPLETED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      result: TaskRunExecutionResult
+    })
+  },
+  TASKS_READY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      tasks: TaskMetadataWithFilePath.array()
+    })
+  },
+  TASKS_FAILED_TO_PARSE: {
+    message: TaskMetadataFailedToParseData
+  },
+  TASK_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      id: zod.z.string()
+    })
+  },
+  READY_TO_DISPOSE: {
+    message: zod.z.undefined()
+  },
+  READY_FOR_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
+  WAIT_FOR_DURATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      ms: zod.z.number(),
+      now: zod.z.number()
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      friendlyId: zod.z.string()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      batchFriendlyId: zod.z.string(),
+      runFriendlyIds: zod.z.string().array()
+    })
+  },
+  UNCAUGHT_EXCEPTION: {
+    message: UncaughtExceptionMessage
+  }
+};
+var ProdWorkerToChildMessages = {
+  EXECUTE_TASK_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      traceContext: zod.z.record(zod.z.unknown()),
+      metadata: BackgroundWorkerProperties
+    })
+  },
+  TASK_RUN_COMPLETED_NOTIFICATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      completion: TaskRunExecutionResult,
+      execution: TaskRunExecution
+    })
+  },
+  CLEANUP: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      flush: zod.z.boolean().default(false),
+      kill: zod.z.boolean().default(true)
+    }),
+    callback: zod.z.void()
+  },
+  WAIT_COMPLETED_NOTIFICATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  }
+};
+
+// src/v3/schemas/resources.ts
+var TaskResource = zod.z.object({
+  id: zod.z.string(),
+  filePath: zod.z.string(),
+  exportName: zod.z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional()
+});
+var BackgroundWorkerMetadata = zod.z.object({
+  packageVersion: zod.z.string(),
+  contentHash: zod.z.string(),
+  cliPackageVersion: zod.z.string().optional(),
+  tasks: zod.z.array(TaskResource)
+});
+var ImageDetailsMetadata = zod.z.object({
+  contentHash: zod.z.string(),
+  imageTag: zod.z.string()
+});
+
+// src/v3/schemas/api.ts
+var WhoAmIResponseSchema = zod.z.object({
+  userId: zod.z.string(),
+  email: zod.z.string().email(),
+  dashboardUrl: zod.z.string()
+});
+var GetProjectResponseBody = zod.z.object({
+  id: zod.z.string(),
+  externalRef: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  createdAt: zod.z.coerce.date(),
+  organization: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    slug: zod.z.string(),
+    createdAt: zod.z.coerce.date()
+  })
+});
+var GetProjectsResponseBody = zod.z.array(GetProjectResponseBody);
+var GetProjectEnvResponse = zod.z.object({
+  apiKey: zod.z.string(),
+  name: zod.z.string(),
+  apiUrl: zod.z.string()
+});
+var CreateBackgroundWorkerRequestBody = zod.z.object({
+  localOnly: zod.z.boolean(),
+  metadata: BackgroundWorkerMetadata
+});
+var CreateBackgroundWorkerResponse = zod.z.object({
+  id: zod.z.string(),
+  version: zod.z.string(),
+  contentHash: zod.z.string()
+});
+var TriggerTaskRequestBody = zod.z.object({
+  payload: zod.z.any(),
+  context: zod.z.any(),
+  options: zod.z.object({
+    dependentAttempt: zod.z.string().optional(),
+    dependentBatch: zod.z.string().optional(),
+    lockToVersion: zod.z.string().optional(),
+    queue: QueueOptions.optional(),
+    concurrencyKey: zod.z.string().optional(),
+    test: zod.z.boolean().optional()
+  }).optional()
+});
+var TriggerTaskResponse = zod.z.object({
+  id: zod.z.string()
+});
+var BatchTriggerTaskRequestBody = zod.z.object({
+  items: TriggerTaskRequestBody.array(),
+  dependentAttempt: zod.z.string().optional()
+});
+var BatchTriggerTaskResponse = zod.z.object({
+  batchId: zod.z.string(),
+  runs: zod.z.string().array()
+});
+var GetBatchResponseBody = zod.z.object({
+  id: zod.z.string(),
+  items: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    taskRunId: zod.z.string(),
+    status: zod.z.enum([
+      "PENDING",
+      "CANCELED",
+      "COMPLETED",
+      "FAILED"
+    ])
+  }))
+});
+var GetEnvironmentVariablesResponseBody = zod.z.object({
+  variables: zod.z.record(zod.z.string())
+});
+var StartDeploymentIndexingRequestBody = zod.z.object({
+  imageReference: zod.z.string()
+});
+var StartDeploymentIndexingResponseBody = zod.z.object({
+  id: zod.z.string(),
+  contentHash: zod.z.string()
+});
+var ExternalBuildData = zod.z.object({
+  buildId: zod.z.string(),
+  buildToken: zod.z.string(),
+  projectId: zod.z.string()
+});
+var InitializeDeploymentResponseBody = zod.z.object({
+  id: zod.z.string(),
+  contentHash: zod.z.string(),
+  shortCode: zod.z.string(),
+  version: zod.z.string(),
+  imageTag: zod.z.string(),
+  externalBuildData: ExternalBuildData.optional().nullable(),
+  registryHost: zod.z.string().optional()
+});
+var InitializeDeploymentRequestBody = zod.z.object({
+  contentHash: zod.z.string(),
+  userId: zod.z.string().optional()
+});
+var DeploymentErrorData = zod.z.object({
+  name: zod.z.string(),
+  message: zod.z.string(),
+  stack: zod.z.string().optional()
+});
+var GetDeploymentResponseBody = zod.z.object({
+  id: zod.z.string(),
+  status: zod.z.enum([
+    "PENDING",
+    "BUILDING",
+    "DEPLOYING",
+    "DEPLOYED",
+    "FAILED",
+    "CANCELED",
+    "TIMED_OUT"
+  ]),
+  contentHash: zod.z.string(),
+  shortCode: zod.z.string(),
+  version: zod.z.string(),
+  imageReference: zod.z.string().optional(),
+  errorData: DeploymentErrorData.optional().nullable(),
+  worker: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string(),
+    tasks: zod.z.array(zod.z.object({
+      id: zod.z.string(),
+      slug: zod.z.string(),
+      filePath: zod.z.string(),
+      exportName: zod.z.string()
+    }))
+  }).optional()
+});
+var CreateUploadPayloadUrlResponseBody = zod.z.object({
+  presignedUrl: zod.z.string()
+});
+var PostStartCauses = zod.z.enum([
+  "index",
+  "create",
+  "restore"
+]);
+var PreStopCauses = zod.z.enum([
+  "terminate"
+]);
+var RegexSchema = zod.z.custom((val) => {
+  try {
+    return typeof val.test === "function";
+  } catch {
+    return false;
+  }
+});
+var Config = zod.z.object({
+  project: zod.z.string(),
+  triggerDirectories: zod.z.string().array().optional(),
+  triggerUrl: zod.z.string().optional(),
+  projectDir: zod.z.string().optional(),
+  tsconfigPath: zod.z.string().optional(),
+  retries: zod.z.object({
+    enabledInDev: zod.z.boolean().default(true),
+    default: RetryOptions.optional()
+  }).optional(),
+  additionalPackages: zod.z.string().array().optional(),
+  additionalFiles: zod.z.string().array().optional(),
+  dependenciesToBundle: zod.z.array(zod.z.union([
+    zod.z.string(),
+    RegexSchema
+  ])).optional(),
+  logLevel: zod.z.string().optional()
+});
+var WaitReason = zod.z.enum([
+  "WAIT_FOR_DURATION",
+  "WAIT_FOR_TASK",
+  "WAIT_FOR_BATCH"
+]);
+var ProviderToPlatformMessages = {
+  LOG: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      data: zod.z.string()
+    })
+  },
+  LOG_WITH_ACK: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      data: zod.z.string()
+    }),
+    callback: zod.z.object({
+      status: zod.z.literal("ok")
+    })
+  },
+  WORKER_CRASHED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      reason: zod.z.string().optional(),
+      exitCode: zod.z.number().optional(),
+      message: zod.z.string().optional(),
+      logs: zod.z.string().optional()
+    })
+  },
+  INDEXING_FAILED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      deploymentId: zod.z.string(),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional()
+      })
+    })
+  }
+};
+var PlatformToProviderMessages = {
+  HEALTH: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    }),
+    callback: zod.z.object({
+      status: zod.z.literal("ok")
+    })
+  },
+  INDEX: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      imageTag: zod.z.string(),
+      shortCode: zod.z.string(),
+      apiKey: zod.z.string(),
+      apiUrl: zod.z.string(),
+      // identifiers
+      envId: zod.z.string(),
+      envType: EnvironmentType,
+      orgId: zod.z.string(),
+      projectId: zod.z.string(),
+      deploymentId: zod.z.string()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        error: zod.z.object({
+          name: zod.z.string(),
+          message: zod.z.string(),
+          stack: zod.z.string().optional()
+        })
+      }),
+      zod.z.object({
+        success: zod.z.literal(true)
+      })
+    ])
+  },
+  // TODO: this should be a shared queue message instead
+  RESTORE: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      type: zod.z.enum([
+        "DOCKER",
+        "KUBERNETES"
+      ]),
+      location: zod.z.string(),
+      reason: zod.z.string().optional(),
+      imageRef: zod.z.string(),
+      machine: Machine,
+      // identifiers
+      checkpointId: zod.z.string(),
+      envId: zod.z.string(),
+      envType: EnvironmentType,
+      orgId: zod.z.string(),
+      projectId: zod.z.string(),
+      runId: zod.z.string()
+    })
+  },
+  DELETE: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      name: zod.z.string()
+    }),
+    callback: zod.z.object({
+      message: zod.z.string()
+    })
+  },
+  GET: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      name: zod.z.string()
+    })
+  }
+};
+var CoordinatorToPlatformMessages = {
+  LOG: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      metadata: zod.z.any(),
+      text: zod.z.string()
+    })
+  },
+  CREATE_WORKER: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      projectRef: zod.z.string(),
+      envId: zod.z.string(),
+      deploymentId: zod.z.string(),
+      metadata: zod.z.object({
+        cliPackageVersion: zod.z.string().optional(),
+        contentHash: zod.z.string(),
+        packageVersion: zod.z.string(),
+        tasks: TaskResource.array()
+      })
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false)
+      }),
+      zod.z.object({
+        success: zod.z.literal(true)
+      })
+    ])
+  },
+  READY_FOR_EXECUTION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false)
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        payload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  READY_FOR_RESUME: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string(),
+      type: WaitReason
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult,
+      checkpoint: zod.z.object({
+        docker: zod.z.boolean(),
+        location: zod.z.string()
+      }).optional()
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string()
+    })
+  },
+  CHECKPOINT_CREATED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string(),
+      docker: zod.z.boolean(),
+      location: zod.z.string(),
+      reason: zod.z.discriminatedUnion("type", [
+        zod.z.object({
+          type: zod.z.literal("WAIT_FOR_DURATION"),
+          ms: zod.z.number(),
+          now: zod.z.number()
+        }),
+        zod.z.object({
+          type: zod.z.literal("WAIT_FOR_BATCH"),
+          batchFriendlyId: zod.z.string(),
+          runFriendlyIds: zod.z.string().array()
+        }),
+        zod.z.object({
+          type: zod.z.literal("WAIT_FOR_TASK"),
+          friendlyId: zod.z.string()
+        }),
+        zod.z.object({
+          type: zod.z.literal("RETRYING_AFTER_FAILURE"),
+          attemptNumber: zod.z.number()
+        })
+      ])
+    })
+  },
+  INDEXING_FAILED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      deploymentId: zod.z.string(),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional()
+      })
+    })
+  }
+};
+var PlatformToCoordinatorMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string()
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string()
+    })
+  },
+  READY_FOR_RETRY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  }
+};
+var ClientToSharedQueueMessages = {
+  READY_FOR_TASKS: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      backgroundWorkerId: zod.z.string()
+    })
+  },
+  BACKGROUND_WORKER_DEPRECATED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      backgroundWorkerId: zod.z.string()
+    })
+  },
+  BACKGROUND_WORKER_MESSAGE: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      backgroundWorkerId: zod.z.string(),
+      data: BackgroundWorkerClientMessages
+    })
+  }
+};
+var SharedQueueToClientMessages = {
+  SERVER_READY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      id: zod.z.string()
+    })
+  },
+  BACKGROUND_WORKER_MESSAGE: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      backgroundWorkerId: zod.z.string(),
+      data: BackgroundWorkerServerMessages
+    })
+  }
+};
+var ProdWorkerToCoordinatorMessages = {
+  LOG: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      text: zod.z.string()
+    }),
+    callback: zod.z.void()
+  },
+  INDEX_TASKS: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      deploymentId: zod.z.string(),
+      tasks: TaskResource.array(),
+      packageVersion: zod.z.string()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false)
+      }),
+      zod.z.object({
+        success: zod.z.literal(true)
+      })
+    ])
+  },
+  READY_FOR_EXECUTION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    })
+  },
+  READY_FOR_RESUME: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string(),
+      type: WaitReason
+    })
+  },
+  READY_FOR_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string()
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean(),
+      shouldExit: zod.z.boolean()
+    })
+  },
+  WAIT_FOR_DURATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      ms: zod.z.number(),
+      now: zod.z.number(),
+      attemptFriendlyId: zod.z.string()
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      friendlyId: zod.z.string(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: zod.z.string()
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      batchFriendlyId: zod.z.string(),
+      runFriendlyIds: zod.z.string().array(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: zod.z.string()
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean()
+    })
+  },
+  INDEXING_FAILED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      deploymentId: zod.z.string(),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional()
+      })
+    })
+  }
+};
+var CoordinatorToProdWorkerMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string()
+    })
+  },
+  EXECUTE_TASK_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      executionPayload: ProdTaskRunExecutionPayload
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string()
+    })
+  },
+  REQUEST_EXIT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
+  READY_FOR_RETRY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  }
 };
+var ProdWorkerSocketData = zod.z.object({
+  contentHash: zod.z.string(),
+  projectRef: zod.z.string(),
+  envId: zod.z.string(),
+  runId: zod.z.string(),
+  attemptFriendlyId: zod.z.string().optional(),
+  podName: zod.z.string(),
+  deploymentId: zod.z.string(),
+  deploymentVersion: zod.z.string()
+});
+var PRIMARY_VARIANT = "primary";
+var Variant = zod.z.enum([
+  PRIMARY_VARIANT
+]);
+var AccessoryItem = zod.z.object({
+  text: zod.z.string(),
+  variant: zod.z.string().optional(),
+  url: zod.z.string().optional()
+});
+var Accessory = zod.z.object({
+  items: zod.z.array(AccessoryItem),
+  style: zod.z.enum([
+    "codepath"
+  ]).optional()
+});
+var TaskEventStyle = zod.z.object({
+  icon: zod.z.string().optional(),
+  variant: Variant.optional(),
+  accessory: Accessory.optional()
+}).default({
+  icon: void 0,
+  variant: void 0
+});
+var stringPatternMatchers = [
+  zod.z.object({
+    $endsWith: zod.z.string()
+  }),
+  zod.z.object({
+    $startsWith: zod.z.string()
+  }),
+  zod.z.object({
+    $ignoreCaseEquals: zod.z.string()
+  })
+];
+var EventMatcher = zod.z.union([
+  /** Match against a string */
+  zod.z.array(zod.z.string()),
+  /** Match against a number */
+  zod.z.array(zod.z.number()),
+  /** Match against a boolean */
+  zod.z.array(zod.z.boolean()),
+  zod.z.array(zod.z.union([
+    ...stringPatternMatchers,
+    zod.z.object({
+      $exists: zod.z.boolean()
+    }),
+    zod.z.object({
+      $isNull: zod.z.boolean()
+    }),
+    zod.z.object({
+      $anythingBut: zod.z.union([
+        zod.z.string(),
+        zod.z.number(),
+        zod.z.boolean()
+      ])
+    }),
+    zod.z.object({
+      $anythingBut: zod.z.union([
+        zod.z.array(zod.z.string()),
+        zod.z.array(zod.z.number()),
+        zod.z.array(zod.z.boolean())
+      ])
+    }),
+    zod.z.object({
+      $gt: zod.z.number()
+    }),
+    zod.z.object({
+      $lt: zod.z.number()
+    }),
+    zod.z.object({
+      $gte: zod.z.number()
+    }),
+    zod.z.object({
+      $lte: zod.z.number()
+    }),
+    zod.z.object({
+      $between: zod.z.tuple([
+        zod.z.number(),
+        zod.z.number()
+      ])
+    }),
+    zod.z.object({
+      $includes: zod.z.union([
+        zod.z.string(),
+        zod.z.number(),
+        zod.z.boolean()
+      ])
+    }),
+    zod.z.object({
+      $not: zod.z.union([
+        zod.z.string(),
+        zod.z.number(),
+        zod.z.boolean()
+      ])
+    })
+  ]))
+]);
+var EventFilter = zod.z.lazy(() => zod.z.record(zod.z.union([
+  EventMatcher,
+  EventFilter
+])));
+
+// src/v3/schemas/fetch.ts
+var FetchRetryHeadersStrategy = zod.z.object({
+  /** The `headers` strategy retries the request using info from the response headers. */
+  strategy: zod.z.literal("headers"),
+  /** The header to use to determine the maximum number of times to retry the request. */
+  limitHeader: zod.z.string(),
+  /** The header to use to determine the number of remaining retries. */
+  remainingHeader: zod.z.string(),
+  /** The header to use to determine the time when the number of remaining retries will be reset. */
+  resetHeader: zod.z.string(),
+  /** The event filter to use to determine if the request should be retried. */
+  bodyFilter: EventFilter.optional(),
+  /** The format of the `resetHeader` value. */
+  resetFormat: zod.z.enum([
+    "unix_timestamp",
+    "unix_timestamp_in_ms",
+    "iso_8601",
+    "iso_8601_duration_openai_variant"
+  ]).default("unix_timestamp").optional()
+});
+var FetchRetryBackoffStrategy = RetryOptions.extend({
+  /** The `backoff` strategy retries the request with an exponential backoff. */
+  strategy: zod.z.literal("backoff"),
+  /** The event filter to use to determine if the request should be retried. */
+  bodyFilter: EventFilter.optional()
+});
+var FetchRetryStrategy = zod.z.discriminatedUnion("strategy", [
+  FetchRetryHeadersStrategy,
+  FetchRetryBackoffStrategy
+]);
+var FetchRetryByStatusOptions = zod.z.record(zod.z.string(), FetchRetryStrategy);
+var FetchTimeoutOptions = zod.z.object({
+  /** The maximum time to wait for the request to complete. */
+  durationInMs: zod.z.number().optional(),
+  retry: RetryOptions.optional()
+});
+var FetchRetryOptions = zod.z.object({
+  /** The retrying strategy for specific status codes. */
+  byStatus: FetchRetryByStatusOptions.optional(),
+  /** The timeout options for the request. */
+  timeout: RetryOptions.optional(),
+  /**
+  * The retrying strategy for connection errors.
+  */
+  connectionError: RetryOptions.optional()
+});
+var ExceptionEventProperties = zod.z.object({
+  type: zod.z.string().optional(),
+  message: zod.z.string().optional(),
+  stacktrace: zod.z.string().optional()
+});
+var ExceptionSpanEvent = zod.z.object({
+  name: zod.z.literal("exception"),
+  time: zod.z.coerce.date(),
+  properties: zod.z.object({
+    exception: ExceptionEventProperties
+  })
+});
+var CancellationSpanEvent = zod.z.object({
+  name: zod.z.literal("cancellation"),
+  time: zod.z.coerce.date(),
+  properties: zod.z.object({
+    reason: zod.z.string()
+  })
+});
+var OtherSpanEvent = zod.z.object({
+  name: zod.z.string(),
+  time: zod.z.coerce.date(),
+  properties: zod.z.record(zod.z.unknown())
+});
+var SpanEvent = zod.z.union([
+  ExceptionSpanEvent,
+  CancellationSpanEvent,
+  OtherSpanEvent
+]);
+var SpanEvents = zod.z.array(SpanEvent);
+function isExceptionSpanEvent(event) {
+  return event.name === "exception";
+}
+__name(isExceptionSpanEvent, "isExceptionSpanEvent");
+function isCancellationSpanEvent(event) {
+  return event.name === "cancellation";
+}
+__name(isCancellationSpanEvent, "isCancellationSpanEvent");
+var SpanMessagingEvent = zod.z.object({
+  system: zod.z.string().optional(),
+  client_id: zod.z.string().optional(),
+  operation: zod.z.enum([
+    "publish",
+    "create",
+    "receive",
+    "deliver"
+  ]),
+  message: zod.z.any(),
+  destination: zod.z.string().optional()
+});
 
 // src/zodfetch.ts
-async function zodfetch(schema, url, requestInit) {
+async function zodfetch(schema, url, requestInit, options) {
+  return await _doZodFetch(schema, url, requestInit, options);
+}
+__name(zodfetch, "zodfetch");
+async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
   try {
     const response = await fetch(url, requestInit);
     if ((!requestInit || requestInit.method === "GET") && response.status === 404) {
@@ -292,7 +1455,7 @@ async function zodfetch(schema, url, requestInit) {
         error: `404: ${response.statusText}`
       };
     }
-    if (response.status >= 400 && response.status < 500) {
+    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
       const body = await response.json();
       if (!body.error) {
         return {
@@ -305,6 +1468,27 @@ async function zodfetch(schema, url, requestInit) {
         error: body.error
       };
     }
+    if (response.status === 429 || response.status >= 500) {
+      if (!options?.retry) {
+        return {
+          ok: false,
+          error: `Failed to fetch ${url}, got status code ${response.status}`
+        };
+      }
+      const retry = {
+        ...defaultRetryOptions,
+        ...options.retry
+      };
+      if (attempt > retry.maxAttempts) {
+        return {
+          ok: false,
+          error: `Failed to fetch ${url}, got status code ${response.status}`
+        };
+      }
+      const delay = calculateNextRetryDelay(retry, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+    }
     if (response.status !== 200) {
       return {
         ok: false,
@@ -330,31 +1514,45 @@ async function zodfetch(schema, url, requestInit) {
       error: parsedResult.error.message
     };
   } catch (error) {
+    if (options?.retry) {
+      const retry = {
+        ...defaultRetryOptions,
+        ...options.retry
+      };
+      if (attempt > retry.maxAttempts) {
+        return {
+          ok: false,
+          error: error instanceof Error ? error.message : JSON.stringify(error)
+        };
+      }
+      const delay = calculateNextRetryDelay(retry, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+    }
     return {
       ok: false,
       error: error instanceof Error ? error.message : JSON.stringify(error)
     };
   }
 }
-__name(zodfetch, "zodfetch");
-var _SafeAsyncLocalStorage = class _SafeAsyncLocalStorage {
-  constructor() {
-    this.storage = new node_async_hooks.AsyncLocalStorage();
+__name(_doZodFetch, "_doZodFetch");
+
+// src/v3/utils/flattenAttributes.ts
+function flattenAttributes(obj, prefix) {
+  const result = {};
+  if (!obj) {
+    return result;
   }
-  runWith(context3, fn) {
-    return this.storage.run(context3, fn);
+  if (typeof obj === "string") {
+    result[prefix || ""] = obj;
+    return result;
   }
-  getStore() {
-    return this.storage.getStore();
+  if (typeof obj === "number") {
+    result[prefix || ""] = obj;
+    return result;
   }
-};
-__name(_SafeAsyncLocalStorage, "SafeAsyncLocalStorage");
-var SafeAsyncLocalStorage = _SafeAsyncLocalStorage;
-
-// src/v3/utils/flattenAttributes.ts
-function flattenAttributes(obj, prefix) {
-  const result = {};
-  if (obj == null) {
+  if (typeof obj === "boolean") {
+    result[prefix || ""] = obj;
     return result;
   }
   for (const [key, value] of Object.entries(obj)) {
@@ -362,9 +1560,9 @@ function flattenAttributes(obj, prefix) {
     if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
         if (typeof value[i] === "object" && value[i] !== null) {
-          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.${i}`));
+          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
         } else {
-          result[`${newPrefix}.${i}`] = value[i];
+          result[`${newPrefix}.[${i}]`] = value[i];
         }
       }
     } else if (isRecord(value)) {
@@ -382,6 +1580,115 @@ function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 __name(isRecord, "isRecord");
+function unflattenAttributes(obj) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return obj;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const parts = key.split(".").reduce((acc, part) => {
+      if (detectIsArrayIndex(part)) {
+        acc.push(part);
+      } else {
+        acc.push(...part.split(/\.\[(.*?)\]/).filter(Boolean));
+      }
+      return acc;
+    }, []);
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      const isArray = detectIsArrayIndex(part);
+      const cleanPart = isArray ? part.substring(1, part.length - 1) : part;
+      const nextIsArray = detectIsArrayIndex(parts[i + 1]);
+      if (!current[cleanPart]) {
+        current[cleanPart] = nextIsArray ? [] : {};
+      }
+      current = current[cleanPart];
+    }
+    const lastPart = parts[parts.length - 1];
+    const cleanLastPart = detectIsArrayIndex(lastPart) ? parseInt(lastPart.substring(1, lastPart.length - 1), 10) : lastPart;
+    current[cleanLastPart] = value;
+  }
+  return result;
+}
+__name(unflattenAttributes, "unflattenAttributes");
+function detectIsArrayIndex(key) {
+  const match = key.match(/^\[(\d+)\]$/);
+  if (match) {
+    return true;
+  }
+  return false;
+}
+__name(detectIsArrayIndex, "detectIsArrayIndex");
+function primitiveValueOrflattenedAttributes(obj, prefix) {
+  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || obj === void 0) {
+    return obj;
+  }
+  const attributes = flattenAttributes(obj, prefix);
+  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
+    return attributes[prefix];
+  }
+  return attributes;
+}
+__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
+var _SafeAsyncLocalStorage = class _SafeAsyncLocalStorage {
+  constructor() {
+    this.storage = new async_hooks.AsyncLocalStorage();
+  }
+  runWith(context3, fn) {
+    return this.storage.run(context3, fn);
+  }
+  getStore() {
+    return this.storage.getStore();
+  }
+};
+__name(_SafeAsyncLocalStorage, "SafeAsyncLocalStorage");
+var SafeAsyncLocalStorage = _SafeAsyncLocalStorage;
+
+// src/v3/semanticInternalAttributes.ts
+var SemanticInternalAttributes = {
+  ENVIRONMENT_ID: "ctx.environment.id",
+  ENVIRONMENT_TYPE: "ctx.environment.type",
+  ORGANIZATION_ID: "ctx.organization.id",
+  ORGANIZATION_SLUG: "ctx.organization.slug",
+  ORGANIZATION_NAME: "ctx.organization.name",
+  PROJECT_ID: "ctx.project.id",
+  PROJECT_REF: "ctx.project.ref",
+  PROJECT_NAME: "ctx.project.title",
+  PROJECT_DIR: "project.dir",
+  ATTEMPT_ID: "ctx.attempt.id",
+  ATTEMPT_NUMBER: "ctx.attempt.number",
+  RUN_ID: "ctx.run.id",
+  RUN_IS_TEST: "ctx.run.isTest",
+  BATCH_ID: "ctx.batch.id",
+  TASK_SLUG: "ctx.task.id",
+  TASK_PATH: "ctx.task.filePath",
+  TASK_EXPORT_NAME: "ctx.task.exportName",
+  QUEUE_NAME: "ctx.queue.name",
+  QUEUE_ID: "ctx.queue.id",
+  SPAN_PARTIAL: "$span.partial",
+  SPAN_ID: "$span.span_id",
+  OUTPUT: "$output",
+  OUTPUT_TYPE: "$mime_type_output",
+  STYLE: "$style",
+  STYLE_ICON: "$style.icon",
+  STYLE_VARIANT: "$style.variant",
+  STYLE_ACCESSORY: "$style.accessory",
+  METADATA: "$metadata",
+  TRIGGER: "$trigger",
+  PAYLOAD: "$payload",
+  PAYLOAD_TYPE: "$mime_type_payload",
+  SHOW: "$show",
+  SHOW_ACTIONS: "$show.actions",
+  WORKER_ID: "worker.id",
+  WORKER_VERSION: "worker.version",
+  CLI_VERSION: "cli.version",
+  SDK_VERSION: "sdk.version",
+  SDK_LANGUAGE: "sdk.language",
+  RETRY_AT: "retry.at",
+  RETRY_DELAY: "retry.delay",
+  RETRY_COUNT: "retry.count"
+};
 
 // src/v3/tasks/taskContextManager.ts
 var _getStore, getStore_fn;
@@ -397,10 +1704,6 @@ var _TaskContextManager = class _TaskContextManager {
     const store = __privateMethod(this, _getStore, getStore_fn).call(this);
     return store?.ctx;
   }
-  get payload() {
-    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
-    return store?.payload;
-  }
   get worker() {
     const store = __privateMethod(this, _getStore, getStore_fn).call(this);
     return store?.worker;
@@ -408,10 +1711,42 @@ var _TaskContextManager = class _TaskContextManager {
   get attributes() {
     if (this.ctx) {
       return {
-        ...flattenAttributes(this.ctx, "ctx"),
-        ...flattenAttributes(this.payload, "payload"),
-        ...flattenAttributes(this.worker, "worker"),
-        "service.name": this.ctx.task.id
+        ...this.contextAttributes,
+        ...this.workerAttributes
+      };
+    }
+    return {};
+  }
+  get workerAttributes() {
+    if (this.worker) {
+      return {
+        [SemanticInternalAttributes.WORKER_ID]: this.worker.id,
+        [SemanticInternalAttributes.WORKER_VERSION]: this.worker.version
+      };
+    }
+    return {};
+  }
+  get contextAttributes() {
+    if (this.ctx) {
+      return {
+        [SemanticInternalAttributes.ATTEMPT_ID]: this.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: this.ctx.attempt.number,
+        [SemanticInternalAttributes.TASK_SLUG]: this.ctx.task.id,
+        [SemanticInternalAttributes.TASK_PATH]: this.ctx.task.filePath,
+        [SemanticInternalAttributes.TASK_EXPORT_NAME]: this.ctx.task.exportName,
+        [SemanticInternalAttributes.QUEUE_NAME]: this.ctx.queue.name,
+        [SemanticInternalAttributes.QUEUE_ID]: this.ctx.queue.id,
+        [SemanticInternalAttributes.ENVIRONMENT_ID]: this.ctx.environment.id,
+        [SemanticInternalAttributes.ENVIRONMENT_TYPE]: this.ctx.environment.type,
+        [SemanticInternalAttributes.ORGANIZATION_ID]: this.ctx.organization.id,
+        [SemanticInternalAttributes.PROJECT_ID]: this.ctx.project.id,
+        [SemanticInternalAttributes.PROJECT_REF]: this.ctx.project.ref,
+        [SemanticInternalAttributes.PROJECT_NAME]: this.ctx.project.name,
+        [SemanticInternalAttributes.RUN_ID]: this.ctx.run.id,
+        [SemanticInternalAttributes.RUN_IS_TEST]: this.ctx.run.isTest,
+        [SemanticInternalAttributes.ORGANIZATION_SLUG]: this.ctx.organization.slug,
+        [SemanticInternalAttributes.ORGANIZATION_NAME]: this.ctx.organization.name,
+        [SemanticInternalAttributes.BATCH_ID]: this.ctx.batch?.id
       };
     }
     return {};
@@ -427,37 +1762,165 @@ getStore_fn = /* @__PURE__ */ __name(function() {
 __name(_TaskContextManager, "TaskContextManager");
 var TaskContextManager = _TaskContextManager;
 var taskContextManager = new TaskContextManager();
+var _TaskContextSpanProcessor = class _TaskContextSpanProcessor {
+  constructor(innerProcessor) {
+    this._innerProcessor = innerProcessor;
+  }
+  // Called when a span starts
+  onStart(span, parentContext) {
+    if (taskContextManager.ctx) {
+      span.setAttributes(flattenAttributes({
+        [SemanticInternalAttributes.ATTEMPT_ID]: taskContextManager.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContextManager.ctx.attempt.number
+      }, SemanticInternalAttributes.METADATA));
+    }
+    this._innerProcessor.onStart(span, parentContext);
+  }
+  // Delegate the rest of the methods to the wrapped processor
+  onEnd(span) {
+    this._innerProcessor.onEnd(span);
+  }
+  shutdown() {
+    return this._innerProcessor.shutdown();
+  }
+  forceFlush() {
+    return this._innerProcessor.forceFlush();
+  }
+};
+__name(_TaskContextSpanProcessor, "TaskContextSpanProcessor");
+var TaskContextSpanProcessor = _TaskContextSpanProcessor;
+var _TaskContextLogProcessor = class _TaskContextLogProcessor {
+  constructor(innerProcessor) {
+    this._innerProcessor = innerProcessor;
+  }
+  forceFlush() {
+    return this._innerProcessor.forceFlush();
+  }
+  onEmit(logRecord, context3) {
+    if (taskContextManager.ctx) {
+      logRecord.setAttributes(flattenAttributes({
+        [SemanticInternalAttributes.ATTEMPT_ID]: taskContextManager.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContextManager.ctx.attempt.number
+      }, SemanticInternalAttributes.METADATA));
+    }
+    this._innerProcessor.onEmit(logRecord, context3);
+  }
+  shutdown() {
+    return this._innerProcessor.shutdown();
+  }
+};
+__name(_TaskContextLogProcessor, "TaskContextLogProcessor");
+var TaskContextLogProcessor = _TaskContextLogProcessor;
+
+// src/v3/utils/getEnv.ts
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && typeof process.env === "object" && process.env !== null) {
+    return process.env[name];
+  }
+}
+__name(getEnvVar, "getEnvVar");
 
 // src/v3/apiClient/index.ts
+var zodFetchOptions = {
+  retry: {
+    maxAttempts: 5,
+    minTimeoutInMs: 1e3,
+    maxTimeoutInMs: 3e4,
+    factor: 2,
+    randomize: false
+  }
+};
 var _getHeaders, getHeaders_fn;
 var _ApiClient = class _ApiClient {
   constructor(baseUrl, accessToken) {
     __privateAdd(this, _getHeaders);
-    this.baseUrl = baseUrl;
     this.accessToken = accessToken;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
   }
-  triggerTask(taskId, options) {
+  triggerTask(taskId, body, options) {
     return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, {
       method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this),
-      body: JSON.stringify(options)
-    });
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
+      body: JSON.stringify(body)
+    }, zodFetchOptions);
+  }
+  batchTriggerTask(taskId, body, options) {
+    return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/batch`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
+      body: JSON.stringify(body)
+    }, zodFetchOptions);
+  }
+  createUploadPayloadUrl(filename) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
+  getPayloadUrl(filename) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
   }
 };
 _getHeaders = new WeakSet();
-getHeaders_fn = /* @__PURE__ */ __name(function() {
+getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
   const headers = {
     "Content-Type": "application/json",
     Authorization: `Bearer ${this.accessToken}`
   };
   if (taskContextManager.isInsideTask) {
     api.propagation.inject(api.context.active(), headers);
+    if (spanParentAsLink) {
+      headers["x-trigger-span-parent-as-link"] = "1";
+    }
   }
   return headers;
 }, "#getHeaders");
 __name(_ApiClient, "ApiClient");
 var ApiClient = _ApiClient;
-var messageSchema = zod.z.object({
+var _getStore2, getStore_fn2;
+var _ApiClientManager = class _ApiClientManager {
+  constructor() {
+    __privateAdd(this, _getStore2);
+    __publicField(this, "_storage", new SafeAsyncLocalStorage());
+  }
+  get baseURL() {
+    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
+    return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
+  }
+  get accessToken() {
+    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
+    return store?.accessToken ?? getEnvVar("TRIGGER_SECRET_KEY");
+  }
+  get client() {
+    if (!this.baseURL || !this.accessToken) {
+      return void 0;
+    }
+    return new ApiClient(this.baseURL, this.accessToken);
+  }
+  runWith(context3, fn) {
+    return this._storage.runWith(context3, fn);
+  }
+};
+_getStore2 = new WeakSet();
+getStore_fn2 = /* @__PURE__ */ __name(function() {
+  return this._storage.getStore();
+}, "#getStore");
+__name(_ApiClientManager, "ApiClientManager");
+var ApiClientManager = _ApiClientManager;
+var apiClientManager = new ApiClientManager();
+var _ZodSchemaParsedError = class _ZodSchemaParsedError extends Error {
+  constructor(error, payload) {
+    super(error.message);
+    this.error = error;
+    this.payload = payload;
+  }
+};
+__name(_ZodSchemaParsedError, "ZodSchemaParsedError");
+var ZodSchemaParsedError = _ZodSchemaParsedError;
+var ZodMessageSchema = zod.z.object({
   version: zod.z.literal("v1").default("v1"),
   type: zod.z.string(),
   payload: zod.z.unknown()
@@ -477,12 +1940,14 @@ var _ZodMessageHandler = class _ZodMessageHandler {
     }
     const handler = __privateGet(this, _handlers)[parsedMessage.type];
     if (!handler) {
-      throw new Error(`Unknown message type: ${String(parsedMessage.type)}`);
+      console.error(`No handler for message type: ${String(parsedMessage.type)}`);
+      return;
     }
-    await handler(parsedMessage.payload);
+    const ack = await handler(parsedMessage.payload);
+    return ack;
   }
   parseMessage(message) {
-    const parsedMessage = messageSchema.safeParse(message);
+    const parsedMessage = ZodMessageSchema.safeParse(message);
     if (!parsedMessage.success) {
       throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`);
     }
@@ -499,6 +1964,38 @@ var _ZodMessageHandler = class _ZodMessageHandler {
       payload: parsedPayload.data
     };
   }
+  registerHandlers(emitter, logger2) {
+    const log = logger2 ?? console;
+    if (!__privateGet(this, _handlers)) {
+      log.info("No handlers provided");
+      return;
+    }
+    for (const eventName of Object.keys(__privateGet(this, _schema))) {
+      emitter.on(eventName, async (message, callback) => {
+        log.info(`handling ${eventName}`, {
+          payload: message,
+          hasCallback: !!callback
+        });
+        let ack;
+        if ("payload" in message) {
+          ack = await this.handleMessage({
+            type: eventName,
+            ...message
+          });
+        } else {
+          const { version, ...payload } = message;
+          ack = await this.handleMessage({
+            type: eventName,
+            version,
+            payload
+          });
+        }
+        if (callback && typeof callback === "function") {
+          callback(ack);
+        }
+      });
+    }
+  }
 };
 _schema = new WeakMap();
 _handlers = new WeakMap();
@@ -519,7 +2016,7 @@ var _ZodMessageSender = class _ZodMessageSender {
     }
     const parsedPayload = schema.safeParse(payload);
     if (!parsedPayload.success) {
-      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+      throw new ZodSchemaParsedError(parsedPayload.error, payload);
     }
     await __privateGet(this, _sender).call(this, {
       type,
@@ -527,82 +2024,747 @@ var _ZodMessageSender = class _ZodMessageSender {
       version: "v1"
     });
   }
+  async forwardMessage(message) {
+    const parsedMessage = ZodMessageSchema.safeParse(message);
+    if (!parsedMessage.success) {
+      throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`);
+    }
+    const schema = __privateGet(this, _schema2)[parsedMessage.data.type];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${parsedMessage.data.type}`);
+    }
+    const parsedPayload = schema.safeParse(parsedMessage.data.payload);
+    if (!parsedPayload.success) {
+      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+    }
+    await __privateGet(this, _sender).call(this, {
+      type: parsedMessage.data.type,
+      payload: parsedPayload.data,
+      version: "v1"
+    });
+  }
 };
 _schema2 = new WeakMap();
 _sender = new WeakMap();
 __name(_ZodMessageSender, "ZodMessageSender");
 var ZodMessageSender = _ZodMessageSender;
-
-// src/v3/errors.ts
-function parseError(error) {
-  if (error instanceof Error) {
-    return {
-      type: "BUILT_IN_ERROR",
-      name: error.name,
-      message: error.message,
-      stackTrace: error.stack ?? ""
-    };
+var messageSchema = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  type: zod.z.string(),
+  payload: zod.z.unknown()
+});
+var _schema3, _handlers2;
+var _ZodSocketMessageHandler = class _ZodSocketMessageHandler {
+  constructor(options) {
+    __privateAdd(this, _schema3, void 0);
+    __privateAdd(this, _handlers2, void 0);
+    __privateSet(this, _schema3, options.schema);
+    __privateSet(this, _handlers2, options.handlers);
   }
-  if (typeof error === "string") {
-    return {
-      type: "STRING_ERROR",
-      raw: error
-    };
+  async handleMessage(message) {
+    const parsedMessage = this.parseMessage(message);
+    if (!__privateGet(this, _handlers2)) {
+      throw new Error("No handlers provided");
+    }
+    const handler = __privateGet(this, _handlers2)[parsedMessage.type];
+    if (!handler) {
+      console.error(`No handler for message type: ${String(parsedMessage.type)}`);
+      return;
+    }
+    const ack = await handler(parsedMessage.payload);
+    return ack;
   }
-  try {
-    return {
-      type: "CUSTOM_ERROR",
-      raw: JSON.stringify(error)
-    };
-  } catch (e) {
+  parseMessage(message) {
+    const parsedMessage = messageSchema.safeParse(message);
+    if (!parsedMessage.success) {
+      throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`);
+    }
+    const schema = __privateGet(this, _schema3)[parsedMessage.data.type]["message"];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${parsedMessage.data.type}`);
+    }
+    const parsedPayload = schema.safeParse(parsedMessage.data.payload);
+    if (!parsedPayload.success) {
+      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+    }
     return {
-      type: "CUSTOM_ERROR",
-      raw: String(error)
+      type: parsedMessage.data.type,
+      payload: parsedPayload.data
     };
   }
-}
-__name(parseError, "parseError");
-function createErrorTaskError(error) {
-  switch (error.type) {
-    case "BUILT_IN_ERROR": {
-      const e = new Error(error.message);
-      e.name = error.name;
-      e.stack = error.stackTrace;
-      return e;
+  registerHandlers(emitter, logger2) {
+    const log = logger2 ?? console;
+    if (!__privateGet(this, _handlers2)) {
+      log.info("No handlers provided");
+      return;
     }
-    case "STRING_ERROR": {
-      return error.raw;
+    for (const eventName of Object.keys(__privateGet(this, _handlers2))) {
+      emitter.on(eventName, async (message, callback) => {
+        log.info(`handling ${eventName}`, {
+          payload: message,
+          hasCallback: !!callback
+        });
+        let ack;
+        try {
+          if ("payload" in message) {
+            ack = await this.handleMessage({
+              type: eventName,
+              ...message
+            });
+          } else {
+            const { version, ...payload } = message;
+            ack = await this.handleMessage({
+              type: eventName,
+              version,
+              payload
+            });
+          }
+        } catch (error) {
+          log.error("Error while handling message", {
+            error
+          });
+          return;
+        }
+        if (callback && typeof callback === "function") {
+          callback(ack);
+        }
+      });
     }
-    case "CUSTOM_ERROR": {
-      return JSON.parse(error.raw);
+  }
+};
+_schema3 = new WeakMap();
+_handlers2 = new WeakMap();
+__name(_ZodSocketMessageHandler, "ZodSocketMessageHandler");
+var ZodSocketMessageHandler = _ZodSocketMessageHandler;
+var _schema4, _socket;
+var _ZodSocketMessageSender = class _ZodSocketMessageSender {
+  constructor(options) {
+    __privateAdd(this, _schema4, void 0);
+    __privateAdd(this, _socket, void 0);
+    __privateSet(this, _schema4, options.schema);
+    __privateSet(this, _socket, options.socket);
+  }
+  send(type, payload) {
+    const schema = __privateGet(this, _schema4)[type]["message"];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${type}`);
     }
-    case "INTERNAL_ERROR": {
-      return new Error(`trigger.dev internal error (${error.code})`);
+    const parsedPayload = schema.safeParse(payload);
+    if (!parsedPayload.success) {
+      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
     }
+    __privateGet(this, _socket).emit(type, {
+      payload,
+      version: "v1"
+    });
+    return;
   }
-}
-__name(createErrorTaskError, "createErrorTaskError");
-
-// src/v3/utils/platform.ts
-var _globalThis = typeof globalThis === "object" ? globalThis : global;
-
-// src/v3/utils/globals.ts
-var GLOBAL_TRIGGER_DOT_DEV_KEY = Symbol.for(`dev.trigger.ts.api`);
-var _global = _globalThis;
-function registerGlobal(type, instance, allowOverride = false) {
-  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] ?? {};
-  if (!allowOverride && api[type]) {
-    return false;
+  async sendWithAck(type, payload) {
+    const schema = __privateGet(this, _schema4)[type]["message"];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${type}`);
+    }
+    const parsedPayload = schema.safeParse(payload);
+    if (!parsedPayload.success) {
+      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+    }
+    const callbackResult = await __privateGet(this, _socket).emitWithAck(type, {
+      payload,
+      version: "v1"
+    });
+    return callbackResult;
   }
-  api[type] = instance;
-  return true;
-}
-__name(registerGlobal, "registerGlobal");
-function getGlobal(type) {
-  return _global[GLOBAL_TRIGGER_DOT_DEV_KEY]?.[type];
-}
-__name(getGlobal, "getGlobal");
-function unregisterGlobal(type) {
+};
+_schema4 = new WeakMap();
+_socket = new WeakMap();
+__name(_ZodSocketMessageSender, "ZodSocketMessageSender");
+var ZodSocketMessageSender = _ZodSocketMessageSender;
+var _sender2, _handler, _logger;
+var _ZodSocketConnection = class _ZodSocketConnection {
+  constructor(opts) {
+    __privateAdd(this, _sender2, void 0);
+    __privateAdd(this, _handler, void 0);
+    __privateAdd(this, _logger, void 0);
+    const uri = `${opts.secure ? "wss" : "ws"}://${opts.host}:${opts.port ?? (opts.secure ? "443" : "80")}/${opts.namespace}`;
+    const logger2 = new SimpleStructuredLogger(opts.namespace, exports.LogLevel.info);
+    logger2.log("new zod socket", {
+      uri
+    });
+    this.socket = socket_ioClient.io(uri, {
+      transports: [
+        "websocket"
+      ],
+      auth: {
+        token: opts.authToken
+      },
+      extraHeaders: opts.extraHeaders,
+      reconnectionDelay: 500,
+      reconnectionDelayMax: 1e3
+    });
+    __privateSet(this, _logger, logger2.child({
+      socketId: this.socket.id
+    }));
+    __privateSet(this, _handler, new ZodSocketMessageHandler({
+      schema: opts.serverMessages,
+      handlers: opts.handlers
+    }));
+    __privateGet(this, _handler).registerHandlers(this.socket, __privateGet(this, _logger));
+    __privateSet(this, _sender2, new ZodSocketMessageSender({
+      schema: opts.clientMessages,
+      socket: this.socket
+    }));
+    this.socket.on("connect_error", async (error) => {
+      __privateGet(this, _logger).error(`connect_error: ${error}`);
+      if (opts.onError) {
+        await opts.onError(this.socket, error, __privateGet(this, _logger));
+      }
+    });
+    this.socket.on("connect", async () => {
+      __privateGet(this, _logger).info("connect");
+      if (opts.onConnection) {
+        await opts.onConnection(this.socket, __privateGet(this, _handler), __privateGet(this, _sender2), __privateGet(this, _logger));
+      }
+    });
+    this.socket.on("disconnect", async (reason, description) => {
+      __privateGet(this, _logger).info("disconnect", {
+        reason,
+        description
+      });
+      if (opts.onDisconnect) {
+        await opts.onDisconnect(this.socket, reason, description, __privateGet(this, _logger));
+      }
+    });
+  }
+  close() {
+    this.socket.close();
+  }
+  connect() {
+    this.socket.connect();
+  }
+  get send() {
+    return __privateGet(this, _sender2).send.bind(__privateGet(this, _sender2));
+  }
+  get sendWithAck() {
+    return __privateGet(this, _sender2).sendWithAck.bind(__privateGet(this, _sender2));
+  }
+};
+_sender2 = new WeakMap();
+_handler = new WeakMap();
+_logger = new WeakMap();
+__name(_ZodSocketConnection, "ZodSocketConnection");
+var ZodSocketConnection = _ZodSocketConnection;
+
+// src/v3/zodNamespace.ts
+exports.LogLevel = void 0;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["log"] = 0] = "log";
+  LogLevel2[LogLevel2["error"] = 1] = "error";
+  LogLevel2[LogLevel2["warn"] = 2] = "warn";
+  LogLevel2[LogLevel2["info"] = 3] = "info";
+  LogLevel2[LogLevel2["debug"] = 4] = "debug";
+})(exports.LogLevel || (exports.LogLevel = {}));
+var _structuredLog, structuredLog_fn;
+var _SimpleStructuredLogger = class _SimpleStructuredLogger {
+  constructor(name, level = [
+    "1",
+    "true"
+  ].includes(process.env.DEBUG ?? "") ? exports.LogLevel.debug : exports.LogLevel.info, fields) {
+    __privateAdd(this, _structuredLog);
+    this.name = name;
+    this.level = level;
+    this.fields = fields;
+  }
+  child(fields, level) {
+    return new _SimpleStructuredLogger(this.name, level, {
+      ...this.fields,
+      ...fields
+    });
+  }
+  log(message, ...args) {
+    if (this.level < exports.LogLevel.log)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
+  }
+  error(message, ...args) {
+    if (this.level < exports.LogLevel.error)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
+  }
+  warn(message, ...args) {
+    if (this.level < exports.LogLevel.warn)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
+  }
+  info(message, ...args) {
+    if (this.level < exports.LogLevel.info)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
+  }
+  debug(message, ...args) {
+    if (this.level < exports.LogLevel.debug)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, "debug", ...args);
+  }
+};
+_structuredLog = new WeakSet();
+structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
+  const structuredLog = {
+    ...args.length === 1 ? args[0] : args,
+    ...this.fields,
+    timestamp: /* @__PURE__ */ new Date(),
+    name: this.name,
+    message,
+    level
+  };
+  loggerFunction(JSON.stringify(structuredLog));
+}, "#structuredLog");
+__name(_SimpleStructuredLogger, "SimpleStructuredLogger");
+var SimpleStructuredLogger = _SimpleStructuredLogger;
+var _logger2, _handler2;
+var _ZodNamespace = class _ZodNamespace {
+  constructor(opts) {
+    __privateAdd(this, _logger2, void 0);
+    __privateAdd(this, _handler2, void 0);
+    __privateSet(this, _logger2, opts.logger ?? new SimpleStructuredLogger(opts.name));
+    __privateSet(this, _handler2, new ZodSocketMessageHandler({
+      schema: opts.clientMessages,
+      handlers: opts.handlers
+    }));
+    this.io = opts.io;
+    this.namespace = this.io.of(opts.name);
+    this.sender = new ZodMessageSender({
+      schema: opts.serverMessages,
+      sender: async (message) => {
+        return new Promise((resolve, reject) => {
+          try {
+            this.namespace.emit(message.type, message.payload);
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+      }
+    });
+    if (opts.preAuth) {
+      this.namespace.use(async (socket, next) => {
+        const logger2 = __privateGet(this, _logger2).child({
+          socketId: socket.id,
+          socketStage: "preAuth"
+        });
+        if (typeof opts.preAuth === "function") {
+          await opts.preAuth(socket, next, logger2);
+        }
+      });
+    }
+    if (opts.authToken) {
+      this.namespace.use((socket, next) => {
+        const logger2 = __privateGet(this, _logger2).child({
+          socketId: socket.id,
+          socketStage: "auth"
+        });
+        const { auth } = socket.handshake;
+        if (!("token" in auth)) {
+          logger2.error("no token");
+          return socket.disconnect(true);
+        }
+        if (auth.token !== opts.authToken) {
+          logger2.error("invalid token");
+          return socket.disconnect(true);
+        }
+        logger2.info("success");
+        next();
+      });
+    }
+    if (opts.postAuth) {
+      this.namespace.use(async (socket, next) => {
+        const logger2 = __privateGet(this, _logger2).child({
+          socketId: socket.id,
+          socketStage: "auth"
+        });
+        if (typeof opts.postAuth === "function") {
+          await opts.postAuth(socket, next, logger2);
+        }
+      });
+    }
+    this.namespace.on("connection", async (socket) => {
+      const logger2 = __privateGet(this, _logger2).child({
+        socketId: socket.id,
+        socketStage: "connection"
+      });
+      logger2.info("connected");
+      __privateGet(this, _handler2).registerHandlers(socket, logger2);
+      socket.on("disconnect", async (reason, description) => {
+        logger2.info("disconnect", {
+          reason,
+          description
+        });
+        if (opts.onDisconnect) {
+          await opts.onDisconnect(socket, reason, description, logger2);
+        }
+      });
+      socket.on("error", async (error) => {
+        logger2.error("error", {
+          error
+        });
+        if (opts.onError) {
+          await opts.onError(socket, error, logger2);
+        }
+      });
+      if (opts.onConnection) {
+        await opts.onConnection(socket, __privateGet(this, _handler2), this.sender, logger2);
+      }
+    });
+  }
+  fetchSockets() {
+    return this.namespace.fetchSockets();
+  }
+};
+_logger2 = new WeakMap();
+_handler2 = new WeakMap();
+__name(_ZodNamespace, "ZodNamespace");
+var ZodNamespace = _ZodNamespace;
+var messageSchema2 = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  type: zod.z.string(),
+  payload: zod.z.unknown()
+});
+var _schema5, _handlers3, _sender3, _a;
+var ZodIpcMessageHandler = (_a = class {
+  constructor(options) {
+    __privateAdd(this, _schema5, void 0);
+    __privateAdd(this, _handlers3, void 0);
+    __privateAdd(this, _sender3, void 0);
+    __privateSet(this, _schema5, options.schema);
+    __privateSet(this, _handlers3, options.handlers);
+    __privateSet(this, _sender3, options.sender);
+  }
+  async handleMessage(message) {
+    const parsedMessage = this.parseMessage(message);
+    if (!__privateGet(this, _handlers3)) {
+      throw new Error("No handlers provided");
+    }
+    const handler = __privateGet(this, _handlers3)[parsedMessage.type];
+    if (!handler) {
+      return;
+    }
+    const ack = await handler(parsedMessage.payload, __privateGet(this, _sender3));
+    return ack;
+  }
+  parseMessage(message) {
+    const parsedMessage = messageSchema2.safeParse(message);
+    if (!parsedMessage.success) {
+      throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`);
+    }
+    const schema = __privateGet(this, _schema5)[parsedMessage.data.type]["message"];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${parsedMessage.data.type}`);
+    }
+    const parsedPayload = schema.safeParse(parsedMessage.data.payload);
+    if (!parsedPayload.success) {
+      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+    }
+    return {
+      type: parsedMessage.data.type,
+      payload: parsedPayload.data
+    };
+  }
+}, _schema5 = new WeakMap(), _handlers3 = new WeakMap(), _sender3 = new WeakMap(), __name(_a, "ZodIpcMessageHandler"), _a);
+var Packet = zod.z.discriminatedUnion("type", [
+  zod.z.object({
+    type: zod.z.literal("CONNECT"),
+    sessionId: zod.z.string().optional()
+  }),
+  zod.z.object({
+    type: zod.z.literal("ACK"),
+    message: zod.z.any(),
+    id: zod.z.number()
+  }),
+  zod.z.object({
+    type: zod.z.literal("EVENT"),
+    message: zod.z.any(),
+    id: zod.z.number().optional()
+  })
+]);
+var _sessionId, _messageCounter, _handler3, _acks, _registerHandlers, registerHandlers_fn, _handlePacket, handlePacket_fn, _sendPacket, sendPacket_fn;
+var _ZodIpcConnection = class _ZodIpcConnection {
+  constructor(opts) {
+    __privateAdd(this, _registerHandlers);
+    __privateAdd(this, _handlePacket);
+    __privateAdd(this, _sendPacket);
+    __privateAdd(this, _sessionId, void 0);
+    __privateAdd(this, _messageCounter, void 0);
+    __privateAdd(this, _handler3, void 0);
+    __privateAdd(this, _acks, void 0);
+    this.opts = opts;
+    __privateSet(this, _messageCounter, 0);
+    __privateSet(this, _acks, /* @__PURE__ */ new Map());
+    __privateSet(this, _handler3, new ZodIpcMessageHandler({
+      schema: opts.listenSchema,
+      handlers: opts.handlers,
+      sender: {
+        send: this.send.bind(this),
+        sendWithAck: this.sendWithAck.bind(this)
+      }
+    }));
+    __privateMethod(this, _registerHandlers, registerHandlers_fn).call(this);
+  }
+  async connect() {
+    __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+      type: "CONNECT"
+    });
+  }
+  async send(type, payload) {
+    const schema = this.opts.emitSchema[type]["message"];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${type}`);
+    }
+    const parsedPayload = schema.safeParse(payload);
+    if (!parsedPayload.success) {
+      throw new ZodSchemaParsedError(parsedPayload.error, payload);
+    }
+    await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+      type: "EVENT",
+      message: {
+        type,
+        payload,
+        version: "v1"
+      }
+    });
+  }
+  async sendWithAck(type, payload, timeoutInMs) {
+    const currentId = __privateWrapper(this, _messageCounter)._++;
+    return new Promise(async (resolve, reject) => {
+      const defaultTimeoutInMs = 2e3;
+      const timeout = setTimeout(() => {
+        reject(JSON.stringify({
+          reason: "sendWithAck() timeout",
+          timeoutInMs: timeoutInMs ?? defaultTimeoutInMs,
+          type,
+          payload
+        }));
+      }, timeoutInMs ?? defaultTimeoutInMs);
+      __privateGet(this, _acks).set(currentId, {
+        resolve,
+        reject,
+        timeout
+      });
+      const schema = this.opts.emitSchema[type]["message"];
+      if (!schema) {
+        clearTimeout(timeout);
+        return reject(`Unknown message type: ${type}`);
+      }
+      const parsedPayload = schema.safeParse(payload);
+      if (!parsedPayload.success) {
+        clearTimeout(timeout);
+        return reject(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+      }
+      await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+        type: "EVENT",
+        message: {
+          type,
+          payload,
+          version: "v1"
+        },
+        id: currentId
+      });
+    });
+  }
+};
+_sessionId = new WeakMap();
+_messageCounter = new WeakMap();
+_handler3 = new WeakMap();
+_acks = new WeakMap();
+_registerHandlers = new WeakSet();
+registerHandlers_fn = /* @__PURE__ */ __name(async function() {
+  if (!this.opts.process.on) {
+    return;
+  }
+  this.opts.process.on("message", async (message) => {
+    __privateMethod(this, _handlePacket, handlePacket_fn).call(this, message);
+  });
+}, "#registerHandlers");
+_handlePacket = new WeakSet();
+handlePacket_fn = /* @__PURE__ */ __name(async function(packet) {
+  const parsedPacket = Packet.safeParse(packet);
+  if (!parsedPacket.success) {
+    return;
+  }
+  switch (parsedPacket.data.type) {
+    case "ACK": {
+      const ack = __privateGet(this, _acks).get(parsedPacket.data.id);
+      if (!ack) {
+        return;
+      }
+      clearTimeout(ack.timeout);
+      ack.resolve(parsedPacket.data.message);
+      break;
+    }
+    case "CONNECT": {
+      if (!parsedPacket.data.sessionId) {
+        const id = crypto.randomUUID();
+        await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+          type: "CONNECT",
+          sessionId: id
+        });
+        return;
+      }
+      if (__privateGet(this, _sessionId)) {
+        return;
+      }
+      __privateSet(this, _sessionId, parsedPacket.data.sessionId);
+      break;
+    }
+    case "EVENT": {
+      const result = await __privateGet(this, _handler3).handleMessage(parsedPacket.data.message);
+      if (typeof parsedPacket.data.id === "undefined") {
+        return;
+      }
+      await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+        type: "ACK",
+        id: parsedPacket.data.id,
+        message: result
+      });
+      break;
+    }
+  }
+}, "#handlePacket");
+_sendPacket = new WeakSet();
+sendPacket_fn = /* @__PURE__ */ __name(async function(packet1) {
+  await this.opts.process.send?.(packet1);
+}, "#sendPacket");
+__name(_ZodIpcConnection, "ZodIpcConnection");
+var ZodIpcConnection = _ZodIpcConnection;
+function parseError(error) {
+  if (error instanceof Error) {
+    return {
+      type: "BUILT_IN_ERROR",
+      name: error.name,
+      message: error.message,
+      stackTrace: error.stack ?? ""
+    };
+  }
+  if (typeof error === "string") {
+    return {
+      type: "STRING_ERROR",
+      raw: error
+    };
+  }
+  try {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: JSON.stringify(error)
+    };
+  } catch (e) {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: String(error)
+    };
+  }
+}
+__name(parseError, "parseError");
+function createErrorTaskError(error) {
+  switch (error.type) {
+    case "BUILT_IN_ERROR": {
+      const e = new Error(error.message);
+      e.name = error.name;
+      e.stack = error.stackTrace;
+      return e;
+    }
+    case "STRING_ERROR": {
+      return error.raw;
+    }
+    case "CUSTOM_ERROR": {
+      return JSON.parse(error.raw);
+    }
+    case "INTERNAL_ERROR": {
+      return new Error(`trigger.dev internal error (${error.code})`);
+    }
+  }
+}
+__name(createErrorTaskError, "createErrorTaskError");
+function correctErrorStackTrace(stackTrace, projectDir, options) {
+  const [errorLine, ...traceLines] = stackTrace.split("\n");
+  return [
+    options?.removeFirstLine ? void 0 : errorLine,
+    ...traceLines.map((line) => correctStackTraceLine(line, projectDir))
+  ].filter(Boolean).join("\n");
+}
+__name(correctErrorStackTrace, "correctErrorStackTrace");
+function correctStackTraceLine(line, projectDir) {
+  const regex = /at (.*?) \(?file:\/\/(\/.*?\.ts):(\d+):(\d+)\)?/;
+  const match = regex.exec(line);
+  if (!match) {
+    return;
+  }
+  const [_, identifier, path, lineNum, colNum] = match;
+  if (!path) {
+    return;
+  }
+  if (nodePath__default.default.basename(path) === "__entryPoint.ts") {
+    return;
+  }
+  if (projectDir && !path.includes(projectDir)) {
+    return;
+  }
+  return line;
+}
+__name(correctStackTraceLine, "correctStackTraceLine");
+function groupTaskMetadataIssuesByTask(tasks, issues) {
+  return issues.reduce((acc, issue) => {
+    if (issue.path.length === 0) {
+      return acc;
+    }
+    const taskIndex = issue.path[1];
+    if (typeof taskIndex !== "number") {
+      return acc;
+    }
+    const task = tasks[taskIndex];
+    if (!task) {
+      return acc;
+    }
+    const restOfPath = issue.path.slice(2);
+    const taskId = task.id;
+    const taskName = task.exportName;
+    const filePath = task.filePath;
+    const key = taskIndex;
+    const existing = acc[key] ?? {
+      id: taskId,
+      exportName: taskName,
+      filePath,
+      issues: []
+    };
+    existing.issues.push({
+      message: issue.message,
+      path: restOfPath.length === 0 ? void 0 : restOfPath.join(".")
+    });
+    return {
+      ...acc,
+      [key]: existing
+    };
+  }, {});
+}
+__name(groupTaskMetadataIssuesByTask, "groupTaskMetadataIssuesByTask");
+
+// src/v3/utils/platform.ts
+var _globalThis = typeof globalThis === "object" ? globalThis : global;
+
+// src/v3/utils/globals.ts
+var GLOBAL_TRIGGER_DOT_DEV_KEY = Symbol.for(`dev.trigger.ts.api`);
+var _global = _globalThis;
+function registerGlobal(type, instance, allowOverride = false) {
+  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] ?? {};
+  if (!allowOverride && api[type]) {
+    return false;
+  }
+  api[type] = instance;
+  return true;
+}
+__name(registerGlobal, "registerGlobal");
+function getGlobal(type) {
+  return _global[GLOBAL_TRIGGER_DOT_DEV_KEY]?.[type];
+}
+__name(getGlobal, "getGlobal");
+function unregisterGlobal(type) {
   const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY];
   if (api) {
     delete api[type];
@@ -614,6 +2776,11 @@ __name(unregisterGlobal, "unregisterGlobal");
 var _NoopRuntimeManager = class _NoopRuntimeManager {
   disable() {
   }
+  registerTasks() {
+  }
+  getTaskMetadata(id) {
+    return void 0;
+  }
   waitForDuration(ms) {
     return Promise.resolve();
   }
@@ -621,7 +2788,20 @@ var _NoopRuntimeManager = class _NoopRuntimeManager {
     return Promise.resolve();
   }
   waitForTask(params) {
-    throw new Error("Method not implemented.");
+    return Promise.resolve({
+      ok: false,
+      id: params.id,
+      error: {
+        type: "INTERNAL_ERROR",
+        code: "CONFIGURED_INCORRECTLY"
+      }
+    });
+  }
+  waitForBatch(params) {
+    return Promise.resolve({
+      id: params.id,
+      items: []
+    });
   }
 };
 __name(_NoopRuntimeManager, "NoopRuntimeManager");
@@ -650,6 +2830,9 @@ var _RuntimeAPI = class _RuntimeAPI {
   waitForTask(params) {
     return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForTask(params);
   }
+  waitForBatch(params) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForBatch(params);
+  }
   setGlobalRuntimeManager(runtimeManager) {
     return registerGlobal(API_NAME, runtimeManager);
   }
@@ -657,6 +2840,12 @@ var _RuntimeAPI = class _RuntimeAPI {
     __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
     unregisterGlobal(API_NAME);
   }
+  registerTasks(tasks) {
+    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).registerTasks(tasks);
+  }
+  getTaskMetadata(id) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).getTaskMetadata(id);
+  }
 };
 _getRuntimeManager = new WeakSet();
 getRuntimeManager_fn = /* @__PURE__ */ __name(function() {
@@ -667,58 +2856,159 @@ var RuntimeAPI = _RuntimeAPI;
 
 // src/v3/runtime-api.ts
 var runtime = RuntimeAPI.getInstance();
+function iconStringForSeverity(severityNumber) {
+  switch (severityNumber) {
+    case apiLogs.SeverityNumber.UNSPECIFIED:
+      return void 0;
+    case apiLogs.SeverityNumber.TRACE:
+    case apiLogs.SeverityNumber.TRACE2:
+    case apiLogs.SeverityNumber.TRACE3:
+    case apiLogs.SeverityNumber.TRACE4:
+      return "trace";
+    case apiLogs.SeverityNumber.DEBUG:
+    case apiLogs.SeverityNumber.DEBUG2:
+    case apiLogs.SeverityNumber.DEBUG3:
+    case apiLogs.SeverityNumber.DEBUG4:
+      return "debug";
+    case apiLogs.SeverityNumber.INFO:
+    case apiLogs.SeverityNumber.INFO2:
+    case apiLogs.SeverityNumber.INFO3:
+    case apiLogs.SeverityNumber.INFO4:
+      return "info";
+    case apiLogs.SeverityNumber.WARN:
+    case apiLogs.SeverityNumber.WARN2:
+    case apiLogs.SeverityNumber.WARN3:
+    case apiLogs.SeverityNumber.WARN4:
+      return "warn";
+    case apiLogs.SeverityNumber.ERROR:
+    case apiLogs.SeverityNumber.ERROR2:
+    case apiLogs.SeverityNumber.ERROR3:
+    case apiLogs.SeverityNumber.ERROR4:
+      return "error";
+    case apiLogs.SeverityNumber.FATAL:
+    case apiLogs.SeverityNumber.FATAL2:
+    case apiLogs.SeverityNumber.FATAL3:
+    case apiLogs.SeverityNumber.FATAL4:
+      return "fatal";
+  }
+}
+__name(iconStringForSeverity, "iconStringForSeverity");
+var _SimpleClock = class _SimpleClock {
+  preciseNow() {
+    const now = new preciseDate.PreciseDate();
+    const nowStruct = now.toStruct();
+    return [
+      nowStruct.seconds,
+      nowStruct.nanos
+    ];
+  }
+  reset() {
+  }
+};
+__name(_SimpleClock, "SimpleClock");
+var SimpleClock = _SimpleClock;
+
+// src/v3/clock/index.ts
+var API_NAME2 = "clock";
+var SIMPLE_CLOCK = new SimpleClock();
+var _getClock, getClock_fn;
+var _ClockAPI = class _ClockAPI {
+  constructor() {
+    __privateAdd(this, _getClock);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _ClockAPI();
+    }
+    return this._instance;
+  }
+  setGlobalClock(clock2) {
+    return registerGlobal(API_NAME2, clock2);
+  }
+  preciseNow() {
+    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
+  }
+  reset() {
+    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
+  }
+};
+_getClock = new WeakSet();
+getClock_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME2) ?? SIMPLE_CLOCK;
+}, "#getClock");
+__name(_ClockAPI, "ClockAPI");
+var ClockAPI = _ClockAPI;
+
+// src/v3/clock-api.ts
+var clock = ClockAPI.getInstance();
+
+// src/v3/logger/taskLogger.ts
 var logLevels = [
+  "none",
   "error",
   "warn",
   "log",
   "info",
   "debug"
 ];
-var _emitLog, emitLog_fn;
+var _emitLog, emitLog_fn, _getTimestampInHrTime, getTimestampInHrTime_fn;
 var _OtelTaskLogger = class _OtelTaskLogger {
   constructor(_config) {
     __privateAdd(this, _emitLog);
+    __privateAdd(this, _getTimestampInHrTime);
     this._config = _config;
     this._level = logLevels.indexOf(_config.level);
   }
   debug(message, properties) {
-    if (this._level < 4)
+    if (this._level < 5)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "debug", apiLogs.SeverityNumber.DEBUG, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "debug", apiLogs.SeverityNumber.DEBUG, properties);
   }
   log(message, properties) {
-    if (this._level < 2)
+    if (this._level < 3)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "log", apiLogs.SeverityNumber.INFO, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "log", apiLogs.SeverityNumber.INFO, properties);
   }
   info(message, properties) {
-    if (this._level < 3)
+    if (this._level < 4)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "info", apiLogs.SeverityNumber.INFO, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "info", apiLogs.SeverityNumber.INFO, properties);
   }
   warn(message, properties) {
-    if (this._level < 1)
+    if (this._level < 2)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "warn", apiLogs.SeverityNumber.WARN, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "warn", apiLogs.SeverityNumber.WARN, properties);
   }
   error(message, properties) {
-    if (this._level < 0)
+    if (this._level < 1)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "error", apiLogs.SeverityNumber.ERROR, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "error", apiLogs.SeverityNumber.ERROR, properties);
+  }
+  trace(name, fn, options) {
+    return this._config.tracer.startActiveSpan(name, fn, options);
   }
 };
 _emitLog = new WeakSet();
-emitLog_fn = /* @__PURE__ */ __name(function(message, severityText, severityNumber, properties) {
+emitLog_fn = /* @__PURE__ */ __name(function(message, timestamp, severityText, severityNumber, properties) {
+  let attributes = {
+    ...flattenAttributes(properties)
+  };
+  const icon = iconStringForSeverity(severityNumber);
+  if (icon !== void 0) {
+    attributes[SemanticInternalAttributes.STYLE_ICON] = icon;
+  }
   this._config.logger.emit({
     severityNumber,
     severityText,
     body: message,
-    attributes: {
-      ...flattenAttributes(properties),
-      "log.type": "logger"
-    }
+    attributes,
+    timestamp
   });
 }, "#emitLog");
+_getTimestampInHrTime = new WeakSet();
+getTimestampInHrTime_fn = /* @__PURE__ */ __name(function() {
+  return clock.preciseNow();
+}, "#getTimestampInHrTime");
 __name(_OtelTaskLogger, "OtelTaskLogger");
 var OtelTaskLogger = _OtelTaskLogger;
 var _NoopTaskLogger = class _NoopTaskLogger {
@@ -732,12 +3022,15 @@ var _NoopTaskLogger = class _NoopTaskLogger {
   }
   error() {
   }
+  trace(name, fn) {
+    return fn({});
+  }
 };
 __name(_NoopTaskLogger, "NoopTaskLogger");
 var NoopTaskLogger = _NoopTaskLogger;
 
 // src/v3/logger/index.ts
-var API_NAME2 = "logger";
+var API_NAME3 = "logger";
 var NOOP_TASK_LOGGER = new NoopTaskLogger();
 var _getTaskLogger, getTaskLogger_fn;
 var _LoggerAPI = class _LoggerAPI {
@@ -751,10 +3044,10 @@ var _LoggerAPI = class _LoggerAPI {
     return this._instance;
   }
   disable() {
-    unregisterGlobal(API_NAME2);
+    unregisterGlobal(API_NAME3);
   }
   setGlobalTaskLogger(taskLogger) {
-    return registerGlobal(API_NAME2, taskLogger);
+    return registerGlobal(API_NAME3, taskLogger);
   }
   debug(message, metadata) {
     __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).debug(message, metadata);
@@ -771,10 +3064,13 @@ var _LoggerAPI = class _LoggerAPI {
   error(message, metadata) {
     __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).error(message, metadata);
   }
+  trace(name, fn) {
+    return __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).trace(name, fn);
+  }
 };
 _getTaskLogger = new WeakSet();
 getTaskLogger_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME2) ?? NOOP_TASK_LOGGER;
+  return getGlobal(API_NAME3) ?? NOOP_TASK_LOGGER;
 }, "#getTaskLogger");
 __name(_LoggerAPI, "LoggerAPI");
 var LoggerAPI = _LoggerAPI;
@@ -782,47 +3078,145 @@ var LoggerAPI = _LoggerAPI;
 // src/v3/logger-api.ts
 var logger = LoggerAPI.getInstance();
 
-// src/v3/semanticInternalAttributes.ts
-var SemanticInternalAttributes = {
-  ENVIRONMENT_ID: "ctx.environment.id",
-  ENVIRONMENT_TYPE: "ctx.environment.type",
-  ORGANIZATION_ID: "ctx.organization.id",
-  PROJECT_ID: "ctx.project.id",
-  PROJECT_REF: "ctx.project.ref",
-  ATTEMPT_ID: "ctx.attempt.id",
-  ATTEMP_NUMBER: "ctx.attempt.number",
-  RUN_ID: "ctx.run.id",
-  TASK_SLUG: "ctx.task.id",
-  TASK_PATH: "ctx.task.filePath",
-  TASK_EXPORT_NAME: "ctx.task.exportName",
-  SPAN_PARTIAL: "$span.partial",
-  SPAN_ID: "$span.span_id",
-  OUTPUT: "$output",
-  STYLE: "$style",
-  STYLE_ICON: "$style.icon",
-  METADATA: "$metadata",
-  TRIGGER: "$trigger",
-  PAYLOAD: "$payload",
-  WORKER_ID: "worker.id",
-  WORKER_VERSION: "worker.version",
-  CLI_VERSION: "cli.version",
-  SDK_VERSION: "sdk.version",
-  SDK_LANGUAGE: "sdk.language"
-};
+// src/v3/limits.ts
+var OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = 256;
+var OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = 256;
+var OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
+var OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
+var OTEL_SPAN_EVENT_COUNT_LIMIT = 10;
+var OTEL_LINK_COUNT_LIMIT = 2;
+var OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = 10;
+var OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = 10;
+var OFFLOAD_IO_PACKET_LENGTH_LIMIT = 128 * 1024;
+function imposeAttributeLimits(attributes) {
+  const newAttributes = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (calculateAttributeValueLength(value) > OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT) {
+      continue;
+    }
+    if (Object.keys(newAttributes).length >= OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT) {
+      break;
+    }
+    newAttributes[key] = value;
+  }
+  return newAttributes;
+}
+__name(imposeAttributeLimits, "imposeAttributeLimits");
+function calculateAttributeValueLength(value) {
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  if (typeof value === "string") {
+    return value.length;
+  }
+  if (typeof value === "number") {
+    return 8;
+  }
+  if (typeof value === "boolean") {
+    return 4;
+  }
+  if (Array.isArray(value)) {
+    return value.reduce((acc, v) => acc + calculateAttributeValueLength(v), 0);
+  }
+  return 0;
+}
+__name(calculateAttributeValueLength, "calculateAttributeValueLength");
+function dateDifference(date1, date2) {
+  return Math.abs(date1.getTime() - date2.getTime());
+}
+__name(dateDifference, "dateDifference");
+function formatDuration(start, end, options) {
+  if (!start || !end) {
+    return "\u2013";
+  }
+  return formatDurationMilliseconds(dateDifference(start, end), options);
+}
+__name(formatDuration, "formatDuration");
+function nanosecondsToMilliseconds(nanoseconds) {
+  return nanoseconds / 1e6;
+}
+__name(nanosecondsToMilliseconds, "nanosecondsToMilliseconds");
+function millisecondsToNanoseconds(milliseconds) {
+  return milliseconds * 1e6;
+}
+__name(millisecondsToNanoseconds, "millisecondsToNanoseconds");
+function formatDurationNanoseconds(nanoseconds, options) {
+  return formatDurationMilliseconds(nanosecondsToMilliseconds(nanoseconds), options);
+}
+__name(formatDurationNanoseconds, "formatDurationNanoseconds");
+var aboveOneSecondUnits = [
+  "d",
+  "h",
+  "m",
+  "s"
+];
+var belowOneSecondUnits = [
+  "ms"
+];
+function formatDurationMilliseconds(milliseconds, options) {
+  let duration = humanizeDuration__default.default(milliseconds, {
+    units: options?.units ? options.units : milliseconds < 1e3 ? belowOneSecondUnits : aboveOneSecondUnits,
+    maxDecimalPoints: options?.maxDecimalPoints ?? 1,
+    largest: 2
+  });
+  if (!options) {
+    return duration;
+  }
+  switch (options.style) {
+    case "short":
+      duration = duration.replace(" milliseconds", "ms");
+      duration = duration.replace(" millisecond", "ms");
+      duration = duration.replace(" seconds", "s");
+      duration = duration.replace(" second", "s");
+      duration = duration.replace(" minutes", "m");
+      duration = duration.replace(" minute", "m");
+      duration = duration.replace(" hours", "h");
+      duration = duration.replace(" hour", "h");
+      duration = duration.replace(" days", "d");
+      duration = duration.replace(" day", "d");
+      duration = duration.replace(" weeks", "w");
+      duration = duration.replace(" week", "w");
+      duration = duration.replace(" months", "mo");
+      duration = duration.replace(" month", "mo");
+      duration = duration.replace(" years", "y");
+      duration = duration.replace(" year", "y");
+  }
+  return duration;
+}
+__name(formatDurationMilliseconds, "formatDurationMilliseconds");
+function formatDurationInDays(milliseconds) {
+  let duration = humanizeDuration__default.default(milliseconds, {
+    maxDecimalPoints: 0,
+    largest: 2,
+    units: [
+      "d"
+    ]
+  });
+  return duration;
+}
+__name(formatDurationInDays, "formatDurationInDays");
 
 // src/v3/runtime/devRuntimeManager.ts
 var _DevRuntimeManager = class _DevRuntimeManager {
-  constructor(options) {
-    this.options = options;
-    this._taskWaits = /* @__PURE__ */ new Map();
+  constructor() {
+    __publicField(this, "_taskWaits", /* @__PURE__ */ new Map());
+    __publicField(this, "_batchWaits", /* @__PURE__ */ new Map());
+    __publicField(this, "_tasks", /* @__PURE__ */ new Map());
+    __publicField(this, "_pendingCompletionNotifications", /* @__PURE__ */ new Map());
   }
   disable() {
   }
+  registerTasks(tasks) {
+    for (const task of tasks) {
+      this._tasks.set(task.id, task);
+    }
+  }
+  getTaskMetadata(id) {
+    return this._tasks.get(id);
+  }
   async waitForDuration(ms) {
-    return this.options.tracer.startActiveSpan("wait for duration", async (span) => {
-      return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-      });
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
     });
   }
   async waitUntil(date) {
@@ -831,27 +3225,215 @@ var _DevRuntimeManager = class _DevRuntimeManager {
     });
   }
   async waitForTask(params) {
-    return this.options.tracer.startActiveSpan("wait for task", async (span) => {
-      span.setAttribute("trigger.task.run.id", params.id);
-      const promise = new Promise((resolve, reject) => {
-        this._taskWaits.set(params.id, {
+    const pendingCompletion = this._pendingCompletionNotifications.get(params.id);
+    if (pendingCompletion) {
+      this._pendingCompletionNotifications.delete(params.id);
+      return pendingCompletion;
+    }
+    const promise = new Promise((resolve, reject) => {
+      this._taskWaits.set(params.id, {
+        resolve,
+        reject
+      });
+    });
+    return await promise;
+  }
+  async waitForBatch(params) {
+    if (!params.runs.length) {
+      return Promise.resolve({
+        id: params.id,
+        items: []
+      });
+    }
+    const promise = Promise.all(params.runs.map((runId) => {
+      return new Promise((resolve, reject) => {
+        const pendingCompletion = this._pendingCompletionNotifications.get(runId);
+        if (pendingCompletion) {
+          this._pendingCompletionNotifications.delete(runId);
+          if (pendingCompletion.ok) {
+            resolve(pendingCompletion);
+          } else {
+            reject(pendingCompletion);
+          }
+          return;
+        }
+        this._taskWaits.set(runId, {
           resolve,
           reject
         });
       });
-      return await promise;
-    });
+    }));
+    const results = await promise;
+    return {
+      id: params.id,
+      items: results
+    };
   }
   resumeTask(completion, execution) {
     const wait = this._taskWaits.get(execution.run.id);
-    if (wait) {
+    if (!wait) {
+      this._pendingCompletionNotifications.set(execution.run.id, completion);
+      return;
+    }
+    if (completion.ok) {
       wait.resolve(completion);
-      this._taskWaits.delete(execution.run.id);
+    } else {
+      wait.reject(completion);
     }
+    this._taskWaits.delete(execution.run.id);
   }
 };
 __name(_DevRuntimeManager, "DevRuntimeManager");
 var DevRuntimeManager = _DevRuntimeManager;
+var _ProdRuntimeManager = class _ProdRuntimeManager {
+  constructor(ipc, options = {}) {
+    this.ipc = ipc;
+    this.options = options;
+    this._taskWaits = /* @__PURE__ */ new Map();
+    this._batchWaits = /* @__PURE__ */ new Map();
+    this._tasks = /* @__PURE__ */ new Map();
+  }
+  disable() {
+  }
+  registerTasks(tasks) {
+    for (const task of tasks) {
+      this._tasks.set(task.id, task);
+    }
+  }
+  getTaskMetadata(id) {
+    return this._tasks.get(id);
+  }
+  async waitForDuration(ms) {
+    const now = Date.now();
+    const resolveAfterDuration = promises.setTimeout(ms, "duration");
+    if (ms <= this.waitThresholdInMs) {
+      await resolveAfterDuration;
+      return;
+    }
+    const waitForRestore = new Promise((resolve, reject) => {
+      this._waitForRestore = {
+        resolve,
+        reject
+      };
+    });
+    const { willCheckpointAndRestore } = await this.ipc.sendWithAck("WAIT_FOR_DURATION", {
+      ms,
+      now
+    });
+    if (!willCheckpointAndRestore) {
+      await resolveAfterDuration;
+      return;
+    }
+    this.ipc.send("READY_FOR_CHECKPOINT", {});
+    await Promise.race([
+      waitForRestore,
+      resolveAfterDuration
+    ]);
+    this.ipc.send("CANCEL_CHECKPOINT", {});
+  }
+  resumeAfterRestore() {
+    if (!this._waitForRestore) {
+      return;
+    }
+    clock.reset();
+    this._waitForRestore.resolve("restore");
+    this._waitForRestore = void 0;
+  }
+  async waitUntil(date) {
+    return this.waitForDuration(date.getTime() - Date.now());
+  }
+  async waitForTask(params) {
+    const promise = new Promise((resolve, reject) => {
+      this._taskWaits.set(params.id, {
+        resolve,
+        reject
+      });
+    });
+    await this.ipc.send("WAIT_FOR_TASK", {
+      friendlyId: params.id
+    });
+    return await promise;
+  }
+  async waitForBatch(params) {
+    if (!params.runs.length) {
+      return Promise.resolve({
+        id: params.id,
+        items: []
+      });
+    }
+    const promise = Promise.all(params.runs.map((runId) => {
+      return new Promise((resolve, reject) => {
+        this._taskWaits.set(runId, {
+          resolve,
+          reject
+        });
+      });
+    }));
+    await this.ipc.send("WAIT_FOR_BATCH", {
+      batchFriendlyId: params.id,
+      runFriendlyIds: params.runs
+    });
+    const results = await promise;
+    return {
+      id: params.id,
+      items: results
+    };
+  }
+  resumeTask(completion, execution) {
+    const wait = this._taskWaits.get(execution.run.id);
+    if (!wait) {
+      return;
+    }
+    if (completion.ok) {
+      wait.resolve(completion);
+    } else {
+      wait.reject(completion);
+    }
+    this._taskWaits.delete(execution.run.id);
+  }
+  get waitThresholdInMs() {
+    return this.options.waitThresholdInMs ?? 3e4;
+  }
+};
+__name(_ProdRuntimeManager, "ProdRuntimeManager");
+var ProdRuntimeManager = _ProdRuntimeManager;
+var _originClockTime, originClockTime_get, _originPreciseDate, originPreciseDate_get;
+var _PreciseWallClock = class _PreciseWallClock {
+  constructor(options = {}) {
+    __privateAdd(this, _originClockTime);
+    __privateAdd(this, _originPreciseDate);
+    this._origin = {
+      clockTime: options.origin ?? process.hrtime(),
+      preciseDate: options.now ?? new preciseDate.PreciseDate()
+    };
+  }
+  preciseNow() {
+    const elapsedHrTime = process.hrtime(__privateGet(this, _originClockTime, originClockTime_get));
+    const elapsedNanoseconds = BigInt(elapsedHrTime[0]) * BigInt(1e9) + BigInt(elapsedHrTime[1]);
+    const preciseDate$1 = new preciseDate.PreciseDate(__privateGet(this, _originPreciseDate, originPreciseDate_get).getFullTime() + elapsedNanoseconds);
+    const dateStruct = preciseDate$1.toStruct();
+    return [
+      dateStruct.seconds,
+      dateStruct.nanos
+    ];
+  }
+  reset() {
+    this._origin = {
+      clockTime: process.hrtime(),
+      preciseDate: new preciseDate.PreciseDate()
+    };
+  }
+};
+_originClockTime = new WeakSet();
+originClockTime_get = /* @__PURE__ */ __name(function() {
+  return this._origin.clockTime;
+}, "#originClockTime");
+_originPreciseDate = new WeakSet();
+originPreciseDate_get = /* @__PURE__ */ __name(function() {
+  return this._origin.preciseDate;
+}, "#originPreciseDate");
+__name(_PreciseWallClock, "PreciseWallClock");
+var PreciseWallClock = _PreciseWallClock;
 var _TriggerTracer = class _TriggerTracer {
   constructor(_config) {
     this._config = _config;
@@ -880,7 +3462,8 @@ var _TriggerTracer = class _TriggerTracer {
     const attributes = options?.attributes ?? {};
     return this.tracer.startActiveSpan(name, {
       ...options,
-      attributes
+      attributes,
+      startTime: clock.preciseNow()
     }, parentContext, async (span) => {
       this.tracer.startSpan(name, {
         ...options,
@@ -901,57 +3484,72 @@ var _TriggerTracer = class _TriggerTracer {
         });
         throw e;
       } finally {
-        span.end();
+        span.end(clock.preciseNow());
+      }
+    });
+  }
+  startSpan(name, options, ctx) {
+    const parentContext = ctx ?? api.context.active();
+    const attributes = options?.attributes ?? {};
+    const span = this.tracer.startSpan(name, options, ctx);
+    this.tracer.startSpan(name, {
+      ...options,
+      attributes: {
+        ...attributes,
+        [SemanticInternalAttributes.SPAN_PARTIAL]: true,
+        [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId
       }
-    });
+    }, parentContext).end();
+    return span;
   }
 };
 __name(_TriggerTracer, "TriggerTracer");
 var TriggerTracer = _TriggerTracer;
-var _handleLog, handleLog_fn, _getAttributes, getAttributes_fn;
+var _handleLog, handleLog_fn, _getTimestampInHrTime2, getTimestampInHrTime_fn2, _getAttributes, getAttributes_fn;
 var _ConsoleInterceptor = class _ConsoleInterceptor {
   constructor(logger2) {
     __privateAdd(this, _handleLog);
+    __privateAdd(this, _getTimestampInHrTime2);
     __privateAdd(this, _getAttributes);
     this.logger = logger2;
   }
   // Intercept the console and send logs to the OpenTelemetry logger
   // during the execution of the callback
-  async intercept(console, callback) {
+  async intercept(console2, callback) {
     const originalConsole = {
-      log: console.log,
-      info: console.info,
-      warn: console.warn,
-      error: console.error
+      log: console2.log,
+      info: console2.info,
+      warn: console2.warn,
+      error: console2.error
     };
-    console.log = this.log.bind(this);
-    console.info = this.info.bind(this);
-    console.warn = this.warn.bind(this);
-    console.error = this.error.bind(this);
+    console2.log = this.log.bind(this);
+    console2.info = this.info.bind(this);
+    console2.warn = this.warn.bind(this);
+    console2.error = this.error.bind(this);
     try {
       return await callback();
     } finally {
-      console.log = originalConsole.log;
-      console.info = originalConsole.info;
-      console.warn = originalConsole.warn;
-      console.error = originalConsole.error;
+      console2.log = originalConsole.log;
+      console2.info = originalConsole.info;
+      console2.warn = originalConsole.warn;
+      console2.error = originalConsole.error;
     }
   }
   log(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, "Log", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Log", ...args);
   }
   info(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, "Info", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Info", ...args);
   }
   warn(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.WARN, "Warn", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.WARN, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Warn", ...args);
   }
   error(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.ERROR, "Error", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.ERROR, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Error", ...args);
   }
 };
 _handleLog = new WeakSet();
-handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, severityText, ...args) {
+handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, timestamp, severityText, ...args) {
   const body = util__default.default.format(...args);
   const parsed = tryParseJSON(body);
   if (parsed.ok) {
@@ -960,9 +3558,10 @@ handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, severityText, ...
       severityText,
       body: getLogMessage(parsed.value, severityText),
       attributes: {
-        ...__privateMethod(this, _getAttributes, getAttributes_fn).call(this),
+        ...__privateMethod(this, _getAttributes, getAttributes_fn).call(this, severityNumber),
         ...flattenAttributes(parsed.value)
-      }
+      },
+      timestamp
     });
     return;
   }
@@ -970,14 +3569,22 @@ handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, severityText, ...
     severityNumber,
     severityText,
     body,
-    attributes: __privateMethod(this, _getAttributes, getAttributes_fn).call(this)
+    attributes: __privateMethod(this, _getAttributes, getAttributes_fn).call(this, severityNumber),
+    timestamp
   });
 }, "#handleLog");
+_getTimestampInHrTime2 = new WeakSet();
+getTimestampInHrTime_fn2 = /* @__PURE__ */ __name(function() {
+  return clock.preciseNow();
+}, "#getTimestampInHrTime");
 _getAttributes = new WeakSet();
-getAttributes_fn = /* @__PURE__ */ __name(function() {
-  return {
-    "log.type": "console"
-  };
+getAttributes_fn = /* @__PURE__ */ __name(function(severityNumber1) {
+  const icon = iconStringForSeverity(severityNumber1);
+  let result = {};
+  if (icon !== void 0) {
+    result[SemanticInternalAttributes.STYLE_ICON] = icon;
+  }
+  return result;
 }, "#getAttributes");
 __name(_ConsoleInterceptor, "ConsoleInterceptor");
 var ConsoleInterceptor = _ConsoleInterceptor;
@@ -1019,28 +3626,1077 @@ function tryParseJSON(value) {
 }
 __name(tryParseJSON, "tryParseJSON");
 
+// src/retry.ts
+function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return;
+  switch (format) {
+    case "iso_8601_duration_openai_variant": {
+      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
+    }
+    case "iso_8601": {
+      return calculateISO8601ResetAt(resets, now);
+    }
+    case "unix_timestamp": {
+      return calculateUnixTimestampResetAt(resets, now);
+    }
+    case "unix_timestamp_in_ms": {
+      return calculateUnixTimestampInMsResetAt(resets, now);
+    }
+  }
+}
+__name(calculateResetAt, "calculateResetAt");
+function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt * 1e3);
+}
+__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
+function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt);
+}
+__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
+function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = new Date(resets);
+  if (isNaN(resetAt.getTime()))
+    return void 0;
+  return resetAt;
+}
+__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
+function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
+  const match = resets.match(pattern);
+  if (!match)
+    return void 0;
+  const days = parseInt(match[1], 10) || 0;
+  const hours = parseInt(match[2], 10) || 0;
+  const minutes = parseInt(match[3], 10) || 0;
+  const seconds = parseFloat(match[4]) || 0;
+  const milliseconds = parseInt(match[5], 10) || 0;
+  const resetAt = new Date(now);
+  resetAt.setDate(resetAt.getDate() + days);
+  resetAt.setHours(resetAt.getHours() + hours);
+  resetAt.setMinutes(resetAt.getMinutes() + minutes);
+  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
+  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
+  return resetAt;
+}
+__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
+
+// src/v3/utils/retries.ts
+var defaultRetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+var defaultFetchRetryOptions = {
+  byStatus: {
+    "429,408,409,5xx": {
+      strategy: "backoff",
+      ...defaultRetryOptions
+    }
+  },
+  connectionError: defaultRetryOptions,
+  timeout: defaultRetryOptions
+};
+function calculateNextRetryDelay(options, attempt) {
+  const opts = {
+    ...defaultRetryOptions,
+    ...options
+  };
+  if (attempt >= opts.maxAttempts) {
+    return;
+  }
+  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
+  const random = randomize ? Math.random() + 1 : 1;
+  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
+  return Math.round(timeout);
+}
+__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+function calculateResetAt2(resets, format, now = Date.now()) {
+  const resetAt = calculateResetAt(resets, format, new Date(now));
+  return resetAt?.getTime();
+}
+__name(calculateResetAt2, "calculateResetAt");
+
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
+}
+__name(accessoryAttributes, "accessoryAttributes");
+
+// 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)) {
+      if (patternValue.length === 0) {
+        continue;
+      }
+      if (patternValue.every((item) => typeof item === "string")) {
+        if (patternValue.includes(payloadValue)) {
+          continue;
+        }
+        return false;
+      }
+      if (patternValue.every((item) => typeof item === "number")) {
+        if (patternValue.includes(payloadValue)) {
+          continue;
+        }
+        return false;
+      }
+      if (patternValue.every((item) => typeof item === "boolean")) {
+        if (patternValue.includes(payloadValue)) {
+          continue;
+        }
+        return false;
+      }
+      const objectArray = patternValue;
+      if (!contentFiltersMatches(payloadValue, objectArray)) {
+        return false;
+      }
+      continue;
+    } else if (typeof patternValue === "object") {
+      if (Array.isArray(payloadValue)) {
+        if (!payloadValue.some((item) => eventFilterMatches(item, patternValue))) {
+          return false;
+        }
+      } else {
+        if (!eventFilterMatches(payloadValue, patternValue)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+__name(eventFilterMatches, "eventFilterMatches");
+function contentFiltersMatches(actualValue, contentFilters) {
+  for (const contentFilter of contentFilters) {
+    if (typeof contentFilter === "object") {
+      Object.entries(contentFilter)[0];
+      if (!contentFilterMatches(actualValue, contentFilter)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+__name(contentFiltersMatches, "contentFiltersMatches");
+function contentFilterMatches(actualValue, contentFilter) {
+  if ("$endsWith" in contentFilter) {
+    if (typeof actualValue !== "string") {
+      return false;
+    }
+    return actualValue.endsWith(contentFilter.$endsWith);
+  }
+  if ("$startsWith" in contentFilter) {
+    if (typeof actualValue !== "string") {
+      return false;
+    }
+    return actualValue.startsWith(contentFilter.$startsWith);
+  }
+  if ("$anythingBut" in contentFilter) {
+    if (Array.isArray(contentFilter.$anythingBut)) {
+      if (contentFilter.$anythingBut.includes(actualValue)) {
+        return false;
+      }
+    }
+    if (contentFilter.$anythingBut === actualValue) {
+      return false;
+    }
+    return true;
+  }
+  if ("$exists" in contentFilter) {
+    if (contentFilter.$exists) {
+      return actualValue !== void 0;
+    }
+    return actualValue === void 0;
+  }
+  if ("$gt" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue > contentFilter.$gt;
+  }
+  if ("$lt" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue < contentFilter.$lt;
+  }
+  if ("$gte" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue >= contentFilter.$gte;
+  }
+  if ("$lte" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue <= contentFilter.$lte;
+  }
+  if ("$between" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue >= contentFilter.$between[0] && actualValue <= contentFilter.$between[1];
+  }
+  if ("$includes" in contentFilter) {
+    if (Array.isArray(actualValue)) {
+      return actualValue.includes(contentFilter.$includes);
+    }
+    return false;
+  }
+  if ("$ignoreCaseEquals" in contentFilter) {
+    if (typeof actualValue !== "string") {
+      return false;
+    }
+    return actualValue.localeCompare(contentFilter.$ignoreCaseEquals, void 0, {
+      sensitivity: "accent"
+    }) === 0;
+  }
+  if ("$isNull" in contentFilter) {
+    if (contentFilter.$isNull) {
+      return actualValue === null;
+    }
+    return actualValue !== null;
+  }
+  if ("$not" in contentFilter) {
+    if (Array.isArray(actualValue)) {
+      return !actualValue.includes(contentFilter.$not);
+    } else if (typeof actualValue === "number" || typeof actualValue === "boolean" || typeof actualValue === "string") {
+      return actualValue !== contentFilter.$not;
+    }
+    return false;
+  }
+  return true;
+}
+__name(contentFilterMatches, "contentFilterMatches");
+
+// src/v3/utils/omit.ts
+function omit(obj, ...keys) {
+  const result = {};
+  for (const key in obj) {
+    if (!keys.includes(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+__name(omit, "omit");
+var _a2;
+var AsyncResourceDetector = (_a2 = class {
+  constructor() {
+    __publicField(this, "_resolved", false);
+    this._promise = new Promise((resolver) => {
+      this._resolver = resolver;
+    });
+  }
+  detect(_config) {
+    return new resources.Resource({}, this._promise);
+  }
+  resolveWithAttributes(attributes) {
+    if (!this._resolver) {
+      throw new Error("Resolver not available");
+    }
+    if (this._resolved) {
+      return;
+    }
+    this._resolved = true;
+    this._resolver(attributes);
+  }
+}, __name(_a2, "AsyncResourceDetector"), _a2);
+var _TracingSDK = class _TracingSDK {
+  constructor(config) {
+    this.config = config;
+    this.asyncResourceDetector = new AsyncResourceDetector();
+    setLogLevel(config.diagLogLevel ?? "none");
+    const envResourceAttributesSerialized = getEnvVar("OTEL_RESOURCE_ATTRIBUTES");
+    const envResourceAttributes = envResourceAttributesSerialized ? JSON.parse(envResourceAttributesSerialized) : {};
+    const commonResources = resources.detectResourcesSync({
+      detectors: [
+        this.asyncResourceDetector,
+        resources.processDetectorSync
+      ]
+    }).merge(new resources.Resource({
+      [semanticConventions.SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev",
+      [SemanticInternalAttributes.TRIGGER]: true
+    })).merge(config.resource ?? new resources.Resource({})).merge(new resources.Resource(envResourceAttributes));
+    const traceProvider = new sdkTraceNode.NodeTracerProvider({
+      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500,
+      resource: commonResources,
+      spanLimits: {
+        attributeCountLimit: OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
+        attributeValueLengthLimit: OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT,
+        eventCountLimit: OTEL_SPAN_EVENT_COUNT_LIMIT,
+        attributePerEventCountLimit: OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
+        linkCountLimit: OTEL_LINK_COUNT_LIMIT,
+        attributePerLinkCountLimit: OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT
+      }
+    });
+    const spanExporter = new exporterTraceOtlpHttp.OTLPTraceExporter({
+      url: `${config.url}/v1/traces`,
+      timeoutMillis: config.forceFlushTimeoutMillis ?? 1e3
+    });
+    traceProvider.addSpanProcessor(new TaskContextSpanProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new sdkTraceNode.BatchSpanProcessor(spanExporter, {
+      maxExportBatchSize: parseInt(getEnvVar("OTEL_SPAN_MAX_EXPORT_BATCH_SIZE") ?? "64"),
+      scheduledDelayMillis: parseInt(getEnvVar("OTEL_SPAN_SCHEDULED_DELAY_MILLIS") ?? "200"),
+      exportTimeoutMillis: parseInt(getEnvVar("OTEL_SPAN_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
+      maxQueueSize: parseInt(getEnvVar("OTEL_SPAN_MAX_QUEUE_SIZE") ?? "512")
+    }) : new sdkTraceNode.SimpleSpanProcessor(spanExporter)));
+    traceProvider.register();
+    instrumentation.registerInstrumentations({
+      instrumentations: config.instrumentations ?? [],
+      tracerProvider: traceProvider
+    });
+    const logExporter = new exporterLogsOtlpHttp.OTLPLogExporter({
+      url: `${config.url}/v1/logs`
+    });
+    const loggerProvider = new sdkLogs.LoggerProvider({
+      resource: commonResources,
+      logRecordLimits: {
+        attributeCountLimit: OTEL_LOG_ATTRIBUTE_COUNT_LIMIT,
+        attributeValueLengthLimit: OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT
+      }
+    });
+    loggerProvider.addLogRecordProcessor(new TaskContextLogProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new sdkLogs.BatchLogRecordProcessor(logExporter, {
+      maxExportBatchSize: parseInt(getEnvVar("OTEL_LOG_MAX_EXPORT_BATCH_SIZE") ?? "64"),
+      scheduledDelayMillis: parseInt(getEnvVar("OTEL_LOG_SCHEDULED_DELAY_MILLIS") ?? "200"),
+      exportTimeoutMillis: parseInt(getEnvVar("OTEL_LOG_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
+      maxQueueSize: parseInt(getEnvVar("OTEL_LOG_MAX_QUEUE_SIZE") ?? "512")
+    }) : new sdkLogs.SimpleLogRecordProcessor(logExporter)));
+    this._logProvider = loggerProvider;
+    this._spanExporter = spanExporter;
+    this._traceProvider = traceProvider;
+    apiLogs.logs.setGlobalLoggerProvider(loggerProvider);
+    this.getLogger = loggerProvider.getLogger.bind(loggerProvider);
+    this.getTracer = traceProvider.getTracer.bind(traceProvider);
+  }
+  async flush() {
+    await this._traceProvider.forceFlush();
+    await this._logProvider.forceFlush();
+  }
+  async shutdown() {
+    await this._traceProvider.shutdown();
+    await this._logProvider.shutdown();
+  }
+};
+__name(_TracingSDK, "TracingSDK");
+var TracingSDK = _TracingSDK;
+function setLogLevel(level) {
+  let diagLogLevel;
+  switch (level) {
+    case "none":
+      diagLogLevel = api.DiagLogLevel.NONE;
+      break;
+    case "error":
+      diagLogLevel = api.DiagLogLevel.ERROR;
+      break;
+    case "warn":
+      diagLogLevel = api.DiagLogLevel.WARN;
+      break;
+    case "info":
+      diagLogLevel = api.DiagLogLevel.INFO;
+      break;
+    case "debug":
+      diagLogLevel = api.DiagLogLevel.DEBUG;
+      break;
+    case "verbose":
+      diagLogLevel = api.DiagLogLevel.VERBOSE;
+      break;
+    case "all":
+      diagLogLevel = api.DiagLogLevel.ALL;
+      break;
+    default:
+      diagLogLevel = api.DiagLogLevel.NONE;
+  }
+  api.diag.setLogger(new api.DiagConsoleLogger(), diagLogLevel);
+}
+__name(setLogLevel, "setLogLevel");
+
+// src/v3/otel/index.ts
+function recordSpanException(span, error) {
+  if (error instanceof Error) {
+    span.recordException(error);
+  } else if (typeof error === "string") {
+    span.recordException(new Error(error));
+  } else {
+    span.recordException(new Error(JSON.stringify(error)));
+  }
+  span.setStatus({
+    code: api.SpanStatusCode.ERROR
+  });
+}
+__name(recordSpanException, "recordSpanException");
+
+// src/v3/utils/ioSerialization.ts
+async function parsePacket(value) {
+  if (!value.data) {
+    return void 0;
+  }
+  switch (value.dataType) {
+    case "application/json":
+      return JSON.parse(value.data);
+    case "application/super+json":
+      const { parse } = await loadSuperJSON();
+      return parse(value.data);
+    case "text/plain":
+      return value.data;
+    case "application/store":
+      throw new Error(`Cannot parse an application/store packet (${value.data}). Needs to be imported first.`);
+    default:
+      return value.data;
+  }
+}
+__name(parsePacket, "parsePacket");
+async function stringifyIO(value) {
+  if (value === void 0) {
+    return {
+      dataType: "application/json"
+    };
+  }
+  if (typeof value === "string") {
+    return {
+      data: value,
+      dataType: "text/plain"
+    };
+  }
+  try {
+    const { stringify } = await loadSuperJSON();
+    const data = stringify(value);
+    return {
+      data,
+      dataType: "application/super+json"
+    };
+  } catch {
+    return {
+      dataType: "application/json"
+    };
+  }
+}
+__name(stringifyIO, "stringifyIO");
+async function conditionallyExportPacket(packet, pathPrefix, tracer) {
+  if (apiClientManager.client) {
+    const { needsOffloading, size } = packetRequiresOffloading(packet);
+    if (needsOffloading) {
+      if (!tracer) {
+        return await exportPacket(packet, pathPrefix);
+      } else {
+        const result = await tracer.startActiveSpan("store.uploadOutput", async (span) => {
+          return await exportPacket(packet, pathPrefix);
+        }, {
+          attributes: {
+            byteLength: size,
+            [SemanticInternalAttributes.STYLE_ICON]: "cloud-upload"
+          }
+        });
+        return result ?? packet;
+      }
+    }
+  }
+  return packet;
+}
+__name(conditionallyExportPacket, "conditionallyExportPacket");
+function packetRequiresOffloading(packet) {
+  if (!packet.data) {
+    return {
+      needsOffloading: false,
+      size: 0
+    };
+  }
+  const byteSize = Buffer.byteLength(packet.data, "utf8");
+  return {
+    needsOffloading: byteSize >= OFFLOAD_IO_PACKET_LENGTH_LIMIT,
+    size: byteSize
+  };
+}
+__name(packetRequiresOffloading, "packetRequiresOffloading");
+async function exportPacket(packet, pathPrefix) {
+  const filename = `${pathPrefix}.${getPacketExtension(packet.dataType)}`;
+  const presignedResponse = await apiClientManager.client.createUploadPayloadUrl(filename);
+  if (presignedResponse.ok) {
+    const uploadResponse = await fetch(presignedResponse.data.presignedUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": packet.dataType
+      },
+      body: packet.data
+    });
+    if (!uploadResponse.ok) {
+      throw new Error(`Failed to upload output to ${presignedResponse.data.presignedUrl}: ${uploadResponse.statusText}`);
+    }
+    return {
+      data: filename,
+      dataType: "application/store"
+    };
+  }
+  return packet;
+}
+__name(exportPacket, "exportPacket");
+async function conditionallyImportPacket(packet, tracer) {
+  if (packet.dataType !== "application/store") {
+    return packet;
+  }
+  if (!tracer) {
+    return await importPacket(packet);
+  } else {
+    const result = await tracer.startActiveSpan("store.downloadPayload", async (span) => {
+      return await importPacket(packet, span);
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "cloud-download"
+      }
+    });
+    return result ?? packet;
+  }
+}
+__name(conditionallyImportPacket, "conditionallyImportPacket");
+async function importPacket(packet, span) {
+  if (!packet.data) {
+    return packet;
+  }
+  if (!apiClientManager.client) {
+    return packet;
+  }
+  const presignedResponse = await apiClientManager.client.getPayloadUrl(packet.data);
+  if (presignedResponse.ok) {
+    const response = await fetch(presignedResponse.data.presignedUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to import packet ${presignedResponse.data.presignedUrl}: ${response.statusText}`);
+    }
+    const data = await response.text();
+    span?.setAttribute("size", Buffer.byteLength(data, "utf8"));
+    return {
+      data,
+      dataType: response.headers.get("content-type") ?? "application/json"
+    };
+  }
+  return packet;
+}
+__name(importPacket, "importPacket");
+async function createPacketAttributes(packet, dataKey, dataTypeKey) {
+  if (!packet.data) {
+    return;
+  }
+  switch (packet.dataType) {
+    case "application/json":
+      return {
+        ...flattenAttributes(packet, dataKey),
+        [dataTypeKey]: packet.dataType
+      };
+    case "application/super+json":
+      const { parse } = await loadSuperJSON();
+      if (typeof packet.data === "undefined" || packet.data === null) {
+        return;
+      }
+      try {
+        const parsed = parse(packet.data);
+        const jsonified = JSON.parse(JSON.stringify(parsed, safeReplacer));
+        return {
+          ...flattenAttributes(jsonified, dataKey),
+          [dataTypeKey]: "application/json"
+        };
+      } catch {
+        return;
+      }
+    case "application/store":
+      return {
+        [dataKey]: packet.data,
+        [dataTypeKey]: packet.dataType
+      };
+    case "text/plain":
+      return {
+        [dataKey]: packet.data,
+        [dataTypeKey]: packet.dataType
+      };
+    default:
+      return;
+  }
+}
+__name(createPacketAttributes, "createPacketAttributes");
+async function createPacketAttributesAsJson(data, dataType) {
+  if (typeof data === "string" || typeof data === "number" || typeof data === "boolean" || data === null || data === void 0) {
+    return data;
+  }
+  switch (dataType) {
+    case "application/json":
+      return imposeAttributeLimits(flattenAttributes(data, void 0));
+    case "application/super+json":
+      const { deserialize } = await loadSuperJSON();
+      const deserialized = deserialize(data);
+      const jsonify = safeJsonParse(JSON.stringify(deserialized, safeReplacer));
+      return imposeAttributeLimits(flattenAttributes(jsonify, void 0));
+    case "application/store":
+      return data;
+    default:
+      return {};
+  }
+}
+__name(createPacketAttributesAsJson, "createPacketAttributesAsJson");
+async function prettyPrintPacket(rawData, dataType) {
+  if (rawData === void 0) {
+    return "";
+  }
+  if (dataType === "application/super+json") {
+    const { deserialize } = await loadSuperJSON();
+    return await prettyPrintPacket(deserialize(rawData), "application/json");
+  }
+  if (dataType === "application/json") {
+    return JSON.stringify(rawData, safeReplacer, 2);
+  }
+  if (typeof rawData === "string") {
+    return rawData;
+  }
+  return JSON.stringify(rawData, safeReplacer, 2);
+}
+__name(prettyPrintPacket, "prettyPrintPacket");
+function safeReplacer(key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  if (value instanceof Set) {
+    return Array.from(value);
+  }
+  if (value instanceof Map) {
+    const obj = {};
+    value.forEach((v, k) => {
+      obj[k] = v;
+    });
+    return obj;
+  }
+  return value;
+}
+__name(safeReplacer, "safeReplacer");
+function getPacketExtension(outputType) {
+  switch (outputType) {
+    case "application/json":
+      return "json";
+    case "application/super+json":
+      return "json";
+    case "text/plain":
+      return "txt";
+    default:
+      return "txt";
+  }
+}
+__name(getPacketExtension, "getPacketExtension");
+async function loadSuperJSON() {
+  return await import('superjson');
+}
+__name(loadSuperJSON, "loadSuperJSON");
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+}
+__name(safeJsonParse, "safeJsonParse");
+
+// src/v3/workers/taskExecutor.ts
+var _callRun, callRun_fn, _callTaskInit, callTaskInit_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
+var _TaskExecutor = class _TaskExecutor {
+  constructor(task, options) {
+    __privateAdd(this, _callRun);
+    __privateAdd(this, _callTaskInit);
+    __privateAdd(this, _callTaskCleanup);
+    __privateAdd(this, _handleError);
+    this.task = task;
+    this._tracingSDK = options.tracingSDK;
+    this._tracer = options.tracer;
+    this._consoleInterceptor = options.consoleInterceptor;
+    this._config = options.projectConfig;
+    this._importedConfig = options.importedConfig;
+    this._handleErrorFn = options.handleErrorFn;
+  }
+  async execute(execution, worker, traceContext) {
+    const ctx = TaskRunContext.parse(execution);
+    const attemptMessage = `Attempt ${execution.attempt.number}`;
+    const originalPacket = {
+      data: execution.run.payload,
+      dataType: execution.run.payloadType
+    };
+    const result = await taskContextManager.runWith({
+      ctx,
+      worker
+    }, async () => {
+      this._tracingSDK.asyncResourceDetector.resolveWithAttributes({
+        ...taskContextManager.attributes,
+        [SemanticInternalAttributes.SDK_VERSION]: this.task.packageVersion,
+        [SemanticInternalAttributes.SDK_LANGUAGE]: "typescript"
+      });
+      return await this._tracer.startActiveSpan(attemptMessage, async (span) => {
+        return await this._consoleInterceptor.intercept(console, async () => {
+          let parsedPayload;
+          let initOutput;
+          try {
+            const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
+            parsedPayload = await parsePacket(payloadPacket);
+            initOutput = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
+            const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
+            try {
+              const stringifiedOutput = await stringifyIO(output);
+              const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
+              const attributes = await createPacketAttributes(finalOutput, SemanticInternalAttributes.OUTPUT, SemanticInternalAttributes.OUTPUT_TYPE);
+              if (attributes) {
+                span.setAttributes(attributes);
+              }
+              return {
+                ok: true,
+                id: execution.attempt.id,
+                output: finalOutput.data,
+                outputType: finalOutput.dataType
+              };
+            } catch (stringifyError) {
+              recordSpanException(span, stringifyError);
+              return {
+                ok: false,
+                id: execution.attempt.id,
+                error: {
+                  type: "INTERNAL_ERROR",
+                  code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
+                  message: stringifyError instanceof Error ? stringifyError.message : typeof stringifyError === "string" ? stringifyError : void 0
+                }
+              };
+            }
+          } catch (runError) {
+            try {
+              const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
+              recordSpanException(span, handleErrorResult.error ?? runError);
+              return {
+                id: execution.attempt.id,
+                ok: false,
+                error: handleErrorResult.error ? parseError(handleErrorResult.error) : parseError(runError),
+                retry: handleErrorResult.status === "retry" ? handleErrorResult.retry : void 0,
+                skippedRetrying: handleErrorResult.status === "skipped"
+              };
+            } catch (handleErrorError) {
+              recordSpanException(span, handleErrorError);
+              return {
+                ok: false,
+                id: execution.attempt.id,
+                error: {
+                  type: "INTERNAL_ERROR",
+                  code: TaskRunErrorCodes.HANDLE_ERROR_ERROR,
+                  message: handleErrorError instanceof Error ? handleErrorError.message : typeof handleErrorError === "string" ? handleErrorError : void 0
+                }
+              };
+            }
+          } finally {
+            await __privateMethod(this, _callTaskCleanup, callTaskCleanup_fn).call(this, parsedPayload, ctx, initOutput);
+          }
+        });
+      }, {
+        kind: api.SpanKind.CONSUMER,
+        attributes: {
+          [SemanticInternalAttributes.STYLE_ICON]: "attempt",
+          ...accessoryAttributes({
+            items: [
+              {
+                text: ctx.task.filePath
+              },
+              {
+                text: `${ctx.task.exportName}.run()`
+              }
+            ],
+            style: "codepath"
+          })
+        }
+      }, this._tracer.extractContext(traceContext));
+    });
+    return result;
+  }
+};
+_callRun = new WeakSet();
+callRun_fn = /* @__PURE__ */ __name(async function(payload, ctx, init) {
+  const runFn = this.task.fns.run;
+  const middlewareFn = this.task.fns.middleware;
+  if (!runFn) {
+    throw new Error("Task does not have a run function");
+  }
+  if (!middlewareFn) {
+    return runFn(payload, {
+      ctx
+    });
+  }
+  return middlewareFn(payload, {
+    ctx,
+    next: async () => runFn(payload, {
+      ctx,
+      init
+    })
+  });
+}, "#callRun");
+_callTaskInit = new WeakSet();
+callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+  const initFn = this.task.fns.init;
+  if (!initFn) {
+    return {};
+  }
+  return this._tracer.startActiveSpan("init", async (span) => {
+    return await initFn(payload1, {
+      ctx: ctx1
+    });
+  });
+}, "#callTaskInit");
+_callTaskCleanup = new WeakSet();
+callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload2, ctx2, init1) {
+  const cleanupFn = this.task.fns.cleanup;
+  if (!cleanupFn) {
+    return;
+  }
+  return this._tracer.startActiveSpan("cleanup", async (span) => {
+    return await cleanupFn(payload2, {
+      ctx: ctx2,
+      init: init1
+    });
+  });
+}, "#callTaskCleanup");
+_handleError = new WeakSet();
+handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload3, ctx3) {
+  const retriesConfig = this._importedConfig?.retries ?? this._config.retries;
+  const retry = this.task.retry ?? retriesConfig?.default;
+  if (!retry) {
+    return {
+      status: "noop"
+    };
+  }
+  const delay = calculateNextRetryDelay(retry, execution.attempt.number);
+  if (execution.environment.type === "DEVELOPMENT" && typeof retriesConfig?.enabledInDev === "boolean" && !retriesConfig.enabledInDev) {
+    return {
+      status: "skipped"
+    };
+  }
+  return this._tracer.startActiveSpan("handleError()", async (span) => {
+    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload3, error, {
+      ctx: ctx3,
+      retry,
+      retryDelayInMs: delay,
+      retryAt: delay ? new Date(Date.now() + delay) : void 0
+    }) : this._importedConfig ? await this._handleErrorFn?.(payload3, error, {
+      ctx: ctx3,
+      retry,
+      retryDelayInMs: delay,
+      retryAt: delay ? new Date(Date.now() + delay) : void 0
+    }) : void 0;
+    if (!handleErrorResult) {
+      return typeof delay === "undefined" ? {
+        status: "noop"
+      } : {
+        status: "retry",
+        retry: {
+          timestamp: Date.now() + delay,
+          delay
+        }
+      };
+    }
+    if (handleErrorResult.skipRetrying) {
+      return {
+        status: "skipped",
+        error: handleErrorResult.error
+      };
+    }
+    if (typeof handleErrorResult.retryAt !== "undefined") {
+      return {
+        status: "retry",
+        retry: {
+          timestamp: handleErrorResult.retryAt.getTime(),
+          delay: handleErrorResult.retryAt.getTime() - Date.now()
+        },
+        error: handleErrorResult.error
+      };
+    }
+    if (typeof handleErrorResult.retryDelayInMs === "number") {
+      return {
+        status: "retry",
+        retry: {
+          timestamp: Date.now() + handleErrorResult.retryDelayInMs,
+          delay: handleErrorResult.retryDelayInMs
+        },
+        error: handleErrorResult.error
+      };
+    }
+    if (handleErrorResult.retry && typeof handleErrorResult.retry === "object") {
+      const delay2 = calculateNextRetryDelay(handleErrorResult.retry, execution.attempt.number);
+      return typeof delay2 === "undefined" ? {
+        status: "noop",
+        error: handleErrorResult.error
+      } : {
+        status: "retry",
+        retry: {
+          timestamp: Date.now() + delay2,
+          delay: delay2
+        },
+        error: handleErrorResult.error
+      };
+    }
+    return {
+      status: "noop",
+      error: handleErrorResult.error
+    };
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "exclamation-circle"
+    }
+  });
+}, "#handleError");
+__name(_TaskExecutor, "TaskExecutor");
+var TaskExecutor = _TaskExecutor;
+
+// package.json
+var dependencies = {
+  "@google-cloud/precise-date": "^4.0.0",
+  "@opentelemetry/api": "^1.8.0",
+  "@opentelemetry/api-logs": "^0.48.0",
+  "@opentelemetry/exporter-logs-otlp-http": "^0.49.1",
+  "@opentelemetry/exporter-trace-otlp-http": "^0.49.1",
+  "@opentelemetry/instrumentation": "^0.49.1",
+  "@opentelemetry/resources": "^1.22.0",
+  "@opentelemetry/sdk-logs": "^0.49.1",
+  "@opentelemetry/sdk-node": "^0.49.1",
+  "@opentelemetry/sdk-trace-base": "^1.22.0",
+  "@opentelemetry/sdk-trace-node": "^1.22.0",
+  "@opentelemetry/semantic-conventions": "^1.22.0",
+  "humanize-duration": "^3.27.3",
+  "socket.io": "^4.7.4",
+  "socket.io-client": "^4.7.4",
+  superjson: "^2.2.1",
+  ulidx: "^2.2.1",
+  zod: "3.22.3",
+  "zod-error": "1.5.0"
+};
+
+// src/v3/utils/detectDependencyVersion.ts
+function detectDependencyVersion(dependency) {
+  return dependencies[dependency];
+}
+__name(detectDependencyVersion, "detectDependencyVersion");
+
 // src/v3/index.ts
 function parseTriggerTaskRequestBody(body) {
   return TriggerTaskRequestBody.safeParse(body);
 }
 __name(parseTriggerTaskRequestBody, "parseTriggerTaskRequestBody");
+function parseBatchTriggerTaskRequestBody(body) {
+  return BatchTriggerTaskRequestBody.safeParse(body);
+}
+__name(parseBatchTriggerTaskRequestBody, "parseBatchTriggerTaskRequestBody");
 
 exports.ApiClient = ApiClient;
+exports.ApiClientManager = ApiClientManager;
 exports.BackgroundWorkerClientMessages = BackgroundWorkerClientMessages;
 exports.BackgroundWorkerMetadata = BackgroundWorkerMetadata;
-exports.BackgroundWorkerRecord = BackgroundWorkerRecord;
+exports.BackgroundWorkerProperties = BackgroundWorkerProperties;
 exports.BackgroundWorkerServerMessages = BackgroundWorkerServerMessages;
+exports.BatchTaskRunExecutionResult = BatchTaskRunExecutionResult;
+exports.BatchTriggerTaskRequestBody = BatchTriggerTaskRequestBody;
+exports.BatchTriggerTaskResponse = BatchTriggerTaskResponse;
+exports.CancellationSpanEvent = CancellationSpanEvent;
+exports.ClientToSharedQueueMessages = ClientToSharedQueueMessages;
+exports.Config = Config;
 exports.ConsoleInterceptor = ConsoleInterceptor;
+exports.CoordinatorToPlatformMessages = CoordinatorToPlatformMessages;
+exports.CoordinatorToProdWorkerMessages = CoordinatorToProdWorkerMessages;
 exports.CreateAuthorizationCodeResponseSchema = CreateAuthorizationCodeResponseSchema;
 exports.CreateBackgroundWorkerRequestBody = CreateBackgroundWorkerRequestBody;
 exports.CreateBackgroundWorkerResponse = CreateBackgroundWorkerResponse;
+exports.CreateUploadPayloadUrlResponseBody = CreateUploadPayloadUrlResponseBody;
+exports.DeploymentErrorData = DeploymentErrorData;
 exports.DevRuntimeManager = DevRuntimeManager;
+exports.DurableClock = PreciseWallClock;
+exports.EnvironmentType = EnvironmentType;
+exports.EventFilter = EventFilter;
+exports.ExceptionEventProperties = ExceptionEventProperties;
+exports.ExceptionSpanEvent = ExceptionSpanEvent;
+exports.ExternalBuildData = ExternalBuildData;
+exports.FetchRetryBackoffStrategy = FetchRetryBackoffStrategy;
+exports.FetchRetryByStatusOptions = FetchRetryByStatusOptions;
+exports.FetchRetryHeadersStrategy = FetchRetryHeadersStrategy;
+exports.FetchRetryOptions = FetchRetryOptions;
+exports.FetchRetryStrategy = FetchRetryStrategy;
+exports.FetchTimeoutOptions = FetchTimeoutOptions;
+exports.FixedWindowRateLimit = FixedWindowRateLimit;
+exports.GetBatchResponseBody = GetBatchResponseBody;
+exports.GetDeploymentResponseBody = GetDeploymentResponseBody;
+exports.GetEnvironmentVariablesResponseBody = GetEnvironmentVariablesResponseBody;
 exports.GetPersonalAccessTokenRequestSchema = GetPersonalAccessTokenRequestSchema;
 exports.GetPersonalAccessTokenResponseSchema = GetPersonalAccessTokenResponseSchema;
-exports.GetProjectDevResponse = GetProjectDevResponse;
+exports.GetProjectEnvResponse = GetProjectEnvResponse;
+exports.GetProjectResponseBody = GetProjectResponseBody;
+exports.GetProjectsResponseBody = GetProjectsResponseBody;
+exports.ImageDetailsMetadata = ImageDetailsMetadata;
+exports.InitializeDeploymentRequestBody = InitializeDeploymentRequestBody;
+exports.InitializeDeploymentResponseBody = InitializeDeploymentResponseBody;
+exports.Machine = Machine;
+exports.MachineCpu = MachineCpu;
+exports.MachineMemory = MachineMemory;
+exports.OFFLOAD_IO_PACKET_LENGTH_LIMIT = OFFLOAD_IO_PACKET_LENGTH_LIMIT;
+exports.OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT;
+exports.OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT;
+exports.OTEL_LINK_COUNT_LIMIT = OTEL_LINK_COUNT_LIMIT;
+exports.OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = OTEL_LOG_ATTRIBUTE_COUNT_LIMIT;
+exports.OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+exports.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT;
+exports.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+exports.OTEL_SPAN_EVENT_COUNT_LIMIT = OTEL_SPAN_EVENT_COUNT_LIMIT;
 exports.OtelTaskLogger = OtelTaskLogger;
+exports.OtherSpanEvent = OtherSpanEvent;
+exports.PRIMARY_VARIANT = PRIMARY_VARIANT;
+exports.PlatformToCoordinatorMessages = PlatformToCoordinatorMessages;
+exports.PlatformToProviderMessages = PlatformToProviderMessages;
+exports.PostStartCauses = PostStartCauses;
+exports.PreStopCauses = PreStopCauses;
+exports.ProdChildToWorkerMessages = ProdChildToWorkerMessages;
+exports.ProdRuntimeManager = ProdRuntimeManager;
+exports.ProdTaskRunExecution = ProdTaskRunExecution;
+exports.ProdTaskRunExecutionPayload = ProdTaskRunExecutionPayload;
+exports.ProdWorkerSocketData = ProdWorkerSocketData;
+exports.ProdWorkerToChildMessages = ProdWorkerToChildMessages;
+exports.ProdWorkerToCoordinatorMessages = ProdWorkerToCoordinatorMessages;
+exports.ProviderToPlatformMessages = ProviderToPlatformMessages;
+exports.QueueOptions = QueueOptions;
+exports.RateLimitOptions = RateLimitOptions;
+exports.RetryOptions = RetryOptions;
 exports.SemanticInternalAttributes = SemanticInternalAttributes;
+exports.SharedQueueToClientMessages = SharedQueueToClientMessages;
+exports.SimpleStructuredLogger = SimpleStructuredLogger;
+exports.SlidingWindowRateLimit = SlidingWindowRateLimit;
+exports.SpanEvent = SpanEvent;
+exports.SpanEvents = SpanEvents;
+exports.SpanMessagingEvent = SpanMessagingEvent;
+exports.StartDeploymentIndexingRequestBody = StartDeploymentIndexingRequestBody;
+exports.StartDeploymentIndexingResponseBody = StartDeploymentIndexingResponseBody;
+exports.TaskContextSpanProcessor = TaskContextSpanProcessor;
+exports.TaskEventStyle = TaskEventStyle;
+exports.TaskExecutor = TaskExecutor;
 exports.TaskMetadata = TaskMetadata;
+exports.TaskMetadataFailedToParseData = TaskMetadataFailedToParseData;
 exports.TaskMetadataWithFilePath = TaskMetadataWithFilePath;
 exports.TaskResource = TaskResource;
 exports.TaskRun = TaskRun;
@@ -1051,32 +4707,82 @@ exports.TaskRunError = TaskRunError;
 exports.TaskRunErrorCodes = TaskRunErrorCodes;
 exports.TaskRunExecution = TaskRunExecution;
 exports.TaskRunExecutionAttempt = TaskRunExecutionAttempt;
+exports.TaskRunExecutionBatch = TaskRunExecutionBatch;
 exports.TaskRunExecutionEnvironment = TaskRunExecutionEnvironment;
 exports.TaskRunExecutionOrganization = TaskRunExecutionOrganization;
 exports.TaskRunExecutionPayload = TaskRunExecutionPayload;
 exports.TaskRunExecutionProject = TaskRunExecutionProject;
+exports.TaskRunExecutionQueue = TaskRunExecutionQueue;
 exports.TaskRunExecutionResult = TaskRunExecutionResult;
+exports.TaskRunExecutionRetry = TaskRunExecutionRetry;
 exports.TaskRunExecutionTask = TaskRunExecutionTask;
 exports.TaskRunFailedExecutionResult = TaskRunFailedExecutionResult;
 exports.TaskRunInternalError = TaskRunInternalError;
 exports.TaskRunStringError = TaskRunStringError;
 exports.TaskRunSuccessfulExecutionResult = TaskRunSuccessfulExecutionResult;
+exports.TracingSDK = TracingSDK;
 exports.TriggerTaskRequestBody = TriggerTaskRequestBody;
 exports.TriggerTaskResponse = TriggerTaskResponse;
 exports.TriggerTracer = TriggerTracer;
+exports.UncaughtExceptionMessage = UncaughtExceptionMessage;
+exports.WaitReason = WaitReason;
 exports.WhoAmIResponseSchema = WhoAmIResponseSchema;
+exports.ZodIpcConnection = ZodIpcConnection;
 exports.ZodMessageHandler = ZodMessageHandler;
+exports.ZodMessageSchema = ZodMessageSchema;
 exports.ZodMessageSender = ZodMessageSender;
+exports.ZodNamespace = ZodNamespace;
+exports.ZodSchemaParsedError = ZodSchemaParsedError;
+exports.ZodSocketConnection = ZodSocketConnection;
+exports.ZodSocketMessageHandler = ZodSocketMessageHandler;
+exports.ZodSocketMessageSender = ZodSocketMessageSender;
+exports.accessoryAttributes = accessoryAttributes;
+exports.apiClientManager = apiClientManager;
+exports.calculateNextRetryDelay = calculateNextRetryDelay;
+exports.calculateResetAt = calculateResetAt2;
 exports.childToWorkerMessages = childToWorkerMessages;
 exports.clientWebsocketMessages = clientWebsocketMessages;
+exports.clock = clock;
+exports.conditionallyExportPacket = conditionallyExportPacket;
+exports.conditionallyImportPacket = conditionallyImportPacket;
+exports.correctErrorStackTrace = correctErrorStackTrace;
 exports.createErrorTaskError = createErrorTaskError;
+exports.createPacketAttributes = createPacketAttributes;
+exports.createPacketAttributesAsJson = createPacketAttributesAsJson;
+exports.defaultFetchRetryOptions = defaultFetchRetryOptions;
+exports.defaultRetryOptions = defaultRetryOptions;
+exports.detectDependencyVersion = detectDependencyVersion;
+exports.eventFilterMatches = eventFilterMatches;
 exports.flattenAttributes = flattenAttributes;
+exports.formatDuration = formatDuration;
+exports.formatDurationInDays = formatDurationInDays;
+exports.formatDurationMilliseconds = formatDurationMilliseconds;
+exports.formatDurationNanoseconds = formatDurationNanoseconds;
+exports.getEnvVar = getEnvVar;
+exports.groupTaskMetadataIssuesByTask = groupTaskMetadataIssuesByTask;
+exports.iconStringForSeverity = iconStringForSeverity;
+exports.imposeAttributeLimits = imposeAttributeLimits;
+exports.isCancellationSpanEvent = isCancellationSpanEvent;
+exports.isExceptionSpanEvent = isExceptionSpanEvent;
+exports.logLevels = logLevels;
 exports.logger = logger;
+exports.millisecondsToNanoseconds = millisecondsToNanoseconds;
+exports.nanosecondsToMilliseconds = nanosecondsToMilliseconds;
+exports.omit = omit;
+exports.packetRequiresOffloading = packetRequiresOffloading;
+exports.parseBatchTriggerTaskRequestBody = parseBatchTriggerTaskRequestBody;
 exports.parseError = parseError;
+exports.parsePacket = parsePacket;
 exports.parseTriggerTaskRequestBody = parseTriggerTaskRequestBody;
+exports.prettyPrintPacket = prettyPrintPacket;
+exports.primitiveValueOrflattenedAttributes = primitiveValueOrflattenedAttributes;
+exports.recordSpanException = recordSpanException;
 exports.runtime = runtime;
 exports.serverWebsocketMessages = serverWebsocketMessages;
+exports.stringPatternMatchers = stringPatternMatchers;
+exports.stringifyIO = stringifyIO;
 exports.taskContextManager = taskContextManager;
+exports.unflattenAttributes = unflattenAttributes;
 exports.workerToChildMessages = workerToChildMessages;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map