@trigger.dev/core 0.0.0-prerelease-20240418145424 → 0.0.0-prerelease-20240528152213

package/dist/v3/index.js

@@ -1,30 +1,17 @@
 'use strict';
 
-var zod = require('zod');
 var api = require('@opentelemetry/api');
+var zod = require('zod');
 var zodValidationError = require('zod-validation-error');
-var async_hooks = require('async_hooks');
-var socket_ioClient = require('socket.io-client');
-var crypto = require('crypto');
-var nodePath = require('path');
-var apiLogs = require('@opentelemetry/api-logs');
+var formDataEncoder = require('form-data-encoder');
+var stream = require('stream');
 var preciseDate = require('@google-cloud/precise-date');
+var apiLogs = require('@opentelemetry/api-logs');
 var humanizeDuration = require('humanize-duration');
-var promises = require('timers/promises');
-var util = require('util');
-var exporterLogsOtlpHttp = require('@opentelemetry/exporter-logs-otlp-http');
-var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
-var instrumentation = require('@opentelemetry/instrumentation');
-var resources = require('@opentelemetry/resources');
-var sdkLogs = require('@opentelemetry/sdk-logs');
-var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
-var semanticConventions = require('@opentelemetry/semantic-conventions');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var nodePath__default = /*#__PURE__*/_interopDefault(nodePath);
 var humanizeDuration__default = /*#__PURE__*/_interopDefault(humanizeDuration);
-var util__default = /*#__PURE__*/_interopDefault(util);
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -37,32 +24,178 @@ var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
 var __privateAdd = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  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;
 };
