@trigger.dev/core 2.3.18 → 3.0.0-beta.0

package/dist/v3/index.mjs

@@ -0,0 +1,4318 @@
+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 humanizeDuration from 'humanize-duration';
+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, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { NodeTracerProvider, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
+import { parse, stringify, deserialize } from 'superjson';
+
+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;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+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;
+};
+var CreateAuthorizationCodeResponseSchema = z.object({
+  url: z.string().url(),
+  authorizationCode: z.string()
+});
+var GetPersonalAccessTokenRequestSchema = z.object({
+  authorizationCode: z.string()
+});
+var GetPersonalAccessTokenResponseSchema = z.object({
+  token: z.object({
+    token: z.string(),
+    obfuscatedToken: z.string()
+  }).nullable()
+});
+var TaskRunBuiltInError = z.object({
+  type: z.literal("BUILT_IN_ERROR"),
+  name: z.string(),
+  message: z.string(),
+  stackTrace: z.string()
+});
+var TaskRunCustomErrorObject = z.object({
+  type: z.literal("CUSTOM_ERROR"),
+  raw: z.string()
+});
+var TaskRunStringError = z.object({
+  type: z.literal("STRING_ERROR"),
+  raw: z.string()
+});
+var TaskRunErrorCodes = {
+  COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR",
+  CONFIGURED_INCORRECTLY: "CONFIGURED_INCORRECTLY",
+  TASK_ALREADY_RUNNING: "TASK_ALREADY_RUNNING",
+  TASK_EXECUTION_FAILED: "TASK_EXECUTION_FAILED",
+  TASK_EXECUTION_ABORTED: "TASK_EXECUTION_ABORTED",
+  TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE: "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+  TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
+  TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
+  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR"
+};
+var TaskRunInternalError = z.object({
+  type: z.literal("INTERNAL_ERROR"),
+  code: z.enum([
+    "COULD_NOT_FIND_EXECUTOR",
+    "CONFIGURED_INCORRECTLY",
+    "TASK_ALREADY_RUNNING",
+    "TASK_EXECUTION_FAILED",
+    "TASK_EXECUTION_ABORTED",
+    "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+    "TASK_RUN_CANCELLED",
+    "TASK_OUTPUT_ERROR",
+    "HANDLE_ERROR_ERROR"
+  ]),
+  message: z.string().optional()
+});
+var TaskRunError = z.discriminatedUnion("type", [
+  TaskRunBuiltInError,
+  TaskRunCustomErrorObject,
+  TaskRunStringError,
+  TaskRunInternalError
+]);
+var TaskRun = z.object({
+  id: z.string(),
+  payload: z.string(),
+  payloadType: z.string(),
+  context: z.any(),
+  tags: z.array(z.string()),
+  isTest: z.boolean().default(false),
+  createdAt: z.coerce.date()
+});
+var TaskRunExecutionTask = z.object({
+  id: z.string(),
+  filePath: z.string(),
+  exportName: z.string()
+});
+var TaskRunExecutionAttempt = z.object({
+  id: z.string(),
+  number: z.number(),
+  startedAt: z.coerce.date(),
+  backgroundWorkerId: z.string(),
+  backgroundWorkerTaskId: z.string(),
+  status: z.string()
+});
+var TaskRunExecutionEnvironment = z.object({
+  id: z.string(),
+  slug: z.string(),
+  type: z.enum([
+    "PRODUCTION",
+    "STAGING",
+    "DEVELOPMENT",
+    "PREVIEW"
+  ])
+});
+var TaskRunExecutionOrganization = z.object({
+  id: z.string(),
+  slug: z.string(),
+  name: z.string()
+});
+var TaskRunExecutionProject = z.object({
+  id: z.string(),
+  ref: z.string(),
+  slug: z.string(),
+  name: z.string()
+});
+var TaskRunExecutionQueue = z.object({
+  id: z.string(),
+  name: z.string()
+});
+var TaskRunExecutionBatch = z.object({
+  id: z.string()
+});
+var TaskRunExecution = z.object({
+  task: TaskRunExecutionTask,
+  attempt: TaskRunExecutionAttempt,
+  run: TaskRun,
+  queue: TaskRunExecutionQueue,
+  environment: TaskRunExecutionEnvironment,
+  organization: TaskRunExecutionOrganization,
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional()
+});
+var TaskRunContext = z.object({
+  task: TaskRunExecutionTask,
+  attempt: TaskRunExecutionAttempt.omit({
+    backgroundWorkerId: true,
+    backgroundWorkerTaskId: true
+  }),
+  run: TaskRun.omit({
+    payload: true,
+    payloadType: true
+  }),
+  queue: TaskRunExecutionQueue,
+  environment: TaskRunExecutionEnvironment,
+  organization: TaskRunExecutionOrganization,
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional()
+});
+var TaskRunExecutionRetry = z.object({
+  timestamp: z.number(),
+  delay: z.number(),
+  error: z.unknown().optional()
+});
+var TaskRunFailedExecutionResult = z.object({
+  ok: z.literal(false),
+  id: z.string(),
+  error: TaskRunError,
+  retry: TaskRunExecutionRetry.optional(),
+  skippedRetrying: z.boolean().optional()
+});
+var TaskRunSuccessfulExecutionResult = z.object({
+  ok: z.literal(true),
+  id: z.string(),
+  output: z.string().optional(),
+  outputType: z.string()
+});
+var TaskRunExecutionResult = z.discriminatedUnion("ok", [
+  TaskRunSuccessfulExecutionResult,
+  TaskRunFailedExecutionResult
+]);
+var BatchTaskRunExecutionResult = z.object({
+  id: z.string(),
+  items: TaskRunExecutionResult.array()
+});
+
+// src/v3/schemas/messages.ts
+var TaskRunExecutionPayload = z.object({
+  execution: TaskRunExecution,
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
+});
+var ProdTaskRunExecution = TaskRunExecution.extend({
+  worker: z.object({
+    id: z.string(),
+    contentHash: z.string(),
+    version: z.string()
+  })
+});
+var ProdTaskRunExecutionPayload = z.object({
+  execution: ProdTaskRunExecution,
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
+});
+var BackgroundWorkerServerMessages = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("EXECUTE_RUNS"),
+    payloads: z.array(TaskRunExecutionPayload)
+  }),
+  z.object({
+    type: z.literal("CANCEL_ATTEMPT"),
+    taskAttemptId: z.string(),
+    taskRunId: z.string()
+  }),
+  z.object({
+    type: z.literal("SCHEDULE_ATTEMPT"),
+    id: z.string(),
+    image: z.string(),
+    envId: z.string(),
+    runId: z.string(),
+    version: 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(),
+  window: z.union([
+    z.object({
+      seconds: z.number()
+    }),
+    z.object({
+      minutes: z.number()
+    }),
+    z.object({
+      hours: z.number()
+    })
+  ])
+});
+var SlidingWindowRateLimit = z.object({
+  type: z.literal("sliding-window"),
+  limit: z.number(),
+  window: z.union([
+    z.object({
+      seconds: z.number()
+    }),
+    z.object({
+      minutes: z.number()
+    }),
+    z.object({
+      hours: z.number()
+    })
+  ])
+});
+var RateLimitOptions = z.discriminatedUnion("type", [
+  FixedWindowRateLimit,
+  SlidingWindowRateLimit
+]);
+var RetryOptions = z.object({
+  /** The number of attempts before giving up */
+  maxAttempts: z.number().int().optional(),
+  /** The exponential factor to use when calculating the next retry time.
+  *
+  * Each subsequent retry will be calculated as `previousTimeout * factor`
+  */
+  factor: z.number().optional(),
+  /** The minimum time to wait before retrying */
+  minTimeoutInMs: z.number().int().optional(),
+  /** The maximum time to wait before retrying */
+  maxTimeoutInMs: z.number().int().optional(),
+  /** Randomize the timeout between retries.
+  *
+  * This can be useful to prevent the thundering herd problem where all retries happen at the same time.
+  */
+  randomize: z.boolean().optional()
+});
+var QueueOptions = z.object({
+  /** You can define a shared queue and then pass the name in to your task.
+     * 
+     * @example
+     * 
+     * ```ts
+     * const myQueue = queue({
+        name: "my-queue",
+        concurrencyLimit: 1,
+      });
+  
+      export const task1 = task({
+        id: "task-1",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+  
+      export const task2 = task({
+        id: "task-2",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+     * ```
+     */
+  name: z.string().optional(),
+  /** An optional property that specifies the maximum number of concurrent run executions.
+  *
+  * If this property is omitted, the task can potentially use up the full concurrency of an environment. */
+  concurrencyLimit: z.number().int().min(1).max(1e3).optional(),
+  /** @deprecated This feature is coming soon */
+  rateLimit: RateLimitOptions.optional()
+});
+var TaskMetadata = z.object({
+  id: z.string(),
+  exportName: z.string(),
+  packageVersion: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional()
+});
+var TaskMetadataWithFilePath = TaskMetadata.extend({
+  filePath: z.string()
+});
+var UncaughtExceptionMessage = z.object({
+  version: z.literal("v1").default("v1"),
+  error: z.object({
+    name: z.string(),
+    message: z.string(),
+    stack: z.string().optional()
+  }),
+  origin: z.enum([
+    "uncaughtException",
+    "unhandledRejection"
+  ])
+});
+var 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()
+  }),
+  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()
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      id: z.string()
+    })
+  },
+  READY_TO_DISPOSE: {
+    message: z.undefined()
+  },
+  READY_FOR_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  WAIT_FOR_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      ms: z.number(),
+      now: z.number()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      friendlyId: z.string()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      batchFriendlyId: z.string(),
+      runFriendlyIds: z.string().array()
+    })
+  },
+  UNCAUGHT_EXCEPTION: {
+    message: UncaughtExceptionMessage
+  }
+};
+var ProdWorkerToChildMessages = {
+  EXECUTE_TASK_RUN: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      traceContext: z.record(z.unknown()),
+      metadata: BackgroundWorkerProperties
+    })
+  },
+  TASK_RUN_COMPLETED_NOTIFICATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      completion: TaskRunExecutionResult,
+      execution: TaskRunExecution
+    })
+  },
+  CLEANUP: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      flush: z.boolean().default(false),
+      kill: z.boolean().default(true)
+    }),
+    callback: z.void()
+  },
+  WAIT_COMPLETED_NOTIFICATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  }
+};
+
+// src/v3/schemas/resources.ts
+var TaskResource = z.object({
+  id: z.string(),
+  filePath: z.string(),
+  exportName: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional()
+});
+var BackgroundWorkerMetadata = z.object({
+  packageVersion: z.string(),
+  contentHash: z.string(),
+  cliPackageVersion: z.string().optional(),
+  tasks: z.array(TaskResource)
+});
+var ImageDetailsMetadata = z.object({
+  contentHash: z.string(),
+  imageTag: z.string()
+});
+
+// src/v3/schemas/api.ts
+var WhoAmIResponseSchema = z.object({
+  userId: z.string(),
+  email: z.string().email(),
+  dashboardUrl: z.string()
+});
+var GetProjectResponseBody = z.object({
+  id: z.string(),
+  externalRef: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  createdAt: z.coerce.date(),
+  organization: z.object({
+    id: z.string(),
+    title: z.string(),
+    slug: z.string(),
+    createdAt: z.coerce.date()
+  })
+});
+var GetProjectsResponseBody = z.array(GetProjectResponseBody);
+var GetProjectEnvResponse = z.object({
+  apiKey: z.string(),
+  name: z.string(),
+  apiUrl: z.string()
+});
+var CreateBackgroundWorkerRequestBody = z.object({
+  localOnly: z.boolean(),
+  metadata: BackgroundWorkerMetadata
+});
+var CreateBackgroundWorkerResponse = z.object({
+  id: z.string(),
+  version: z.string(),
+  contentHash: z.string()
+});
+var TriggerTaskRequestBody = z.object({
+  payload: z.any(),
+  context: z.any(),
+  options: z.object({
+    dependentAttempt: z.string().optional(),
+    dependentBatch: z.string().optional(),
+    lockToVersion: z.string().optional(),
+    queue: QueueOptions.optional(),
+    concurrencyKey: z.string().optional(),
+    test: z.boolean().optional()
+  }).optional()
+});
+var TriggerTaskResponse = z.object({
+  id: z.string()
+});
+var BatchTriggerTaskRequestBody = z.object({
+  items: TriggerTaskRequestBody.array(),
+  dependentAttempt: z.string().optional()
+});
+var BatchTriggerTaskResponse = z.object({
+  batchId: z.string(),
+  runs: z.string().array()
+});
+var GetBatchResponseBody = z.object({
+  id: z.string(),
+  items: z.array(z.object({
+    id: z.string(),
+    taskRunId: z.string(),
+    status: z.enum([
+      "PENDING",
+      "CANCELED",
+      "COMPLETED",
+      "FAILED"
+    ])
+  }))
+});
+var GetEnvironmentVariablesResponseBody = z.object({
+  variables: z.record(z.string())
+});
+var StartDeploymentIndexingRequestBody = z.object({
+  imageReference: z.string()
+});
+var StartDeploymentIndexingResponseBody = z.object({
+  id: z.string(),
+  contentHash: z.string()
+});
+var ExternalBuildData = z.object({
+  buildId: z.string(),
+  buildToken: z.string(),
+  projectId: z.string()
+});
+var InitializeDeploymentResponseBody = z.object({
+  id: z.string(),
+  contentHash: z.string(),
+  shortCode: z.string(),
+  version: z.string(),
+  imageTag: z.string(),
+  externalBuildData: ExternalBuildData.optional().nullable(),
+  registryHost: z.string().optional()
+});
+var InitializeDeploymentRequestBody = z.object({
+  contentHash: z.string(),
+  userId: z.string().optional()
+});
+var GetDeploymentResponseBody = z.object({
+  id: z.string(),
+  status: z.enum([
+    "PENDING",
+    "BUILDING",
+    "DEPLOYING",
+    "DEPLOYED",
+    "FAILED",
+    "CANCELED",
+    "TIMED_OUT"
+  ]),
+  contentHash: z.string(),
+  shortCode: z.string(),
+  version: z.string(),
+  imageReference: z.string().optional(),
+  errorData: z.object({
+    name: z.string(),
+    message: z.string(),
+    stack: z.string().optional()
+  }).optional().nullable(),
+  worker: z.object({
+    id: z.string(),
+    version: z.string(),
+    tasks: z.array(z.object({
+      id: z.string(),
+      slug: z.string(),
+      filePath: z.string(),
+      exportName: z.string()
+    }))
+  }).optional()
+});
+var CreateUploadPayloadUrlResponseBody = z.object({
+  presignedUrl: z.string()
+});
+var 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()
+});
+var Machine = z.object({
+  cpu: z.string().default("1").optional(),
+  memory: z.string().default("500Mi").optional()
+});
+var WaitReason = z.enum([
+  "WAIT_FOR_DURATION",
+  "WAIT_FOR_TASK",
+  "WAIT_FOR_BATCH"
+]);
+var ProviderToPlatformMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      data: z.string()
+    })
+  },
+  LOG_WITH_ACK: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      data: z.string()
+    }),
+    callback: z.object({
+      status: z.literal("ok")
+    })
+  }
+};
+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(),
+      envId: z.string(),
+      apiKey: z.string(),
+      apiUrl: 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)
+      })
+    ])
+  },
+  INVOKE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      name: z.string(),
+      machine: Machine
+    })
+  },
+  RESTORE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      checkpointId: z.string(),
+      runId: z.string(),
+      type: z.enum([
+        "DOCKER",
+        "KUBERNETES"
+      ]),
+      location: z.string(),
+      reason: z.string().optional(),
+      imageRef: z.string()
+    })
+  },
+  DELETE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      name: z.string()
+    }),
+    callback: z.object({
+      message: z.string()
+    })
+  },
+  GET: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      name: z.string()
+    })
+  }
+};
+var CoordinatorToPlatformMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      metadata: z.any(),
+      text: z.string()
+    })
+  },
+  CREATE_WORKER: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      projectRef: z.string(),
+      envId: z.string(),
+      deploymentId: z.string(),
+      metadata: z.object({
+        cliPackageVersion: z.string().optional(),
+        contentHash: z.string(),
+        packageVersion: z.string(),
+        tasks: TaskResource.array()
+      })
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false)
+      }),
+      z.object({
+        success: z.literal(true)
+      })
+    ])
+  },
+  READY_FOR_EXECUTION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      totalCompletions: z.number()
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false)
+      }),
+      z.object({
+        success: z.literal(true),
+        payload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  READY_FOR_RESUME: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string(),
+      type: WaitReason
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult,
+      checkpoint: z.object({
+        docker: z.boolean(),
+        location: z.string()
+      }).optional()
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string()
+    })
+  },
+  CHECKPOINT_CREATED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string(),
+      docker: z.boolean(),
+      location: z.string(),
+      reason: z.discriminatedUnion("type", [
+        z.object({
+          type: z.literal("WAIT_FOR_DURATION"),
+          ms: z.number(),
+          now: z.number()
+        }),
+        z.object({
+          type: z.literal("WAIT_FOR_BATCH"),
+          batchFriendlyId: z.string(),
+          runFriendlyIds: z.string().array()
+        }),
+        z.object({
+          type: z.literal("WAIT_FOR_TASK"),
+          friendlyId: z.string()
+        }),
+        z.object({
+          type: z.literal("RETRYING_AFTER_FAILURE"),
+          attemptNumber: z.number()
+        })
+      ])
+    })
+  },
+  INDEXING_FAILED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      error: z.object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().optional()
+      })
+    })
+  }
+};
+var PlatformToCoordinatorMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      attemptId: z.string(),
+      attemptFriendlyId: z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string(),
+      attemptFriendlyId: z.string()
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string(),
+      attemptFriendlyId: z.string()
+    })
+  },
+  READY_FOR_RETRY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string()
+    })
+  }
+};
+var ClientToSharedQueueMessages = {
+  READY_FOR_TASKS: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      backgroundWorkerId: z.string()
+    })
+  },
+  BACKGROUND_WORKER_DEPRECATED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      backgroundWorkerId: z.string()
+    })
+  },
+  BACKGROUND_WORKER_MESSAGE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      backgroundWorkerId: z.string(),
+      data: BackgroundWorkerClientMessages
+    })
+  }
+};
+var SharedQueueToClientMessages = {
+  SERVER_READY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      id: z.string()
+    })
+  },
+  BACKGROUND_WORKER_MESSAGE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      backgroundWorkerId: z.string(),
+      data: BackgroundWorkerServerMessages
+    })
+  }
+};
+var ProdWorkerToCoordinatorMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      text: z.string()
+    }),
+    callback: z.void()
+  },
+  INDEX_TASKS: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      tasks: TaskResource.array(),
+      packageVersion: z.string()
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false)
+      }),
+      z.object({
+        success: z.literal(true)
+      })
+    ])
+  },
+  READY_FOR_EXECUTION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      totalCompletions: z.number()
+    })
+  },
+  READY_FOR_RESUME: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string(),
+      type: WaitReason
+    })
+  },
+  READY_FOR_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string()
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean(),
+      shouldExit: z.boolean()
+    })
+  },
+  WAIT_FOR_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      ms: z.number(),
+      now: z.number(),
+      attemptFriendlyId: z.string()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      friendlyId: z.string(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: z.string()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      batchFriendlyId: z.string(),
+      runFriendlyIds: z.string().array(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: z.string()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  INDEXING_FAILED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      error: z.object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().optional()
+      })
+    })
+  }
+};
+var CoordinatorToProdWorkerMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string()
+    })
+  },
+  EXECUTE_TASK_RUN: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      executionPayload: ProdTaskRunExecutionPayload
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string()
+    })
+  },
+  REQUEST_EXIT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  READY_FOR_RETRY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string()
+    })
+  }
+};
+var ProdWorkerSocketData = z.object({
+  contentHash: z.string(),
+  projectRef: z.string(),
+  envId: z.string(),
+  runId: z.string(),
+  attemptFriendlyId: z.string().optional(),
+  podName: z.string(),
+  deploymentId: z.string(),
+  deploymentVersion: z.string()
+});
+var PRIMARY_VARIANT = "primary";
+var Variant = z.enum([
+  PRIMARY_VARIANT
+]);
+var AccessoryItem = z.object({
+  text: z.string(),
+  variant: z.string().optional(),
+  url: z.string().optional()
+});
+var Accessory = z.object({
+  items: z.array(AccessoryItem),
+  style: z.enum([
+    "codepath"
+  ]).optional()
+});
+var TaskEventStyle = z.object({
+  icon: z.string().optional(),
+  variant: Variant.optional(),
+  accessory: Accessory.optional()
+}).default({
+  icon: void 0,
+  variant: void 0
+});
+var stringPatternMatchers = [
+  z.object({
+    $endsWith: z.string()
+  }),
+  z.object({
+    $startsWith: z.string()
+  }),
+  z.object({
+    $ignoreCaseEquals: z.string()
+  })
+];
+var EventMatcher = z.union([
+  /** Match against a string */
+  z.array(z.string()),
+  /** Match against a number */
+  z.array(z.number()),
+  /** Match against a boolean */
+  z.array(z.boolean()),
+  z.array(z.union([
+    ...stringPatternMatchers,
+    z.object({
+      $exists: z.boolean()
+    }),
+    z.object({
+      $isNull: z.boolean()
+    }),
+    z.object({
+      $anythingBut: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+      ])
+    }),
+    z.object({
+      $anythingBut: z.union([
+        z.array(z.string()),
+        z.array(z.number()),
+        z.array(z.boolean())
+      ])
+    }),
+    z.object({
+      $gt: z.number()
+    }),
+    z.object({
+      $lt: z.number()
+    }),
+    z.object({
+      $gte: z.number()
+    }),
+    z.object({
+      $lte: z.number()
+    }),
+    z.object({
+      $between: z.tuple([
+        z.number(),
+        z.number()
+      ])
+    }),
+    z.object({
+      $includes: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+      ])
+    }),
+    z.object({
+      $not: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+      ])
+    })
+  ]))
+]);
+var EventFilter = z.lazy(() => z.record(z.union([
+  EventMatcher,
+  EventFilter
+])));
+
+// src/v3/schemas/fetch.ts
+var FetchRetryHeadersStrategy = z.object({
+  /** The `headers` strategy retries the request using info from the response headers. */
+  strategy: z.literal("headers"),
+  /** The header to use to determine the maximum number of times to retry the request. */
+  limitHeader: z.string(),
+  /** The header to use to determine the number of remaining retries. */
+  remainingHeader: z.string(),
+  /** The header to use to determine the time when the number of remaining retries will be reset. */
+  resetHeader: z.string(),
+  /** The event filter to use to determine if the request should be retried. */
+  bodyFilter: EventFilter.optional(),
+  /** The format of the `resetHeader` value. */
+  resetFormat: z.enum([
+    "unix_timestamp",
+    "unix_timestamp_in_ms",
+    "iso_8601",
+    "iso_8601_duration_openai_variant"
+  ]).default("unix_timestamp").optional()
+});
+var FetchRetryBackoffStrategy = RetryOptions.extend({
+  /** The `backoff` strategy retries the request with an exponential backoff. */
+  strategy: z.literal("backoff"),
+  /** The event filter to use to determine if the request should be retried. */
+  bodyFilter: EventFilter.optional()
+});
+var FetchRetryStrategy = z.discriminatedUnion("strategy", [
+  FetchRetryHeadersStrategy,
+  FetchRetryBackoffStrategy
+]);
+var FetchRetryByStatusOptions = z.record(z.string(), FetchRetryStrategy);
+var FetchTimeoutOptions = z.object({
+  /** The maximum time to wait for the request to complete. */
+  durationInMs: z.number().optional(),
+  retry: RetryOptions.optional()
+});
+var FetchRetryOptions = z.object({
+  /** The retrying strategy for specific status codes. */
+  byStatus: FetchRetryByStatusOptions.optional(),
+  /** The timeout options for the request. */
+  timeout: RetryOptions.optional(),
+  /**
+  * The retrying strategy for connection errors.
+  */
+  connectionError: RetryOptions.optional()
+});
+var ExceptionEventProperties = z.object({
+  type: z.string().optional(),
+  message: z.string().optional(),
+  stacktrace: z.string().optional()
+});
+var ExceptionSpanEvent = z.object({
+  name: z.literal("exception"),
+  time: z.coerce.date(),
+  properties: z.object({
+    exception: ExceptionEventProperties
+  })
+});
+var CancellationSpanEvent = z.object({
+  name: z.literal("cancellation"),
+  time: z.coerce.date(),
+  properties: z.object({
+    reason: z.string()
+  })
+});
+var OtherSpanEvent = z.object({
+  name: z.string(),
+  time: z.coerce.date(),
+  properties: z.record(z.unknown())
+});
+var SpanEvent = z.union([
+  ExceptionSpanEvent,
+  CancellationSpanEvent,
+  OtherSpanEvent
+]);
+var SpanEvents = z.array(SpanEvent);
+function isExceptionSpanEvent(event) {
+  return event.name === "exception";
+}
+__name(isExceptionSpanEvent, "isExceptionSpanEvent");
+function isCancellationSpanEvent(event) {
+  return event.name === "cancellation";
+}
+__name(isCancellationSpanEvent, "isCancellationSpanEvent");
+var SpanMessagingEvent = z.object({
+  system: z.string().optional(),
+  client_id: z.string().optional(),
+  operation: z.enum([
+    "publish",
+    "create",
+    "receive",
+    "deliver"
+  ]),
+  message: z.any(),
+  destination: z.string().optional()
+});
+
+// src/zodfetch.ts
+async function zodfetch(schema, url, requestInit) {
+  try {
+    const response = await fetch(url, requestInit);
+    if ((!requestInit || requestInit.method === "GET") && response.status === 404) {
+      return {
+        ok: false,
+        error: `404: ${response.statusText}`
+      };
+    }
+    if (response.status >= 400 && response.status < 500) {
+      const body = await response.json();
+      if (!body.error) {
+        return {
+          ok: false,
+          error: "Something went wrong"
+        };
+      }
+      return {
+        ok: false,
+        error: body.error
+      };
+    }
+    if (response.status !== 200) {
+      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) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : JSON.stringify(error)
+    };
+  }
+}
+__name(zodfetch, "zodfetch");
+
+// 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
+      };
+    }
+    return {};
+  }
+  get contextAttributes() {
+    if (this.ctx) {
+      return {
+        [SemanticInternalAttributes.ATTEMPT_ID]: this.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: this.ctx.attempt.number,
+        [SemanticInternalAttributes.TASK_SLUG]: this.ctx.task.id,
+        [SemanticInternalAttributes.TASK_PATH]: this.ctx.task.filePath,
+        [SemanticInternalAttributes.TASK_EXPORT_NAME]: this.ctx.task.exportName,
+        [SemanticInternalAttributes.QUEUE_NAME]: this.ctx.queue.name,
+        [SemanticInternalAttributes.QUEUE_ID]: this.ctx.queue.id,
+        [SemanticInternalAttributes.ENVIRONMENT_ID]: this.ctx.environment.id,
+        [SemanticInternalAttributes.ENVIRONMENT_TYPE]: this.ctx.environment.type,
+        [SemanticInternalAttributes.ORGANIZATION_ID]: this.ctx.organization.id,
+        [SemanticInternalAttributes.PROJECT_ID]: this.ctx.project.id,
+        [SemanticInternalAttributes.PROJECT_REF]: this.ctx.project.ref,
+        [SemanticInternalAttributes.PROJECT_NAME]: this.ctx.project.name,
+        [SemanticInternalAttributes.RUN_ID]: this.ctx.run.id,
+        [SemanticInternalAttributes.RUN_IS_TEST]: this.ctx.run.isTest,
+        [SemanticInternalAttributes.ORGANIZATION_SLUG]: this.ctx.organization.slug,
+        [SemanticInternalAttributes.ORGANIZATION_NAME]: this.ctx.organization.name,
+        [SemanticInternalAttributes.BATCH_ID]: this.ctx.batch?.id
+      };
+    }
+    return {};
+  }
+  runWith(context3, fn) {
+    return this._storage.runWith(context3, fn);
+  }
+};
+_getStore = new WeakSet();
+getStore_fn = /* @__PURE__ */ __name(function() {
+  return this._storage.getStore();
+}, "#getStore");
+__name(_TaskContextManager, "TaskContextManager");
+var TaskContextManager = _TaskContextManager;
+var taskContextManager = new TaskContextManager();
+var _TaskContextSpanProcessor = class _TaskContextSpanProcessor {
+  constructor(innerProcessor) {
+    this._innerProcessor = innerProcessor;
+  }
+  // Called when a span starts
+  onStart(span, parentContext) {
+    if (taskContextManager.ctx) {
+      span.setAttributes(flattenAttributes({
+        [SemanticInternalAttributes.ATTEMPT_ID]: taskContextManager.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContextManager.ctx.attempt.number
+      }, SemanticInternalAttributes.METADATA));
+    }
+    this._innerProcessor.onStart(span, parentContext);
+  }
+  // Delegate the rest of the methods to the wrapped processor
+  onEnd(span) {
+    this._innerProcessor.onEnd(span);
+  }
+  shutdown() {
+    return this._innerProcessor.shutdown();
+  }
+  forceFlush() {
+    return this._innerProcessor.forceFlush();
+  }
+};
+__name(_TaskContextSpanProcessor, "TaskContextSpanProcessor");
+var TaskContextSpanProcessor = _TaskContextSpanProcessor;
+var _TaskContextLogProcessor = class _TaskContextLogProcessor {
+  constructor(innerProcessor) {
+    this._innerProcessor = innerProcessor;
+  }
+  forceFlush() {
+    return this._innerProcessor.forceFlush();
+  }
+  onEmit(logRecord, context3) {
+    if (taskContextManager.ctx) {
+      logRecord.setAttributes(flattenAttributes({
+        [SemanticInternalAttributes.ATTEMPT_ID]: taskContextManager.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContextManager.ctx.attempt.number
+      }, SemanticInternalAttributes.METADATA));
+    }
+    this._innerProcessor.onEmit(logRecord, context3);
+  }
+  shutdown() {
+    return this._innerProcessor.shutdown();
+  }
+};
+__name(_TaskContextLogProcessor, "TaskContextLogProcessor");
+var TaskContextLogProcessor = _TaskContextLogProcessor;
+
+// src/v3/utils/getEnv.ts
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && typeof process.env === "object" && process.env !== null) {
+    return process.env[name];
+  }
+}
+__name(getEnvVar, "getEnvVar");
+
+// src/v3/apiClient/index.ts
+var _getHeaders, getHeaders_fn;
+var _ApiClient = class _ApiClient {
+  constructor(baseUrl, accessToken) {
+    __privateAdd(this, _getHeaders);
+    this.accessToken = accessToken;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  triggerTask(taskId, body, options) {
+    return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
+      body: JSON.stringify(body)
+    });
+  }
+  batchTriggerTask(taskId, body, options) {
+    return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/batch`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
+      body: JSON.stringify(body)
+    });
+  }
+  createUploadPayloadUrl(filename) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  getPayloadUrl(filename) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+};
+_getHeaders = new WeakSet();
+getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${this.accessToken}`
+  };
+  if (taskContextManager.isInsideTask) {
+    propagation.inject(context.active(), headers);
+    if (spanParentAsLink) {
+      headers["x-trigger-span-parent-as-link"] = "1";
+    }
+  }
+  return headers;
+}, "#getHeaders");
+__name(_ApiClient, "ApiClient");
+var ApiClient = _ApiClient;
+var _getStore2, getStore_fn2;
+var _ApiClientManager = class _ApiClientManager {
+  constructor() {
+    __privateAdd(this, _getStore2);
+    __publicField(this, "_storage", new SafeAsyncLocalStorage());
+  }
+  get baseURL() {
+    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
+    return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
+  }
+  get accessToken() {
+    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
+    return store?.accessToken ?? getEnvVar("TRIGGER_SECRET_KEY");
+  }
+  get client() {
+    if (!this.baseURL || !this.accessToken) {
+      return void 0;
+    }
+    return new ApiClient(this.baseURL, this.accessToken);
+  }
+  runWith(context3, fn) {
+    return this._storage.runWith(context3, fn);
+  }
+};
+_getStore2 = new WeakSet();
+getStore_fn2 = /* @__PURE__ */ __name(function() {
+  return this._storage.getStore();
+}, "#getStore");
+__name(_ApiClientManager, "ApiClientManager");
+var ApiClientManager = _ApiClientManager;
+var apiClientManager = new ApiClientManager();
+var 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 Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+    }
+    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;
+  }
+};
+_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);
+    this.socket = io(`ws://${opts.host}:${opts.port}/${opts.namespace}`, {
+      transports: [
+        "websocket"
+      ],
+      auth: {
+        token: opts.authToken
+      },
+      extraHeaders: opts.extraHeaders
+    });
+    __privateSet(this, _logger, new SimpleStructuredLogger(opts.namespace, LogLevel.info, {
+      socketId: this.socket.id
+    }));
+    __privateSet(this, _handler, new ZodSocketMessageHandler({
+      schema: opts.serverMessages,
+      handlers: opts.handlers
+    }));
+    __privateGet(this, _handler).registerHandlers(this.socket, __privateGet(this, _logger));
+    __privateSet(this, _sender2, new ZodSocketMessageSender({
+      schema: opts.clientMessages,
+      socket: this.socket
+    }));
+    this.socket.on("connect_error", async (error) => {
+      __privateGet(this, _logger).error(`connect_error: ${error}`);
+      if (opts.onError) {
+        await opts.onError(this.socket, error, __privateGet(this, _logger));
+      }
+    });
+    this.socket.on("connect", async () => {
+      __privateGet(this, _logger).info("connect");
+      if (opts.onConnection) {
+        await opts.onConnection(this.socket, __privateGet(this, _handler), __privateGet(this, _sender2), __privateGet(this, _logger));
+      }
+    });
+    this.socket.on("disconnect", async (reason, description) => {
+      __privateGet(this, _logger).info("disconnect", {
+        reason,
+        description
+      });
+      if (opts.onDisconnect) {
+        await opts.onDisconnect(this.socket, reason, description, __privateGet(this, _logger));
+      }
+    });
+  }
+  close() {
+    this.socket.close();
+  }
+  connect() {
+    this.socket.connect();
+  }
+  get send() {
+    return __privateGet(this, _sender2).send.bind(__privateGet(this, _sender2));
+  }
+  get sendWithAck() {
+    return __privateGet(this, _sender2).sendWithAck.bind(__privateGet(this, _sender2));
+  }
+};
+_sender2 = new WeakMap();
+_handler = new WeakMap();
+_logger = new WeakMap();
+__name(_ZodSocketConnection, "ZodSocketConnection");
+var ZodSocketConnection = _ZodSocketConnection;
+
+// src/v3/zodNamespace.ts
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["log"] = 0] = "log";
+  LogLevel2[LogLevel2["error"] = 1] = "error";
+  LogLevel2[LogLevel2["warn"] = 2] = "warn";
+  LogLevel2[LogLevel2["info"] = 3] = "info";
+  LogLevel2[LogLevel2["debug"] = 4] = "debug";
+})(LogLevel || (LogLevel = {}));
+var _structuredLog, structuredLog_fn;
+var _SimpleStructuredLogger = class _SimpleStructuredLogger {
+  constructor(name, level = [
+    "1",
+    "true"
+  ].includes(process.env.DEBUG ?? "") ? LogLevel.debug : LogLevel.info, fields) {
+    __privateAdd(this, _structuredLog);
+    this.name = name;
+    this.level = level;
+    this.fields = fields;
+  }
+  child(fields, level) {
+    return new _SimpleStructuredLogger(this.name, level, {
+      ...this.fields,
+      ...fields
+    });
+  }
+  log(message, ...args) {
+    if (this.level < LogLevel.log)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
+  }
+  error(message, ...args) {
+    if (this.level < LogLevel.error)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
+  }
+  warn(message, ...args) {
+    if (this.level < LogLevel.warn)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
+  }
+  info(message, ...args) {
+    if (this.level < LogLevel.info)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
+  }
+  debug(message, ...args) {
+    if (this.level < LogLevel.debug)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, "debug", ...args);
+  }
+};
+_structuredLog = new WeakSet();
+structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
+  const structuredLog = {
+    ...args.length === 1 ? args[0] : args,
+    ...this.fields,
+    timestamp: /* @__PURE__ */ new Date(),
+    name: this.name,
+    message,
+    level
+  };
+  loggerFunction(JSON.stringify(structuredLog));
+}, "#structuredLog");
+__name(_SimpleStructuredLogger, "SimpleStructuredLogger");
+var SimpleStructuredLogger = _SimpleStructuredLogger;
+var _logger2, _handler2;
+var _ZodNamespace = class _ZodNamespace {
+  constructor(opts) {
+    __privateAdd(this, _logger2, void 0);
+    __privateAdd(this, _handler2, void 0);
+    __privateSet(this, _logger2, opts.logger ?? new SimpleStructuredLogger(opts.name));
+    __privateSet(this, _handler2, new ZodSocketMessageHandler({
+      schema: opts.clientMessages,
+      handlers: opts.handlers
+    }));
+    this.io = opts.io;
+    this.namespace = this.io.of(opts.name);
+    this.sender = new ZodMessageSender({
+      schema: opts.serverMessages,
+      sender: async (message) => {
+        return new Promise((resolve, reject) => {
+          try {
+            this.namespace.emit(message.type, message.payload);
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+      }
+    });
+    if (opts.preAuth) {
+      this.namespace.use(async (socket, next) => {
+        const logger2 = __privateGet(this, _logger2).child({
+          socketId: socket.id,
+          socketStage: "preAuth"
+        });
+        if (typeof opts.preAuth === "function") {
+          await opts.preAuth(socket, next, logger2);
+        }
+      });
+    }
+    if (opts.authToken) {
+      this.namespace.use((socket, next) => {
+        const logger2 = __privateGet(this, _logger2).child({
+          socketId: socket.id,
+          socketStage: "auth"
+        });
+        const { auth } = socket.handshake;
+        if (!("token" in auth)) {
+          logger2.error("no token");
+          return socket.disconnect(true);
+        }
+        if (auth.token !== opts.authToken) {
+          logger2.error("invalid token");
+          return socket.disconnect(true);
+        }
+        logger2.info("success");
+        next();
+      });
+    }
+    if (opts.postAuth) {
+      this.namespace.use(async (socket, next) => {
+        const logger2 = __privateGet(this, _logger2).child({
+          socketId: socket.id,
+          socketStage: "auth"
+        });
+        if (typeof opts.postAuth === "function") {
+          await opts.postAuth(socket, next, logger2);
+        }
+      });
+    }
+    this.namespace.on("connection", async (socket) => {
+      const logger2 = __privateGet(this, _logger2).child({
+        socketId: socket.id,
+        socketStage: "connection"
+      });
+      logger2.info("connected");
+      __privateGet(this, _handler2).registerHandlers(socket, logger2);
+      socket.on("disconnect", async (reason, description) => {
+        logger2.info("disconnect", {
+          reason,
+          description
+        });
+        if (opts.onDisconnect) {
+          await opts.onDisconnect(socket, reason, description, logger2);
+        }
+      });
+      socket.on("error", async (error) => {
+        logger2.error("error", {
+          error
+        });
+        if (opts.onError) {
+          await opts.onError(socket, error, logger2);
+        }
+      });
+      if (opts.onConnection) {
+        await opts.onConnection(socket, __privateGet(this, _handler2), this.sender, logger2);
+      }
+    });
+  }
+  fetchSockets() {
+    return this.namespace.fetchSockets();
+  }
+};
+_logger2 = new WeakMap();
+_handler2 = new WeakMap();
+__name(_ZodNamespace, "ZodNamespace");
+var ZodNamespace = _ZodNamespace;
+var messageSchema2 = z.object({
+  version: z.literal("v1").default("v1"),
+  type: z.string(),
+  payload: z.unknown()
+});
+var _schema5, _handlers3, _sender3, _a;
+var ZodIpcMessageHandler = (_a = class {
+  constructor(options) {
+    __privateAdd(this, _schema5, void 0);
+    __privateAdd(this, _handlers3, void 0);
+    __privateAdd(this, _sender3, void 0);
+    __privateSet(this, _schema5, options.schema);
+    __privateSet(this, _handlers3, options.handlers);
+    __privateSet(this, _sender3, options.sender);
+  }
+  async handleMessage(message) {
+    const parsedMessage = this.parseMessage(message);
+    if (!__privateGet(this, _handlers3)) {
+      throw new Error("No handlers provided");
+    }
+    const handler = __privateGet(this, _handlers3)[parsedMessage.type];
+    if (!handler) {
+      return;
+    }
+    const ack = await handler(parsedMessage.payload, __privateGet(this, _sender3));
+    return ack;
+  }
+  parseMessage(message) {
+    const parsedMessage = messageSchema2.safeParse(message);
+    if (!parsedMessage.success) {
+      throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`);
+    }
+    const schema = __privateGet(this, _schema5)[parsedMessage.data.type]["message"];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${parsedMessage.data.type}`);
+    }
+    const parsedPayload = schema.safeParse(parsedMessage.data.payload);
+    if (!parsedPayload.success) {
+      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+    }
+    return {
+      type: parsedMessage.data.type,
+      payload: parsedPayload.data
+    };
+  }
+}, _schema5 = new WeakMap(), _handlers3 = new WeakMap(), _sender3 = new WeakMap(), __name(_a, "ZodIpcMessageHandler"), _a);
+var Packet = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("CONNECT"),
+    sessionId: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("ACK"),
+    message: z.any(),
+    id: z.number()
+  }),
+  z.object({
+    type: z.literal("EVENT"),
+    message: z.any(),
+    id: z.number().optional()
+  })
+]);
+var _sessionId, _messageCounter, _handler3, _acks, _registerHandlers, registerHandlers_fn, _handlePacket, handlePacket_fn, _sendPacket, sendPacket_fn;
+var _ZodIpcConnection = class _ZodIpcConnection {
+  constructor(opts) {
+    __privateAdd(this, _registerHandlers);
+    __privateAdd(this, _handlePacket);
+    __privateAdd(this, _sendPacket);
+    __privateAdd(this, _sessionId, void 0);
+    __privateAdd(this, _messageCounter, void 0);
+    __privateAdd(this, _handler3, void 0);
+    __privateAdd(this, _acks, void 0);
+    this.opts = opts;
+    __privateSet(this, _messageCounter, 0);
+    __privateSet(this, _acks, /* @__PURE__ */ new Map());
+    __privateSet(this, _handler3, new ZodIpcMessageHandler({
+      schema: opts.listenSchema,
+      handlers: opts.handlers,
+      sender: {
+        send: this.send.bind(this),
+        sendWithAck: this.sendWithAck.bind(this)
+      }
+    }));
+    __privateMethod(this, _registerHandlers, registerHandlers_fn).call(this);
+  }
+  async connect() {
+    __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+      type: "CONNECT"
+    });
+  }
+  async send(type, payload) {
+    const schema = this.opts.emitSchema[type]["message"];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${type}`);
+    }
+    const parsedPayload = schema.safeParse(payload);
+    if (!parsedPayload.success) {
+      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+    }
+    await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+      type: "EVENT",
+      message: {
+        type,
+        payload,
+        version: "v1"
+      }
+    });
+  }
+  async sendWithAck(type, payload, timeoutInMs) {
+    const currentId = __privateWrapper(this, _messageCounter)._++;
+    return new Promise(async (resolve, reject) => {
+      const defaultTimeoutInMs = 2e3;
+      const timeout = setTimeout(() => {
+        reject(JSON.stringify({
+          reason: "sendWithAck() timeout",
+          timeoutInMs: timeoutInMs ?? defaultTimeoutInMs,
+          type,
+          payload
+        }));
+      }, timeoutInMs ?? defaultTimeoutInMs);
+      __privateGet(this, _acks).set(currentId, {
+        resolve,
+        reject,
+        timeout
+      });
+      const schema = this.opts.emitSchema[type]["message"];
+      if (!schema) {
+        clearTimeout(timeout);
+        return reject(`Unknown message type: ${type}`);
+      }
+      const parsedPayload = schema.safeParse(payload);
+      if (!parsedPayload.success) {
+        clearTimeout(timeout);
+        return reject(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+      }
+      await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+        type: "EVENT",
+        message: {
+          type,
+          payload,
+          version: "v1"
+        },
+        id: currentId
+      });
+    });
+  }
+};
+_sessionId = new WeakMap();
+_messageCounter = new WeakMap();
+_handler3 = new WeakMap();
+_acks = new WeakMap();
+_registerHandlers = new WeakSet();
+registerHandlers_fn = /* @__PURE__ */ __name(async function() {
+  if (!this.opts.process.on) {
+    return;
+  }
+  this.opts.process.on("message", async (message) => {
+    __privateMethod(this, _handlePacket, handlePacket_fn).call(this, message);
+  });
+}, "#registerHandlers");
+_handlePacket = new WeakSet();
+handlePacket_fn = /* @__PURE__ */ __name(async function(packet) {
+  const parsedPacket = Packet.safeParse(packet);
+  if (!parsedPacket.success) {
+    return;
+  }
+  switch (parsedPacket.data.type) {
+    case "ACK": {
+      const ack = __privateGet(this, _acks).get(parsedPacket.data.id);
+      if (!ack) {
+        return;
+      }
+      clearTimeout(ack.timeout);
+      ack.resolve(parsedPacket.data.message);
+      break;
+    }
+    case "CONNECT": {
+      if (!parsedPacket.data.sessionId) {
+        const id = randomUUID();
+        await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+          type: "CONNECT",
+          sessionId: id
+        });
+        return;
+      }
+      if (__privateGet(this, _sessionId)) {
+        return;
+      }
+      __privateSet(this, _sessionId, parsedPacket.data.sessionId);
+      break;
+    }
+    case "EVENT": {
+      const result = await __privateGet(this, _handler3).handleMessage(parsedPacket.data.message);
+      if (typeof parsedPacket.data.id === "undefined") {
+        return;
+      }
+      await __privateMethod(this, _sendPacket, sendPacket_fn).call(this, {
+        type: "ACK",
+        id: parsedPacket.data.id,
+        message: result
+      });
+      break;
+    }
+  }
+}, "#handlePacket");
+_sendPacket = new WeakSet();
+sendPacket_fn = /* @__PURE__ */ __name(async function(packet1) {
+  await this.opts.process.send?.(packet1);
+}, "#sendPacket");
+__name(_ZodIpcConnection, "ZodIpcConnection");
+var ZodIpcConnection = _ZodIpcConnection;
+function parseError(error) {
+  if (error instanceof Error) {
+    return {
+      type: "BUILT_IN_ERROR",
+      name: error.name,
+      message: error.message,
+      stackTrace: error.stack ?? ""
+    };
+  }
+  if (typeof error === "string") {
+    return {
+      type: "STRING_ERROR",
+      raw: error
+    };
+  }
+  try {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: JSON.stringify(error)
+    };
+  } catch (e) {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: String(error)
+    };
+  }
+}
+__name(parseError, "parseError");
+function createErrorTaskError(error) {
+  switch (error.type) {
+    case "BUILT_IN_ERROR": {
+      const e = new Error(error.message);
+      e.name = error.name;
+      e.stack = error.stackTrace;
+      return e;
+    }
+    case "STRING_ERROR": {
+      return error.raw;
+    }
+    case "CUSTOM_ERROR": {
+      return JSON.parse(error.raw);
+    }
+    case "INTERNAL_ERROR": {
+      return new Error(`trigger.dev internal error (${error.code})`);
+    }
+  }
+}
+__name(createErrorTaskError, "createErrorTaskError");
+function correctErrorStackTrace(stackTrace, projectDir, options) {
+  const [errorLine, ...traceLines] = stackTrace.split("\n");
+  return [
+    options?.removeFirstLine ? void 0 : errorLine,
+    ...traceLines.map((line) => correctStackTraceLine(line, projectDir))
+  ].filter(Boolean).join("\n");
+}
+__name(correctErrorStackTrace, "correctErrorStackTrace");
+function correctStackTraceLine(line, projectDir) {
+  const regex = /at (.*?) \(?file:\/\/(\/.*?\.ts):(\d+):(\d+)\)?/;
+  const match = regex.exec(line);
+  if (!match) {
+    return;
+  }
+  const [_, identifier, path, lineNum, colNum] = match;
+  if (!path) {
+    return;
+  }
+  if (nodePath.basename(path) === "__entryPoint.ts") {
+    return;
+  }
+  if (projectDir && !path.includes(projectDir)) {
+    return;
+  }
+  return line;
+}
+__name(correctStackTraceLine, "correctStackTraceLine");
+
+// 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];
+  }
+}
+__name(unregisterGlobal, "unregisterGlobal");
+
+// src/v3/runtime/noopRuntimeManager.ts
+var _NoopRuntimeManager = class _NoopRuntimeManager {
+  disable() {
+  }
+  registerTasks() {
+  }
+  getTaskMetadata(id) {
+    return void 0;
+  }
+  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_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);
+  }
+  setGlobalRuntimeManager(runtimeManager) {
+    return registerGlobal(API_NAME, runtimeManager);
+  }
+  disable() {
+    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
+    unregisterGlobal(API_NAME);
+  }
+  registerTasks(tasks) {
+    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).registerTasks(tasks);
+  }
+  getTaskMetadata(id) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).getTaskMetadata(id);
+  }
+};
+_getRuntimeManager = new WeakSet();
+getRuntimeManager_fn = /* @__PURE__ */ __name(function() {
+  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";
+  }
+}
+__name(iconStringForSeverity, "iconStringForSeverity");
+function preciseDateOriginNow() {
+  return {
+    hrtime: process.hrtime(),
+    timestamp: new PreciseDate()
+  };
+}
+__name(preciseDateOriginNow, "preciseDateOriginNow");
+function calculatePreciseDateHrTime(origin) {
+  const elapsedHrTime = process.hrtime(origin.hrtime);
+  const elapsedNanoseconds = BigInt(elapsedHrTime[0]) * BigInt(1e9) + BigInt(elapsedHrTime[1]);
+  const preciseDate = new PreciseDate(origin.timestamp.getFullTime() + elapsedNanoseconds);
+  const dateStruct = preciseDate.toStruct();
+  return [
+    dateStruct.seconds,
+    dateStruct.nanos
+  ];
+}
+__name(calculatePreciseDateHrTime, "calculatePreciseDateHrTime");
+
+// src/v3/logger/taskLogger.ts
+var logLevels = [
+  "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 < 4)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "debug", SeverityNumber.DEBUG, properties);
+  }
+  log(message, properties) {
+    if (this._level < 2)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "log", SeverityNumber.INFO, properties);
+  }
+  info(message, properties) {
+    if (this._level < 3)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "info", SeverityNumber.INFO, properties);
+  }
+  warn(message, properties) {
+    if (this._level < 1)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "warn", SeverityNumber.WARN, properties);
+  }
+  error(message, properties) {
+    if (this._level < 0)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, "error", SeverityNumber.ERROR, properties);
+  }
+  trace(name, fn, options) {
+    return this._config.tracer.startActiveSpan(name, fn, options);
+  }
+};
+_emitLog = new WeakSet();
+emitLog_fn = /* @__PURE__ */ __name(function(message, severityText, severityNumber, properties) {
+  const timestamp = __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this);
+  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 calculatePreciseDateHrTime(this._config.preciseDateOrigin);
+}, "#getTimestampInHrTime");
+__name(_OtelTaskLogger, "OtelTaskLogger");
+var OtelTaskLogger = _OtelTaskLogger;
+var _NoopTaskLogger = class _NoopTaskLogger {
+  debug() {
+  }
+  log() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+  trace(name, fn) {
+    return fn({});
+  }
+};
+__name(_NoopTaskLogger, "NoopTaskLogger");
+var NoopTaskLogger = _NoopTaskLogger;
+
+// src/v3/logger/index.ts
+var API_NAME2 = "logger";
+var NOOP_TASK_LOGGER = new NoopTaskLogger();
+var _getTaskLogger, getTaskLogger_fn;
+var _LoggerAPI = class _LoggerAPI {
+  constructor() {
+    __privateAdd(this, _getTaskLogger);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _LoggerAPI();
+    }
+    return this._instance;
+  }
+  disable() {
+    unregisterGlobal(API_NAME2);
+  }
+  setGlobalTaskLogger(taskLogger) {
+    return registerGlobal(API_NAME2, taskLogger);
+  }
+  debug(message, metadata) {
+    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).debug(message, metadata);
+  }
+  log(message, metadata) {
+    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).log(message, metadata);
+  }
+  info(message, metadata) {
+    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).info(message, metadata);
+  }
+  warn(message, metadata) {
+    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).warn(message, metadata);
+  }
+  error(message, metadata) {
+    __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).error(message, metadata);
+  }
+  trace(name, fn) {
+    return __privateMethod(this, _getTaskLogger, getTaskLogger_fn).call(this).trace(name, fn);
+  }
+};
+_getTaskLogger = new WeakSet();
+getTaskLogger_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME2) ?? NOOP_TASK_LOGGER;
+}, "#getTaskLogger");
+__name(_LoggerAPI, "LoggerAPI");
+var LoggerAPI = _LoggerAPI;
+
+// src/v3/logger-api.ts
+var logger = LoggerAPI.getInstance();
+
+// src/v3/limits.ts
+var OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = 256;
+var OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = 256;
+var OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
+var OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
+var OTEL_SPAN_EVENT_COUNT_LIMIT = 10;
+var OTEL_LINK_COUNT_LIMIT = 2;
+var OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = 10;
+var OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = 10;
+var OFFLOAD_IO_PACKET_LENGTH_LIMIT = 128 * 1024;
+function imposeAttributeLimits(attributes) {
+  const newAttributes = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (calculateAttributeValueLength(value) > OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT) {
+      continue;
+    }
+    if (Object.keys(newAttributes).length >= OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT) {
+      break;
+    }
+    newAttributes[key] = value;
+  }
+  return newAttributes;
+}
+__name(imposeAttributeLimits, "imposeAttributeLimits");
+function calculateAttributeValueLength(value) {
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  if (typeof value === "string") {
+    return value.length;
+  }
+  if (typeof value === "number") {
+    return 8;
+  }
+  if (typeof value === "boolean") {
+    return 4;
+  }
+  if (Array.isArray(value)) {
+    return value.reduce((acc, v) => acc + calculateAttributeValueLength(v), 0);
+  }
+  return 0;
+}
+__name(calculateAttributeValueLength, "calculateAttributeValueLength");
+function dateDifference(date1, date2) {
+  return Math.abs(date1.getTime() - date2.getTime());
+}
+__name(dateDifference, "dateDifference");
+function formatDuration(start, end, options) {
+  if (!start || !end) {
+    return "\u2013";
+  }
+  return formatDurationMilliseconds(dateDifference(start, end), options);
+}
+__name(formatDuration, "formatDuration");
+function nanosecondsToMilliseconds(nanoseconds) {
+  return nanoseconds / 1e6;
+}
+__name(nanosecondsToMilliseconds, "nanosecondsToMilliseconds");
+function millisecondsToNanoseconds(milliseconds) {
+  return milliseconds * 1e6;
+}
+__name(millisecondsToNanoseconds, "millisecondsToNanoseconds");
+function formatDurationNanoseconds(nanoseconds, options) {
+  return formatDurationMilliseconds(nanosecondsToMilliseconds(nanoseconds), options);
+}
+__name(formatDurationNanoseconds, "formatDurationNanoseconds");
+var aboveOneSecondUnits = [
+  "d",
+  "h",
+  "m",
+  "s"
+];
+var belowOneSecondUnits = [
+  "ms"
+];
+function formatDurationMilliseconds(milliseconds, options) {
+  let duration = humanizeDuration(milliseconds, {
+    units: options?.units ? options.units : milliseconds < 1e3 ? belowOneSecondUnits : aboveOneSecondUnits,
+    maxDecimalPoints: options?.maxDecimalPoints ?? 1,
+    largest: 2
+  });
+  if (!options) {
+    return duration;
+  }
+  switch (options.style) {
+    case "short":
+      duration = duration.replace(" milliseconds", "ms");
+      duration = duration.replace(" millisecond", "ms");
+      duration = duration.replace(" seconds", "s");
+      duration = duration.replace(" second", "s");
+      duration = duration.replace(" minutes", "m");
+      duration = duration.replace(" minute", "m");
+      duration = duration.replace(" hours", "h");
+      duration = duration.replace(" hour", "h");
+      duration = duration.replace(" days", "d");
+      duration = duration.replace(" day", "d");
+      duration = duration.replace(" weeks", "w");
+      duration = duration.replace(" week", "w");
+      duration = duration.replace(" months", "mo");
+      duration = duration.replace(" month", "mo");
+      duration = duration.replace(" years", "y");
+      duration = duration.replace(" year", "y");
+  }
+  return duration;
+}
+__name(formatDurationMilliseconds, "formatDurationMilliseconds");
+function formatDurationInDays(milliseconds) {
+  let duration = humanizeDuration(milliseconds, {
+    maxDecimalPoints: 0,
+    largest: 2,
+    units: [
+      "d"
+    ]
+  });
+  return duration;
+}
+__name(formatDurationInDays, "formatDurationInDays");
+
+// src/v3/runtime/devRuntimeManager.ts
+var _DevRuntimeManager = class _DevRuntimeManager {
+  constructor() {
+    __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;
+
+// src/v3/runtime/prodRuntimeManager.ts
+var _ProdRuntimeManager = class _ProdRuntimeManager {
+  constructor(ipc) {
+    this.ipc = ipc;
+    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) {
+    let timeout;
+    const now = Date.now();
+    const resolveAfterDuration = new Promise((resolve) => {
+      timeout = setTimeout(resolve, ms);
+    });
+    if (ms < 1e4) {
+      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", {});
+    clearTimeout(timeout);
+  }
+  resumeAfterRestore() {
+    if (!this._waitForRestore) {
+      return;
+    }
+    this._waitForRestore.resolve();
+    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);
+  }
+};
+__name(_ProdRuntimeManager, "ProdRuntimeManager");
+var ProdRuntimeManager = _ProdRuntimeManager;
+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
+    }, 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();
+      }
+    });
+  }
+  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, preciseDateOrigin) {
+    __privateAdd(this, _handleLog);
+    __privateAdd(this, _getTimestampInHrTime2);
+    __privateAdd(this, _getAttributes);
+    this.logger = logger2;
+    this.preciseDateOrigin = preciseDateOrigin;
+  }
+  // Intercept the console and send logs to the OpenTelemetry logger
+  // during the execution of the callback
+  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, "Log", ...args);
+  }
+  info(...args) {
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.INFO, "Info", ...args);
+  }
+  warn(...args) {
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.WARN, "Warn", ...args);
+  }
+  error(...args) {
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.ERROR, "Error", ...args);
+  }
+};
+_handleLog = new WeakSet();
+handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, severityText, ...args) {
+  const body = util.format(...args);
+  const timestamp = __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this);
+  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 calculatePreciseDateHrTime(this.preciseDateOrigin);
+}, "#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();
+}
+__name(calculateResetAt2, "calculateResetAt");
+
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
+}
+__name(accessoryAttributes, "accessoryAttributes");
+
+// src/eventFilterMatches.ts
+function eventFilterMatches(payload, filter) {
+  if (payload === void 0 || payload === null) {
+    if (Object.entries(filter).length === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  for (const [patternKey, patternValue] of Object.entries(filter)) {
+    const payloadValue = payload[patternKey];
+    if (Array.isArray(patternValue)) {
+      if (patternValue.length === 0) {
+        continue;
+      }
+      if (patternValue.every((item) => typeof item === "string")) {
+        if (patternValue.includes(payloadValue)) {
+          continue;
+        }
+        return false;
+      }
+      if (patternValue.every((item) => typeof item === "number")) {
+        if (patternValue.includes(payloadValue)) {
+          continue;
+        }
+        return false;
+      }
+      if (patternValue.every((item) => typeof item === "boolean")) {
+        if (patternValue.includes(payloadValue)) {
+          continue;
+        }
+        return false;
+      }
+      const objectArray = patternValue;
+      if (!contentFiltersMatches(payloadValue, objectArray)) {
+        return false;
+      }
+      continue;
+    } else if (typeof patternValue === "object") {
+      if (Array.isArray(payloadValue)) {
+        if (!payloadValue.some((item) => eventFilterMatches(item, patternValue))) {
+          return false;
+        }
+      } else {
+        if (!eventFilterMatches(payloadValue, patternValue)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+__name(eventFilterMatches, "eventFilterMatches");
+function contentFiltersMatches(actualValue, contentFilters) {
+  for (const contentFilter of contentFilters) {
+    if (typeof contentFilter === "object") {
+      Object.entries(contentFilter)[0];
+      if (!contentFilterMatches(actualValue, contentFilter)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+__name(contentFiltersMatches, "contentFiltersMatches");
+function contentFilterMatches(actualValue, contentFilter) {
+  if ("$endsWith" in contentFilter) {
+    if (typeof actualValue !== "string") {
+      return false;
+    }
+    return actualValue.endsWith(contentFilter.$endsWith);
+  }
+  if ("$startsWith" in contentFilter) {
+    if (typeof actualValue !== "string") {
+      return false;
+    }
+    return actualValue.startsWith(contentFilter.$startsWith);
+  }
+  if ("$anythingBut" in contentFilter) {
+    if (Array.isArray(contentFilter.$anythingBut)) {
+      if (contentFilter.$anythingBut.includes(actualValue)) {
+        return false;
+      }
+    }
+    if (contentFilter.$anythingBut === actualValue) {
+      return false;
+    }
+    return true;
+  }
+  if ("$exists" in contentFilter) {
+    if (contentFilter.$exists) {
+      return actualValue !== void 0;
+    }
+    return actualValue === void 0;
+  }
+  if ("$gt" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue > contentFilter.$gt;
+  }
+  if ("$lt" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue < contentFilter.$lt;
+  }
+  if ("$gte" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue >= contentFilter.$gte;
+  }
+  if ("$lte" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue <= contentFilter.$lte;
+  }
+  if ("$between" in contentFilter) {
+    if (typeof actualValue !== "number") {
+      return false;
+    }
+    return actualValue >= contentFilter.$between[0] && actualValue <= contentFilter.$between[1];
+  }
+  if ("$includes" in contentFilter) {
+    if (Array.isArray(actualValue)) {
+      return actualValue.includes(contentFilter.$includes);
+    }
+    return false;
+  }
+  if ("$ignoreCaseEquals" in contentFilter) {
+    if (typeof actualValue !== "string") {
+      return false;
+    }
+    return actualValue.localeCompare(contentFilter.$ignoreCaseEquals, void 0, {
+      sensitivity: "accent"
+    }) === 0;
+  }
+  if ("$isNull" in contentFilter) {
+    if (contentFilter.$isNull) {
+      return actualValue === null;
+    }
+    return actualValue !== null;
+  }
+  if ("$not" in contentFilter) {
+    if (Array.isArray(actualValue)) {
+      return !actualValue.includes(contentFilter.$not);
+    } else if (typeof actualValue === "number" || typeof actualValue === "boolean" || typeof actualValue === "string") {
+      return actualValue !== contentFilter.$not;
+    }
+    return false;
+  }
+  return true;
+}
+__name(contentFilterMatches, "contentFilterMatches");
+
+// src/v3/utils/omit.ts
+function omit(obj, ...keys) {
+  const result = {};
+  for (const key in obj) {
+    if (!keys.includes(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+__name(omit, "omit");
+var _a2;
+var AsyncResourceDetector = (_a2 = class {
+  constructor() {
+    __publicField(this, "_resolved", false);
+    this._promise = new Promise((resolver) => {
+      this._resolver = resolver;
+    });
+  }
+  detect(_config) {
+    return new Resource({}, this._promise);
+  }
+  resolveWithAttributes(attributes) {
+    if (!this._resolver) {
+      throw new Error("Resolver not available");
+    }
+    if (this._resolved) {
+      return;
+    }
+    this._resolved = true;
+    this._resolver(attributes);
+  }
+}, __name(_a2, "AsyncResourceDetector"), _a2);
+var _TracingSDK = class _TracingSDK {
+  constructor(config) {
+    this.config = config;
+    this.asyncResourceDetector = new AsyncResourceDetector();
+    setLogLevel(config.diagLogLevel ?? "none");
+    const envResourceAttributesSerialized = getEnvVar("OTEL_RESOURCE_ATTRIBUTES");
+    const envResourceAttributes = envResourceAttributesSerialized ? JSON.parse(envResourceAttributesSerialized) : {};
+    const commonResources = detectResourcesSync({
+      detectors: [
+        this.asyncResourceDetector,
+        processDetectorSync
+      ]
+    }).merge(new Resource({
+      [SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev",
+      [SemanticInternalAttributes.TRIGGER]: true
+    })).merge(config.resource ?? new Resource({})).merge(new Resource(envResourceAttributes));
+    const traceProvider = new NodeTracerProvider({
+      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500,
+      resource: commonResources,
+      spanLimits: {
+        attributeCountLimit: OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
+        attributeValueLengthLimit: OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT,
+        eventCountLimit: OTEL_SPAN_EVENT_COUNT_LIMIT,
+        attributePerEventCountLimit: OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
+        linkCountLimit: OTEL_LINK_COUNT_LIMIT,
+        attributePerLinkCountLimit: OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT
+      }
+    });
+    const spanExporter = new OTLPTraceExporter({
+      url: `${config.url}/v1/traces`,
+      timeoutMillis: config.forceFlushTimeoutMillis ?? 1e3
+    });
+    traceProvider.addSpanProcessor(new TaskContextSpanProcessor(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(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);
+}
+__name(setLogLevel, "setLogLevel");
+
+// src/v3/otel/index.ts
+function recordSpanException(span, error) {
+  if (error instanceof Error) {
+    span.recordException(error);
+  } else if (typeof error === "string") {
+    span.recordException(new Error(error));
+  } else {
+    span.recordException(new Error(JSON.stringify(error)));
+  }
+  span.setStatus({
+    code: SpanStatusCode.ERROR
+  });
+}
+__name(recordSpanException, "recordSpanException");
+function parsePacket(value) {
+  if (!value.data) {
+    return void 0;
+  }
+  switch (value.dataType) {
+    case "application/json":
+      return JSON.parse(value.data);
+    case "application/super+json":
+      return parse(value.data);
+    case "text/plain":
+      return value.data;
+    case "application/store":
+      throw new Error(`Cannot parse an application/store packet (${value.data}). Needs to be imported first.`);
+    default:
+      return value.data;
+  }
+}
+__name(parsePacket, "parsePacket");
+function stringifyIO(value) {
+  if (value === void 0) {
+    return {
+      dataType: "application/json"
+    };
+  }
+  if (typeof value === "string") {
+    return {
+      data: value,
+      dataType: "text/plain"
+    };
+  }
+  return {
+    data: stringify(value),
+    dataType: "application/super+json"
+  };
+}
+__name(stringifyIO, "stringifyIO");
+async function conditionallyExportPacket(packet, pathPrefix, tracer) {
+  if (apiClientManager.client) {
+    const { needsOffloading, size } = packetRequiresOffloading(packet);
+    if (needsOffloading) {
+      if (!tracer) {
+        return await exportPacket(packet, pathPrefix);
+      } else {
+        const result = await tracer.startActiveSpan("store.uploadOutput", async (span) => {
+          return await exportPacket(packet, pathPrefix);
+        }, {
+          attributes: {
+            byteLength: size,
+            [SemanticInternalAttributes.STYLE_ICON]: "cloud-upload"
+          }
+        });
+        return result ?? packet;
+      }
+    }
+  }
+  return packet;
+}
+__name(conditionallyExportPacket, "conditionallyExportPacket");
+function packetRequiresOffloading(packet) {
+  if (!packet.data) {
+    return {
+      needsOffloading: false,
+      size: 0
+    };
+  }
+  const byteSize = Buffer.byteLength(packet.data, "utf8");
+  return {
+    needsOffloading: byteSize >= OFFLOAD_IO_PACKET_LENGTH_LIMIT,
+    size: byteSize
+  };
+}
+__name(packetRequiresOffloading, "packetRequiresOffloading");
+async function exportPacket(packet, pathPrefix) {
+  const filename = `${pathPrefix}.${getPacketExtension(packet.dataType)}`;
+  const presignedResponse = await apiClientManager.client.createUploadPayloadUrl(filename);
+  if (presignedResponse.ok) {
+    const uploadResponse = await fetch(presignedResponse.data.presignedUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": packet.dataType
+      },
+      body: packet.data
+    });
+    if (!uploadResponse.ok) {
+      throw new Error(`Failed to upload output to ${presignedResponse.data.presignedUrl}: ${uploadResponse.statusText}`);
+    }
+    return {
+      data: filename,
+      dataType: "application/store"
+    };
+  }
+  return packet;
+}
+__name(exportPacket, "exportPacket");
+async function conditionallyImportPacket(packet, tracer) {
+  if (packet.dataType !== "application/store") {
+    return packet;
+  }
+  if (!tracer) {
+    return await importPacket(packet);
+  } else {
+    const result = await tracer.startActiveSpan("store.downloadPayload", async (span) => {
+      return await importPacket(packet, span);
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "cloud-download"
+      }
+    });
+    return result ?? packet;
+  }
+}
+__name(conditionallyImportPacket, "conditionallyImportPacket");
+async function importPacket(packet, span) {
+  if (!packet.data) {
+    return packet;
+  }
+  if (!apiClientManager.client) {
+    return packet;
+  }
+  const presignedResponse = await apiClientManager.client.getPayloadUrl(packet.data);
+  if (presignedResponse.ok) {
+    const response = await fetch(presignedResponse.data.presignedUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to import packet ${presignedResponse.data.presignedUrl}: ${response.statusText}`);
+    }
+    const data = await response.text();
+    span?.setAttribute("size", Buffer.byteLength(data, "utf8"));
+    return {
+      data,
+      dataType: response.headers.get("content-type") ?? "application/json"
+    };
+  }
+  return packet;
+}
+__name(importPacket, "importPacket");
+function createPacketAttributes(packet, dataKey, dataTypeKey) {
+  if (!packet.data) {
+    return {};
+  }
+  switch (packet.dataType) {
+    case "application/json":
+      return {
+        ...flattenAttributes(packet, dataKey),
+        [dataTypeKey]: packet.dataType
+      };
+    case "application/super+json":
+      const parsed = parse(packet.data);
+      const jsonified = JSON.parse(JSON.stringify(parsed, safeReplacer));
+      return {
+        ...flattenAttributes(jsonified, dataKey),
+        [dataTypeKey]: "application/json"
+      };
+    case "application/store":
+      return {
+        [dataKey]: packet.data,
+        [dataTypeKey]: packet.dataType
+      };
+    case "text/plain":
+      return {
+        [SemanticInternalAttributes.OUTPUT]: packet.data,
+        [SemanticInternalAttributes.OUTPUT_TYPE]: packet.dataType
+      };
+    default:
+      return {};
+  }
+}
+__name(createPacketAttributes, "createPacketAttributes");
+function createPackageAttributesAsJson(data, dataType) {
+  if (typeof data === "string" || typeof data === "number" || typeof data === "boolean" || data === null || data === void 0) {
+    return data;
+  }
+  switch (dataType) {
+    case "application/json":
+      return imposeAttributeLimits(flattenAttributes(data, void 0));
+    case "application/super+json":
+      const deserialized = deserialize(data);
+      const jsonify = JSON.parse(JSON.stringify(deserialized, safeReplacer));
+      return imposeAttributeLimits(flattenAttributes(jsonify, void 0));
+    case "application/store":
+      return data;
+    default:
+      return {};
+  }
+}
+__name(createPackageAttributesAsJson, "createPackageAttributesAsJson");
+function prettyPrintPacket(rawData, dataType) {
+  if (rawData === void 0) {
+    return "";
+  }
+  if (dataType === "application/super+json") {
+    return prettyPrintPacket(deserialize(rawData), "application/json");
+  }
+  if (dataType === "application/json") {
+    return JSON.stringify(rawData, safeReplacer, 2);
+  }
+  if (typeof rawData === "string") {
+    return rawData;
+  }
+  return JSON.stringify(rawData, safeReplacer, 2);
+}
+__name(prettyPrintPacket, "prettyPrintPacket");
+function safeReplacer(key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  if (value instanceof Set) {
+    return Array.from(value);
+  }
+  if (value instanceof Map) {
+    const obj = {};
+    value.forEach((v, k) => {
+      obj[k] = v;
+    });
+    return obj;
+  }
+  return value;
+}
+__name(safeReplacer, "safeReplacer");
+function getPacketExtension(outputType) {
+  switch (outputType) {
+    case "application/json":
+      return "json";
+    case "application/super+json":
+      return "json";
+    case "text/plain":
+      return "txt";
+    default:
+      return "txt";
+  }
+}
+__name(getPacketExtension, "getPacketExtension");
+
+// 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 = 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 = stringifyIO(output);
+              const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
+              span.setAttributes(createPacketAttributes(finalOutput, SemanticInternalAttributes.OUTPUT, SemanticInternalAttributes.OUTPUT_TYPE));
+              return {
+                ok: true,
+                id: execution.attempt.id,
+                output: finalOutput.data,
+                outputType: finalOutput.dataType
+              };
+            } catch (stringifyError) {
+              recordSpanException(span, stringifyError);
+              return {
+                ok: false,
+                id: execution.attempt.id,
+                error: {
+                  type: "INTERNAL_ERROR",
+                  code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
+                  message: stringifyError instanceof Error ? stringifyError.message : typeof stringifyError === "string" ? stringifyError : void 0
+                }
+              };
+            }
+          } catch (runError) {
+            try {
+              const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
+              recordSpanException(span, handleErrorResult.error ?? runError);
+              return {
+                id: execution.attempt.id,
+                ok: false,
+                error: handleErrorResult.error ? parseError(handleErrorResult.error) : parseError(runError),
+                retry: handleErrorResult.status === "retry" ? handleErrorResult.retry : void 0,
+                skippedRetrying: handleErrorResult.status === "skipped"
+              };
+            } catch (handleErrorError) {
+              recordSpanException(span, handleErrorError);
+              return {
+                ok: false,
+                id: execution.attempt.id,
+                error: {
+                  type: "INTERNAL_ERROR",
+                  code: TaskRunErrorCodes.HANDLE_ERROR_ERROR,
+                  message: handleErrorError instanceof Error ? handleErrorError.message : typeof handleErrorError === "string" ? handleErrorError : void 0
+                }
+              };
+            }
+          } finally {
+            await __privateMethod(this, _callTaskCleanup, callTaskCleanup_fn).call(this, parsedPayload, ctx, initOutput);
+          }
+        });
+      }, {
+        kind: SpanKind.CONSUMER,
+        attributes: {
+          [SemanticInternalAttributes.STYLE_ICON]: "attempt",
+          ...accessoryAttributes({
+            items: [
+              {
+                text: ctx.task.filePath
+              },
+              {
+                text: `${ctx.task.exportName}.run()`
+              }
+            ],
+            style: "codepath"
+          })
+        }
+      }, this._tracer.extractContext(traceContext));
+    });
+    return result;
+  }
+};
+_callRun = new WeakSet();
+callRun_fn = /* @__PURE__ */ __name(async function(payload, ctx, init) {
+  const runFn = this.task.fns.run;
+  const middlewareFn = this.task.fns.middleware;
+  if (!runFn) {
+    throw new Error("Task does not have a run function");
+  }
+  if (!middlewareFn) {
+    return runFn(payload, {
+      ctx
+    });
+  }
+  return middlewareFn(payload, {
+    ctx,
+    next: async () => runFn(payload, {
+      ctx,
+      init
+    })
+  });
+}, "#callRun");
+_callTaskInit = new WeakSet();
+callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+  const initFn = this.task.fns.init;
+  if (!initFn) {
+    return {};
+  }
+  return this._tracer.startActiveSpan("init", async (span) => {
+    return await initFn(payload1, {
+      ctx: ctx1
+    });
+  });
+}, "#callTaskInit");
+_callTaskCleanup = new WeakSet();
+callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload2, ctx2, init1) {
+  const cleanupFn = this.task.fns.cleanup;
+  if (!cleanupFn) {
+    return;
+  }
+  return this._tracer.startActiveSpan("cleanup", async (span) => {
+    return await cleanupFn(payload2, {
+      ctx: ctx2,
+      init: init1
+    });
+  });
+}, "#callTaskCleanup");
+_handleError = new WeakSet();
+handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload3, ctx3) {
+  const retriesConfig = this._importedConfig?.retries ?? this._config.retries;
+  const retry = this.task.retry ?? retriesConfig?.default;
+  if (!retry) {
+    return {
+      status: "noop"
+    };
+  }
+  const delay = calculateNextRetryDelay(retry, execution.attempt.number);
+  if (execution.environment.type === "DEVELOPMENT" && typeof retriesConfig?.enabledInDev === "boolean" && !retriesConfig.enabledInDev) {
+    return {
+      status: "skipped"
+    };
+  }
+  return this._tracer.startActiveSpan("handleError()", async (span) => {
+    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload3, error, {
+      ctx: ctx3,
+      retry,
+      retryDelayInMs: delay,
+      retryAt: delay ? new Date(Date.now() + delay) : void 0
+    }) : this._importedConfig ? await this._handleErrorFn?.(payload3, error, {
+      ctx: ctx3,
+      retry,
+      retryDelayInMs: delay,
+      retryAt: delay ? new Date(Date.now() + delay) : void 0
+    }) : void 0;
+    if (!handleErrorResult) {
+      return typeof delay === "undefined" ? {
+        status: "noop"
+      } : {
+        status: "retry",
+        retry: {
+          timestamp: Date.now() + delay,
+          delay
+        }
+      };
+    }
+    if (handleErrorResult.skipRetrying) {
+      return {
+        status: "skipped",
+        error: handleErrorResult.error
+      };
+    }
+    if (typeof handleErrorResult.retryAt !== "undefined") {
+      return {
+        status: "retry",
+        retry: {
+          timestamp: handleErrorResult.retryAt.getTime(),
+          delay: handleErrorResult.retryAt.getTime() - Date.now()
+        },
+        error: handleErrorResult.error
+      };
+    }
+    if (typeof handleErrorResult.retryDelayInMs === "number") {
+      return {
+        status: "retry",
+        retry: {
+          timestamp: Date.now() + handleErrorResult.retryDelayInMs,
+          delay: handleErrorResult.retryDelayInMs
+        },
+        error: handleErrorResult.error
+      };
+    }
+    if (handleErrorResult.retry && typeof handleErrorResult.retry === "object") {
+      const delay2 = calculateNextRetryDelay(handleErrorResult.retry, execution.attempt.number);
+      return typeof delay2 === "undefined" ? {
+        status: "noop",
+        error: handleErrorResult.error
+      } : {
+        status: "retry",
+        retry: {
+          timestamp: Date.now() + delay2,
+          delay: delay2
+        },
+        error: handleErrorResult.error
+      };
+    }
+    return {
+      status: "noop",
+      error: handleErrorResult.error
+    };
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "exclamation-circle"
+    }
+  });
+}, "#handleError");
+__name(_TaskExecutor, "TaskExecutor");
+var TaskExecutor = _TaskExecutor;
+
+// package.json
+var dependencies = {
+  "@google-cloud/precise-date": "^4.0.0",
+  "@opentelemetry/api": "^1.8.0",
+  "@opentelemetry/api-logs": "^0.48.0",
+  "@opentelemetry/exporter-logs-otlp-http": "^0.49.1",
+  "@opentelemetry/exporter-trace-otlp-http": "^0.49.1",
+  "@opentelemetry/instrumentation": "^0.49.1",
+  "@opentelemetry/resources": "^1.22.0",
+  "@opentelemetry/sdk-logs": "^0.49.1",
+  "@opentelemetry/sdk-node": "^0.49.1",
+  "@opentelemetry/sdk-trace-base": "^1.22.0",
+  "@opentelemetry/sdk-trace-node": "^1.22.0",
+  "@opentelemetry/semantic-conventions": "^1.22.0",
+  "humanize-duration": "^3.27.3",
+  "socket.io": "^4.7.4",
+  "socket.io-client": "^4.7.4",
+  superjson: "^2.2.1",
+  ulidx: "^2.2.1",
+  zod: "3.22.3",
+  "zod-error": "1.5.0"
+};
+
+// src/v3/utils/detectDependencyVersion.ts
+function detectDependencyVersion(dependency) {
+  return dependencies[dependency];
+}
+__name(detectDependencyVersion, "detectDependencyVersion");
+
+// src/v3/index.ts
+function parseTriggerTaskRequestBody(body) {
+  return TriggerTaskRequestBody.safeParse(body);
+}
+__name(parseTriggerTaskRequestBody, "parseTriggerTaskRequestBody");
+function parseBatchTriggerTaskRequestBody(body) {
+  return BatchTriggerTaskRequestBody.safeParse(body);
+}
+__name(parseBatchTriggerTaskRequestBody, "parseBatchTriggerTaskRequestBody");
+
+export { ApiClient, ApiClientManager, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConsoleInterceptor, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateUploadPayloadUrlResponseBody, DevRuntimeManager, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, LogLevel, Machine, 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, ProdChildToWorkerMessages, ProdRuntimeManager, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitOptions, RetryOptions, SemanticInternalAttributes, SharedQueueToClientMessages, SimpleStructuredLogger, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskContextSpanProcessor, TaskEventStyle, TaskExecutor, TaskMetadata, 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, ZodSocketConnection, ZodSocketMessageHandler, ZodSocketMessageSender, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculatePreciseDateHrTime, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createPackageAttributesAsJson, createPacketAttributes, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, getEnvVar, iconStringForSeverity, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseBatchTriggerTaskRequestBody, parseError, parsePacket, parseTriggerTaskRequestBody, preciseDateOriginNow, prettyPrintPacket, primitiveValueOrflattenedAttributes, recordSpanException, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskContextManager, unflattenAttributes, workerToChildMessages };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map