@trigger.dev/core 3.0.0-beta.3 → 3.0.0-beta.31

package/dist/v3/index.mjs

@@ -1,21 +1,9 @@
+import { propagation, context, trace, SpanStatusCode } from '@opentelemetry/api';
+import { fromZodError } from 'zod-validation-error';
 import { z } from 'zod';
-import { SpanStatusCode, trace, propagation, context, DiagLogLevel, diag, DiagConsoleLogger, SpanKind } from '@opentelemetry/api';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { io } from 'socket.io-client';
-import { randomUUID } from 'crypto';
-import nodePath from 'node:path';
-import { SeverityNumber, logs } from '@opentelemetry/api-logs';
 import { PreciseDate } from '@google-cloud/precise-date';
+import { logs } from '@opentelemetry/api-logs';
 import humanizeDuration from 'humanize-duration';
-import { setTimeout as setTimeout$1 } from 'node:timers/promises';
-import util from 'node:util';
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { registerInstrumentations } from '@opentelemetry/instrumentation';
-import { Resource, detectResourcesSync, processDetectorSync } from '@opentelemetry/resources';
-import { LoggerProvider, BatchLogRecordProcessor, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
-import { NodeTracerProvider, BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
-import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -28,32 +16,394 @@ 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;
 };
+
+// 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");
+
+// src/retry.ts
+function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return;
+  switch (format) {
+    case "iso_8601_duration_openai_variant": {
+      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
+    }
+    case "iso_8601": {
+      return calculateISO8601ResetAt(resets, now);
+    }
+    case "unix_timestamp": {
+      return calculateUnixTimestampResetAt(resets, now);
+    }
+    case "unix_timestamp_in_ms": {
+      return calculateUnixTimestampInMsResetAt(resets, now);
+    }
+  }
+}
+__name(calculateResetAt, "calculateResetAt");
+function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt * 1e3);
+}
+__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
+function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt);
+}
+__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
+function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = new Date(resets);
+  if (isNaN(resetAt.getTime()))
+    return void 0;
+  return resetAt;
+}
+__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
+function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
+  const match = resets.match(pattern);
+  if (!match)
+    return void 0;
+  const days = parseInt(match[1], 10) || 0;
+  const hours = parseInt(match[2], 10) || 0;
+  const minutes = parseInt(match[3], 10) || 0;
+  const seconds = parseFloat(match[4]) || 0;
+  const milliseconds = parseInt(match[5], 10) || 0;
+  const resetAt = new Date(now);
+  resetAt.setDate(resetAt.getDate() + days);
+  resetAt.setHours(resetAt.getHours() + hours);
+  resetAt.setMinutes(resetAt.getMinutes() + minutes);
+  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
+  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
+  return resetAt;
+}
+__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
+
+// src/v3/utils/retries.ts
+var defaultRetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+var defaultFetchRetryOptions = {
+  byStatus: {
+    "429,408,409,5xx": {
+      strategy: "backoff",
+      ...defaultRetryOptions
+    }
+  },
+  connectionError: defaultRetryOptions,
+  timeout: defaultRetryOptions
+};
+function calculateNextRetryDelay(options, attempt) {
+  const opts = {
+    ...defaultRetryOptions,
+    ...options
+  };
+  if (attempt >= opts.maxAttempts) {
+    return;
+  }
+  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
+  const random = randomize ? Math.random() + 1 : 1;
+  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
+  return Math.round(timeout);
+}
+__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+function calculateResetAt2(resets, format, now = Date.now()) {
+  const resetAt = calculateResetAt(resets, format, new Date(now));
+  return resetAt?.getTime();
+}
+__name(calculateResetAt2, "calculateResetAt");
+
+// src/v3/zodfetch.ts
+var defaultRetryOptions2 = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: false
+};
+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, requestInitWithCache(requestInit));
+    const responseHeaders = createResponseHeaders(response.headers);
+    if (!response.ok) {
+      const retryResult = shouldRetry(response, attempt, options?.retry);
+      if (retryResult.retry) {
+        await new Promise((resolve) => setTimeout(resolve, retryResult.delay));
+        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+      } else {
+        const errText = await response.text().catch((e) => castToError2(e).message);
+        const errJSON = safeJsonParse(errText);
+        const errMessage = errJSON ? void 0 : errText;
+        throw APIError.generate(response.status, errJSON, errMessage, responseHeaders);
+      }
+    }
+    const jsonBody = await response.json();
+    const parsedResult = schema.safeParse(jsonBody);
+    if (parsedResult.success) {
+      return parsedResult.data;
+    }
+    throw fromZodError(parsedResult.error);
+  } catch (error) {
+    if (error instanceof APIError) {
+      throw error;
+    }
+    if (options?.retry) {
+      const retry = {
+        ...defaultRetryOptions2,
+        ...options.retry
+      };
+      const delay = calculateNextRetryDelay(retry, attempt);
+      if (delay) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+      }
+    }
+    throw new APIConnectionError({
+      cause: castToError2(error)
+    });
+  }
+}
+__name(_doZodFetch, "_doZodFetch");
+function castToError2(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError2, "castToError");
+function shouldRetry(response, attempt, retryOptions) {
+  function shouldRetryForOptions() {
+    const retry = {
+      ...defaultRetryOptions2,
+      ...retryOptions
+    };
+    const delay = calculateNextRetryDelay(retry, attempt);
+    if (delay) {
+      return {
+        retry: true,
+        delay
+      };
+    } else {
+      return {
+        retry: false
+      };
+    }
+  }
+  __name(shouldRetryForOptions, "shouldRetryForOptions");
+  const shouldRetryHeader = response.headers.get("x-should-retry");
+  if (shouldRetryHeader === "true")
+    return shouldRetryForOptions();
+  if (shouldRetryHeader === "false")
+    return {
+      retry: false
+    };
+  if (response.status === 408)
+    return shouldRetryForOptions();
+  if (response.status === 409)
+    return shouldRetryForOptions();
+  if (response.status === 429)
+    return shouldRetryForOptions();
+  if (response.status >= 500)
+    return shouldRetryForOptions();
+  return {
+    retry: false
+  };
+}
+__name(shouldRetry, "shouldRetry");
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return void 0;
+  }
+}
+__name(safeJsonParse, "safeJsonParse");
+function createResponseHeaders(headers) {
+  return new Proxy(Object.fromEntries(
+    // @ts-ignore
+    headers.entries()
+  ), {
+    get(target, name) {
+      const key = name.toString();
+      return target[key.toLowerCase()] || target[key];
+    }
+  });
+}
+__name(createResponseHeaders, "createResponseHeaders");
+function requestInitWithCache(requestInit) {
+  try {
+    const withCache = {
+      ...requestInit,
+      cache: "no-cache"
+    };
+    const _ = new Request("http://localhost", withCache);
+    return withCache;
+  } catch (error) {
+    return requestInit ?? {};
+  }
+}
+__name(requestInitWithCache, "requestInitWithCache");
 var CreateAuthorizationCodeResponseSchema = z.object({
   url: z.string().url(),
   authorizationCode: z.string()
@@ -83,6 +433,7 @@ var TaskRunStringError = z.object({
 });
 var TaskRunErrorCodes = {
   COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR",
+  COULD_NOT_FIND_TASK: "COULD_NOT_FIND_TASK",
   CONFIGURED_INCORRECTLY: "CONFIGURED_INCORRECTLY",
   TASK_ALREADY_RUNNING: "TASK_ALREADY_RUNNING",
   TASK_EXECUTION_FAILED: "TASK_EXECUTION_FAILED",
@@ -90,12 +441,14 @@ var TaskRunErrorCodes = {
   TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE: "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
   TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
   TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
-  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR"
+  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
+  GRACEFUL_EXIT_TIMEOUT: "GRACEFUL_EXIT_TIMEOUT"
 };
 var TaskRunInternalError = z.object({
   type: z.literal("INTERNAL_ERROR"),
   code: z.enum([
     "COULD_NOT_FIND_EXECUTOR",
+    "COULD_NOT_FIND_TASK",
     "CONFIGURED_INCORRECTLY",
     "TASK_ALREADY_RUNNING",
     "TASK_EXECUTION_FAILED",
@@ -103,7 +456,8 @@ var TaskRunInternalError = z.object({
     "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
     "TASK_RUN_CANCELLED",
     "TASK_OUTPUT_ERROR",
-    "HANDLE_ERROR_ERROR"
+    "HANDLE_ERROR_ERROR",
+    "GRACEFUL_EXIT_TIMEOUT"
   ]),
   message: z.string().optional()
 });
@@ -120,7 +474,8 @@ var TaskRun = z.object({
   context: z.any(),
   tags: z.array(z.string()),
   isTest: z.boolean().default(false),
-  createdAt: z.coerce.date()
+  createdAt: z.coerce.date(),
+  idempotencyKey: z.string().optional()
 });
 var TaskRunExecutionTask = z.object({
   id: z.string(),
@@ -216,7 +571,7 @@ var BatchTaskRunExecutionResult = z.object({
   items: TaskRunExecutionResult.array()
 });
 
-// src/v3/schemas/messages.ts
+// src/v3/schemas/schemas.ts
 var EnvironmentType = z.enum([
   "PRODUCTION",
   "STAGING",
@@ -260,92 +615,6 @@ var ProdTaskRunExecutionPayload = z.object({
   traceContext: z.record(z.unknown()),
   environment: z.record(z.string()).optional()
 });
-var BackgroundWorkerServerMessages = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("EXECUTE_RUNS"),
-    payloads: z.array(TaskRunExecutionPayload)
-  }),
-  z.object({
-    type: z.literal("CANCEL_ATTEMPT"),
-    taskAttemptId: z.string(),
-    taskRunId: z.string()
-  }),
-  z.object({
-    type: z.literal("SCHEDULE_ATTEMPT"),
-    image: z.string(),
-    version: z.string(),
-    machine: Machine,
-    // identifiers
-    id: z.string(),
-    envId: z.string(),
-    envType: EnvironmentType,
-    orgId: z.string(),
-    projectId: z.string(),
-    runId: z.string()
-  })
-]);
-var serverWebsocketMessages = {
-  SERVER_READY: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string()
-  }),
-  BACKGROUND_WORKER_MESSAGE: z.object({
-    version: z.literal("v1").default("v1"),
-    backgroundWorkerId: z.string(),
-    data: BackgroundWorkerServerMessages
-  })
-};
-var BackgroundWorkerClientMessages = z.discriminatedUnion("type", [
-  z.object({
-    version: z.literal("v1").default("v1"),
-    type: z.literal("TASK_RUN_COMPLETED"),
-    completion: TaskRunExecutionResult,
-    execution: TaskRunExecution
-  }),
-  z.object({
-    version: z.literal("v1").default("v1"),
-    type: z.literal("TASK_HEARTBEAT"),
-    id: z.string()
-  })
-]);
-var BackgroundWorkerProperties = z.object({
-  id: z.string(),
-  version: z.string(),
-  contentHash: z.string()
-});
-var clientWebsocketMessages = {
-  READY_FOR_TASKS: z.object({
-    version: z.literal("v1").default("v1"),
-    backgroundWorkerId: z.string()
-  }),
-  BACKGROUND_WORKER_DEPRECATED: z.object({
-    version: z.literal("v1").default("v1"),
-    backgroundWorkerId: z.string()
-  }),
-  BACKGROUND_WORKER_MESSAGE: z.object({
-    version: z.literal("v1").default("v1"),
-    backgroundWorkerId: z.string(),
-    data: BackgroundWorkerClientMessages
-  })
-};
-var workerToChildMessages = {
-  EXECUTE_TASK_RUN: z.object({
-    version: z.literal("v1").default("v1"),
-    execution: TaskRunExecution,
-    traceContext: z.record(z.unknown()),
-    metadata: BackgroundWorkerProperties
-  }),
-  TASK_RUN_COMPLETED_NOTIFICATION: z.object({
-    version: z.literal("v1").default("v1"),
-    completion: TaskRunExecutionResult,
-    execution: TaskRunExecution
-  }),
-  CLEANUP: z.object({
-    version: z.literal("v1").default("v1"),
-    flush: z.boolean().default(false),
-    kill: z.boolean().default(true)
-  })
-};
 var FixedWindowRateLimit = z.object({
   type: z.literal("fixed-window"),
   limit: z.number(),
@@ -440,158 +709,57 @@ var QueueOptions = z.object({
 });
 var TaskMetadata = z.object({
   id: z.string(),
-  exportName: z.string(),
   packageVersion: z.string(),
   queue: QueueOptions.optional(),
   retry: RetryOptions.optional(),
-  machine: Machine.partial().optional()
+  machine: Machine.partial().optional(),
+  triggerSource: z.string().optional()
 });
-var TaskMetadataWithFilePath = TaskMetadata.extend({
-  filePath: z.string()
+var TaskFileMetadata = z.object({
+  filePath: z.string(),
+  exportName: z.string()
 });
-var UncaughtExceptionMessage = z.object({
-  version: z.literal("v1").default("v1"),
-  error: z.object({
-    name: z.string(),
-    message: z.string(),
-    stack: z.string().optional()
-  }),
-  origin: z.enum([
-    "uncaughtException",
-    "unhandledRejection"
-  ])
+var TaskMetadataWithFilePath = TaskMetadata.merge(TaskFileMetadata);
+var PostStartCauses = z.enum([
+  "index",
+  "create",
+  "restore"
+]);
+var PreStopCauses = z.enum([
+  "terminate"
+]);
+var RegexSchema = z.custom((val) => {
+  try {
+    return typeof val.test === "function";
+  } catch {
+    return false;
+  }
 });
-var TaskMetadataFailedToParseData = z.object({
-  version: z.literal("v1").default("v1"),
-  tasks: z.unknown(),
-  zodIssues: z.custom((v) => {
-    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
-  })
+var Config = z.object({
+  project: z.string(),
+  triggerDirectories: z.string().array().optional(),
+  triggerUrl: z.string().optional(),
+  projectDir: z.string().optional(),
+  tsconfigPath: z.string().optional(),
+  retries: z.object({
+    enabledInDev: z.boolean().default(true),
+    default: RetryOptions.optional()
+  }).optional(),
+  additionalPackages: z.string().array().optional(),
+  additionalFiles: z.string().array().optional(),
+  dependenciesToBundle: z.array(z.union([
+    z.string(),
+    RegexSchema
+  ])).optional(),
+  logLevel: z.string().optional(),
+  enableConsoleLogging: z.boolean().optional(),
+  postInstall: z.string().optional()
 });
-var childToWorkerMessages = {
-  TASK_RUN_COMPLETED: z.object({
-    version: z.literal("v1").default("v1"),
-    execution: TaskRunExecution,
-    result: TaskRunExecutionResult
-  }),
-  TASKS_READY: z.object({
-    version: z.literal("v1").default("v1"),
-    tasks: TaskMetadataWithFilePath.array()
-  }),
-  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
-  TASK_HEARTBEAT: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string()
-  }),
-  READY_TO_DISPOSE: z.undefined(),
-  WAIT_FOR_DURATION: z.object({
-    version: z.literal("v1").default("v1"),
-    ms: z.number()
-  }),
-  WAIT_FOR_TASK: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string()
-  }),
-  WAIT_FOR_BATCH: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string(),
-    runs: z.string().array()
-  }),
-  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
-};
-var ProdChildToWorkerMessages = {
-  TASK_RUN_COMPLETED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      execution: TaskRunExecution,
-      result: TaskRunExecutionResult
-    })
-  },
-  TASKS_READY: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      tasks: TaskMetadataWithFilePath.array()
-    })
-  },
-  TASKS_FAILED_TO_PARSE: {
-    message: TaskMetadataFailedToParseData
-  },
-  TASK_HEARTBEAT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      id: z.string()
-    })
-  },
-  READY_TO_DISPOSE: {
-    message: z.undefined()
-  },
-  READY_FOR_CHECKPOINT: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
-  },
-  CANCEL_CHECKPOINT: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
-  },
-  WAIT_FOR_DURATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      ms: z.number(),
-      now: z.number()
-    }),
-    callback: z.object({
-      willCheckpointAndRestore: z.boolean()
-    })
-  },
-  WAIT_FOR_TASK: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      friendlyId: z.string()
-    })
-  },
-  WAIT_FOR_BATCH: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      batchFriendlyId: z.string(),
-      runFriendlyIds: z.string().array()
-    })
-  },
-  UNCAUGHT_EXCEPTION: {
-    message: UncaughtExceptionMessage
-  }
-};
-var ProdWorkerToChildMessages = {
-  EXECUTE_TASK_RUN: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      execution: TaskRunExecution,
-      traceContext: z.record(z.unknown()),
-      metadata: BackgroundWorkerProperties
-    })
-  },
-  TASK_RUN_COMPLETED_NOTIFICATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      completion: TaskRunExecutionResult,
-      execution: TaskRunExecution
-    })
-  },
-  CLEANUP: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      flush: z.boolean().default(false),
-      kill: z.boolean().default(true)
-    }),
-    callback: z.void()
-  },
-  WAIT_COMPLETED_NOTIFICATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
-  }
-};
+var WaitReason = z.enum([
+  "WAIT_FOR_DURATION",
+  "WAIT_FOR_TASK",
+  "WAIT_FOR_BATCH"
+]);
 
 // src/v3/schemas/resources.ts
 var TaskResource = z.object({
@@ -600,7 +768,8 @@ var TaskResource = z.object({
   exportName: z.string(),
   queue: QueueOptions.optional(),
   retry: RetryOptions.optional(),
-  machine: Machine.partial().optional()
+  machine: Machine.partial().optional(),
+  triggerSource: z.string().optional()
 });
 var BackgroundWorkerMetadata = z.object({
   packageVersion: z.string(),
@@ -656,7 +825,9 @@ var TriggerTaskRequestBody = z.object({
     lockToVersion: z.string().optional(),
     queue: QueueOptions.optional(),
     concurrencyKey: z.string().optional(),
-    test: z.boolean().optional()
+    idempotencyKey: z.string().optional(),
+    test: z.boolean().optional(),
+    payloadType: z.string().optional()
   }).optional()
 });
 var TriggerTaskResponse = z.object({
@@ -687,7 +858,8 @@ var GetEnvironmentVariablesResponseBody = z.object({
   variables: z.record(z.string())
 });
 var StartDeploymentIndexingRequestBody = z.object({
-  imageReference: z.string()
+  imageReference: z.string(),
+  selfHosted: z.boolean().optional()
 });
 var StartDeploymentIndexingResponseBody = z.object({
   id: z.string(),
@@ -746,131 +918,478 @@ var GetDeploymentResponseBody = z.object({
 var CreateUploadPayloadUrlResponseBody = z.object({
   presignedUrl: z.string()
 });
-var PostStartCauses = z.enum([
-  "index",
-  "create",
-  "restore"
+var ReplayRunResponse = z.object({
+  id: z.string()
+});
+var CanceledRunResponse = z.object({
+  message: z.string()
+});
+var ScheduledTaskPayload = z.object({
+  /** The schedule id associated with this run (you can have many schedules for the same task).
+  You can use this to remove the schedule, update it, etc */
+  scheduleId: z.string(),
+  /** When the task was scheduled to run.
+  * Note this will be slightly different from `new Date()` because it takes a few ms to run the task. */
+  timestamp: z.date(),
+  /** When the task was last run (it has been).
+  This can be undefined if it's never been run */
+  lastTimestamp: z.date().optional(),
+  /** You can optionally provide an external id when creating the schedule.
+  Usually you would use a userId or some other unique identifier.
+  This defaults to undefined if you didn't provide one. */
+  externalId: z.string().optional(),
+  /** The next 5 dates this task is scheduled to run */
+  upcoming: z.array(z.date())
+});
+var CreateScheduleOptions = z.object({
+  /** The id of the task you want to attach to. */
+  task: z.string(),
+  /**  The schedule in CRON format.
+     * 
+     * ```txt
+  *    *    *    *    *    *
+  ┬    ┬    ┬    ┬    ┬
+  │    │    │    │    |
+  │    │    │    │    └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
+  │    │    │    └───── month (1 - 12)
+  │    │    └────────── day of month (1 - 31, L)
+  │    └─────────────── hour (0 - 23)
+  └──────────────────── minute (0 - 59)
+     * ```
+  
+  "L" means the last. In the "day of week" field, 1L means the last Monday of the month. In the day of month field, L means the last day of the month.
+  
+     */
+  cron: z.string(),
+  /** (Optional) You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
+  *
+  * This is useful if you don't want to create duplicate schedules for a user. */
+  deduplicationKey: z.string().optional(),
+  /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
+  *
+  * This allows you to have per-user CRON tasks.
+  */
+  externalId: z.string().optional()
+});
+var UpdateScheduleOptions = CreateScheduleOptions;
+var ScheduleObject = z.object({
+  id: z.string(),
+  task: z.string(),
+  active: z.boolean(),
+  deduplicationKey: z.string().nullish(),
+  externalId: z.string().nullish(),
+  generator: z.object({
+    type: z.literal("CRON"),
+    expression: z.string(),
+    description: z.string()
+  }),
+  nextRun: z.coerce.date().nullish(),
+  environments: z.array(z.object({
+    id: z.string(),
+    type: z.string(),
+    userName: z.string().nullish()
+  }))
+});
+var DeletedScheduleObject = z.object({
+  id: z.string()
+});
+var ListSchedulesResult = z.object({
+  data: z.array(ScheduleObject),
+  pagination: z.object({
+    currentPage: z.number(),
+    totalPages: z.number(),
+    count: z.number()
+  })
+});
+var ListScheduleOptions = z.object({
+  page: z.number().optional(),
+  perPage: z.number().optional()
+});
+var RunStatus = z.enum([
+  "PENDING",
+  "EXECUTING",
+  "PAUSED",
+  "COMPLETED",
+  "FAILED",
+  "CANCELED"
 ]);
-var PreStopCauses = z.enum([
-  "terminate"
+var AttemptStatus = z.enum([
+  "PENDING",
+  "EXECUTING",
+  "PAUSED",
+  "COMPLETED",
+  "FAILED",
+  "CANCELED"
 ]);
-var RegexSchema = z.custom((val) => {
-  try {
-    return typeof val.test === "function";
-  } catch {
-    return false;
-  }
-});
-var Config = z.object({
-  project: z.string(),
-  triggerDirectories: z.string().array().optional(),
-  triggerUrl: z.string().optional(),
-  projectDir: z.string().optional(),
-  tsconfigPath: z.string().optional(),
-  retries: z.object({
-    enabledInDev: z.boolean().default(true),
-    default: RetryOptions.optional()
-  }).optional(),
-  additionalPackages: z.string().array().optional(),
-  additionalFiles: z.string().array().optional(),
-  dependenciesToBundle: z.array(z.union([
-    z.string(),
-    RegexSchema
-  ])).optional(),
-  logLevel: z.string().optional()
+var RetrieveRunResponse = z.object({
+  id: z.string(),
+  status: RunStatus,
+  taskIdentifier: z.string(),
+  idempotencyKey: z.string().optional(),
+  version: z.string().optional(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+  attempts: z.array(z.object({
+    id: z.string(),
+    status: AttemptStatus,
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
+    startedAt: z.coerce.date().optional(),
+    completedAt: z.coerce.date().optional()
+  }).optional())
 });
-var WaitReason = z.enum([
-  "WAIT_FOR_DURATION",
-  "WAIT_FOR_TASK",
-  "WAIT_FOR_BATCH"
+var BackgroundWorkerServerMessages = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("EXECUTE_RUNS"),
+    payloads: z.array(TaskRunExecutionPayload)
+  }),
+  z.object({
+    type: z.literal("CANCEL_ATTEMPT"),
+    taskAttemptId: z.string(),
+    taskRunId: z.string()
+  }),
+  z.object({
+    type: z.literal("SCHEDULE_ATTEMPT"),
+    image: z.string(),
+    version: z.string(),
+    machine: Machine,
+    // identifiers
+    id: z.string(),
+    envId: z.string(),
+    envType: EnvironmentType,
+    orgId: z.string(),
+    projectId: z.string(),
+    runId: z.string()
+  })
 ]);
-var ProviderToPlatformMessages = {
-  LOG: {
+var serverWebsocketMessages = {
+  SERVER_READY: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string()
+  }),
+  BACKGROUND_WORKER_MESSAGE: z.object({
+    version: z.literal("v1").default("v1"),
+    backgroundWorkerId: z.string(),
+    data: BackgroundWorkerServerMessages
+  })
+};
+var BackgroundWorkerClientMessages = z.discriminatedUnion("type", [
+  z.object({
+    version: z.literal("v1").default("v1"),
+    type: z.literal("TASK_RUN_COMPLETED"),
+    completion: TaskRunExecutionResult,
+    execution: TaskRunExecution
+  }),
+  z.object({
+    version: z.literal("v1").default("v1"),
+    type: z.literal("TASK_HEARTBEAT"),
+    id: z.string()
+  })
+]);
+var BackgroundWorkerProperties = z.object({
+  id: z.string(),
+  version: z.string(),
+  contentHash: z.string()
+});
+var clientWebsocketMessages = {
+  READY_FOR_TASKS: z.object({
+    version: z.literal("v1").default("v1"),
+    backgroundWorkerId: z.string()
+  }),
+  BACKGROUND_WORKER_DEPRECATED: z.object({
+    version: z.literal("v1").default("v1"),
+    backgroundWorkerId: z.string()
+  }),
+  BACKGROUND_WORKER_MESSAGE: z.object({
+    version: z.literal("v1").default("v1"),
+    backgroundWorkerId: z.string(),
+    data: BackgroundWorkerClientMessages
+  })
+};
+var workerToChildMessages = {
+  EXECUTE_TASK_RUN: z.object({
+    version: z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
+    traceContext: z.record(z.unknown()),
+    metadata: BackgroundWorkerProperties
+  }),
+  TASK_RUN_COMPLETED_NOTIFICATION: z.object({
+    version: z.literal("v1").default("v1"),
+    completion: TaskRunExecutionResult,
+    execution: TaskRunExecution
+  }),
+  CLEANUP: z.object({
+    version: z.literal("v1").default("v1"),
+    flush: z.boolean().default(false),
+    kill: z.boolean().default(true)
+  })
+};
+var UncaughtExceptionMessage = z.object({
+  version: z.literal("v1").default("v1"),
+  error: z.object({
+    name: z.string(),
+    message: z.string(),
+    stack: z.string().optional()
+  }),
+  origin: z.enum([
+    "uncaughtException",
+    "unhandledRejection"
+  ])
+});
+var TaskMetadataFailedToParseData = z.object({
+  version: z.literal("v1").default("v1"),
+  tasks: z.unknown(),
+  zodIssues: z.custom((v) => {
+    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
+  })
+});
+var childToWorkerMessages = {
+  TASK_RUN_COMPLETED: z.object({
+    version: z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
+    result: TaskRunExecutionResult
+  }),
+  TASKS_READY: z.object({
+    version: z.literal("v1").default("v1"),
+    tasks: TaskMetadataWithFilePath.array()
+  }),
+  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
+  TASK_HEARTBEAT: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string()
+  }),
+  READY_TO_DISPOSE: z.undefined(),
+  WAIT_FOR_DURATION: z.object({
+    version: z.literal("v1").default("v1"),
+    ms: z.number()
+  }),
+  WAIT_FOR_TASK: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string()
+  }),
+  WAIT_FOR_BATCH: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string(),
+    runs: z.string().array()
+  }),
+  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
+};
+var ProdChildToWorkerMessages = {
+  TASK_RUN_COMPLETED: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      data: z.string()
+      execution: TaskRunExecution,
+      result: TaskRunExecutionResult
     })
   },
-  LOG_WITH_ACK: {
+  TASKS_READY: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      data: z.string()
-    }),
-    callback: z.object({
-      status: z.literal("ok")
+      tasks: TaskMetadataWithFilePath.array()
     })
-  }
-};
-var PlatformToProviderMessages = {
-  HEALTH: {
+  },
+  TASKS_FAILED_TO_PARSE: {
+    message: TaskMetadataFailedToParseData
+  },
+  TASK_HEARTBEAT: {
     message: z.object({
-      version: z.literal("v1").default("v1")
-    }),
-    callback: z.object({
-      status: z.literal("ok")
+      version: z.literal("v1").default("v1"),
+      id: z.string()
     })
   },
-  INDEX: {
+  READY_TO_DISPOSE: {
+    message: z.undefined()
+  },
+  READY_FOR_CHECKPOINT: {
     message: z.object({
-      version: z.literal("v1").default("v1"),
-      imageTag: z.string(),
-      shortCode: z.string(),
-      apiKey: z.string(),
-      apiUrl: z.string(),
-      // identifiers
-      envId: z.string(),
-      envType: EnvironmentType,
-      orgId: z.string(),
-      projectId: z.string()
-    }),
-    callback: z.discriminatedUnion("success", [
+      version: z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: z.discriminatedUnion("version", [
       z.object({
-        success: z.literal(false),
-        error: z.object({
-          name: z.string(),
-          message: z.string(),
-          stack: z.string().optional()
-        })
+        version: z.literal("v1")
       }),
       z.object({
-        success: z.literal(true)
+        version: z.literal("v2"),
+        reason: WaitReason.optional()
       })
-    ])
+    ]).default({
+      version: "v1"
+    }),
+    callback: z.object({
+      // TODO: Figure out how best to handle callback schema parsing in zod IPC
+      version: z.literal("v2"),
+      checkpointCanceled: z.boolean(),
+      reason: WaitReason.optional()
+    })
   },
-  // TODO: this should be a shared queue message instead
-  RESTORE: {
+  WAIT_FOR_DURATION: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      type: z.enum([
-        "DOCKER",
-        "KUBERNETES"
-      ]),
-      location: z.string(),
-      reason: z.string().optional(),
-      imageRef: z.string(),
-      machine: Machine,
-      // identifiers
-      checkpointId: z.string(),
-      envId: z.string(),
-      envType: EnvironmentType,
-      orgId: z.string(),
-      projectId: z.string(),
-      runId: z.string()
+      ms: z.number(),
+      now: z.number()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
     })
   },
-  DELETE: {
+  WAIT_FOR_TASK: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      name: z.string()
-    }),
-    callback: z.object({
-      message: z.string()
+      friendlyId: z.string()
     })
   },
