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

package/dist/v3/index.mjs

@@ -1,8 +1,21 @@
 import { z } from 'zod';
-import { trace, propagation, context, SpanStatusCode } from '@opentelemetry/api';
+import { SpanStatusCode, trace, propagation, context, DiagLogLevel, diag, DiagConsoleLogger, SpanKind } from '@opentelemetry/api';
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { io } from 'socket.io-client';
+import { randomUUID } from 'crypto';
+import nodePath from 'node:path';
 import { SeverityNumber, logs } from '@opentelemetry/api-logs';
+import { PreciseDate } from '@google-cloud/precise-date';
+import humanizeDuration from 'humanize-duration';
+import { setTimeout as setTimeout$1 } from 'node:timers/promises';
 import util from 'node:util';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { registerInstrumentations } from '@opentelemetry/instrumentation';
+import { Resource, detectResourcesSync, processDetectorSync } from '@opentelemetry/resources';
+import { LoggerProvider, BatchLogRecordProcessor, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { NodeTracerProvider, BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -29,6 +42,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;
@@ -46,48 +67,6 @@ var GetPersonalAccessTokenResponseSchema = z.object({
     obfuscatedToken: z.string()
   }).nullable()
 });
-var TaskResource = z.object({
-  id: z.string(),
-  filePath: z.string(),
-  exportName: z.string()
-});
-var BackgroundWorkerMetadata = z.object({
-  packageVersion: z.string(),
-  contentHash: z.string(),
-  cliPackageVersion: z.string(),
-  tasks: z.array(TaskResource)
-});
-
-// src/v3/schemas/api.ts
-var WhoAmIResponseSchema = z.object({
-  userId: z.string(),
-  email: z.string().email()
-});
-var GetProjectDevResponse = z.object({
-  apiKey: z.string(),
-  name: z.string()
-});
-var CreateBackgroundWorkerRequestBody = z.object({
-  localOnly: z.boolean(),
-  metadata: BackgroundWorkerMetadata
-});
-var CreateBackgroundWorkerResponse = z.object({
-  id: z.string(),
-  version: z.string(),
-  contentHash: z.string()
-});
-var BackgroundWorkerRecord = CreateBackgroundWorkerResponse;
-var TriggerTaskRequestBody = z.object({
-  payload: z.any(),
-  context: z.any(),
-  options: z.object({
-    parentAttempt: z.string().optional(),
-    lockToCurrentVersion: z.boolean().optional()
-  }).optional()
-});
-var TriggerTaskResponse = z.object({
-  id: z.string()
-});
 var TaskRunBuiltInError = z.object({
   type: z.literal("BUILT_IN_ERROR"),
   name: z.string(),
@@ -103,13 +82,30 @@ var TaskRunStringError = z.object({
   raw: 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 = z.object({
   type: z.literal("INTERNAL_ERROR"),
   code: 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: z.string().optional()
 });
 var TaskRunError = z.discriminatedUnion("type", [
   TaskRunBuiltInError,
@@ -123,6 +119,7 @@ var TaskRun = z.object({
   payloadType: z.string(),
   context: z.any(),
   tags: z.array(z.string()),
+  isTest: z.boolean().default(false),
   createdAt: z.coerce.date()
 });
 var TaskRunExecutionTask = z.object({
@@ -159,13 +156,22 @@ var TaskRunExecutionProject = z.object({
   slug: z.string(),
   name: z.string()
 });
+var TaskRunExecutionQueue = z.object({
+  id: z.string(),
+  name: z.string()
+});
+var TaskRunExecutionBatch = z.object({
+  id: z.string()
+});
 var TaskRunExecution = z.object({
   task: TaskRunExecutionTask,
   attempt: TaskRunExecutionAttempt,
   run: TaskRun,
+  queue: TaskRunExecutionQueue,
   environment: TaskRunExecutionEnvironment,
   organization: TaskRunExecutionOrganization,
-  project: TaskRunExecutionProject
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional()
 });
 var TaskRunContext = z.object({
   task: TaskRunExecutionTask,
@@ -177,33 +183,105 @@ var TaskRunContext = z.object({
     payload: true,
     payloadType: true
   }),
+  queue: TaskRunExecutionQueue,
   environment: TaskRunExecutionEnvironment,
   organization: TaskRunExecutionOrganization,
-  project: TaskRunExecutionProject
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional()
+});
+var TaskRunExecutionRetry = z.object({
+  timestamp: z.number(),
+  delay: z.number(),
+  error: z.unknown().optional()
 });
 var TaskRunFailedExecutionResult = z.object({
   ok: z.literal(false),
   id: z.string(),
-  error: TaskRunError
+  error: TaskRunError,
+  retry: TaskRunExecutionRetry.optional(),
+  skippedRetrying: z.boolean().optional()
 });
 var TaskRunSuccessfulExecutionResult = z.object({
   ok: z.literal(true),
   id: z.string(),
-  output: z.string(),
+  output: z.string().optional(),
   outputType: z.string()
 });
 var TaskRunExecutionResult = z.discriminatedUnion("ok", [
   TaskRunSuccessfulExecutionResult,
   TaskRunFailedExecutionResult
 ]);
+var BatchTaskRunExecutionResult = z.object({
+  id: z.string(),
+  items: TaskRunExecutionResult.array()
+});
+
+// src/v3/schemas/messages.ts
+var EnvironmentType = z.enum([
+  "PRODUCTION",
+  "STAGING",
+  "DEVELOPMENT",
+  "PREVIEW"
+]);
+var MachineCpu = z.union([
+  z.literal(0.25),
+  z.literal(0.5),
+  z.literal(1),
+  z.literal(2),
+  z.literal(4)
+]).default(0.5);
+var MachineMemory = z.union([
+  z.literal(0.25),
+  z.literal(0.5),
+  z.literal(1),
+  z.literal(2),
+  z.literal(4),
+  z.literal(8)
+]).default(1);
+var Machine = z.object({
+  version: z.literal("v1").default("v1"),
+  cpu: MachineCpu,
+  memory: MachineMemory
+});
 var TaskRunExecutionPayload = z.object({
   execution: TaskRunExecution,
-  traceContext: z.record(z.unknown())
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
+});
+var ProdTaskRunExecution = TaskRunExecution.extend({
+  worker: z.object({
+    id: z.string(),
+    contentHash: z.string(),
+    version: z.string()
+  })
+});
+var ProdTaskRunExecutionPayload = z.object({
+  execution: ProdTaskRunExecution,
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
 });
 var BackgroundWorkerServerMessages = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("EXECUTE_RUNS"),
     payloads: z.array(TaskRunExecutionPayload)
+  }),
+  z.object({
+    type: z.literal("CANCEL_ATTEMPT"),
+    taskAttemptId: z.string(),
+    taskRunId: z.string()
+  }),
+  z.object({
+    type: z.literal("SCHEDULE_ATTEMPT"),
+    image: z.string(),
+    version: z.string(),
+    machine: Machine,
+    // identifiers
+    id: z.string(),
+    envId: z.string(),
+    envType: EnvironmentType,
+    orgId: z.string(),
+    projectId: z.string(),
+    runId: z.string()
   })
 ]);
 var serverWebsocketMessages = {
@@ -221,15 +299,26 @@ var BackgroundWorkerClientMessages = z.discriminatedUnion("type", [
   z.object({
     version: z.literal("v1").default("v1"),
     type: z.literal("TASK_RUN_COMPLETED"),
-    completion: TaskRunExecutionResult
+    completion: TaskRunExecutionResult,
+    execution: TaskRunExecution
+  }),
+  z.object({
+    version: z.literal("v1").default("v1"),
+    type: z.literal("TASK_HEARTBEAT"),
+    id: z.string()
   })
 ]);
+var BackgroundWorkerProperties = z.object({
+  id: z.string(),
+  version: z.string(),
+  contentHash: z.string()
+});
 var clientWebsocketMessages = {
   READY_FOR_TASKS: z.object({
     version: z.literal("v1").default("v1"),
     backgroundWorkerId: z.string()
   }),
-  WORKER_DEPRECATED: z.object({
+  BACKGROUND_WORKER_DEPRECATED: z.object({
     version: z.literal("v1").default("v1"),
     backgroundWorkerId: z.string()
   }),
@@ -244,40 +333,1112 @@ var workerToChildMessages = {
     version: z.literal("v1").default("v1"),
     execution: TaskRunExecution,
     traceContext: z.record(z.unknown()),
-    metadata: BackgroundWorkerRecord
+    metadata: BackgroundWorkerProperties
   }),
-  TASK_RUN_COMPLETED: z.object({
+  TASK_RUN_COMPLETED_NOTIFICATION: z.object({
     version: z.literal("v1").default("v1"),
     completion: TaskRunExecutionResult,
     execution: TaskRunExecution
   }),
   CLEANUP: z.object({
     version: z.literal("v1").default("v1"),
-    flush: z.boolean().default(false)
+    flush: z.boolean().default(false),
+    kill: z.boolean().default(true)
   })
 };
+var FixedWindowRateLimit = z.object({
+  type: z.literal("fixed-window"),
+  limit: z.number(),
+  window: z.union([
+    z.object({
+      seconds: z.number()
+    }),
+    z.object({
+      minutes: z.number()
+    }),
+    z.object({
+      hours: z.number()
+    })
+  ])
+});
+var SlidingWindowRateLimit = z.object({
+  type: z.literal("sliding-window"),
+  limit: z.number(),
+  window: z.union([
+    z.object({
+      seconds: z.number()
+    }),
+    z.object({
+      minutes: z.number()
+    }),
+    z.object({
+      hours: z.number()
+    })
+  ])
+});
+var RateLimitOptions = z.discriminatedUnion("type", [
+  FixedWindowRateLimit,
+  SlidingWindowRateLimit
+]);
+var RetryOptions = z.object({
+  /** The number of attempts before giving up */
+  maxAttempts: 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: z.number().optional(),
+  /** The minimum time to wait before retrying */
+  minTimeoutInMs: z.number().int().optional(),
+  /** The maximum time to wait before retrying */
+  maxTimeoutInMs: 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: z.boolean().optional()
+});
+var QueueOptions = 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: 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: z.number().int().min(0).max(1e3).optional(),
+  /** @deprecated This feature is coming soon */
+  rateLimit: RateLimitOptions.optional()
+});
 var TaskMetadata = z.object({
   id: z.string(),
   exportName: z.string(),
-  packageVersion: z.string()
+  packageVersion: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional()
 });
 var TaskMetadataWithFilePath = TaskMetadata.extend({
   filePath: z.string()
 });
+var UncaughtExceptionMessage = z.object({
+  version: z.literal("v1").default("v1"),
+  error: z.object({
+    name: z.string(),
+    message: z.string(),
+    stack: z.string().optional()
+  }),
+  origin: z.enum([
+    "uncaughtException",
+    "unhandledRejection"
+  ])
+});
+var TaskMetadataFailedToParseData = z.object({
+  version: z.literal("v1").default("v1"),
+  tasks: z.unknown(),
+  zodIssues: z.custom((v) => {
+    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
+  })
+});
 var childToWorkerMessages = {
   TASK_RUN_COMPLETED: z.object({
     version: z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
     result: TaskRunExecutionResult
   }),
   TASKS_READY: z.object({
     version: z.literal("v1").default("v1"),
     tasks: TaskMetadataWithFilePath.array()
   }),
-  READY_TO_DISPOSE: z.undefined()
+  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
+  TASK_HEARTBEAT: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string()
+  }),
+  READY_TO_DISPOSE: z.undefined(),
+  WAIT_FOR_DURATION: z.object({
+    version: z.literal("v1").default("v1"),
+    ms: z.number()
+  }),
+  WAIT_FOR_TASK: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string()
+  }),
+  WAIT_FOR_BATCH: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string(),
+    runs: z.string().array()
+  }),
+  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
+};
+var ProdChildToWorkerMessages = {
+  TASK_RUN_COMPLETED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      result: TaskRunExecutionResult
+    })
+  },
+  TASKS_READY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      tasks: TaskMetadataWithFilePath.array()
+    })
+  },
+  TASKS_FAILED_TO_PARSE: {
+    message: TaskMetadataFailedToParseData
+  },
+  TASK_HEARTBEAT: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      id: z.string()
+    })
+  },
+  READY_TO_DISPOSE: {
+    message: z.undefined()
+  },
+  READY_FOR_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  WAIT_FOR_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      ms: z.number(),
+      now: z.number()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      friendlyId: z.string()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      batchFriendlyId: z.string(),
+      runFriendlyIds: z.string().array()
+    })
+  },
+  UNCAUGHT_EXCEPTION: {
+    message: UncaughtExceptionMessage
+  }
+};
+var ProdWorkerToChildMessages = {
+  EXECUTE_TASK_RUN: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      traceContext: z.record(z.unknown()),
+      metadata: BackgroundWorkerProperties
+    })
+  },
+  TASK_RUN_COMPLETED_NOTIFICATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      completion: TaskRunExecutionResult,
+      execution: TaskRunExecution
+    })
+  },
+  CLEANUP: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      flush: z.boolean().default(false),
+      kill: z.boolean().default(true)
+    }),
+    callback: z.void()
+  },
+  WAIT_COMPLETED_NOTIFICATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  }
+};
+
+// src/v3/schemas/resources.ts
+var TaskResource = z.object({
+  id: z.string(),
+  filePath: z.string(),
+  exportName: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional()
+});
+var BackgroundWorkerMetadata = z.object({
+  packageVersion: z.string(),
+  contentHash: z.string(),
+  cliPackageVersion: z.string().optional(),
+  tasks: z.array(TaskResource)
+});
+var ImageDetailsMetadata = z.object({
+  contentHash: z.string(),
+  imageTag: z.string()
+});
+
+// src/v3/schemas/api.ts
+var WhoAmIResponseSchema = z.object({
+  userId: z.string(),
+  email: z.string().email(),
+  dashboardUrl: z.string()
+});
+var GetProjectResponseBody = z.object({
+  id: z.string(),
+  externalRef: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  createdAt: z.coerce.date(),
+  organization: z.object({
+    id: z.string(),
+    title: z.string(),
+    slug: z.string(),
+    createdAt: z.coerce.date()
+  })
+});
+var GetProjectsResponseBody = z.array(GetProjectResponseBody);
+var GetProjectEnvResponse = z.object({
+  apiKey: z.string(),
+  name: z.string(),
+  apiUrl: z.string()
+});
+var CreateBackgroundWorkerRequestBody = z.object({
+  localOnly: z.boolean(),
+  metadata: BackgroundWorkerMetadata
+});
+var CreateBackgroundWorkerResponse = z.object({
+  id: z.string(),
+  version: z.string(),
+  contentHash: z.string()
+});
+var TriggerTaskRequestBody = z.object({
+  payload: z.any(),
+  context: z.any(),
+  options: z.object({
+    dependentAttempt: z.string().optional(),
+    dependentBatch: z.string().optional(),
+    lockToVersion: z.string().optional(),
+    queue: QueueOptions.optional(),
+    concurrencyKey: z.string().optional(),
+    test: z.boolean().optional()
+  }).optional()
+});
+var TriggerTaskResponse = z.object({
+  id: z.string()
+});
+var BatchTriggerTaskRequestBody = z.object({
+  items: TriggerTaskRequestBody.array(),
+  dependentAttempt: z.string().optional()
+});
+var BatchTriggerTaskResponse = z.object({
+  batchId: z.string(),
+  runs: z.string().array()
+});
+var GetBatchResponseBody = z.object({
+  id: z.string(),
+  items: z.array(z.object({
+    id: z.string(),
+    taskRunId: z.string(),
+    status: z.enum([
+      "PENDING",
+      "CANCELED",
+      "COMPLETED",
+      "FAILED"
+    ])
+  }))
+});
+var GetEnvironmentVariablesResponseBody = z.object({
+  variables: z.record(z.string())
+});
+var StartDeploymentIndexingRequestBody = z.object({
+  imageReference: z.string()
+});
+var StartDeploymentIndexingResponseBody = z.object({
+  id: z.string(),
+  contentHash: z.string()
+});
+var ExternalBuildData = z.object({
+  buildId: z.string(),
+  buildToken: z.string(),
+  projectId: z.string()
+});
+var InitializeDeploymentResponseBody = z.object({
+  id: z.string(),
+  contentHash: z.string(),
+  shortCode: z.string(),
+  version: z.string(),
+  imageTag: z.string(),
+  externalBuildData: ExternalBuildData.optional().nullable(),
+  registryHost: z.string().optional()
+});
+var InitializeDeploymentRequestBody = z.object({
+  contentHash: z.string(),
+  userId: z.string().optional()
+});
+var DeploymentErrorData = z.object({
+  name: z.string(),
+  message: z.string(),
+  stack: z.string().optional()
+});
+var GetDeploymentResponseBody = z.object({
+  id: z.string(),
+  status: z.enum([
+    "PENDING",
+    "BUILDING",
+    "DEPLOYING",
+    "DEPLOYED",
+    "FAILED",
+    "CANCELED",
+    "TIMED_OUT"
+  ]),
+  contentHash: z.string(),
+  shortCode: z.string(),
+  version: z.string(),
+  imageReference: z.string().optional(),
+  errorData: DeploymentErrorData.optional().nullable(),
+  worker: z.object({
+    id: z.string(),
+    version: z.string(),
+    tasks: z.array(z.object({
+      id: z.string(),
+      slug: z.string(),
+      filePath: z.string(),
+      exportName: z.string()
+    }))
+  }).optional()
+});
+var CreateUploadPayloadUrlResponseBody = z.object({
+  presignedUrl: z.string()
+});
+var PostStartCauses = z.enum([
+  "index",
+  "create",
+  "restore"
+]);
+var PreStopCauses = z.enum([
+  "terminate"
+]);
+var RegexSchema = z.custom((val) => {
+  try {
+    return typeof val.test === "function";
+  } catch {
+    return false;
+  }
+});
+var Config = z.object({
+  project: z.string(),
+  triggerDirectories: z.string().array().optional(),
+  triggerUrl: z.string().optional(),
+  projectDir: z.string().optional(),
+  tsconfigPath: z.string().optional(),
+  retries: z.object({
+    enabledInDev: z.boolean().default(true),
+    default: RetryOptions.optional()
+  }).optional(),
+  additionalPackages: z.string().array().optional(),
+  additionalFiles: z.string().array().optional(),
+  dependenciesToBundle: z.array(z.union([
+    z.string(),
+    RegexSchema
+  ])).optional(),
+  logLevel: z.string().optional()
+});
+var WaitReason = z.enum([
+  "WAIT_FOR_DURATION",
+  "WAIT_FOR_TASK",
+  "WAIT_FOR_BATCH"
+]);
+var ProviderToPlatformMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      data: z.string()
+    })
+  },
+  LOG_WITH_ACK: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      data: z.string()
+    }),
+    callback: z.object({
+      status: z.literal("ok")
+    })
+  },
+  WORKER_CRASHED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      reason: z.string().optional(),
+      exitCode: z.number().optional(),
+      message: z.string().optional(),
+      logs: z.string().optional()
+    })
+  },
+  INDEXING_FAILED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      error: z.object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().optional()
+      })
+    })
+  }
+};
+var PlatformToProviderMessages = {
+  HEALTH: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    }),
+    callback: z.object({
+      status: z.literal("ok")
+    })
+  },
+  INDEX: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      imageTag: z.string(),
+      shortCode: z.string(),
+      apiKey: z.string(),
+      apiUrl: z.string(),
+      // identifiers
+      envId: z.string(),
+      envType: EnvironmentType,
+      orgId: z.string(),
+      projectId: z.string(),
+      deploymentId: z.string()
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false),
+        error: z.object({
+          name: z.string(),
+          message: z.string(),
+          stack: z.string().optional()
+        })
+      }),
+      z.object({
+        success: z.literal(true)
+      })
+    ])
+  },
+  // TODO: this should be a shared queue message instead
+  RESTORE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      type: z.enum([
+        "DOCKER",
+        "KUBERNETES"
+      ]),
+      location: z.string(),
+      reason: z.string().optional(),
+      imageRef: z.string(),
+      machine: Machine,
+      // identifiers
+      checkpointId: z.string(),
+      envId: z.string(),
+      envType: EnvironmentType,
+      orgId: z.string(),
+      projectId: z.string(),
+      runId: z.string()
+    })
+  },
+  DELETE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      name: z.string()
+    }),
+    callback: z.object({
+      message: z.string()
+    })
+  },
+  GET: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      name: z.string()
+    })
+  }
+};
+var CoordinatorToPlatformMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      metadata: z.any(),
+      text: z.string()
+    })
+  },
+  CREATE_WORKER: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      projectRef: z.string(),
+      envId: z.string(),
+      deploymentId: z.string(),
+      metadata: z.object({
+        cliPackageVersion: z.string().optional(),
+        contentHash: z.string(),
+        packageVersion: z.string(),
+        tasks: TaskResource.array()
+      })
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false)
+      }),
+      z.object({
+        success: z.literal(true)
+      })
+    ])
+  },
+  READY_FOR_EXECUTION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      totalCompletions: z.number()
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false)
+      }),
+      z.object({
+        success: z.literal(true),
+        payload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  READY_FOR_RESUME: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string(),
+      type: WaitReason
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult,
+      checkpoint: z.object({
+        docker: z.boolean(),
+        location: z.string()
+      }).optional()
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string()
+    })
+  },
+  CHECKPOINT_CREATED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string(),
+      docker: z.boolean(),
+      location: z.string(),
+      reason: z.discriminatedUnion("type", [
+        z.object({
+          type: z.literal("WAIT_FOR_DURATION"),
+          ms: z.number(),
+          now: z.number()
+        }),
+        z.object({
+          type: z.literal("WAIT_FOR_BATCH"),
+          batchFriendlyId: z.string(),
+          runFriendlyIds: z.string().array()
+        }),
+        z.object({
+          type: z.literal("WAIT_FOR_TASK"),
+          friendlyId: z.string()
+        }),
+        z.object({
+          type: z.literal("RETRYING_AFTER_FAILURE"),
+          attemptNumber: z.number()
+        })
+      ])
+    })
+  },
+  INDEXING_FAILED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      error: z.object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().optional()
+      })
+    })
+  }
+};
+var PlatformToCoordinatorMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      attemptId: z.string(),
+      attemptFriendlyId: z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string(),
+      attemptFriendlyId: z.string()
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string(),
+      attemptFriendlyId: z.string()
+    })
+  },
+  READY_FOR_RETRY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string()
+    })
+  }
+};
+var ClientToSharedQueueMessages = {
+  READY_FOR_TASKS: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      backgroundWorkerId: z.string()
+    })
+  },
+  BACKGROUND_WORKER_DEPRECATED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      backgroundWorkerId: z.string()
+    })
+  },
+  BACKGROUND_WORKER_MESSAGE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      backgroundWorkerId: z.string(),
+      data: BackgroundWorkerClientMessages
+    })
+  }
+};
+var SharedQueueToClientMessages = {
+  SERVER_READY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      id: z.string()
+    })
+  },
+  BACKGROUND_WORKER_MESSAGE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      backgroundWorkerId: z.string(),
+      data: BackgroundWorkerServerMessages
+    })
+  }
+};
+var ProdWorkerToCoordinatorMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      text: z.string()
+    }),
+    callback: z.void()
+  },
+  INDEX_TASKS: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      tasks: TaskResource.array(),
+      packageVersion: z.string()
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false)
+      }),
+      z.object({
+        success: z.literal(true)
+      })
+    ])
+  },
+  READY_FOR_EXECUTION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      totalCompletions: z.number()
+    })
+  },
+  READY_FOR_RESUME: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string(),
+      type: WaitReason
+    })
+  },
+  READY_FOR_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string()
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean(),
+      shouldExit: z.boolean()
+    })
+  },
+  WAIT_FOR_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      ms: z.number(),
+      now: z.number(),
+      attemptFriendlyId: z.string()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      friendlyId: z.string(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: z.string()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      batchFriendlyId: z.string(),
+      runFriendlyIds: z.string().array(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: z.string()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  INDEXING_FAILED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      error: z.object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().optional()
+      })
+    })
+  }
+};
+var CoordinatorToProdWorkerMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string()
+    })
+  },
+  EXECUTE_TASK_RUN: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      executionPayload: ProdTaskRunExecutionPayload
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string()
+    })
+  },
+  REQUEST_EXIT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  READY_FOR_RETRY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string()
+    })
+  }
 };
