@trigger.dev/core 0.0.0-v3-prerelease-20240813130521 → 0.0.0-v3-prerelease-20240912191953

package/dist/v3/index.mjs

@@ -1,4546 +0,0 @@
-import { propagation, context, trace, SpanStatusCode } from '@opentelemetry/api';
-import { z } from 'zod';
-import { fromZodError } from 'zod-validation-error';
-import { PreciseDate } from '@google-cloud/precise-date';
-import { logs } from '@opentelemetry/api-logs';
-import humanizeDuration from 'humanize-duration';
-
-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 __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 __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
-
-// package.json
-var version = "0.0.0-v3-prerelease-20240813130521";
-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-client": "4.7.5",
-  superjson: "^2.2.1",
-  ulidx: "^2.2.1",
-  zod: "3.22.3",
-  "zod-error": "1.5.0",
-  "zod-validation-error": "^1.5.0"
-};
-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 MachineCpu = z.union([
-  z.literal(0.25),
-  z.literal(0.5),
-  z.literal(1),
-  z.literal(2),
-  z.literal(4)
-]);
-var MachineMemory = z.union([
-  z.literal(0.25),
-  z.literal(0.5),
-  z.literal(1),
-  z.literal(2),
-  z.literal(4),
-  z.literal(8)
-]);
-var MachinePresetName = z.enum([
-  "micro",
-  "small-1x",
-  "small-2x",
-  "medium-1x",
-  "medium-2x",
-  "large-1x",
-  "large-2x"
-]);
-var MachineConfig = z.object({
-  cpu: MachineCpu.optional(),
-  memory: MachineMemory.optional(),
-  preset: MachinePresetName.optional()
-});
-var MachinePreset = z.object({
-  name: MachinePresetName,
-  cpu: z.number(),
-  memory: z.number(),
-  centsPerMs: z.number()
-});
-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",
-  COULD_NOT_FIND_TASK: "COULD_NOT_FIND_TASK",
-  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_PROCESS_SIGKILL_TIMEOUT: "TASK_PROCESS_SIGKILL_TIMEOUT",
-  TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
-  TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
-  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
-  GRACEFUL_EXIT_TIMEOUT: "GRACEFUL_EXIT_TIMEOUT",
-  TASK_RUN_CRASHED: "TASK_RUN_CRASHED"
-};
-var TaskRunInternalError = z.object({
-  type: z.literal("INTERNAL_ERROR"),
-  code: z.enum([
-    "COULD_NOT_FIND_EXECUTOR",
-    "COULD_NOT_FIND_TASK",
-    "CONFIGURED_INCORRECTLY",
-    "TASK_ALREADY_RUNNING",
-    "TASK_EXECUTION_FAILED",
-    "TASK_EXECUTION_ABORTED",
-    "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
-    "TASK_PROCESS_SIGKILL_TIMEOUT",
-    "TASK_RUN_CANCELLED",
-    "TASK_OUTPUT_ERROR",
-    "HANDLE_ERROR_ERROR",
-    "GRACEFUL_EXIT_TIMEOUT",
-    "TASK_RUN_HEARTBEAT_TIMEOUT",
-    "TASK_RUN_CRASHED"
-  ]),
-  message: z.string().optional(),
-  stackTrace: 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(),
-  startedAt: z.coerce.date().default(() => /* @__PURE__ */ new Date()),
-  idempotencyKey: z.string().optional(),
-  maxAttempts: z.number().optional(),
-  durationMs: z.number().default(0),
-  costInCents: z.number().default(0),
-  baseCostInCents: z.number().default(0),
-  version: z.string().optional()
-});
-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(),
-  machine: MachinePreset.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(),
-  machine: MachinePreset.optional()
-});
-var TaskRunExecutionRetry = z.object({
-  timestamp: z.number(),
-  delay: z.number(),
-  error: z.unknown().optional()
-});
-var TaskRunExecutionUsage = z.object({
-  durationMs: z.number()
-});
-var TaskRunFailedExecutionResult = z.object({
-  ok: z.literal(false),
-  id: z.string(),
-  error: TaskRunError,
-  retry: TaskRunExecutionRetry.optional(),
-  skippedRetrying: z.boolean().optional(),
-  usage: TaskRunExecutionUsage.optional()
-});
-var TaskRunSuccessfulExecutionResult = z.object({
-  ok: z.literal(true),
-  id: z.string(),
-  output: z.string().optional(),
-  outputType: z.string(),
-  usage: TaskRunExecutionUsage.optional()
-});
-var TaskRunExecutionResult = z.discriminatedUnion("ok", [
-  TaskRunSuccessfulExecutionResult,
-  TaskRunFailedExecutionResult
-]);
-var BatchTaskRunExecutionResult = z.object({
-  id: z.string(),
-  items: TaskRunExecutionResult.array()
-});
-
-// src/v3/schemas/schemas.ts
-var EnvironmentType = z.enum([
-  "PRODUCTION",
-  "STAGING",
-  "DEVELOPMENT",
-  "PREVIEW"
-]);
-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()
-  }),
-  machine: MachinePreset.default({
-    name: "small-1x",
-    cpu: 1,
-    memory: 1,
-    centsPerMs: 0
-  })
-});
-var ProdTaskRunExecutionPayload = z.object({
-  execution: ProdTaskRunExecution,
-  traceContext: z.record(z.unknown()),
-  environment: z.record(z.string()).optional()
-});
-var FixedWindowRateLimit = z.object({
-  type: z.literal("fixed-window"),
-  limit: z.number(),
-  window: z.union([
-    z.object({
-      seconds: z.number()
-    }),
-    z.object({
-      minutes: z.number()
-    }),
-    z.object({
-      hours: z.number()
-    })
-  ])
-});
-var SlidingWindowRateLimit = z.object({
-  type: z.literal("sliding-window"),
-  limit: z.number(),
-  window: z.union([
-    z.object({
-      seconds: z.number()
-    }),
-    z.object({
-      minutes: z.number()
-    }),
-    z.object({
-      hours: z.number()
-    })
-  ])
-});
-var RateLimitOptions = z.discriminatedUnion("type", [
-  FixedWindowRateLimit,
-  SlidingWindowRateLimit
-]);
-var RetryOptions = z.object({
-  /** The number of attempts before giving up */
-  maxAttempts: z.number().int().optional(),
-  /** The exponential factor to use when calculating the next retry time.
-  *
-  * Each subsequent retry will be calculated as `previousTimeout * factor`
-  */
-  factor: z.number().optional(),
-  /** The minimum time to wait before retrying */
-  minTimeoutInMs: z.number().int().optional(),
-  /** The maximum time to wait before retrying */
-  maxTimeoutInMs: z.number().int().optional(),
-  /** Randomize the timeout between retries.
-  *
-  * This can be useful to prevent the thundering herd problem where all retries happen at the same time.
-  */
-  randomize: z.boolean().optional()
-});
-var QueueOptions = z.object({
-  /** You can define a shared queue and then pass the name in to your task.
-     * 
-     * @example
-     * 
-     * ```ts
-     * const myQueue = queue({
-        name: "my-queue",
-        concurrencyLimit: 1,
-      });
-  
-      export const task1 = task({
-        id: "task-1",
-        queue: {
-          name: "my-queue",
-        },
-        run: async (payload: { message: string }) => {
-          // ...
-        },
-      });
-  
-      export const task2 = task({
-        id: "task-2",
-        queue: {
-          name: "my-queue",
-        },
-        run: async (payload: { message: string }) => {
-          // ...
-        },
-      });
-     * ```
-     */
-  name: z.string().optional(),
-  /** An optional property that specifies the maximum number of concurrent run executions.
-  *
-  * If this property is omitted, the task can potentially use up the full concurrency of an environment. */
-  concurrencyLimit: z.number().int().min(0).max(1e3).optional(),
-  /** @deprecated This feature is coming soon */
-  rateLimit: RateLimitOptions.optional()
-});
-var ScheduleMetadata = z.object({
-  cron: z.string(),
-  timezone: z.string()
-});
-var TaskMetadata = z.object({
-  id: z.string(),
-  packageVersion: z.string(),
-  queue: QueueOptions.optional(),
-  retry: RetryOptions.optional(),
-  machine: MachineConfig.optional(),
-  triggerSource: z.string().optional(),
-  schedule: ScheduleMetadata.optional()
-});
-var TaskFileMetadata = z.object({
-  filePath: z.string(),
-  exportName: z.string()
-});
-var TaskMetadataWithFilePath = z.object({
-  id: z.string(),
-  packageVersion: z.string(),
-  queue: QueueOptions.optional(),
-  retry: RetryOptions.optional(),
-  machine: MachineConfig.optional(),
-  triggerSource: z.string().optional(),
-  schedule: ScheduleMetadata.optional(),
-  filePath: z.string(),
-  exportName: z.string()
-});
-var PostStartCauses = z.enum([
-  "index",
-  "create",
-  "restore"
-]);
-var PreStopCauses = z.enum([
-  "terminate"
-]);
-var RegexSchema = z.custom((val) => {
-  try {
-    return typeof val.test === "function";
-  } catch {
-    return false;
-  }
-});
-var Config = z.object({
-  project: z.string(),
-  triggerDirectories: z.string().array().optional(),
-  triggerUrl: z.string().optional(),
-  projectDir: z.string().optional(),
-  tsconfigPath: z.string().optional(),
-  retries: z.object({
-    enabledInDev: z.boolean().default(true),
-    default: RetryOptions.optional()
-  }).optional(),
-  additionalPackages: z.string().array().optional(),
-  additionalFiles: z.string().array().optional(),
-  dependenciesToBundle: z.array(z.union([
-    z.string(),
-    RegexSchema
-  ])).optional(),
-  logLevel: z.string().optional(),
-  enableConsoleLogging: z.boolean().optional(),
-  postInstall: z.string().optional(),
-  extraCACerts: z.string().optional()
-});
-var WaitReason = z.enum([
-  "WAIT_FOR_DURATION",
-  "WAIT_FOR_TASK",
-  "WAIT_FOR_BATCH"
-]);
-var TaskRunExecutionLazyAttemptPayload = z.object({
-  runId: z.string(),
-  attemptCount: z.number().optional(),
-  messageId: z.string(),
-  isTest: z.boolean(),
-  traceContext: z.record(z.unknown()),
-  environment: z.record(z.string()).optional()
-});
-
-// src/v3/schemas/resources.ts
-var TaskResource = z.object({
-  id: z.string(),
-  filePath: z.string(),
-  exportName: z.string(),
-  queue: QueueOptions.optional(),
-  retry: RetryOptions.optional(),
-  machine: MachineConfig.optional(),
-  triggerSource: z.string().optional(),
-  schedule: ScheduleMetadata.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()
-});
-var _AbortTaskRunError = class _AbortTaskRunError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AbortTaskRunError";
-  }
-};
-__name(_AbortTaskRunError, "AbortTaskRunError");
-var AbortTaskRunError = _AbortTaskRunError;
-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");
-var SerializedError = z.object({
-  message: z.string(),
-  name: z.string().optional(),
-  stackTrace: z.string().optional()
-});
-function createJsonErrorObject(error) {
-  switch (error.type) {
-    case "BUILT_IN_ERROR": {
-      return {
-        name: error.name,
-        message: error.message,
-        stackTrace: error.stackTrace
-      };
-    }
-    case "STRING_ERROR": {
-      return {
-        message: error.raw
-      };
-    }
-    case "CUSTOM_ERROR": {
-      return {
-        message: error.raw
-      };
-    }
-    case "INTERNAL_ERROR": {
-      return {
-        message: `trigger.dev internal error (${error.code})`
-      };
-    }
-  }
-}
-__name(createJsonErrorObject, "createJsonErrorObject");
-function sanitizeError(error) {
-  switch (error.type) {
-    case "BUILT_IN_ERROR": {
-      return {
-        type: "BUILT_IN_ERROR",
-        message: error.message?.replace(/\0/g, ""),
-        name: error.name?.replace(/\0/g, ""),
-        stackTrace: error.stackTrace?.replace(/\0/g, "")
-      };
-    }
-    case "STRING_ERROR": {
-      return {
-        type: "STRING_ERROR",
-        raw: error.raw.replace(/\0/g, "")
-      };
-    }
-    case "CUSTOM_ERROR": {
-      return {
-        type: "CUSTOM_ERROR",
-        raw: error.raw.replace(/\0/g, "")
-      };
-    }
-    case "INTERNAL_ERROR": {
-      return {
-        type: "INTERNAL_ERROR",
-        code: error.code,
-        message: error.message?.replace(/\0/g, ""),
-        stackTrace: error.stackTrace?.replace(/\0/g, "")
-      };
-    }
-  }
-}
-__name(sanitizeError, "sanitizeError");
-function correctErrorStackTrace(stackTrace, projectDir, options) {
-  const [errorLine, ...traceLines] = stackTrace.split("\n");
-  return [
-    options?.removeFirstLine ? void 0 : errorLine,
-    ...traceLines.map((line) => correctStackTraceLine(line, projectDir, options?.isDev))
-  ].filter(Boolean).join("\n");
-}
-__name(correctErrorStackTrace, "correctErrorStackTrace");
-var LINES_TO_IGNORE = [
-  /ConsoleInterceptor/,
-  /TriggerTracer/,
-  /TaskExecutor/,
-  /EXECUTE_TASK_RUN/,
-  /@trigger.dev\/core/,
-  /packages\/core\/src\/v3/,
-  /safeJsonProcess/,
-  /__entryPoint.ts/,
-  /ZodIpc/,
-  /startActiveSpan/,
-  /processTicksAndRejections/
-];
-function correctStackTraceLine(line, projectDir, isDev) {
-  if (LINES_TO_IGNORE.some((regex) => regex.test(line))) {
-    return;
-  }
-  if (isDev && projectDir && !line.includes(projectDir)) {
-    return;
-  }
-  return line.trim();
-}
-__name(correctStackTraceLine, "correctStackTraceLine");
-function groupTaskMetadataIssuesByTask(tasks, issues) {
-  return issues.reduce((acc, issue) => {
-    if (issue.path.length === 0) {
-      return acc;
-    }
-    const taskIndex = issue.path[1];
-    if (typeof taskIndex !== "number") {
-      return acc;
-    }
-    const task = tasks[taskIndex];
-    if (!task) {
-      return acc;
-    }
-    const restOfPath = issue.path.slice(2);
-    const taskId = task.id;
-    const taskName = task.exportName;
-    const filePath = task.filePath;
-    const key = taskIndex;
-    const existing = acc[key] ?? {
-      id: taskId,
-      exportName: taskName,
-      filePath,
-      issues: []
-    };
-    existing.issues.push({
-      message: issue.message,
-      path: restOfPath.length === 0 ? void 0 : restOfPath.join(".")
-    });
-    return {
-      ...acc,
-      [key]: existing
-    };
-  }, {});
-}
-__name(groupTaskMetadataIssuesByTask, "groupTaskMetadataIssuesByTask");
-
-// src/v3/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,
-  supportsLazyAttempts: z.boolean().optional()
-});
-var CreateBackgroundWorkerResponse = z.object({
-  id: z.string(),
-  version: z.string(),
-  contentHash: z.string()
-});
-var RunTag = z.string().max(64, "Tags must be less than 64 characters");
-var RunTags = z.union([
-  RunTag,
-  RunTag.array()
-]);
-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(),
-    idempotencyKey: z.string().optional(),
-    test: z.boolean().optional(),
-    payloadType: z.string().optional(),
-    delay: z.string().or(z.coerce.date()).optional(),
-    ttl: z.string().or(z.number().nonnegative().int()).optional(),
-    tags: RunTags.optional(),
-    maxAttempts: z.number().int().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 AddTagsRequestBody = z.object({
-  tags: RunTags
-});
-var RescheduleRunRequestBody = z.object({
-  delay: z.string().or(z.coerce.date())
-});
-var GetEnvironmentVariablesResponseBody = z.object({
-  variables: z.record(z.string())
-});
-var StartDeploymentIndexingRequestBody = z.object({
-  imageReference: z.string(),
-  selfHosted: z.boolean().optional()
-});
-var StartDeploymentIndexingResponseBody = z.object({
-  id: z.string(),
-  contentHash: z.string()
-});
-var ExternalBuildData = z.object({
-  buildId: z.string(),
-  buildToken: z.string(),
-  projectId: z.string()
-});
-var InitializeDeploymentResponseBody = z.object({
-  id: z.string(),
-  contentHash: z.string(),
-  shortCode: z.string(),
-  version: z.string(),
-  imageTag: z.string(),
-  externalBuildData: ExternalBuildData.optional().nullable(),
-  registryHost: z.string().optional()
-});
-var InitializeDeploymentRequestBody = z.object({
-  contentHash: z.string(),
-  userId: z.string().optional()
-});
-var DeploymentErrorData = z.object({
-  name: z.string(),
-  message: z.string(),
-  stack: z.string().optional(),
-  stderr: z.string().optional()
-});
-var GetDeploymentResponseBody = z.object({
-  id: z.string(),
-  status: z.enum([
-    "PENDING",
-    "BUILDING",
-    "DEPLOYING",
-    "DEPLOYED",
-    "FAILED",
-    "CANCELED",
-    "TIMED_OUT"
-  ]),
-  contentHash: z.string(),
-  shortCode: z.string(),
-  version: z.string(),
-  imageReference: z.string().optional(),
-  errorData: DeploymentErrorData.optional().nullable(),
-  worker: z.object({
-    id: z.string(),
-    version: z.string(),
-    tasks: z.array(z.object({
-      id: z.string(),
-      slug: z.string(),
-      filePath: z.string(),
-      exportName: z.string()
-    }))
-  }).optional()
-});
-var CreateUploadPayloadUrlResponseBody = z.object({
-  presignedUrl: z.string()
-});
-var ReplayRunResponse = z.object({
-  id: z.string()
-});
-var CanceledRunResponse = z.object({
-  id: z.string()
-});
-var ScheduleType = z.union([
-  z.literal("DECLARATIVE"),
-  z.literal("IMPERATIVE")
-]);
-var ScheduledTaskPayload = z.object({
-  /** The schedule id associated with this run (you can have many schedules for the same task).
-  You can use this to remove the schedule, update it, etc */
-  scheduleId: z.string(),
-  /** The type of schedule – `"DECLARATIVE"` or `"IMPERATIVE"`.
-  *
-  * **DECLARATIVE** – defined inline on your `schedules.task` using the `cron` property. They can only be created, updated or deleted by modifying the `cron` property on your task.
-  *
-  * **IMPERATIVE** – created using the `schedules.create` functions or in the dashboard.
-  */
-  type: ScheduleType,
-  /** When the task was scheduled to run.
-  * Note this will be slightly different from `new Date()` because it takes a few ms to run the task.
-  * 
-  * This date is UTC. To output it as a string with a timezone you would do this: 
-  * ```ts
-  * const formatted = payload.timestamp.toLocaleString("en-US", {
-       timeZone: payload.timezone,
-   });
-   ```  */
-  timestamp: z.date(),
-  /** When the task was last run (it has been).
-  This can be undefined if it's never been run. This date is UTC. */
-  lastTimestamp: z.date().optional(),
-  /** You can optionally provide an external id when creating the schedule.
-  Usually you would use a userId or some other unique identifier.
-  This defaults to undefined if you didn't provide one. */
-  externalId: z.string().optional(),
-  /** The IANA timezone the schedule is set to. The default is UTC.
-  * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
-  */
-  timezone: z.string(),
-  /** The next 5 dates this task is scheduled to run */
-  upcoming: z.array(z.date())
-});
-var CreateScheduleOptions = z.object({
-  /** The id of the task you want to attach to. */
-  task: z.string(),
-  /**  The schedule in CRON format.
-     * 
-     * ```txt
-  *    *    *    *    *    *
-  ┬    ┬    ┬    ┬    ┬
-  │    │    │    │    |
-  │    │    │    │    └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
-  │    │    │    └───── month (1 - 12)
-  │    │    └────────── day of month (1 - 31, L)
-  │    └─────────────── hour (0 - 23)
-  └──────────────────── minute (0 - 59)
-     * ```
-  
-  "L" means the last. In the "day of week" field, 1L means the last Monday of the month. In the day of month field, L means the last day of the month.
-  
-     */
-  cron: z.string(),
-  /** You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
-  *
-  * This is required to prevent you from creating duplicate schedules. */
-  deduplicationKey: z.string(),
-  /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
-  *
-  * This allows you to have per-user CRON tasks.
-  */
-  externalId: z.string().optional(),
-  /** Optionally, you can specify a timezone in the IANA format. If unset it will use UTC.
-  * If specified then the CRON will be evaluated in that timezone and will respect daylight savings.
-  *
-  * If you set the CRON to `0 0 * * *` and the timezone to `America/New_York` then the task will run at midnight in New York time, no matter whether it's daylight savings or not.
-  *
-  * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
-  *
-  * @example "America/New_York", "Europe/London", "Asia/Tokyo", "Africa/Cairo"
-  *
-  */
-  timezone: z.string().optional()
-});
-var UpdateScheduleOptions = CreateScheduleOptions.omit({
-  deduplicationKey: true
-});
-var ScheduleGenerator = z.object({
-  type: z.literal("CRON"),
-  expression: z.string(),
-  description: z.string()
-});
-var ScheduleObject = z.object({
-  id: z.string(),
-  type: ScheduleType,
-  task: z.string(),
-  active: z.boolean(),
-  deduplicationKey: z.string().nullish(),
-  externalId: z.string().nullish(),
-  generator: ScheduleGenerator,
-  timezone: z.string(),
-  nextRun: z.coerce.date().nullish(),
-  environments: z.array(z.object({
-    id: z.string(),
-    type: z.string(),
-    userName: z.string().nullish()
-  }))
-});
-var DeletedScheduleObject = z.object({
-  id: z.string()
-});
-var ListSchedulesResult = z.object({
-  data: z.array(ScheduleObject),
-  pagination: z.object({
-    currentPage: z.number(),
-    totalPages: z.number(),
-    count: z.number()
-  })
-});
-var ListScheduleOptions = z.object({
-  page: z.number().optional(),
-  perPage: z.number().optional()
-});
-var TimezonesResult = z.object({
-  timezones: z.array(z.string())
-});
-var RunStatus = z.enum([
-  /// Task hasn't been deployed yet but is waiting to be executed
-  "WAITING_FOR_DEPLOY",
-  /// Task is waiting to be executed by a worker
-  "QUEUED",
-  /// Task is currently being executed by a worker
-  "EXECUTING",
-  /// Task has failed and is waiting to be retried
-  "REATTEMPTING",
-  /// Task has been paused by the system, and will be resumed by the system
-  "FROZEN",
-  /// Task has been completed successfully
-  "COMPLETED",
-  /// Task has been canceled by the user
-  "CANCELED",
-  /// Task has been completed with errors
-  "FAILED",
-  /// Task has crashed and won't be retried, most likely the worker ran out of resources, e.g. memory or storage
-  "CRASHED",
-  /// Task was interrupted during execution, mostly this happens in development environments
-  "INTERRUPTED",
-  /// Task has failed to complete, due to an error in the system
-  "SYSTEM_FAILURE",
-  /// Task has been scheduled to run at a specific time
-  "DELAYED",
-  /// Task has expired and won't be executed
-  "EXPIRED"
-]);
-var AttemptStatus = z.enum([
-  "PENDING",
-  "EXECUTING",
-  "PAUSED",
-  "COMPLETED",
-  "FAILED",
-  "CANCELED"
-]);
-var RunEnvironmentDetails = z.object({
-  id: z.string(),
-  name: z.string(),
-  user: z.string().optional()
-});
-var RunScheduleDetails = z.object({
-  id: z.string(),
-  externalId: z.string().optional(),
-  deduplicationKey: z.string().optional(),
-  generator: ScheduleGenerator
-});
-var CommonRunFields = {
-  id: z.string(),
-  status: RunStatus,
-  taskIdentifier: z.string(),
-  idempotencyKey: z.string().optional(),
-  version: z.string().optional(),
-  isQueued: z.boolean(),
-  isExecuting: z.boolean(),
-  isCompleted: z.boolean(),
-  isSuccess: z.boolean(),
-  isFailed: z.boolean(),
-  isCancelled: z.boolean(),
-  isTest: z.boolean(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-  startedAt: z.coerce.date().optional(),
-  finishedAt: z.coerce.date().optional(),
-  delayedUntil: z.coerce.date().optional(),
-  ttl: z.string().optional(),
-  expiredAt: z.coerce.date().optional(),
-  tags: z.string().array(),
-  costInCents: z.number(),
-  baseCostInCents: z.number(),
-  durationMs: z.number()
-};
-var RetrieveRunResponse = z.object({
-  ...CommonRunFields,
-  payload: z.any().optional(),
-  payloadPresignedUrl: z.string().optional(),
-  output: z.any().optional(),
-  outputPresignedUrl: z.string().optional(),
-  schedule: RunScheduleDetails.optional(),
-  attempts: z.array(z.object({
-    id: z.string(),
-    status: AttemptStatus,
-    createdAt: z.coerce.date(),
-    updatedAt: z.coerce.date(),
-    startedAt: z.coerce.date().optional(),
-    completedAt: z.coerce.date().optional(),
-    error: SerializedError.optional()
-  }).optional())
-});
-var ListRunResponseItem = z.object({
-  ...CommonRunFields,
-  env: RunEnvironmentDetails
-});
-var ListRunResponse = z.object({
-  data: z.array(ListRunResponseItem),
-  pagination: z.object({
-    next: z.string().optional(),
-    previous: z.string().optional()
-  })
-});
-var CreateEnvironmentVariableRequestBody = z.object({
-  name: z.string(),
-  value: z.string()
-});
-var UpdateEnvironmentVariableRequestBody = z.object({
-  value: z.string()
-});
-var ImportEnvironmentVariablesRequestBody = z.object({
-  variables: z.record(z.string()),
-  override: z.boolean().optional()
-});
-var EnvironmentVariableResponseBody = z.object({
-  success: z.boolean()
-});
-var EnvironmentVariableValue = z.object({
-  value: z.string()
-});
-var EnvironmentVariable = z.object({
-  name: z.string(),
-  value: z.string()
-});
-var EnvironmentVariables = z.array(EnvironmentVariable);
-var BackgroundWorkerServerMessages = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("EXECUTE_RUNS"),
-    payloads: z.array(TaskRunExecutionPayload)
-  }),
-  z.object({
-    type: z.literal("CANCEL_ATTEMPT"),
-    taskAttemptId: z.string(),
-    taskRunId: z.string()
-  }),
-  z.object({
-    type: z.literal("SCHEDULE_ATTEMPT"),
-    image: z.string(),
-    version: z.string(),
-    machine: MachinePreset,
-    nextAttemptNumber: z.number().optional(),
-    // identifiers
-    id: z.string().optional(),
-    envId: z.string(),
-    envType: EnvironmentType,
-    orgId: z.string(),
-    projectId: z.string(),
-    runId: z.string()
-  }),
-  z.object({
-    type: z.literal("EXECUTE_RUN_LAZY_ATTEMPT"),
-    payload: TaskRunExecutionLazyAttemptPayload
-  })
-]);
-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_RUN_FAILED_TO_RUN"),
-    completion: TaskRunFailedExecutionResult
-  }),
-  z.object({
-    version: z.literal("v1").default("v1"),
-    type: z.literal("TASK_HEARTBEAT"),
-    id: z.string()
-  }),
-  z.object({
-    version: z.literal("v1").default("v1"),
-    type: z.literal("TASK_RUN_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(),
-    inProgressRuns: z.string().array().optional()
-  }),
-  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.discriminatedUnion("version", [
-    z.object({
-      version: z.literal("v1"),
-      completion: TaskRunExecutionResult,
-      execution: TaskRunExecution
-    }),
-    z.object({
-      version: z.literal("v2"),
-      completion: TaskRunExecutionResult
-    })
-  ]),
-  CLEANUP: z.object({
-    version: z.literal("v1").default("v1"),
-    flush: z.boolean().default(false),
-    kill: z.boolean().default(true)
-  })
-};
-var UncaughtExceptionMessage = z.object({
-  version: z.literal("v1").default("v1"),
-  error: z.object({
-    name: z.string(),
-    message: z.string(),
-    stack: z.string().optional()
-  }),
-  origin: z.enum([
-    "uncaughtException",
-    "unhandledRejection"
-  ])
-});
-var TaskMetadataFailedToParseData = z.object({
-  version: z.literal("v1").default("v1"),
-  tasks: z.unknown(),
-  zodIssues: z.custom((v) => {
-    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
-  })
-});
-var childToWorkerMessages = {
-  TASK_RUN_COMPLETED: z.object({
-    version: z.literal("v1").default("v1"),
-    execution: TaskRunExecution,
-    result: TaskRunExecutionResult
-  }),
-  TASKS_READY: z.object({
-    version: z.literal("v1").default("v1"),
-    tasks: TaskMetadataWithFilePath.array()
-  }),
-  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
-  TASK_HEARTBEAT: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string()
-  }),
-  TASK_RUN_HEARTBEAT: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string()
-  }),
-  READY_TO_DISPOSE: z.undefined(),
-  WAIT_FOR_DURATION: z.object({
-    version: z.literal("v1").default("v1"),
-    ms: z.number()
-  }),
-  WAIT_FOR_TASK: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string()
-  }),
-  WAIT_FOR_BATCH: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string(),
-    runs: z.string().array()
-  }),
-  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
-};
-var ProdChildToWorkerMessages = {
-  TASK_RUN_COMPLETED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      execution: TaskRunExecution,
-      result: TaskRunExecutionResult
-    })
-  },
-  TASKS_READY: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      tasks: TaskMetadataWithFilePath.array()
-    })
-  },
-  TASKS_FAILED_TO_PARSE: {
-    message: TaskMetadataFailedToParseData
-  },
-  TASK_HEARTBEAT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      id: z.string()
-    })
-  },
-  READY_TO_DISPOSE: {
-    message: z.undefined()
-  },
-  WAIT_FOR_DURATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      ms: z.number(),
-      now: z.number(),
-      waitThresholdInMs: z.number()
-    })
-  },
-  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.discriminatedUnion("version", [
-      z.object({
-        version: z.literal("v1"),
-        completion: TaskRunExecutionResult,
-        execution: TaskRunExecution
-      }),
-      z.object({
-        version: z.literal("v2"),
-        completion: TaskRunExecutionResult
-      })
-    ])
-  },
-  CLEANUP: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      flush: z.boolean().default(false),
-      kill: z.boolean().default(true)
-    }),
-    callback: z.void()
-  },
-  WAIT_COMPLETED_NOTIFICATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
-  }
-};
-var ProviderToPlatformMessages = {
-  LOG: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      data: z.string()
-    })
-  },
-  LOG_WITH_ACK: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      data: z.string()
-    }),
-    callback: z.object({
-      status: z.literal("ok")
-    })
-  },
-  WORKER_CRASHED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string(),
-      reason: z.string().optional(),
-      exitCode: z.number().optional(),
-      message: z.string().optional(),
-      logs: z.string().optional(),
-      overrideCompletion: z.boolean().optional()
-    })
-  },
-  INDEXING_FAILED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      deploymentId: z.string(),
-      error: z.object({
-        name: z.string(),
-        message: z.string(),
-        stack: z.string().optional(),
-        stderr: z.string().optional()
-      }),
-      overrideCompletion: z.boolean().optional()
-    })
-  }
-};
-var PlatformToProviderMessages = {
-  INDEX: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      imageTag: z.string(),
-      shortCode: z.string(),
-      apiKey: z.string(),
-      apiUrl: z.string(),
-      // identifiers
-      envId: z.string(),
-      envType: EnvironmentType,
-      orgId: z.string(),
-      projectId: z.string(),
-      deploymentId: z.string()
-    }),
-    callback: z.discriminatedUnion("success", [
-      z.object({
-        success: z.literal(false),
-        error: z.object({
-          name: z.string(),
-          message: z.string(),
-          stack: z.string().optional(),
-          stderr: z.string().optional()
-        })
-      }),
-      z.object({
-        success: z.literal(true)
-      })
-    ])
-  },
-  RESTORE: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      type: z.enum([
-        "DOCKER",
-        "KUBERNETES"
-      ]),
-      location: z.string(),
-      reason: z.string().optional(),
-      imageRef: z.string(),
-      attemptNumber: z.number().optional(),
-      machine: MachinePreset,
-      // identifiers
-      checkpointId: z.string(),
-      envId: z.string(),
-      envType: EnvironmentType,
-      orgId: z.string(),
-      projectId: z.string(),
-      runId: z.string()
-    })
-  },
-  PRE_PULL_DEPLOYMENT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      imageRef: z.string(),
-      shortCode: z.string(),
-      // identifiers
-      envId: z.string(),
-      envType: EnvironmentType,
-      orgId: z.string(),
-      projectId: z.string(),
-      deploymentId: z.string()
-    })
-  }
-};
-var CreateWorkerMessage = z.object({
-  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()
-  })
-});
-var CoordinatorToPlatformMessages = {
-  LOG: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      metadata: z.any(),
-      text: z.string()
-    })
-  },
-  CREATE_WORKER: {
-    message: z.discriminatedUnion("version", [
-      CreateWorkerMessage.extend({
-        version: z.literal("v1")
-      }),
-      CreateWorkerMessage.extend({
-        version: z.literal("v2"),
-        supportsLazyAttempts: z.boolean()
-      })
-    ]),
-    callback: z.discriminatedUnion("success", [
-      z.object({
-        success: z.literal(false)
-      }),
-      z.object({
-        success: z.literal(true)
-      })
-    ])
-  },
-  CREATE_TASK_RUN_ATTEMPT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string(),
-      envId: z.string()
-    }),
-    callback: z.discriminatedUnion("success", [
-      z.object({
-        success: z.literal(false),
-        reason: z.string().optional()
-      }),
-      z.object({
-        success: z.literal(true),
-        executionPayload: ProdTaskRunExecutionPayload
-      })
-    ])
-  },
-  // Deprecated: Only workers without lazy attempt support will use this
-  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_LAZY_ATTEMPT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string(),
-      envId: z.string(),
-      totalCompletions: z.number()
-    }),
-    callback: z.discriminatedUnion("success", [
-      z.object({
-        success: z.literal(false),
-        reason: z.string().optional()
-      }),
-      z.object({
-        success: z.literal(true),
-        lazyPayload: TaskRunExecutionLazyAttemptPayload
-      })
-    ])
-  },
-  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.enum([
-        "v1",
-        "v2"
-      ]).default("v1"),
-      execution: ProdTaskRunExecution,
-      completion: TaskRunExecutionResult,
-      checkpoint: z.object({
-        docker: z.boolean(),
-        location: z.string()
-      }).optional()
-    })
-  },
-  TASK_RUN_FAILED_TO_RUN: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      completion: TaskRunFailedExecutionResult
-    })
-  },
-  TASK_HEARTBEAT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptFriendlyId: z.string()
-    })
-  },
-  TASK_RUN_HEARTBEAT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: 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()
-        })
-      ])
-    }),
-    callback: z.object({
-      version: z.literal("v1").default("v1"),
-      keepRunAlive: 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(),
-        stderr: z.string().optional()
-      })
-    })
-  },
-  RUN_CRASHED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: 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()
-    })
-  },
-  REQUEST_RUN_CANCELLATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string(),
-      delayInMs: z.number().optional()
-    })
-  },
-  READY_FOR_RETRY: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string()
-    })
-  },
-  DYNAMIC_CONFIG: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      checkpointThresholdInMs: z.number()
-    })
-  }
-};
-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 IndexTasksMessage = z.object({
-  version: z.literal("v1"),
-  deploymentId: z.string(),
-  tasks: TaskResource.array(),
-  packageVersion: z.string()
-});
-var ProdWorkerToCoordinatorMessages = {
-  TEST: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    }),
-    callback: z.void()
-  },
-  INDEX_TASKS: {
-    message: z.discriminatedUnion("version", [
-      IndexTasksMessage.extend({
-        version: z.literal("v1")
-      }),
-      IndexTasksMessage.extend({
-        version: z.literal("v2"),
-        supportsLazyAttempts: z.boolean()
-      })
-    ]),
-    callback: z.discriminatedUnion("success", [
-      z.object({
-        success: z.literal(false)
-      }),
-      z.object({
-        success: z.literal(true)
-      })
-    ])
-  },
-  // Deprecated: Only workers without lazy attempt support will use this
-  READY_FOR_EXECUTION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string(),
-      totalCompletions: z.number()
-    })
-  },
-  READY_FOR_LAZY_ATTEMPT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string(),
-      totalCompletions: z.number()
-    })
-  },
-  READY_FOR_RESUME: {
-    message: z.discriminatedUnion("version", [
-      z.object({
-        version: z.literal("v1"),
-        attemptFriendlyId: z.string(),
-        type: WaitReason
-      }),
-      z.object({
-        version: z.literal("v2"),
-        attemptFriendlyId: z.string(),
-        attemptNumber: z.number(),
-        type: WaitReason
-      })
-    ])
-  },
-  READY_FOR_CHECKPOINT: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
-  },
-  CANCEL_CHECKPOINT: {
-    message: z.discriminatedUnion("version", [
-      z.object({
-        version: z.literal("v1")
-      }),
-      z.object({
-        version: z.literal("v2"),
-        reason: WaitReason.optional()
-      })
-    ]).default({
-      version: "v1"
-    }),
-    callback: z.object({
-      version: z.literal("v2").default("v2"),
-      checkpointCanceled: z.boolean(),
-      reason: WaitReason.optional()
-    })
-  },
-  TASK_HEARTBEAT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptFriendlyId: z.string()
-    })
-  },
-  TASK_RUN_HEARTBEAT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string()
-    })
-  },
-  TASK_RUN_COMPLETED: {
-    message: z.object({
-      version: z.enum([
-        "v1",
-        "v2"
-      ]).default("v1"),
-      execution: ProdTaskRunExecution,
-      completion: TaskRunExecutionResult
-    }),
-    callback: z.object({
-      willCheckpointAndRestore: z.boolean(),
-      shouldExit: z.boolean()
-    })
-  },
-  TASK_RUN_FAILED_TO_RUN: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      completion: TaskRunFailedExecutionResult
-    })
-  },
-  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.enum([
-        "v1",
-        "v2"
-      ]).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.enum([
-        "v1",
-        "v2"
-      ]).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(),
-        stderr: z.string().optional()
-      })
-    })
-  },
-  CREATE_TASK_RUN_ATTEMPT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string()
-    }),
-    callback: z.discriminatedUnion("success", [
-      z.object({
-        success: z.literal(false),
-        reason: z.string().optional()
-      }),
-      z.object({
-        success: z.literal(true),
-        executionPayload: ProdTaskRunExecutionPayload
-      })
-    ])
-  },
-  UNRECOVERABLE_ERROR: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      error: z.object({
-        name: z.string(),
-        message: z.string(),
-        stack: z.string().optional()
-      })
-    })
-  },
-  SET_STATE: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptFriendlyId: z.string().optional(),
-      attemptNumber: 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()
-    })
-  },
-  // Deprecated: Only workers without lazy attempt support will use this
-  EXECUTE_TASK_RUN: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      executionPayload: ProdTaskRunExecutionPayload
-    })
-  },
-  EXECUTE_TASK_RUN_LAZY_ATTEMPT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      lazyPayload: TaskRunExecutionLazyAttemptPayload
-    })
-  },
-  REQUEST_ATTEMPT_CANCELLATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptId: z.string()
-    })
-  },
-  REQUEST_EXIT: {
-    message: z.discriminatedUnion("version", [
-      z.object({
-        version: z.literal("v1")
-      }),
-      z.object({
-        version: z.literal("v2"),
-        delayInMs: z.number().optional()
-      })
-    ])
-  },
-  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(),
-  attemptNumber: z.string().optional(),
-  podName: z.string(),
-  deploymentId: z.string(),
-  deploymentVersion: z.string()
-});
-var CoordinatorSocketData = z.object({
-  supportsDynamicConfig: z.string().optional()
-});
-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/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/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",
-  MACHINE_PRESET_NAME: "ctx.machine.name",
-  MACHINE_PRESET_CPU: "ctx.machine.cpu",
-  MACHINE_PRESET_MEMORY: "ctx.machine.memory",
-  MACHINE_PRESET_CENTS_PER_MS: "ctx.machine.centsPerMs",
-  SPAN_PARTIAL: "$span.partial",
-  SPAN_ID: "$span.span_id",
-  OUTPUT: "$output",
-  OUTPUT_TYPE: "$mime_type_output",
-  STYLE: "$style",
-  STYLE_ICON: "$style.icon",
-  STYLE_VARIANT: "$style.variant",
-  STYLE_ACCESSORY: "$style.accessory",
-  METADATA: "$metadata",
-  TRIGGER: "$trigger",
-  PAYLOAD: "$payload",
-  PAYLOAD_TYPE: "$mime_type_payload",
-  SHOW: "$show",
-  SHOW_ACTIONS: "$show.actions",
-  WORKER_ID: "worker.id",
-  WORKER_VERSION: "worker.version",
-  CLI_VERSION: "cli.version",
-  SDK_VERSION: "sdk.version",
-  SDK_LANGUAGE: "sdk.language",
-  RETRY_AT: "retry.at",
-  RETRY_DELAY: "retry.delay",
-  RETRY_COUNT: "retry.count",
-  LINK_TITLE: "$link.title",
-  IDEMPOTENCY_KEY: "ctx.run.idempotencyKey",
-  USAGE_DURATION_MS: "$usage.durationMs",
-  USAGE_COST_IN_CENTS: "$usage.costInCents",
-  RATE_LIMIT_LIMIT: "response.rateLimit.limit",
-  RATE_LIMIT_REMAINING: "response.rateLimit.remaining",
-  RATE_LIMIT_RESET: "response.rateLimit.reset"
-};
-
-// src/v3/taskContext/index.ts
-var API_NAME = "task-context";
-var _getTaskContext, getTaskContext_fn;
-var _TaskContextAPI = class _TaskContextAPI {
-  constructor() {
-    __privateAdd(this, _getTaskContext);
-  }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _TaskContextAPI();
-    }
-    return this._instance;
-  }
-  get isInsideTask() {
-    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this) !== void 0;
-  }
-  get ctx() {
-    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.ctx;
-  }
-  get worker() {
-    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.worker;
-  }
-  get attributes() {
-    if (this.ctx) {
-      return {
-        ...this.contextAttributes,
-        ...this.workerAttributes
-      };
-    }
-    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,
-        [SemanticInternalAttributes.IDEMPOTENCY_KEY]: this.ctx.run.idempotencyKey,
-        [SemanticInternalAttributes.MACHINE_PRESET_NAME]: this.ctx.machine?.name,
-        [SemanticInternalAttributes.MACHINE_PRESET_CPU]: this.ctx.machine?.cpu,
-        [SemanticInternalAttributes.MACHINE_PRESET_MEMORY]: this.ctx.machine?.memory,
-        [SemanticInternalAttributes.MACHINE_PRESET_CENTS_PER_MS]: this.ctx.machine?.centsPerMs
-      };
-    }
-    return {};
-  }
-  disable() {
-    unregisterGlobal(API_NAME);
-  }
-  setGlobalTaskContext(taskContext2) {
-    return registerGlobal(API_NAME, taskContext2);
-  }
-};
-_getTaskContext = new WeakSet();
-getTaskContext_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME);
-}, "#getTaskContext");
-__name(_TaskContextAPI, "TaskContextAPI");
-var TaskContextAPI = _TaskContextAPI;
-
-// src/v3/task-context-api.ts
-var taskContext = TaskContextAPI.getInstance();
-
-// src/retry.ts
-function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
-  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/apiClient/errors.ts
-var _ApiError = class _ApiError extends Error {
-  constructor(status, error, message, headers) {
-    super(`${_ApiError.makeMessage(status, error, message)}`);
-    this.name = "TriggerApiError";
-    this.status = status;
-    this.headers = headers;
-    const data = error;
-    this.error = data;
-    this.code = data?.["code"];
-    this.param = data?.["param"];
-    this.type = data?.["type"];
-  }
-  static makeMessage(status, error, message) {
-    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
-    if (status && msg) {
-      return `${status} ${msg}`;
-    }
-    if (status) {
-      return `${status} status code (no body)`;
-    }
-    if (msg) {
-      return msg;
-    }
-    return "(no status code or body)";
-  }
-  static generate(status, errorResponse, message, headers) {
-    if (!status) {
-      return new ApiConnectionError({
-        cause: castToError(errorResponse)
-      });
-    }
-    const error = errorResponse?.["error"];
-    if (status === 400) {
-      return new BadRequestError(status, error, message, headers);
-    }
-    if (status === 401) {
-      return new AuthenticationError(status, error, message, headers);
-    }
-    if (status === 403) {
-      return new PermissionDeniedError(status, error, message, headers);
-    }
-    if (status === 404) {
-      return new NotFoundError(status, error, message, headers);
-    }
-    if (status === 409) {
-      return new ConflictError(status, error, message, headers);
-    }
-    if (status === 422) {
-      return new UnprocessableEntityError(status, error, message, headers);
-    }
-    if (status === 429) {
-      return new RateLimitError(status, error, message, headers);
-    }
-    if (status >= 500) {
-      return new InternalServerError(status, error, message, headers);
-    }
-    return new _ApiError(status, error, message, headers);
-  }
-};
-__name(_ApiError, "ApiError");
-var ApiError = _ApiError;
-var _ApiConnectionError = class _ApiConnectionError extends ApiError {
-  constructor({ message, cause }) {
-    super(void 0, void 0, message || "Connection error.", void 0);
-    __publicField(this, "status");
-    if (cause)
-      this.cause = cause;
-  }
-};
-__name(_ApiConnectionError, "ApiConnectionError");
-var ApiConnectionError = _ApiConnectionError;
-var _BadRequestError = class _BadRequestError extends ApiError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 400);
-  }
-};
-__name(_BadRequestError, "BadRequestError");
-var BadRequestError = _BadRequestError;
-var _AuthenticationError = class _AuthenticationError extends ApiError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 401);
-  }
-};
-__name(_AuthenticationError, "AuthenticationError");
-var AuthenticationError = _AuthenticationError;
-var _PermissionDeniedError = class _PermissionDeniedError extends ApiError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 403);
-  }
-};
-__name(_PermissionDeniedError, "PermissionDeniedError");
-var PermissionDeniedError = _PermissionDeniedError;
-var _NotFoundError = class _NotFoundError extends ApiError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 404);
-  }
-};
-__name(_NotFoundError, "NotFoundError");
-var NotFoundError = _NotFoundError;
-var _ConflictError = class _ConflictError extends ApiError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 409);
-  }
-};
-__name(_ConflictError, "ConflictError");
-var ConflictError = _ConflictError;
-var _UnprocessableEntityError = class _UnprocessableEntityError extends ApiError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 422);
-  }
-};
-__name(_UnprocessableEntityError, "UnprocessableEntityError");
-var UnprocessableEntityError = _UnprocessableEntityError;
-var _RateLimitError = class _RateLimitError extends ApiError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 429);
-  }
-  get millisecondsUntilReset() {
-    const resetAtUnixEpochMs = (this.headers ?? {})["x-ratelimit-reset"];
-    if (typeof resetAtUnixEpochMs === "string") {
-      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
-      if (isNaN(resetAtUnixEpoch)) {
-        return;
-      }
-      return Math.max(resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 2e3), 0);
-    }
-  }
-};
-__name(_RateLimitError, "RateLimitError");
-var RateLimitError = _RateLimitError;
-var _InternalServerError = class _InternalServerError extends ApiError {
-};
-__name(_InternalServerError, "InternalServerError");
-var InternalServerError = _InternalServerError;
-function castToError(err) {
-  if (err instanceof Error)
-    return err;
-  return new Error(err);
-}
-__name(castToError, "castToError");
-
-// src/v3/utils/flattenAttributes.ts
-var NULL_SENTINEL = "$@null((";
-function flattenAttributes(obj, prefix) {
-  const result = {};
-  if (obj === void 0) {
-    return result;
-  }
-  if (obj === null) {
-    result[prefix || ""] = NULL_SENTINEL;
-    return result;
-  }
-  if (typeof obj === "string") {
-    result[prefix || ""] = obj;
-    return result;
-  }
-  if (typeof obj === "number") {
-    result[prefix || ""] = obj;
-    return result;
-  }
-  if (typeof obj === "boolean") {
-    result[prefix || ""] = obj;
-    return result;
-  }
-  for (const [key, value] of Object.entries(obj)) {
-    const newPrefix = `${prefix ? `${prefix}.` : ""}${Array.isArray(obj) ? `[${key}]` : key}`;
-    if (Array.isArray(value)) {
-      for (let i = 0; i < value.length; i++) {
-        if (typeof value[i] === "object" && value[i] !== null) {
-          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
-        } else {
-          if (value[i] === null) {
-            result[`${newPrefix}.[${i}]`] = NULL_SENTINEL;
-          } else {
-            result[`${newPrefix}.[${i}]`] = value[i];
-          }
-        }
-      }
-    } else if (isRecord(value)) {
-      Object.assign(result, flattenAttributes(value, newPrefix));
-    } else {
-      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
-        result[newPrefix] = value;
-      } else if (value === null) {
-        result[newPrefix] = NULL_SENTINEL;
-      }
-    }
-  }
-  return 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;
-  }
-  if (typeof obj === "object" && obj !== null && Object.keys(obj).length === 1 && Object.keys(obj)[0] === "") {
-    return rehydrateNull(obj[""]);
-  }
-  if (Object.keys(obj).length === 0) {
-    return;
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const parts = key.split(".").reduce((acc, part) => {
-      if (part.includes("[")) {
-        const subparts = part.split(/\[|\]/).filter((p) => p !== "");
-        acc.push(...subparts);
-      } else {
-        acc.push(part);
-      }
-      return acc;
-    }, []);
-    let current = result;
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i];
-      const nextPart = parts[i + 1];
-      const isArray = /^\d+$/.test(nextPart);
-      if (isArray && !Array.isArray(current[part])) {
-        current[part] = [];
-      } else if (!isArray && current[part] === void 0) {
-        current[part] = {};
-      }
-      current = current[part];
-    }
-    const lastPart = parts[parts.length - 1];
-    current[lastPart] = rehydrateNull(value);
-  }
-  if (Object.keys(result).every((k) => /^\d+$/.test(k))) {
-    const maxIndex = Math.max(...Object.keys(result).map((k) => parseInt(k)));
-    const arrayResult = Array(maxIndex + 1);
-    for (const key in result) {
-      arrayResult[parseInt(key)] = result[key];
-    }
-    return arrayResult;
-  }
-  return result;
-}
-__name(unflattenAttributes, "unflattenAttributes");
-function primitiveValueOrflattenedAttributes(obj, prefix) {
-  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || obj === void 0) {
-    return obj;
-  }
-  const attributes = flattenAttributes(obj, prefix);
-  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
-    return attributes[prefix];
-  }
-  return attributes;
-}
-__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
-function rehydrateNull(value) {
-  if (value === NULL_SENTINEL) {
-    return null;
-  }
-  return value;
-}
-__name(rehydrateNull, "rehydrateNull");
-
-// src/v3/utils/styleAttributes.ts
-function accessoryAttributes(accessory) {
-  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
-}
-__name(accessoryAttributes, "accessoryAttributes");
-
-// src/v3/apiClient/pagination.ts
-var _CursorPage = class _CursorPage {
-  constructor(data, pagination, pageFetcher) {
-    this.pageFetcher = pageFetcher;
-    this.data = data;
-    this.pagination = pagination;
-  }
-  getPaginatedItems() {
-    return this.data ?? [];
-  }
-  hasNextPage() {
-    return !!this.pagination.next;
-  }
-  hasPreviousPage() {
-    return !!this.pagination.previous;
-  }
-  getNextPage() {
-    if (!this.pagination.next) {
-      throw new Error("No next page available");
-    }
-    return this.pageFetcher({
-      after: this.pagination.next
-    });
-  }
-  getPreviousPage() {
-    if (!this.pagination.previous) {
-      throw new Error("No previous page available");
-    }
-    return this.pageFetcher({
-      before: this.pagination.previous
-    });
-  }
-  async *iterPages() {
-    let page = this;
-    yield page;
-    while (page.hasNextPage()) {
-      page = await page.getNextPage();
-      yield page;
-    }
-  }
-  async *[Symbol.asyncIterator]() {
-    for await (const page of this.iterPages()) {
-      for (const item of page.getPaginatedItems()) {
-        yield item;
-      }
-    }
-  }
-};
-__name(_CursorPage, "CursorPage");
-var CursorPage = _CursorPage;
-var _OffsetLimitPage = class _OffsetLimitPage {
-  constructor(data, pagination, pageFetcher) {
-    this.pageFetcher = pageFetcher;
-    this.data = data;
-    this.pagination = pagination;
-  }
-  getPaginatedItems() {
-    return this.data ?? [];
-  }
-  hasNextPage() {
-    return this.pagination.currentPage < this.pagination.totalPages;
-  }
-  hasPreviousPage() {
-    return this.pagination.currentPage > 1;
-  }
-  getNextPage() {
-    if (!this.hasNextPage()) {
-      throw new Error("No next page available");
-    }
-    return this.pageFetcher({
-      page: this.pagination.currentPage + 1
-    });
-  }
-  getPreviousPage() {
-    if (!this.hasPreviousPage()) {
-      throw new Error("No previous page available");
-    }
-    return this.pageFetcher({
-      page: this.pagination.currentPage - 1
-    });
-  }
-  async *iterPages() {
-    let page = this;
-    yield page;
-    while (page.hasNextPage()) {
-      page = await page.getNextPage();
-      yield page;
-    }
-  }
-  async *[Symbol.asyncIterator]() {
-    for await (const page of this.iterPages()) {
-      for (const item of page.getPaginatedItems()) {
-        yield item;
-      }
-    }
-  }
-};
-__name(_OffsetLimitPage, "OffsetLimitPage");
-var OffsetLimitPage = _OffsetLimitPage;
-
-// src/v3/apiClient/core.ts
-var defaultRetryOptions2 = {
-  maxAttempts: 3,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: false
-};
-var requestOptionsKeys = {
-  retry: true
-};
-var isRequestOptions = /* @__PURE__ */ __name((obj) => {
-  return typeof obj === "object" && obj !== null && !isEmptyObj(obj) && Object.keys(obj).every((k) => hasOwn(requestOptionsKeys, k));
-}, "isRequestOptions");
-function zodfetch(schema, url, requestInit, options) {
-  return new ApiPromise(_doZodFetch(schema, url, requestInit, options));
-}
-__name(zodfetch, "zodfetch");
-function zodfetchCursorPage(schema, url, params, requestInit, options) {
-  const query = new URLSearchParams(params.query);
-  if (params.limit) {
-    query.set("page[size]", String(params.limit));
-  }
-  if (params.after) {
-    query.set("page[after]", params.after);
-  }
-  if (params.before) {
-    query.set("page[before]", params.before);
-  }
-  const cursorPageSchema = z.object({
-    data: z.array(schema),
-    pagination: z.object({
-      next: z.string().optional(),
-      previous: z.string().optional()
-    })
-  });
-  const $url = new URL(url);
-  $url.search = query.toString();
-  const fetchResult = _doZodFetch(cursorPageSchema, $url.href, requestInit, options);
-  return new CursorPagePromise(fetchResult, schema, url, params, requestInit, options);
-}
-__name(zodfetchCursorPage, "zodfetchCursorPage");
-function zodfetchOffsetLimitPage(schema, url, params, requestInit, options) {
-  const query = new URLSearchParams(params.query);
-  if (params.limit) {
-    query.set("perPage", String(params.limit));
-  }
-  if (params.page) {
-    query.set("page", String(params.page));
-  }
-  const offsetLimitPageSchema = z.object({
-    data: z.array(schema),
-    pagination: z.object({
-      currentPage: z.coerce.number(),
-      totalPages: z.coerce.number(),
-      count: z.coerce.number()
-    })
-  });
-  const $url = new URL(url);
-  $url.search = query.toString();
-  const fetchResult = _doZodFetch(offsetLimitPageSchema, $url.href, requestInit, options);
-  return new OffsetLimitPagePromise(fetchResult, schema, url, params, requestInit, options);
-}
-__name(zodfetchOffsetLimitPage, "zodfetchOffsetLimitPage");
-async function traceZodFetch(params, callback) {
-  if (!params.options?.tracer) {
-    return callback();
-  }
-  const url = new URL(params.url);
-  const method = params.requestInit?.method ?? "GET";
-  const name = params.options.name ?? `${method} ${url.pathname}`;
-  return await params.options.tracer.startActiveSpan(name, async (span) => {
-    return await callback(span);
-  }, {
-    attributes: {
-      [SemanticInternalAttributes.STYLE_ICON]: params.options?.icon ?? "api",
-      ...params.options.attributes
-    }
-  });
-}
-__name(traceZodFetch, "traceZodFetch");
-async function _doZodFetch(schema, url, requestInit, options) {
-  const $requestInit = await requestInit;
-  return traceZodFetch({
-    url,
-    requestInit: $requestInit,
-    options
-  }, async (span) => {
-    const result = await _doZodFetchWithRetries(schema, url, $requestInit, options);
-    if (options?.onResponseBody && span) {
-      options.onResponseBody(result.data, span);
-    }
-    return result;
-  });
-}
-__name(_doZodFetch, "_doZodFetch");
-async function _doZodFetchWithRetries(schema, url, requestInit, options, attempt = 1) {
-  try {
-    const response = await fetch(url, requestInitWithCache(requestInit));
-    const responseHeaders = createResponseHeaders(response.headers);
-    if (!response.ok) {
-      const retryResult = shouldRetry(response, attempt, options?.retry);
-      if (retryResult.retry) {
-        await waitForRetry(url, attempt + 1, retryResult.delay, options, requestInit, response);
-        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
-      } else {
-        const errText = await response.text().catch((e) => castToError2(e).message);
-        const errJSON = safeJsonParse(errText);
-        const errMessage = errJSON ? void 0 : errText;
-        throw ApiError.generate(response.status, errJSON, errMessage, responseHeaders);
-      }
-    }
-    const jsonBody = await response.json();
-    const parsedResult = schema.safeParse(jsonBody);
-    if (parsedResult.success) {
-      return {
-        data: parsedResult.data,
-        response
-      };
-    }
-    throw fromZodError(parsedResult.error);
-  } catch (error) {
-    if (error instanceof ApiError) {
-      throw error;
-    }
-    if (options?.retry) {
-      const retry = {
-        ...defaultRetryOptions2,
-        ...options.retry
-      };
-      const delay = calculateNextRetryDelay(retry, attempt);
-      if (delay) {
-        await waitForRetry(url, attempt + 1, delay, options, requestInit);
-        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
-      }
-    }
-    throw new ApiConnectionError({
-      cause: castToError2(error)
-    });
-  }
-}
-__name(_doZodFetchWithRetries, "_doZodFetchWithRetries");
-function castToError2(err) {
-  if (err instanceof Error)
-    return err;
-  return new Error(err);
-}
-__name(castToError2, "castToError");
-function shouldRetry(response, attempt, retryOptions) {
-  function shouldRetryForOptions() {
-    const retry = {
-      ...defaultRetryOptions2,
-      ...retryOptions
-    };
-    const delay = calculateNextRetryDelay(retry, attempt);
-    if (delay) {
-      return {
-        retry: true,
-        delay
-      };
-    } else {
-      return {
-        retry: false
-      };
-    }
-  }
-  __name(shouldRetryForOptions, "shouldRetryForOptions");
-  const shouldRetryHeader = response.headers.get("x-should-retry");
-  if (shouldRetryHeader === "true")
-    return shouldRetryForOptions();
-  if (shouldRetryHeader === "false")
-    return {
-      retry: false
-    };
-  if (response.status === 408)
-    return shouldRetryForOptions();
-  if (response.status === 409)
-    return shouldRetryForOptions();
-  if (response.status === 429) {
-    if (attempt >= (typeof retryOptions?.maxAttempts === "number" ? retryOptions?.maxAttempts : 3)) {
-      return {
-        retry: false
-      };
-    }
-    const resetAtUnixEpochMs = response.headers.get("x-ratelimit-reset");
-    if (resetAtUnixEpochMs) {
-      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
-      const delay = resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 1e3);
-      if (delay > 0) {
-        return {
-          retry: true,
-          delay
-        };
-      }
-    }
-    return shouldRetryForOptions();
-  }
-  if (response.status >= 500)
-    return shouldRetryForOptions();
-  return {
-    retry: false
-  };
-}
-__name(shouldRetry, "shouldRetry");
-function safeJsonParse(text) {
-  try {
-    return JSON.parse(text);
-  } catch (e) {
-    return void 0;
-  }
-}
-__name(safeJsonParse, "safeJsonParse");
-function createResponseHeaders(headers) {
-  return new Proxy(Object.fromEntries(
-    // @ts-ignore
-    headers.entries()
-  ), {
-    get(target, name) {
-      const key = name.toString();
-      return target[key.toLowerCase()] || target[key];
-    }
-  });
-}
-__name(createResponseHeaders, "createResponseHeaders");
-function requestInitWithCache(requestInit) {
-  try {
-    const withCache = {
-      ...requestInit,
-      cache: "no-cache"
-    };
-    const _ = new Request("http://localhost", withCache);
-    return withCache;
-  } catch (error) {
-    return requestInit ?? {};
-  }
-}
-__name(requestInitWithCache, "requestInitWithCache");
-var _ApiPromise = class _ApiPromise extends Promise {
-  constructor(responsePromise) {
-    super((resolve) => {
-      resolve(null);
-    });
-    this.responsePromise = responsePromise;
-  }
-  /**
-  * Gets the raw `Response` instance instead of parsing the response
-  * data.
-  *
-  * If you want to parse the response body but still get the `Response`
-  * instance, you can use {@link withResponse()}.
-  */
-  asResponse() {
-    return this.responsePromise.then((p) => p.response);
-  }
-  /**
-  * Gets the parsed response data and the raw `Response` instance.
-  *
-  * If you just want to get the raw `Response` instance without parsing it,
-  * you can use {@link asResponse()}.
-  */
-  async withResponse() {
-    const [data, response] = await Promise.all([
-      this.parse(),
-      this.asResponse()
-    ]);
-    return {
-      data,
-      response
-    };
-  }
-  parse() {
-    return this.responsePromise.then((result) => result.data);
-  }
-  then(onfulfilled, onrejected) {
-    return this.parse().then(onfulfilled, onrejected);
-  }
-  catch(onrejected) {
-    return this.parse().catch(onrejected);
-  }
-  finally(onfinally) {
-    return this.parse().finally(onfinally);
-  }
-};
-__name(_ApiPromise, "ApiPromise");
-var ApiPromise = _ApiPromise;
-var _fetchPage, fetchPage_fn;
-var _CursorPagePromise = class _CursorPagePromise extends ApiPromise {
-  constructor(result, schema, url, params, requestInit, options) {
-    super(result.then((result2) => ({
-      data: new CursorPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage, fetchPage_fn).bind(this)),
-      response: result2.response
-    })));
-    __privateAdd(this, _fetchPage);
-    this.schema = schema;
-    this.url = url;
-    this.params = params;
-    this.requestInit = requestInit;
-    this.options = options;
-  }
-  /**
-  * Allow auto-paginating iteration on an unawaited list call, eg:
-  *
-  *    for await (const item of client.items.list()) {
-  *      console.log(item)
-  *    }
-  */
-  async *[Symbol.asyncIterator]() {
-    const page = await this;
-    for await (const item of page) {
-      yield item;
-    }
-  }
-};
-_fetchPage = new WeakSet();
-fetchPage_fn = /* @__PURE__ */ __name(function(params) {
-  return zodfetchCursorPage(this.schema, this.url, {
-    ...this.params,
-    ...params
-  }, this.requestInit, this.options);
-}, "#fetchPage");
-__name(_CursorPagePromise, "CursorPagePromise");
-var CursorPagePromise = _CursorPagePromise;
-var _fetchPage2, fetchPage_fn2;
-var _OffsetLimitPagePromise = class _OffsetLimitPagePromise extends ApiPromise {
-  constructor(result, schema, url, params, requestInit, options) {
-    super(result.then((result2) => ({
-      data: new OffsetLimitPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage2, fetchPage_fn2).bind(this)),
-      response: result2.response
-    })));
-    __privateAdd(this, _fetchPage2);
-    this.schema = schema;
-    this.url = url;
-    this.params = params;
-    this.requestInit = requestInit;
-    this.options = options;
-  }
-  /**
-  * Allow auto-paginating iteration on an unawaited list call, eg:
-  *
-  *    for await (const item of client.items.list()) {
-  *      console.log(item)
-  *    }
-  */
-  async *[Symbol.asyncIterator]() {
-    const page = await this;
-    for await (const item of page) {
-      yield item;
-    }
-  }
-};
-_fetchPage2 = new WeakSet();
-fetchPage_fn2 = /* @__PURE__ */ __name(function(params1) {
-  return zodfetchOffsetLimitPage(this.schema, this.url, {
-    ...this.params,
-    ...params1
-  }, this.requestInit, this.options);
-}, "#fetchPage");
-__name(_OffsetLimitPagePromise, "OffsetLimitPagePromise");
-var OffsetLimitPagePromise = _OffsetLimitPagePromise;
-async function waitForRetry(url, attempt, delay, options, requestInit, response) {
-  if (options?.tracer) {
-    const method = requestInit?.method ?? "GET";
-    return options.tracer.startActiveSpan(response ? `wait after ${response.status}` : `wait after error`, async (span) => {
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }, {
-      attributes: {
-        [SemanticInternalAttributes.STYLE_ICON]: "wait",
-        ...accessoryAttributes({
-          items: [
-            {
-              text: `retrying ${options?.name ?? method.toUpperCase()} in ${delay}ms`,
-              variant: "normal"
-            }
-          ],
-          style: "codepath"
-        })
-      }
-    });
-  }
-  await new Promise((resolve) => setTimeout(resolve, delay));
-}
-__name(waitForRetry, "waitForRetry");
-function isEmptyObj(obj) {
-  if (!obj)
-    return true;
-  for (const _k in obj)
-    return false;
-  return true;
-}
-__name(isEmptyObj, "isEmptyObj");
-function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-}
-__name(hasOwn, "hasOwn");
-
-// src/v3/apiClient/index.ts
-var DEFAULT_ZOD_FETCH_OPTIONS = {
-  retry: {
-    maxAttempts: 3,
-    minTimeoutInMs: 1e3,
-    maxTimeoutInMs: 3e4,
-    factor: 2,
-    randomize: false
-  }
-};
-var _getHeaders, getHeaders_fn;
-var _ApiClient = class _ApiClient {
-  constructor(baseUrl, accessToken, requestOptions = {}) {
-    __privateAdd(this, _getHeaders);
-    this.accessToken = accessToken;
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.defaultRequestOptions = mergeRequestOptions(DEFAULT_ZOD_FETCH_OPTIONS, requestOptions);
-  }
-  async getRunResult(runId, requestOptions) {
-    try {
-      return await zodfetch(TaskRunExecutionResult, `${this.baseUrl}/api/v1/runs/${runId}/result`, {
-        method: "GET",
-        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-      }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-    } catch (error) {
-      if (error instanceof ApiError) {
-        if (error.status === 404) {
-          return void 0;
-        }
-      }
-      throw error;
-    }
-  }
-  async getBatchResults(batchId, requestOptions) {
-    return await zodfetch(BatchTaskRunExecutionResult, `${this.baseUrl}/api/v1/batches/${batchId}/results`, {
-      method: "GET",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  triggerTask(taskId, body, options, requestOptions) {
-    const encodedTaskId = encodeURIComponent(taskId);
-    return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/trigger`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
-      body: JSON.stringify(body)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  batchTriggerTask(taskId, body, options, requestOptions) {
-    const encodedTaskId = encodeURIComponent(taskId);
-    return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/batch`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
-      body: JSON.stringify(body)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  createUploadPayloadUrl(filename, requestOptions) {
-    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
-      method: "PUT",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  getPayloadUrl(filename, requestOptions) {
-    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
-      method: "GET",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  retrieveRun(runId, requestOptions) {
-    return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v3/runs/${runId}`, {
-      method: "GET",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  listRuns(query, requestOptions) {
-    const searchParams = createSearchQueryForListRuns(query);
-    return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/runs`, {
-      query: searchParams,
-      limit: query?.limit,
-      after: query?.after,
-      before: query?.before
-    }, {
-      method: "GET",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  listProjectRuns(projectRef, query, requestOptions) {
-    const searchParams = createSearchQueryForListRuns(query);
-    if (query?.env) {
-      searchParams.append("filter[env]", Array.isArray(query.env) ? query.env.join(",") : query.env);
-    }
-    return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/projects/${projectRef}/runs`, {
-      query: searchParams,
-      limit: query?.limit,
-      after: query?.after,
-      before: query?.before
-    }, {
-      method: "GET",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  replayRun(runId, requestOptions) {
-    return zodfetch(ReplayRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/replay`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  cancelRun(runId, requestOptions) {
-    return zodfetch(CanceledRunResponse, `${this.baseUrl}/api/v2/runs/${runId}/cancel`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  rescheduleRun(runId, body, requestOptions) {
-    return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/reschedule`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
-      body: JSON.stringify(body)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  addTags(runId, body, requestOptions) {
-    return zodfetch(z.object({
-      message: z.string()
-    }), `${this.baseUrl}/api/v1/runs/${runId}/tags`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
-      body: JSON.stringify(body)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  createSchedule(options, requestOptions) {
-    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
-      body: JSON.stringify(options)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  listSchedules(options, requestOptions) {
-    const searchParams = new URLSearchParams();
-    if (options?.page) {
-      searchParams.append("page", options.page.toString());
-    }
-    if (options?.perPage) {
-      searchParams.append("perPage", options.perPage.toString());
-    }
-    return zodfetchOffsetLimitPage(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
-      page: options?.page,
-      limit: options?.perPage
-    }, {
-      method: "GET",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  retrieveSchedule(scheduleId, requestOptions) {
-    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
-      method: "GET",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  updateSchedule(scheduleId, options, requestOptions) {
-    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
-      method: "PUT",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
-      body: JSON.stringify(options)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  deactivateSchedule(scheduleId, requestOptions) {
-    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/deactivate`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  activateSchedule(scheduleId, requestOptions) {
-    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/activate`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  deleteSchedule(scheduleId, requestOptions) {
-    return zodfetch(DeletedScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
-      method: "DELETE",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  listEnvVars(projectRef, slug, requestOptions) {
-    return zodfetch(EnvironmentVariables, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
-      method: "GET",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  importEnvVars(projectRef, slug, body, requestOptions) {
-    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/import`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
-      body: JSON.stringify(body)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  retrieveEnvVar(projectRef, slug, key, requestOptions) {
-    return zodfetch(EnvironmentVariableValue, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
-      method: "GET",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  createEnvVar(projectRef, slug, body, requestOptions) {
-    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
-      method: "POST",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
-      body: JSON.stringify(body)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  updateEnvVar(projectRef, slug, key, body, requestOptions) {
-    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
-      method: "PUT",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
-      body: JSON.stringify(body)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-  deleteEnvVar(projectRef, slug, key, requestOptions) {
-    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
-      method: "DELETE",
-      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
-  }
-};
-_getHeaders = new WeakSet();
-getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${this.accessToken}`,
-    "trigger-version": version
-  };
-  if (taskContext.isInsideTask) {
-    headers["x-trigger-worker"] = "true";
-    propagation.inject(context.active(), headers);
-    if (spanParentAsLink) {
-      headers["x-trigger-span-parent-as-link"] = "1";
-    }
-  }
-  return headers;
-}, "#getHeaders");
-__name(_ApiClient, "ApiClient");
-var ApiClient = _ApiClient;
-function createSearchQueryForListRuns(query) {
-  const searchParams = new URLSearchParams();
-  if (query) {
-    if (query.status) {
-      searchParams.append("filter[status]", Array.isArray(query.status) ? query.status.join(",") : query.status);
-    }
-    if (query.taskIdentifier) {
-      searchParams.append("filter[taskIdentifier]", Array.isArray(query.taskIdentifier) ? query.taskIdentifier.join(",") : query.taskIdentifier);
-    }
-    if (query.version) {
-      searchParams.append("filter[version]", Array.isArray(query.version) ? query.version.join(",") : query.version);
-    }
-    if (query.bulkAction) {
-      searchParams.append("filter[bulkAction]", query.bulkAction);
-    }
-    if (query.tag) {
-      searchParams.append("filter[tag]", Array.isArray(query.tag) ? query.tag.join(",") : query.tag);
-    }
-    if (query.schedule) {
-      searchParams.append("filter[schedule]", query.schedule);
-    }
-    if (typeof query.isTest === "boolean") {
-      searchParams.append("filter[isTest]", String(query.isTest));
-    }
-    if (query.from) {
-      searchParams.append("filter[createdAt][from]", query.from instanceof Date ? query.from.getTime().toString() : query.from.toString());
-    }
-    if (query.to) {
-      searchParams.append("filter[createdAt][to]", query.to instanceof Date ? query.to.getTime().toString() : query.to.toString());
-    }
-    if (query.period) {
-      searchParams.append("filter[createdAt][period]", query.period);
-    }
-  }
-  return searchParams;
-}
-__name(createSearchQueryForListRuns, "createSearchQueryForListRuns");
-function mergeRequestOptions(defaultOptions, options) {
-  if (!options) {
-    return defaultOptions;
-  }
-  return {
-    ...defaultOptions,
-    ...options,
-    retry: {
-      ...defaultOptions.retry,
-      ...options.retry
-    }
-  };
-}
-__name(mergeRequestOptions, "mergeRequestOptions");
-var _SimpleClock = class _SimpleClock {
-  preciseNow() {
-    const now = new PreciseDate();
-    const nowStruct = now.toStruct();
-    return [
-      nowStruct.seconds,
-      nowStruct.nanos
-    ];
-  }
-  reset() {
-  }
-};
-__name(_SimpleClock, "SimpleClock");
-var SimpleClock = _SimpleClock;
-
-// src/v3/clock/index.ts
-var API_NAME2 = "clock";
-var SIMPLE_CLOCK = new SimpleClock();
-var _getClock, getClock_fn;
-var _ClockAPI = class _ClockAPI {
-  constructor() {
-    __privateAdd(this, _getClock);
-  }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _ClockAPI();
-    }
-    return this._instance;
-  }
-  setGlobalClock(clock2) {
-    return registerGlobal(API_NAME2, clock2);
-  }
-  preciseNow() {
-    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
-  }
-  reset() {
-    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
-  }
-};
-_getClock = new WeakSet();
-getClock_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME2) ?? SIMPLE_CLOCK;
-}, "#getClock");
-__name(_ClockAPI, "ClockAPI");
-var ClockAPI = _ClockAPI;
-
-// src/v3/clock-api.ts
-var clock = ClockAPI.getInstance();
-
-// src/v3/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");
-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_NAME3 = "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_NAME3);
-  }
-  setGlobalTaskLogger(taskLogger) {
-    return registerGlobal(API_NAME3, 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_NAME3) ?? NOOP_TASK_LOGGER;
-}, "#getTaskLogger");
-__name(_LoggerAPI, "LoggerAPI");
-var LoggerAPI = _LoggerAPI;
-
-// src/v3/logger-api.ts
-var logger = LoggerAPI.getInstance();
-
-// src/v3/runtime/noopRuntimeManager.ts
-var _NoopRuntimeManager = class _NoopRuntimeManager {
-  disable() {
-  }
-  waitForDuration(ms) {
-    return Promise.resolve();
-  }
-  waitUntil(date) {
-    return Promise.resolve();
-  }
-  waitForTask(params) {
-    return Promise.resolve({
-      ok: false,
-      id: params.id,
-      error: {
-        type: "INTERNAL_ERROR",
-        code: "CONFIGURED_INCORRECTLY"
-      }
-    });
-  }
-  waitForBatch(params) {
-    return Promise.resolve({
-      id: params.id,
-      items: []
-    });
-  }
-};
-__name(_NoopRuntimeManager, "NoopRuntimeManager");
-var NoopRuntimeManager = _NoopRuntimeManager;
-
-// src/v3/usage/noopUsageManager.ts
-var _NoopUsageManager = class _NoopUsageManager {
-  disable() {
-  }
-  start() {
-    return {
-      sample: () => ({
-        cpuTime: 0,
-        wallTime: 0
-      })
-    };
-  }
-  stop(measurement) {
-    return measurement.sample();
-  }
-  pauseAsync(cb) {
-    return cb();
-  }
-  sample() {
-    return void 0;
-  }
-};
-__name(_NoopUsageManager, "NoopUsageManager");
-var NoopUsageManager = _NoopUsageManager;
-
-// src/v3/usage/api.ts
-var API_NAME4 = "usage";
-var NOOP_USAGE_MANAGER = new NoopUsageManager();
-var _getUsageManager, getUsageManager_fn;
-var _UsageAPI = class _UsageAPI {
-  constructor() {
-    __privateAdd(this, _getUsageManager);
-  }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _UsageAPI();
-    }
-    return this._instance;
-  }
-  setGlobalUsageManager(manager) {
-    return registerGlobal(API_NAME4, manager);
-  }
-  disable() {
-    __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).disable();
-    unregisterGlobal(API_NAME4);
-  }
-  start() {
-    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).start();
-  }
-  stop(measurement) {
-    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).stop(measurement);
-  }
-  pauseAsync(cb) {
-    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).pauseAsync(cb);
-  }
-  sample() {
-    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).sample();
-  }
-};
-_getUsageManager = new WeakSet();
-getUsageManager_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME4) ?? NOOP_USAGE_MANAGER;
-}, "#getUsageManager");
-__name(_UsageAPI, "UsageAPI");
-var UsageAPI = _UsageAPI;
-
-// src/v3/usage-api.ts
-var usage = UsageAPI.getInstance();
-
-// src/v3/runtime/index.ts
-var API_NAME5 = "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 usage.pauseAsync(() => __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForDuration(ms));
-  }
-  waitUntil(date) {
-    return usage.pauseAsync(() => __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitUntil(date));
-  }
-  waitForTask(params) {
-    return usage.pauseAsync(() => __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForTask(params));
-  }
-  waitForBatch(params) {
-    return usage.pauseAsync(() => __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForBatch(params));
-  }
-  setGlobalRuntimeManager(runtimeManager) {
-    return registerGlobal(API_NAME5, runtimeManager);
-  }
-  disable() {
-    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
-    unregisterGlobal(API_NAME5);
-  }
-};
-_getRuntimeManager = new WeakSet();
-getRuntimeManager_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME5) ?? NOOP_RUNTIME_MANAGER;
-}, "#getRuntimeManager");
-__name(_RuntimeAPI, "RuntimeAPI");
-var RuntimeAPI = _RuntimeAPI;
-
-// src/v3/runtime-api.ts
-var runtime = RuntimeAPI.getInstance();
-
-// src/v3/utils/getEnv.ts
-function getEnvVar(name) {
-  if (typeof process !== "undefined" && typeof process.env === "object" && process.env !== null) {
-    return process.env[name];
-  }
-}
-__name(getEnvVar, "getEnvVar");
-
-// src/v3/apiClientManager/index.ts
-var API_NAME6 = "api-client";
-var _getConfig, getConfig_fn;
-var _APIClientManagerAPI = class _APIClientManagerAPI {
-  constructor() {
-    __privateAdd(this, _getConfig);
-  }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _APIClientManagerAPI();
-    }
-    return this._instance;
-  }
-  disable() {
-    unregisterGlobal(API_NAME6);
-  }
-  setGlobalAPIClientConfiguration(config) {
-    return registerGlobal(API_NAME6, config);
-  }
-  get baseURL() {
-    const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
-    return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
-  }
-  get accessToken() {
-    const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
-    return store?.secretKey ?? getEnvVar("TRIGGER_SECRET_KEY") ?? getEnvVar("TRIGGER_ACCESS_TOKEN");
-  }
-  get client() {
-    if (!this.baseURL || !this.accessToken) {
-      return void 0;
-    }
-    return new ApiClient(this.baseURL, this.accessToken);
-  }
-};
-_getConfig = new WeakSet();
-getConfig_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME6);
-}, "#getConfig");
-__name(_APIClientManagerAPI, "APIClientManagerAPI");
-var APIClientManagerAPI = _APIClientManagerAPI;
-
-// src/v3/apiClientManager-api.ts
-var apiClientManager = APIClientManagerAPI.getInstance();
-
-// src/v3/task-catalog/noopTaskCatalog.ts
-var _NoopTaskCatalog = class _NoopTaskCatalog {
-  registerTaskMetadata(task) {
-  }
-  registerTaskFileMetadata(id, metadata) {
-  }
-  updateTaskMetadata(id, updates) {
-  }
-  getAllTaskMetadata() {
-    return [];
-  }
-  getTaskMetadata(id) {
-    return void 0;
-  }
-  getTask(id) {
-    return void 0;
-  }
-  taskExists(id) {
-    return false;
-  }
-  disable() {
-  }
-};
-__name(_NoopTaskCatalog, "NoopTaskCatalog");
-var NoopTaskCatalog = _NoopTaskCatalog;
-
-// src/v3/task-catalog/index.ts
-var API_NAME7 = "task-catalog";
-var NOOP_TASK_CATALOG = new NoopTaskCatalog();
-var _getCatalog, getCatalog_fn;
-var _TaskCatalogAPI = class _TaskCatalogAPI {
-  constructor() {
-    __privateAdd(this, _getCatalog);
-  }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _TaskCatalogAPI();
-    }
-    return this._instance;
-  }
-  setGlobalTaskCatalog(taskCatalog2) {
-    return registerGlobal(API_NAME7, taskCatalog2);
-  }
-  disable() {
-    unregisterGlobal(API_NAME7);
-  }
-  registerTaskMetadata(task) {
-    __privateMethod(this, _getCatalog, getCatalog_fn).call(this).registerTaskMetadata(task);
-  }
-  updateTaskMetadata(id, updates) {
-    __privateMethod(this, _getCatalog, getCatalog_fn).call(this).updateTaskMetadata(id, updates);
-  }
-  registerTaskFileMetadata(id, metadata) {
-    __privateMethod(this, _getCatalog, getCatalog_fn).call(this).registerTaskFileMetadata(id, metadata);
-  }
-  getAllTaskMetadata() {
-    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).getAllTaskMetadata();
-  }
-  getTaskMetadata(id) {
-    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).getTaskMetadata(id);
-  }
-  getTask(id) {
-    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).getTask(id);
-  }
-  taskExists(id) {
-    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).taskExists(id);
-  }
-};
-_getCatalog = new WeakSet();
-getCatalog_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME7) ?? NOOP_TASK_CATALOG;
-}, "#getCatalog");
-__name(_TaskCatalogAPI, "TaskCatalogAPI");
-var TaskCatalogAPI = _TaskCatalogAPI;
-
-// src/v3/task-catalog-api.ts
-var taskCatalog = TaskCatalogAPI.getInstance();
-function dateDifference(date1, date2) {
-  return Math.abs(date1.getTime() - date2.getTime());
-}
-__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");
-var _TriggerTracer = class _TriggerTracer {
-  constructor(_config) {
-    this._config = _config;
-  }
-  get tracer() {
-    if (!this._tracer) {
-      if ("tracer" in this._config)
-        return this._config.tracer;
-      this._tracer = trace.getTracer(this._config.name, this._config.version);
-    }
-    return this._tracer;
-  }
-  get logger() {
-    if (!this._logger) {
-      if ("logger" in this._config)
-        return this._config.logger;
-      this._logger = logs.getLogger(this._config.name, this._config.version);
-    }
-    return this._logger;
-  }
-  extractContext(traceContext) {
-    return propagation.extract(context.active(), traceContext ?? {});
-  }
-  startActiveSpan(name, fn, options, ctx) {
-    const parentContext = ctx ?? context.active();
-    const attributes = options?.attributes ?? {};
-    return this.tracer.startActiveSpan(name, {
-      ...options,
-      attributes,
-      startTime: clock.preciseNow()
-    }, parentContext, async (span) => {
-      if (taskContext.ctx) {
-        this.tracer.startSpan(name, {
-          ...options,
-          attributes: {
-            ...attributes,
-            [SemanticInternalAttributes.SPAN_PARTIAL]: true,
-            [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId
-          }
-        }, parentContext).end();
-      }
-      const usageMeasurement = usage.start();
-      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 {
-        if (taskContext.ctx) {
-          const usageSample = usage.stop(usageMeasurement);
-          const machine = taskContext.ctx.machine;
-          span.setAttributes({
-            [SemanticInternalAttributes.USAGE_DURATION_MS]: usageSample.cpuTime,
-            [SemanticInternalAttributes.USAGE_COST_IN_CENTS]: machine?.centsPerMs ? usageSample.cpuTime * machine.centsPerMs : 0
-          });
-        }
-        span.end(clock.preciseNow());
-      }
-    });
-  }
-  startSpan(name, options, ctx) {
-    const parentContext = ctx ?? context.active();
-    const attributes = options?.attributes ?? {};
-    const span = this.tracer.startSpan(name, options, ctx);
-    this.tracer.startSpan(name, {
-      ...options,
-      attributes: {
-        ...attributes,
-        [SemanticInternalAttributes.SPAN_PARTIAL]: true,
-        [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId
-      }
-    }, parentContext).end();
-    return span;
-  }
-};
-__name(_TriggerTracer, "TriggerTracer");
-var TriggerTracer = _TriggerTracer;
-
-// src/eventFilterMatches.ts
-function eventFilterMatches(payload, filter) {
-  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");
-
-// src/v3/utils/detectDependencyVersion.ts
-function detectDependencyVersion(dependency) {
-  return dependencies[dependency];
-}
-__name(detectDependencyVersion, "detectDependencyVersion");
-
-// src/v3/utils/ioSerialization.ts
-async function parsePacket(value) {
-  if (!value.data) {
-    return void 0;
-  }
-  switch (value.dataType) {
-    case "application/json":
-      return JSON.parse(value.data);
-    case "application/super+json":
-      const { parse } = await loadSuperJSON();
-      return parse(value.data);
-    case "text/plain":
-      return value.data;
-    case "application/store":
-      throw new Error(`Cannot parse an application/store packet (${value.data}). Needs to be imported first.`);
-    default:
-      return value.data;
-  }
-}
-__name(parsePacket, "parsePacket");
-async function stringifyIO(value) {
-  if (value === void 0) {
-    return {
-      dataType: "application/json"
-    };
-  }
-  if (typeof value === "string") {
-    return {
-      data: value,
-      dataType: "text/plain"
-    };
-  }
-  try {
-    const { stringify } = await loadSuperJSON();
-    const data = stringify(value);
-    return {
-      data,
-      dataType: "application/super+json"
-    };
-  } catch {
-    return {
-      data: value,
-      dataType: "application/json"
-    };
-  }
-}
-__name(stringifyIO, "stringifyIO");
-async function conditionallyExportPacket(packet, pathPrefix, tracer) {
-  if (apiClientManager.client) {
-    const { needsOffloading, size } = packetRequiresOffloading(packet);
-    if (needsOffloading) {
-      if (!tracer) {
-        return await exportPacket(packet, pathPrefix);
-      } else {
-        const result = await tracer.startActiveSpan("store.uploadOutput", async (span) => {
-          return await exportPacket(packet, pathPrefix);
-        }, {
-          attributes: {
-            byteLength: size,
-            [SemanticInternalAttributes.STYLE_ICON]: "cloud-upload"
-          }
-        });
-        return result ?? packet;
-      }
-    }
-  }
-  return packet;
-}
-__name(conditionallyExportPacket, "conditionallyExportPacket");
-function packetRequiresOffloading(packet, lengthLimit) {
-  if (!packet.data) {
-    return {
-      needsOffloading: false,
-      size: 0
-    };
-  }
-  const byteSize = Buffer.byteLength(packet.data, "utf8");
-  return {
-    needsOffloading: byteSize >= (lengthLimit ?? 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);
-  const uploadResponse = await fetch(presignedResponse.presignedUrl, {
-    method: "PUT",
-    headers: {
-      "Content-Type": packet.dataType
-    },
-    body: packet.data
-  });
-  if (!uploadResponse.ok) {
-    throw new Error(`Failed to upload output to ${presignedResponse.presignedUrl}: ${uploadResponse.statusText}`);
-  }
-  return {
-    data: filename,
-    dataType: "application/store"
-  };
-}
-__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);
-  const response = await fetch(presignedResponse.presignedUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to import packet ${presignedResponse.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"
-  };
-}
-__name(importPacket, "importPacket");
-async function createPacketAttributes(packet, dataKey, dataTypeKey) {
-  if (!packet.data) {
-    return;
-  }
-  switch (packet.dataType) {
-    case "application/json":
-      return {
-        ...flattenAttributes(packet, dataKey),
-        [dataTypeKey]: packet.dataType
-      };
-    case "application/super+json":
-      const { parse } = await loadSuperJSON();
-      if (typeof packet.data === "undefined" || packet.data === null) {
-        return;
-      }
-      try {
-        const parsed = parse(packet.data);
-        const jsonified = JSON.parse(JSON.stringify(parsed, safeReplacer));
-        const result = {
-          ...flattenAttributes(jsonified, dataKey),
-          [dataTypeKey]: "application/json"
-        };
-        return result;
-      } catch (e) {
-        return;
-      }
-    case "application/store":
-      return {
-        [dataKey]: packet.data,
-        [dataTypeKey]: packet.dataType
-      };
-    case "text/plain":
-      return {
-        [dataKey]: packet.data,
-        [dataTypeKey]: packet.dataType
-      };
-    default:
-      return;
-  }
-}
-__name(createPacketAttributes, "createPacketAttributes");
-async function createPacketAttributesAsJson(data, dataType) {
-  if (typeof data === "string" || typeof data === "number" || typeof data === "boolean" || data === null || data === void 0) {
-    return data;
-  }
-  switch (dataType) {
-    case "application/json":
-      return imposeAttributeLimits(flattenAttributes(data, void 0));
-    case "application/super+json":
-      const { deserialize } = await loadSuperJSON();
-      const deserialized = deserialize(data);
-      const jsonify = safeJsonParse2(JSON.stringify(deserialized, safeReplacer));
-      return imposeAttributeLimits(flattenAttributes(jsonify, void 0));
-    case "application/store":
-      return data;
-    default:
-      return {};
-  }
-}
-__name(createPacketAttributesAsJson, "createPacketAttributesAsJson");
-async function prettyPrintPacket(rawData, dataType) {
-  if (rawData === void 0) {
-    return "";
-  }
-  if (dataType === "application/super+json") {
-    if (typeof rawData === "string") {
-      rawData = safeJsonParse2(rawData);
-    }
-    const { deserialize } = await loadSuperJSON();
-    return await prettyPrintPacket(deserialize(rawData), "application/json");
-  }
-  if (dataType === "application/json") {
-    if (typeof rawData === "string") {
-      rawData = safeJsonParse2(rawData);
-    }
-    return JSON.stringify(rawData, safeReplacer, 2);
-  }
-  if (typeof rawData === "string") {
-    return rawData;
-  }
-  return JSON.stringify(rawData, safeReplacer, 2);
-}
-__name(prettyPrintPacket, "prettyPrintPacket");
-function safeReplacer(key, value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (value instanceof RegExp) {
-    return value.toString();
-  }
-  if (value instanceof Set) {
-    return Array.from(value);
-  }
-  if (value instanceof Map) {
-    const obj = {};
-    value.forEach((v, k) => {
-      obj[k] = v;
-    });
-    return obj;
-  }
-  return value;
-}
-__name(safeReplacer, "safeReplacer");
-function getPacketExtension(outputType) {
-  switch (outputType) {
-    case "application/json":
-      return "json";
-    case "application/super+json":
-      return "json";
-    case "text/plain":
-      return "txt";
-    default:
-      return "txt";
-  }
-}
-__name(getPacketExtension, "getPacketExtension");
-async function loadSuperJSON() {
-  return await import('superjson');
-}
-__name(loadSuperJSON, "loadSuperJSON");
-function safeJsonParse2(value) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return;
-  }
-}
-__name(safeJsonParse2, "safeJsonParse");
-
-export { AbortTaskRunError, AddTagsRequestBody, ApiClient, ApiConnectionError, ApiError, AttemptStatus, AuthenticationError, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BadRequestError, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConflictError, CoordinatorSocketData, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateEnvironmentVariableRequestBody, CreateScheduleOptions, CreateUploadPayloadUrlResponseBody, CursorPage, DeletedScheduleObject, DeploymentErrorData, EnvironmentType, EnvironmentVariable, EnvironmentVariableResponseBody, EnvironmentVariableValue, EnvironmentVariables, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, ImportEnvironmentVariablesRequestBody, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, InternalServerError, ListRunResponse, ListRunResponseItem, ListScheduleOptions, ListSchedulesResult, MachineConfig, MachineCpu, MachineMemory, MachinePreset, MachinePresetName, NULL_SENTINEL, NotFoundError, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OffsetLimitPage, OtherSpanEvent, PRIMARY_VARIANT, PermissionDeniedError, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitError, RateLimitOptions, ReplayRunResponse, RescheduleRunRequestBody, RetrieveRunResponse, RetryOptions, RunEnvironmentDetails, RunScheduleDetails, RunStatus, RunTags, ScheduleGenerator, ScheduleMetadata, ScheduleObject, ScheduleType, ScheduledTaskPayload, SemanticInternalAttributes, SerializedError, SharedQueueToClientMessages, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskEventStyle, TaskFileMetadata, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionLazyAttemptPayload, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunExecutionUsage, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TimezonesResult, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, UnprocessableEntityError, UpdateEnvironmentVariableRequestBody, UpdateScheduleOptions, WaitReason, WhoAmIResponseSchema, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createJsonErrorObject, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, groupTaskMetadataIssuesByTask, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, isRequestOptions, logger, mergeRequestOptions, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseError, parsePacket, prettyPrintPacket, primitiveValueOrflattenedAttributes, runtime, sanitizeError, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskCatalog, taskContext, unflattenAttributes, usage, workerToChildMessages };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.mjs.map