-  GET: {
+  WAIT_FOR_BATCH: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      name: z.string()
+      batchFriendlyId: z.string(),
+      runFriendlyIds: z.string().array()
+    })
+  },
+  UNCAUGHT_EXCEPTION: {
+    message: UncaughtExceptionMessage
+  }
+};
+var ProdWorkerToChildMessages = {
+  EXECUTE_TASK_RUN: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      traceContext: z.record(z.unknown()),
+      metadata: BackgroundWorkerProperties
+    })
+  },
+  TASK_RUN_COMPLETED_NOTIFICATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      completion: TaskRunExecutionResult,
+      execution: TaskRunExecution
+    })
+  },
+  CLEANUP: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      flush: z.boolean().default(false),
+      kill: z.boolean().default(true)
+    }),
+    callback: z.void()
+  },
+  WAIT_COMPLETED_NOTIFICATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  }
+};
+var ProviderToPlatformMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      data: z.string()
+    })
+  },
+  LOG_WITH_ACK: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      data: z.string()
+    }),
+    callback: z.object({
+      status: z.literal("ok")
+    })
+  },
+  WORKER_CRASHED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      reason: z.string().optional(),
+      exitCode: z.number().optional(),
+      message: z.string().optional(),
+      logs: z.string().optional()
+    })
+  },
+  INDEXING_FAILED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      error: z.object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().optional()
+      })
+    })
+  }
+};
+var PlatformToProviderMessages = {
+  HEALTH: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    }),
+    callback: z.object({
+      status: z.literal("ok")
+    })
+  },
+  INDEX: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      imageTag: z.string(),
+      shortCode: z.string(),
+      apiKey: z.string(),
+      apiUrl: z.string(),
+      // identifiers
+      envId: z.string(),
+      envType: EnvironmentType,
+      orgId: z.string(),
+      projectId: z.string(),
+      deploymentId: z.string()
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false),
+        error: z.object({
+          name: z.string(),
+          message: z.string(),
+          stack: z.string().optional()
+        })
+      }),
+      z.object({
+        success: z.literal(true)
+      })
+    ])
+  },
+  // TODO: this should be a shared queue message instead
+  RESTORE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      type: z.enum([
+        "DOCKER",
+        "KUBERNETES"
+      ]),
+      location: z.string(),
+      reason: z.string().optional(),
+      imageRef: z.string(),
+      machine: Machine,
+      // identifiers
+      checkpointId: z.string(),
+      envId: z.string(),
+      envType: EnvironmentType,
+      orgId: z.string(),
+      projectId: z.string(),
+      runId: z.string()
+    })
+  },
+  DELETE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      name: z.string()
+    }),
+    callback: z.object({
+      message: z.string()
+    })
+  },
+  GET: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      name: z.string()
     })
   }
 };
