@trigger.dev/core 0.0.0-v3-canary-20240325172431 → 0.0.0-v3-pnpm-fix-20240404110601

package/dist/v3/index.js

@@ -3,13 +3,13 @@
 var zod = require('zod');
 var api = require('@opentelemetry/api');
 var async_hooks = require('async_hooks');
-var semanticConventions = require('@opentelemetry/semantic-conventions');
 var socket_ioClient = require('socket.io-client');
 var crypto = require('crypto');
 var nodePath = require('path');
 var apiLogs = require('@opentelemetry/api-logs');
 var preciseDate = require('@google-cloud/precise-date');
 var humanizeDuration = require('humanize-duration');
+var promises = require('timers/promises');
 var util = require('util');
 var exporterLogsOtlpHttp = require('@opentelemetry/exporter-logs-otlp-http');
 var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
@@ -17,6 +17,7 @@ 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 }; }
 
@@ -224,6 +225,32 @@ var BatchTaskRunExecutionResult = zod.z.object({
 });
 
 // src/v3/schemas/messages.ts
+var EnvironmentType = zod.z.enum([
+  "PRODUCTION",
+  "STAGING",
+  "DEVELOPMENT",
+  "PREVIEW"
+]);
+var MachineCpu = zod.z.union([
+  zod.z.literal(0.25),
+  zod.z.literal(0.5),
+  zod.z.literal(1),
+  zod.z.literal(2),
+  zod.z.literal(4)
+]).default(0.5);
+var MachineMemory = zod.z.union([
+  zod.z.literal(0.25),
+  zod.z.literal(0.5),
+  zod.z.literal(1),
+  zod.z.literal(2),
+  zod.z.literal(4),
+  zod.z.literal(8)
+]).default(1);
+var Machine = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  cpu: MachineCpu,
+  memory: MachineMemory
+});
 var TaskRunExecutionPayload = zod.z.object({
   execution: TaskRunExecution,
   traceContext: zod.z.record(zod.z.unknown()),
@@ -253,11 +280,16 @@ var BackgroundWorkerServerMessages = zod.z.discriminatedUnion("type", [
   }),
   zod.z.object({
     type: zod.z.literal("SCHEDULE_ATTEMPT"),
-    id: zod.z.string(),
     image: zod.z.string(),
+    version: zod.z.string(),
+    machine: Machine,
+    // identifiers
+    id: zod.z.string(),
     envId: zod.z.string(),
-    runId: zod.z.string(),
-    version: zod.z.string()
+    envType: EnvironmentType,
+    orgId: zod.z.string(),
+    projectId: zod.z.string(),
+    runId: zod.z.string()
   })
 ]);
 var serverWebsocketMessages = {
@@ -410,7 +442,7 @@ var QueueOptions = zod.z.object({
   /** An optional property that specifies the maximum number of concurrent run executions.
   *
   * If this property is omitted, the task can potentially use up the full concurrency of an environment. */
-  concurrencyLimit: zod.z.number().int().min(1).max(1e3).optional(),
+  concurrencyLimit: zod.z.number().int().min(0).max(1e3).optional(),
   /** @deprecated This feature is coming soon */
   rateLimit: RateLimitOptions.optional()
 });
@@ -419,7 +451,8 @@ var TaskMetadata = zod.z.object({
   exportName: zod.z.string(),
   packageVersion: zod.z.string(),
   queue: QueueOptions.optional(),
-  retry: RetryOptions.optional()
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional()
 });
 var TaskMetadataWithFilePath = TaskMetadata.extend({
   filePath: zod.z.string()
@@ -436,6 +469,13 @@ var UncaughtExceptionMessage = zod.z.object({
     "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"),
@@ -446,6 +486,7 @@ var childToWorkerMessages = {
     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()
@@ -480,6 +521,9 @@ var ProdChildToWorkerMessages = {
       tasks: TaskMetadataWithFilePath.array()
     })
   },
+  TASKS_FAILED_TO_PARSE: {
+    message: TaskMetadataFailedToParseData
+  },
   TASK_HEARTBEAT: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -563,7 +607,8 @@ var TaskResource = zod.z.object({
   filePath: zod.z.string(),
   exportName: zod.z.string(),
   queue: QueueOptions.optional(),
-  retry: RetryOptions.optional()
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional()
 });
 var BackgroundWorkerMetadata = zod.z.object({
   packageVersion: zod.z.string(),
@@ -674,6 +719,11 @@ var InitializeDeploymentRequestBody = zod.z.object({
   contentHash: zod.z.string(),
   userId: zod.z.string().optional()
 });
+var DeploymentErrorData = zod.z.object({
+  name: zod.z.string(),
+  message: zod.z.string(),
+  stack: zod.z.string().optional()
+});
 var GetDeploymentResponseBody = zod.z.object({
   id: zod.z.string(),
   status: zod.z.enum([
@@ -689,11 +739,7 @@ var GetDeploymentResponseBody = zod.z.object({
   shortCode: zod.z.string(),
   version: zod.z.string(),
   imageReference: zod.z.string().optional(),
-  errorData: zod.z.object({
-    name: zod.z.string(),
-    message: zod.z.string(),
-    stack: zod.z.string().optional()
-  }).optional().nullable(),
+  errorData: DeploymentErrorData.optional().nullable(),
   worker: zod.z.object({
     id: zod.z.string(),
     version: zod.z.string(),
@@ -705,6 +751,17 @@ var GetDeploymentResponseBody = zod.z.object({
     }))
   }).optional()
 });
+var CreateUploadPayloadUrlResponseBody = zod.z.object({
+  presignedUrl: zod.z.string()
+});
+var PostStartCauses = zod.z.enum([
+  "index",
+  "create",
+  "restore"
+]);
+var PreStopCauses = zod.z.enum([
+  "terminate"
+]);
 var RegexSchema = zod.z.custom((val) => {
   try {
     return typeof val.test === "function";
@@ -727,11 +784,8 @@ var Config = zod.z.object({
   dependenciesToBundle: zod.z.array(zod.z.union([
     zod.z.string(),
     RegexSchema
-  ])).optional()
-});
-var Machine = zod.z.object({
-  cpu: zod.z.string().default("1").optional(),
-  memory: zod.z.string().default("500Mi").optional()
+  ])).optional(),
+  logLevel: zod.z.string().optional()
 });
 var WaitReason = zod.z.enum([
   "WAIT_FOR_DURATION",
@@ -769,9 +823,13 @@ var PlatformToProviderMessages = {
       version: zod.z.literal("v1").default("v1"),
       imageTag: zod.z.string(),
       shortCode: zod.z.string(),
-      envId: zod.z.string(),
       apiKey: zod.z.string(),
-      apiUrl: zod.z.string()
+      apiUrl: zod.z.string(),
+      // identifiers
+      envId: zod.z.string(),
+      envType: EnvironmentType,
+      orgId: zod.z.string(),
+      projectId: zod.z.string()
     }),
     callback: zod.z.discriminatedUnion("success", [
       zod.z.object({
@@ -787,25 +845,25 @@ var PlatformToProviderMessages = {
       })
     ])
   },
-  INVOKE: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      name: zod.z.string(),
-      machine: Machine
-    })
-  },
+  // TODO: this should be a shared queue message instead
   RESTORE: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      checkpointId: zod.z.string(),
-      runId: zod.z.string(),
       type: zod.z.enum([
         "DOCKER",
         "KUBERNETES"
       ]),
       location: zod.z.string(),
       reason: zod.z.string().optional(),
-      imageRef: zod.z.string()
+      imageRef: zod.z.string(),
+      machine: Machine,
+      // identifiers
+      checkpointId: zod.z.string(),
+      envId: zod.z.string(),
+      envType: EnvironmentType,
+      orgId: zod.z.string(),
+      projectId: zod.z.string(),
+      runId: zod.z.string()
     })
   },
   DELETE: {
@@ -1362,7 +1420,11 @@ var SpanMessagingEvent = zod.z.object({
 });
 
 // src/zodfetch.ts
-async function zodfetch(schema, url, requestInit) {
+async function zodfetch(schema, url, requestInit, options) {
+  return await _doZodFetch(schema, url, requestInit, options);
+}
+__name(zodfetch, "zodfetch");
+async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
   try {
     const response = await fetch(url, requestInit);
     if ((!requestInit || requestInit.method === "GET") && response.status === 404) {
@@ -1371,7 +1433,7 @@ async function zodfetch(schema, url, requestInit) {
         error: `404: ${response.statusText}`
       };
     }
-    if (response.status >= 400 && response.status < 500) {
+    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
       const body = await response.json();
       if (!body.error) {
         return {
@@ -1384,6 +1446,27 @@ async function zodfetch(schema, url, requestInit) {
         error: body.error
       };
     }
+    if (response.status === 429 || response.status >= 500) {
+      if (!options?.retry) {
+        return {
+          ok: false,
+          error: `Failed to fetch ${url}, got status code ${response.status}`
+        };
+      }
+      const retry = {
+        ...defaultRetryOptions,
+        ...options.retry
+      };
+      if (attempt > retry.maxAttempts) {
+        return {
+          ok: false,
+          error: `Failed to fetch ${url}, got status code ${response.status}`
+        };
+      }
+      const delay = calculateNextRetryDelay(retry, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+    }
     if (response.status !== 200) {
       return {
         ok: false,
@@ -1409,13 +1492,28 @@ async function zodfetch(schema, url, requestInit) {
       error: parsedResult.error.message
     };
   } catch (error) {
+    if (options?.retry) {
+      const retry = {
+        ...defaultRetryOptions,
+        ...options.retry
+      };
+      if (attempt > retry.maxAttempts) {
+        return {
+          ok: false,
+          error: error instanceof Error ? error.message : JSON.stringify(error)
+        };
+      }
+      const delay = calculateNextRetryDelay(retry, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+    }
     return {
       ok: false,
       error: error instanceof Error ? error.message : JSON.stringify(error)
     };
   }
 }
-__name(zodfetch, "zodfetch");
+__name(_doZodFetch, "_doZodFetch");
 
 // src/v3/utils/flattenAttributes.ts
 function flattenAttributes(obj, prefix) {
@@ -1549,6 +1647,7 @@ var SemanticInternalAttributes = {
   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",
@@ -1556,6 +1655,7 @@ var SemanticInternalAttributes = {
   METADATA: "$metadata",
   TRIGGER: "$trigger",
   PAYLOAD: "$payload",
+  PAYLOAD_TYPE: "$mime_type_payload",
   SHOW: "$show",
   SHOW_ACTIONS: "$show.actions",
   WORKER_ID: "worker.id",
@@ -1582,10 +1682,6 @@ var _TaskContextManager = class _TaskContextManager {
     const store = __privateMethod(this, _getStore, getStore_fn).call(this);
     return store?.ctx;
   }
-  get payload() {
-    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
-    return store?.payload;
-  }
   get worker() {
     const store = __privateMethod(this, _getStore, getStore_fn).call(this);
     return store?.worker;
@@ -1594,19 +1690,11 @@ var _TaskContextManager = class _TaskContextManager {
     if (this.ctx) {
       return {
         ...this.contextAttributes,
-        ...this.workerAttributes,
-        ...this.payloadAttributes,
-        [semanticConventions.SemanticResourceAttributes.SERVICE_NAME]: this.ctx.task.id
+        ...this.workerAttributes
       };
     }
     return {};
   }
-  get payloadAttributes() {
-    if (this.payload) {
-      return flattenAttributes(this.payload, "payload");
-    }
-    return {};
-  }
   get workerAttributes() {
     if (this.worker) {
       return {
@@ -1711,6 +1799,15 @@ function getEnvVar(name) {
 __name(getEnvVar, "getEnvVar");
 
 // src/v3/apiClient/index.ts
+var zodFetchOptions = {
+  retry: {
+    maxAttempts: 5,
+    minTimeoutInMs: 1e3,
+    maxTimeoutInMs: 3e4,
+    factor: 2,
+    randomize: false
+  }
+};
 var _getHeaders, getHeaders_fn;
 var _ApiClient = class _ApiClient {
   constructor(baseUrl, accessToken) {
@@ -1723,14 +1820,26 @@ var _ApiClient = class _ApiClient {
       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);
   }
 };
 _getHeaders = new WeakSet();
@@ -1757,7 +1866,7 @@ var _ApiClientManager = class _ApiClientManager {
   }
   get baseURL() {
     const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
-    return store?.baseURL ?? getEnvVar("TRIGGER_API_URL");
+    return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
   }
   get accessToken() {
     const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
@@ -1780,6 +1889,15 @@ getStore_fn2 = /* @__PURE__ */ __name(function() {
 __name(_ApiClientManager, "ApiClientManager");
 var ApiClientManager = _ApiClientManager;
 var apiClientManager = new ApiClientManager();
+var _ZodSchemaParsedError = class _ZodSchemaParsedError extends Error {
+  constructor(error, payload) {
+    super(error.message);
+    this.error = error;
+    this.payload = payload;
+  }
+};
+__name(_ZodSchemaParsedError, "ZodSchemaParsedError");
+var ZodSchemaParsedError = _ZodSchemaParsedError;
 var ZodMessageSchema = zod.z.object({
   version: zod.z.literal("v1").default("v1"),
   type: zod.z.string(),
@@ -1876,7 +1994,7 @@ var _ZodMessageSender = class _ZodMessageSender {
     }
     const parsedPayload = schema.safeParse(payload);
     if (!parsedPayload.success) {
-      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+      throw new ZodSchemaParsedError(parsedPayload.error, payload);
     }
     await __privateGet(this, _sender).call(this, {
       type,
@@ -2045,16 +2163,23 @@ var _ZodSocketConnection = class _ZodSocketConnection {
     __privateAdd(this, _sender2, void 0);
     __privateAdd(this, _handler, void 0);
     __privateAdd(this, _logger, void 0);
-    this.socket = socket_ioClient.io(`ws://${opts.host}:${opts.port}/${opts.namespace}`, {
+    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
+      extraHeaders: opts.extraHeaders,
+      reconnectionDelay: 500,
+      reconnectionDelayMax: 1e3
     });
-    __privateSet(this, _logger, new SimpleStructuredLogger(opts.namespace, exports.LogLevel.info, {
+    __privateSet(this, _logger, logger2.child({
       socketId: this.socket.id
     }));
     __privateSet(this, _handler, new ZodSocketMessageHandler({
@@ -2373,7 +2498,7 @@ var _ZodIpcConnection = class _ZodIpcConnection {
     }
     const parsedPayload = schema.safeParse(payload);
     if (!parsedPayload.success) {
-      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+      throw new ZodSchemaParsedError(parsedPayload.error, payload);
     }
     await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
       type: "EVENT",
@@ -2562,6 +2687,41 @@ function correctStackTraceLine(line, projectDir) {
   return line;
 }
 __name(correctStackTraceLine, "correctStackTraceLine");
+function groupTaskMetadataIssuesByTask(tasks, issues) {
+  return issues.reduce((acc, issue) => {
+    if (issue.path.length === 0) {
+      return acc;
+    }
+    const taskIndex = issue.path[1];
+    if (typeof taskIndex !== "number") {
+      return acc;
+    }
+    const task = tasks[taskIndex];
+    if (!task) {
+      return acc;
+    }
+    const restOfPath = issue.path.slice(2);
+    const taskId = task.id;
+    const taskName = task.exportName;
+    const filePath = task.filePath;
+    const key = taskIndex;
+    const existing = acc[key] ?? {
+      id: taskId,
+      exportName: taskName,
+      filePath,
+      issues: []
+    };
+    existing.issues.push({
+      message: issue.message,
+      path: restOfPath.length === 0 ? void 0 : restOfPath.join(".")
+    });
+    return {
+      ...acc,
+      [key]: existing
+    };
+  }, {});
+}
+__name(groupTaskMetadataIssuesByTask, "groupTaskMetadataIssuesByTask");
 
 // src/v3/utils/platform.ts
 var _globalThis = typeof globalThis === "object" ? globalThis : global;
@@ -2711,27 +2871,58 @@ function iconStringForSeverity(severityNumber) {
   }
 }
 __name(iconStringForSeverity, "iconStringForSeverity");
-function preciseDateOriginNow() {
-  return {
-    hrtime: process.hrtime(),
-    timestamp: new preciseDate.PreciseDate()
-  };
-}
-__name(preciseDateOriginNow, "preciseDateOriginNow");
-function calculatePreciseDateHrTime(origin) {
-  const elapsedHrTime = process.hrtime(origin.hrtime);
-  const elapsedNanoseconds = BigInt(elapsedHrTime[0]) * BigInt(1e9) + BigInt(elapsedHrTime[1]);
-  const preciseDate$1 = new preciseDate.PreciseDate(origin.timestamp.getFullTime() + elapsedNanoseconds);
-  const dateStruct = preciseDate$1.toStruct();
-  return [
-    dateStruct.seconds,
-    dateStruct.nanos
-  ];
-}
-__name(calculatePreciseDateHrTime, "calculatePreciseDateHrTime");
+var _SimpleClock = class _SimpleClock {
+  preciseNow() {
+    const now = new preciseDate.PreciseDate();
+    const nowStruct = now.toStruct();
+    return [
+      nowStruct.seconds,
+      nowStruct.nanos
+    ];
+  }
+  reset() {
+  }
+};
+__name(_SimpleClock, "SimpleClock");
+var SimpleClock = _SimpleClock;
+
+// src/v3/clock/index.ts
+var API_NAME2 = "clock";
+var SIMPLE_CLOCK = new SimpleClock();
+var _getClock, getClock_fn;
+var _ClockAPI = class _ClockAPI {
+  constructor() {
+    __privateAdd(this, _getClock);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _ClockAPI();
+    }
+    return this._instance;
+  }
+  setGlobalClock(clock2) {
+    return registerGlobal(API_NAME2, clock2);
+  }
+  preciseNow() {
+    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
+  }
+  reset() {
+    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
+  }
+};
+_getClock = new WeakSet();
+getClock_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME2) ?? SIMPLE_CLOCK;
+}, "#getClock");
+__name(_ClockAPI, "ClockAPI");
+var ClockAPI = _ClockAPI;
+
+// src/v3/clock-api.ts
+var clock = ClockAPI.getInstance();
 
 // src/v3/logger/taskLogger.ts
 var logLevels = [
+  "none",
   "error",
   "warn",
   "log",
@@ -2747,37 +2938,36 @@ var _OtelTaskLogger = class _OtelTaskLogger {
     this._level = logLevels.indexOf(_config.level);
   }
   debug(message, properties) {
-    if (this._level < 4)
+    if (this._level < 5)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "debug", apiLogs.SeverityNumber.DEBUG, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "debug", apiLogs.SeverityNumber.DEBUG, properties);
   }
   log(message, properties) {
-    if (this._level < 2)
+    if (this._level < 3)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "log", apiLogs.SeverityNumber.INFO, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "log", apiLogs.SeverityNumber.INFO, properties);
   }
   info(message, properties) {
-    if (this._level < 3)
+    if (this._level < 4)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "info", apiLogs.SeverityNumber.INFO, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "info", apiLogs.SeverityNumber.INFO, properties);
   }
   warn(message, properties) {
-    if (this._level < 1)
+    if (this._level < 2)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "warn", apiLogs.SeverityNumber.WARN, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "warn", apiLogs.SeverityNumber.WARN, properties);
   }
   error(message, properties) {
-    if (this._level < 0)
+    if (this._level < 1)
       return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "error", apiLogs.SeverityNumber.ERROR, properties);
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "error", apiLogs.SeverityNumber.ERROR, properties);
   }
   trace(name, fn, options) {
     return this._config.tracer.startActiveSpan(name, fn, options);
   }
 };
 _emitLog = new WeakSet();
-emitLog_fn = /* @__PURE__ */ __name(function(message, severityText, severityNumber, properties) {
-  const timestamp = __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this);
+emitLog_fn = /* @__PURE__ */ __name(function(message, timestamp, severityText, severityNumber, properties) {
   let attributes = {
     ...flattenAttributes(properties)
   };
@@ -2795,7 +2985,7 @@ emitLog_fn = /* @__PURE__ */ __name(function(message, severityText, severityNumb
 }, "#emitLog");
 _getTimestampInHrTime = new WeakSet();
 getTimestampInHrTime_fn = /* @__PURE__ */ __name(function() {
-  return calculatePreciseDateHrTime(this._config.preciseDateOrigin);
+  return clock.preciseNow();
 }, "#getTimestampInHrTime");
 __name(_OtelTaskLogger, "OtelTaskLogger");
 var OtelTaskLogger = _OtelTaskLogger;
@@ -2818,7 +3008,7 @@ __name(_NoopTaskLogger, "NoopTaskLogger");
 var NoopTaskLogger = _NoopTaskLogger;
 
 // src/v3/logger/index.ts
-var API_NAME2 = "logger";
+var API_NAME3 = "logger";
 var NOOP_TASK_LOGGER = new NoopTaskLogger();
 var _getTaskLogger, getTaskLogger_fn;
 var _LoggerAPI = class _LoggerAPI {
@@ -2832,10 +3022,10 @@ var _LoggerAPI = class _LoggerAPI {
     return this._instance;
   }
   disable() {
-    unregisterGlobal(API_NAME2);
+    unregisterGlobal(API_NAME3);
   }
   setGlobalTaskLogger(taskLogger) {
-    return registerGlobal(API_NAME2, taskLogger);
+    return registerGlobal(API_NAME3, taskLogger);
   }
   debug(message, metadata) {
     __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).debug(message, metadata);
@@ -2858,13 +3048,57 @@ var _LoggerAPI = class _LoggerAPI {
 };
 _getTaskLogger = new WeakSet();
 getTaskLogger_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME2) ?? NOOP_TASK_LOGGER;
+  return getGlobal(API_NAME3) ?? NOOP_TASK_LOGGER;
 }, "#getTaskLogger");
 __name(_LoggerAPI, "LoggerAPI");
 var LoggerAPI = _LoggerAPI;
 
 // src/v3/logger-api.ts
 var logger = LoggerAPI.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());
 }
@@ -3029,11 +3263,10 @@ var _DevRuntimeManager = class _DevRuntimeManager {
 };
 __name(_DevRuntimeManager, "DevRuntimeManager");
 var DevRuntimeManager = _DevRuntimeManager;
-
-// src/v3/runtime/prodRuntimeManager.ts
 var _ProdRuntimeManager = class _ProdRuntimeManager {
-  constructor(ipc) {
+  constructor(ipc, options = {}) {
     this.ipc = ipc;
+    this.options = options;
     this._taskWaits = /* @__PURE__ */ new Map();
     this._batchWaits = /* @__PURE__ */ new Map();
     this._tasks = /* @__PURE__ */ new Map();
@@ -3049,12 +3282,9 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
     return this._tasks.get(id);
   }
   async waitForDuration(ms) {
-    let timeout;
     const now = Date.now();
-    const resolveAfterDuration = new Promise((resolve) => {
-      timeout = setTimeout(resolve, ms);
-    });
-    if (ms < 1e4) {
+    const resolveAfterDuration = promises.setTimeout(ms, "duration");
+    if (ms <= this.waitThresholdInMs) {
       await resolveAfterDuration;
       return;
     }
@@ -3078,13 +3308,13 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
       resolveAfterDuration
     ]);
     this.ipc.send("CANCEL_CHECKPOINT", {});
-    clearTimeout(timeout);
   }
   resumeAfterRestore() {
     if (!this._waitForRestore) {
       return;
     }
-    this._waitForRestore.resolve();
+    clock.reset();
+    this._waitForRestore.resolve("restore");
     this._waitForRestore = void 0;
   }
   async waitUntil(date) {
@@ -3139,9 +3369,49 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
     }
     this._taskWaits.delete(execution.run.id);
   }
+  get waitThresholdInMs() {
+    return this.options.waitThresholdInMs ?? 3e4;
+  }
 };
 __name(_ProdRuntimeManager, "ProdRuntimeManager");
 var ProdRuntimeManager = _ProdRuntimeManager;
+var _originClockTime, originClockTime_get, _originPreciseDate, originPreciseDate_get;
+var _PreciseWallClock = class _PreciseWallClock {
+  constructor(options = {}) {
+    __privateAdd(this, _originClockTime);
+    __privateAdd(this, _originPreciseDate);
+    this._origin = {
+      clockTime: options.origin ?? process.hrtime(),
+      preciseDate: options.now ?? new preciseDate.PreciseDate()
+    };
+  }
+  preciseNow() {
+    const elapsedHrTime = process.hrtime(__privateGet(this, _originClockTime, originClockTime_get));
+    const elapsedNanoseconds = BigInt(elapsedHrTime[0]) * BigInt(1e9) + BigInt(elapsedHrTime[1]);
+    const preciseDate$1 = new preciseDate.PreciseDate(__privateGet(this, _originPreciseDate, originPreciseDate_get).getFullTime() + elapsedNanoseconds);
+    const dateStruct = preciseDate$1.toStruct();
+    return [
+      dateStruct.seconds,
+      dateStruct.nanos
+    ];
+  }
+  reset() {
+    this._origin = {
+      clockTime: process.hrtime(),
+      preciseDate: new preciseDate.PreciseDate()
+    };
+  }
+};
+_originClockTime = new WeakSet();
+originClockTime_get = /* @__PURE__ */ __name(function() {
+  return this._origin.clockTime;
+}, "#originClockTime");
+_originPreciseDate = new WeakSet();
+originPreciseDate_get = /* @__PURE__ */ __name(function() {
+  return this._origin.preciseDate;
+}, "#originPreciseDate");
+__name(_PreciseWallClock, "PreciseWallClock");
+var PreciseWallClock = _PreciseWallClock;
 var _TriggerTracer = class _TriggerTracer {
   constructor(_config) {
     this._config = _config;
@@ -3170,7 +3440,8 @@ var _TriggerTracer = class _TriggerTracer {
     const attributes = options?.attributes ?? {};
     return this.tracer.startActiveSpan(name, {
       ...options,
-      attributes
+      attributes,
+      startTime: clock.preciseNow()
     }, parentContext, async (span) => {
       this.tracer.startSpan(name, {
         ...options,
@@ -3191,7 +3462,7 @@ var _TriggerTracer = class _TriggerTracer {
         });
         throw e;
       } finally {
-        span.end();
+        span.end(clock.preciseNow());
       }
     });
   }
@@ -3214,12 +3485,11 @@ __name(_TriggerTracer, "TriggerTracer");
 var TriggerTracer = _TriggerTracer;
 var _handleLog, handleLog_fn, _getTimestampInHrTime2, getTimestampInHrTime_fn2, _getAttributes, getAttributes_fn;
 var _ConsoleInterceptor = class _ConsoleInterceptor {
-  constructor(logger2, preciseDateOrigin) {
+  constructor(logger2) {
     __privateAdd(this, _handleLog);
     __privateAdd(this, _getTimestampInHrTime2);
     __privateAdd(this, _getAttributes);
     this.logger = logger2;
-    this.preciseDateOrigin = preciseDateOrigin;
   }
   // Intercept the console and send logs to the OpenTelemetry logger
   // during the execution of the callback
@@ -3244,22 +3514,21 @@ var _ConsoleInterceptor = class _ConsoleInterceptor {
     }
   }
   log(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, "Log", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Log", ...args);
   }
   info(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, "Info", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Info", ...args);
   }
   warn(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.WARN, "Warn", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.WARN, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Warn", ...args);
   }
   error(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.ERROR, "Error", ...args);
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.ERROR, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Error", ...args);
   }
 };
 _handleLog = new WeakSet();
-handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, severityText, ...args) {
+handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, timestamp, severityText, ...args) {
   const body = util__default.default.format(...args);
-  const timestamp = __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this);
   const parsed = tryParseJSON(body);
   if (parsed.ok) {
     this.logger.emit({
@@ -3284,7 +3553,7 @@ handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, severityText, ...
 }, "#handleLog");
 _getTimestampInHrTime2 = new WeakSet();
 getTimestampInHrTime_fn2 = /* @__PURE__ */ __name(function() {
-  return calculatePreciseDateHrTime(this.preciseDateOrigin);
+  return clock.preciseNow();
 }, "#getTimestampInHrTime");
 _getAttributes = new WeakSet();
 getAttributes_fn = /* @__PURE__ */ __name(function(severityNumber1) {
@@ -3658,19 +3927,24 @@ var _TracingSDK = class _TracingSDK {
       forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500,
       resource: commonResources,
       spanLimits: {
-        attributeCountLimit: 1e3,
-        attributeValueLengthLimit: 1e3,
-        eventCountLimit: 100,
-        attributePerEventCountLimit: 100,
-        linkCountLimit: 10,
-        attributePerLinkCountLimit: 100
+        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(new sdkTraceNode.SimpleSpanProcessor(spanExporter)));
+    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 ?? [],
@@ -3682,11 +3956,16 @@ var _TracingSDK = class _TracingSDK {
     const loggerProvider = new sdkLogs.LoggerProvider({
       resource: commonResources,
       logRecordLimits: {
-        attributeCountLimit: 1e3,
-        attributeValueLengthLimit: 1e3
+        attributeCountLimit: OTEL_LOG_ATTRIBUTE_COUNT_LIMIT,
+        attributeValueLengthLimit: OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT
       }
     });
-    loggerProvider.addLogRecordProcessor(new TaskContextLogProcessor(new sdkLogs.SimpleLogRecordProcessor(logExporter)));
+    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;
@@ -3695,11 +3974,11 @@ var _TracingSDK = class _TracingSDK {
     this.getTracer = traceProvider.getTracer.bind(traceProvider);
   }
   async flush() {
-    await this._spanExporter.forceFlush?.();
+    await this._traceProvider.forceFlush();
     await this._logProvider.forceFlush();
   }
   async shutdown() {
-    await this._spanExporter.shutdown();
+    await this._traceProvider.shutdown();
     await this._logProvider.shutdown();
   }
 };
@@ -3750,6 +4029,275 @@ function recordSpanException(span, error) {
   });
 }
 __name(recordSpanException, "recordSpanException");
+
+// src/v3/utils/ioSerialization.ts
+async function parsePacket(value) {
+  if (!value.data) {
+    return void 0;
+  }
+  switch (value.dataType) {
+    case "application/json":
+      return JSON.parse(value.data);
+    case "application/super+json":
+      const { parse } = await loadSuperJSON();
+      return parse(value.data);
+    case "text/plain":
+      return value.data;
+    case "application/store":
+      throw new Error(`Cannot parse an application/store packet (${value.data}). Needs to be imported first.`);
+    default:
+      return value.data;
+  }
+}
+__name(parsePacket, "parsePacket");
+async function stringifyIO(value) {
+  if (value === void 0) {
+    return {
+      dataType: "application/json"
+    };
+  }
+  if (typeof value === "string") {
+    return {
+      data: value,
+      dataType: "text/plain"
+    };
+  }
+  try {
+    const { stringify } = await loadSuperJSON();
+    const data = stringify(value);
+    return {
+      data,
+      dataType: "application/super+json"
+    };
+  } catch {
+    return {
+      dataType: "application/json"
+    };
+  }
+}
+__name(stringifyIO, "stringifyIO");
+async function conditionallyExportPacket(packet, pathPrefix, tracer) {
+  if (apiClientManager.client) {
+    const { needsOffloading, size } = packetRequiresOffloading(packet);
+    if (needsOffloading) {
+      if (!tracer) {
+        return await exportPacket(packet, pathPrefix);
+      } else {
+        const result = await tracer.startActiveSpan("store.uploadOutput", async (span) => {
+          return await exportPacket(packet, pathPrefix);
+        }, {
+          attributes: {
+            byteLength: size,
+            [SemanticInternalAttributes.STYLE_ICON]: "cloud-upload"
+          }
+        });
+        return result ?? packet;
+      }
+    }
+  }
+  return packet;
+}
+__name(conditionallyExportPacket, "conditionallyExportPacket");
+function packetRequiresOffloading(packet) {
+  if (!packet.data) {
+    return {
+      needsOffloading: false,
+      size: 0
+    };
+  }
+  const byteSize = Buffer.byteLength(packet.data, "utf8");
+  return {
+    needsOffloading: byteSize >= OFFLOAD_IO_PACKET_LENGTH_LIMIT,
+    size: byteSize
+  };
+}
+__name(packetRequiresOffloading, "packetRequiresOffloading");
+async function exportPacket(packet, pathPrefix) {
+  const filename = `${pathPrefix}.${getPacketExtension(packet.dataType)}`;
+  const presignedResponse = await apiClientManager.client.createUploadPayloadUrl(filename);
+  if (presignedResponse.ok) {
+    const uploadResponse = await fetch(presignedResponse.data.presignedUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": packet.dataType
+      },
+      body: packet.data
+    });
+    if (!uploadResponse.ok) {
+      throw new Error(`Failed to upload output to ${presignedResponse.data.presignedUrl}: ${uploadResponse.statusText}`);
+    }
+    return {
+      data: filename,
+      dataType: "application/store"
+    };
+  }
+  return packet;
+}
+__name(exportPacket, "exportPacket");
+async function conditionallyImportPacket(packet, tracer) {
+  if (packet.dataType !== "application/store") {
+    return packet;
+  }
+  if (!tracer) {
+    return await importPacket(packet);
+  } else {
+    const result = await tracer.startActiveSpan("store.downloadPayload", async (span) => {
+      return await importPacket(packet, span);
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "cloud-download"
+      }
+    });
+    return result ?? packet;
+  }
+}
+__name(conditionallyImportPacket, "conditionallyImportPacket");
+async function importPacket(packet, span) {
+  if (!packet.data) {
+    return packet;
+  }
+  if (!apiClientManager.client) {
+    return packet;
+  }
+  const presignedResponse = await apiClientManager.client.getPayloadUrl(packet.data);
+  if (presignedResponse.ok) {
+    const response = await fetch(presignedResponse.data.presignedUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to import packet ${presignedResponse.data.presignedUrl}: ${response.statusText}`);
+    }
+    const data = await response.text();
+    span?.setAttribute("size", Buffer.byteLength(data, "utf8"));
+    return {
+      data,
+      dataType: response.headers.get("content-type") ?? "application/json"
+    };
+  }
+  return packet;
+}
+__name(importPacket, "importPacket");
+async function createPacketAttributes(packet, dataKey, dataTypeKey) {
+  if (!packet.data) {
+    return;
+  }
+  switch (packet.dataType) {
+    case "application/json":
+      return {
+        ...flattenAttributes(packet, dataKey),
+        [dataTypeKey]: packet.dataType
+      };
+    case "application/super+json":
+      const { parse } = await loadSuperJSON();
+      if (typeof packet.data === "undefined" || packet.data === null) {
+        return;
+      }
+      try {
+        const parsed = parse(packet.data);
+        const jsonified = JSON.parse(JSON.stringify(parsed, safeReplacer));
+        return {
+          ...flattenAttributes(jsonified, dataKey),
+          [dataTypeKey]: "application/json"
+        };
+      } catch {
+        return;
+      }
+    case "application/store":
+      return {
+        [dataKey]: packet.data,
+        [dataTypeKey]: packet.dataType
+      };
+    case "text/plain":
+      return {
+        [dataKey]: packet.data,
+        [dataTypeKey]: packet.dataType
+      };
+    default:
+      return;
+  }
+}
+__name(createPacketAttributes, "createPacketAttributes");
+async function createPacketAttributesAsJson(data, dataType) {
+  if (typeof data === "string" || typeof data === "number" || typeof data === "boolean" || data === null || data === void 0) {
+    return data;
+  }
+  switch (dataType) {
+    case "application/json":
+      return imposeAttributeLimits(flattenAttributes(data, void 0));
+    case "application/super+json":
+      const { deserialize } = await loadSuperJSON();
+      const deserialized = deserialize(data);
+      const jsonify = safeJsonParse(JSON.stringify(deserialized, safeReplacer));
+      return imposeAttributeLimits(flattenAttributes(jsonify, void 0));
+    case "application/store":
+      return data;
+    default:
+      return {};
+  }
+}
+__name(createPacketAttributesAsJson, "createPacketAttributesAsJson");
+async function prettyPrintPacket(rawData, dataType) {
+  if (rawData === void 0) {
+    return "";
+  }
+  if (dataType === "application/super+json") {
+    const { deserialize } = await loadSuperJSON();
+    return await prettyPrintPacket(deserialize(rawData), "application/json");
+  }
+  if (dataType === "application/json") {
+    return JSON.stringify(rawData, safeReplacer, 2);
+  }
+  if (typeof rawData === "string") {
+    return rawData;
+  }
+  return JSON.stringify(rawData, safeReplacer, 2);
+}
+__name(prettyPrintPacket, "prettyPrintPacket");
+function safeReplacer(key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  if (value instanceof Set) {
+    return Array.from(value);
+  }
+  if (value instanceof Map) {
+    const obj = {};
+    value.forEach((v, k) => {
+      obj[k] = v;
+    });
+    return obj;
+  }
+  return value;
+}
+__name(safeReplacer, "safeReplacer");
+function getPacketExtension(outputType) {
+  switch (outputType) {
+    case "application/json":
+      return "json";
+    case "application/super+json":
+      return "json";
+    case "text/plain":
+      return "txt";
+    default:
+      return "txt";
+  }
+}
+__name(getPacketExtension, "getPacketExtension");
+async function loadSuperJSON() {
+  return await import('superjson');
+}
+__name(loadSuperJSON, "loadSuperJSON");
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+}
+__name(safeJsonParse, "safeJsonParse");
+
+// src/v3/workers/taskExecutor.ts
 var _callRun, callRun_fn, _callTaskInit, callTaskInit_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
 var _TaskExecutor = class _TaskExecutor {
   constructor(task, options) {
@@ -3766,12 +4314,14 @@ var _TaskExecutor = class _TaskExecutor {
     this._handleErrorFn = options.handleErrorFn;
   }
   async execute(execution, worker, traceContext) {
-    const parsedPayload = JSON.parse(execution.run.payload);
     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,
-      payload: parsedPayload,
       worker
     }, async () => {
       this._tracingSDK.asyncResourceDetector.resolveWithAttributes({
@@ -3781,17 +4331,25 @@ var _TaskExecutor = class _TaskExecutor {
       });
       return await this._tracer.startActiveSpan(attemptMessage, async (span) => {
         return await this._consoleInterceptor.intercept(console, async () => {
-          const init = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
+          let parsedPayload;
+          let initOutput;
           try {
-            const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, init);
+            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 {
-              span.setAttributes(flattenAttributes(output, SemanticInternalAttributes.OUTPUT));
-              const serializedOutput = JSON.stringify(output);
+              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: serializedOutput,
-                outputType: "application/json"
+                output: finalOutput.data,
+                outputType: finalOutput.dataType
               };
             } catch (stringifyError) {
               recordSpanException(span, stringifyError);
@@ -3829,14 +4387,13 @@ var _TaskExecutor = class _TaskExecutor {
               };
             }
           } finally {
-            await __privateMethod(this, _callTaskCleanup, callTaskCleanup_fn).call(this, parsedPayload, ctx, init);
+            await __privateMethod(this, _callTaskCleanup, callTaskCleanup_fn).call(this, parsedPayload, ctx, initOutput);
           }
         });
       }, {
         kind: api.SpanKind.CONSUMER,
         attributes: {
           [SemanticInternalAttributes.STYLE_ICON]: "attempt",
-          ...flattenAttributes(parsedPayload, SemanticInternalAttributes.PAYLOAD),
           ...accessoryAttributes({
             items: [
               {
@@ -4007,6 +4564,7 @@ var dependencies = {
   "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"
@@ -4046,7 +4604,11 @@ exports.CoordinatorToProdWorkerMessages = CoordinatorToProdWorkerMessages;
 exports.CreateAuthorizationCodeResponseSchema = CreateAuthorizationCodeResponseSchema;
 exports.CreateBackgroundWorkerRequestBody = CreateBackgroundWorkerRequestBody;
 exports.CreateBackgroundWorkerResponse = CreateBackgroundWorkerResponse;
+exports.CreateUploadPayloadUrlResponseBody = CreateUploadPayloadUrlResponseBody;
+exports.DeploymentErrorData = DeploymentErrorData;
 exports.DevRuntimeManager = DevRuntimeManager;
+exports.DurableClock = PreciseWallClock;
+exports.EnvironmentType = EnvironmentType;
 exports.EventFilter = EventFilter;
 exports.ExceptionEventProperties = ExceptionEventProperties;
 exports.ExceptionSpanEvent = ExceptionSpanEvent;
@@ -4070,11 +4632,24 @@ exports.ImageDetailsMetadata = ImageDetailsMetadata;
 exports.InitializeDeploymentRequestBody = InitializeDeploymentRequestBody;
 exports.InitializeDeploymentResponseBody = InitializeDeploymentResponseBody;
 exports.Machine = Machine;
+exports.MachineCpu = MachineCpu;
+exports.MachineMemory = MachineMemory;
+exports.OFFLOAD_IO_PACKET_LENGTH_LIMIT = OFFLOAD_IO_PACKET_LENGTH_LIMIT;
+exports.OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT;
+exports.OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT;
+exports.OTEL_LINK_COUNT_LIMIT = OTEL_LINK_COUNT_LIMIT;
+exports.OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = OTEL_LOG_ATTRIBUTE_COUNT_LIMIT;
+exports.OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+exports.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT;
+exports.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+exports.OTEL_SPAN_EVENT_COUNT_LIMIT = OTEL_SPAN_EVENT_COUNT_LIMIT;
 exports.OtelTaskLogger = OtelTaskLogger;
 exports.OtherSpanEvent = OtherSpanEvent;
 exports.PRIMARY_VARIANT = PRIMARY_VARIANT;
 exports.PlatformToCoordinatorMessages = PlatformToCoordinatorMessages;
 exports.PlatformToProviderMessages = PlatformToProviderMessages;
+exports.PostStartCauses = PostStartCauses;
+exports.PreStopCauses = PreStopCauses;
 exports.ProdChildToWorkerMessages = ProdChildToWorkerMessages;
 exports.ProdRuntimeManager = ProdRuntimeManager;
 exports.ProdTaskRunExecution = ProdTaskRunExecution;
@@ -4099,6 +4674,7 @@ exports.TaskContextSpanProcessor = TaskContextSpanProcessor;
 exports.TaskEventStyle = TaskEventStyle;
 exports.TaskExecutor = TaskExecutor;
 exports.TaskMetadata = TaskMetadata;
+exports.TaskMetadataFailedToParseData = TaskMetadataFailedToParseData;
 exports.TaskMetadataWithFilePath = TaskMetadataWithFilePath;
 exports.TaskResource = TaskResource;
 exports.TaskRun = TaskRun;
@@ -4134,18 +4710,23 @@ exports.ZodMessageHandler = ZodMessageHandler;
 exports.ZodMessageSchema = ZodMessageSchema;
 exports.ZodMessageSender = ZodMessageSender;
 exports.ZodNamespace = ZodNamespace;
+exports.ZodSchemaParsedError = ZodSchemaParsedError;
 exports.ZodSocketConnection = ZodSocketConnection;
 exports.ZodSocketMessageHandler = ZodSocketMessageHandler;
 exports.ZodSocketMessageSender = ZodSocketMessageSender;
 exports.accessoryAttributes = accessoryAttributes;
 exports.apiClientManager = apiClientManager;
 exports.calculateNextRetryDelay = calculateNextRetryDelay;
-exports.calculatePreciseDateHrTime = calculatePreciseDateHrTime;
 exports.calculateResetAt = calculateResetAt2;
 exports.childToWorkerMessages = childToWorkerMessages;
 exports.clientWebsocketMessages = clientWebsocketMessages;
+exports.clock = clock;
+exports.conditionallyExportPacket = conditionallyExportPacket;
+exports.conditionallyImportPacket = conditionallyImportPacket;
 exports.correctErrorStackTrace = correctErrorStackTrace;
 exports.createErrorTaskError = createErrorTaskError;
+exports.createPacketAttributes = createPacketAttributes;
+exports.createPacketAttributesAsJson = createPacketAttributesAsJson;
 exports.defaultFetchRetryOptions = defaultFetchRetryOptions;
 exports.defaultRetryOptions = defaultRetryOptions;
 exports.detectDependencyVersion = detectDependencyVersion;
@@ -4156,22 +4737,28 @@ 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.preciseDateOriginNow = preciseDateOriginNow;
+exports.prettyPrintPacket = prettyPrintPacket;
 exports.primitiveValueOrflattenedAttributes = primitiveValueOrflattenedAttributes;
 exports.recordSpanException = recordSpanException;
 exports.runtime = runtime;
 exports.serverWebsocketMessages = serverWebsocketMessages;
 exports.stringPatternMatchers = stringPatternMatchers;
+exports.stringifyIO = stringifyIO;
 exports.taskContextManager = taskContextManager;
 exports.unflattenAttributes = unflattenAttributes;
 exports.workerToChildMessages = workerToChildMessages;