+
+// package.json
+var version = "0.0.0-prerelease-20240528152213";
+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",
+  "form-data-encoder": "^4.0.2",
+  "humanize-duration": "^3.27.3",
+  "socket.io-client": "4.7.4",
+  superjson: "^2.2.1",
+  ulidx: "^2.2.1",
+  zod: "3.22.3",
+  "zod-error": "1.5.0",
+  "zod-validation-error": "^1.5.0"
+};
+
+// src/v3/apiErrors.ts
+var _APIError = class _APIError extends Error {
+  constructor(status, error, message, headers) {
+    super(`${_APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    const data = error;
+    this.error = data;
+    this.code = data?.["code"];
+    this.param = data?.["param"];
+    this.type = data?.["type"];
+  }
+  static makeMessage(status, error, message) {
+    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return "(no status code or body)";
+  }
+  static generate(status, errorResponse, message, headers) {
+    if (!status) {
+      return new APIConnectionError({
+        cause: castToError(errorResponse)
+      });
+    }
+    const error = errorResponse?.["error"];
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+    return new _APIError(status, error, message, headers);
+  }
+};
+__name(_APIError, "APIError");
+var APIError = _APIError;
+var _APIConnectionError = class _APIConnectionError extends APIError {
+  constructor({ message, cause }) {
+    super(void 0, void 0, message || "Connection error.", void 0);
+    __publicField(this, "status");
+    if (cause)
+      this.cause = cause;
+  }
+};
+__name(_APIConnectionError, "APIConnectionError");
+var APIConnectionError = _APIConnectionError;
+var _BadRequestError = class _BadRequestError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 400);
+  }
+};
+__name(_BadRequestError, "BadRequestError");
+var BadRequestError = _BadRequestError;
+var _AuthenticationError = class _AuthenticationError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 401);
+  }
+};
+__name(_AuthenticationError, "AuthenticationError");
+var AuthenticationError = _AuthenticationError;
+var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 403);
+  }
+};
+__name(_PermissionDeniedError, "PermissionDeniedError");
+var PermissionDeniedError = _PermissionDeniedError;
+var _NotFoundError = class _NotFoundError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 404);
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+var NotFoundError = _NotFoundError;
+var _ConflictError = class _ConflictError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 409);
+  }
+};
+__name(_ConflictError, "ConflictError");
+var ConflictError = _ConflictError;
+var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 422);
+  }
+};
+__name(_UnprocessableEntityError, "UnprocessableEntityError");
+var UnprocessableEntityError = _UnprocessableEntityError;
+var _RateLimitError = class _RateLimitError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 429);
+  }
+};
+__name(_RateLimitError, "RateLimitError");
+var RateLimitError = _RateLimitError;
+var _InternalServerError = class _InternalServerError extends APIError {
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+function castToError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError, "castToError");
 var CreateAuthorizationCodeResponseSchema = zod.z.object({
   url: zod.z.string().url(),
   authorizationCode: zod.z.string()
@@ -98,6 +231,7 @@ var TaskRunErrorCodes = {
   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_PROCESS_SIGKILL_TIMEOUT: "TASK_PROCESS_SIGKILL_TIMEOUT",
   TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
   TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
   HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
@@ -113,10 +247,12 @@ var TaskRunInternalError = zod.z.object({
     "TASK_EXECUTION_FAILED",
     "TASK_EXECUTION_ABORTED",
     "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+    "TASK_PROCESS_SIGKILL_TIMEOUT",
     "TASK_RUN_CANCELLED",
     "TASK_OUTPUT_ERROR",
     "HANDLE_ERROR_ERROR",
-    "GRACEFUL_EXIT_TIMEOUT"
+    "GRACEFUL_EXIT_TIMEOUT",
+    "TASK_RUN_HEARTBEAT_TIMEOUT"
   ]),
   message: zod.z.string().optional()
 });
@@ -133,7 +269,8 @@ var TaskRun = zod.z.object({
   context: zod.z.any(),
   tags: zod.z.array(zod.z.string()),
   isTest: zod.z.boolean().default(false),
-  createdAt: zod.z.coerce.date()
+  createdAt: zod.z.coerce.date(),
+  idempotencyKey: zod.z.string().optional()
 });
 var TaskRunExecutionTask = zod.z.object({
   id: zod.z.string(),
@@ -229,7 +366,7 @@ var BatchTaskRunExecutionResult = zod.z.object({
   items: TaskRunExecutionResult.array()
 });
 
-// src/v3/schemas/messages.ts
+// src/v3/schemas/schemas.ts
 var EnvironmentType = zod.z.enum([
   "PRODUCTION",
   "STAGING",
@@ -273,92 +410,6 @@ var ProdTaskRunExecutionPayload = zod.z.object({
   traceContext: zod.z.record(zod.z.unknown()),
   environment: zod.z.record(zod.z.string()).optional()
 });
-var BackgroundWorkerServerMessages = zod.z.discriminatedUnion("type", [
-  zod.z.object({
-    type: zod.z.literal("EXECUTE_RUNS"),
-    payloads: zod.z.array(TaskRunExecutionPayload)
-  }),
-  zod.z.object({
-    type: zod.z.literal("CANCEL_ATTEMPT"),
-    taskAttemptId: zod.z.string(),
-    taskRunId: zod.z.string()
-  }),
-  zod.z.object({
-    type: zod.z.literal("SCHEDULE_ATTEMPT"),
-    image: zod.z.string(),
-    version: zod.z.string(),
-    machine: Machine,
-    // identifiers
-    id: zod.z.string(),
-    envId: zod.z.string(),
-    envType: EnvironmentType,
-    orgId: zod.z.string(),
-    projectId: zod.z.string(),
-    runId: zod.z.string()
-  })
-]);
-var serverWebsocketMessages = {
-  SERVER_READY: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    id: zod.z.string()
-  }),
-  BACKGROUND_WORKER_MESSAGE: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    backgroundWorkerId: zod.z.string(),
-    data: BackgroundWorkerServerMessages
-  })
-};
-var BackgroundWorkerClientMessages = zod.z.discriminatedUnion("type", [
-  zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    type: zod.z.literal("TASK_RUN_COMPLETED"),
-    completion: TaskRunExecutionResult,
-    execution: TaskRunExecution
-  }),
-  zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    type: zod.z.literal("TASK_HEARTBEAT"),
-    id: zod.z.string()
-  })
-]);
-var BackgroundWorkerProperties = zod.z.object({
-  id: zod.z.string(),
-  version: zod.z.string(),
-  contentHash: zod.z.string()
-});
-var clientWebsocketMessages = {
-  READY_FOR_TASKS: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    backgroundWorkerId: zod.z.string()
-  }),
-  BACKGROUND_WORKER_DEPRECATED: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    backgroundWorkerId: zod.z.string()
-  }),
-  BACKGROUND_WORKER_MESSAGE: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    backgroundWorkerId: zod.z.string(),
-    data: BackgroundWorkerClientMessages
-  })
-};
-var workerToChildMessages = {
-  EXECUTE_TASK_RUN: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    execution: TaskRunExecution,
-    traceContext: zod.z.record(zod.z.unknown()),
-    metadata: BackgroundWorkerProperties
-  }),
-  TASK_RUN_COMPLETED_NOTIFICATION: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    completion: TaskRunExecutionResult,
-    execution: TaskRunExecution
-  }),
-  CLEANUP: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    flush: zod.z.boolean().default(false),
-    kill: zod.z.boolean().default(true)
-  })
-};
 var FixedWindowRateLimit = zod.z.object({
   type: zod.z.literal("fixed-window"),
   limit: zod.z.number(),
@@ -464,149 +515,53 @@ var TaskFileMetadata = zod.z.object({
   exportName: zod.z.string()
 });
 var TaskMetadataWithFilePath = TaskMetadata.merge(TaskFileMetadata);
-var UncaughtExceptionMessage = zod.z.object({
-  version: zod.z.literal("v1").default("v1"),
-  error: zod.z.object({
-    name: zod.z.string(),
-    message: zod.z.string(),
-    stack: zod.z.string().optional()
-  }),
-  origin: zod.z.enum([
-    "uncaughtException",
-    "unhandledRejection"
-  ])
+var PostStartCauses = zod.z.enum([
+  "index",
+  "create",
+  "restore"
+]);
+var PreStopCauses = zod.z.enum([
+  "terminate"
+]);
+var RegexSchema = zod.z.custom((val) => {
+  try {
+    return typeof val.test === "function";
+  } catch {
+    return false;
+  }
 });
-var TaskMetadataFailedToParseData = zod.z.object({
-  version: zod.z.literal("v1").default("v1"),
-  tasks: zod.z.unknown(),
-  zodIssues: zod.z.custom((v) => {
-    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
-  })
+var Config = zod.z.object({
+  project: zod.z.string(),
+  triggerDirectories: zod.z.string().array().optional(),
+  triggerUrl: zod.z.string().optional(),
+  projectDir: zod.z.string().optional(),
+  tsconfigPath: zod.z.string().optional(),
+  retries: zod.z.object({
+    enabledInDev: zod.z.boolean().default(true),
+    default: RetryOptions.optional()
+  }).optional(),
+  additionalPackages: zod.z.string().array().optional(),
+  additionalFiles: zod.z.string().array().optional(),
+  dependenciesToBundle: zod.z.array(zod.z.union([
+    zod.z.string(),
+    RegexSchema
+  ])).optional(),
+  logLevel: zod.z.string().optional(),
+  enableConsoleLogging: zod.z.boolean().optional(),
+  postInstall: zod.z.string().optional()
+});
+var WaitReason = zod.z.enum([
+  "WAIT_FOR_DURATION",
+  "WAIT_FOR_TASK",
+  "WAIT_FOR_BATCH"
+]);
+var TaskRunExecutionLazyAttemptPayload = zod.z.object({
+  runId: zod.z.string(),
+  messageId: zod.z.string(),
+  isTest: zod.z.boolean(),
+  traceContext: zod.z.record(zod.z.unknown()),
+  environment: zod.z.record(zod.z.string()).optional()
 });
-var childToWorkerMessages = {
-  TASK_RUN_COMPLETED: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    execution: TaskRunExecution,
-    result: TaskRunExecutionResult
-  }),
-  TASKS_READY: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    tasks: TaskMetadataWithFilePath.array()
-  }),
-  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
-  TASK_HEARTBEAT: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    id: zod.z.string()
-  }),
-  READY_TO_DISPOSE: zod.z.undefined(),
-  WAIT_FOR_DURATION: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    ms: zod.z.number()
-  }),
-  WAIT_FOR_TASK: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    id: zod.z.string()
-  }),
-  WAIT_FOR_BATCH: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    id: zod.z.string(),
-    runs: zod.z.string().array()
-  }),
-  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
-};
-var ProdChildToWorkerMessages = {
-  TASK_RUN_COMPLETED: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      execution: TaskRunExecution,
-      result: TaskRunExecutionResult
-    })
-  },
-  TASKS_READY: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      tasks: TaskMetadataWithFilePath.array()
-    })
-  },
-  TASKS_FAILED_TO_PARSE: {
-    message: TaskMetadataFailedToParseData
-  },
-  TASK_HEARTBEAT: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      id: zod.z.string()
-    })
-  },
-  READY_TO_DISPOSE: {
-    message: zod.z.undefined()
-  },
-  READY_FOR_CHECKPOINT: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1")
-    })
-  },
-  CANCEL_CHECKPOINT: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1")
-    })
-  },
-  WAIT_FOR_DURATION: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      ms: zod.z.number(),
-      now: zod.z.number()
-    }),
-    callback: zod.z.object({
-      willCheckpointAndRestore: zod.z.boolean()
-    })
-  },
-  WAIT_FOR_TASK: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      friendlyId: zod.z.string()
-    })
-  },
-  WAIT_FOR_BATCH: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      batchFriendlyId: zod.z.string(),
-      runFriendlyIds: zod.z.string().array()
-    })
-  },
-  UNCAUGHT_EXCEPTION: {
-    message: UncaughtExceptionMessage
-  }
-};
-var ProdWorkerToChildMessages = {
-  EXECUTE_TASK_RUN: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      execution: TaskRunExecution,
-      traceContext: zod.z.record(zod.z.unknown()),
-      metadata: BackgroundWorkerProperties
-    })
-  },
-  TASK_RUN_COMPLETED_NOTIFICATION: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      completion: TaskRunExecutionResult,
-      execution: TaskRunExecution
-    })
-  },
-  CLEANUP: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      flush: zod.z.boolean().default(false),
-      kill: zod.z.boolean().default(true)
-    }),
-    callback: zod.z.void()
-  },
-  WAIT_COMPLETED_NOTIFICATION: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1")
-    })
-  }
-};
 
 // src/v3/schemas/resources.ts
 var TaskResource = zod.z.object({
@@ -656,7 +611,8 @@ var GetProjectEnvResponse = zod.z.object({
 });
 var CreateBackgroundWorkerRequestBody = zod.z.object({
   localOnly: zod.z.boolean(),
-  metadata: BackgroundWorkerMetadata
+  metadata: BackgroundWorkerMetadata,
+  supportsLazyAttempts: zod.z.boolean().optional()
 });
 var CreateBackgroundWorkerResponse = zod.z.object({
   id: zod.z.string(),
@@ -705,7 +661,8 @@ var GetEnvironmentVariablesResponseBody = zod.z.object({
   variables: zod.z.record(zod.z.string())
 });
 var StartDeploymentIndexingRequestBody = zod.z.object({
-  imageReference: zod.z.string()
+  imageReference: zod.z.string(),
+  selfHosted: zod.z.boolean().optional()
 });
 var StartDeploymentIndexingResponseBody = zod.z.object({
   id: zod.z.string(),
@@ -851,54 +808,350 @@ var ListScheduleOptions = zod.z.object({
   page: zod.z.number().optional(),
   perPage: zod.z.number().optional()
 });
-var PostStartCauses = zod.z.enum([
-  "index",
-  "create",
-  "restore"
+var RunStatus = zod.z.enum([
+  "PENDING",
+  "EXECUTING",
+  "PAUSED",
+  "COMPLETED",
+  "FAILED",
+  "CANCELED"
 ]);
-var PreStopCauses = zod.z.enum([
-  "terminate"
+var AttemptStatus = zod.z.enum([
+  "PENDING",
+  "EXECUTING",
+  "PAUSED",
+  "COMPLETED",
+  "FAILED",
+  "CANCELED"
 ]);
-var RegexSchema = zod.z.custom((val) => {
-  try {
-    return typeof val.test === "function";
-  } catch {
-    return false;
-  }
+var RetrieveRunResponse = zod.z.object({
+  id: zod.z.string(),
+  status: RunStatus,
+  taskIdentifier: zod.z.string(),
+  idempotencyKey: zod.z.string().optional(),
+  version: zod.z.string().optional(),
+  createdAt: zod.z.coerce.date(),
+  updatedAt: zod.z.coerce.date(),
+  attempts: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    status: AttemptStatus,
+    createdAt: zod.z.coerce.date(),
+    updatedAt: zod.z.coerce.date(),
+    startedAt: zod.z.coerce.date().optional(),
+    completedAt: zod.z.coerce.date().optional()
+  }).optional())
+});
+var CreateEnvironmentVariableRequestBody = zod.z.object({
+  name: zod.z.string(),
+  value: zod.z.string()
 });
-var Config = zod.z.object({
-  project: zod.z.string(),
-  triggerDirectories: zod.z.string().array().optional(),
-  triggerUrl: zod.z.string().optional(),
-  projectDir: zod.z.string().optional(),
-  tsconfigPath: zod.z.string().optional(),
-  retries: zod.z.object({
-    enabledInDev: zod.z.boolean().default(true),
-    default: RetryOptions.optional()
-  }).optional(),
-  additionalPackages: zod.z.string().array().optional(),
-  additionalFiles: zod.z.string().array().optional(),
-  dependenciesToBundle: zod.z.array(zod.z.union([
-    zod.z.string(),
-    RegexSchema
-  ])).optional(),
-  logLevel: zod.z.string().optional(),
-  enableConsoleLogging: zod.z.boolean().optional()
+var UpdateEnvironmentVariableRequestBody = zod.z.object({
+  value: zod.z.string()
 });
-var WaitReason = zod.z.enum([
-  "WAIT_FOR_DURATION",
-  "WAIT_FOR_TASK",
-  "WAIT_FOR_BATCH"
+var ImportEnvironmentVariablesRequestBody = zod.z.object({
+  variables: zod.z.record(zod.z.string()),
+  override: zod.z.boolean().optional()
+});
+var EnvironmentVariableResponseBody = zod.z.object({
+  success: zod.z.boolean()
+});
+var EnvironmentVariableValue = zod.z.object({
+  value: zod.z.string()
+});
+var EnvironmentVariable = zod.z.object({
+  name: zod.z.string(),
+  value: zod.z.string()
+});
+var EnvironmentVariables = zod.z.array(EnvironmentVariable);
+var BackgroundWorkerServerMessages = zod.z.discriminatedUnion("type", [
+  zod.z.object({
+    type: zod.z.literal("EXECUTE_RUNS"),
+    payloads: zod.z.array(TaskRunExecutionPayload)
+  }),
+  zod.z.object({
+    type: zod.z.literal("CANCEL_ATTEMPT"),
+    taskAttemptId: zod.z.string(),
+    taskRunId: zod.z.string()
+  }),
+  zod.z.object({
+    type: zod.z.literal("SCHEDULE_ATTEMPT"),
+    image: zod.z.string(),
+    version: zod.z.string(),
+    machine: Machine,
+    // identifiers
+    id: zod.z.string().optional(),
+    envId: zod.z.string(),
+    envType: EnvironmentType,
+    orgId: zod.z.string(),
+    projectId: zod.z.string(),
+    runId: zod.z.string()
+  }),
+  zod.z.object({
+    type: zod.z.literal("EXECUTE_RUN_LAZY_ATTEMPT"),
+    payload: TaskRunExecutionLazyAttemptPayload
+  })
 ]);
-var ProviderToPlatformMessages = {
-  LOG: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      data: zod.z.string()
-    })
-  },
-  LOG_WITH_ACK: {
-    message: zod.z.object({
+var serverWebsocketMessages = {
+  SERVER_READY: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  BACKGROUND_WORKER_MESSAGE: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    backgroundWorkerId: zod.z.string(),
+    data: BackgroundWorkerServerMessages
+  })
+};
+var BackgroundWorkerClientMessages = zod.z.discriminatedUnion("type", [
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_RUN_COMPLETED"),
+    completion: TaskRunExecutionResult,
+    execution: TaskRunExecution
+  }),
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_RUN_FAILED_TO_RUN"),
+    completion: TaskRunFailedExecutionResult
+  }),
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_HEARTBEAT"),
+    id: zod.z.string()
+  }),
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_RUN_HEARTBEAT"),
+    id: zod.z.string()
+  })
+]);
+var BackgroundWorkerProperties = zod.z.object({
+  id: zod.z.string(),
+  version: zod.z.string(),
+  contentHash: zod.z.string()
+});
+var clientWebsocketMessages = {
+  READY_FOR_TASKS: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    backgroundWorkerId: zod.z.string(),
+    inProgressRuns: zod.z.string().array().optional()
+  }),
+  BACKGROUND_WORKER_DEPRECATED: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    backgroundWorkerId: zod.z.string()
+  }),
+  BACKGROUND_WORKER_MESSAGE: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    backgroundWorkerId: zod.z.string(),
+    data: BackgroundWorkerClientMessages
+  })
+};
+var workerToChildMessages = {
+  EXECUTE_TASK_RUN: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
+    traceContext: zod.z.record(zod.z.unknown()),
+    metadata: BackgroundWorkerProperties
+  }),
+  TASK_RUN_COMPLETED_NOTIFICATION: zod.z.discriminatedUnion("version", [
+    zod.z.object({
+      version: zod.z.literal("v1"),
+      completion: TaskRunExecutionResult,
+      execution: TaskRunExecution
+    }),
+    zod.z.object({
+      version: zod.z.literal("v2"),
+      completion: TaskRunExecutionResult
+    })
+  ]),
+  CLEANUP: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    flush: zod.z.boolean().default(false),
+    kill: zod.z.boolean().default(true)
+  })
+};
+var UncaughtExceptionMessage = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  error: zod.z.object({
+    name: zod.z.string(),
+    message: zod.z.string(),
+    stack: zod.z.string().optional()
+  }),
+  origin: zod.z.enum([
+    "uncaughtException",
+    "unhandledRejection"
+  ])
+});
+var TaskMetadataFailedToParseData = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  tasks: zod.z.unknown(),
+  zodIssues: zod.z.custom((v) => {
+    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
+  })
+});
+var childToWorkerMessages = {
+  TASK_RUN_COMPLETED: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
+    result: TaskRunExecutionResult
+  }),
+  TASKS_READY: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    tasks: TaskMetadataWithFilePath.array()
+  }),
+  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
+  TASK_HEARTBEAT: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  TASK_RUN_HEARTBEAT: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  READY_TO_DISPOSE: zod.z.undefined(),
+  WAIT_FOR_DURATION: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    ms: zod.z.number()
+  }),
+  WAIT_FOR_TASK: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  WAIT_FOR_BATCH: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string(),
+    runs: zod.z.string().array()
+  }),
+  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
+};
+var ProdChildToWorkerMessages = {
+  TASK_RUN_COMPLETED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      result: TaskRunExecutionResult
+    })
+  },
+  TASKS_READY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      tasks: TaskMetadataWithFilePath.array()
+    })
+  },
+  TASKS_FAILED_TO_PARSE: {
+    message: TaskMetadataFailedToParseData
+  },
+  TASK_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      id: zod.z.string()
+    })
+  },
+  TASK_RUN_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      id: zod.z.string()
+    })
+  },
+  READY_TO_DISPOSE: {
+    message: zod.z.undefined()
+  },
+  READY_FOR_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: zod.z.discriminatedUnion("version", [
+      zod.z.object({
+        version: zod.z.literal("v1")
+      }),
+      zod.z.object({
+        version: zod.z.literal("v2"),
+        reason: WaitReason.optional()
+      })
+    ]).default({
+      version: "v1"
+    }),
+    callback: zod.z.object({
+      // TODO: Figure out how best to handle callback schema parsing in zod IPC
+      version: zod.z.literal("v2"),
+      checkpointCanceled: zod.z.boolean(),
+      reason: WaitReason.optional()
+    })
+  },
+  WAIT_FOR_DURATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      ms: zod.z.number(),
+      now: zod.z.number()
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      friendlyId: zod.z.string()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      batchFriendlyId: zod.z.string(),
+      runFriendlyIds: zod.z.string().array()
+    })
+  },
+  UNCAUGHT_EXCEPTION: {
+    message: UncaughtExceptionMessage
+  }
+};
+var ProdWorkerToChildMessages = {
+  EXECUTE_TASK_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      traceContext: zod.z.record(zod.z.unknown()),
+      metadata: BackgroundWorkerProperties
+    })
+  },
+  TASK_RUN_COMPLETED_NOTIFICATION: {
+    message: zod.z.discriminatedUnion("version", [
+      zod.z.object({
+        version: zod.z.literal("v1"),
+        completion: TaskRunExecutionResult,
+        execution: TaskRunExecution
+      }),
+      zod.z.object({
+        version: zod.z.literal("v2"),
+        completion: TaskRunExecutionResult
+      })
+    ])
+  },
+  CLEANUP: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      flush: zod.z.boolean().default(false),
+      kill: zod.z.boolean().default(true)
+    }),
+    callback: zod.z.void()
+  },
+  WAIT_COMPLETED_NOTIFICATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  }
+};
+var ProviderToPlatformMessages = {
+  LOG: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      data: zod.z.string()
+    })
+  },
+  LOG_WITH_ACK: {
+    message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       data: zod.z.string()
     }),
@@ -1002,6 +1255,17 @@ var PlatformToProviderMessages = {
     })
   }
 };
+var CreateWorkerMessage = zod.z.object({
+  projectRef: zod.z.string(),
+  envId: zod.z.string(),
+  deploymentId: zod.z.string(),
+  metadata: zod.z.object({
+    cliPackageVersion: zod.z.string().optional(),
+    contentHash: zod.z.string(),
+    packageVersion: zod.z.string(),
+    tasks: TaskResource.array()
+  })
+});
 var CoordinatorToPlatformMessages = {
   LOG: {
     message: zod.z.object({
@@ -1011,18 +1275,15 @@ var CoordinatorToPlatformMessages = {
     })
   },
   CREATE_WORKER: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      projectRef: zod.z.string(),
-      envId: zod.z.string(),
-      deploymentId: zod.z.string(),
-      metadata: zod.z.object({
-        cliPackageVersion: zod.z.string().optional(),
-        contentHash: zod.z.string(),
-        packageVersion: zod.z.string(),
-        tasks: TaskResource.array()
+    message: zod.z.discriminatedUnion("version", [
+      CreateWorkerMessage.extend({
+        version: zod.z.literal("v1")
+      }),
+      CreateWorkerMessage.extend({
+        version: zod.z.literal("v2"),
+        supportsLazyAttempts: zod.z.boolean()
       })
-    }),
+    ]),
     callback: zod.z.discriminatedUnion("success", [
       zod.z.object({
         success: zod.z.literal(false)
@@ -1032,23 +1293,58 @@ var CoordinatorToPlatformMessages = {
       })
     ])
   },
-  READY_FOR_EXECUTION: {
+  CREATE_TASK_RUN_ATTEMPT: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       runId: zod.z.string(),
-      totalCompletions: zod.z.number()
+      envId: zod.z.string()
     }),
     callback: zod.z.discriminatedUnion("success", [
       zod.z.object({
-        success: zod.z.literal(false)
+        success: zod.z.literal(false),
+        reason: zod.z.string().optional()
       }),
       zod.z.object({
         success: zod.z.literal(true),
-        payload: ProdTaskRunExecutionPayload
+        executionPayload: ProdTaskRunExecutionPayload
       })
     ])
   },
-  READY_FOR_RESUME: {
+  READY_FOR_EXECUTION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false)
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        payload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  READY_FOR_LAZY_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      envId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        reason: zod.z.string().optional()
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        lazyPayload: TaskRunExecutionLazyAttemptPayload
+      })
+    ])
+  },
+  READY_FOR_RESUME: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       attemptFriendlyId: zod.z.string(),
@@ -1066,12 +1362,24 @@ var CoordinatorToPlatformMessages = {
       }).optional()
     })
   },
+  TASK_RUN_FAILED_TO_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      completion: TaskRunFailedExecutionResult
+    })
+  },
   TASK_HEARTBEAT: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       attemptFriendlyId: zod.z.string()
     })
   },
+  TASK_RUN_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  },
   CHECKPOINT_CREATED: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1110,6 +1418,17 @@ var CoordinatorToPlatformMessages = {
         stack: zod.z.string().optional()
       })
     })
+  },
+  RUN_CRASHED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional()
+      })
+    })
   }
 };
 var PlatformToCoordinatorMessages = {
@@ -1137,6 +1456,13 @@ var PlatformToCoordinatorMessages = {
       attemptFriendlyId: zod.z.string()
     })
   },
+  REQUEST_RUN_CANCELLATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      delayInMs: zod.z.number().optional()
+    })
+  },
   READY_FOR_RETRY: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1180,6 +1506,12 @@ var SharedQueueToClientMessages = {
     })
   }
 };
+var IndexTasksMessage = zod.z.object({
+  version: zod.z.literal("v1"),
+  deploymentId: zod.z.string(),
+  tasks: TaskResource.array(),
+  packageVersion: zod.z.string()
+});
 var ProdWorkerToCoordinatorMessages = {
   LOG: {
     message: zod.z.object({
@@ -1189,12 +1521,15 @@ var ProdWorkerToCoordinatorMessages = {
     callback: zod.z.void()
   },
   INDEX_TASKS: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      deploymentId: zod.z.string(),
-      tasks: TaskResource.array(),
-      packageVersion: zod.z.string()
-    }),
+    message: zod.z.discriminatedUnion("version", [
+      IndexTasksMessage.extend({
+        version: zod.z.literal("v1")
+      }),
+      IndexTasksMessage.extend({
+        version: zod.z.literal("v2"),
+        supportsLazyAttempts: zod.z.boolean()
+      })
+    ]),
     callback: zod.z.discriminatedUnion("success", [
       zod.z.object({
         success: zod.z.literal(false)
@@ -1211,6 +1546,13 @@ var ProdWorkerToCoordinatorMessages = {
       totalCompletions: zod.z.number()
     })
   },
+  READY_FOR_LAZY_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    })
+  },
   READY_FOR_RESUME: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1224,8 +1566,21 @@ var ProdWorkerToCoordinatorMessages = {
     })
   },
   CANCEL_CHECKPOINT: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1")
+    message: zod.z.discriminatedUnion("version", [
+      zod.z.object({
+        version: zod.z.literal("v1")
+      }),
+      zod.z.object({
+        version: zod.z.literal("v2"),
+        reason: WaitReason.optional()
+      })
+    ]).default({
+      version: "v1"
+    }),
+    callback: zod.z.object({
+      version: zod.z.literal("v2").default("v2"),
+      checkpointCanceled: zod.z.boolean(),
+      reason: WaitReason.optional()
     })
   },
   TASK_HEARTBEAT: {
@@ -1234,6 +1589,12 @@ var ProdWorkerToCoordinatorMessages = {
       attemptFriendlyId: zod.z.string()
     })
   },
+  TASK_RUN_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  },
   TASK_RUN_COMPLETED: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1245,6 +1606,12 @@ var ProdWorkerToCoordinatorMessages = {
       shouldExit: zod.z.boolean()
     })
   },
+  TASK_RUN_FAILED_TO_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      completion: TaskRunFailedExecutionResult
+    })
+  },
   WAIT_FOR_DURATION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1289,6 +1656,32 @@ var ProdWorkerToCoordinatorMessages = {
         stack: zod.z.string().optional()
       })
     })
+  },
+  CREATE_TASK_RUN_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        reason: zod.z.string().optional()
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        executionPayload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  UNRECOVERABLE_ERROR: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional()
+      })
+    })
   }
 };
 var CoordinatorToProdWorkerMessages = {
@@ -1312,6 +1705,12 @@ var CoordinatorToProdWorkerMessages = {
       executionPayload: ProdTaskRunExecutionPayload
     })
   },
+  EXECUTE_TASK_RUN_LAZY_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      lazyPayload: TaskRunExecutionLazyAttemptPayload
+    })
+  },
   REQUEST_ATTEMPT_CANCELLATION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1319,9 +1718,15 @@ var CoordinatorToProdWorkerMessages = {
     })
   },
   REQUEST_EXIT: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1")
-    })
+    message: zod.z.discriminatedUnion("version", [
+      zod.z.object({
+        version: zod.z.literal("v1")
+      }),
+      zod.z.object({
+        version: zod.z.literal("v2"),
+        delayInMs: zod.z.number().optional()
+      })
+    ])
   },
   READY_FOR_RETRY: {
     message: zod.z.object({
@@ -1539,143 +1944,162 @@ var SpanMessagingEvent = zod.z.object({
   destination: zod.z.string().optional()
 });
 
-// src/v3/apiErrors.ts
-var _APIError = class _APIError extends Error {
-  constructor(status, error, message, headers) {
-    super(`${_APIError.makeMessage(status, error, message)}`);
-    this.status = status;
-    this.headers = headers;
-    const data = error;
-    this.error = data;
-    this.code = data?.["code"];
-    this.param = data?.["param"];
-    this.type = data?.["type"];
+// 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;
   }
-  static makeMessage(status, error, message) {
-    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
-    if (status && msg) {
-      return `${status} ${msg}`;
-    }
-    if (status) {
-      return `${status} status code (no body)`;
-    }
-    if (msg) {
-      return msg;
-    }
-    return "(no status code or body)";
+  api[type] = instance;
+  return true;
+}
+__name(registerGlobal, "registerGlobal");
+function getGlobal(type) {
+  return _global[GLOBAL_TRIGGER_DOT_DEV_KEY]?.[type];
+}
+__name(getGlobal, "getGlobal");
+function unregisterGlobal(type) {
+  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY];
+  if (api) {
+    delete api[type];
   }
-  static generate(status, errorResponse, message, headers) {
-    if (!status) {
-      return new APIConnectionError({
-        cause: castToError(errorResponse)
-      });
-    }
-    const error = errorResponse?.["error"];
-    if (status === 400) {
-      return new BadRequestError(status, error, message, headers);
-    }
-    if (status === 401) {
-      return new AuthenticationError(status, error, message, headers);
+}
+__name(unregisterGlobal, "unregisterGlobal");
+
+// 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",
+  LINK_TITLE: "$link.title",
+  IDEMPOTENCY_KEY: "ctx.run.idempotencyKey"
+};
+
+// src/v3/taskContext/index.ts
+var API_NAME = "task-context";
+var _getTaskContext, getTaskContext_fn;
+var _TaskContextAPI = class _TaskContextAPI {
+  constructor() {
+    __privateAdd(this, _getTaskContext);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _TaskContextAPI();
     }
-    if (status === 403) {
-      return new PermissionDeniedError(status, error, message, headers);
+    return this._instance;
+  }
+  get isInsideTask() {
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this) !== void 0;
+  }
+  get ctx() {
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.ctx;
+  }
+  get worker() {
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.worker;
+  }
+  get attributes() {
+    if (this.ctx) {
+      return {
+        ...this.contextAttributes,
+        ...this.workerAttributes
+      };
     }
-    if (status === 404) {
-      return new NotFoundError(status, error, message, headers);
+    return {};
+  }
+  get workerAttributes() {
+    if (this.worker) {
+      return {
+        [SemanticInternalAttributes.WORKER_ID]: this.worker.id,
+        [SemanticInternalAttributes.WORKER_VERSION]: this.worker.version
+      };
     }
-    if (status === 409) {
-      return new ConflictError(status, error, message, headers);
-    }
-    if (status === 422) {
-      return new UnprocessableEntityError(status, error, message, headers);
-    }
-    if (status === 429) {
-      return new RateLimitError(status, error, message, headers);
-    }
-    if (status >= 500) {
-      return new InternalServerError(status, error, message, headers);
-    }
-    return new _APIError(status, error, message, headers);
-  }
-};
-__name(_APIError, "APIError");
-var APIError = _APIError;
-var _APIConnectionError = class _APIConnectionError extends APIError {
-  constructor({ message, cause }) {
-    super(void 0, void 0, message || "Connection error.", void 0);
-    __publicField(this, "status");
-    if (cause)
-      this.cause = cause;
-  }
-};
-__name(_APIConnectionError, "APIConnectionError");
-var APIConnectionError = _APIConnectionError;
-var _BadRequestError = class _BadRequestError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 400);
-  }
-};
-__name(_BadRequestError, "BadRequestError");
-var BadRequestError = _BadRequestError;
-var _AuthenticationError = class _AuthenticationError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 401);
-  }
-};
-__name(_AuthenticationError, "AuthenticationError");
-var AuthenticationError = _AuthenticationError;
-var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 403);
-  }
-};
-__name(_PermissionDeniedError, "PermissionDeniedError");
-var PermissionDeniedError = _PermissionDeniedError;
-var _NotFoundError = class _NotFoundError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 404);
+    return {};
   }
-};
-__name(_NotFoundError, "NotFoundError");
-var NotFoundError = _NotFoundError;
-var _ConflictError = class _ConflictError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 409);
+  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,
+        [SemanticInternalAttributes.IDEMPOTENCY_KEY]: this.ctx.run.idempotencyKey
+      };
+    }
+    return {};
   }
-};
-__name(_ConflictError, "ConflictError");
-var ConflictError = _ConflictError;
-var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 422);
+  disable() {
+    unregisterGlobal(API_NAME);
   }
-};
-__name(_UnprocessableEntityError, "UnprocessableEntityError");
-var UnprocessableEntityError = _UnprocessableEntityError;
-var _RateLimitError = class _RateLimitError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 429);
+  setGlobalTaskContext(taskContext2) {
+    return registerGlobal(API_NAME, taskContext2);
   }
 };
-__name(_RateLimitError, "RateLimitError");
-var RateLimitError = _RateLimitError;
-var _InternalServerError = class _InternalServerError extends APIError {
-};
-__name(_InternalServerError, "InternalServerError");
-var InternalServerError = _InternalServerError;
-function castToError(err) {
-  if (err instanceof Error)
-    return err;
-  return new Error(err);
-}
-__name(castToError, "castToError");
+_getTaskContext = new WeakSet();
+getTaskContext_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME);
+}, "#getTaskContext");
+__name(_TaskContextAPI, "TaskContextAPI");
+var TaskContextAPI = _TaskContextAPI;
+
+// src/v3/task-context-api.ts
+var taskContext = TaskContextAPI.getInstance();
 
 // src/retry.ts
 function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
@@ -1783,8 +2207,6 @@ function calculateResetAt2(resets, format, now = Date.now()) {
   return resetAt?.getTime();
 }
 __name(calculateResetAt2, "calculateResetAt");
-
-// src/v3/zodfetch.ts
 var defaultRetryOptions2 = {
   maxAttempts: 3,
   factor: 2,
@@ -1796,6 +2218,32 @@ async function zodfetch(schema, url, requestInit, options) {
   return await _doZodFetch(schema, url, requestInit, options);
 }
 __name(zodfetch, "zodfetch");
+async function zodupload(schema, url, body, requestInit, options) {
+  const form = await createForm(body);
+  const encoder = new formDataEncoder.FormDataEncoder(form);
+  const finalHeaders = {};
+  for (const [key, value] of Object.entries(requestInit?.headers || {})) {
+    finalHeaders[key] = value;
+  }
+  for (const [key, value] of Object.entries(encoder.headers)) {
+    finalHeaders[key] = value;
+  }
+  finalHeaders["Content-Length"] = String(encoder.contentLength);
+  const finalRequestInit = {
+    ...requestInit,
+    headers: finalHeaders,
+    body: stream.Readable.from(encoder),
+    // @ts-expect-error
+    duplex: "half"
+  };
+  return await _doZodFetch(schema, url, finalRequestInit, options);
+}
+__name(zodupload, "zodupload");
+var createForm = /* @__PURE__ */ __name(async (body) => {
+  const form = new FormData();
+  await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
+  return form;
+}, "createForm");
 async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
   try {
     const response = await fetch(url, requestInitWithCache(requestInit));
@@ -1917,345 +2365,177 @@ function requestInitWithCache(requestInit) {
   }
 }
 __name(requestInitWithCache, "requestInitWithCache");
-
-// src/v3/utils/flattenAttributes.ts
-function flattenAttributes(obj, prefix) {
-  const result = {};
-  if (!obj) {
-    return result;
-  }
-  if (typeof obj === "string") {
-    result[prefix || ""] = obj;
-    return result;
+var addFormValue = /* @__PURE__ */ __name(async (form, key, value) => {
+  if (value === void 0)
+    return;
+  if (value == null) {
+    throw new TypeError(`Received null for "${key}"; to pass null in FormData, you must use the string 'null'`);
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    form.append(key, String(value));
+  } else if (isUploadable(value) || isBlobLike(value) || value instanceof Buffer || value instanceof ArrayBuffer) {
+    const file = await toFile(value);
+    form.append(key, file);
+  } else if (Array.isArray(value)) {
+    await Promise.all(value.map((entry) => addFormValue(form, key + "[]", entry)));
+  } else if (typeof value === "object") {
+    await Promise.all(Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop)));
+  } else {
+    throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`);
+  }
+}, "addFormValue");
+async function toFile(value, name, options) {
+  value = await value;
+  options ??= isFileLike(value) ? {
+    lastModified: value.lastModified,
+    type: value.type
+  } : {};
+  if (isResponseLike(value)) {
+    const blob = await value.blob();
+    name ||= new URL(value.url).pathname.split(/[\\/]/).pop() ?? "unknown_file";
+    return new File([
+      blob
+    ], name, options);
+  }
+  const bits = await getBytes(value);
+  name ||= getName(value) ?? "unknown_file";
+  if (!options.type) {
+    const type = bits[0]?.type;
+    if (typeof type === "string") {
+      options = {
+        ...options,
+        type
+      };
+    }
   }
-  if (typeof obj === "number") {
-    result[prefix || ""] = obj;
-    return result;
+  return new File(bits, name, options);
+}
+__name(toFile, "toFile");
+function getName(value) {
+  return getStringFromMaybeBuffer(value.name) || getStringFromMaybeBuffer(value.filename) || // For fs.ReadStream
+  getStringFromMaybeBuffer(value.path)?.split(/[\\/]/).pop();
+}
+__name(getName, "getName");
+var getStringFromMaybeBuffer = /* @__PURE__ */ __name((x) => {
+  if (typeof x === "string")
+    return x;
+  if (typeof Buffer !== "undefined" && x instanceof Buffer)
+    return String(x);
+  return void 0;
+}, "getStringFromMaybeBuffer");
+async function getBytes(value) {
+  let parts = [];
+  if (typeof value === "string" || ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+  value instanceof ArrayBuffer) {
+    parts.push(value);
+  } else if (isBlobLike(value)) {
+    parts.push(await value.arrayBuffer());
+  } else if (isAsyncIterableIterator(value)) {
+    for await (const chunk of value) {
+      parts.push(chunk);
+    }
+  } else {
+    throw new Error(`Unexpected data type: ${typeof value}; constructor: ${value?.constructor?.name}; props: ${propsForError(value)}`);
+  }
+  return parts;
+}
+__name(getBytes, "getBytes");
+function propsForError(value) {
+  const props = Object.getOwnPropertyNames(value);
+  return `[${props.map((p) => `"${p}"`).join(", ")}]`;
+}
+__name(propsForError, "propsForError");
+var isAsyncIterableIterator = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function", "isAsyncIterableIterator");
+var isResponseLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function", "isResponseLike");
+var isFileLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value), "isFileLike");
+var isBlobLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function", "isBlobLike");
+var isFsReadStream = /* @__PURE__ */ __name((value) => value instanceof stream.Readable, "isFsReadStream");
+var isUploadable = /* @__PURE__ */ __name((value) => {
+  return isFileLike(value) || isResponseLike(value) || isFsReadStream(value);
+}, "isUploadable");
+var isRecordLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => typeof key === "string" && typeof value[key] === "string"), "isRecordLike");
+
+// src/v3/apiClient/index.ts
+var zodFetchOptions = {
+  retry: {
+    maxAttempts: 3,
+    minTimeoutInMs: 1e3,
+    maxTimeoutInMs: 3e4,
+    factor: 2,
+    randomize: false
   }
-  if (typeof obj === "boolean") {
-    result[prefix || ""] = obj;
-    return result;
+};
+var _getHeaders, getHeaders_fn;
+var _ApiClient = class _ApiClient {
+  constructor(baseUrl, accessToken) {
+    __privateAdd(this, _getHeaders);
+    this.accessToken = accessToken;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
   }
-  for (const [key, value] of Object.entries(obj)) {
-    const newPrefix = `${prefix ? `${prefix}.` : ""}${key}`;
-    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}]`));
-        } else {
-          result[`${newPrefix}.[${i}]`] = value[i];
+  async getRunResult(runId) {
+    try {
+      return await zodfetch(TaskRunExecutionResult, `${this.baseUrl}/api/v1/runs/${runId}/result`, {
+        method: "GET",
+        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+      }, zodFetchOptions);
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.status === 404) {
+          return void 0;
         }
       }
-    } else if (isRecord(value)) {
-      Object.assign(result, flattenAttributes(value, newPrefix));
-    } else {
-      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
-        result[newPrefix] = value;
-      }
+      throw error;
     }
   }
-  return result;
-}
-__name(flattenAttributes, "flattenAttributes");
-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;
+  async getBatchResults(batchId) {
+    return await zodfetch(BatchTaskRunExecutionResult, `${this.baseUrl}/api/v1/batches/${batchId}/results`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
   }
-  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;
+  triggerTask(taskId, body, options) {
+    return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
+      body: JSON.stringify(body)
+    }, zodFetchOptions);
   }
-  return result;
-}
-__name(unflattenAttributes, "unflattenAttributes");
-function detectIsArrayIndex(key) {
-  const match = key.match(/^\[(\d+)\]$/);
-  if (match) {
-    return true;
+  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);
   }
-  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;
+  createUploadPayloadUrl(filename) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
   }
-  const attributes = flattenAttributes(obj, prefix);
-  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
-    return attributes[prefix];
+  getPayloadUrl(filename) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
   }
-  return attributes;
-}
-__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
-var _SafeAsyncLocalStorage = class _SafeAsyncLocalStorage {
-  constructor() {
-    this.storage = new async_hooks.AsyncLocalStorage();
+  retrieveRun(runId) {
+    return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v3/runs/${runId}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
   }
-  runWith(context3, fn) {
-    return this.storage.run(context3, fn);
+  replayRun(runId) {
+    return zodfetch(ReplayRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/replay`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
   }