@@ -1096,8 +1615,21 @@ var ProdWorkerToCoordinatorMessages = {
     })
   },
   CANCEL_CHECKPOINT: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
+    message: z.discriminatedUnion("version", [
+      z.object({
+        version: z.literal("v1")
+      }),
+      z.object({
+        version: z.literal("v2"),
+        reason: WaitReason.optional()
+      })
+    ]).default({
+      version: "v1"
+    }),
+    callback: z.object({
+      version: z.literal("v2").default("v2"),
+      checkpointCanceled: z.boolean(),
+      reason: WaitReason.optional()
     })
   },
   TASK_HEARTBEAT: {
@@ -1411,287 +1943,116 @@ var SpanMessagingEvent = z.object({
   destination: z.string().optional()
 });
 
-// src/zodfetch.ts
-async function zodfetch(schema, url, requestInit, options) {
-  return await _doZodFetch(schema, url, requestInit, options);
+// src/v3/utils/platform.ts
+var _globalThis = typeof globalThis === "object" ? globalThis : global;
+
+// src/v3/utils/globals.ts
+var GLOBAL_TRIGGER_DOT_DEV_KEY = Symbol.for(`dev.trigger.ts.api`);
+var _global = _globalThis;
+function registerGlobal(type, instance, allowOverride = false) {
+  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] ?? {};
+  if (!allowOverride && api[type]) {
+    return false;
+  }
+  api[type] = instance;
+  return true;
 }
-__name(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) {
-      return {
-        ok: false,
-        error: `404: ${response.statusText}`
-      };
+__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];
+  }
+}
+__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 (response.status >= 400 && response.status < 500 && response.status !== 429) {
-      const body = await response.json();
-      if (!body.error) {
-        return {
-          ok: false,
-          error: "Something went wrong"
-        };
-      }
+    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 {
-        ok: false,
-        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
+        ...this.contextAttributes,
+        ...this.workerAttributes
       };
-      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 {};
+  }
+  get workerAttributes() {
+    if (this.worker) {
       return {
-        ok: false,
-        error: `Failed to fetch ${url}, got status code ${response.status}`
-      };
-    }
-    const jsonBody = await response.json();
-    const parsedResult = schema.safeParse(jsonBody);
-    if (parsedResult.success) {
-      return {
-        ok: true,
-        data: parsedResult.data
-      };
-    }
-    if ("error" in jsonBody) {
-      return {
-        ok: false,
-        error: typeof jsonBody.error === "string" ? jsonBody.error : JSON.stringify(jsonBody.error)
-      };
-    }
-    return {
-      ok: false,
-      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(_doZodFetch, "_doZodFetch");
-
-// src/v3/utils/flattenAttributes.ts
-function flattenAttributes(obj, prefix) {
-  const result = {};
-  if (!obj) {
-    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}.` : ""}${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];
-        }
-      }
-    } else if (isRecord(value)) {
-      Object.assign(result, flattenAttributes(value, newPrefix));
-    } else {
-      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
-        result[newPrefix] = value;
-      }
-    }
-  }
-  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;
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const parts = key.split(".").reduce((acc, part) => {
-      if (detectIsArrayIndex(part)) {
-        acc.push(part);
-      } else {
-        acc.push(...part.split(/\.\[(.*?)\]/).filter(Boolean));
-      }
-      return acc;
-    }, []);
-    let current = result;
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i];
-      const isArray = detectIsArrayIndex(part);
-      const cleanPart = isArray ? part.substring(1, part.length - 1) : part;
-      const nextIsArray = detectIsArrayIndex(parts[i + 1]);
-      if (!current[cleanPart]) {
-        current[cleanPart] = nextIsArray ? [] : {};
-      }
-      current = current[cleanPart];
-    }
-    const lastPart = parts[parts.length - 1];
-    const cleanLastPart = detectIsArrayIndex(lastPart) ? parseInt(lastPart.substring(1, lastPart.length - 1), 10) : lastPart;
-    current[cleanLastPart] = value;
-  }
-  return result;
-}
-__name(unflattenAttributes, "unflattenAttributes");
-function detectIsArrayIndex(key) {
-  const match = key.match(/^\[(\d+)\]$/);
-  if (match) {
-    return true;
-  }
-  return false;
-}
-__name(detectIsArrayIndex, "detectIsArrayIndex");
-function primitiveValueOrflattenedAttributes(obj, prefix) {
-  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || obj === void 0) {
-    return obj;
-  }
-  const attributes = flattenAttributes(obj, prefix);
-  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
-    return attributes[prefix];
-  }
-  return attributes;
-}
-__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
-var _SafeAsyncLocalStorage = class _SafeAsyncLocalStorage {
-  constructor() {
-    this.storage = new AsyncLocalStorage();
-  }
-  runWith(context3, fn) {
-    return this.storage.run(context3, fn);
-  }
-  getStore() {
-    return this.storage.getStore();
-  }
-};
-__name(_SafeAsyncLocalStorage, "SafeAsyncLocalStorage");
-var SafeAsyncLocalStorage = _SafeAsyncLocalStorage;
-
-// src/v3/semanticInternalAttributes.ts
-var SemanticInternalAttributes = {
-  ENVIRONMENT_ID: "ctx.environment.id",
-  ENVIRONMENT_TYPE: "ctx.environment.type",
-  ORGANIZATION_ID: "ctx.organization.id",
-  ORGANIZATION_SLUG: "ctx.organization.slug",
-  ORGANIZATION_NAME: "ctx.organization.name",
-  PROJECT_ID: "ctx.project.id",
-  PROJECT_REF: "ctx.project.ref",
-  PROJECT_NAME: "ctx.project.title",
-  PROJECT_DIR: "project.dir",
-  ATTEMPT_ID: "ctx.attempt.id",
-  ATTEMPT_NUMBER: "ctx.attempt.number",
-  RUN_ID: "ctx.run.id",
-  RUN_IS_TEST: "ctx.run.isTest",
-  BATCH_ID: "ctx.batch.id",
-  TASK_SLUG: "ctx.task.id",
-  TASK_PATH: "ctx.task.filePath",
-  TASK_EXPORT_NAME: "ctx.task.exportName",
-  QUEUE_NAME: "ctx.queue.name",
-  QUEUE_ID: "ctx.queue.id",
-  SPAN_PARTIAL: "$span.partial",
-  SPAN_ID: "$span.span_id",
-  OUTPUT: "$output",
-  OUTPUT_TYPE: "$mime_type_output",
-  STYLE: "$style",
-  STYLE_ICON: "$style.icon",
-  STYLE_VARIANT: "$style.variant",
-  STYLE_ACCESSORY: "$style.accessory",
-  METADATA: "$metadata",
-  TRIGGER: "$trigger",
-  PAYLOAD: "$payload",
-  PAYLOAD_TYPE: "$mime_type_payload",
-  SHOW: "$show",
-  SHOW_ACTIONS: "$show.actions",
-  WORKER_ID: "worker.id",
-  WORKER_VERSION: "worker.version",
-  CLI_VERSION: "cli.version",
-  SDK_VERSION: "sdk.version",
-  SDK_LANGUAGE: "sdk.language",
-  RETRY_AT: "retry.at",
-  RETRY_DELAY: "retry.delay",
-  RETRY_COUNT: "retry.count"
-};
-
-// src/v3/tasks/taskContextManager.ts
-var _getStore, getStore_fn;
-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
+        [SemanticInternalAttributes.WORKER_ID]: this.worker.id,
+        [SemanticInternalAttributes.WORKER_VERSION]: this.worker.version
       };
     }
     return {};
@@ -1716,84 +2077,33 @@ var _TaskContextManager = class _TaskContextManager {
         [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.BATCH_ID]: this.ctx.batch?.id,
+        [SemanticInternalAttributes.IDEMPOTENCY_KEY]: this.ctx.run.idempotencyKey
       };
     }
     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);
+  disable() {
+    unregisterGlobal(API_NAME);
   }
-  shutdown() {
-    return this._innerProcessor.shutdown();
+  setGlobalTaskContext(taskContext2) {
+    return registerGlobal(API_NAME, taskContext2);
   }
 };
-__name(_TaskContextLogProcessor, "TaskContextLogProcessor");
-var TaskContextLogProcessor = _TaskContextLogProcessor;
+_getTaskContext = new WeakSet();
+getTaskContext_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME);
+}, "#getTaskContext");
+__name(_TaskContextAPI, "TaskContextAPI");
+var TaskContextAPI = _TaskContextAPI;
 
-// 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/task-context-api.ts
+var taskContext = TaskContextAPI.getInstance();
 
 // src/v3/apiClient/index.ts
 var zodFetchOptions = {
   retry: {
-    maxAttempts: 5,
+    maxAttempts: 3,
     minTimeoutInMs: 1e3,
     maxTimeoutInMs: 3e4,
     factor: 2,
@@ -1807,6 +2117,27 @@ var _ApiClient = class _ApiClient {
     this.accessToken = accessToken;
     this.baseUrl = baseUrl.replace(/\/$/, "");
   }
+  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;
+        }
+      }
+      throw error;
+    }
+  }
+  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);
+  }
   triggerTask(taskId, body, options) {
     return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, {
       method: "POST",
@@ -1833,6 +2164,75 @@ var _ApiClient = class _ApiClient {
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
     }, zodFetchOptions);
   }
+  retrieveRun(runId) {
+    return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v3/runs/${runId}`, {
+      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);
+  }
+  createSchedule(options) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(options)
+    });
+  }
+  listSchedules(options) {
+    const searchParams = new URLSearchParams();
+    if (options?.page) {
+      searchParams.append("page", options.page.toString());
+    }
+    if (options?.perPage) {
+      searchParams.append("perPage", options.perPage.toString());
+    }
+    return zodfetch(ListSchedulesResult, `${this.baseUrl}/api/v1/schedules${searchParams.size > 0 ? `?${searchParams}` : ""}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  retrieveSchedule(scheduleId) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  updateSchedule(scheduleId, options) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(options)
+    });
+  }
+  deactivateSchedule(scheduleId) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/deactivate`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  activateSchedule(scheduleId) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/activate`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  deleteSchedule(scheduleId) {
+    return zodfetch(DeletedScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "DELETE",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
 };
 _getHeaders = new WeakSet();
 getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
@@ -1840,7 +2240,7 @@ getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
     "Content-Type": "application/json",
     Authorization: `Bearer ${this.accessToken}`
   };
-  if (taskContextManager.isInsideTask) {
+  if (taskContext.isInsideTask) {
     propagation.inject(context.active(), headers);
     if (spanParentAsLink) {
       headers["x-trigger-span-parent-as-link"] = "1";
@@ -1850,760 +2250,56 @@ 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();
+    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";
-  }
-  get accessToken() {
-    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
-    return store?.accessToken ?? getEnvVar("TRIGGER_SECRET_KEY");
-  }
-  get client() {
-    if (!this.baseURL || !this.accessToken) {
-      return void 0;
-    }
-    return new ApiClient(this.baseURL, this.accessToken);
-  }
-  runWith(context3, fn) {
-    return this._storage.runWith(context3, fn);
-  }
-};
-_getStore2 = new WeakSet();
-getStore_fn2 = /* @__PURE__ */ __name(function() {
-  return this._storage.getStore();
-}, "#getStore");
-__name(_ApiClientManager, "ApiClientManager");
-var ApiClientManager = _ApiClientManager;
-var apiClientManager = new ApiClientManager();
-var _ZodSchemaParsedError = class _ZodSchemaParsedError extends Error {
-  constructor(error, payload) {
-    super(error.message);
-    this.error = error;
-    this.payload = payload;
-  }
-};
-__name(_ZodSchemaParsedError, "ZodSchemaParsedError");
-var ZodSchemaParsedError = _ZodSchemaParsedError;
-var ZodMessageSchema = z.object({
-  version: z.literal("v1").default("v1"),
-  type: z.string(),
-  payload: z.unknown()
-});
-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)}`);
-    }
-    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 = z.object({
-  version: z.literal("v1").default("v1"),
-  type: z.string(),
-  payload: z.unknown()
-});
-var _schema3, _handlers2;
-var _ZodSocketMessageHandler = class _ZodSocketMessageHandler {
-  constructor(options) {
-    __privateAdd(this, _schema3, void 0);
-    __privateAdd(this, _handlers2, void 0);
-    __privateSet(this, _schema3, options.schema);
-    __privateSet(this, _handlers2, options.handlers);
-  }
-  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;
+  reset() {
   }
 };