+var ProdWorkerSocketData = z.object({
+  contentHash: z.string(),
+  projectRef: z.string(),
+  envId: z.string(),
+  runId: z.string(),
+  attemptFriendlyId: z.string().optional(),
+  podName: z.string(),
+  deploymentId: z.string(),
+  deploymentVersion: z.string()
+});
+var PRIMARY_VARIANT = "primary";
+var Variant = z.enum([
+  PRIMARY_VARIANT
+]);
+var AccessoryItem = z.object({
+  text: z.string(),
+  variant: z.string().optional(),
+  url: z.string().optional()
+});
+var Accessory = z.object({
+  items: z.array(AccessoryItem),
+  style: z.enum([
+    "codepath"
+  ]).optional()
+});
+var TaskEventStyle = z.object({
+  icon: z.string().optional(),
+  variant: Variant.optional(),
+  accessory: Accessory.optional()
+}).default({
+  icon: void 0,
+  variant: void 0
+});
+var stringPatternMatchers = [
+  z.object({
+    $endsWith: z.string()
+  }),
+  z.object({
+    $startsWith: z.string()
+  }),
+  z.object({
+    $ignoreCaseEquals: z.string()
+  })
+];
+var EventMatcher = z.union([
+  /** Match against a string */
+  z.array(z.string()),
+  /** Match against a number */
+  z.array(z.number()),
+  /** Match against a boolean */
+  z.array(z.boolean()),
+  z.array(z.union([
+    ...stringPatternMatchers,
+    z.object({
+      $exists: z.boolean()
+    }),
+    z.object({
+      $isNull: z.boolean()
+    }),
+    z.object({
+      $anythingBut: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+      ])
+    }),
+    z.object({
+      $anythingBut: z.union([
+        z.array(z.string()),
+        z.array(z.number()),
+        z.array(z.boolean())
+      ])
+    }),
+    z.object({
+      $gt: z.number()
+    }),
+    z.object({
+      $lt: z.number()
+    }),
+    z.object({
+      $gte: z.number()
+    }),
+    z.object({
+      $lte: z.number()
+    }),
+    z.object({
+      $between: z.tuple([
+        z.number(),
+        z.number()
+      ])
+    }),
+    z.object({
+      $includes: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+      ])
+    }),
+    z.object({
+      $not: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+      ])
+    })
+  ]))
+]);
+var EventFilter = z.lazy(() => z.record(z.union([
+  EventMatcher,
+  EventFilter
+])));
+
+// src/v3/schemas/fetch.ts
+var FetchRetryHeadersStrategy = z.object({
+  /** The `headers` strategy retries the request using info from the response headers. */
+  strategy: z.literal("headers"),
+  /** The header to use to determine the maximum number of times to retry the request. */
+  limitHeader: z.string(),
+  /** The header to use to determine the number of remaining retries. */
+  remainingHeader: z.string(),
+  /** The header to use to determine the time when the number of remaining retries will be reset. */
+  resetHeader: 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: 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: z.literal("backoff"),
+  /** The event filter to use to determine if the request should be retried. */
+  bodyFilter: EventFilter.optional()
+});
+var FetchRetryStrategy = z.discriminatedUnion("strategy", [
+  FetchRetryHeadersStrategy,
+  FetchRetryBackoffStrategy
+]);
+var FetchRetryByStatusOptions = z.record(z.string(), FetchRetryStrategy);
+var FetchTimeoutOptions = z.object({
+  /** The maximum time to wait for the request to complete. */
+  durationInMs: z.number().optional(),
+  retry: RetryOptions.optional()
+});
+var FetchRetryOptions = 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 = z.object({
+  type: z.string().optional(),
+  message: z.string().optional(),
+  stacktrace: z.string().optional()
+});
+var ExceptionSpanEvent = z.object({
+  name: z.literal("exception"),
+  time: z.coerce.date(),
+  properties: z.object({
+    exception: ExceptionEventProperties
+  })
+});
+var CancellationSpanEvent = z.object({
+  name: z.literal("cancellation"),
+  time: z.coerce.date(),
+  properties: z.object({
+    reason: z.string()
+  })
+});
+var OtherSpanEvent = z.object({
+  name: z.string(),
+  time: z.coerce.date(),
+  properties: z.record(z.unknown())
+});
+var SpanEvent = z.union([
+  ExceptionSpanEvent,
+  CancellationSpanEvent,
+  OtherSpanEvent
+]);
+var SpanEvents = 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 = z.object({
+  system: z.string().optional(),
+  client_id: z.string().optional(),
+  operation: z.enum([
+    "publish",
+    "create",
+    "receive",
+    "deliver"
+  ]),
+  message: z.any(),
+  destination: 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) {
@@ -286,7 +1447,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 {
@@ -299,6 +1460,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,
@@ -324,31 +1506,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 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)) {
@@ -356,9 +1552,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)) {
@@ -376,6 +1572,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 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;
@@ -391,10 +1696,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;
@@ -402,10 +1703,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 {};
@@ -421,37 +1754,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) {
     propagation.inject(context.active(), headers);
+    if (spanParentAsLink) {
+      headers["x-trigger-span-parent-as-link"] = "1";
+    }
   }
   return headers;
 }, "#getHeaders");
 __name(_ApiClient, "ApiClient");
 var ApiClient = _ApiClient;