-  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",
-  LINK_TITLE: "$link.title"
-};
-
-// src/v3/tasks/taskContextManager.ts
-var _getStore, getStore_fn;
-var _TaskContextManager = class _TaskContextManager {
-  constructor() {
-    __privateAdd(this, _getStore);
-    __publicField(this, "_storage", new SafeAsyncLocalStorage());
-  }
-  get isInsideTask() {
-    return __privateMethod(this, _getStore, getStore_fn).call(this) !== void 0;
-  }
-  get ctx() {
-    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
-    return store?.ctx;
-  }
-  get worker() {
-    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
-    return store?.worker;
-  }
-  get attributes() {
-    if (this.ctx) {
-      return {
-        ...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 {};
-  }
-  runWith(context3, fn) {
-    return this._storage.runWith(context3, fn);
-  }
-};
-_getStore = new WeakSet();
-getStore_fn = /* @__PURE__ */ __name(function() {
-  return this._storage.getStore();
-}, "#getStore");
-__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: 3,
-    minTimeoutInMs: 1e3,
-    maxTimeoutInMs: 3e4,
-    factor: 2,
-    randomize: false
-  }
-};
-var _getHeaders, getHeaders_fn;
-var _ApiClient = class _ApiClient {
-  constructor(baseUrl, accessToken) {
-    __privateAdd(this, _getHeaders);
-    this.accessToken = accessToken;
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-  }
-  triggerTask(taskId, body, options) {
-    return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, {
-      method: "POST",
-      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);
-  }
-  replayRun(runId) {
-    return zodfetch(ReplayRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/replay`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
-  }
-  cancelRun(runId) {
-    return zodfetch(CanceledRunResponse, `${this.baseUrl}/api/v2/runs/${runId}/cancel`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+  cancelRun(runId) {
+    return zodfetch(CanceledRunResponse, `${this.baseUrl}/api/v2/runs/${runId}/cancel`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
   }
   createSchedule(options) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
@@ -2308,14 +2588,62 @@ var _ApiClient = class _ApiClient {
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
     });
   }
+  listEnvVars(projectRef, slug) {
+    return zodfetch(EnvironmentVariables, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  importEnvVars(projectRef, slug, body) {
+    if (isRecordLike(body.variables)) {
+      return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/import`, {
+        method: "POST",
+        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+        body: JSON.stringify(body)
+      });
+    } else {
+      return zodupload(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/import`, body, {
+        method: "POST",
+        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+      });
+    }
+  }
+  retrieveEnvVar(projectRef, slug, key) {
+    return zodfetch(EnvironmentVariableValue, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  createEnvVar(projectRef, slug, body) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(body)
+    });
+  }
+  updateEnvVar(projectRef, slug, key, body) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(body)
+    });
+  }
+  deleteEnvVar(projectRef, slug, key) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "DELETE",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
 };
 _getHeaders = new WeakSet();
 getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
   const headers = {
     "Content-Type": "application/json",
-    Authorization: `Bearer ${this.accessToken}`
+    Authorization: `Bearer ${this.accessToken}`,
+    "trigger-version": version
   };
-  if (taskContextManager.isInsideTask) {
+  if (taskContext.isInsideTask) {
+    headers["x-trigger-worker"] = "true";
     api.propagation.inject(api.context.active(), headers);
     if (spanParentAsLink) {
       headers["x-trigger-span-parent-as-link"] = "1";
@@ -2325,767 +2653,63 @@ getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
 }, "#getHeaders");
 __name(_ApiClient, "ApiClient");
 var ApiClient = _ApiClient;
-var _getStore2, getStore_fn2;
-var _ApiClientManager = class _ApiClientManager {
-  constructor() {
-    __privateAdd(this, _getStore2);
-    __publicField(this, "_storage", new SafeAsyncLocalStorage());
+var _SimpleClock = class _SimpleClock {
+  preciseNow() {
+    const now = new preciseDate.PreciseDate();
+    const nowStruct = now.toStruct();
+    return [
+      nowStruct.seconds,
+      nowStruct.nanos
+    ];
   }
-  get baseURL() {
-    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
-    return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
+  reset() {
   }
-  get accessToken() {
-    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
-    return store?.accessToken ?? getEnvVar("TRIGGER_SECRET_KEY");
+};
+__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);
   }
-  get client() {
-    if (!this.baseURL || !this.accessToken) {
-      return void 0;
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _ClockAPI();
     }
-    return new ApiClient(this.baseURL, this.accessToken);
+    return this._instance;
+  }
+  setGlobalClock(clock2) {
+    return registerGlobal(API_NAME2, clock2);
   }
-  runWith(context3, fn) {
-    return this._storage.runWith(context3, fn);
+  preciseNow() {
+    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
   }
-};
-_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;
+  reset() {
+    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
   }
 };
-__name(_ZodSchemaParsedError, "ZodSchemaParsedError");
-var ZodSchemaParsedError = _ZodSchemaParsedError;
-var ZodMessageSchema = zod.z.object({
-  version: zod.z.literal("v1").default("v1"),
-  type: zod.z.string(),
-  payload: zod.z.unknown()
-});
-var _schema, _handlers;
-var _ZodMessageHandler = class _ZodMessageHandler {
-  constructor(options) {
-    __privateAdd(this, _schema, void 0);
-    __privateAdd(this, _handlers, void 0);
-    __privateSet(this, _schema, options.schema);
-    __privateSet(this, _handlers, options.messages);
-  }
-  async handleMessage(message) {
-    const parsedMessage = this.parseMessage(message);
-    if (!__privateGet(this, _handlers)) {
-      throw new Error("No handlers provided");
-    }
-    const handler = __privateGet(this, _handlers)[parsedMessage.type];
-    if (!handler) {
-      console.error(`No handler for message type: ${String(parsedMessage.type)}`);
-      return;
-    }
-    const ack = await handler(parsedMessage.payload);
-    return ack;
-  }
-  parseMessage(message) {
-    const parsedMessage = ZodMessageSchema.safeParse(message);
-    if (!parsedMessage.success) {
-      throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`);
-    }
-    const schema = __privateGet(this, _schema)[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)}`);
-    }
+_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/errors.ts
+function parseError(error) {
+  if (error instanceof Error) {
     return {
-      type: parsedMessage.data.type,
-      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();
-__name(_ZodMessageHandler, "ZodMessageHandler");
-var ZodMessageHandler = _ZodMessageHandler;
-var _schema2, _sender;
-var _ZodMessageSender = class _ZodMessageSender {
-  constructor(options) {
-    __privateAdd(this, _schema2, void 0);
-    __privateAdd(this, _sender, void 0);
-    __privateSet(this, _schema2, options.schema);
-    __privateSet(this, _sender, options.sender);
-  }
-  async send(type, payload) {
-    const schema = __privateGet(this, _schema2)[type];
-    if (!schema) {
-      throw new Error(`Unknown message type: ${type}`);
-    }
-    const parsedPayload = schema.safeParse(payload);
-    if (!parsedPayload.success) {
-      throw new ZodSchemaParsedError(parsedPayload.error, payload);
-    }
-    await __privateGet(this, _sender).call(this, {
-      type,
-      payload,
-      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;
-var messageSchema = zod.z.object({
-  version: zod.z.literal("v1").default("v1"),
-  type: zod.z.string(),
-  payload: zod.z.unknown()
-});
-var _schema3, _handlers2;
-var _ZodSocketMessageHandler = class _ZodSocketMessageHandler {
-  constructor(options) {
-    __privateAdd(this, _schema3, void 0);
-    __privateAdd(this, _handlers2, void 0);
-    __privateSet(this, _schema3, options.schema);
-    __privateSet(this, _handlers2, options.handlers);
-  }
-  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;
-  }
-  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: parsedMessage.data.type,
-      payload: parsedPayload.data
-    };
-  }
-  registerHandlers(emitter, logger2) {
-    const log = logger2 ?? console;
-    if (!__privateGet(this, _handlers2)) {
-      log.info("No handlers provided");
-      return;
-    }
-    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);
-        }
-      });
-    }
-  }
-};
-_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}`);
-    }
-    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;
-  }
-  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;
-  }
-};
-_schema4 = new WeakMap();
-_socket = new WeakMap();
-__name(_ZodSocketMessageSender, "ZodSocketMessageSender");
-var ZodSocketMessageSender = _ZodSocketMessageSender;
-var _sender2, _handler, _logger;
-var _ZodSocketConnection = class _ZodSocketConnection {
-  constructor(opts) {
-    __privateAdd(this, _sender2, void 0);
-    __privateAdd(this, _handler, void 0);
-    __privateAdd(this, _logger, void 0);
-    const uri = `${opts.secure ? "wss" : "ws"}://${opts.host}:${opts.port ?? (opts.secure ? "443" : "80")}/${opts.namespace}`;
-    const logger2 = new SimpleStructuredLogger(opts.namespace, exports.LogLevel.info);
-    logger2.log("new zod socket", {
-      uri
-    });
-    this.socket = socket_ioClient.io(uri, {
-      transports: [
-        "websocket"
-      ],
-      auth: {
-        token: opts.authToken
-      },
-      extraHeaders: opts.extraHeaders,
-      reconnectionDelay: 500,
-      reconnectionDelayMax: 1e3
-    });
-    __privateSet(this, _logger, logger2.child({
-      socketId: this.socket.id
-    }));
-    __privateSet(this, _handler, new ZodSocketMessageHandler({
-      schema: opts.serverMessages,
-      handlers: opts.handlers
-    }));
-    __privateGet(this, _handler).registerHandlers(this.socket, __privateGet(this, _logger));
-    __privateSet(this, _sender2, new ZodSocketMessageSender({
-      schema: opts.clientMessages,
-      socket: this.socket
-    }));
-    this.socket.on("connect_error", async (error) => {
-      __privateGet(this, _logger).error(`connect_error: ${error}`);
-      if (opts.onError) {
-        await opts.onError(this.socket, error, __privateGet(this, _logger));
-      }
-    });
-    this.socket.on("connect", async () => {
-      __privateGet(this, _logger).info("connect");
-      if (opts.onConnection) {
-        await opts.onConnection(this.socket, __privateGet(this, _handler), __privateGet(this, _sender2), __privateGet(this, _logger));
-      }
-    });
-    this.socket.on("disconnect", async (reason, description) => {
-      __privateGet(this, _logger).info("disconnect", {
-        reason,
-        description
-      });
-      if (opts.onDisconnect) {
-        await opts.onDisconnect(this.socket, reason, description, __privateGet(this, _logger));
-      }
-    });
-  }
-  close() {
-    this.socket.close();
-  }
-  connect() {
-    this.socket.connect();
-  }
-  get send() {
-    return __privateGet(this, _sender2).send.bind(__privateGet(this, _sender2));
-  }
-  get sendWithAck() {
-    return __privateGet(this, _sender2).sendWithAck.bind(__privateGet(this, _sender2));
-  }
-};
-_sender2 = new WeakMap();
-_handler = new WeakMap();
-_logger = new WeakMap();
-__name(_ZodSocketConnection, "ZodSocketConnection");
-var ZodSocketConnection = _ZodSocketConnection;
-
-// src/v3/zodNamespace.ts
-exports.LogLevel = void 0;
-(function(LogLevel2) {
-  LogLevel2[LogLevel2["log"] = 0] = "log";
-  LogLevel2[LogLevel2["error"] = 1] = "error";
-  LogLevel2[LogLevel2["warn"] = 2] = "warn";
-  LogLevel2[LogLevel2["info"] = 3] = "info";
-  LogLevel2[LogLevel2["debug"] = 4] = "debug";
-})(exports.LogLevel || (exports.LogLevel = {}));
-var _structuredLog, structuredLog_fn;
-var _SimpleStructuredLogger = class _SimpleStructuredLogger {
-  constructor(name, level = [
-    "1",
-    "true"
-  ].includes(process.env.DEBUG ?? "") ? exports.LogLevel.debug : exports.LogLevel.info, fields) {
-    __privateAdd(this, _structuredLog);
-    this.name = name;
-    this.level = level;
-    this.fields = fields;
-  }
-  child(fields, level) {
-    return new _SimpleStructuredLogger(this.name, level, {
-      ...this.fields,
-      ...fields
-    });
-  }
-  log(message, ...args) {
-    if (this.level < exports.LogLevel.log)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
-  }
-  error(message, ...args) {
-    if (this.level < exports.LogLevel.error)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
-  }
-  warn(message, ...args) {
-    if (this.level < exports.LogLevel.warn)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
-  }
-  info(message, ...args) {
-    if (this.level < exports.LogLevel.info)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
-  }
-  debug(message, ...args) {
-    if (this.level < exports.LogLevel.debug)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, "debug", ...args);
-  }
-};
-_structuredLog = new WeakSet();
-structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
-  const structuredLog = {
-    ...args.length === 1 ? args[0] : args,
-    ...this.fields,
-    timestamp: /* @__PURE__ */ new Date(),
-    name: this.name,
-    message,
-    level
-  };
-  loggerFunction(JSON.stringify(structuredLog));
-}, "#structuredLog");
-__name(_SimpleStructuredLogger, "SimpleStructuredLogger");
-var SimpleStructuredLogger = _SimpleStructuredLogger;
-var _logger2, _handler2;
-var _ZodNamespace = class _ZodNamespace {
-  constructor(opts) {
-    __privateAdd(this, _logger2, void 0);
-    __privateAdd(this, _handler2, void 0);
-    __privateSet(this, _logger2, opts.logger ?? new SimpleStructuredLogger(opts.name));
-    __privateSet(this, _handler2, new ZodSocketMessageHandler({
-      schema: opts.clientMessages,
-      handlers: opts.handlers
-    }));
-    this.io = opts.io;
-    this.namespace = this.io.of(opts.name);
-    this.sender = new ZodMessageSender({
-      schema: opts.serverMessages,
-      sender: async (message) => {
-        return new Promise((resolve, reject) => {
-          try {
-            this.namespace.emit(message.type, message.payload);
-            resolve();
-          } catch (err) {
-            reject(err);
-          }
-        });
-      }
-    });
-    if (opts.preAuth) {
-      this.namespace.use(async (socket, next) => {
-        const logger2 = __privateGet(this, _logger2).child({
-          socketId: socket.id,
-          socketStage: "preAuth"
-        });
-        if (typeof opts.preAuth === "function") {
-          await opts.preAuth(socket, next, logger2);
-        }
-      });
-    }
-    if (opts.authToken) {
-      this.namespace.use((socket, next) => {
-        const logger2 = __privateGet(this, _logger2).child({
-          socketId: socket.id,
-          socketStage: "auth"
-        });
-        const { auth } = socket.handshake;
-        if (!("token" in auth)) {
-          logger2.error("no token");
-          return socket.disconnect(true);
-        }
-        if (auth.token !== opts.authToken) {
-          logger2.error("invalid token");
-          return socket.disconnect(true);
-        }
-        logger2.info("success");
-        next();
-      });
-    }
-    if (opts.postAuth) {
-      this.namespace.use(async (socket, next) => {
-        const logger2 = __privateGet(this, _logger2).child({
-          socketId: socket.id,
-          socketStage: "auth"
-        });
-        if (typeof opts.postAuth === "function") {
-          await opts.postAuth(socket, next, logger2);
-        }
-      });
-    }
-    this.namespace.on("connection", async (socket) => {
-      const logger2 = __privateGet(this, _logger2).child({
-        socketId: socket.id,
-        socketStage: "connection"
-      });
-      logger2.info("connected");
-      __privateGet(this, _handler2).registerHandlers(socket, logger2);
-      socket.on("disconnect", async (reason, description) => {
-        logger2.info("disconnect", {
-          reason,
-          description
-        });
-        if (opts.onDisconnect) {
-          await opts.onDisconnect(socket, reason, description, logger2);
-        }
-      });
-      socket.on("error", async (error) => {
-        logger2.error("error", {
-          error
-        });
-        if (opts.onError) {
-          await opts.onError(socket, error, logger2);
-        }
-      });
-      if (opts.onConnection) {
-        await opts.onConnection(socket, __privateGet(this, _handler2), this.sender, logger2);
-      }
-    });
-  }
-  fetchSockets() {
-    return this.namespace.fetchSockets();
-  }
-};
-_logger2 = new WeakMap();
-_handler2 = new WeakMap();
-__name(_ZodNamespace, "ZodNamespace");
-var ZodNamespace = _ZodNamespace;
-var messageSchema2 = zod.z.object({
-  version: zod.z.literal("v1").default("v1"),
-  type: zod.z.string(),
-  payload: zod.z.unknown()
-});
-var _schema5, _handlers3, _sender3, _a;
-var ZodIpcMessageHandler = (_a = class {
-  constructor(options) {
-    __privateAdd(this, _schema5, void 0);
-    __privateAdd(this, _handlers3, void 0);
-    __privateAdd(this, _sender3, void 0);
-    __privateSet(this, _schema5, options.schema);
-    __privateSet(this, _handlers3, options.handlers);
-    __privateSet(this, _sender3, options.sender);
-  }
-  async handleMessage(message) {
-    const parsedMessage = this.parseMessage(message);
-    if (!__privateGet(this, _handlers3)) {
-      throw new Error("No handlers provided");
-    }
-    const handler = __privateGet(this, _handlers3)[parsedMessage.type];
-    if (!handler) {
-      return;
-    }
-    const ack = await handler(parsedMessage.payload, __privateGet(this, _sender3));
-    return ack;
-  }
-  parseMessage(message) {
-    const parsedMessage = messageSchema2.safeParse(message);
-    if (!parsedMessage.success) {
-      throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`);
-    }
-    const schema = __privateGet(this, _schema5)[parsedMessage.data.type]["message"];
-    if (!schema) {
-      throw new Error(`Unknown message type: ${parsedMessage.data.type}`);
-    }
-    const parsedPayload = schema.safeParse(parsedMessage.data.payload);
-    if (!parsedPayload.success) {
-      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
-    }
-    return {
-      type: parsedMessage.data.type,
-      payload: parsedPayload.data
-    };
-  }
-}, _schema5 = new WeakMap(), _handlers3 = new WeakMap(), _sender3 = new WeakMap(), __name(_a, "ZodIpcMessageHandler"), _a);
-var Packet = zod.z.discriminatedUnion("type", [
-  zod.z.object({
-    type: zod.z.literal("CONNECT"),
-    sessionId: zod.z.string().optional()
-  }),
-  zod.z.object({
-    type: zod.z.literal("ACK"),
-    message: zod.z.any(),
-    id: zod.z.number()
-  }),
-  zod.z.object({
-    type: zod.z.literal("EVENT"),
-    message: zod.z.any(),
-    id: zod.z.number().optional()
-  })
-]);
-var _sessionId, _messageCounter, _handler3, _acks, _registerHandlers, registerHandlers_fn, _handlePacket, handlePacket_fn, _sendPacket, sendPacket_fn;
-var _ZodIpcConnection = class _ZodIpcConnection {
-  constructor(opts) {
-    __privateAdd(this, _registerHandlers);
-    __privateAdd(this, _handlePacket);
-    __privateAdd(this, _sendPacket);
-    __privateAdd(this, _sessionId, void 0);
-    __privateAdd(this, _messageCounter, void 0);
-    __privateAdd(this, _handler3, void 0);
-    __privateAdd(this, _acks, void 0);
-    this.opts = opts;
-    __privateSet(this, _messageCounter, 0);
-    __privateSet(this, _acks, /* @__PURE__ */ new Map());
-    __privateSet(this, _handler3, new ZodIpcMessageHandler({
-      schema: opts.listenSchema,
-      handlers: opts.handlers,
-      sender: {
-        send: this.send.bind(this),
-        sendWithAck: this.sendWithAck.bind(this)
-      }
-    }));
-    __privateMethod(this, _registerHandlers, registerHandlers_fn).call(this);
-  }
-  async connect() {
-    __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
-      type: "CONNECT"
-    });
-  }
-  async send(type, payload) {
-    const schema = this.opts.emitSchema[type]["message"];
-    if (!schema) {
-      throw new Error(`Unknown message type: ${type}`);
-    }
-    const parsedPayload = schema.safeParse(payload);
-    if (!parsedPayload.success) {
-      throw new ZodSchemaParsedError(parsedPayload.error, payload);
-    }
-    await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
-      type: "EVENT",
-      message: {
-        type,
-        payload,
-        version: "v1"
-      }
-    });
-  }
-  async sendWithAck(type, payload, timeoutInMs) {
-    const currentId = __privateWrapper(this, _messageCounter)._++;
-    return new Promise(async (resolve, reject) => {
-      const defaultTimeoutInMs = 2e3;
-      const timeout = setTimeout(() => {
-        reject(JSON.stringify({
-          reason: "sendWithAck() timeout",
-          timeoutInMs: timeoutInMs ?? defaultTimeoutInMs,
-          type,
-          payload
-        }));
-      }, timeoutInMs ?? defaultTimeoutInMs);
-      __privateGet(this, _acks).set(currentId, {
-        resolve,
-        reject,
-        timeout
-      });
-      const schema = this.opts.emitSchema[type]["message"];
-      if (!schema) {
-        clearTimeout(timeout);
-        return reject(`Unknown message type: ${type}`);
-      }
-      const parsedPayload = schema.safeParse(payload);
-      if (!parsedPayload.success) {
-        clearTimeout(timeout);
-        return reject(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
-      }
-      await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
-        type: "EVENT",
-        message: {
-          type,
-          payload,
-          version: "v1"
-        },
-        id: currentId
-      });
-    });
-  }
-};
-_sessionId = new WeakMap();
-_messageCounter = new WeakMap();
-_handler3 = new WeakMap();
-_acks = new WeakMap();
-_registerHandlers = new WeakSet();
-registerHandlers_fn = /* @__PURE__ */ __name(async function() {
-  if (!this.opts.process.on) {
-    return;
-  }
-  this.opts.process.on("message", async (message) => {
-    __privateMethod(this, _handlePacket, handlePacket_fn).call(this, message);
-  });
-}, "#registerHandlers");
-_handlePacket = new WeakSet();
-handlePacket_fn = /* @__PURE__ */ __name(async function(packet) {
-  const parsedPacket = Packet.safeParse(packet);
-  if (!parsedPacket.success) {
-    return;
-  }
-  switch (parsedPacket.data.type) {
-    case "ACK": {
-      const ack = __privateGet(this, _acks).get(parsedPacket.data.id);
-      if (!ack) {
-        return;
-      }
-      clearTimeout(ack.timeout);
-      ack.resolve(parsedPacket.data.message);
-      break;
-    }
-    case "CONNECT": {
-      if (!parsedPacket.data.sessionId) {
-        const id = crypto.randomUUID();
-        await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
-          type: "CONNECT",
-          sessionId: id
-        });
-        return;
-      }
-      if (__privateGet(this, _sessionId)) {
-        return;
-      }
-      __privateSet(this, _sessionId, parsedPacket.data.sessionId);
-      break;
-    }
-    case "EVENT": {
-      const result = await __privateGet(this, _handler3).handleMessage(parsedPacket.data.message);
-      if (typeof parsedPacket.data.id === "undefined") {
-        return;
-      }
-      await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
-        type: "ACK",
-        id: parsedPacket.data.id,
-        message: result
-      });
-      break;
-    }
-  }
-}, "#handlePacket");
-_sendPacket = new WeakSet();
-sendPacket_fn = /* @__PURE__ */ __name(async function(packet1) {
-  await this.opts.process.send?.(packet1);
-}, "#sendPacket");
-__name(_ZodIpcConnection, "ZodIpcConnection");
-var ZodIpcConnection = _ZodIpcConnection;
-function parseError(error) {
-  if (error instanceof Error) {
-    return {
-      type: "BUILT_IN_ERROR",
-      name: error.name,
-      message: error.message,
-      stackTrace: error.stack ?? ""
+      type: "BUILT_IN_ERROR",
+      name: error.name,
+      message: error.message,
+      stackTrace: error.stack ?? ""
     };
   }
   if (typeof error === "string") {
@@ -3127,31 +2751,62 @@ function createErrorTaskError(error) {
   }
 }
 __name(createErrorTaskError, "createErrorTaskError");
+function createJsonErrorObject(error) {
+  switch (error.type) {
+    case "BUILT_IN_ERROR": {
+      return {
+        name: error.name,
+        message: error.message,
+        stackTrace: error.stackTrace
+      };
+    }
+    case "STRING_ERROR": {
+      return {
+        message: error.raw
+      };
+    }
+    case "CUSTOM_ERROR": {
+      return {
+        message: error.raw
+      };
+    }
+    case "INTERNAL_ERROR": {
+      return {
+        message: `trigger.dev internal error (${error.code})`
+      };
+    }
+  }
+}
+__name(createJsonErrorObject, "createJsonErrorObject");
 function correctErrorStackTrace(stackTrace, projectDir, options) {
   const [errorLine, ...traceLines] = stackTrace.split("\n");
   return [
     options?.removeFirstLine ? void 0 : errorLine,
-    ...traceLines.map((line) => correctStackTraceLine(line, projectDir))
+    ...traceLines.map((line) => correctStackTraceLine(line, projectDir, options?.isDev))
   ].filter(Boolean).join("\n");
 }
 __name(correctErrorStackTrace, "correctErrorStackTrace");
-function correctStackTraceLine(line, projectDir) {
-  const regex = /at (.*?) \(?file:\/\/(\/.*?\.ts):(\d+):(\d+)\)?/;
-  const match = regex.exec(line);
-  if (!match) {
-    return;
-  }
-  const [_, identifier, path, lineNum, colNum] = match;
-  if (!path) {
-    return;
-  }
-  if (nodePath__default.default.basename(path) === "__entryPoint.ts") {
+var LINES_TO_IGNORE = [
+  /ConsoleInterceptor/,
+  /TriggerTracer/,
+  /TaskExecutor/,
+  /EXECUTE_TASK_RUN/,
+  /@trigger.dev\/core/,
+  /packages\/core\/src\/v3/,
+  /safeJsonProcess/,
+  /__entryPoint.ts/,
+  /ZodIpc/,
+  /startActiveSpan/,
+  /processTicksAndRejections/
+];
+function correctStackTraceLine(line, projectDir, isDev) {
+  if (LINES_TO_IGNORE.some((regex) => regex.test(line))) {
     return;
   }
-  if (projectDir && !path.includes(projectDir)) {
+  if (isDev && projectDir && !line.includes(projectDir)) {
     return;
   }
-  return line;
+  return line.trim();
 }
 __name(correctStackTraceLine, "correctStackTraceLine");
 function groupTaskMetadataIssuesByTask(tasks, issues) {
@@ -3190,335 +2845,363 @@ function groupTaskMetadataIssuesByTask(tasks, issues) {
 }
 __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;
+// 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;
   }
-  api[type] = instance;
-  return true;
-}
-__name(registerGlobal, "registerGlobal");
-function getGlobal(type) {
-  return _global[GLOBAL_TRIGGER_DOT_DEV_KEY]?.[type];
+  return newAttributes;
 }
-__name(getGlobal, "getGlobal");
-function unregisterGlobal(type) {
-  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY];
-  if (api) {
-    delete api[type];
+__name(imposeAttributeLimits, "imposeAttributeLimits");
+function calculateAttributeValueLength(value) {
+  if (value === void 0 || value === null) {
+    return 0;
   }
-}
-__name(unregisterGlobal, "unregisterGlobal");
-
-// src/v3/runtime/noopRuntimeManager.ts
-var _NoopRuntimeManager = class _NoopRuntimeManager {
-  disable() {
-  }
-  waitForDuration(ms) {
-    return Promise.resolve();
+  if (typeof value === "string") {
+    return value.length;
   }
-  waitUntil(date) {
-    return Promise.resolve();
+  if (typeof value === "number") {
+    return 8;
   }
-  waitForTask(params) {
-    return Promise.resolve({
-      ok: false,
-      id: params.id,
-      error: {
-        type: "INTERNAL_ERROR",
-        code: "CONFIGURED_INCORRECTLY"
-      }
-    });
+  if (typeof value === "boolean") {
+    return 4;
   }
-  waitForBatch(params) {
-    return Promise.resolve({
-      id: params.id,
-      items: []
-    });
+  if (Array.isArray(value)) {
+    return value.reduce((acc, v) => acc + calculateAttributeValueLength(v), 0);
   }
-};
-__name(_NoopRuntimeManager, "NoopRuntimeManager");
-var NoopRuntimeManager = _NoopRuntimeManager;
+  return 0;
+}
+__name(calculateAttributeValueLength, "calculateAttributeValueLength");
 
-// src/v3/runtime/index.ts
-var API_NAME = "runtime";
-var NOOP_RUNTIME_MANAGER = new NoopRuntimeManager();
-var _getRuntimeManager, getRuntimeManager_fn;
-var _RuntimeAPI = class _RuntimeAPI {
-  constructor() {
-    __privateAdd(this, _getRuntimeManager);
+// src/v3/utils/flattenAttributes.ts
+var NULL_SENTINEL = "$@null((";
+function flattenAttributes(obj, prefix) {
+  const result = {};
+  if (obj === void 0) {
+    return result;
   }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _RuntimeAPI();
+  if (obj === null) {
+    result[prefix || ""] = NULL_SENTINEL;
+    return result;
+  }
+  if (typeof obj === "string") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "number") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "boolean") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const newPrefix = `${prefix ? `${prefix}.` : ""}${Array.isArray(obj) ? `[${key}]` : key}`;
+    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}]`));
+        } else {
+          if (value[i] === null) {
+            result[`${newPrefix}.[${i}]`] = NULL_SENTINEL;
+          } else {
+            result[`${newPrefix}.[${i}]`] = value[i];
+          }
+        }
+      }
+    } else if (isRecord(value)) {
+      Object.assign(result, flattenAttributes(value, newPrefix));
+    } else {
+      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+        result[newPrefix] = value;
+      } else if (value === null) {
+        result[newPrefix] = NULL_SENTINEL;
+      }
     }