-_schema4 = new WeakMap();
-_socket = new WeakMap();
-__name(_ZodSocketMessageSender, "ZodSocketMessageSender");
-var ZodSocketMessageSender = _ZodSocketMessageSender;
-var _sender2, _handler, _logger;
-var _ZodSocketConnection = class _ZodSocketConnection {
-  constructor(opts) {
-    __privateAdd(this, _sender2, void 0);
-    __privateAdd(this, _handler, void 0);
-    __privateAdd(this, _logger, void 0);
-    const uri = `${opts.secure ? "wss" : "ws"}://${opts.host}:${opts.port ?? (opts.secure ? "443" : "80")}/${opts.namespace}`;
-    const logger2 = new SimpleStructuredLogger(opts.namespace, LogLevel.info);
-    logger2.log("new zod socket", {
-      uri
-    });
-    this.socket = io(uri, {
-      transports: [
-        "websocket"
-      ],
-      auth: {
-        token: opts.authToken
-      },
-      extraHeaders: opts.extraHeaders,
-      reconnectionDelay: 500,
-      reconnectionDelayMax: 1e3
-    });
-    __privateSet(this, _logger, logger2.child({
-      socketId: this.socket.id
-    }));
-    __privateSet(this, _handler, new ZodSocketMessageHandler({
-      schema: opts.serverMessages,
-      handlers: opts.handlers
-    }));
-    __privateGet(this, _handler).registerHandlers(this.socket, __privateGet(this, _logger));
-    __privateSet(this, _sender2, new ZodSocketMessageSender({
-      schema: opts.clientMessages,
-      socket: this.socket
-    }));
-    this.socket.on("connect_error", async (error) => {
-      __privateGet(this, _logger).error(`connect_error: ${error}`);
-      if (opts.onError) {
-        await opts.onError(this.socket, error, __privateGet(this, _logger));
-      }
-    });
-    this.socket.on("connect", async () => {
-      __privateGet(this, _logger).info("connect");
-      if (opts.onConnection) {
-        await opts.onConnection(this.socket, __privateGet(this, _handler), __privateGet(this, _sender2), __privateGet(this, _logger));
-      }
-    });
-    this.socket.on("disconnect", async (reason, description) => {
-      __privateGet(this, _logger).info("disconnect", {
-        reason,
-        description
-      });
-      if (opts.onDisconnect) {
-        await opts.onDisconnect(this.socket, reason, description, __privateGet(this, _logger));
-      }
-    });
-  }
-  close() {
-    this.socket.close();
-  }
-  connect() {
-    this.socket.connect();
-  }
-  get send() {
-    return __privateGet(this, _sender2).send.bind(__privateGet(this, _sender2));
-  }
-  get sendWithAck() {
-    return __privateGet(this, _sender2).sendWithAck.bind(__privateGet(this, _sender2));
-  }
-};
-_sender2 = new WeakMap();
-_handler = new WeakMap();
-_logger = new WeakMap();
-__name(_ZodSocketConnection, "ZodSocketConnection");
-var ZodSocketConnection = _ZodSocketConnection;
+__name(_SimpleClock, "SimpleClock");
+var SimpleClock = _SimpleClock;
 