-var messageSchema = 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 = z.object({
   version: z.literal("v1").default("v1"),
   type: z.string(),
   payload: z.unknown()
@@ -471,12 +1932,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)}`);
     }
@@ -493,6 +1956,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();
@@ -513,7 +2008,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,
@@ -521,80 +2016,745 @@ 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 = z.object({
+  version: z.literal("v1").default("v1"),
+  type: z.string(),
+  payload: 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];
-}
+};
+_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, LogLevel.info);
+    logger2.log("new zod socket", {
+      uri
+    });
+    this.socket = 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
+var LogLevel;
+(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";
+})(LogLevel || (LogLevel = {}));
+var _structuredLog, structuredLog_fn;
+var _SimpleStructuredLogger = class _SimpleStructuredLogger {
+  constructor(name, level = [
+    "1",
+    "true"
+  ].includes(process.env.DEBUG ?? "") ? LogLevel.debug : 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 < LogLevel.log)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
+  }
+  error(message, ...args) {
+    if (this.level < LogLevel.error)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
+  }
+  warn(message, ...args) {
+    if (this.level < LogLevel.warn)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
+  }
+  info(message, ...args) {
+    if (this.level < LogLevel.info)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
+  }
+  debug(message, ...args) {
+    if (this.level < 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 = z.object({
+  version: z.literal("v1").default("v1"),
+  type: z.string(),
+  payload: 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 = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("CONNECT"),
+    sessionId: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("ACK"),
+    message: z.any(),
+    id: z.number()
+  }),
+  z.object({
+    type: z.literal("EVENT"),
+    message: z.any(),
+    id: 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 = 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.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];
@@ -608,6 +2768,11 @@ __name(unregisterGlobal, "unregisterGlobal");
 var _NoopRuntimeManager = class _NoopRuntimeManager {
   disable() {
   }
+  registerTasks() {
+  }
+  getTaskMetadata(id) {
+    return void 0;
+  }
   waitForDuration(ms) {
     return Promise.resolve();
   }
@@ -615,7 +2780,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");
@@ -644,6 +2822,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);
   }
@@ -651,6 +2832,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() {
@@ -661,58 +2848,159 @@ var RuntimeAPI = _RuntimeAPI;
 
 // src/v3/runtime-api.ts
 var runtime = RuntimeAPI.getInstance();
+function iconStringForSeverity(severityNumber) {
+  switch (severityNumber) {
+    case SeverityNumber.UNSPECIFIED:
+      return void 0;
+    case SeverityNumber.TRACE:
+    case SeverityNumber.TRACE2:
+    case SeverityNumber.TRACE3:
+    case SeverityNumber.TRACE4:
+      return "trace";
+    case SeverityNumber.DEBUG:
+    case SeverityNumber.DEBUG2:
+    case SeverityNumber.DEBUG3:
+    case SeverityNumber.DEBUG4:
+      return "debug";
+    case SeverityNumber.INFO:
+    case SeverityNumber.INFO2:
+    case SeverityNumber.INFO3:
+    case SeverityNumber.INFO4:
+      return "info";
+    case SeverityNumber.WARN:
+    case SeverityNumber.WARN2:
+    case SeverityNumber.WARN3:
+    case SeverityNumber.WARN4:
+      return "warn";
+    case SeverityNumber.ERROR:
+    case SeverityNumber.ERROR2:
+    case SeverityNumber.ERROR3:
+    case SeverityNumber.ERROR4:
+      return "error";
+    case SeverityNumber.FATAL:
+    case SeverityNumber.FATAL2:
+    case SeverityNumber.FATAL3:
+    case SeverityNumber.FATAL4:
+      return "fatal";
+  }
+}
+__name(iconStringForSeverity, "iconStringForSeverity");
+var _SimpleClock = class _SimpleClock {
+  preciseNow() {
+    const now = new 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", SeverityNumber.DEBUG, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "debug", SeverityNumber.DEBUG, properties);
   }
   log(message, properties) {
-    if (this._level < 2)
+    if (this._level < 3)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "log", SeverityNumber.INFO, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "log", SeverityNumber.INFO, properties);
   }
   info(message, properties) {
-    if (this._level < 3)
+    if (this._level < 4)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "info", SeverityNumber.INFO, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "info", SeverityNumber.INFO, properties);
   }
   warn(message, properties) {
-    if (this._level < 1)
+    if (this._level < 2)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "warn", SeverityNumber.WARN, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "warn", SeverityNumber.WARN, properties);
   }
   error(message, properties) {
-    if (this._level < 0)
+    if (this._level < 1)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "error", SeverityNumber.ERROR, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "error", 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 {
@@ -726,12 +3014,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 {
@@ -745,10 +3036,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);
@@ -765,10 +3056,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;
@@ -776,47 +3070,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(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(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) {
@@ -825,27 +3217,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 = setTimeout$1(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()
+    };
+  }
+  preciseNow() {
+    const elapsedHrTime = process.hrtime(__privateGet(this, _originClockTime, originClockTime_get));
+    const elapsedNanoseconds = BigInt(elapsedHrTime[0]) * BigInt(1e9) + BigInt(elapsedHrTime[1]);
+    const preciseDate = new PreciseDate(__privateGet(this, _originPreciseDate, originPreciseDate_get).getFullTime() + elapsedNanoseconds);
+    const dateStruct = preciseDate.toStruct();
+    return [
+      dateStruct.seconds,
+      dateStruct.nanos
+    ];
+  }
+  reset() {
+    this._origin = {
+      clockTime: process.hrtime(),
+      preciseDate: new 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;
@@ -874,7 +3454,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,
@@ -895,57 +3476,72 @@ var _TriggerTracer = class _TriggerTracer {
         });
         throw e;
       } finally {
-        span.end();
+        span.end(clock.preciseNow());
+      }
+    });
+  }
+  startSpan(name, options, ctx) {
+    const parentContext = ctx ?? 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, SeverityNumber.INFO, "Log", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Log", ...args);
   }
   info(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.INFO, "Info", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Info", ...args);
   }
   warn(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.WARN, "Warn", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.WARN, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Warn", ...args);
   }
   error(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.ERROR, "Error", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, 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.format(...args);
   const parsed = tryParseJSON(body);
   if (parsed.ok) {
@@ -954,9 +3550,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;
   }
@@ -964,14 +3561,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;
@@ -1013,12 +3618,988 @@ 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 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 = detectResourcesSync({
+      detectors: [
+        this.asyncResourceDetector,
+        processDetectorSync
+      ]
+    }).merge(new Resource({
+      [SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev",
+      [SemanticInternalAttributes.TRIGGER]: true
+    })).merge(config.resource ?? new Resource({})).merge(new Resource(envResourceAttributes));
+    const traceProvider = new 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 OTLPTraceExporter({
+      url: `${config.url}/v1/traces`,
+      timeoutMillis: config.forceFlushTimeoutMillis ?? 1e3
+    });
+    traceProvider.addSpanProcessor(new TaskContextSpanProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new 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 SimpleSpanProcessor(spanExporter)));
+    traceProvider.register();
+    registerInstrumentations({
+      instrumentations: config.instrumentations ?? [],
+      tracerProvider: traceProvider
+    });
+    const logExporter = new OTLPLogExporter({
+      url: `${config.url}/v1/logs`
+    });
+    const loggerProvider = new 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 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 SimpleLogRecordProcessor(logExporter)));
+    this._logProvider = loggerProvider;
+    this._spanExporter = spanExporter;
+    this._traceProvider = traceProvider;
+    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 = DiagLogLevel.NONE;
+      break;
+    case "error":
+      diagLogLevel = DiagLogLevel.ERROR;
+      break;
+    case "warn":
+      diagLogLevel = DiagLogLevel.WARN;
+      break;
+    case "info":
+      diagLogLevel = DiagLogLevel.INFO;
+      break;
+    case "debug":
+      diagLogLevel = DiagLogLevel.DEBUG;
+      break;
+    case "verbose":
+      diagLogLevel = DiagLogLevel.VERBOSE;
+      break;
+    case "all":
+      diagLogLevel = DiagLogLevel.ALL;
+      break;
+    default:
+      diagLogLevel = DiagLogLevel.NONE;
+  }
+  diag.setLogger(new 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: 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: 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");
 
-export { ApiClient, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerRecord, BackgroundWorkerServerMessages, ConsoleInterceptor, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, DevRuntimeManager, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectDevResponse, OtelTaskLogger, SemanticInternalAttributes, TaskMetadata, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionEnvironment, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionResult, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, WhoAmIResponseSchema, ZodMessageHandler, ZodMessageSender, childToWorkerMessages, clientWebsocketMessages, createErrorTaskError, flattenAttributes, logger, parseError, parseTriggerTaskRequestBody, runtime, serverWebsocketMessages, taskContextManager, workerToChildMessages };
+export { ApiClient, ApiClientManager, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConsoleInterceptor, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateUploadPayloadUrlResponseBody, DeploymentErrorData, DevRuntimeManager, PreciseWallClock as DurableClock, EnvironmentType, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, LogLevel, Machine, MachineCpu, MachineMemory, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OtelTaskLogger, OtherSpanEvent, PRIMARY_VARIANT, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdRuntimeManager, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitOptions, RetryOptions, SemanticInternalAttributes, SharedQueueToClientMessages, SimpleStructuredLogger, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskContextSpanProcessor, TaskEventStyle, TaskExecutor, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TracingSDK, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, WaitReason, WhoAmIResponseSchema, ZodIpcConnection, ZodMessageHandler, ZodMessageSchema, ZodMessageSender, ZodNamespace, ZodSchemaParsedError, ZodSocketConnection, ZodSocketMessageHandler, ZodSocketMessageSender, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, getEnvVar, groupTaskMetadataIssuesByTask, iconStringForSeverity, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logLevels, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseBatchTriggerTaskRequestBody, parseError, parsePacket, parseTriggerTaskRequestBody, prettyPrintPacket, primitiveValueOrflattenedAttributes, recordSpanException, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskContextManager, unflattenAttributes, workerToChildMessages };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map