-    return this._instance;
   }
-  waitForDuration(ms) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForDuration(ms);
+  return result;
+}
+__name(flattenAttributes, "flattenAttributes");
+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;
   }
-  waitUntil(date) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitUntil(date);
+  if (typeof obj === "object" && obj !== null && Object.keys(obj).length === 1 && Object.keys(obj)[0] === "") {
+    return rehydrateNull(obj[""]);
   }
-  waitForTask(params) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForTask(params);
+  if (Object.keys(obj).length === 0) {
+    return;
   }
-  waitForBatch(params) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForBatch(params);
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const parts = key.split(".").reduce((acc, part) => {
+      if (part.includes("[")) {
+        const subparts = part.split(/\[|\]/).filter((p) => p !== "");
+        acc.push(...subparts);
+      } else {
+        acc.push(part);
+      }
+      return acc;
+    }, []);
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      const nextPart = parts[i + 1];
+      const isArray = /^\d+$/.test(nextPart);
+      if (isArray && !Array.isArray(current[part])) {
+        current[part] = [];
+      } else if (!isArray && current[part] === void 0) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    const lastPart = parts[parts.length - 1];
+    current[lastPart] = rehydrateNull(value);
   }
-  setGlobalRuntimeManager(runtimeManager) {
-    return registerGlobal(API_NAME, runtimeManager);
+  if (Object.keys(result).every((k) => /^\d+$/.test(k))) {
+    const maxIndex = Math.max(...Object.keys(result).map((k) => parseInt(k)));
+    const arrayResult = Array(maxIndex + 1);
+    for (const key in result) {
+      arrayResult[parseInt(key)] = result[key];
+    }
+    return arrayResult;
   }
-  disable() {
-    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
-    unregisterGlobal(API_NAME);
+  return result;
+}
+__name(unflattenAttributes, "unflattenAttributes");
+function primitiveValueOrflattenedAttributes(obj, prefix) {
+  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || obj === void 0) {
+    return obj;
   }
-};
-_getRuntimeManager = new WeakSet();
-getRuntimeManager_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME) ?? NOOP_RUNTIME_MANAGER;
-}, "#getRuntimeManager");
-__name(_RuntimeAPI, "RuntimeAPI");
-var RuntimeAPI = _RuntimeAPI;
-
-// src/v3/runtime-api.ts
-var runtime = RuntimeAPI.getInstance();
-function iconStringForSeverity(severityNumber) {
-  switch (severityNumber) {
-    case apiLogs.SeverityNumber.UNSPECIFIED:
-      return void 0;
-    case apiLogs.SeverityNumber.TRACE:
-    case apiLogs.SeverityNumber.TRACE2:
-    case apiLogs.SeverityNumber.TRACE3:
-    case apiLogs.SeverityNumber.TRACE4:
-      return "trace";
-    case apiLogs.SeverityNumber.DEBUG:
-    case apiLogs.SeverityNumber.DEBUG2:
-    case apiLogs.SeverityNumber.DEBUG3:
-    case apiLogs.SeverityNumber.DEBUG4:
-      return "debug";
-    case apiLogs.SeverityNumber.INFO:
-    case apiLogs.SeverityNumber.INFO2:
-    case apiLogs.SeverityNumber.INFO3:
-    case apiLogs.SeverityNumber.INFO4:
-      return "info";
-    case apiLogs.SeverityNumber.WARN:
-    case apiLogs.SeverityNumber.WARN2:
-    case apiLogs.SeverityNumber.WARN3:
-    case apiLogs.SeverityNumber.WARN4:
-      return "warn";
-    case apiLogs.SeverityNumber.ERROR:
-    case apiLogs.SeverityNumber.ERROR2:
-    case apiLogs.SeverityNumber.ERROR3:
-    case apiLogs.SeverityNumber.ERROR4:
-      return "error";
-    case apiLogs.SeverityNumber.FATAL:
-    case apiLogs.SeverityNumber.FATAL2:
-    case apiLogs.SeverityNumber.FATAL3:
-    case apiLogs.SeverityNumber.FATAL4:
-      return "fatal";
+  const attributes = flattenAttributes(obj, prefix);
+  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
+    return attributes[prefix];
   }
+  return attributes;
 }