-// src/v3/zodNamespace.ts
-var LogLevel;
-(function(LogLevel2) {
-  LogLevel2[LogLevel2["log"] = 0] = "log";
-  LogLevel2[LogLevel2["error"] = 1] = "error";
-  LogLevel2[LogLevel2["warn"] = 2] = "warn";
-  LogLevel2[LogLevel2["info"] = 3] = "info";
-  LogLevel2[LogLevel2["debug"] = 4] = "debug";
-})(LogLevel || (LogLevel = {}));
-var _structuredLog, structuredLog_fn;
-var _SimpleStructuredLogger = class _SimpleStructuredLogger {
-  constructor(name, level = [
-    "1",
-    "true"
-  ].includes(process.env.DEBUG ?? "") ? LogLevel.debug : LogLevel.info, fields) {
-    __privateAdd(this, _structuredLog);
-    this.name = name;
-    this.level = level;
-    this.fields = fields;
-  }
-  child(fields, level) {
-    return new _SimpleStructuredLogger(this.name, level, {
-      ...this.fields,
-      ...fields
-    });
-  }
-  log(message, ...args) {
-    if (this.level < LogLevel.log)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
-  }
-  error(message, ...args) {
-    if (this.level < LogLevel.error)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
-  }
-  warn(message, ...args) {
-    if (this.level < LogLevel.warn)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
-  }
-  info(message, ...args) {
-    if (this.level < LogLevel.info)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
-  }
-  debug(message, ...args) {
-    if (this.level < LogLevel.debug)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, "debug", ...args);
-  }
-};
-_structuredLog = new WeakSet();
-structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
-  const structuredLog = {
-    ...args.length === 1 ? args[0] : args,
-    ...this.fields,
-    timestamp: /* @__PURE__ */ new Date(),
-    name: this.name,
-    message,
-    level
-  };
-  loggerFunction(JSON.stringify(structuredLog));
-}, "#structuredLog");
-__name(_SimpleStructuredLogger, "SimpleStructuredLogger");
-var SimpleStructuredLogger = _SimpleStructuredLogger;
-var _logger2, _handler2;
-var _ZodNamespace = class _ZodNamespace {
-  constructor(opts) {
-    __privateAdd(this, _logger2, void 0);
-    __privateAdd(this, _handler2, void 0);
-    __privateSet(this, _logger2, opts.logger ?? new SimpleStructuredLogger(opts.name));
-    __privateSet(this, _handler2, new ZodSocketMessageHandler({
-      schema: opts.clientMessages,
-      handlers: opts.handlers
-    }));
-    this.io = opts.io;
-    this.namespace = this.io.of(opts.name);
-    this.sender = new ZodMessageSender({
-      schema: opts.serverMessages,
-      sender: async (message) => {
-        return new Promise((resolve, reject) => {
-          try {
-            this.namespace.emit(message.type, message.payload);
-            resolve();
-          } catch (err) {
-            reject(err);
-          }
-        });
-      }
-    });
-    if (opts.preAuth) {
-      this.namespace.use(async (socket, next) => {
-        const logger2 = __privateGet(this, _logger2).child({
-          socketId: socket.id,
-          socketStage: "preAuth"
-        });
-        if (typeof opts.preAuth === "function") {
-          await opts.preAuth(socket, next, logger2);
-        }
-      });
-    }
-    if (opts.authToken) {
-      this.namespace.use((socket, next) => {
-        const logger2 = __privateGet(this, _logger2).child({
-          socketId: socket.id,
-          socketStage: "auth"
-        });
-        const { auth } = socket.handshake;
-        if (!("token" in auth)) {
-          logger2.error("no token");
-          return socket.disconnect(true);
-        }
-        if (auth.token !== opts.authToken) {
-          logger2.error("invalid token");
-          return socket.disconnect(true);
-        }
-        logger2.info("success");
-        next();
-      });
-    }
-    if (opts.postAuth) {
-      this.namespace.use(async (socket, next) => {
-        const logger2 = __privateGet(this, _logger2).child({
-          socketId: socket.id,
-          socketStage: "auth"
-        });
-        if (typeof opts.postAuth === "function") {
-          await opts.postAuth(socket, next, logger2);
-        }
-      });
-    }
-    this.namespace.on("connection", async (socket) => {
-      const logger2 = __privateGet(this, _logger2).child({
-        socketId: socket.id,
-        socketStage: "connection"
-      });
-      logger2.info("connected");
-      __privateGet(this, _handler2).registerHandlers(socket, logger2);
-      socket.on("disconnect", async (reason, description) => {
-        logger2.info("disconnect", {
-          reason,
-          description
-        });
-        if (opts.onDisconnect) {
-          await opts.onDisconnect(socket, reason, description, logger2);
-        }
-      });
-      socket.on("error", async (error) => {
-        logger2.error("error", {
-          error
-        });
-        if (opts.onError) {
-          await opts.onError(socket, error, logger2);
-        }
-      });
-      if (opts.onConnection) {
-        await opts.onConnection(socket, __privateGet(this, _handler2), this.sender, logger2);
-      }
-    });
-  }
-  fetchSockets() {
-    return this.namespace.fetchSockets();
-  }
-};
-_logger2 = new WeakMap();
-_handler2 = new WeakMap();
-__name(_ZodNamespace, "ZodNamespace");
-var ZodNamespace = _ZodNamespace;
-var messageSchema2 = z.object({
-  version: z.literal("v1").default("v1"),
-  type: z.string(),
-  payload: z.unknown()
-});
-var _schema5, _handlers3, _sender3, _a;
-var ZodIpcMessageHandler = (_a = class {
-  constructor(options) {
-    __privateAdd(this, _schema5, void 0);
-    __privateAdd(this, _handlers3, void 0);
-    __privateAdd(this, _sender3, void 0);
-    __privateSet(this, _schema5, options.schema);
-    __privateSet(this, _handlers3, options.handlers);
-    __privateSet(this, _sender3, options.sender);
-  }
-  async handleMessage(message) {
-    const parsedMessage = this.parseMessage(message);
-    if (!__privateGet(this, _handlers3)) {
-      throw new Error("No handlers provided");
-    }
-    const handler = __privateGet(this, _handlers3)[parsedMessage.type];
-    if (!handler) {
-      return;
-    }
-    const ack = await handler(parsedMessage.payload, __privateGet(this, _sender3));
-    return ack;
+// 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);
   }
-  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)}`);
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _ClockAPI();
     }
-    return {
-      type: parsedMessage.data.type,
-      payload: parsedPayload.data
-    };
-  }
-}, _schema5 = new WeakMap(), _handlers3 = new WeakMap(), _sender3 = new WeakMap(), __name(_a, "ZodIpcMessageHandler"), _a);
-var Packet = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("CONNECT"),
-    sessionId: z.string().optional()
-  }),
-  z.object({
-    type: z.literal("ACK"),
-    message: z.any(),
-    id: z.number()
-  }),
-  z.object({
-    type: z.literal("EVENT"),
-    message: z.any(),
-    id: z.number().optional()
-  })
-]);
-var _sessionId, _messageCounter, _handler3, _acks, _registerHandlers, registerHandlers_fn, _handlePacket, handlePacket_fn, _sendPacket, sendPacket_fn;
-var _ZodIpcConnection = class _ZodIpcConnection {
-  constructor(opts) {
-    __privateAdd(this, _registerHandlers);
-    __privateAdd(this, _handlePacket);
-    __privateAdd(this, _sendPacket);
-    __privateAdd(this, _sessionId, void 0);
-    __privateAdd(this, _messageCounter, void 0);
-    __privateAdd(this, _handler3, void 0);
-    __privateAdd(this, _acks, void 0);
-    this.opts = opts;
-    __privateSet(this, _messageCounter, 0);
-    __privateSet(this, _acks, /* @__PURE__ */ new Map());
-    __privateSet(this, _handler3, new ZodIpcMessageHandler({
-      schema: opts.listenSchema,
-      handlers: opts.handlers,
-      sender: {
-        send: this.send.bind(this),
-        sendWithAck: this.sendWithAck.bind(this)
-      }
-    }));
-    __privateMethod(this, _registerHandlers, registerHandlers_fn).call(this);
+    return this._instance;
   }
-  async connect() {
-    __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
-      type: "CONNECT"
-    });
+  setGlobalClock(clock2) {
+    return registerGlobal(API_NAME2, clock2);
   }
-  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"
-      }
-    });
+  preciseNow() {
+    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
   }
-  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
-      });
-    });
+  reset() {
+    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
   }
 };
-_sessionId = new WeakMap();
-_messageCounter = new WeakMap();
-_handler3 = new WeakMap();
-_acks = new WeakMap();
-_registerHandlers = new WeakSet();
-registerHandlers_fn = /* @__PURE__ */ __name(async function() {
-  if (!this.opts.process.on) {
-    return;
-  }
-  this.opts.process.on("message", async (message) => {
-    __privateMethod(this, _handlePacket, handlePacket_fn).call(this, message);
-  });
-}, "#registerHandlers");
-_handlePacket = new WeakSet();
-handlePacket_fn = /* @__PURE__ */ __name(async function(packet) {
-  const parsedPacket = Packet.safeParse(packet);
-  if (!parsedPacket.success) {
-    return;
-  }
-  switch (parsedPacket.data.type) {
-    case "ACK": {
-      const ack = __privateGet(this, _acks).get(parsedPacket.data.id);
-      if (!ack) {
-        return;
-      }
-      clearTimeout(ack.timeout);
-      ack.resolve(parsedPacket.data.message);
-      break;
-    }
-    case "CONNECT": {
-      if (!parsedPacket.data.sessionId) {
-        const id = randomUUID();
-        await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
-          type: "CONNECT",
-          sessionId: id
-        });
-        return;
-      }
-      if (__privateGet(this, _sessionId)) {
-        return;
-      }
-      __privateSet(this, _sessionId, parsedPacket.data.sessionId);
-      break;
-    }
-    case "EVENT": {
-      const result = await __privateGet(this, _handler3).handleMessage(parsedPacket.data.message);
-      if (typeof parsedPacket.data.id === "undefined") {
-        return;
-      }
-      await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
-        type: "ACK",
-        id: parsedPacket.data.id,
-        message: result
-      });
-      break;
-    }
-  }
-}, "#handlePacket");
-_sendPacket = new WeakSet();
-sendPacket_fn = /* @__PURE__ */ __name(async function(packet1) {
-  await this.opts.process.send?.(packet1);
-}, "#sendPacket");
-__name(_ZodIpcConnection, "ZodIpcConnection");
-var ZodIpcConnection = _ZodIpcConnection;
+_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 {
@@ -2652,6 +2348,33 @@ 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 [
@@ -2660,23 +2383,23 @@ function correctErrorStackTrace(stackTrace, projectDir, options) {
   ].filter(Boolean).join("\n");
 }
 __name(correctErrorStackTrace, "correctErrorStackTrace");
+var LINES_TO_IGNORE = [
+  /ConsoleInterceptor/,
+  /TriggerTracer/,
+  /TaskExecutor/,
+  /EXECUTE_TASK_RUN/,
+  /@trigger.dev\/core/,
+  /safeJsonProcess/,
+  /__entryPoint.ts/
+];
 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) {
+  if (LINES_TO_IGNORE.some((regex) => regex.test(line))) {
     return;
   }
-  if (nodePath.basename(path) === "__entryPoint.ts") {
+  if (projectDir && !line.includes(projectDir)) {
     return;
   }
-  if (projectDir && !path.includes(projectDir)) {
-    return;
-  }
-  return line;
+  return line.trim();
 }
 __name(correctStackTraceLine, "correctStackTraceLine");
 function groupTaskMetadataIssuesByTask(tasks, issues) {
@@ -2715,272 +2438,171 @@ 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;
-  }
-  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];
+// 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(unregisterGlobal, "unregisterGlobal");
-
-// src/v3/runtime/noopRuntimeManager.ts
-var _NoopRuntimeManager = class _NoopRuntimeManager {
-  disable() {
-  }
-  registerTasks() {
-  }
-  getTaskMetadata(id) {
-    return void 0;
+__name(imposeAttributeLimits, "imposeAttributeLimits");
+function calculateAttributeValueLength(value) {
+  if (value === void 0 || value === null) {
+    return 0;
   }
-  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);
-  }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _RuntimeAPI();
-    }
-    return this._instance;
-  }
-  waitForDuration(ms) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForDuration(ms);
-  }
-  waitUntil(date) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitUntil(date);
-  }
-  waitForTask(params) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForTask(params);
-  }
-  waitForBatch(params) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForBatch(params);
+// src/v3/utils/flattenAttributes.ts
+var NULL_SENTINEL = "$@null((";
+function flattenAttributes(obj, prefix) {
+  const result = {};
+  if (obj === void 0) {
+    return result;
   }
-  setGlobalRuntimeManager(runtimeManager) {
-    return registerGlobal(API_NAME, runtimeManager);
+  if (obj === null) {
+    result[prefix || ""] = NULL_SENTINEL;
+    return result;
   }
-  disable() {
-    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
-    unregisterGlobal(API_NAME);
+  if (typeof obj === "string") {
+    result[prefix || ""] = obj;
+    return result;
   }
-  registerTasks(tasks) {
-    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).registerTasks(tasks);
+  if (typeof obj === "number") {
+    result[prefix || ""] = obj;
+    return result;
   }
-  getTaskMetadata(id) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).getTaskMetadata(id);
+  if (typeof obj === "boolean") {
+    result[prefix || ""] = obj;
+    return result;
   }
-};
-_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 SeverityNumber.UNSPECIFIED:
-      return void 0;
-    case SeverityNumber.TRACE:
-    case SeverityNumber.TRACE2:
-    case SeverityNumber.TRACE3:
-    case SeverityNumber.TRACE4:
-      return "trace";
-    case SeverityNumber.DEBUG:
-    case SeverityNumber.DEBUG2:
-    case SeverityNumber.DEBUG3:
-    case SeverityNumber.DEBUG4:
-      return "debug";
-    case SeverityNumber.INFO:
-    case SeverityNumber.INFO2:
-    case SeverityNumber.INFO3:
-    case SeverityNumber.INFO4:
-      return "info";
-    case SeverityNumber.WARN:
-    case SeverityNumber.WARN2:
-    case SeverityNumber.WARN3:
-    case SeverityNumber.WARN4:
-      return "warn";
-    case SeverityNumber.ERROR:
-    case SeverityNumber.ERROR2:
-    case SeverityNumber.ERROR3:
-    case SeverityNumber.ERROR4:
-      return "error";
-    case SeverityNumber.FATAL:
-    case SeverityNumber.FATAL2:
-    case SeverityNumber.FATAL3:
-    case SeverityNumber.FATAL4:
-      return "fatal";
+  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 result;
 }
-__name(iconStringForSeverity, "iconStringForSeverity");
-var _SimpleClock = class _SimpleClock {
-  preciseNow() {
-    const now = new PreciseDate();
-    const nowStruct = now.toStruct();
-    return [
-      nowStruct.seconds,
-      nowStruct.nanos
-    ];
+__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;
   }
-  reset() {
+  if (typeof obj === "object" && obj !== null && Object.keys(obj).length === 1 && Object.keys(obj)[0] === "") {
+    return rehydrateNull(obj[""]);
   }
-};
-__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);
+  if (Object.keys(obj).length === 0) {
+    return;
   }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _ClockAPI();
+  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];
     }
-    return this._instance;
+    const lastPart = parts[parts.length - 1];
+    current[lastPart] = rehydrateNull(value);
   }
-  setGlobalClock(clock2) {
-    return registerGlobal(API_NAME2, clock2);
+  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;
   }
-  preciseNow() {
-    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
+  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;
   }
-  reset() {
-    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
+  const attributes = flattenAttributes(obj, prefix);
+  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
+    return attributes[prefix];
   }
-};
-_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();
+  return attributes;
+}
+__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
+function rehydrateNull(value) {
+  if (value === NULL_SENTINEL) {
+    return null;
+  }
+  return value;
+}
+__name(rehydrateNull, "rehydrateNull");
 
 // 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);
-  }
-  debug(message, properties) {
-    if (this._level < 5)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "debug", SeverityNumber.DEBUG, properties);
-  }
-  log(message, properties) {
-    if (this._level < 3)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "log", SeverityNumber.INFO, properties);
-  }
-  info(message, properties) {
-    if (this._level < 4)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "info", SeverityNumber.INFO, properties);
-  }
-  warn(message, properties) {
-    if (this._level < 2)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "warn", SeverityNumber.WARN, properties);
-  }
-  error(message, properties) {
-    if (this._level < 1)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "error", SeverityNumber.ERROR, properties);
-  }
-  trace(name, fn, options) {
-    return this._config.tracer.startActiveSpan(name, fn, options);
-  }
-};
-_emitLog = new WeakSet();
-emitLog_fn = /* @__PURE__ */ __name(function(message, timestamp, severityText, severityNumber, properties) {
-  let attributes = {
-    ...flattenAttributes(properties)
-  };
-  const icon = iconStringForSeverity(severityNumber);
-  if (icon !== void 0) {
-    attributes[SemanticInternalAttributes.STYLE_ICON] = icon;
-  }
-  this._config.logger.emit({
-    severityNumber,
-    severityText,
-    body: message,
-    attributes,
-    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() {
   }
@@ -3048,49 +2670,209 @@ 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;
+// src/v3/runtime/noopRuntimeManager.ts
+var _NoopRuntimeManager = class _NoopRuntimeManager {
+  disable() {
+  }
+  waitForDuration(ms) {
+    return Promise.resolve();
+  }
+  waitUntil(date) {
+    return Promise.resolve();
+  }
+  waitForTask(params) {
+    return Promise.resolve({
+      ok: false,
+      id: params.id,
+      error: {
+        type: "INTERNAL_ERROR",
+        code: "CONFIGURED_INCORRECTLY"
+      }
+    });
+  }
+  waitForBatch(params) {
+    return Promise.resolve({
+      id: params.id,
+      items: []
+    });
+  }
+};
+__name(_NoopRuntimeManager, "NoopRuntimeManager");
+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);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _RuntimeAPI();
     }
-    newAttributes[key] = value;
+    return this._instance;
   }
-  return newAttributes;
-}
-__name(imposeAttributeLimits, "imposeAttributeLimits");
-function calculateAttributeValueLength(value) {
-  if (value === void 0 || value === null) {
-    return 0;
+  waitForDuration(ms) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForDuration(ms);
   }
-  if (typeof value === "string") {
-    return value.length;
+  waitUntil(date) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitUntil(date);
   }
-  if (typeof value === "number") {
-    return 8;
+  waitForTask(params) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForTask(params);
   }
-  if (typeof value === "boolean") {
-    return 4;
+  waitForBatch(params) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForBatch(params);
   }
-  if (Array.isArray(value)) {
-    return value.reduce((acc, v) => acc + calculateAttributeValueLength(v), 0);
+  setGlobalRuntimeManager(runtimeManager) {
+    return registerGlobal(API_NAME4, runtimeManager);
+  }
+  disable() {
+    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
+    unregisterGlobal(API_NAME4);
+  }
+};
+_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];
   }
-  return 0;
 }
-__name(calculateAttributeValueLength, "calculateAttributeValueLength");
+__name(getEnvVar, "getEnvVar");
+
+// src/v3/apiClientManager/index.ts
+var API_NAME5 = "api-client";
+var _getConfig, getConfig_fn;
+var _APIClientManagerAPI = class _APIClientManagerAPI {
+  constructor() {
+    __privateAdd(this, _getConfig);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _APIClientManagerAPI();
+    }
+    return this._instance;
+  }
+  disable() {
+    unregisterGlobal(API_NAME5);
+  }
+  setGlobalAPIClientConfiguration(config) {
+    return registerGlobal(API_NAME5, config);
+  }
+  get baseURL() {
+    const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
+    return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
+  }
+  get accessToken() {
+    const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
+    return store?.secretKey ?? getEnvVar("TRIGGER_SECRET_KEY");
+  }
+  get client() {
+    if (!this.baseURL || !this.accessToken) {
+      return void 0;
+    }
+    return new ApiClient(this.baseURL, this.accessToken);
+  }
+};
+_getConfig = new WeakSet();
+getConfig_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME5);
+}, "#getConfig");
+__name(_APIClientManagerAPI, "APIClientManagerAPI");
+var APIClientManagerAPI = _APIClientManagerAPI;
+
+// src/v3/apiClientManager-api.ts
+var apiClientManager = APIClientManagerAPI.getInstance();
+
+// src/v3/task-catalog/noopTaskCatalog.ts
+var _NoopTaskCatalog = class _NoopTaskCatalog {
+  registerTaskMetadata(task) {
+  }
+  registerTaskFileMetadata(id, metadata) {
+  }
+  updateTaskMetadata(id, updates) {
+  }
+  getAllTaskMetadata() {
+    return [];
+  }
+  getTaskMetadata(id) {
+    return void 0;
+  }
+  getTask(id) {
+    return void 0;
+  }
+  taskExists(id) {
+    return false;
+  }
+  disable() {
+  }
+};
+__name(_NoopTaskCatalog, "NoopTaskCatalog");
+var NoopTaskCatalog = _NoopTaskCatalog;
+
+// src/v3/task-catalog/index.ts
+var API_NAME6 = "task-catalog";
+var NOOP_TASK_CATALOG = new NoopTaskCatalog();
+var _getCatalog, getCatalog_fn;
+var _TaskCatalogAPI = class _TaskCatalogAPI {
+  constructor() {
+    __privateAdd(this, _getCatalog);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _TaskCatalogAPI();
+    }
+    return this._instance;
+  }
+  setGlobalTaskCatalog(taskCatalog2) {
+    return registerGlobal(API_NAME6, taskCatalog2);
+  }
+  disable() {
+    unregisterGlobal(API_NAME6);
+  }
+  registerTaskMetadata(task) {
+    __privateMethod(this, _getCatalog, getCatalog_fn).call(this).registerTaskMetadata(task);
+  }
+  updateTaskMetadata(id, updates) {
+    __privateMethod(this, _getCatalog, getCatalog_fn).call(this).updateTaskMetadata(id, updates);
+  }
+  registerTaskFileMetadata(id, metadata) {
+    __privateMethod(this, _getCatalog, getCatalog_fn).call(this).registerTaskFileMetadata(id, metadata);
+  }
+  getAllTaskMetadata() {
+    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).getAllTaskMetadata();
+  }
+  getTaskMetadata(id) {
+    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).getTaskMetadata(id);
+  }
+  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_NAME6) ?? NOOP_TASK_CATALOG;
+}, "#getCatalog");
+__name(_TaskCatalogAPI, "TaskCatalogAPI");
+var TaskCatalogAPI = _TaskCatalogAPI;
+
+// src/v3/task-catalog-api.ts
+var taskCatalog = TaskCatalogAPI.getInstance();
 function dateDifference(date1, date2) {
   return Math.abs(date1.getTime() - date2.getTime());
 }
@@ -3143,571 +2925,99 @@ function formatDurationMilliseconds(milliseconds, options) {
       duration = duration.replace(" hours", "h");
       duration = duration.replace(" hour", "h");
       duration = duration.replace(" days", "d");
-      duration = duration.replace(" day", "d");
-      duration = duration.replace(" weeks", "w");
-      duration = duration.replace(" week", "w");
-      duration = duration.replace(" months", "mo");
-      duration = duration.replace(" month", "mo");
-      duration = duration.replace(" years", "y");
-      duration = duration.replace(" year", "y");
-  }
-  return duration;
-}
-__name(formatDurationMilliseconds, "formatDurationMilliseconds");
-function formatDurationInDays(milliseconds) {
-  let duration = humanizeDuration(milliseconds, {
-    maxDecimalPoints: 0,
-    largest: 2,
-    units: [
-      "d"
-    ]
-  });
-  return duration;
-}
-__name(formatDurationInDays, "formatDurationInDays");
-
-// src/v3/runtime/devRuntimeManager.ts
-var _DevRuntimeManager = class _DevRuntimeManager {
-  constructor() {
-    __publicField(this, "_taskWaits", /* @__PURE__ */ new Map());
-    __publicField(this, "_batchWaits", /* @__PURE__ */ new Map());
-    __publicField(this, "_tasks", /* @__PURE__ */ new Map());
-    __publicField(this, "_pendingCompletionNotifications", /* @__PURE__ */ new Map());
-  }
-  disable() {
-  }
-  registerTasks(tasks) {
-    for (const task of tasks) {
-      this._tasks.set(task.id, task);
-    }
-  }
-  getTaskMetadata(id) {
-    return this._tasks.get(id);
-  }
-  async waitForDuration(ms) {
-    return new Promise((resolve) => {
-      setTimeout(resolve, ms);
-    });
-  }
-  async waitUntil(date) {
-    return new Promise((resolve) => {
-      setTimeout(resolve, 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;
-var _ProdRuntimeManager = class _ProdRuntimeManager {
-  constructor(ipc, options = {}) {
-    this.ipc = ipc;
-    this.options = options;
-    this._taskWaits = /* @__PURE__ */ new Map();
-    this._batchWaits = /* @__PURE__ */ new Map();
-    this._tasks = /* @__PURE__ */ new Map();
-  }
-  disable() {
-  }
-  registerTasks(tasks) {
-    for (const task of tasks) {
-      this._tasks.set(task.id, task);
-    }
-  }
-  getTaskMetadata(id) {
-    return this._tasks.get(id);
-  }
-  async waitForDuration(ms) {
-    const now = Date.now();
-    const resolveAfterDuration = setTimeout$1(ms, "duration");
-    if (ms <= this.waitThresholdInMs) {
-      await resolveAfterDuration;
-      return;
-    }
-    const waitForRestore = new Promise((resolve, reject) => {
-      this._waitForRestore = {
-        resolve,
-        reject
-      };
-    });
-    const { willCheckpointAndRestore } = await this.ipc.sendWithAck("WAIT_FOR_DURATION", {
-      ms,
-      now
-    });
-    if (!willCheckpointAndRestore) {
-      await resolveAfterDuration;
-      return;
-    }
-    this.ipc.send("READY_FOR_CHECKPOINT", {});
-    await Promise.race([
-      waitForRestore,
-      resolveAfterDuration
-    ]);
-    this.ipc.send("CANCEL_CHECKPOINT", {});
-  }
-  resumeAfterRestore() {
-    if (!this._waitForRestore) {
-      return;
-    }
-    clock.reset();
-    this._waitForRestore.resolve("restore");
-    this._waitForRestore = void 0;
-  }
-  async waitUntil(date) {
-    return this.waitForDuration(date.getTime() - Date.now());
-  }
-  async waitForTask(params) {
-    const promise = new Promise((resolve, reject) => {
-      this._taskWaits.set(params.id, {
-        resolve,
-        reject
-      });
-    });
-    await this.ipc.send("WAIT_FOR_TASK", {
-      friendlyId: params.id
-    });
-    return await promise;
-  }
-  async waitForBatch(params) {
-    if (!params.runs.length) {
-      return Promise.resolve({
-        id: params.id,
-        items: []
-      });
-    }
-    const promise = Promise.all(params.runs.map((runId) => {
-      return new Promise((resolve, reject) => {
-        this._taskWaits.set(runId, {
-          resolve,
-          reject
-        });
-      });
-    }));
-    await this.ipc.send("WAIT_FOR_BATCH", {
-      batchFriendlyId: params.id,
-      runFriendlyIds: params.runs
-    });
-    const results = await promise;
-    return {
-      id: params.id,
-      items: results
-    };
-  }
-  resumeTask(completion, execution) {
-    const wait = this._taskWaits.get(execution.run.id);
-    if (!wait) {
-      return;
-    }
-    if (completion.ok) {
-      wait.resolve(completion);
-    } else {
-      wait.reject(completion);
-    }
-    this._taskWaits.delete(execution.run.id);
-  }
-  get waitThresholdInMs() {
-    return this.options.waitThresholdInMs ?? 3e4;
-  }
-};
-__name(_ProdRuntimeManager, "ProdRuntimeManager");
-var ProdRuntimeManager = _ProdRuntimeManager;
-var _originClockTime, originClockTime_get, _originPreciseDate, originPreciseDate_get;
-var _PreciseWallClock = class _PreciseWallClock {
-  constructor(options = {}) {
-    __privateAdd(this, _originClockTime);
-    __privateAdd(this, _originPreciseDate);
-    this._origin = {
-      clockTime: options.origin ?? process.hrtime(),
-      preciseDate: options.now ?? new PreciseDate()
-    };
-  }
-  preciseNow() {
-    const elapsedHrTime = process.hrtime(__privateGet(this, _originClockTime, originClockTime_get));
-    const elapsedNanoseconds = BigInt(elapsedHrTime[0]) * BigInt(1e9) + BigInt(elapsedHrTime[1]);
-    const preciseDate = new PreciseDate(__privateGet(this, _originPreciseDate, originPreciseDate_get).getFullTime() + elapsedNanoseconds);
-    const dateStruct = preciseDate.toStruct();
-    return [
-      dateStruct.seconds,
-      dateStruct.nanos
-    ];
-  }
-  reset() {
-    this._origin = {
-      clockTime: process.hrtime(),
-      preciseDate: new PreciseDate()
-    };
-  }
-};
-_originClockTime = new WeakSet();
-originClockTime_get = /* @__PURE__ */ __name(function() {
-  return this._origin.clockTime;
-}, "#originClockTime");
-_originPreciseDate = new WeakSet();
-originPreciseDate_get = /* @__PURE__ */ __name(function() {
-  return this._origin.preciseDate;
-}, "#originPreciseDate");
-__name(_PreciseWallClock, "PreciseWallClock");
-var PreciseWallClock = _PreciseWallClock;
-var _TriggerTracer = class _TriggerTracer {
-  constructor(_config) {
-    this._config = _config;
-  }
-  get tracer() {
-    if (!this._tracer) {
-      if ("tracer" in this._config)
-        return this._config.tracer;
-      this._tracer = trace.getTracer(this._config.name, this._config.version);
-    }
-    return this._tracer;
-  }
-  get logger() {
-    if (!this._logger) {
-      if ("logger" in this._config)
-        return this._config.logger;
-      this._logger = logs.getLogger(this._config.name, this._config.version);
-    }
-    return this._logger;
-  }
-  extractContext(traceContext) {
-    return propagation.extract(context.active(), traceContext ?? {});
-  }
-  startActiveSpan(name, fn, options, ctx) {
-    const parentContext = ctx ?? context.active();
-    const attributes = options?.attributes ?? {};
-    return this.tracer.startActiveSpan(name, {
-      ...options,
-      attributes,
-      startTime: clock.preciseNow()
-    }, parentContext, async (span) => {
-      this.tracer.startSpan(name, {
-        ...options,
-        attributes: {
-          ...attributes,
-          [SemanticInternalAttributes.SPAN_PARTIAL]: true,
-          [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId
-        }
-      }, parentContext).end();
-      try {
-        return await fn(span);
-      } catch (e) {
-        if (typeof e === "string" || e instanceof Error) {
-          span.recordException(e);
-        }
-        span.setStatus({
-          code: SpanStatusCode.ERROR
-        });
-        throw e;
-      } finally {
-        span.end(clock.preciseNow());
-      }
-    });
-  }
-  startSpan(name, options, ctx) {
-    const parentContext = ctx ?? context.active();
-    const attributes = options?.attributes ?? {};
-    const span = this.tracer.startSpan(name, options, ctx);
-    this.tracer.startSpan(name, {
-      ...options,
-      attributes: {
-        ...attributes,
-        [SemanticInternalAttributes.SPAN_PARTIAL]: true,
-        [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId
-      }
-    }, parentContext).end();
-    return span;
-  }
-};
-__name(_TriggerTracer, "TriggerTracer");
-var TriggerTracer = _TriggerTracer;
-var _handleLog, handleLog_fn, _getTimestampInHrTime2, getTimestampInHrTime_fn2, _getAttributes, getAttributes_fn;
-var _ConsoleInterceptor = class _ConsoleInterceptor {
-  constructor(logger2) {
-    __privateAdd(this, _handleLog);
-    __privateAdd(this, _getTimestampInHrTime2);
-    __privateAdd(this, _getAttributes);
-    this.logger = logger2;
-  }
-  // Intercept the console and send logs to the OpenTelemetry logger
-  // during the execution of the callback
-  async intercept(console2, callback) {
-    const originalConsole = {
-      log: console2.log,
-      info: console2.info,
-      warn: console2.warn,
-      error: console2.error
-    };
-    console2.log = this.log.bind(this);
-    console2.info = this.info.bind(this);
-    console2.warn = this.warn.bind(this);
-    console2.error = this.error.bind(this);
-    try {
-      return await callback();
-    } finally {
-      console2.log = originalConsole.log;
-      console2.info = originalConsole.info;
-      console2.warn = originalConsole.warn;
-      console2.error = originalConsole.error;
-    }
-  }
-  log(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Log", ...args);
-  }
-  info(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Info", ...args);
-  }
-  warn(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.WARN, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Warn", ...args);
-  }
-  error(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.ERROR, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Error", ...args);
-  }
-};
-_handleLog = new WeakSet();
-handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, timestamp, severityText, ...args) {
-  const body = util.format(...args);
-  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/retry.ts
-function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return;
-  switch (format) {
-    case "iso_8601_duration_openai_variant": {
-      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
-    }
-    case "iso_8601": {
-      return calculateISO8601ResetAt(resets, now);
-    }
-    case "unix_timestamp": {
-      return calculateUnixTimestampResetAt(resets, now);
-    }
-    case "unix_timestamp_in_ms": {
-      return calculateUnixTimestampInMsResetAt(resets, now);
-    }
-  }
-}
-__name(calculateResetAt, "calculateResetAt");
-function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = parseInt(resets, 10);
-  if (isNaN(resetAt))
-    return void 0;
-  return new Date(resetAt * 1e3);
-}
-__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
-function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = parseInt(resets, 10);
-  if (isNaN(resetAt))
-    return void 0;
-  return new Date(resetAt);
-}
-__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
-function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = new Date(resets);
-  if (isNaN(resetAt.getTime()))
-    return void 0;
-  return resetAt;
-}
-__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
-function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
-  const match = resets.match(pattern);
-  if (!match)
-    return void 0;
-  const days = parseInt(match[1], 10) || 0;
-  const hours = parseInt(match[2], 10) || 0;
-  const minutes = parseInt(match[3], 10) || 0;
-  const seconds = parseFloat(match[4]) || 0;
-  const milliseconds = parseInt(match[5], 10) || 0;
-  const resetAt = new Date(now);
-  resetAt.setDate(resetAt.getDate() + days);
-  resetAt.setHours(resetAt.getHours() + hours);
-  resetAt.setMinutes(resetAt.getMinutes() + minutes);
-  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
-  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
-  return resetAt;
-}
-__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
-
-// src/v3/utils/retries.ts
-var defaultRetryOptions = {
-  maxAttempts: 3,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
-};
-var defaultFetchRetryOptions = {
-  byStatus: {
-    "429,408,409,5xx": {
-      strategy: "backoff",
-      ...defaultRetryOptions
-    }
-  },
-  connectionError: defaultRetryOptions,
-  timeout: defaultRetryOptions
-};
-function calculateNextRetryDelay(options, attempt) {
-  const opts = {
-    ...defaultRetryOptions,
-    ...options
-  };
-  if (attempt >= opts.maxAttempts) {
-    return;
-  }
-  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
-  const random = randomize ? Math.random() + 1 : 1;
-  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
-  return Math.round(timeout);
-}
-__name(calculateNextRetryDelay, "calculateNextRetryDelay");
-function calculateResetAt2(resets, format, now = Date.now()) {
-  const resetAt = calculateResetAt(resets, format, new Date(now));
-  return resetAt?.getTime();
+      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(calculateResetAt2, "calculateResetAt");
-
-// src/v3/utils/styleAttributes.ts
-function accessoryAttributes(accessory) {
-  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
+__name(formatDurationMilliseconds, "formatDurationMilliseconds");
+function formatDurationInDays(milliseconds) {
+  let duration = humanizeDuration(milliseconds, {
+    maxDecimalPoints: 0,
+    largest: 2,
+    units: [
+      "d"
+    ]
+  });
+  return duration;
 }
-__name(accessoryAttributes, "accessoryAttributes");
+__name(formatDurationInDays, "formatDurationInDays");
+var _TriggerTracer = class _TriggerTracer {
+  constructor(_config) {
+    this._config = _config;
+  }
+  get tracer() {
+    if (!this._tracer) {
+      if ("tracer" in this._config)
+        return this._config.tracer;
+      this._tracer = trace.getTracer(this._config.name, this._config.version);
+    }
+    return this._tracer;
+  }
+  get logger() {
+    if (!this._logger) {
+      if ("logger" in this._config)
+        return this._config.logger;
+      this._logger = logs.getLogger(this._config.name, this._config.version);
+    }
+    return this._logger;
+  }
+  extractContext(traceContext) {
+    return propagation.extract(context.active(), traceContext ?? {});
+  }
+  startActiveSpan(name, fn, options, ctx) {
+    const parentContext = ctx ?? context.active();
+    const attributes = options?.attributes ?? {};
+    return this.tracer.startActiveSpan(name, {
+      ...options,
+      attributes,
+      startTime: clock.preciseNow()
+    }, parentContext, async (span) => {
+      this.tracer.startSpan(name, {
+        ...options,
+        attributes: {
+          ...attributes,
+          [SemanticInternalAttributes.SPAN_PARTIAL]: true,
+          [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId
+        }
+      }, parentContext).end();
+      try {
+        return await fn(span);
+      } catch (e) {
+        if (typeof e === "string" || e instanceof Error) {
+          span.recordException(e);
+        }
+        span.setStatus({
+          code: SpanStatusCode.ERROR
+        });
+        throw e;
+      } finally {
+        span.end(clock.preciseNow());
+      }
+    });
+  }
+  startSpan(name, options, ctx) {
+    const parentContext = ctx ?? context.active();
+    const attributes = options?.attributes ?? {};
+    const span = this.tracer.startSpan(name, options, ctx);
+    this.tracer.startSpan(name, {
+      ...options,
+      attributes: {
+        ...attributes,
+        [SemanticInternalAttributes.SPAN_PARTIAL]: true,
+        [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId
+      }
+    }, parentContext).end();
+    return span;
+  }
+};
+__name(_TriggerTracer, "TriggerTracer");
+var TriggerTracer = _TriggerTracer;
 
 // src/eventFilterMatches.ts
 function eventFilterMatches(payload, filter) {
@@ -3877,150 +3187,41 @@ 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 Resource({}, this._promise);
-  }
-  resolveWithAttributes(attributes) {
-    if (!this._resolver) {
-      throw new Error("Resolver not available");
-    }
-    if (this._resolved) {
-      return;
-    }
-    this._resolved = true;
-    this._resolver(attributes);
-  }
-}, __name(_a2, "AsyncResourceDetector"), _a2);
-var _TracingSDK = class _TracingSDK {
-  constructor(config) {
-    this.config = config;
-    this.asyncResourceDetector = new AsyncResourceDetector();
-    setLogLevel(config.diagLogLevel ?? "none");
-    const envResourceAttributesSerialized = getEnvVar("OTEL_RESOURCE_ATTRIBUTES");
-    const envResourceAttributes = envResourceAttributesSerialized ? JSON.parse(envResourceAttributesSerialized) : {};
-    const commonResources = detectResourcesSync({
-      detectors: [
-        this.asyncResourceDetector,
-        processDetectorSync
-      ]
-    }).merge(new Resource({
-      [SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev",
-      [SemanticInternalAttributes.TRIGGER]: true
-    })).merge(config.resource ?? new Resource({})).merge(new Resource(envResourceAttributes));
-    const traceProvider = new NodeTracerProvider({
-      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500,
-      resource: commonResources,
-      spanLimits: {
-        attributeCountLimit: OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
-        attributeValueLengthLimit: OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT,
-        eventCountLimit: OTEL_SPAN_EVENT_COUNT_LIMIT,
-        attributePerEventCountLimit: OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
-        linkCountLimit: OTEL_LINK_COUNT_LIMIT,
-        attributePerLinkCountLimit: OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT
-      }
-    });
-    const spanExporter = new OTLPTraceExporter({
-      url: `${config.url}/v1/traces`,
-      timeoutMillis: config.forceFlushTimeoutMillis ?? 1e3
-    });
-    traceProvider.addSpanProcessor(new TaskContextSpanProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new BatchSpanProcessor(spanExporter, {
-      maxExportBatchSize: parseInt(getEnvVar("OTEL_SPAN_MAX_EXPORT_BATCH_SIZE") ?? "64"),
-      scheduledDelayMillis: parseInt(getEnvVar("OTEL_SPAN_SCHEDULED_DELAY_MILLIS") ?? "200"),
-      exportTimeoutMillis: parseInt(getEnvVar("OTEL_SPAN_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
-      maxQueueSize: parseInt(getEnvVar("OTEL_SPAN_MAX_QUEUE_SIZE") ?? "512")
-    }) : new SimpleSpanProcessor(spanExporter)));
-    traceProvider.register();
-    registerInstrumentations({
-      instrumentations: config.instrumentations ?? [],
-      tracerProvider: traceProvider
-    });
-    const logExporter = new OTLPLogExporter({
-      url: `${config.url}/v1/logs`
-    });
-    const loggerProvider = new LoggerProvider({
-      resource: commonResources,
-      logRecordLimits: {
-        attributeCountLimit: OTEL_LOG_ATTRIBUTE_COUNT_LIMIT,
-        attributeValueLengthLimit: OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT
-      }
-    });
-    loggerProvider.addLogRecordProcessor(new TaskContextLogProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new BatchLogRecordProcessor(logExporter, {
-      maxExportBatchSize: parseInt(getEnvVar("OTEL_LOG_MAX_EXPORT_BATCH_SIZE") ?? "64"),
-      scheduledDelayMillis: parseInt(getEnvVar("OTEL_LOG_SCHEDULED_DELAY_MILLIS") ?? "200"),
-      exportTimeoutMillis: parseInt(getEnvVar("OTEL_LOG_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
-      maxQueueSize: parseInt(getEnvVar("OTEL_LOG_MAX_QUEUE_SIZE") ?? "512")
-    }) : new SimpleLogRecordProcessor(logExporter)));
-    this._logProvider = loggerProvider;
-    this._spanExporter = spanExporter;
-    this._traceProvider = traceProvider;
-    logs.setGlobalLoggerProvider(loggerProvider);
-    this.getLogger = loggerProvider.getLogger.bind(loggerProvider);
-    this.getTracer = traceProvider.getTracer.bind(traceProvider);
-  }
-  async flush() {
-    await this._spanExporter.forceFlush?.();
-    await this._logProvider.forceFlush();
-  }
-  async shutdown() {
-    await this._spanExporter.shutdown();
-    await this._logProvider.shutdown();
-  }
-};
-__name(_TracingSDK, "TracingSDK");
-var TracingSDK = _TracingSDK;
-function setLogLevel(level) {
-  let diagLogLevel;
-  switch (level) {
-    case "none":
-      diagLogLevel = DiagLogLevel.NONE;
-      break;
-    case "error":
-      diagLogLevel = DiagLogLevel.ERROR;
-      break;
-    case "warn":
-      diagLogLevel = DiagLogLevel.WARN;
-      break;
-    case "info":
-      diagLogLevel = DiagLogLevel.INFO;
-      break;
-    case "debug":
-      diagLogLevel = DiagLogLevel.DEBUG;
-      break;
-    case "verbose":
-      diagLogLevel = DiagLogLevel.VERBOSE;
-      break;
-    case "all":
-      diagLogLevel = DiagLogLevel.ALL;
-      break;
-    default:
-      diagLogLevel = DiagLogLevel.NONE;
-  }
-  diag.setLogger(new DiagConsoleLogger(), diagLogLevel);
+
+// 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: SpanStatusCode.ERROR
-  });
+// 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",
+  superjson: "^2.2.1",
+  ulidx: "^2.2.1",
+  zod: "3.22.3",
+  "zod-error": "1.5.0",
+  "zod-validation-error": "^1.5.0",
+  "socket.io-client": "4.7.4"
+};
+
+// 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) {
@@ -4063,6 +3264,7 @@ async function stringifyIO(value) {
     };
   } catch {
     return {
+      data: value,
       dataType: "application/json"
     };
   }
@@ -4107,23 +3309,20 @@ __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"
-    };
+  const uploadResponse = await fetch(presignedResponse.presignedUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Type": packet.dataType
+    },
+    body: packet.data
+  });
+  if (!uploadResponse.ok) {
+    throw new Error(`Failed to upload output to ${presignedResponse.presignedUrl}: ${uploadResponse.statusText}`);
   }
-  return packet;
+  return {
+    data: filename,
+    dataType: "application/store"
+  };
 }
 __name(exportPacket, "exportPacket");
 async function conditionallyImportPacket(packet, tracer) {
@@ -4152,19 +3351,16 @@ async function importPacket(packet, span) {
     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"
-    };
+  const response = await fetch(presignedResponse.presignedUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to import packet ${presignedResponse.presignedUrl}: ${response.statusText}`);
   }