-__name(iconStringForSeverity, "iconStringForSeverity");
-var _SimpleClock = class _SimpleClock {
-  preciseNow() {
-    const now = new preciseDate.PreciseDate();
-    const nowStruct = now.toStruct();
-    return [
-      nowStruct.seconds,
-      nowStruct.nanos
-    ];
+__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
+function rehydrateNull(value) {
+  if (value === NULL_SENTINEL) {
+    return null;
   }
-  reset() {
+  return value;
+}
+__name(rehydrateNull, "rehydrateNull");
+
+// src/v3/logger/taskLogger.ts
+var _NoopTaskLogger = class _NoopTaskLogger {
+  debug() {
+  }
+  log() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+  trace(name, fn) {
+    return fn({});
   }
 };
-__name(_SimpleClock, "SimpleClock");
-var SimpleClock = _SimpleClock;
+__name(_NoopTaskLogger, "NoopTaskLogger");
+var NoopTaskLogger = _NoopTaskLogger;
 
-// src/v3/clock/index.ts
-var API_NAME2 = "clock";
-var SIMPLE_CLOCK = new SimpleClock();
-var _getClock, getClock_fn;
-var _ClockAPI = class _ClockAPI {
+// src/v3/logger/index.ts
+var API_NAME3 = "logger";
+var NOOP_TASK_LOGGER = new NoopTaskLogger();
+var _getTaskLogger, getTaskLogger_fn;
+var _LoggerAPI = class _LoggerAPI {
   constructor() {
-    __privateAdd(this, _getClock);
+    __privateAdd(this, _getTaskLogger);
   }
   static getInstance() {
     if (!this._instance) {
-      this._instance = new _ClockAPI();
+      this._instance = new _LoggerAPI();
     }
     return this._instance;
   }
-  setGlobalClock(clock2) {
-    return registerGlobal(API_NAME2, clock2);
+  disable() {
+    unregisterGlobal(API_NAME3);
   }
-  preciseNow() {
-    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
+  setGlobalTaskLogger(taskLogger) {
+    return registerGlobal(API_NAME3, taskLogger);
   }
-  reset() {
-    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
+  debug(message, metadata) {
+    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).debug(message, metadata);
+  }
+  log(message, metadata) {
+    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).log(message, metadata);
+  }
+  info(message, metadata) {
+    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).info(message, metadata);
+  }
+  warn(message, metadata) {
+    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).warn(message, metadata);
+  }
+  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);
   }
 };
-_getClock = new WeakSet();
-getClock_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME2) ?? SIMPLE_CLOCK;
-}, "#getClock");
-__name(_ClockAPI, "ClockAPI");
-var ClockAPI = _ClockAPI;
+_getTaskLogger = new WeakSet();
+getTaskLogger_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME3) ?? NOOP_TASK_LOGGER;
+}, "#getTaskLogger");
+__name(_LoggerAPI, "LoggerAPI");
+var LoggerAPI = _LoggerAPI;
 
-// src/v3/clock-api.ts
-var clock = ClockAPI.getInstance();
+// src/v3/logger-api.ts
+var logger = LoggerAPI.getInstance();
 
-// src/v3/logger/taskLogger.ts
-var logLevels = [
-  "none",
-  "error",
-  "warn",
-  "log",
-  "info",
-  "debug"
-];
-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);
+// src/v3/runtime/noopRuntimeManager.ts
+var _NoopRuntimeManager = class _NoopRuntimeManager {
+  disable() {
   }
-  debug(message, properties) {
-    if (this._level < 5)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "debug", apiLogs.SeverityNumber.DEBUG, properties);
+  waitForDuration(ms) {
+    return Promise.resolve();
   }
-  log(message, properties) {
-    if (this._level < 3)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "log", apiLogs.SeverityNumber.INFO, properties);
+  waitUntil(date) {
+    return Promise.resolve();
   }
-  info(message, properties) {
-    if (this._level < 4)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "info", apiLogs.SeverityNumber.INFO, properties);
+  waitForTask(params) {
+    return Promise.resolve({
+      ok: false,
+      id: params.id,
+      error: {
+        type: "INTERNAL_ERROR",
+        code: "CONFIGURED_INCORRECTLY"
+      }
+    });
   }
-  warn(message, properties) {
-    if (this._level < 2)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "warn", apiLogs.SeverityNumber.WARN, properties);
+  waitForBatch(params) {
+    return Promise.resolve({
+      id: params.id,
+      items: []
+    });
   }
-  error(message, properties) {
-    if (this._level < 1)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "error", apiLogs.SeverityNumber.ERROR, properties);
+};
+__name(_NoopRuntimeManager, "NoopRuntimeManager");
+var NoopRuntimeManager = _NoopRuntimeManager;
+
+// src/v3/runtime/index.ts
+var API_NAME4 = "runtime";
+var NOOP_RUNTIME_MANAGER = new NoopRuntimeManager();
+var _getRuntimeManager, getRuntimeManager_fn;
+var _RuntimeAPI = class _RuntimeAPI {
+  constructor() {
+    __privateAdd(this, _getRuntimeManager);
   }
-  trace(name, fn, options) {
-    return this._config.tracer.startActiveSpan(name, fn, options);
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _RuntimeAPI();
+    }
+    return this._instance;
   }