-  return packet;
+  const data = await response.text();
+  span?.setAttribute("size", Buffer.byteLength(data, "utf8"));
+  return {
+    data,
+    dataType: response.headers.get("content-type") ?? "application/json"
+  };
 }
 __name(importPacket, "importPacket");
 async function createPacketAttributes(packet, dataKey, dataTypeKey) {
@@ -4185,11 +3381,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":
@@ -4217,7 +3414,7 @@ async function createPacketAttributesAsJson(data, dataType) {
     case "application/super+json":
       const { deserialize } = await loadSuperJSON();
       const deserialized = deserialize(data);
-      const jsonify = safeJsonParse(JSON.stringify(deserialized, safeReplacer));
+      const jsonify = safeJsonParse2(JSON.stringify(deserialized, safeReplacer));
       return imposeAttributeLimits(flattenAttributes(jsonify, void 0));
     case "application/store":
       return data;
@@ -4231,10 +3428,16 @@ async function prettyPrintPacket(rawData, dataType) {
     return "";
   }
   if (dataType === "application/super+json") {
+    if (typeof rawData === "string") {
+      rawData = safeJsonParse2(rawData);
+    }
     const { deserialize } = await loadSuperJSON();
     return await prettyPrintPacket(deserialize(rawData), "application/json");
   }
   if (dataType === "application/json") {
+    if (typeof rawData === "string") {
+      rawData = safeJsonParse2(rawData);
+    }
     return JSON.stringify(rawData, safeReplacer, 2);
   }
   if (typeof rawData === "string") {
@@ -4280,304 +3483,15 @@ async function loadSuperJSON() {
   return await import('superjson');
 }
 __name(loadSuperJSON, "loadSuperJSON");
-function safeJsonParse(value) {
+function safeJsonParse2(value) {
   try {
     return JSON.parse(value);
   } catch {
     return;
   }
 }
-__name(safeJsonParse, "safeJsonParse");
-
-// src/v3/workers/taskExecutor.ts
-var _callRun, callRun_fn, _callTaskInit, callTaskInit_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
-var _TaskExecutor = class _TaskExecutor {
-  constructor(task, options) {
-    __privateAdd(this, _callRun);
-    __privateAdd(this, _callTaskInit);
-    __privateAdd(this, _callTaskCleanup);
-    __privateAdd(this, _handleError);
-    this.task = task;
-    this._tracingSDK = options.tracingSDK;
-    this._tracer = options.tracer;
-    this._consoleInterceptor = options.consoleInterceptor;
-    this._config = options.projectConfig;
-    this._importedConfig = options.importedConfig;
-    this._handleErrorFn = options.handleErrorFn;
-  }
-  async execute(execution, worker, traceContext) {
-    const ctx = TaskRunContext.parse(execution);
-    const attemptMessage = `Attempt ${execution.attempt.number}`;
-    const originalPacket = {
-      data: execution.run.payload,
-      dataType: execution.run.payloadType
-    };
-    const result = await taskContextManager.runWith({
-      ctx,
-      worker
-    }, async () => {
-      this._tracingSDK.asyncResourceDetector.resolveWithAttributes({
-        ...taskContextManager.attributes,
-        [SemanticInternalAttributes.SDK_VERSION]: this.task.packageVersion,
-        [SemanticInternalAttributes.SDK_LANGUAGE]: "typescript"
-      });
-      return await this._tracer.startActiveSpan(attemptMessage, async (span) => {
-        return await this._consoleInterceptor.intercept(console, async () => {
-          let parsedPayload;
-          let initOutput;
-          try {
-            const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
-            parsedPayload = await parsePacket(payloadPacket);
-            initOutput = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
-            const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
-            try {
-              const stringifiedOutput = await stringifyIO(output);
-              const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
-              const attributes = await createPacketAttributes(finalOutput, SemanticInternalAttributes.OUTPUT, SemanticInternalAttributes.OUTPUT_TYPE);
-              if (attributes) {
-                span.setAttributes(attributes);
-              }
-              return {
-                ok: true,
-                id: execution.attempt.id,
-                output: finalOutput.data,
-                outputType: finalOutput.dataType
-              };
-            } catch (stringifyError) {
-              recordSpanException(span, stringifyError);
-              return {
-                ok: false,
-                id: execution.attempt.id,
-                error: {
-                  type: "INTERNAL_ERROR",
-                  code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
-                  message: stringifyError instanceof Error ? stringifyError.message : typeof stringifyError === "string" ? stringifyError : void 0
-                }
-              };
-            }
-          } catch (runError) {
-            try {
-              const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
-              recordSpanException(span, handleErrorResult.error ?? runError);
-              return {
-                id: execution.attempt.id,
-                ok: false,
-                error: handleErrorResult.error ? parseError(handleErrorResult.error) : parseError(runError),
-                retry: handleErrorResult.status === "retry" ? handleErrorResult.retry : void 0,
-                skippedRetrying: handleErrorResult.status === "skipped"
-              };
-            } catch (handleErrorError) {
-              recordSpanException(span, handleErrorError);
-              return {
-                ok: false,
-                id: execution.attempt.id,
-                error: {
-                  type: "INTERNAL_ERROR",
-                  code: TaskRunErrorCodes.HANDLE_ERROR_ERROR,
-                  message: handleErrorError instanceof Error ? handleErrorError.message : typeof handleErrorError === "string" ? handleErrorError : void 0
-                }
-              };
-            }
-          } finally {
-            await __privateMethod(this, _callTaskCleanup, callTaskCleanup_fn).call(this, parsedPayload, ctx, initOutput);
-          }
-        });
-      }, {
-        kind: SpanKind.CONSUMER,
-        attributes: {
-          [SemanticInternalAttributes.STYLE_ICON]: "attempt",
-          ...accessoryAttributes({
-            items: [
-              {
-                text: ctx.task.filePath
-              },
-              {
-                text: `${ctx.task.exportName}.run()`
-              }
-            ],
-            style: "codepath"
-          })
-        }
-      }, this._tracer.extractContext(traceContext));
-    });
-    return result;
-  }
-};
-_callRun = new WeakSet();
-callRun_fn = /* @__PURE__ */ __name(async function(payload, ctx, init) {
-  const runFn = this.task.fns.run;
-  const middlewareFn = this.task.fns.middleware;
-  if (!runFn) {
-    throw new Error("Task does not have a run function");
-  }
-  if (!middlewareFn) {
-    return runFn(payload, {
-      ctx
-    });
-  }
-  return middlewareFn(payload, {
-    ctx,
-    next: async () => runFn(payload, {
-      ctx,
-      init
-    })
-  });
-}, "#callRun");
-_callTaskInit = new WeakSet();
-callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
-  const initFn = this.task.fns.init;
-  if (!initFn) {
-    return {};
-  }
-  return this._tracer.startActiveSpan("init", async (span) => {
-    return await initFn(payload1, {
-      ctx: ctx1
-    });
-  });
-}, "#callTaskInit");
-_callTaskCleanup = new WeakSet();
-callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload2, ctx2, init1) {
-  const cleanupFn = this.task.fns.cleanup;
-  if (!cleanupFn) {
-    return;
-  }
-  return this._tracer.startActiveSpan("cleanup", async (span) => {
-    return await cleanupFn(payload2, {
-      ctx: ctx2,
-      init: init1
-    });
-  });
-}, "#callTaskCleanup");
-_handleError = new WeakSet();
-handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload3, ctx3) {
-  const retriesConfig = this._importedConfig?.retries ?? this._config.retries;
-  const retry = this.task.retry ?? retriesConfig?.default;
-  if (!retry) {
-    return {
-      status: "noop"
-    };
-  }
-  const delay = calculateNextRetryDelay(retry, execution.attempt.number);
-  if (execution.environment.type === "DEVELOPMENT" && typeof retriesConfig?.enabledInDev === "boolean" && !retriesConfig.enabledInDev) {
-    return {
-      status: "skipped"
-    };
-  }
-  return this._tracer.startActiveSpan("handleError()", async (span) => {
-    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload3, error, {
-      ctx: ctx3,
-      retry,
-      retryDelayInMs: delay,
-      retryAt: delay ? new Date(Date.now() + delay) : void 0
-    }) : this._importedConfig ? await this._handleErrorFn?.(payload3, error, {
-      ctx: ctx3,
-      retry,
-      retryDelayInMs: delay,
-      retryAt: delay ? new Date(Date.now() + delay) : void 0
-    }) : void 0;
-    if (!handleErrorResult) {
-      return typeof delay === "undefined" ? {
-        status: "noop"
-      } : {
-        status: "retry",
-        retry: {
-          timestamp: Date.now() + delay,
-          delay
-        }
-      };
-    }
-    if (handleErrorResult.skipRetrying) {
-      return {
-        status: "skipped",
-        error: handleErrorResult.error
-      };
-    }
-    if (typeof handleErrorResult.retryAt !== "undefined") {
-      return {
-        status: "retry",
-        retry: {
-          timestamp: handleErrorResult.retryAt.getTime(),
-          delay: handleErrorResult.retryAt.getTime() - Date.now()
-        },
-        error: handleErrorResult.error
-      };
-    }
-    if (typeof handleErrorResult.retryDelayInMs === "number") {
-      return {
-        status: "retry",
-        retry: {
-          timestamp: Date.now() + handleErrorResult.retryDelayInMs,
-          delay: handleErrorResult.retryDelayInMs
-        },
-        error: handleErrorResult.error
-      };
-    }
-    if (handleErrorResult.retry && typeof handleErrorResult.retry === "object") {
-      const delay2 = calculateNextRetryDelay(handleErrorResult.retry, execution.attempt.number);
-      return typeof delay2 === "undefined" ? {
-        status: "noop",
-        error: handleErrorResult.error
-      } : {
-        status: "retry",
-        retry: {
-          timestamp: Date.now() + delay2,
-          delay: delay2
-        },
-        error: handleErrorResult.error
-      };
-    }
-    return {
-      status: "noop",
-      error: handleErrorResult.error
-    };
-  }, {
-    attributes: {
-      [SemanticInternalAttributes.STYLE_ICON]: "exclamation-circle"
-    }
-  });
-}, "#handleError");
-__name(_TaskExecutor, "TaskExecutor");
-var TaskExecutor = _TaskExecutor;
-
-// package.json
-var dependencies = {
-  "@google-cloud/precise-date": "^4.0.0",
-  "@opentelemetry/api": "^1.8.0",
-  "@opentelemetry/api-logs": "^0.48.0",
-  "@opentelemetry/exporter-logs-otlp-http": "^0.49.1",
-  "@opentelemetry/exporter-trace-otlp-http": "^0.49.1",
-  "@opentelemetry/instrumentation": "^0.49.1",
-  "@opentelemetry/resources": "^1.22.0",
-  "@opentelemetry/sdk-logs": "^0.49.1",
-  "@opentelemetry/sdk-node": "^0.49.1",
-  "@opentelemetry/sdk-trace-base": "^1.22.0",
-  "@opentelemetry/sdk-trace-node": "^1.22.0",
-  "@opentelemetry/semantic-conventions": "^1.22.0",
-  "humanize-duration": "^3.27.3",
-  "socket.io": "^4.7.4",
-  "socket.io-client": "^4.7.4",
-  superjson: "^2.2.1",
-  ulidx: "^2.2.1",
-  zod: "3.22.3",
-  "zod-error": "1.5.0"
-};
-
-// src/v3/utils/detectDependencyVersion.ts
-function detectDependencyVersion(dependency) {
-  return dependencies[dependency];
-}
-__name(detectDependencyVersion, "detectDependencyVersion");
-
-// src/v3/index.ts
-function parseTriggerTaskRequestBody(body) {
-  return TriggerTaskRequestBody.safeParse(body);
-}
-__name(parseTriggerTaskRequestBody, "parseTriggerTaskRequestBody");
-function parseBatchTriggerTaskRequestBody(body) {
-  return BatchTriggerTaskRequestBody.safeParse(body);
-}
-__name(parseBatchTriggerTaskRequestBody, "parseBatchTriggerTaskRequestBody");
+__name(safeJsonParse2, "safeJsonParse");
 