-};
-_emitLog = new WeakSet();
-emitLog_fn = /* @__PURE__ */ __name(function(message, timestamp, severityText, severityNumber, properties) {
-  let attributes = {
-    ...flattenAttributes(safeJsonProcess(properties))
-  };
-  const icon = iconStringForSeverity(severityNumber);
-  if (icon !== void 0) {
-    attributes[SemanticInternalAttributes.STYLE_ICON] = icon;
-  }
-  this._config.logger.emit({
-    severityNumber,
-    severityText,
-    body: message,
-    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 {
-  debug() {
+  waitForDuration(ms) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForDuration(ms);
   }
-  log() {
+  waitUntil(date) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitUntil(date);
   }
-  info() {
+  waitForTask(params) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForTask(params);
   }
-  warn() {
+  waitForBatch(params) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForBatch(params);
   }
-  error() {
+  setGlobalRuntimeManager(runtimeManager) {
+    return registerGlobal(API_NAME4, runtimeManager);
   }
-  trace(name, fn) {
-    return fn({});
+  disable() {
+    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
+    unregisterGlobal(API_NAME4);
   }
 };
-__name(_NoopTaskLogger, "NoopTaskLogger");
-var NoopTaskLogger = _NoopTaskLogger;
-function safeJsonProcess(value) {
-  try {
-    return JSON.parse(JSON.stringify(value));
-  } catch {
-    return value;
+_getRuntimeManager = new WeakSet();
+getRuntimeManager_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME4) ?? NOOP_RUNTIME_MANAGER;
+}, "#getRuntimeManager");
+__name(_RuntimeAPI, "RuntimeAPI");
+var RuntimeAPI = _RuntimeAPI;
+
+// src/v3/runtime-api.ts
+var runtime = RuntimeAPI.getInstance();
+
+// src/v3/utils/getEnv.ts
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && typeof process.env === "object" && process.env !== null) {
+    return process.env[name];
   }
 }
-__name(safeJsonProcess, "safeJsonProcess");
+__name(getEnvVar, "getEnvVar");
 
-// src/v3/logger/index.ts
-var API_NAME3 = "logger";
-var NOOP_TASK_LOGGER = new NoopTaskLogger();
-var _getTaskLogger, getTaskLogger_fn;
-var _LoggerAPI = class _LoggerAPI {
+// src/v3/apiClientManager/index.ts
+var API_NAME5 = "api-client";
+var _getConfig, getConfig_fn;
+var _APIClientManagerAPI = class _APIClientManagerAPI {
   constructor() {
-    __privateAdd(this, _getTaskLogger);
+    __privateAdd(this, _getConfig);
   }
   static getInstance() {
     if (!this._instance) {
-      this._instance = new _LoggerAPI();
+      this._instance = new _APIClientManagerAPI();
     }
     return this._instance;
   }
   disable() {
-    unregisterGlobal(API_NAME3);
-  }
-  setGlobalTaskLogger(taskLogger) {
-    return registerGlobal(API_NAME3, taskLogger);
+    unregisterGlobal(API_NAME5);
   }
-  debug(message, metadata) {
-    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).debug(message, metadata);
-  }
-  log(message, metadata) {
-    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).log(message, metadata);
-  }
-  info(message, metadata) {
-    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).info(message, metadata);
+  setGlobalAPIClientConfiguration(config) {
+    return registerGlobal(API_NAME5, config);
   }
-  warn(message, metadata) {
-    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).warn(message, metadata);
+  get baseURL() {
+    const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
+    return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
   }
-  error(message, metadata) {
-    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).error(message, metadata);
+  get accessToken() {
+    const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
+    return store?.secretKey ?? getEnvVar("TRIGGER_SECRET_KEY") ?? getEnvVar("TRIGGER_ACCESS_TOKEN");
   }
-  trace(name, fn) {
-    return __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).trace(name, fn);
+  get client() {
+    if (!this.baseURL || !this.accessToken) {
+      return void 0;
+    }
+    return new ApiClient(this.baseURL, this.accessToken);
   }
 };
-_getTaskLogger = new WeakSet();
-getTaskLogger_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME3) ?? NOOP_TASK_LOGGER;
-}, "#getTaskLogger");
-__name(_LoggerAPI, "LoggerAPI");
-var LoggerAPI = _LoggerAPI;
+_getConfig = new WeakSet();
+getConfig_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME5);
+}, "#getConfig");
+__name(_APIClientManagerAPI, "APIClientManagerAPI");
+var APIClientManagerAPI = _APIClientManagerAPI;
 
-// src/v3/logger-api.ts
-var logger = LoggerAPI.getInstance();
+// src/v3/apiClientManager-api.ts
+var apiClientManager = APIClientManagerAPI.getInstance();
 
 // src/v3/task-catalog/noopTaskCatalog.ts
 var _NoopTaskCatalog = class _NoopTaskCatalog {
@@ -3537,6 +3220,9 @@ var _NoopTaskCatalog = class _NoopTaskCatalog {
   getTask(id) {
     return void 0;
   }
+  taskExists(id) {
+    return false;
+  }
   disable() {
   }
 };
@@ -3544,7 +3230,7 @@ __name(_NoopTaskCatalog, "NoopTaskCatalog");
 var NoopTaskCatalog = _NoopTaskCatalog;
 
 // src/v3/task-catalog/index.ts
-var API_NAME4 = "task-catalog";
+var API_NAME6 = "task-catalog";
 var NOOP_TASK_CATALOG = new NoopTaskCatalog();
 var _getCatalog, getCatalog_fn;
 var _TaskCatalogAPI = class _TaskCatalogAPI {
@@ -3558,10 +3244,10 @@ var _TaskCatalogAPI = class _TaskCatalogAPI {
     return this._instance;
   }
   setGlobalTaskCatalog(taskCatalog2) {
-    return registerGlobal(API_NAME4, taskCatalog2);
+    return registerGlobal(API_NAME6, taskCatalog2);
   }
   disable() {
-    unregisterGlobal(API_NAME4);
+    unregisterGlobal(API_NAME6);
   }
   registerTaskMetadata(task) {
     __privateMethod(this, _getCatalog, getCatalog_fn).call(this).registerTaskMetadata(task);
@@ -3581,60 +3267,19 @@ var _TaskCatalogAPI = class _TaskCatalogAPI {
   getTask(id) {
     return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).getTask(id);
   }
+  taskExists(id) {
+    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).taskExists(id);
+  }
 };
 _getCatalog = new WeakSet();
 getCatalog_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME4) ?? NOOP_TASK_CATALOG;
+  return getGlobal(API_NAME6) ?? NOOP_TASK_CATALOG;
 }, "#getCatalog");
 __name(_TaskCatalogAPI, "TaskCatalogAPI");
 var TaskCatalogAPI = _TaskCatalogAPI;
 
 // src/v3/task-catalog-api.ts
 var taskCatalog = TaskCatalogAPI.getInstance();
-
-// 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());
 }
@@ -3654,291 +3299,61 @@ function millisecondsToNanoseconds(milliseconds) {
   return milliseconds * 1e6;
 }
 __name(millisecondsToNanoseconds, "millisecondsToNanoseconds");