-export { ApiClient, ApiClientManager, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConsoleInterceptor, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateUploadPayloadUrlResponseBody, DeploymentErrorData, DevRuntimeManager, PreciseWallClock as DurableClock, EnvironmentType, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, LogLevel, Machine, MachineCpu, MachineMemory, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OtelTaskLogger, OtherSpanEvent, PRIMARY_VARIANT, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdRuntimeManager, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitOptions, RetryOptions, SemanticInternalAttributes, SharedQueueToClientMessages, SimpleStructuredLogger, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskContextSpanProcessor, TaskEventStyle, TaskExecutor, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TracingSDK, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, WaitReason, WhoAmIResponseSchema, ZodIpcConnection, ZodMessageHandler, ZodMessageSchema, ZodMessageSender, ZodNamespace, ZodSchemaParsedError, ZodSocketConnection, ZodSocketMessageHandler, ZodSocketMessageSender, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, getEnvVar, groupTaskMetadataIssuesByTask, iconStringForSeverity, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logLevels, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseBatchTriggerTaskRequestBody, parseError, parsePacket, parseTriggerTaskRequestBody, prettyPrintPacket, primitiveValueOrflattenedAttributes, recordSpanException, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskContextManager, unflattenAttributes, workerToChildMessages };
+export { APIConnectionError, APIError, ApiClient, AttemptStatus, AuthenticationError, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BadRequestError, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConflictError, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateScheduleOptions, CreateUploadPayloadUrlResponseBody, DeletedScheduleObject, DeploymentErrorData, EnvironmentType, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, InternalServerError, ListScheduleOptions, ListSchedulesResult, Machine, MachineCpu, MachineMemory, NULL_SENTINEL, NotFoundError, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OtherSpanEvent, PRIMARY_VARIANT, PermissionDeniedError, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitError, RateLimitOptions, ReplayRunResponse, RetrieveRunResponse, RetryOptions, RunStatus, ScheduleObject, ScheduledTaskPayload, SemanticInternalAttributes, SharedQueueToClientMessages, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskEventStyle, TaskFileMetadata, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, UnprocessableEntityError, UpdateScheduleOptions, WaitReason, WhoAmIResponseSchema, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createJsonErrorObject, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, groupTaskMetadataIssuesByTask, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseError, parsePacket, prettyPrintPacket, primitiveValueOrflattenedAttributes, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskCatalog, taskContext, unflattenAttributes, workerToChildMessages };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map