-function formatDurationNanoseconds(nanoseconds, options) {
-  return formatDurationMilliseconds(nanosecondsToMilliseconds(nanoseconds), options);
-}
-__name(formatDurationNanoseconds, "formatDurationNanoseconds");
-var aboveOneSecondUnits = [
-  "d",
-  "h",
-  "m",
-  "s"
-];
-var belowOneSecondUnits = [
-  "ms"
-];
-function formatDurationMilliseconds(milliseconds, options) {
-  let duration = humanizeDuration__default.default(milliseconds, {
-    units: options?.units ? options.units : milliseconds < 1e3 ? belowOneSecondUnits : aboveOneSecondUnits,
-    maxDecimalPoints: options?.maxDecimalPoints ?? 1,
-    largest: 2
-  });
-  if (!options) {
-    return duration;
-  }
-  switch (options.style) {
-    case "short":
-      duration = duration.replace(" milliseconds", "ms");
-      duration = duration.replace(" millisecond", "ms");
-      duration = duration.replace(" seconds", "s");
-      duration = duration.replace(" second", "s");
-      duration = duration.replace(" minutes", "m");
-      duration = duration.replace(" minute", "m");
-      duration = duration.replace(" hours", "h");
-      duration = duration.replace(" hour", "h");
-      duration = duration.replace(" days", "d");
-      duration = duration.replace(" day", "d");
-      duration = duration.replace(" weeks", "w");
-      duration = duration.replace(" week", "w");
-      duration = duration.replace(" months", "mo");
-      duration = duration.replace(" month", "mo");
-      duration = duration.replace(" years", "y");
-      duration = duration.replace(" year", "y");
-  }
-  return duration;
-}
-__name(formatDurationMilliseconds, "formatDurationMilliseconds");
-function formatDurationInDays(milliseconds) {
-  let duration = humanizeDuration__default.default(milliseconds, {
-    maxDecimalPoints: 0,
-    largest: 2,
-    units: [
-      "d"
-    ]
-  });
-  return duration;
-}
-__name(formatDurationInDays, "formatDurationInDays");
-async function unboundedTimeout(delay = 0, value, options) {
-  const maxDelay = 2147483647;
-  const fullTimeouts = Math.floor(delay / maxDelay);
-  const remainingDelay = delay % maxDelay;
-  let lastTimeoutResult = await promises.setTimeout(remainingDelay, value, options);
-  for (let i = 0; i < fullTimeouts; i++) {
-    lastTimeoutResult = await promises.setTimeout(maxDelay, value, options);
-  }
-  return lastTimeoutResult;
-}
-__name(unboundedTimeout, "unboundedTimeout");
-
-// src/v3/runtime/devRuntimeManager.ts
-var _DevRuntimeManager = class _DevRuntimeManager {
-  constructor() {
-    __publicField(this, "_taskWaits", /* @__PURE__ */ new Map());
-    __publicField(this, "_batchWaits", /* @__PURE__ */ new Map());
-    __publicField(this, "_pendingCompletionNotifications", /* @__PURE__ */ new Map());
-  }
-  disable() {
-  }
-  async waitForDuration(ms) {
-    await unboundedTimeout(ms);
-  }
-  async waitUntil(date) {
-    return this.waitForDuration(date.getTime() - Date.now());
-  }
-  async waitForTask(params) {
-    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
-        });
-      });
-    }));
-    const results = await promise;
-    return {
-      id: params.id,
-      items: results
-    };
-  }
-  resumeTask(completion, execution) {
-    const wait = this._taskWaits.get(execution.run.id);
-    if (!wait) {
-      this._pendingCompletionNotifications.set(execution.run.id, completion);
-      return;
-    }
-    if (completion.ok) {
-      wait.resolve(completion);
-    } else {
-      wait.reject(completion);
-    }
-    this._taskWaits.delete(execution.run.id);
-  }
-};
-__name(_DevRuntimeManager, "DevRuntimeManager");
-var DevRuntimeManager = _DevRuntimeManager;
-
-// src/v3/runtime/prodRuntimeManager.ts
-var _ProdRuntimeManager = class _ProdRuntimeManager {
-  constructor(ipc, options = {}) {
-    this.ipc = ipc;
-    this.options = options;
-    this._taskWaits = /* @__PURE__ */ new Map();
-    this._batchWaits = /* @__PURE__ */ new Map();
-  }
-  disable() {
-  }
-  async waitForDuration(ms) {
-    const now = Date.now();
-    const resolveAfterDuration = unboundedTimeout(ms, "duration");
-    if (ms <= this.waitThresholdInMs) {
-      await resolveAfterDuration;
-      return;
-    }
-    const waitForRestore = new Promise((resolve, reject) => {
-      this._waitForRestore = {
-        resolve,
-        reject
-      };
-    });
-    const { willCheckpointAndRestore } = await this.ipc.sendWithAck("WAIT_FOR_DURATION", {
-      ms,
-      now
-    });
-    if (!willCheckpointAndRestore) {
-      await resolveAfterDuration;
-      return;
-    }
-    this.ipc.send("READY_FOR_CHECKPOINT", {});
-    await Promise.race([
-      waitForRestore,
-      resolveAfterDuration
-    ]);
-    this.ipc.send("CANCEL_CHECKPOINT", {});
-  }
-  resumeAfterRestore() {
-    if (!this._waitForRestore) {
-      return;
-    }
-    clock.reset();
-    this._waitForRestore.resolve("restore");
-    this._waitForRestore = void 0;
-  }
-  async waitUntil(date) {
-    return this.waitForDuration(date.getTime() - Date.now());
-  }
-  async waitForTask(params) {
-    const promise = new Promise((resolve, reject) => {
-      this._taskWaits.set(params.id, {
-        resolve,
-        reject
-      });
-    });
-    await this.ipc.send("WAIT_FOR_TASK", {
-      friendlyId: params.id
-    });
-    return await promise;
-  }
-  async waitForBatch(params) {
-    if (!params.runs.length) {
-      return Promise.resolve({
-        id: params.id,
-        items: []
-      });
-    }
-    const promise = Promise.all(params.runs.map((runId) => {
-      return new Promise((resolve, reject) => {
-        this._taskWaits.set(runId, {
-          resolve,
-          reject
-        });
-      });
-    }));
-    await this.ipc.send("WAIT_FOR_BATCH", {
-      batchFriendlyId: params.id,
-      runFriendlyIds: params.runs
-    });
-    const results = await promise;
-    return {
-      id: params.id,
-      items: results
-    };
-  }
-  resumeTask(completion, execution) {
-    const wait = this._taskWaits.get(execution.run.id);
-    if (!wait) {
-      return;
-    }
-    if (completion.ok) {
-      wait.resolve(completion);
-    } else {
-      wait.reject(completion);
-    }
-    this._taskWaits.delete(execution.run.id);
-  }
-  get waitThresholdInMs() {
-    return this.options.waitThresholdInMs ?? 3e4;
-  }
-};
-__name(_ProdRuntimeManager, "ProdRuntimeManager");
-var ProdRuntimeManager = _ProdRuntimeManager;
-var _originClockTime, originClockTime_get, _originPreciseDate, originPreciseDate_get;
-var _PreciseWallClock = class _PreciseWallClock {
-  constructor(options = {}) {
-    __privateAdd(this, _originClockTime);
-    __privateAdd(this, _originPreciseDate);
-    this._origin = {
-      clockTime: options.origin ?? process.hrtime(),
-      preciseDate: options.now ?? new preciseDate.PreciseDate()
-    };
-  }
-  preciseNow() {
-    const elapsedHrTime = process.hrtime(__privateGet(this, _originClockTime, originClockTime_get));
-    const elapsedNanoseconds = BigInt(elapsedHrTime[0]) * BigInt(1e9) + BigInt(elapsedHrTime[1]);
-    const preciseDate$1 = new preciseDate.PreciseDate(__privateGet(this, _originPreciseDate, originPreciseDate_get).getFullTime() + elapsedNanoseconds);
-    const dateStruct = preciseDate$1.toStruct();
-    return [
-      dateStruct.seconds,
-      dateStruct.nanos
-    ];
+function formatDurationNanoseconds(nanoseconds, options) {
+  return formatDurationMilliseconds(nanosecondsToMilliseconds(nanoseconds), options);
+}
+__name(formatDurationNanoseconds, "formatDurationNanoseconds");
+var aboveOneSecondUnits = [
+  "d",
+  "h",
+  "m",
+  "s"
+];
+var belowOneSecondUnits = [
+  "ms"
+];
+function formatDurationMilliseconds(milliseconds, options) {
+  let duration = humanizeDuration__default.default(milliseconds, {
+    units: options?.units ? options.units : milliseconds < 1e3 ? belowOneSecondUnits : aboveOneSecondUnits,
+    maxDecimalPoints: options?.maxDecimalPoints ?? 1,
+    largest: 2
+  });
+  if (!options) {
+    return duration;
   }
-  reset() {
-    this._origin = {
-      clockTime: process.hrtime(),
-      preciseDate: new preciseDate.PreciseDate()
-    };
+  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");
   }
-};
-_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;
+  return duration;
+}
+__name(formatDurationMilliseconds, "formatDurationMilliseconds");
+function formatDurationInDays(milliseconds) {
+  let duration = humanizeDuration__default.default(milliseconds, {
+    maxDecimalPoints: 0,
+    largest: 2,
+    units: [
+      "d"
+    ]
+  });
+  return duration;
+}
+__name(formatDurationInDays, "formatDurationInDays");
 var _TriggerTracer = class _TriggerTracer {
   constructor(_config) {
     this._config = _config;
@@ -4010,146 +3425,6 @@ var _TriggerTracer = class _TriggerTracer {
 };
 __name(_TriggerTracer, "TriggerTracer");
 var TriggerTracer = _TriggerTracer;
-var _handleLog, handleLog_fn, _getTimestampInHrTime2, getTimestampInHrTime_fn2, _getAttributes, getAttributes_fn;
-var _ConsoleInterceptor = class _ConsoleInterceptor {
-  constructor(logger2, sendToStdIO) {
-    __privateAdd(this, _handleLog);
-    __privateAdd(this, _getTimestampInHrTime2);
-    __privateAdd(this, _getAttributes);
-    this.logger = logger2;
-    this.sendToStdIO = sendToStdIO;
-  }
-  // Intercept the console and send logs to the OpenTelemetry logger
-  // during the execution of the callback
-  async intercept(console2, callback) {
-    const originalConsole = {
-      log: console2.log,
-      info: console2.info,
-      warn: console2.warn,
-      error: console2.error,
-      debug: console2.debug
-    };
-    console2.log = this.log.bind(this);
-    console2.info = this.info.bind(this);
-    console2.warn = this.warn.bind(this);
-    console2.error = this.error.bind(this);
-    console2.debug = this.debug.bind(this);
-    try {
-      return await callback();
-    } finally {
-      console2.log = originalConsole.log;
-      console2.info = originalConsole.info;
-      console2.warn = originalConsole.warn;
-      console2.error = originalConsole.error;
-      console2.debug = originalConsole.debug;
-    }
-  }
-  debug(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.DEBUG, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Debug", ...args);
-  }
-  log(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Log", ...args);
-  }
-  info(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Info", ...args);
-  }
-  warn(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.WARN, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Warn", ...args);
-  }
-  error(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.ERROR, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Error", ...args);
-  }
-};
-_handleLog = new WeakSet();
-handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, timestamp, severityText, ...args) {
-  const body = util__default.default.format(...args);
-  if (this.sendToStdIO) {
-    if (severityNumber === apiLogs.SeverityNumber.ERROR) {
-      process.stderr.write(body);
-    } else {
-      process.stdout.write(body);
-    }
-  }
-  const parsed = tryParseJSON(body);
-  if (parsed.ok) {
-    this.logger.emit({
-      severityNumber,
-      severityText,
-      body: getLogMessage(parsed.value, severityText),
-      attributes: {
-        ...__privateMethod(this, _getAttributes, getAttributes_fn).call(this, severityNumber),
-        ...flattenAttributes(parsed.value)
-      },
-      timestamp
-    });
-    return;
-  }
-  this.logger.emit({
-    severityNumber,
-    severityText,
-    body,
-    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(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;
-function getLogMessage(value, fallback) {
-  if (typeof value["message"] === "string") {
-    return value["message"];
-  }
-  if (typeof value["msg"] === "string") {
-    return value["msg"];
-  }
-  if (typeof value["body"] === "string") {
-    return value["body"];
-  }
-  if (typeof value["error"] === "string") {
-    return value["error"];
-  }
-  return fallback;
-}
-__name(getLogMessage, "getLogMessage");
-function tryParseJSON(value) {
-  try {
-    const parsed = JSON.parse(value);
-    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-      return {
-        ok: true,
-        value: parsed
-      };
-    }
-    return {
-      ok: false,
-      value
-    };
-  } catch (e) {
-    return {
-      ok: false,
-      value
-    };
-  }
-}
-__name(tryParseJSON, "tryParseJSON");
-
-// src/v3/utils/styleAttributes.ts
-function accessoryAttributes(accessory) {
-  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
-}
-__name(accessoryAttributes, "accessoryAttributes");
 
 // src/eventFilterMatches.ts
 function eventFilterMatches(payload, filter) {
@@ -4319,150 +3594,18 @@ function omit(obj, ...keys) {
   return result;
 }
 __name(omit, "omit");
-var _a2;
-var AsyncResourceDetector = (_a2 = class {
-  constructor() {
-    __publicField(this, "_resolved", false);
-    this._promise = new Promise((resolver) => {
-      this._resolver = resolver;
-    });
-  }
-  detect(_config) {
-    return new resources.Resource({}, this._promise);
-  }
-  resolveWithAttributes(attributes) {
-    if (!this._resolver) {
-      throw new Error("Resolver not available");
-    }
-    if (this._resolved) {
-      return;
-    }
-    this._resolved = true;
-    this._resolver(attributes);
-  }
-}, __name(_a2, "AsyncResourceDetector"), _a2);
-var _TracingSDK = class _TracingSDK {
-  constructor(config) {
-    this.config = config;
-    this.asyncResourceDetector = new AsyncResourceDetector();
-    setLogLevel(config.diagLogLevel ?? "none");
-    const envResourceAttributesSerialized = getEnvVar("OTEL_RESOURCE_ATTRIBUTES");
-    const envResourceAttributes = envResourceAttributesSerialized ? JSON.parse(envResourceAttributesSerialized) : {};
-    const commonResources = resources.detectResourcesSync({
-      detectors: [
-        this.asyncResourceDetector,
-        resources.processDetectorSync
-      ]
-    }).merge(new resources.Resource({
-      [semanticConventions.SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev",
-      [SemanticInternalAttributes.TRIGGER]: true
-    })).merge(config.resource ?? new resources.Resource({})).merge(new resources.Resource(envResourceAttributes));
-    const traceProvider = new sdkTraceNode.NodeTracerProvider({
-      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500,
-      resource: commonResources,
-      spanLimits: {
-        attributeCountLimit: OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
-        attributeValueLengthLimit: OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT,
-        eventCountLimit: OTEL_SPAN_EVENT_COUNT_LIMIT,
-        attributePerEventCountLimit: OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
-        linkCountLimit: OTEL_LINK_COUNT_LIMIT,
-        attributePerLinkCountLimit: OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT
-      }
-    });
-    const spanExporter = new exporterTraceOtlpHttp.OTLPTraceExporter({
-      url: `${config.url}/v1/traces`,
-      timeoutMillis: config.forceFlushTimeoutMillis ?? 1e3
-    });
-    traceProvider.addSpanProcessor(new TaskContextSpanProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new sdkTraceNode.BatchSpanProcessor(spanExporter, {
-      maxExportBatchSize: parseInt(getEnvVar("OTEL_SPAN_MAX_EXPORT_BATCH_SIZE") ?? "64"),
-      scheduledDelayMillis: parseInt(getEnvVar("OTEL_SPAN_SCHEDULED_DELAY_MILLIS") ?? "200"),
-      exportTimeoutMillis: parseInt(getEnvVar("OTEL_SPAN_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
-      maxQueueSize: parseInt(getEnvVar("OTEL_SPAN_MAX_QUEUE_SIZE") ?? "512")
-    }) : new sdkTraceNode.SimpleSpanProcessor(spanExporter)));
-    traceProvider.register();
-    instrumentation.registerInstrumentations({
-      instrumentations: config.instrumentations ?? [],
-      tracerProvider: traceProvider
-    });
-    const logExporter = new exporterLogsOtlpHttp.OTLPLogExporter({
-      url: `${config.url}/v1/logs`
-    });
-    const loggerProvider = new sdkLogs.LoggerProvider({
-      resource: commonResources,
-      logRecordLimits: {
-        attributeCountLimit: OTEL_LOG_ATTRIBUTE_COUNT_LIMIT,
-        attributeValueLengthLimit: OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT
-      }
-    });
-    loggerProvider.addLogRecordProcessor(new TaskContextLogProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new sdkLogs.BatchLogRecordProcessor(logExporter, {
-      maxExportBatchSize: parseInt(getEnvVar("OTEL_LOG_MAX_EXPORT_BATCH_SIZE") ?? "64"),
-      scheduledDelayMillis: parseInt(getEnvVar("OTEL_LOG_SCHEDULED_DELAY_MILLIS") ?? "200"),
-      exportTimeoutMillis: parseInt(getEnvVar("OTEL_LOG_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
-      maxQueueSize: parseInt(getEnvVar("OTEL_LOG_MAX_QUEUE_SIZE") ?? "512")
-    }) : new sdkLogs.SimpleLogRecordProcessor(logExporter)));
-    this._logProvider = loggerProvider;
-    this._spanExporter = spanExporter;
-    this._traceProvider = traceProvider;
-    apiLogs.logs.setGlobalLoggerProvider(loggerProvider);
-    this.getLogger = loggerProvider.getLogger.bind(loggerProvider);
-    this.getTracer = traceProvider.getTracer.bind(traceProvider);
-  }
-  async flush() {
-    await this._traceProvider.forceFlush();
-    await this._logProvider.forceFlush();
-  }
-  async shutdown() {
-    await this._traceProvider.shutdown();
-    await this._logProvider.shutdown();
-  }
-};
-__name(_TracingSDK, "TracingSDK");
-var TracingSDK = _TracingSDK;
-function setLogLevel(level) {
-  let diagLogLevel;
-  switch (level) {
-    case "none":
-      diagLogLevel = api.DiagLogLevel.NONE;
-      break;
-    case "error":
-      diagLogLevel = api.DiagLogLevel.ERROR;
-      break;
-    case "warn":
-      diagLogLevel = api.DiagLogLevel.WARN;
-      break;
-    case "info":
-      diagLogLevel = api.DiagLogLevel.INFO;
-      break;
-    case "debug":
-      diagLogLevel = api.DiagLogLevel.DEBUG;
-      break;
-    case "verbose":
-      diagLogLevel = api.DiagLogLevel.VERBOSE;
-      break;
-    case "all":
-      diagLogLevel = api.DiagLogLevel.ALL;
-      break;
-    default:
-      diagLogLevel = api.DiagLogLevel.NONE;
-  }
-  api.diag.setLogger(new api.DiagConsoleLogger(), diagLogLevel);
+
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
 }
-__name(setLogLevel, "setLogLevel");
+__name(accessoryAttributes, "accessoryAttributes");
 
-// src/v3/otel/index.ts
-function recordSpanException(span, error) {
-  if (error instanceof Error) {
-    span.recordException(error);
-  } else if (typeof error === "string") {
-    span.recordException(new Error(error));
-  } else {
-    span.recordException(new Error(JSON.stringify(error)));
-  }
-  span.setStatus({
-    code: api.SpanStatusCode.ERROR
-  });
+// src/v3/utils/detectDependencyVersion.ts
+function detectDependencyVersion(dependency) {
+  return dependencies[dependency];
 }
-__name(recordSpanException, "recordSpanException");
+__name(detectDependencyVersion, "detectDependencyVersion");
 
 // src/v3/utils/ioSerialization.ts
 async function parsePacket(value) {
@@ -4622,11 +3765,12 @@ async function createPacketAttributes(packet, dataKey, dataTypeKey) {
       try {
         const parsed = parse(packet.data);
         const jsonified = JSON.parse(JSON.stringify(parsed, safeReplacer));
-        return {
+        const result = {
           ...flattenAttributes(jsonified, dataKey),
           [dataTypeKey]: "application/json"
         };
-      } catch {
+        return result;
+      } catch (e) {
         return;
       }
     case "application/store":
@@ -4732,378 +3876,10 @@ function safeJsonParse2(value) {
 }
 __name(safeJsonParse2, "safeJsonParse");
 
-// src/v3/workers/taskExecutor.ts
-var _callRun, callRun_fn, _callTaskInit, callTaskInit_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
-var _TaskExecutor = class _TaskExecutor {
-  constructor(task, options) {
-    __privateAdd(this, _callRun);
-    __privateAdd(this, _callTaskInit);
-    __privateAdd(this, _callTaskCleanup);
-    __privateAdd(this, _handleError);
-    this.task = task;
-    this._tracingSDK = options.tracingSDK;
-    this._tracer = options.tracer;
-    this._consoleInterceptor = options.consoleInterceptor;
-    this._config = options.projectConfig;
-    this._importedConfig = options.importedConfig;
-    this._handleErrorFn = options.handleErrorFn;
-  }
-  async execute(execution, worker, traceContext) {
-    const ctx = TaskRunContext.parse(execution);
-    const attemptMessage = `Attempt ${execution.attempt.number}`;
-    const originalPacket = {
-      data: execution.run.payload,
-      dataType: execution.run.payloadType
-    };
-    const result = await taskContextManager.runWith({
-      ctx,
-      worker
-    }, async () => {
-      this._tracingSDK.asyncResourceDetector.resolveWithAttributes({
-        ...taskContextManager.attributes,
-        [SemanticInternalAttributes.SDK_VERSION]: this.task.packageVersion,
-        [SemanticInternalAttributes.SDK_LANGUAGE]: "typescript"
-      });
-      return await this._tracer.startActiveSpan(attemptMessage, async (span) => {
-        return await this._consoleInterceptor.intercept(console, async () => {
-          let parsedPayload;
-          let initOutput;
-          try {
-            const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
-            parsedPayload = await parsePacket(payloadPacket);
-            initOutput = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
-            const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
-            try {
-              const stringifiedOutput = await stringifyIO(output);
-              const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
-              const attributes = await createPacketAttributes(finalOutput, SemanticInternalAttributes.OUTPUT, SemanticInternalAttributes.OUTPUT_TYPE);
-              if (attributes) {
-                span.setAttributes(attributes);
-              }
-              return {
-                ok: true,
-                id: execution.attempt.id,
-                output: finalOutput.data,
-                outputType: finalOutput.dataType
-              };
-            } catch (stringifyError) {
-              recordSpanException(span, stringifyError);
-              return {
-                ok: false,
-                id: execution.attempt.id,
-                error: {
-                  type: "INTERNAL_ERROR",
-                  code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
-                  message: stringifyError instanceof Error ? stringifyError.message : typeof stringifyError === "string" ? stringifyError : void 0
-                }
-              };
-            }
-          } catch (runError) {
-            try {
-              const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
-              recordSpanException(span, handleErrorResult.error ?? runError);
-              return {
-                id: execution.attempt.id,
-                ok: false,
-                error: handleErrorResult.error ? parseError(handleErrorResult.error) : parseError(runError),
-                retry: handleErrorResult.status === "retry" ? handleErrorResult.retry : void 0,
-                skippedRetrying: handleErrorResult.status === "skipped"
-              };
-            } catch (handleErrorError) {
-              recordSpanException(span, handleErrorError);
-              return {
-                ok: false,
-                id: execution.attempt.id,
-                error: {
-                  type: "INTERNAL_ERROR",
-                  code: TaskRunErrorCodes.HANDLE_ERROR_ERROR,
-                  message: handleErrorError instanceof Error ? handleErrorError.message : typeof handleErrorError === "string" ? handleErrorError : void 0
-                }
-              };
-            }
-          } finally {
-            await __privateMethod(this, _callTaskCleanup, callTaskCleanup_fn).call(this, parsedPayload, ctx, initOutput);
-          }
-        });
-      }, {
-        kind: api.SpanKind.CONSUMER,
-        attributes: {
-          [SemanticInternalAttributes.STYLE_ICON]: "attempt",
-          ...accessoryAttributes({
-            items: [
-              {
-                text: ctx.task.filePath
-              },
-              {
-                text: `${ctx.task.exportName}.run()`
-              }
-            ],
-            style: "codepath"
-          })
-        }
-      }, this._tracer.extractContext(traceContext));
-    });
-    return result;
-  }
-};
-_callRun = new WeakSet();
-callRun_fn = /* @__PURE__ */ __name(async function(payload, ctx, init) {
-  const runFn = this.task.fns.run;
-  const middlewareFn = this.task.fns.middleware;
-  if (!runFn) {
-    throw new Error("Task does not have a run function");
-  }
-  if (!middlewareFn) {
-    return runFn(payload, {
-      ctx
-    });
-  }
-  return middlewareFn(payload, {
-    ctx,
-    next: async () => runFn(payload, {
-      ctx,
-      init
-    })
-  });
-}, "#callRun");
-_callTaskInit = new WeakSet();
-callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
-  const initFn = this.task.fns.init;
-  if (!initFn) {
-    return {};
-  }
-  return this._tracer.startActiveSpan("init", async (span) => {
-    return await initFn(payload1, {
-      ctx: ctx1
-    });
-  });
-}, "#callTaskInit");
-_callTaskCleanup = new WeakSet();
-callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload2, ctx2, init1) {
-  const cleanupFn = this.task.fns.cleanup;
-  if (!cleanupFn) {
-    return;
-  }
-  return this._tracer.startActiveSpan("cleanup", async (span) => {
-    return await cleanupFn(payload2, {
-      ctx: ctx2,
-      init: init1
-    });
-  });
-}, "#callTaskCleanup");
-_handleError = new WeakSet();
-handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload3, ctx3) {
-  const retriesConfig = this._importedConfig?.retries ?? this._config.retries;
-  const retry = this.task.retry ?? retriesConfig?.default;
-  if (!retry) {
-    return {
-      status: "noop"
-    };
-  }
-  const delay = calculateNextRetryDelay(retry, execution.attempt.number);
-  if (execution.environment.type === "DEVELOPMENT" && typeof retriesConfig?.enabledInDev === "boolean" && !retriesConfig.enabledInDev) {
-    return {
-      status: "skipped"
-    };
-  }
-  return this._tracer.startActiveSpan("handleError()", async (span) => {
-    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload3, error, {
-      ctx: ctx3,
-      retry,
-      retryDelayInMs: delay,
-      retryAt: delay ? new Date(Date.now() + delay) : void 0
-    }) : this._importedConfig ? await this._handleErrorFn?.(payload3, error, {
-      ctx: ctx3,
-      retry,
-      retryDelayInMs: delay,
-      retryAt: delay ? new Date(Date.now() + delay) : void 0
-    }) : void 0;
-    if (!handleErrorResult) {
-      return typeof delay === "undefined" ? {
-        status: "noop"
-      } : {
-        status: "retry",
-        retry: {
-          timestamp: Date.now() + delay,
-          delay
-        }
-      };
-    }
-    if (handleErrorResult.skipRetrying) {
-      return {
-        status: "skipped",
-        error: handleErrorResult.error
-      };
-    }
-    if (typeof handleErrorResult.retryAt !== "undefined") {
-      return {
-        status: "retry",
-        retry: {
-          timestamp: handleErrorResult.retryAt.getTime(),
-          delay: handleErrorResult.retryAt.getTime() - Date.now()
-        },
-        error: handleErrorResult.error
-      };
-    }
-    if (typeof handleErrorResult.retryDelayInMs === "number") {
-      return {
-        status: "retry",
-        retry: {
-          timestamp: Date.now() + handleErrorResult.retryDelayInMs,
-          delay: handleErrorResult.retryDelayInMs
-        },
-        error: handleErrorResult.error
-      };
-    }
-    if (handleErrorResult.retry && typeof handleErrorResult.retry === "object") {
-      const delay2 = calculateNextRetryDelay(handleErrorResult.retry, execution.attempt.number);
-      return typeof delay2 === "undefined" ? {
-        status: "noop",
-        error: handleErrorResult.error
-      } : {
-        status: "retry",
-        retry: {
-          timestamp: Date.now() + delay2,
-          delay: delay2
-        },
-        error: handleErrorResult.error
-      };
-    }
-    return {
-      status: "noop",
-      error: handleErrorResult.error
-    };
-  }, {
-    attributes: {
-      [SemanticInternalAttributes.STYLE_ICON]: "exclamation-circle"
-    }
-  });
-}, "#handleError");
-__name(_TaskExecutor, "TaskExecutor");
-var TaskExecutor = _TaskExecutor;
-
-// package.json
-var dependencies = {
-  "@google-cloud/precise-date": "^4.0.0",
-  "@opentelemetry/api": "^1.8.0",
-  "@opentelemetry/api-logs": "^0.48.0",
-  "@opentelemetry/exporter-logs-otlp-http": "^0.49.1",
-  "@opentelemetry/exporter-trace-otlp-http": "^0.49.1",
-  "@opentelemetry/instrumentation": "^0.49.1",
-  "@opentelemetry/resources": "^1.22.0",
-  "@opentelemetry/sdk-logs": "^0.49.1",
-  "@opentelemetry/sdk-node": "^0.49.1",
-  "@opentelemetry/sdk-trace-base": "^1.22.0",
-  "@opentelemetry/sdk-trace-node": "^1.22.0",
-  "@opentelemetry/semantic-conventions": "^1.22.0",
-  "humanize-duration": "^3.27.3",
-  "socket.io": "^4.7.4",
-  "socket.io-client": "^4.7.4",
-  superjson: "^2.2.1",
-  ulidx: "^2.2.1",
-  zod: "3.22.3",
-  "zod-error": "1.5.0",
-  "zod-validation-error": "^1.5.0"
-};
-
-// src/v3/utils/detectDependencyVersion.ts
-function detectDependencyVersion(dependency) {
-  return dependencies[dependency];
-}
-__name(detectDependencyVersion, "detectDependencyVersion");
-
-// src/v3/task-catalog/standardTaskCatalog.ts
-var _StandardTaskCatalog = class _StandardTaskCatalog {
-  constructor() {
-    __publicField(this, "_taskMetadata", /* @__PURE__ */ new Map());
-    __publicField(this, "_taskFunctions", /* @__PURE__ */ new Map());
-    __publicField(this, "_taskFileMetadata", /* @__PURE__ */ new Map());
-  }
-  registerTaskMetadata(task) {
-    const { fns, ...metadata } = task;
-    this._taskMetadata.set(task.id, metadata);
-    this._taskFunctions.set(task.id, fns);
-  }
-  updateTaskMetadata(id, updates) {
-    const existingMetadata = this._taskMetadata.get(id);
-    if (existingMetadata) {
-      this._taskMetadata.set(id, {
-        ...existingMetadata,
-        ...updates
-      });
-    }
-    if (updates.fns) {
-      const existingFunctions = this._taskFunctions.get(id);
-      if (existingFunctions) {
-        this._taskFunctions.set(id, {
-          ...existingFunctions,
-          ...updates.fns
-        });
-      }
-    }
-  }
-  registerTaskFileMetadata(id, metadata) {
-    this._taskFileMetadata.set(id, metadata);
-  }
-  // Return all the tasks, without the functions
-  getAllTaskMetadata() {
-    const result = [];
-    for (const [id, metadata] of this._taskMetadata) {
-      const fileMetadata = this._taskFileMetadata.get(id);
-      if (!fileMetadata) {
-        continue;
-      }
-      result.push({
-        ...metadata,
-        ...fileMetadata
-      });
-    }
-    return result;
-  }
-  getTaskMetadata(id) {
-    const metadata = this._taskMetadata.get(id);
-    const fileMetadata = this._taskFileMetadata.get(id);
-    if (!metadata || !fileMetadata) {
-      return void 0;
-    }
-    return {
-      ...metadata,
-      ...fileMetadata
-    };
-  }
-  getTask(id) {
-    const metadata = this._taskMetadata.get(id);
-    const fileMetadata = this._taskFileMetadata.get(id);
-    const fns = this._taskFunctions.get(id);
-    if (!metadata || !fns || !fileMetadata) {
-      return void 0;
-    }
-    return {
-      ...metadata,
-      ...fileMetadata,
-      fns
-    };
-  }
-  disable() {
-  }
-};
-__name(_StandardTaskCatalog, "StandardTaskCatalog");
-var StandardTaskCatalog = _StandardTaskCatalog;
-
-// src/v3/index.ts
-function parseTriggerTaskRequestBody(body) {
-  return TriggerTaskRequestBody.safeParse(body);
-}
-__name(parseTriggerTaskRequestBody, "parseTriggerTaskRequestBody");
-function parseBatchTriggerTaskRequestBody(body) {
-  return BatchTriggerTaskRequestBody.safeParse(body);
-}
-__name(parseBatchTriggerTaskRequestBody, "parseBatchTriggerTaskRequestBody");
-
 exports.APIConnectionError = APIConnectionError;
 exports.APIError = APIError;
 exports.ApiClient = ApiClient;
-exports.ApiClientManager = ApiClientManager;
+exports.AttemptStatus = AttemptStatus;
 exports.AuthenticationError = AuthenticationError;
 exports.BackgroundWorkerClientMessages = BackgroundWorkerClientMessages;
 exports.BackgroundWorkerMetadata = BackgroundWorkerMetadata;
@@ -5118,19 +3894,21 @@ exports.CancellationSpanEvent = CancellationSpanEvent;
 exports.ClientToSharedQueueMessages = ClientToSharedQueueMessages;
 exports.Config = Config;
 exports.ConflictError = ConflictError;
-exports.ConsoleInterceptor = ConsoleInterceptor;
 exports.CoordinatorToPlatformMessages = CoordinatorToPlatformMessages;
 exports.CoordinatorToProdWorkerMessages = CoordinatorToProdWorkerMessages;
 exports.CreateAuthorizationCodeResponseSchema = CreateAuthorizationCodeResponseSchema;
 exports.CreateBackgroundWorkerRequestBody = CreateBackgroundWorkerRequestBody;
 exports.CreateBackgroundWorkerResponse = CreateBackgroundWorkerResponse;
+exports.CreateEnvironmentVariableRequestBody = CreateEnvironmentVariableRequestBody;
 exports.CreateScheduleOptions = CreateScheduleOptions;
 exports.CreateUploadPayloadUrlResponseBody = CreateUploadPayloadUrlResponseBody;
 exports.DeletedScheduleObject = DeletedScheduleObject;
 exports.DeploymentErrorData = DeploymentErrorData;
-exports.DevRuntimeManager = DevRuntimeManager;
-exports.DurableClock = PreciseWallClock;
 exports.EnvironmentType = EnvironmentType;
+exports.EnvironmentVariable = EnvironmentVariable;
+exports.EnvironmentVariableResponseBody = EnvironmentVariableResponseBody;
+exports.EnvironmentVariableValue = EnvironmentVariableValue;
+exports.EnvironmentVariables = EnvironmentVariables;
 exports.EventFilter = EventFilter;
 exports.ExceptionEventProperties = ExceptionEventProperties;
 exports.ExceptionSpanEvent = ExceptionSpanEvent;
@@ -5151,6 +3929,7 @@ exports.GetProjectEnvResponse = GetProjectEnvResponse;
 exports.GetProjectResponseBody = GetProjectResponseBody;
 exports.GetProjectsResponseBody = GetProjectsResponseBody;
 exports.ImageDetailsMetadata = ImageDetailsMetadata;
+exports.ImportEnvironmentVariablesRequestBody = ImportEnvironmentVariablesRequestBody;
 exports.InitializeDeploymentRequestBody = InitializeDeploymentRequestBody;
 exports.InitializeDeploymentResponseBody = InitializeDeploymentResponseBody;
 exports.InternalServerError = InternalServerError;
@@ -5159,6 +3938,7 @@ exports.ListSchedulesResult = ListSchedulesResult;
 exports.Machine = Machine;
 exports.MachineCpu = MachineCpu;
 exports.MachineMemory = MachineMemory;
+exports.NULL_SENTINEL = NULL_SENTINEL;
 exports.NotFoundError = NotFoundError;
 exports.OFFLOAD_IO_PACKET_LENGTH_LIMIT = OFFLOAD_IO_PACKET_LENGTH_LIMIT;
 exports.OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT;
@@ -5169,7 +3949,6 @@ exports.OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_
 exports.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT;
 exports.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
 exports.OTEL_SPAN_EVENT_COUNT_LIMIT = OTEL_SPAN_EVENT_COUNT_LIMIT;
-exports.OtelTaskLogger = OtelTaskLogger;
 exports.OtherSpanEvent = OtherSpanEvent;
 exports.PRIMARY_VARIANT = PRIMARY_VARIANT;
 exports.PermissionDeniedError = PermissionDeniedError;
@@ -5178,7 +3957,6 @@ exports.PlatformToProviderMessages = PlatformToProviderMessages;
 exports.PostStartCauses = PostStartCauses;
 exports.PreStopCauses = PreStopCauses;
 exports.ProdChildToWorkerMessages = ProdChildToWorkerMessages;
-exports.ProdRuntimeManager = ProdRuntimeManager;
 exports.ProdTaskRunExecution = ProdTaskRunExecution;
 exports.ProdTaskRunExecutionPayload = ProdTaskRunExecutionPayload;
 exports.ProdWorkerSocketData = ProdWorkerSocketData;
@@ -5189,22 +3967,20 @@ exports.QueueOptions = QueueOptions;
 exports.RateLimitError = RateLimitError;
 exports.RateLimitOptions = RateLimitOptions;
 exports.ReplayRunResponse = ReplayRunResponse;
+exports.RetrieveRunResponse = RetrieveRunResponse;
 exports.RetryOptions = RetryOptions;
+exports.RunStatus = RunStatus;
 exports.ScheduleObject = ScheduleObject;
 exports.ScheduledTaskPayload = ScheduledTaskPayload;
 exports.SemanticInternalAttributes = SemanticInternalAttributes;
 exports.SharedQueueToClientMessages = SharedQueueToClientMessages;
-exports.SimpleStructuredLogger = SimpleStructuredLogger;
 exports.SlidingWindowRateLimit = SlidingWindowRateLimit;
 exports.SpanEvent = SpanEvent;
 exports.SpanEvents = SpanEvents;
 exports.SpanMessagingEvent = SpanMessagingEvent;
-exports.StandardTaskCatalog = StandardTaskCatalog;
 exports.StartDeploymentIndexingRequestBody = StartDeploymentIndexingRequestBody;
 exports.StartDeploymentIndexingResponseBody = StartDeploymentIndexingResponseBody;
-exports.TaskContextSpanProcessor = TaskContextSpanProcessor;
 exports.TaskEventStyle = TaskEventStyle;
-exports.TaskExecutor = TaskExecutor;
 exports.TaskFileMetadata = TaskFileMetadata;
 exports.TaskMetadata = TaskMetadata;
 exports.TaskMetadataFailedToParseData = TaskMetadataFailedToParseData;
@@ -5220,6 +3996,7 @@ exports.TaskRunExecution = TaskRunExecution;
 exports.TaskRunExecutionAttempt = TaskRunExecutionAttempt;
 exports.TaskRunExecutionBatch = TaskRunExecutionBatch;
 exports.TaskRunExecutionEnvironment = TaskRunExecutionEnvironment;
+exports.TaskRunExecutionLazyAttemptPayload = TaskRunExecutionLazyAttemptPayload;
 exports.TaskRunExecutionOrganization = TaskRunExecutionOrganization;
 exports.TaskRunExecutionPayload = TaskRunExecutionPayload;
 exports.TaskRunExecutionProject = TaskRunExecutionProject;
@@ -5231,24 +4008,15 @@ exports.TaskRunFailedExecutionResult = TaskRunFailedExecutionResult;
 exports.TaskRunInternalError = TaskRunInternalError;
 exports.TaskRunStringError = TaskRunStringError;
 exports.TaskRunSuccessfulExecutionResult = TaskRunSuccessfulExecutionResult;
-exports.TracingSDK = TracingSDK;
 exports.TriggerTaskRequestBody = TriggerTaskRequestBody;
 exports.TriggerTaskResponse = TriggerTaskResponse;
 exports.TriggerTracer = TriggerTracer;
 exports.UncaughtExceptionMessage = UncaughtExceptionMessage;
 exports.UnprocessableEntityError = UnprocessableEntityError;
+exports.UpdateEnvironmentVariableRequestBody = UpdateEnvironmentVariableRequestBody;
 exports.UpdateScheduleOptions = UpdateScheduleOptions;
 exports.WaitReason = WaitReason;
 exports.WhoAmIResponseSchema = WhoAmIResponseSchema;
-exports.ZodIpcConnection = ZodIpcConnection;
-exports.ZodMessageHandler = ZodMessageHandler;
-exports.ZodMessageSchema = ZodMessageSchema;
-exports.ZodMessageSender = ZodMessageSender;
-exports.ZodNamespace = ZodNamespace;
-exports.ZodSchemaParsedError = ZodSchemaParsedError;
-exports.ZodSocketConnection = ZodSocketConnection;
-exports.ZodSocketMessageHandler = ZodSocketMessageHandler;
-exports.ZodSocketMessageSender = ZodSocketMessageSender;
 exports.accessoryAttributes = accessoryAttributes;
 exports.apiClientManager = apiClientManager;
 exports.calculateNextRetryDelay = calculateNextRetryDelay;
@@ -5260,6 +4028,7 @@ exports.conditionallyExportPacket = conditionallyExportPacket;
 exports.conditionallyImportPacket = conditionallyImportPacket;
 exports.correctErrorStackTrace = correctErrorStackTrace;
 exports.createErrorTaskError = createErrorTaskError;
+exports.createJsonErrorObject = createJsonErrorObject;
 exports.createPacketAttributes = createPacketAttributes;
 exports.createPacketAttributesAsJson = createPacketAttributesAsJson;
 exports.defaultFetchRetryOptions = defaultFetchRetryOptions;
@@ -5271,31 +4040,25 @@ exports.formatDuration = formatDuration;
 exports.formatDurationInDays = formatDurationInDays;
 exports.formatDurationMilliseconds = formatDurationMilliseconds;
 exports.formatDurationNanoseconds = formatDurationNanoseconds;
-exports.getEnvVar = getEnvVar;
 exports.groupTaskMetadataIssuesByTask = groupTaskMetadataIssuesByTask;
-exports.iconStringForSeverity = iconStringForSeverity;
 exports.imposeAttributeLimits = imposeAttributeLimits;
 exports.isCancellationSpanEvent = isCancellationSpanEvent;
 exports.isExceptionSpanEvent = isExceptionSpanEvent;
-exports.logLevels = logLevels;
 exports.logger = logger;
 exports.millisecondsToNanoseconds = millisecondsToNanoseconds;
 exports.nanosecondsToMilliseconds = nanosecondsToMilliseconds;
 exports.omit = omit;
 exports.packetRequiresOffloading = packetRequiresOffloading;
-exports.parseBatchTriggerTaskRequestBody = parseBatchTriggerTaskRequestBody;
 exports.parseError = parseError;
 exports.parsePacket = parsePacket;
-exports.parseTriggerTaskRequestBody = parseTriggerTaskRequestBody;
 exports.prettyPrintPacket = prettyPrintPacket;
 exports.primitiveValueOrflattenedAttributes = primitiveValueOrflattenedAttributes;
-exports.recordSpanException = recordSpanException;
 exports.runtime = runtime;
 exports.serverWebsocketMessages = serverWebsocketMessages;
 exports.stringPatternMatchers = stringPatternMatchers;
 exports.stringifyIO = stringifyIO;
 exports.taskCatalog = taskCatalog;
-exports.taskContextManager = taskContextManager;
+exports.taskContext = taskContext;
 exports.unflattenAttributes = unflattenAttributes;
 exports.workerToChildMessages = workerToChildMessages;
 //# sourceMappingURL=out.js.map