@trigger.dev/core 0.0.0-v3-trigger-dirs-20240423091017 → 0.0.0-v3-trigger-dirs-20240423123825

package/dist/v3/index.mjs

@@ -1,19 +1,11 @@
-import { z } from 'zod';
-import { SpanStatusCode, propagation, context, trace, DiagLogLevel, diag, DiagConsoleLogger } from '@opentelemetry/api';
+import { propagation, context, trace, SpanStatusCode } from '@opentelemetry/api';
 import { fromZodError } from 'zod-validation-error';
+import { z } from 'zod';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import nodePath from 'node:path';
-import { SeverityNumber, logs } from '@opentelemetry/api-logs';
 import { PreciseDate } from '@google-cloud/precise-date';
+import nodePath from 'node:path';
+import { logs } from '@opentelemetry/api-logs';
 import humanizeDuration from 'humanize-duration';
-import util from 'node:util';
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { registerInstrumentations } from '@opentelemetry/instrumentation';
-import { Resource, detectResourcesSync, processDetectorSync } from '@opentelemetry/resources';
-import { LoggerProvider, BatchLogRecordProcessor, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
-import { NodeTracerProvider, BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
-import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -35,1969 +27,1888 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var CreateAuthorizationCodeResponseSchema = z.object({
-  url: z.string().url(),
-  authorizationCode: z.string()
-});
-var GetPersonalAccessTokenRequestSchema = z.object({
-  authorizationCode: z.string()
-});
-var GetPersonalAccessTokenResponseSchema = z.object({
-  token: z.object({
-    token: z.string(),
-    obfuscatedToken: z.string()
-  }).nullable()
-});
-var TaskRunBuiltInError = z.object({
-  type: z.literal("BUILT_IN_ERROR"),
-  name: z.string(),
-  message: z.string(),
-  stackTrace: z.string()
-});
-var TaskRunCustomErrorObject = z.object({
-  type: z.literal("CUSTOM_ERROR"),
-  raw: z.string()
-});
-var TaskRunStringError = z.object({
-  type: z.literal("STRING_ERROR"),
-  raw: z.string()
-});
-var TaskRunErrorCodes = {
-  COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR",
-  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_RUN_CANCELLED: "TASK_RUN_CANCELLED",
-  TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
-  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
-  GRACEFUL_EXIT_TIMEOUT: "GRACEFUL_EXIT_TIMEOUT"
-};
-var TaskRunInternalError = z.object({
-  type: z.literal("INTERNAL_ERROR"),
-  code: z.enum([
-    "COULD_NOT_FIND_EXECUTOR",
-    "COULD_NOT_FIND_TASK",
-    "CONFIGURED_INCORRECTLY",
-    "TASK_ALREADY_RUNNING",
-    "TASK_EXECUTION_FAILED",
-    "TASK_EXECUTION_ABORTED",
-    "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
-    "TASK_RUN_CANCELLED",
-    "TASK_OUTPUT_ERROR",
-    "HANDLE_ERROR_ERROR",
-    "GRACEFUL_EXIT_TIMEOUT"
-  ]),
-  message: z.string().optional()
-});
-var TaskRunError = z.discriminatedUnion("type", [
-  TaskRunBuiltInError,
-  TaskRunCustomErrorObject,
-  TaskRunStringError,
-  TaskRunInternalError
-]);
-var TaskRun = z.object({
-  id: z.string(),
-  payload: z.string(),
-  payloadType: z.string(),
-  context: z.any(),
-  tags: z.array(z.string()),
-  isTest: z.boolean().default(false),
-  createdAt: z.coerce.date(),
-  idempotencyKey: 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()
-});
-var TaskRunContext = z.object({
-  task: TaskRunExecutionTask,
-  attempt: TaskRunExecutionAttempt.omit({
-    backgroundWorkerId: true,
-    backgroundWorkerTaskId: true
-  }),
-  run: TaskRun.omit({
-    payload: true,
-    payloadType: true
-  }),
-  queue: TaskRunExecutionQueue,
-  environment: TaskRunExecutionEnvironment,
-  organization: TaskRunExecutionOrganization,
-  project: TaskRunExecutionProject,
-  batch: TaskRunExecutionBatch.optional()
-});
-var TaskRunExecutionRetry = z.object({
-  timestamp: z.number(),
-  delay: z.number(),
-  error: z.unknown().optional()
-});
-var TaskRunFailedExecutionResult = z.object({
-  ok: z.literal(false),
-  id: z.string(),
-  error: TaskRunError,
-  retry: TaskRunExecutionRetry.optional(),
-  skippedRetrying: z.boolean().optional()
-});
-var TaskRunSuccessfulExecutionResult = z.object({
-  ok: z.literal(true),
-  id: z.string(),
-  output: z.string().optional(),
-  outputType: z.string()
-});
-var TaskRunExecutionResult = z.discriminatedUnion("ok", [
-  TaskRunSuccessfulExecutionResult,
-  TaskRunFailedExecutionResult
-]);
-var BatchTaskRunExecutionResult = z.object({
-  id: z.string(),
-  items: TaskRunExecutionResult.array()
-});
 
-// src/v3/schemas/messages.ts
-var EnvironmentType = z.enum([
-  "PRODUCTION",
-  "STAGING",
-  "DEVELOPMENT",
-  "PREVIEW"
-]);
-var MachineCpu = z.union([
-  z.literal(0.25),
-  z.literal(0.5),
-  z.literal(1),
-  z.literal(2),
-  z.literal(4)
-]).default(0.5);
-var MachineMemory = z.union([
-  z.literal(0.25),
-  z.literal(0.5),
-  z.literal(1),
-  z.literal(2),
-  z.literal(4),
-  z.literal(8)
-]).default(1);
-var Machine = z.object({
-  version: z.literal("v1").default("v1"),
-  cpu: MachineCpu,
-  memory: MachineMemory
-});
-var TaskRunExecutionPayload = z.object({
-  execution: TaskRunExecution,
-  traceContext: z.record(z.unknown()),
-  environment: z.record(z.string()).optional()
-});
-var ProdTaskRunExecution = TaskRunExecution.extend({
-  worker: z.object({
-    id: z.string(),
-    contentHash: z.string(),
-    version: z.string()
-  })
-});
-var ProdTaskRunExecutionPayload = z.object({
-  execution: ProdTaskRunExecution,
-  traceContext: z.record(z.unknown()),
-  environment: z.record(z.string()).optional()
-});
-var BackgroundWorkerServerMessages = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("EXECUTE_RUNS"),
-    payloads: z.array(TaskRunExecutionPayload)
-  }),
-  z.object({
-    type: z.literal("CANCEL_ATTEMPT"),
-    taskAttemptId: z.string(),
-    taskRunId: z.string()
-  }),
-  z.object({
-    type: z.literal("SCHEDULE_ATTEMPT"),
-    image: z.string(),
-    version: z.string(),
-    machine: Machine,
-    // identifiers
-    id: z.string(),
-    envId: z.string(),
-    envType: EnvironmentType,
-    orgId: z.string(),
-    projectId: z.string(),
-    runId: z.string()
-  })
-]);
-var serverWebsocketMessages = {
-  SERVER_READY: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string()
-  }),
-  BACKGROUND_WORKER_MESSAGE: z.object({
-    version: z.literal("v1").default("v1"),
-    backgroundWorkerId: z.string(),
-    data: BackgroundWorkerServerMessages
-  })
-};
-var BackgroundWorkerClientMessages = z.discriminatedUnion("type", [
-  z.object({
-    version: z.literal("v1").default("v1"),
-    type: z.literal("TASK_RUN_COMPLETED"),
-    completion: TaskRunExecutionResult,
-    execution: TaskRunExecution
-  }),
-  z.object({
-    version: z.literal("v1").default("v1"),
-    type: z.literal("TASK_HEARTBEAT"),
-    id: z.string()
-  })
-]);
-var BackgroundWorkerProperties = z.object({
-  id: z.string(),
-  version: z.string(),
-  contentHash: z.string()
-});
-var clientWebsocketMessages = {
-  READY_FOR_TASKS: z.object({
-    version: z.literal("v1").default("v1"),
-    backgroundWorkerId: z.string()
-  }),
-  BACKGROUND_WORKER_DEPRECATED: z.object({
-    version: z.literal("v1").default("v1"),
-    backgroundWorkerId: z.string()
-  }),
-  BACKGROUND_WORKER_MESSAGE: z.object({
-    version: z.literal("v1").default("v1"),
-    backgroundWorkerId: z.string(),
-    data: BackgroundWorkerClientMessages
-  })
-};
-var workerToChildMessages = {
-  EXECUTE_TASK_RUN: z.object({
-    version: z.literal("v1").default("v1"),
-    execution: TaskRunExecution,
-    traceContext: z.record(z.unknown()),
-    metadata: BackgroundWorkerProperties
-  }),
-  TASK_RUN_COMPLETED_NOTIFICATION: z.object({
-    version: z.literal("v1").default("v1"),
-    completion: TaskRunExecutionResult,
-    execution: TaskRunExecution
-  }),
-  CLEANUP: z.object({
-    version: z.literal("v1").default("v1"),
-    flush: z.boolean().default(false),
-    kill: z.boolean().default(true)
-  })
-};
-var FixedWindowRateLimit = z.object({
-  type: z.literal("fixed-window"),
-  limit: z.number(),
-  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 }) => {
-          // ...
-        },
+// src/v3/apiErrors.ts
+var _APIError = class _APIError extends Error {
+  constructor(status, error, message, headers) {
+    super(`${_APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    const data = error;
+    this.error = data;
+    this.code = data?.["code"];
+    this.param = data?.["param"];
+    this.type = data?.["type"];
+  }
+  static makeMessage(status, error, message) {
+    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return "(no status code or body)";
+  }
+  static generate(status, errorResponse, message, headers) {
+    if (!status) {
+      return new APIConnectionError({
+        cause: castToError(errorResponse)
       });
-     * ```
-     */
-  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 TaskMetadata = z.object({
-  id: z.string(),
-  packageVersion: z.string(),
-  queue: QueueOptions.optional(),
-  retry: RetryOptions.optional(),
-  machine: Machine.partial().optional(),
-  triggerSource: z.string().optional()
-});
-var TaskFileMetadata = z.object({
-  filePath: z.string(),
-  exportName: z.string()
-});
-var TaskMetadataWithFilePath = TaskMetadata.merge(TaskFileMetadata);
-var UncaughtExceptionMessage = z.object({
-  version: z.literal("v1").default("v1"),
-  error: z.object({
-    name: z.string(),
-    message: z.string(),
-    stack: z.string().optional()
-  }),
-  origin: z.enum([
-    "uncaughtException",
-    "unhandledRejection"
-  ])
-});
-var TaskMetadataFailedToParseData = z.object({
-  version: z.literal("v1").default("v1"),
-  tasks: z.unknown(),
-  zodIssues: z.custom((v) => {
-    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
-  })
-});
-var childToWorkerMessages = {
-  TASK_RUN_COMPLETED: z.object({
-    version: z.literal("v1").default("v1"),
-    execution: TaskRunExecution,
-    result: TaskRunExecutionResult
-  }),
-  TASKS_READY: z.object({
-    version: z.literal("v1").default("v1"),
-    tasks: TaskMetadataWithFilePath.array()
-  }),
-  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
-  TASK_HEARTBEAT: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string()
-  }),
-  READY_TO_DISPOSE: z.undefined(),
-  WAIT_FOR_DURATION: z.object({
-    version: z.literal("v1").default("v1"),
-    ms: z.number()
-  }),
-  WAIT_FOR_TASK: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string()
-  }),
-  WAIT_FOR_BATCH: z.object({
-    version: z.literal("v1").default("v1"),
-    id: z.string(),
-    runs: z.string().array()
-  }),
-  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
+    }
+    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);
+  }
 };
-var ProdChildToWorkerMessages = {
-  TASK_RUN_COMPLETED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      execution: TaskRunExecution,
-      result: TaskRunExecutionResult
-    })
-  },
-  TASKS_READY: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      tasks: TaskMetadataWithFilePath.array()
-    })
-  },
-  TASKS_FAILED_TO_PARSE: {
-    message: TaskMetadataFailedToParseData
-  },
-  TASK_HEARTBEAT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      id: z.string()
-    })
-  },
-  READY_TO_DISPOSE: {
-    message: z.undefined()
-  },
-  READY_FOR_CHECKPOINT: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
-  },
-  CANCEL_CHECKPOINT: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
-  },
-  WAIT_FOR_DURATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      ms: z.number(),
-      now: z.number()
-    }),
-    callback: z.object({
-      willCheckpointAndRestore: z.boolean()
-    })
-  },
-  WAIT_FOR_TASK: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      friendlyId: z.string()
-    })
-  },
-  WAIT_FOR_BATCH: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      batchFriendlyId: z.string(),
-      runFriendlyIds: z.string().array()
-    })
-  },
-  UNCAUGHT_EXCEPTION: {
-    message: UncaughtExceptionMessage
+__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;
   }
 };
-var ProdWorkerToChildMessages = {
-  EXECUTE_TASK_RUN: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      execution: TaskRunExecution,
-      traceContext: z.record(z.unknown()),
-      metadata: BackgroundWorkerProperties
-    })
-  },
-  TASK_RUN_COMPLETED_NOTIFICATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      completion: TaskRunExecutionResult,
-      execution: TaskRunExecution
-    })
-  },
-  CLEANUP: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      flush: z.boolean().default(false),
-      kill: z.boolean().default(true)
-    }),
-    callback: z.void()
-  },
-  WAIT_COMPLETED_NOTIFICATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
+__name(_APIConnectionError, "APIConnectionError");
+var APIConnectionError = _APIConnectionError;
+var _BadRequestError = class _BadRequestError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 400);
+  }
+};
+__name(_BadRequestError, "BadRequestError");
+var BadRequestError = _BadRequestError;
+var _AuthenticationError = class _AuthenticationError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 401);
+  }
+};
+__name(_AuthenticationError, "AuthenticationError");
+var AuthenticationError = _AuthenticationError;
+var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 403);
+  }
+};
+__name(_PermissionDeniedError, "PermissionDeniedError");
+var PermissionDeniedError = _PermissionDeniedError;
+var _NotFoundError = class _NotFoundError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 404);
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+var NotFoundError = _NotFoundError;
+var _ConflictError = class _ConflictError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 409);
+  }
+};
+__name(_ConflictError, "ConflictError");
+var ConflictError = _ConflictError;
+var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 422);
+  }
+};
+__name(_UnprocessableEntityError, "UnprocessableEntityError");
+var UnprocessableEntityError = _UnprocessableEntityError;
+var _RateLimitError = class _RateLimitError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 429);
   }
 };
+__name(_RateLimitError, "RateLimitError");
+var RateLimitError = _RateLimitError;
+var _InternalServerError = class _InternalServerError extends APIError {
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+function castToError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError, "castToError");
 
-// src/v3/schemas/resources.ts
-var TaskResource = z.object({
-  id: z.string(),
-  filePath: z.string(),
-  exportName: z.string(),
-  queue: QueueOptions.optional(),
-  retry: RetryOptions.optional(),
-  machine: Machine.partial().optional(),
-  triggerSource: z.string().optional()
-});
-var BackgroundWorkerMetadata = z.object({
-  packageVersion: z.string(),
-  contentHash: z.string(),
-  cliPackageVersion: z.string().optional(),
-  tasks: z.array(TaskResource)
-});
-var ImageDetailsMetadata = z.object({
-  contentHash: z.string(),
-  imageTag: z.string()
-});
+// src/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/schemas/api.ts
-var WhoAmIResponseSchema = z.object({
-  userId: z.string(),
-  email: z.string().email(),
-  dashboardUrl: z.string()
-});
-var GetProjectResponseBody = z.object({
-  id: z.string(),
-  externalRef: z.string(),
-  name: z.string(),
-  slug: z.string(),
-  createdAt: z.coerce.date(),
-  organization: z.object({
-    id: z.string(),
-    title: z.string(),
-    slug: z.string(),
-    createdAt: z.coerce.date()
-  })
-});
-var GetProjectsResponseBody = z.array(GetProjectResponseBody);
-var GetProjectEnvResponse = z.object({
-  apiKey: z.string(),
-  name: z.string(),
-  apiUrl: z.string()
-});
-var CreateBackgroundWorkerRequestBody = z.object({
-  localOnly: z.boolean(),
-  metadata: BackgroundWorkerMetadata
-});
-var CreateBackgroundWorkerResponse = z.object({
-  id: z.string(),
-  version: z.string(),
-  contentHash: z.string()
-});
-var TriggerTaskRequestBody = z.object({
-  payload: z.any(),
-  context: z.any(),
-  options: z.object({
-    dependentAttempt: z.string().optional(),
-    dependentBatch: z.string().optional(),
-    lockToVersion: z.string().optional(),
-    queue: QueueOptions.optional(),
-    concurrencyKey: z.string().optional(),
-    idempotencyKey: z.string().optional(),
-    test: z.boolean().optional(),
-    payloadType: z.string().optional()
-  }).optional()
+// src/v3/utils/retries.ts
+var defaultRetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+var defaultFetchRetryOptions = {
+  byStatus: {
+    "429,408,409,5xx": {
+      strategy: "backoff",
+      ...defaultRetryOptions
+    }
+  },
+  connectionError: defaultRetryOptions,
+  timeout: defaultRetryOptions
+};
+function calculateNextRetryDelay(options, attempt) {
+  const opts = {
+    ...defaultRetryOptions,
+    ...options
+  };
+  if (attempt >= opts.maxAttempts) {
+    return;
+  }
+  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
+  const random = randomize ? Math.random() + 1 : 1;
+  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
+  return Math.round(timeout);
+}
+__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+function calculateResetAt2(resets, format, now = Date.now()) {
+  const resetAt = calculateResetAt(resets, format, new Date(now));
+  return resetAt?.getTime();
+}
+__name(calculateResetAt2, "calculateResetAt");
+
+// src/v3/zodfetch.ts
+var defaultRetryOptions2 = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: false
+};
+async function zodfetch(schema, url, requestInit, options) {
+  return await _doZodFetch(schema, url, requestInit, options);
+}
+__name(zodfetch, "zodfetch");
+async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
+  try {
+    const response = await fetch(url, requestInitWithCache(requestInit));
+    const responseHeaders = createResponseHeaders(response.headers);
+    if (!response.ok) {
+      const retryResult = shouldRetry(response, attempt, options?.retry);
+      if (retryResult.retry) {
+        await new Promise((resolve) => setTimeout(resolve, retryResult.delay));
+        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+      } else {
+        const errText = await response.text().catch((e) => castToError2(e).message);
+        const errJSON = safeJsonParse(errText);
+        const errMessage = errJSON ? void 0 : errText;
+        throw APIError.generate(response.status, errJSON, errMessage, responseHeaders);
+      }
+    }
+    const jsonBody = await response.json();
+    const parsedResult = schema.safeParse(jsonBody);
+    if (parsedResult.success) {
+      return parsedResult.data;
+    }
+    throw fromZodError(parsedResult.error);
+  } catch (error) {
+    if (error instanceof APIError) {
+      throw error;
+    }
+    if (options?.retry) {
+      const retry = {
+        ...defaultRetryOptions2,
+        ...options.retry
+      };
+      const delay = calculateNextRetryDelay(retry, attempt);
+      if (delay) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+      }
+    }
+    throw new APIConnectionError({
+      cause: castToError2(error)
+    });
+  }
+}
+__name(_doZodFetch, "_doZodFetch");
+function castToError2(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError2, "castToError");
+function shouldRetry(response, attempt, retryOptions) {
+  function shouldRetryForOptions() {
+    const retry = {
+      ...defaultRetryOptions2,
+      ...retryOptions
+    };
+    const delay = calculateNextRetryDelay(retry, attempt);
+    if (delay) {
+      return {
+        retry: true,
+        delay
+      };
+    } else {
+      return {
+        retry: false
+      };
+    }
+  }
+  __name(shouldRetryForOptions, "shouldRetryForOptions");
+  const shouldRetryHeader = response.headers.get("x-should-retry");
+  if (shouldRetryHeader === "true")
+    return shouldRetryForOptions();
+  if (shouldRetryHeader === "false")
+    return {
+      retry: false
+    };
+  if (response.status === 408)
+    return shouldRetryForOptions();
+  if (response.status === 409)
+    return shouldRetryForOptions();
+  if (response.status === 429)
+    return shouldRetryForOptions();
+  if (response.status >= 500)
+    return shouldRetryForOptions();
+  return {
+    retry: false
+  };
+}
+__name(shouldRetry, "shouldRetry");
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return void 0;
+  }
+}
+__name(safeJsonParse, "safeJsonParse");
+function createResponseHeaders(headers) {
+  return new Proxy(Object.fromEntries(
+    // @ts-ignore
+    headers.entries()
+  ), {
+    get(target, name) {
+      const key = name.toString();
+      return target[key.toLowerCase()] || target[key];
+    }
+  });
+}
+__name(createResponseHeaders, "createResponseHeaders");
+function requestInitWithCache(requestInit) {
+  try {
+    const withCache = {
+      ...requestInit,
+      cache: "no-cache"
+    };
+    const _ = new Request("http://localhost", withCache);
+    return withCache;
+  } catch (error) {
+    return requestInit ?? {};
+  }
+}
+__name(requestInitWithCache, "requestInitWithCache");
+var CreateAuthorizationCodeResponseSchema = z.object({
+  url: z.string().url(),
+  authorizationCode: z.string()
 });
-var TriggerTaskResponse = z.object({
-  id: z.string()
+var GetPersonalAccessTokenRequestSchema = z.object({
+  authorizationCode: z.string()
 });
-var BatchTriggerTaskRequestBody = z.object({
-  items: TriggerTaskRequestBody.array(),
-  dependentAttempt: z.string().optional()
+var GetPersonalAccessTokenResponseSchema = z.object({
+  token: z.object({
+    token: z.string(),
+    obfuscatedToken: z.string()
+  }).nullable()
 });
-var BatchTriggerTaskResponse = z.object({
-  batchId: z.string(),
-  runs: z.string().array()
+var TaskRunBuiltInError = z.object({
+  type: z.literal("BUILT_IN_ERROR"),
+  name: z.string(),
+  message: z.string(),
+  stackTrace: z.string()
 });
-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 TaskRunCustomErrorObject = z.object({
+  type: z.literal("CUSTOM_ERROR"),
+  raw: z.string()
 });
-var GetEnvironmentVariablesResponseBody = z.object({
-  variables: z.record(z.string())
+var TaskRunStringError = z.object({
+  type: z.literal("STRING_ERROR"),
+  raw: z.string()
 });
-var StartDeploymentIndexingRequestBody = z.object({
-  imageReference: 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_RUN_CANCELLED: "TASK_RUN_CANCELLED",
+  TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
+  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
+  GRACEFUL_EXIT_TIMEOUT: "GRACEFUL_EXIT_TIMEOUT"
+};
+var TaskRunInternalError = z.object({
+  type: z.literal("INTERNAL_ERROR"),
+  code: z.enum([
+    "COULD_NOT_FIND_EXECUTOR",
+    "COULD_NOT_FIND_TASK",
+    "CONFIGURED_INCORRECTLY",
+    "TASK_ALREADY_RUNNING",
+    "TASK_EXECUTION_FAILED",
+    "TASK_EXECUTION_ABORTED",
+    "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+    "TASK_RUN_CANCELLED",
+    "TASK_OUTPUT_ERROR",
+    "HANDLE_ERROR_ERROR",
+    "GRACEFUL_EXIT_TIMEOUT"
+  ]),
+  message: z.string().optional()
 });
-var StartDeploymentIndexingResponseBody = z.object({
+var TaskRunError = z.discriminatedUnion("type", [
+  TaskRunBuiltInError,
+  TaskRunCustomErrorObject,
+  TaskRunStringError,
+  TaskRunInternalError
+]);
+var TaskRun = z.object({
   id: z.string(),
-  contentHash: 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(),
+  idempotencyKey: z.string().optional()
 });
-var ExternalBuildData = z.object({
-  buildId: z.string(),
-  buildToken: z.string(),
-  projectId: z.string()
+var TaskRunExecutionTask = z.object({
+  id: z.string(),
+  filePath: z.string(),
+  exportName: z.string()
 });
-var InitializeDeploymentResponseBody = z.object({
+var TaskRunExecutionAttempt = 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()
+  number: z.number(),
+  startedAt: z.coerce.date(),
+  backgroundWorkerId: z.string(),
+  backgroundWorkerTaskId: z.string(),
+  status: z.string()
 });
-var InitializeDeploymentRequestBody = z.object({
-  contentHash: z.string(),
-  userId: z.string().optional()
+var TaskRunExecutionEnvironment = z.object({
+  id: z.string(),
+  slug: z.string(),
+  type: z.enum([
+    "PRODUCTION",
+    "STAGING",
+    "DEVELOPMENT",
+    "PREVIEW"
+  ])
 });
-var DeploymentErrorData = z.object({
-  name: z.string(),
-  message: z.string(),
-  stack: z.string().optional()
+var TaskRunExecutionOrganization = z.object({
+  id: z.string(),
+  slug: z.string(),
+  name: z.string()
 });
-var GetDeploymentResponseBody = z.object({
+var TaskRunExecutionProject = 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()
+  ref: z.string(),
+  slug: z.string(),
+  name: z.string()
 });
-var CreateUploadPayloadUrlResponseBody = z.object({
-  presignedUrl: z.string()
+var TaskRunExecutionQueue = z.object({
+  id: z.string(),
+  name: z.string()
 });
-var ReplayRunResponse = z.object({
+var TaskRunExecutionBatch = z.object({
   id: z.string()
 });
-var CanceledRunResponse = z.object({
-  message: z.string()
+var TaskRunExecution = z.object({
+  task: TaskRunExecutionTask,
+  attempt: TaskRunExecutionAttempt,
+  run: TaskRun,
+  queue: TaskRunExecutionQueue,
+  environment: TaskRunExecutionEnvironment,
+  organization: TaskRunExecutionOrganization,
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional()
 });
-var ScheduledTaskPayload = z.object({
-  /** The schedule id associated with this run (you can have many schedules for the same task).
-  You can use this to remove the schedule, update it, etc */
-  scheduleId: z.string(),
-  /** When the task was scheduled to run.
-  * Note this will be slightly different from `new Date()` because it takes a few ms to run the task. */
-  timestamp: z.date(),
-  /** When the task was last run (it has been).
-  This can be undefined if it's never been run */
-  lastTimestamp: z.date().optional(),
-  /** You can optionally provide an external id when creating the schedule.
-  Usually you would use a userId or some other unique identifier.
-  This defaults to undefined if you didn't provide one. */
-  externalId: z.string().optional(),
-  /** The next 5 dates this task is scheduled to run */
-  upcoming: z.array(z.date())
+var TaskRunContext = z.object({
+  task: TaskRunExecutionTask,
+  attempt: TaskRunExecutionAttempt.omit({
+    backgroundWorkerId: true,
+    backgroundWorkerTaskId: true
+  }),
+  run: TaskRun.omit({
+    payload: true,
+    payloadType: true
+  }),
+  queue: TaskRunExecutionQueue,
+  environment: TaskRunExecutionEnvironment,
+  organization: TaskRunExecutionOrganization,
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional()
 });
-var CreateScheduleOptions = z.object({
-  /** The id of the task you want to attach to. */
-  task: z.string(),
-  /**  The schedule in CRON format.
-     * 
-     * ```txt
-  *    *    *    *    *    *
-  ┬    ┬    ┬    ┬    ┬
-  │    │    │    │    |
-  │    │    │    │    └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
-  │    │    │    └───── month (1 - 12)
-  │    │    └────────── day of month (1 - 31, L)
-  │    └─────────────── hour (0 - 23)
-  └──────────────────── minute (0 - 59)
-     * ```
-  
-  "L" means the last. In the "day of week" field, 1L means the last Monday of the month. In the day of month field, L means the last day of the month.
-  
-     */
-  cron: z.string(),
-  /** (Optional) You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
-  *
-  * This is useful if you don't want to create duplicate schedules for a user. */
-  deduplicationKey: z.string().optional(),
-  /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
-  *
-  * This allows you to have per-user CRON tasks.
-  */
-  externalId: z.string().optional()
+var TaskRunExecutionRetry = z.object({
+  timestamp: z.number(),
+  delay: z.number(),
+  error: z.unknown().optional()
 });
-var UpdateScheduleOptions = CreateScheduleOptions;
-var ScheduleObject = z.object({
+var TaskRunFailedExecutionResult = z.object({
+  ok: z.literal(false),
   id: z.string(),
-  task: z.string(),
-  active: z.boolean(),
-  deduplicationKey: z.string().nullish(),
-  externalId: z.string().nullish(),
-  generator: z.object({
-    type: z.literal("CRON"),
-    expression: z.string(),
-    description: z.string()
-  }),
-  nextRun: z.coerce.date().nullish(),
-  environments: z.array(z.object({
-    id: z.string(),
-    type: z.string(),
-    userName: z.string().nullish()
-  }))
-});
-var DeletedScheduleObject = z.object({
-  id: z.string()
+  error: TaskRunError,
+  retry: TaskRunExecutionRetry.optional(),
+  skippedRetrying: z.boolean().optional()
 });
-var ListSchedulesResult = z.object({
-  data: z.array(ScheduleObject),
-  pagination: z.object({
-    currentPage: z.number(),
-    totalPages: z.number(),
-    count: z.number()
-  })
+var TaskRunSuccessfulExecutionResult = z.object({
+  ok: z.literal(true),
+  id: z.string(),
+  output: z.string().optional(),
+  outputType: z.string()
 });
-var ListScheduleOptions = z.object({
-  page: z.number().optional(),
-  perPage: z.number().optional()
+var TaskRunExecutionResult = z.discriminatedUnion("ok", [
+  TaskRunSuccessfulExecutionResult,
+  TaskRunFailedExecutionResult
+]);
+var BatchTaskRunExecutionResult = z.object({
+  id: z.string(),
+  items: TaskRunExecutionResult.array()
 });
-var PostStartCauses = z.enum([
-  "index",
-  "create",
-  "restore"
+
+// src/v3/schemas/messages.ts
+var EnvironmentType = z.enum([
+  "PRODUCTION",
+  "STAGING",
+  "DEVELOPMENT",
+  "PREVIEW"
 ]);
-var PreStopCauses = z.enum([
-  "terminate"
-]);
-var RegexSchema = z.custom((val) => {
-  try {
-    return typeof val.test === "function";
-  } catch {
-    return false;
-  }
+var MachineCpu = z.union([
+  z.literal(0.25),
+  z.literal(0.5),
+  z.literal(1),
+  z.literal(2),
+  z.literal(4)
+]).default(0.5);
+var MachineMemory = z.union([
+  z.literal(0.25),
+  z.literal(0.5),
+  z.literal(1),
+  z.literal(2),
+  z.literal(4),
+  z.literal(8)
+]).default(1);
+var Machine = z.object({
+  version: z.literal("v1").default("v1"),
+  cpu: MachineCpu,
+  memory: MachineMemory
 });
-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()
+var TaskRunExecutionPayload = z.object({
+  execution: TaskRunExecution,
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
 });
-var WaitReason = z.enum([
-  "WAIT_FOR_DURATION",
-  "WAIT_FOR_TASK",
-  "WAIT_FOR_BATCH"
+var ProdTaskRunExecution = TaskRunExecution.extend({
+  worker: z.object({
+    id: z.string(),
+    contentHash: z.string(),
+    version: z.string()
+  })
+});
+var ProdTaskRunExecutionPayload = z.object({
+  execution: ProdTaskRunExecution,
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
+});
+var BackgroundWorkerServerMessages = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("EXECUTE_RUNS"),
+    payloads: z.array(TaskRunExecutionPayload)
+  }),
+  z.object({
+    type: z.literal("CANCEL_ATTEMPT"),
+    taskAttemptId: z.string(),
+    taskRunId: z.string()
+  }),
+  z.object({
+    type: z.literal("SCHEDULE_ATTEMPT"),
+    image: z.string(),
+    version: z.string(),
+    machine: Machine,
+    // identifiers
+    id: z.string(),
+    envId: z.string(),
+    envType: EnvironmentType,
+    orgId: z.string(),
+    projectId: z.string(),
+    runId: z.string()
+  })
 ]);
-var ProviderToPlatformMessages = {
-  LOG: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      data: z.string()
-    })
-  },
-  LOG_WITH_ACK: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      data: z.string()
-    }),
-    callback: z.object({
-      status: z.literal("ok")
-    })
-  },
-  WORKER_CRASHED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string(),
-      reason: z.string().optional(),
-      exitCode: z.number().optional(),
-      message: z.string().optional(),
-      logs: z.string().optional()
-    })
-  },
-  INDEXING_FAILED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      deploymentId: z.string(),
-      error: z.object({
-        name: z.string(),
-        message: z.string(),
-        stack: z.string().optional()
-      })
-    })
-  }
+var 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 PlatformToProviderMessages = {
-  HEALTH: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
+var BackgroundWorkerClientMessages = z.discriminatedUnion("type", [
+  z.object({
+    version: z.literal("v1").default("v1"),
+    type: z.literal("TASK_RUN_COMPLETED"),
+    completion: TaskRunExecutionResult,
+    execution: TaskRunExecution
+  }),
+  z.object({
+    version: z.literal("v1").default("v1"),
+    type: z.literal("TASK_HEARTBEAT"),
+    id: z.string()
+  })
+]);
+var BackgroundWorkerProperties = z.object({
+  id: z.string(),
+  version: z.string(),
+  contentHash: z.string()
+});
+var clientWebsocketMessages = {
+  READY_FOR_TASKS: z.object({
+    version: z.literal("v1").default("v1"),
+    backgroundWorkerId: z.string()
+  }),
+  BACKGROUND_WORKER_DEPRECATED: z.object({
+    version: z.literal("v1").default("v1"),
+    backgroundWorkerId: z.string()
+  }),
+  BACKGROUND_WORKER_MESSAGE: z.object({
+    version: z.literal("v1").default("v1"),
+    backgroundWorkerId: z.string(),
+    data: BackgroundWorkerClientMessages
+  })
+};
+var workerToChildMessages = {
+  EXECUTE_TASK_RUN: z.object({
+    version: z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
+    traceContext: z.record(z.unknown()),
+    metadata: BackgroundWorkerProperties
+  }),
+  TASK_RUN_COMPLETED_NOTIFICATION: z.object({
+    version: z.literal("v1").default("v1"),
+    completion: TaskRunExecutionResult,
+    execution: TaskRunExecution
+  }),
+  CLEANUP: z.object({
+    version: z.literal("v1").default("v1"),
+    flush: z.boolean().default(false),
+    kill: z.boolean().default(true)
+  })
+};
+var FixedWindowRateLimit = z.object({
+  type: z.literal("fixed-window"),
+  limit: z.number(),
+  window: z.union([
+    z.object({
+      seconds: z.number()
     }),
-    callback: z.object({
-      status: z.literal("ok")
-    })
-  },
-  INDEX: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      imageTag: z.string(),
-      shortCode: z.string(),
-      apiKey: z.string(),
-      apiUrl: z.string(),
-      // identifiers
-      envId: z.string(),
-      envType: EnvironmentType,
-      orgId: z.string(),
-      projectId: z.string(),
-      deploymentId: z.string()
+    z.object({
+      minutes: z.number()
     }),
-    callback: z.discriminatedUnion("success", [
-      z.object({
-        success: z.literal(false),
-        error: z.object({
-          name: z.string(),
-          message: z.string(),
-          stack: z.string().optional()
-        })
-      }),
-      z.object({
-        success: z.literal(true)
-      })
-    ])
-  },
-  // TODO: this should be a shared queue message instead
-  RESTORE: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      type: z.enum([
-        "DOCKER",
-        "KUBERNETES"
-      ]),
-      location: z.string(),
-      reason: z.string().optional(),
-      imageRef: z.string(),
-      machine: Machine,
-      // identifiers
-      checkpointId: z.string(),
-      envId: z.string(),
-      envType: EnvironmentType,
-      orgId: z.string(),
-      projectId: z.string(),
-      runId: z.string()
+    z.object({
+      hours: z.number()
     })
-  },
-  DELETE: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      name: z.string()
-    }),
-    callback: z.object({
-      message: z.string()
+  ])
+});
+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 TaskMetadata = z.object({
+  id: z.string(),
+  packageVersion: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional(),
+  triggerSource: z.string().optional()
+});
+var TaskFileMetadata = z.object({
+  filePath: z.string(),
+  exportName: z.string()
+});
+var TaskMetadataWithFilePath = TaskMetadata.merge(TaskFileMetadata);
+var UncaughtExceptionMessage = z.object({
+  version: z.literal("v1").default("v1"),
+  error: z.object({
+    name: z.string(),
+    message: z.string(),
+    stack: z.string().optional()
+  }),
+  origin: z.enum([
+    "uncaughtException",
+    "unhandledRejection"
+  ])
+});
+var TaskMetadataFailedToParseData = z.object({
+  version: z.literal("v1").default("v1"),
+  tasks: z.unknown(),
+  zodIssues: z.custom((v) => {
+    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
+  })
+});
+var childToWorkerMessages = {
+  TASK_RUN_COMPLETED: z.object({
+    version: z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
+    result: TaskRunExecutionResult
+  }),
+  TASKS_READY: z.object({
+    version: z.literal("v1").default("v1"),
+    tasks: TaskMetadataWithFilePath.array()
+  }),
+  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
+  TASK_HEARTBEAT: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string()
+  }),
+  READY_TO_DISPOSE: z.undefined(),
+  WAIT_FOR_DURATION: z.object({
+    version: z.literal("v1").default("v1"),
+    ms: z.number()
+  }),
+  WAIT_FOR_TASK: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string()
+  }),
+  WAIT_FOR_BATCH: z.object({
+    version: z.literal("v1").default("v1"),
+    id: z.string(),
+    runs: z.string().array()
+  }),
+  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
+};
+var ProdChildToWorkerMessages = {
+  TASK_RUN_COMPLETED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      result: TaskRunExecutionResult
     })
   },
-  GET: {
+  TASKS_READY: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      name: z.string()
+      tasks: TaskMetadataWithFilePath.array()
     })
-  }
-};
-var CoordinatorToPlatformMessages = {
-  LOG: {
+  },
+  TASKS_FAILED_TO_PARSE: {
+    message: TaskMetadataFailedToParseData
+  },
+  TASK_HEARTBEAT: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      metadata: z.any(),
-      text: z.string()
+      id: z.string()
     })
   },
-  CREATE_WORKER: {
+  READY_TO_DISPOSE: {
+    message: z.undefined()
+  },
+  READY_FOR_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  WAIT_FOR_DURATION: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      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()
-      })
+      ms: z.number(),
+      now: z.number()
     }),
-    callback: z.discriminatedUnion("success", [
-      z.object({
-        success: z.literal(false)
-      }),
-      z.object({
-        success: z.literal(true)
-      })
-    ])
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
   },
-  READY_FOR_EXECUTION: {
+  WAIT_FOR_TASK: {
     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
-      })
-    ])
+      friendlyId: z.string()
+    })
   },
-  READY_FOR_RESUME: {
+  WAIT_FOR_BATCH: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      attemptFriendlyId: z.string(),
-      type: WaitReason
+      batchFriendlyId: z.string(),
+      runFriendlyIds: z.string().array()
     })
   },
-  TASK_RUN_COMPLETED: {
+  UNCAUGHT_EXCEPTION: {
+    message: UncaughtExceptionMessage
+  }
+};
+var ProdWorkerToChildMessages = {
+  EXECUTE_TASK_RUN: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      execution: ProdTaskRunExecution,
-      completion: TaskRunExecutionResult,
-      checkpoint: z.object({
-        docker: z.boolean(),
-        location: z.string()
-      }).optional()
+      execution: TaskRunExecution,
+      traceContext: z.record(z.unknown()),
+      metadata: BackgroundWorkerProperties
     })
   },
-  TASK_HEARTBEAT: {
+  TASK_RUN_COMPLETED_NOTIFICATION: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      attemptFriendlyId: z.string()
+      completion: TaskRunExecutionResult,
+      execution: TaskRunExecution
     })
   },
-  CHECKPOINT_CREATED: {
+  CLEANUP: {
     message: z.object({
       version: z.literal("v1").default("v1"),
-      attemptFriendlyId: z.string(),
-      docker: z.boolean(),
-      location: z.string(),
-      reason: z.discriminatedUnion("type", [
-        z.object({
-          type: z.literal("WAIT_FOR_DURATION"),
-          ms: z.number(),
-          now: z.number()
-        }),
-        z.object({
-          type: z.literal("WAIT_FOR_BATCH"),
-          batchFriendlyId: z.string(),
-          runFriendlyIds: z.string().array()
-        }),
-        z.object({
-          type: z.literal("WAIT_FOR_TASK"),
-          friendlyId: z.string()
-        }),
-        z.object({
-          type: z.literal("RETRYING_AFTER_FAILURE"),
-          attemptNumber: z.number()
-        })
-      ])
-    })
-  },
-  INDEXING_FAILED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      deploymentId: z.string(),
-      error: z.object({
-        name: z.string(),
-        message: z.string(),
-        stack: z.string().optional()
-      })
-    })
-  }
-};
-var PlatformToCoordinatorMessages = {
-  RESUME_AFTER_DEPENDENCY: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string(),
-      attemptId: z.string(),
-      attemptFriendlyId: z.string(),
-      completions: TaskRunExecutionResult.array(),
-      executions: TaskRunExecution.array()
-    })
-  },
-  RESUME_AFTER_DURATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptId: z.string(),
-      attemptFriendlyId: z.string()
-    })
-  },
-  REQUEST_ATTEMPT_CANCELLATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptId: z.string(),
-      attemptFriendlyId: z.string()
-    })
-  },
-  READY_FOR_RETRY: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string()
-    })
-  }
-};
-var ClientToSharedQueueMessages = {
-  READY_FOR_TASKS: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      backgroundWorkerId: z.string()
-    })
-  },
-  BACKGROUND_WORKER_DEPRECATED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      backgroundWorkerId: z.string()
-    })
-  },
-  BACKGROUND_WORKER_MESSAGE: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      backgroundWorkerId: z.string(),
-      data: BackgroundWorkerClientMessages
-    })
-  }
-};
-var SharedQueueToClientMessages = {
-  SERVER_READY: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      id: z.string()
-    })
-  },
-  BACKGROUND_WORKER_MESSAGE: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      backgroundWorkerId: z.string(),
-      data: BackgroundWorkerServerMessages
-    })
-  }
-};
-var ProdWorkerToCoordinatorMessages = {
-  LOG: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      text: z.string()
+      flush: z.boolean().default(false),
+      kill: z.boolean().default(true)
     }),
     callback: z.void()
   },
-  INDEX_TASKS: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      deploymentId: z.string(),
-      tasks: TaskResource.array(),
-      packageVersion: z.string()
-    }),
-    callback: z.discriminatedUnion("success", [
-      z.object({
-        success: z.literal(false)
-      }),
-      z.object({
-        success: z.literal(true)
-      })
-    ])
-  },
-  READY_FOR_EXECUTION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string(),
-      totalCompletions: z.number()
-    })
-  },
-  READY_FOR_RESUME: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptFriendlyId: z.string(),
-      type: WaitReason
-    })
-  },
-  READY_FOR_CHECKPOINT: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
-  },
-  CANCEL_CHECKPOINT: {
-    message: z.object({
-      version: z.literal("v1").default("v1")
-    })
-  },
-  TASK_HEARTBEAT: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptFriendlyId: z.string()
-    })
-  },
-  TASK_RUN_COMPLETED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      execution: ProdTaskRunExecution,
-      completion: TaskRunExecutionResult
-    }),
-    callback: z.object({
-      willCheckpointAndRestore: z.boolean(),
-      shouldExit: z.boolean()
-    })
-  },
-  WAIT_FOR_DURATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      ms: z.number(),
-      now: z.number(),
-      attemptFriendlyId: z.string()
-    }),
-    callback: z.object({
-      willCheckpointAndRestore: z.boolean()
-    })
-  },
-  WAIT_FOR_TASK: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      friendlyId: z.string(),
-      // This is the attempt that is waiting
-      attemptFriendlyId: z.string()
-    }),
-    callback: z.object({
-      willCheckpointAndRestore: z.boolean()
-    })
-  },
-  WAIT_FOR_BATCH: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      batchFriendlyId: z.string(),
-      runFriendlyIds: z.string().array(),
-      // This is the attempt that is waiting
-      attemptFriendlyId: z.string()
-    }),
-    callback: z.object({
-      willCheckpointAndRestore: z.boolean()
-    })
-  },
-  INDEXING_FAILED: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      deploymentId: z.string(),
-      error: z.object({
-        name: z.string(),
-        message: z.string(),
-        stack: z.string().optional()
-      })
-    })
-  }
-};
-var CoordinatorToProdWorkerMessages = {
-  RESUME_AFTER_DEPENDENCY: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptId: z.string(),
-      completions: TaskRunExecutionResult.array(),
-      executions: TaskRunExecution.array()
-    })
-  },
-  RESUME_AFTER_DURATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptId: z.string()
-    })
-  },
-  EXECUTE_TASK_RUN: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      executionPayload: ProdTaskRunExecutionPayload
-    })
-  },
-  REQUEST_ATTEMPT_CANCELLATION: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      attemptId: z.string()
-    })
-  },
-  REQUEST_EXIT: {
+  WAIT_COMPLETED_NOTIFICATION: {
     message: z.object({
       version: z.literal("v1").default("v1")
     })
-  },
-  READY_FOR_RETRY: {
-    message: z.object({
-      version: z.literal("v1").default("v1"),
-      runId: z.string()
-    })
   }
 };
-var ProdWorkerSocketData = z.object({
+
+// 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: Machine.partial().optional(),
+  triggerSource: z.string().optional()
+});
+var BackgroundWorkerMetadata = z.object({
+  packageVersion: z.string(),
   contentHash: z.string(),
-  projectRef: z.string(),
-  envId: z.string(),
-  runId: z.string(),
-  attemptFriendlyId: z.string().optional(),
-  podName: z.string(),
-  deploymentId: z.string(),
-  deploymentVersion: z.string()
-});
-var PRIMARY_VARIANT = "primary";
-var Variant = z.enum([
-  PRIMARY_VARIANT
-]);
-var AccessoryItem = z.object({
-  text: z.string(),
-  variant: z.string().optional(),
-  url: z.string().optional()
-});
-var Accessory = z.object({
-  items: z.array(AccessoryItem),
-  style: z.enum([
-    "codepath"
-  ]).optional()
+  cliPackageVersion: z.string().optional(),
+  tasks: z.array(TaskResource)
 });
-var TaskEventStyle = z.object({
-  icon: z.string().optional(),
-  variant: Variant.optional(),
-  accessory: Accessory.optional()
-}).default({
-  icon: void 0,
-  variant: void 0
+var ImageDetailsMetadata = z.object({
+  contentHash: z.string(),
+  imageTag: z.string()
 });
-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()
+// src/v3/schemas/api.ts
+var WhoAmIResponseSchema = z.object({
+  userId: z.string(),
+  email: z.string().email(),
+  dashboardUrl: z.string()
 });
-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 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 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 GetProjectsResponseBody = z.array(GetProjectResponseBody);
+var GetProjectEnvResponse = z.object({
+  apiKey: z.string(),
+  name: z.string(),
+  apiUrl: z.string()
 });
-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 CreateBackgroundWorkerRequestBody = z.object({
+  localOnly: z.boolean(),
+  metadata: BackgroundWorkerMetadata
 });
-var ExceptionEventProperties = z.object({
-  type: z.string().optional(),
-  message: z.string().optional(),
-  stacktrace: z.string().optional()
+var CreateBackgroundWorkerResponse = z.object({
+  id: z.string(),
+  version: z.string(),
+  contentHash: z.string()
 });
-var ExceptionSpanEvent = z.object({
-  name: z.literal("exception"),
-  time: z.coerce.date(),
-  properties: z.object({
-    exception: ExceptionEventProperties
-  })
+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()
+  }).optional()
 });
-var CancellationSpanEvent = z.object({
-  name: z.literal("cancellation"),
-  time: z.coerce.date(),
-  properties: z.object({
-    reason: z.string()
-  })
+var TriggerTaskResponse = z.object({
+  id: z.string()
 });
-var OtherSpanEvent = z.object({
-  name: z.string(),
-  time: z.coerce.date(),
-  properties: z.record(z.unknown())
+var BatchTriggerTaskRequestBody = z.object({
+  items: TriggerTaskRequestBody.array(),
+  dependentAttempt: z.string().optional()
 });
-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()
+var BatchTriggerTaskResponse = z.object({
+  batchId: z.string(),
+  runs: z.string().array()
 });
-
-// src/v3/apiErrors.ts
-var _APIError = class _APIError extends Error {
-  constructor(status, error, message, headers) {
-    super(`${_APIError.makeMessage(status, error, message)}`);
-    this.status = status;
-    this.headers = headers;
-    const data = error;
-    this.error = data;
-    this.code = data?.["code"];
-    this.param = data?.["param"];
-    this.type = data?.["type"];
+var GetBatchResponseBody = z.object({
+  id: z.string(),
+  items: z.array(z.object({
+    id: z.string(),
+    taskRunId: z.string(),
+    status: z.enum([
+      "PENDING",
+      "CANCELED",
+      "COMPLETED",
+      "FAILED"
+    ])
+  }))
+});
+var GetEnvironmentVariablesResponseBody = z.object({
+  variables: z.record(z.string())
+});
+var StartDeploymentIndexingRequestBody = z.object({
+  imageReference: z.string()
+});
+var StartDeploymentIndexingResponseBody = z.object({
+  id: z.string(),
+  contentHash: z.string()
+});
+var ExternalBuildData = z.object({
+  buildId: z.string(),
+  buildToken: z.string(),
+  projectId: z.string()
+});
+var InitializeDeploymentResponseBody = z.object({
+  id: z.string(),
+  contentHash: z.string(),
+  shortCode: z.string(),
+  version: z.string(),
+  imageTag: z.string(),
+  externalBuildData: ExternalBuildData.optional().nullable(),
+  registryHost: z.string().optional()
+});
+var InitializeDeploymentRequestBody = z.object({
+  contentHash: z.string(),
+  userId: z.string().optional()
+});
+var DeploymentErrorData = z.object({
+  name: z.string(),
+  message: z.string(),
+  stack: 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({
+  message: z.string()
+});
+var ScheduledTaskPayload = z.object({
+  /** The schedule id associated with this run (you can have many schedules for the same task).
+  You can use this to remove the schedule, update it, etc */
+  scheduleId: z.string(),
+  /** When the task was scheduled to run.
+  * Note this will be slightly different from `new Date()` because it takes a few ms to run the task. */
+  timestamp: z.date(),
+  /** When the task was last run (it has been).
+  This can be undefined if it's never been run */
+  lastTimestamp: z.date().optional(),
+  /** You can optionally provide an external id when creating the schedule.
+  Usually you would use a userId or some other unique identifier.
+  This defaults to undefined if you didn't provide one. */
+  externalId: z.string().optional(),
+  /** The next 5 dates this task is scheduled to run */
+  upcoming: z.array(z.date())
+});
+var CreateScheduleOptions = z.object({
+  /** The id of the task you want to attach to. */
+  task: z.string(),
+  /**  The schedule in CRON format.
+     * 
+     * ```txt
+  *    *    *    *    *    *
+  ┬    ┬    ┬    ┬    ┬
+  │    │    │    │    |
+  │    │    │    │    └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
+  │    │    │    └───── month (1 - 12)
+  │    │    └────────── day of month (1 - 31, L)
+  │    └─────────────── hour (0 - 23)
+  └──────────────────── minute (0 - 59)
+     * ```
+  
+  "L" means the last. In the "day of week" field, 1L means the last Monday of the month. In the day of month field, L means the last day of the month.
+  
+     */
+  cron: z.string(),
+  /** (Optional) You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
+  *
+  * This is useful if you don't want to create duplicate schedules for a user. */
+  deduplicationKey: z.string().optional(),
+  /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
+  *
+  * This allows you to have per-user CRON tasks.
+  */
+  externalId: z.string().optional()
+});
+var UpdateScheduleOptions = CreateScheduleOptions;
+var ScheduleObject = z.object({
+  id: z.string(),
+  task: z.string(),
+  active: z.boolean(),
+  deduplicationKey: z.string().nullish(),
+  externalId: z.string().nullish(),
+  generator: z.object({
+    type: z.literal("CRON"),
+    expression: z.string(),
+    description: z.string()
+  }),
+  nextRun: z.coerce.date().nullish(),
+  environments: z.array(z.object({
+    id: z.string(),
+    type: z.string(),
+    userName: z.string().nullish()
+  }))
+});
+var DeletedScheduleObject = z.object({
+  id: z.string()
+});
+var ListSchedulesResult = z.object({
+  data: z.array(ScheduleObject),
+  pagination: z.object({
+    currentPage: z.number(),
+    totalPages: z.number(),
+    count: z.number()
+  })
+});
+var ListScheduleOptions = z.object({
+  page: z.number().optional(),
+  perPage: z.number().optional()
+});
+var 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;
   }
-  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)";
+});
+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()
+});
+var WaitReason = z.enum([
+  "WAIT_FOR_DURATION",
+  "WAIT_FOR_TASK",
+  "WAIT_FOR_BATCH"
+]);
+var ProviderToPlatformMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      data: z.string()
+    })
+  },
+  LOG_WITH_ACK: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      data: z.string()
+    }),
+    callback: z.object({
+      status: z.literal("ok")
+    })
+  },
+  WORKER_CRASHED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      reason: z.string().optional(),
+      exitCode: z.number().optional(),
+      message: z.string().optional(),
+      logs: z.string().optional()
+    })
+  },
+  INDEXING_FAILED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      error: z.object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().optional()
+      })
+    })
   }
-  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);
+};
+var PlatformToProviderMessages = {
+  HEALTH: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    }),
+    callback: z.object({
+      status: z.literal("ok")
+    })
+  },
+  INDEX: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      imageTag: z.string(),
+      shortCode: z.string(),
+      apiKey: z.string(),
+      apiUrl: z.string(),
+      // identifiers
+      envId: z.string(),
+      envType: EnvironmentType,
+      orgId: z.string(),
+      projectId: z.string(),
+      deploymentId: z.string()
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false),
+        error: z.object({
+          name: z.string(),
+          message: z.string(),
+          stack: z.string().optional()
+        })
+      }),
+      z.object({
+        success: z.literal(true)
+      })
+    ])
+  },
+  // TODO: this should be a shared queue message instead
+  RESTORE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      type: z.enum([
+        "DOCKER",
+        "KUBERNETES"
+      ]),
+      location: z.string(),
+      reason: z.string().optional(),
+      imageRef: z.string(),
+      machine: Machine,
+      // identifiers
+      checkpointId: z.string(),
+      envId: z.string(),
+      envType: EnvironmentType,
+      orgId: z.string(),
+      projectId: z.string(),
+      runId: z.string()
+    })
+  },
+  DELETE: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      name: z.string()
+    }),
+    callback: z.object({
+      message: z.string()
+    })
+  },
+  GET: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      name: z.string()
+    })
   }
 };
-__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;
+var CoordinatorToPlatformMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      metadata: z.any(),
+      text: z.string()
+    })
+  },
+  CREATE_WORKER: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      projectRef: z.string(),
+      envId: z.string(),
+      deploymentId: z.string(),
+      metadata: z.object({
+        cliPackageVersion: z.string().optional(),
+        contentHash: z.string(),
+        packageVersion: z.string(),
+        tasks: TaskResource.array()
+      })
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false)
+      }),
+      z.object({
+        success: z.literal(true)
+      })
+    ])
+  },
+  READY_FOR_EXECUTION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      totalCompletions: z.number()
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false)
+      }),
+      z.object({
+        success: z.literal(true),
+        payload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  READY_FOR_RESUME: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string(),
+      type: WaitReason
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult,
+      checkpoint: z.object({
+        docker: z.boolean(),
+        location: z.string()
+      }).optional()
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string()
+    })
+  },
+  CHECKPOINT_CREATED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string(),
+      docker: z.boolean(),
+      location: z.string(),
+      reason: z.discriminatedUnion("type", [
+        z.object({
+          type: z.literal("WAIT_FOR_DURATION"),
+          ms: z.number(),
+          now: z.number()
+        }),
+        z.object({
+          type: z.literal("WAIT_FOR_BATCH"),
+          batchFriendlyId: z.string(),
+          runFriendlyIds: z.string().array()
+        }),
+        z.object({
+          type: z.literal("WAIT_FOR_TASK"),
+          friendlyId: z.string()
+        }),
+        z.object({
+          type: z.literal("RETRYING_AFTER_FAILURE"),
+          attemptNumber: z.number()
+        })
+      ])
+    })
+  },
+  INDEXING_FAILED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      error: z.object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().optional()
+      })
+    })
   }
 };
-__name(_APIConnectionError, "APIConnectionError");
-var APIConnectionError = _APIConnectionError;
-var _BadRequestError = class _BadRequestError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 400);
+var PlatformToCoordinatorMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      attemptId: z.string(),
+      attemptFriendlyId: z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string(),
+      attemptFriendlyId: z.string()
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string(),
+      attemptFriendlyId: z.string()
+    })
+  },
+  READY_FOR_RETRY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string()
+    })
   }
 };
-__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);
+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
+    })
   }
 };
-__name(_NotFoundError, "NotFoundError");
-var NotFoundError = _NotFoundError;
-var _ConflictError = class _ConflictError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 409);
+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
+    })
   }
 };
-__name(_ConflictError, "ConflictError");
-var ConflictError = _ConflictError;
-var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 422);
+var ProdWorkerToCoordinatorMessages = {
+  LOG: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      text: z.string()
+    }),
+    callback: z.void()
+  },
+  INDEX_TASKS: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      tasks: TaskResource.array(),
+      packageVersion: z.string()
+    }),
+    callback: z.discriminatedUnion("success", [
+      z.object({
+        success: z.literal(false)
+      }),
+      z.object({
+        success: z.literal(true)
+      })
+    ])
+  },
+  READY_FOR_EXECUTION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string(),
+      totalCompletions: z.number()
+    })
+  },
+  READY_FOR_RESUME: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string(),
+      type: WaitReason
+    })
+  },
+  READY_FOR_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptFriendlyId: z.string()
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean(),
+      shouldExit: z.boolean()
+    })
+  },
+  WAIT_FOR_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      ms: z.number(),
+      now: z.number(),
+      attemptFriendlyId: z.string()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      friendlyId: z.string(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: z.string()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      batchFriendlyId: z.string(),
+      runFriendlyIds: z.string().array(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: z.string()
+    }),
+    callback: z.object({
+      willCheckpointAndRestore: z.boolean()
+    })
+  },
+  INDEXING_FAILED: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      deploymentId: z.string(),
+      error: z.object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().optional()
+      })
+    })
   }
 };
-__name(_UnprocessableEntityError, "UnprocessableEntityError");
-var UnprocessableEntityError = _UnprocessableEntityError;
-var _RateLimitError = class _RateLimitError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 429);
+var CoordinatorToProdWorkerMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string()
+    })
+  },
+  EXECUTE_TASK_RUN: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      executionPayload: ProdTaskRunExecutionPayload
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      attemptId: z.string()
+    })
+  },
+  REQUEST_EXIT: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  },
+  READY_FOR_RETRY: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      runId: z.string()
+    })
   }
 };
-__name(_RateLimitError, "RateLimitError");
-var RateLimitError = _RateLimitError;
-var _InternalServerError = class _InternalServerError extends APIError {
-};
-__name(_InternalServerError, "InternalServerError");
-var InternalServerError = _InternalServerError;
-function castToError(err) {
-  if (err instanceof Error)
-    return err;
-  return new Error(err);
-}
-__name(castToError, "castToError");
-
-// src/retry.ts
-function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return;
-  switch (format) {
-    case "iso_8601_duration_openai_variant": {
-      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
-    }
-    case "iso_8601": {
-      return calculateISO8601ResetAt(resets, now);
-    }
-    case "unix_timestamp": {
-      return calculateUnixTimestampResetAt(resets, now);
-    }
-    case "unix_timestamp_in_ms": {
-      return calculateUnixTimestampInMsResetAt(resets, now);
-    }
-  }
-}
-__name(calculateResetAt, "calculateResetAt");
-function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = parseInt(resets, 10);
-  if (isNaN(resetAt))
-    return void 0;
-  return new Date(resetAt * 1e3);
-}
-__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
-function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = parseInt(resets, 10);
-  if (isNaN(resetAt))
-    return void 0;
-  return new Date(resetAt);
-}
-__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
-function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = new Date(resets);
-  if (isNaN(resetAt.getTime()))
-    return void 0;
-  return resetAt;
-}
-__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
-function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
-  const match = resets.match(pattern);
-  if (!match)
-    return void 0;
-  const days = parseInt(match[1], 10) || 0;
-  const hours = parseInt(match[2], 10) || 0;
-  const minutes = parseInt(match[3], 10) || 0;
-  const seconds = parseFloat(match[4]) || 0;
-  const milliseconds = parseInt(match[5], 10) || 0;
-  const resetAt = new Date(now);
-  resetAt.setDate(resetAt.getDate() + days);
-  resetAt.setHours(resetAt.getHours() + hours);
-  resetAt.setMinutes(resetAt.getMinutes() + minutes);
-  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
-  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
-  return resetAt;
-}
-__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
-
-// src/v3/utils/retries.ts
-var defaultRetryOptions = {
-  maxAttempts: 3,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
-};
-var defaultFetchRetryOptions = {
-  byStatus: {
-    "429,408,409,5xx": {
-      strategy: "backoff",
-      ...defaultRetryOptions
-    }
-  },
-  connectionError: defaultRetryOptions,
-  timeout: defaultRetryOptions
-};
-function calculateNextRetryDelay(options, attempt) {
-  const opts = {
-    ...defaultRetryOptions,
-    ...options
-  };
-  if (attempt >= opts.maxAttempts) {
-    return;
-  }
-  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
-  const random = randomize ? Math.random() + 1 : 1;
-  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
-  return Math.round(timeout);
-}
-__name(calculateNextRetryDelay, "calculateNextRetryDelay");
-function calculateResetAt2(resets, format, now = Date.now()) {
-  const resetAt = calculateResetAt(resets, format, new Date(now));
-  return resetAt?.getTime();
-}
-__name(calculateResetAt2, "calculateResetAt");
+var ProdWorkerSocketData = z.object({
+  contentHash: z.string(),
+  projectRef: z.string(),
+  envId: z.string(),
+  runId: z.string(),
+  attemptFriendlyId: z.string().optional(),
+  podName: z.string(),
+  deploymentId: z.string(),
+  deploymentVersion: z.string()
+});
+var PRIMARY_VARIANT = "primary";
+var Variant = z.enum([
+  PRIMARY_VARIANT
+]);
+var AccessoryItem = z.object({
+  text: z.string(),
+  variant: z.string().optional(),
+  url: z.string().optional()
+});
+var Accessory = z.object({
+  items: z.array(AccessoryItem),
+  style: z.enum([
+    "codepath"
+  ]).optional()
+});
+var TaskEventStyle = z.object({
+  icon: z.string().optional(),
+  variant: Variant.optional(),
+  accessory: Accessory.optional()
+}).default({
+  icon: void 0,
+  variant: void 0
+});
+var stringPatternMatchers = [
+  z.object({
+    $endsWith: z.string()
+  }),
+  z.object({
+    $startsWith: z.string()
+  }),
+  z.object({
+    $ignoreCaseEquals: z.string()
+  })
+];
+var EventMatcher = z.union([
+  /** Match against a string */
+  z.array(z.string()),
+  /** Match against a number */
+  z.array(z.number()),
+  /** Match against a boolean */
+  z.array(z.boolean()),
+  z.array(z.union([
+    ...stringPatternMatchers,
+    z.object({
+      $exists: z.boolean()
+    }),
+    z.object({
+      $isNull: z.boolean()
+    }),
+    z.object({
+      $anythingBut: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+      ])
+    }),
+    z.object({
+      $anythingBut: z.union([
+        z.array(z.string()),
+        z.array(z.number()),
+        z.array(z.boolean())
+      ])
+    }),
+    z.object({
+      $gt: z.number()
+    }),
+    z.object({
+      $lt: z.number()
+    }),
+    z.object({
+      $gte: z.number()
+    }),
+    z.object({
+      $lte: z.number()
+    }),
+    z.object({
+      $between: z.tuple([
+        z.number(),
+        z.number()
+      ])
+    }),
+    z.object({
+      $includes: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+      ])
+    }),
+    z.object({
+      $not: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+      ])
+    })
+  ]))
+]);
+var EventFilter = z.lazy(() => z.record(z.union([
+  EventMatcher,
+  EventFilter
+])));
 
-// src/v3/zodfetch.ts
-var defaultRetryOptions2 = {
-  maxAttempts: 3,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: false
-};
-async function zodfetch(schema, url, requestInit, options) {
-  return await _doZodFetch(schema, url, requestInit, options);
-}
-__name(zodfetch, "zodfetch");
-async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
-  try {
-    const response = await fetch(url, requestInitWithCache(requestInit));
-    const responseHeaders = createResponseHeaders(response.headers);
-    if (!response.ok) {
-      const retryResult = shouldRetry(response, attempt, options?.retry);
-      if (retryResult.retry) {
-        await new Promise((resolve) => setTimeout(resolve, retryResult.delay));
-        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
-      } else {
-        const errText = await response.text().catch((e) => castToError2(e).message);
-        const errJSON = safeJsonParse(errText);
-        const errMessage = errJSON ? void 0 : errText;
-        throw APIError.generate(response.status, errJSON, errMessage, responseHeaders);
-      }
-    }
-    const jsonBody = await response.json();
-    const parsedResult = schema.safeParse(jsonBody);
-    if (parsedResult.success) {
-      return parsedResult.data;
-    }
-    throw fromZodError(parsedResult.error);
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    if (options?.retry) {
-      const retry = {
-        ...defaultRetryOptions2,
-        ...options.retry
-      };
-      const delay = calculateNextRetryDelay(retry, attempt);
-      if (delay) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
-      }
-    }
-    throw new APIConnectionError({
-      cause: castToError2(error)
-    });
-  }
-}
-__name(_doZodFetch, "_doZodFetch");
-function castToError2(err) {
-  if (err instanceof Error)
-    return err;
-  return new Error(err);
-}
-__name(castToError2, "castToError");
-function shouldRetry(response, attempt, retryOptions) {
-  function shouldRetryForOptions() {
-    const retry = {
-      ...defaultRetryOptions2,
-      ...retryOptions
-    };
-    const delay = calculateNextRetryDelay(retry, attempt);
-    if (delay) {
-      return {
-        retry: true,
-        delay
-      };
-    } else {
-      return {
-        retry: false
-      };
-    }
-  }
-  __name(shouldRetryForOptions, "shouldRetryForOptions");
-  const shouldRetryHeader = response.headers.get("x-should-retry");
-  if (shouldRetryHeader === "true")
-    return shouldRetryForOptions();
-  if (shouldRetryHeader === "false")
-    return {
-      retry: false
-    };
-  if (response.status === 408)
-    return shouldRetryForOptions();
-  if (response.status === 409)
-    return shouldRetryForOptions();
-  if (response.status === 429)
-    return shouldRetryForOptions();
-  if (response.status >= 500)
-    return shouldRetryForOptions();
-  return {
-    retry: false
-  };
-}
-__name(shouldRetry, "shouldRetry");
-function safeJsonParse(text) {
-  try {
-    return JSON.parse(text);
-  } catch (e) {
-    return void 0;
-  }
-}
-__name(safeJsonParse, "safeJsonParse");
-function createResponseHeaders(headers) {
-  return new Proxy(Object.fromEntries(
-    // @ts-ignore
-    headers.entries()
-  ), {
-    get(target, name) {
-      const key = name.toString();
-      return target[key.toLowerCase()] || target[key];
-    }
-  });
+// 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(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(isExceptionSpanEvent, "isExceptionSpanEvent");
+function isCancellationSpanEvent(event) {
+  return event.name === "cancellation";
 }
-__name(requestInitWithCache, "requestInitWithCache");
+__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/flattenAttributes.ts
-function flattenAttributes(obj, prefix) {
-  const result = {};
-  if (!obj) {
-    return result;
-  }
-  if (typeof obj === "string") {
-    result[prefix || ""] = obj;
-    return result;
-  }
-  if (typeof obj === "number") {
-    result[prefix || ""] = obj;
-    return result;
-  }
-  if (typeof obj === "boolean") {
-    result[prefix || ""] = obj;
-    return result;
-  }
-  for (const [key, value] of Object.entries(obj)) {
-    const newPrefix = `${prefix ? `${prefix}.` : ""}${key}`;
-    if (Array.isArray(value)) {
-      for (let i = 0; i < value.length; i++) {
-        if (typeof value[i] === "object" && value[i] !== null) {
-          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
-        } else {
-          result[`${newPrefix}.[${i}]`] = value[i];
-        }
-      }
-    } else if (isRecord(value)) {
-      Object.assign(result, flattenAttributes(value, newPrefix));
-    } else {
-      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
-        result[newPrefix] = value;
-      }
-    }
-  }
-  return result;
-}
-__name(flattenAttributes, "flattenAttributes");
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-__name(isRecord, "isRecord");
-function unflattenAttributes(obj) {
-  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
-    return obj;
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const parts = key.split(".").reduce((acc, part) => {
-      if (detectIsArrayIndex(part)) {
-        acc.push(part);
-      } else {
-        acc.push(...part.split(/\.\[(.*?)\]/).filter(Boolean));
-      }
-      return acc;
-    }, []);
-    let current = result;
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i];
-      const isArray = detectIsArrayIndex(part);
-      const cleanPart = isArray ? part.substring(1, part.length - 1) : part;
-      const nextIsArray = detectIsArrayIndex(parts[i + 1]);
-      if (!current[cleanPart]) {
-        current[cleanPart] = nextIsArray ? [] : {};
-      }
-      current = current[cleanPart];
-    }
-    const lastPart = parts[parts.length - 1];
-    const cleanLastPart = detectIsArrayIndex(lastPart) ? parseInt(lastPart.substring(1, lastPart.length - 1), 10) : lastPart;
-    current[cleanLastPart] = value;
+// 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;
   }
-  return result;
+  api[type] = instance;
+  return true;
 }
-__name(unflattenAttributes, "unflattenAttributes");
-function detectIsArrayIndex(key) {
-  const match = key.match(/^\[(\d+)\]$/);
-  if (match) {
-    return true;
-  }
-  return false;
+__name(registerGlobal, "registerGlobal");
+function getGlobal(type) {
+  return _global[GLOBAL_TRIGGER_DOT_DEV_KEY]?.[type];
 }
-__name(detectIsArrayIndex, "detectIsArrayIndex");
-function primitiveValueOrflattenedAttributes(obj, prefix) {
-  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || obj === void 0) {
-    return obj;
-  }
-  const attributes = flattenAttributes(obj, prefix);
-  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
-    return attributes[prefix];
+__name(getGlobal, "getGlobal");
+function unregisterGlobal(type) {
+  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY];
+  if (api) {
+    delete api[type];
   }
-  return attributes;
 }
-__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
-var _SafeAsyncLocalStorage = class _SafeAsyncLocalStorage {
-  constructor() {
-    this.storage = new AsyncLocalStorage();
-  }
-  runWith(context3, fn) {
-    return this.storage.run(context3, fn);
-  }
-  getStore() {
-    return this.storage.getStore();
-  }
-};
-__name(_SafeAsyncLocalStorage, "SafeAsyncLocalStorage");
-var SafeAsyncLocalStorage = _SafeAsyncLocalStorage;
+__name(unregisterGlobal, "unregisterGlobal");
 
 // src/v3/semanticInternalAttributes.ts
 var SemanticInternalAttributes = {
@@ -2046,23 +1957,27 @@ var SemanticInternalAttributes = {
   IDEMPOTENCY_KEY: "ctx.run.idempotencyKey"
 };
 
-// src/v3/tasks/taskContextManager.ts
-var _getStore, getStore_fn;
-var _TaskContextManager = class _TaskContextManager {
+// src/v3/taskContext/index.ts
+var API_NAME = "task-context";
+var _getTaskContext, getTaskContext_fn;
+var _TaskContextAPI = class _TaskContextAPI {
   constructor() {
-    __privateAdd(this, _getStore);
-    __publicField(this, "_storage", new SafeAsyncLocalStorage());
+    __privateAdd(this, _getTaskContext);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _TaskContextAPI();
+    }
+    return this._instance;
   }
   get isInsideTask() {
-    return __privateMethod(this, _getStore, getStore_fn).call(this) !== void 0;
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this) !== void 0;
   }
   get ctx() {
-    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
-    return store?.ctx;
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.ctx;
   }
   get worker() {
-    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
-    return store?.worker;
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.worker;
   }
   get attributes() {
     if (this.ctx) {
@@ -2108,66 +2023,22 @@ var _TaskContextManager = class _TaskContextManager {
     }
     return {};
   }
-  runWith(context3, fn) {
-    return this._storage.runWith(context3, fn);
-  }
-};
-_getStore = new WeakSet();
-getStore_fn = /* @__PURE__ */ __name(function() {
-  return this._storage.getStore();
-}, "#getStore");
-__name(_TaskContextManager, "TaskContextManager");
-var TaskContextManager = _TaskContextManager;
-var taskContextManager = new TaskContextManager();
-var _TaskContextSpanProcessor = class _TaskContextSpanProcessor {
-  constructor(innerProcessor) {
-    this._innerProcessor = innerProcessor;
-  }
-  // Called when a span starts
-  onStart(span, parentContext) {
-    if (taskContextManager.ctx) {
-      span.setAttributes(flattenAttributes({
-        [SemanticInternalAttributes.ATTEMPT_ID]: taskContextManager.ctx.attempt.id,
-        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContextManager.ctx.attempt.number
-      }, SemanticInternalAttributes.METADATA));
-    }
-    this._innerProcessor.onStart(span, parentContext);
-  }
-  // Delegate the rest of the methods to the wrapped processor
-  onEnd(span) {
-    this._innerProcessor.onEnd(span);
-  }
-  shutdown() {
-    return this._innerProcessor.shutdown();
-  }
-  forceFlush() {
-    return this._innerProcessor.forceFlush();
-  }
-};
-__name(_TaskContextSpanProcessor, "TaskContextSpanProcessor");
-var TaskContextSpanProcessor = _TaskContextSpanProcessor;
-var _TaskContextLogProcessor = class _TaskContextLogProcessor {
-  constructor(innerProcessor) {
-    this._innerProcessor = innerProcessor;
-  }
-  forceFlush() {
-    return this._innerProcessor.forceFlush();
-  }
-  onEmit(logRecord, context3) {
-    if (taskContextManager.ctx) {
-      logRecord.setAttributes(flattenAttributes({
-        [SemanticInternalAttributes.ATTEMPT_ID]: taskContextManager.ctx.attempt.id,
-        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContextManager.ctx.attempt.number
-      }, SemanticInternalAttributes.METADATA));
-    }
-    this._innerProcessor.onEmit(logRecord, context3);
+  disable() {
+    unregisterGlobal(API_NAME);
   }
-  shutdown() {
-    return this._innerProcessor.shutdown();
+  setGlobalTaskContext(taskContext2) {
+    return registerGlobal(API_NAME, taskContext2);
   }
 };
-__name(_TaskContextLogProcessor, "TaskContextLogProcessor");
-var TaskContextLogProcessor = _TaskContextLogProcessor;
+_getTaskContext = new WeakSet();
+getTaskContext_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME);
+}, "#getTaskContext");
+__name(_TaskContextAPI, "TaskContextAPI");
+var TaskContextAPI = _TaskContextAPI;
+
+// src/v3/task-context-api.ts
+var taskContext = TaskContextAPI.getInstance();
 
 // src/v3/utils/getEnv.ts
 function getEnvVar(name) {
@@ -2176,6 +2047,19 @@ function getEnvVar(name) {
   }
 }
 __name(getEnvVar, "getEnvVar");
+var _SafeAsyncLocalStorage = class _SafeAsyncLocalStorage {
+  constructor() {
+    this.storage = new AsyncLocalStorage();
+  }
+  runWith(context3, fn) {
+    return this.storage.run(context3, fn);
+  }
+  getStore() {
+    return this.storage.getStore();
+  }
+};
+__name(_SafeAsyncLocalStorage, "SafeAsyncLocalStorage");
+var SafeAsyncLocalStorage = _SafeAsyncLocalStorage;
 
 // src/v3/apiClient/index.ts
 var zodFetchOptions = {
@@ -2311,7 +2195,7 @@ getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
     "Content-Type": "application/json",
     Authorization: `Bearer ${this.accessToken}`
   };
-  if (taskContextManager.isInsideTask) {
+  if (taskContext.isInsideTask) {
     propagation.inject(context.active(), headers);
     if (spanParentAsLink) {
       headers["x-trigger-span-parent-as-link"] = "1";
@@ -2321,18 +2205,18 @@ getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
 }, "#getHeaders");
 __name(_ApiClient, "ApiClient");
 var ApiClient = _ApiClient;
-var _getStore2, getStore_fn2;
+var _getStore, getStore_fn;
 var _ApiClientManager = class _ApiClientManager {
   constructor() {
-    __privateAdd(this, _getStore2);
+    __privateAdd(this, _getStore);
     __publicField(this, "_storage", new SafeAsyncLocalStorage());
   }
   get baseURL() {
-    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
+    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
     return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
   }
   get accessToken() {
-    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
+    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
     return store?.accessToken ?? getEnvVar("TRIGGER_SECRET_KEY");
   }
   get client() {
@@ -2345,13 +2229,61 @@ var _ApiClientManager = class _ApiClientManager {
     return this._storage.runWith(context3, fn);
   }
 };
-_getStore2 = new WeakSet();
-getStore_fn2 = /* @__PURE__ */ __name(function() {
+_getStore = new WeakSet();
+getStore_fn = /* @__PURE__ */ __name(function() {
   return this._storage.getStore();
 }, "#getStore");
 __name(_ApiClientManager, "ApiClientManager");
 var ApiClientManager = _ApiClientManager;
 var apiClientManager = new ApiClientManager();
+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();
 function parseError(error) {
   if (error instanceof Error) {
     return {
@@ -2463,261 +2395,146 @@ function groupTaskMetadataIssuesByTask(tasks, issues) {
 }
 __name(groupTaskMetadataIssuesByTask, "groupTaskMetadataIssuesByTask");
 
-// src/v3/utils/platform.ts
-var _globalThis = typeof globalThis === "object" ? globalThis : global;
-
-// src/v3/utils/globals.ts
-var GLOBAL_TRIGGER_DOT_DEV_KEY = Symbol.for(`dev.trigger.ts.api`);
-var _global = _globalThis;
-function registerGlobal(type, instance, allowOverride = false) {
-  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] ?? {};
-  if (!allowOverride && api[type]) {
-    return false;
-  }
-  api[type] = instance;
-  return true;
-}
-__name(registerGlobal, "registerGlobal");
-function getGlobal(type) {
-  return _global[GLOBAL_TRIGGER_DOT_DEV_KEY]?.[type];
-}
-__name(getGlobal, "getGlobal");
-function unregisterGlobal(type) {
-  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY];
-  if (api) {
-    delete api[type];
+// src/v3/limits.ts
+var OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = 256;
+var OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = 256;
+var OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
+var OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
+var OTEL_SPAN_EVENT_COUNT_LIMIT = 10;
+var OTEL_LINK_COUNT_LIMIT = 2;
+var OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = 10;
+var OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = 10;
+var OFFLOAD_IO_PACKET_LENGTH_LIMIT = 128 * 1024;
+function imposeAttributeLimits(attributes) {
+  const newAttributes = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (calculateAttributeValueLength(value) > OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT) {
+      continue;
+    }
+    if (Object.keys(newAttributes).length >= OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT) {
+      break;
+    }
+    newAttributes[key] = value;
   }
+  return newAttributes;
 }
-__name(unregisterGlobal, "unregisterGlobal");
-
-// src/v3/runtime/noopRuntimeManager.ts
-var _NoopRuntimeManager = class _NoopRuntimeManager {
-  disable() {
+__name(imposeAttributeLimits, "imposeAttributeLimits");
+function calculateAttributeValueLength(value) {
+  if (value === void 0 || value === null) {
+    return 0;
   }
-  waitForDuration(ms) {
-    return Promise.resolve();
+  if (typeof value === "string") {
+    return value.length;
   }
-  waitUntil(date) {
-    return Promise.resolve();
+  if (typeof value === "number") {
+    return 8;
   }
-  waitForTask(params) {
-    return Promise.resolve({
-      ok: false,
-      id: params.id,
-      error: {
-        type: "INTERNAL_ERROR",
-        code: "CONFIGURED_INCORRECTLY"
-      }
-    });
+  if (typeof value === "boolean") {
+    return 4;
   }
-  waitForBatch(params) {
-    return Promise.resolve({
-      id: params.id,
-      items: []
-    });
+  if (Array.isArray(value)) {
+    return value.reduce((acc, v) => acc + calculateAttributeValueLength(v), 0);
   }
-};
-__name(_NoopRuntimeManager, "NoopRuntimeManager");
-var NoopRuntimeManager = _NoopRuntimeManager;
+  return 0;
+}
+__name(calculateAttributeValueLength, "calculateAttributeValueLength");
 
-// src/v3/runtime/index.ts
-var API_NAME = "runtime";
-var NOOP_RUNTIME_MANAGER = new NoopRuntimeManager();
-var _getRuntimeManager, getRuntimeManager_fn;
-var _RuntimeAPI = class _RuntimeAPI {
-  constructor() {
-    __privateAdd(this, _getRuntimeManager);
-  }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _RuntimeAPI();
-    }
-    return this._instance;
-  }
-  waitForDuration(ms) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForDuration(ms);
-  }
-  waitUntil(date) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitUntil(date);
-  }
-  waitForTask(params) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForTask(params);
+// src/v3/utils/flattenAttributes.ts
+function flattenAttributes(obj, prefix) {
+  const result = {};
+  if (!obj) {
+    return result;
   }
-  waitForBatch(params) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForBatch(params);
+  if (typeof obj === "string") {
+    result[prefix || ""] = obj;
+    return result;
   }
-  setGlobalRuntimeManager(runtimeManager) {
-    return registerGlobal(API_NAME, runtimeManager);
+  if (typeof obj === "number") {
+    result[prefix || ""] = obj;
+    return result;
   }
-  disable() {
-    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
-    unregisterGlobal(API_NAME);
+  if (typeof obj === "boolean") {
+    result[prefix || ""] = obj;
+    return result;
   }
-};
-_getRuntimeManager = new WeakSet();
-getRuntimeManager_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME) ?? NOOP_RUNTIME_MANAGER;
-}, "#getRuntimeManager");
-__name(_RuntimeAPI, "RuntimeAPI");
-var RuntimeAPI = _RuntimeAPI;
-
-// src/v3/runtime-api.ts
-var runtime = RuntimeAPI.getInstance();
-function iconStringForSeverity(severityNumber) {
-  switch (severityNumber) {
-    case SeverityNumber.UNSPECIFIED:
-      return void 0;
-    case SeverityNumber.TRACE:
-    case SeverityNumber.TRACE2:
-    case SeverityNumber.TRACE3:
-    case SeverityNumber.TRACE4:
-      return "trace";
-    case SeverityNumber.DEBUG:
-    case SeverityNumber.DEBUG2:
-    case SeverityNumber.DEBUG3:
-    case SeverityNumber.DEBUG4:
-      return "debug";
-    case SeverityNumber.INFO:
-    case SeverityNumber.INFO2:
-    case SeverityNumber.INFO3:
-    case SeverityNumber.INFO4:
-      return "info";
-    case SeverityNumber.WARN:
-    case SeverityNumber.WARN2:
-    case SeverityNumber.WARN3:
-    case SeverityNumber.WARN4:
-      return "warn";
-    case SeverityNumber.ERROR:
-    case SeverityNumber.ERROR2:
-    case SeverityNumber.ERROR3:
-    case SeverityNumber.ERROR4:
-      return "error";
-    case SeverityNumber.FATAL:
-    case SeverityNumber.FATAL2:
-    case SeverityNumber.FATAL3:
-    case SeverityNumber.FATAL4:
-      return "fatal";
+  for (const [key, value] of Object.entries(obj)) {
+    const newPrefix = `${prefix ? `${prefix}.` : ""}${key}`;
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        if (typeof value[i] === "object" && value[i] !== null) {
+          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
+        } else {
+          result[`${newPrefix}.[${i}]`] = value[i];
+        }
+      }
+    } else if (isRecord(value)) {
+      Object.assign(result, flattenAttributes(value, newPrefix));
+    } else {
+      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+        result[newPrefix] = value;
+      }
+    }
   }
+  return result;
 }
-__name(iconStringForSeverity, "iconStringForSeverity");
-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);
+__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;
   }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _ClockAPI();
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const parts = key.split(".").reduce((acc, part) => {
+      if (detectIsArrayIndex(part)) {
+        acc.push(part);
+      } else {
+        acc.push(...part.split(/\.\[(.*?)\]/).filter(Boolean));
+      }
+      return acc;
+    }, []);
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      const isArray = detectIsArrayIndex(part);
+      const cleanPart = isArray ? part.substring(1, part.length - 1) : part;
+      const nextIsArray = detectIsArrayIndex(parts[i + 1]);
+      if (!current[cleanPart]) {
+        current[cleanPart] = nextIsArray ? [] : {};
+      }
+      current = current[cleanPart];
     }
-    return this._instance;
-  }
-  setGlobalClock(clock2) {
-    return registerGlobal(API_NAME2, clock2);
-  }
-  preciseNow() {
-    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
-  }
-  reset() {
-    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
-  }
-};
-_getClock = new WeakSet();
-getClock_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME2) ?? SIMPLE_CLOCK;
-}, "#getClock");
-__name(_ClockAPI, "ClockAPI");
-var ClockAPI = _ClockAPI;
-
-// src/v3/clock-api.ts
-var clock = ClockAPI.getInstance();
-
-// src/v3/logger/taskLogger.ts
-var logLevels = [
-  "none",
-  "error",
-  "warn",
-  "log",
-  "info",
-  "debug"
-];
-var _emitLog, emitLog_fn, _getTimestampInHrTime, getTimestampInHrTime_fn;
-var _OtelTaskLogger = class _OtelTaskLogger {
-  constructor(_config) {
-    __privateAdd(this, _emitLog);
-    __privateAdd(this, _getTimestampInHrTime);
-    this._config = _config;
-    this._level = logLevels.indexOf(_config.level);
-  }
-  debug(message, properties) {
-    if (this._level < 5)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "debug", SeverityNumber.DEBUG, properties);
-  }
-  log(message, properties) {
-    if (this._level < 3)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "log", SeverityNumber.INFO, properties);
-  }
-  info(message, properties) {
-    if (this._level < 4)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "info", SeverityNumber.INFO, properties);
+    const lastPart = parts[parts.length - 1];
+    const cleanLastPart = detectIsArrayIndex(lastPart) ? parseInt(lastPart.substring(1, lastPart.length - 1), 10) : lastPart;
+    current[cleanLastPart] = value;
   }
-  warn(message, properties) {
-    if (this._level < 2)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "warn", SeverityNumber.WARN, properties);
+  return result;
+}
+__name(unflattenAttributes, "unflattenAttributes");
+function detectIsArrayIndex(key) {
+  const match = key.match(/^\[(\d+)\]$/);
+  if (match) {
+    return true;
   }
-  error(message, properties) {
-    if (this._level < 1)
-      return;
-    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "error", SeverityNumber.ERROR, properties);
+  return false;
+}
+__name(detectIsArrayIndex, "detectIsArrayIndex");
+function primitiveValueOrflattenedAttributes(obj, prefix) {
+  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || obj === void 0) {
+    return obj;
   }
-  trace(name, fn, options) {
-    return this._config.tracer.startActiveSpan(name, fn, options);
+  const attributes = flattenAttributes(obj, prefix);
+  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
+    return attributes[prefix];
   }
-};
-_emitLog = new WeakSet();
-emitLog_fn = /* @__PURE__ */ __name(function(message, timestamp, severityText, severityNumber, properties) {
-  let attributes = {
-    ...flattenAttributes(safeJsonProcess(properties))
-  };
-  const icon = iconStringForSeverity(severityNumber);
-  if (icon !== void 0) {
-    attributes[SemanticInternalAttributes.STYLE_ICON] = icon;
-  }
-  this._config.logger.emit({
-    severityNumber,
-    severityText,
-    body: message,
-    attributes,
-    timestamp
-  });
-}, "#emitLog");
-_getTimestampInHrTime = new WeakSet();
-getTimestampInHrTime_fn = /* @__PURE__ */ __name(function() {
-  return clock.preciseNow();
-}, "#getTimestampInHrTime");
-__name(_OtelTaskLogger, "OtelTaskLogger");
-var OtelTaskLogger = _OtelTaskLogger;
+  return attributes;
+}
+__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
+
+// src/v3/logger/taskLogger.ts
 var _NoopTaskLogger = class _NoopTaskLogger {
   debug() {
   }
@@ -2735,25 +2552,6 @@ var _NoopTaskLogger = class _NoopTaskLogger {
 };
 __name(_NoopTaskLogger, "NoopTaskLogger");
 var NoopTaskLogger = _NoopTaskLogger;
-function safeJsonProcess(value) {
-  try {
-    return JSON.parse(JSON.stringify(value, jsonErrorReplacer));
-  } catch {
-    return value;
-  }
-}
-__name(safeJsonProcess, "safeJsonProcess");
-function jsonErrorReplacer(key, value) {
-  if (value instanceof Error) {
-    return {
-      name: value.name,
-      message: value.message,
-      stack: value.stack
-    };
-  }
-  return value;
-}
-__name(jsonErrorReplacer, "jsonErrorReplacer");
 
 // src/v3/logger/index.ts
 var API_NAME3 = "logger";
@@ -2804,6 +2602,80 @@ 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/runtime/index.ts
+var API_NAME4 = "runtime";
+var NOOP_RUNTIME_MANAGER = new NoopRuntimeManager();
+var _getRuntimeManager, getRuntimeManager_fn;
+var _RuntimeAPI = class _RuntimeAPI {
+  constructor() {
+    __privateAdd(this, _getRuntimeManager);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _RuntimeAPI();
+    }
+    return this._instance;
+  }
+  waitForDuration(ms) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForDuration(ms);
+  }
+  waitUntil(date) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitUntil(date);
+  }
+  waitForTask(params) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForTask(params);
+  }
+  waitForBatch(params) {
+    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).waitForBatch(params);
+  }
+  setGlobalRuntimeManager(runtimeManager) {
+    return registerGlobal(API_NAME4, runtimeManager);
+  }
+  disable() {
+    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
+    unregisterGlobal(API_NAME4);
+  }
+};
+_getRuntimeManager = new WeakSet();
+getRuntimeManager_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME4) ?? NOOP_RUNTIME_MANAGER;
+}, "#getRuntimeManager");
+__name(_RuntimeAPI, "RuntimeAPI");
+var RuntimeAPI = _RuntimeAPI;
+
+// src/v3/runtime-api.ts
+var runtime = RuntimeAPI.getInstance();
+
 // src/v3/task-catalog/noopTaskCatalog.ts
 var _NoopTaskCatalog = class _NoopTaskCatalog {
   registerTaskMetadata(task) {
@@ -2828,7 +2700,7 @@ __name(_NoopTaskCatalog, "NoopTaskCatalog");
 var NoopTaskCatalog = _NoopTaskCatalog;
 
 // src/v3/task-catalog/index.ts
-var API_NAME4 = "task-catalog";
+var API_NAME5 = "task-catalog";
 var NOOP_TASK_CATALOG = new NoopTaskCatalog();
 var _getCatalog, getCatalog_fn;
 var _TaskCatalogAPI = class _TaskCatalogAPI {
@@ -2842,10 +2714,10 @@ var _TaskCatalogAPI = class _TaskCatalogAPI {
     return this._instance;
   }
   setGlobalTaskCatalog(taskCatalog2) {
-    return registerGlobal(API_NAME4, taskCatalog2);
+    return registerGlobal(API_NAME5, taskCatalog2);
   }
   disable() {
-    unregisterGlobal(API_NAME4);
+    unregisterGlobal(API_NAME5);
   }
   registerTaskMetadata(task) {
     __privateMethod(this, _getCatalog, getCatalog_fn).call(this).registerTaskMetadata(task);
@@ -2868,57 +2740,13 @@ var _TaskCatalogAPI = class _TaskCatalogAPI {
 };
 _getCatalog = new WeakSet();
 getCatalog_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME4) ?? NOOP_TASK_CATALOG;
+  return getGlobal(API_NAME5) ?? NOOP_TASK_CATALOG;
 }, "#getCatalog");
 __name(_TaskCatalogAPI, "TaskCatalogAPI");
 var TaskCatalogAPI = _TaskCatalogAPI;
 
 // src/v3/task-catalog-api.ts
 var taskCatalog = TaskCatalogAPI.getInstance();
-
-// src/v3/limits.ts
-var OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = 256;
-var OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = 256;
-var OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
-var OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
-var OTEL_SPAN_EVENT_COUNT_LIMIT = 10;
-var OTEL_LINK_COUNT_LIMIT = 2;
-var OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = 10;
-var OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = 10;
-var OFFLOAD_IO_PACKET_LENGTH_LIMIT = 128 * 1024;
-function imposeAttributeLimits(attributes) {
-  const newAttributes = {};
-  for (const [key, value] of Object.entries(attributes)) {
-    if (calculateAttributeValueLength(value) > OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT) {
-      continue;
-    }
-    if (Object.keys(newAttributes).length >= OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT) {
-      break;
-    }
-    newAttributes[key] = value;
-  }
-  return newAttributes;
-}
-__name(imposeAttributeLimits, "imposeAttributeLimits");
-function calculateAttributeValueLength(value) {
-  if (value === void 0 || value === null) {
-    return 0;
-  }
-  if (typeof value === "string") {
-    return value.length;
-  }
-  if (typeof value === "number") {
-    return 8;
-  }
-  if (typeof value === "boolean") {
-    return 4;
-  }
-  if (Array.isArray(value)) {
-    return value.reduce((acc, v) => acc + calculateAttributeValueLength(v), 0);
-  }
-  return 0;
-}
-__name(calculateAttributeValueLength, "calculateAttributeValueLength");
 function dateDifference(date1, date2) {
   return Math.abs(date1.getTime() - date2.getTime());
 }
@@ -3064,146 +2892,6 @@ var _TriggerTracer = class _TriggerTracer {
 };
 __name(_TriggerTracer, "TriggerTracer");
 var TriggerTracer = _TriggerTracer;
-var _handleLog, handleLog_fn, _getTimestampInHrTime2, getTimestampInHrTime_fn2, _getAttributes, getAttributes_fn;
-var _ConsoleInterceptor = class _ConsoleInterceptor {
-  constructor(logger2, sendToStdIO) {
-    __privateAdd(this, _handleLog);
-    __privateAdd(this, _getTimestampInHrTime2);
-    __privateAdd(this, _getAttributes);
-    this.logger = logger2;
-    this.sendToStdIO = sendToStdIO;
-  }
-  // Intercept the console and send logs to the OpenTelemetry logger
-  // during the execution of the callback
-  async intercept(console, callback) {
-    const originalConsole = {
-      log: console.log,
-      info: console.info,
-      warn: console.warn,
-      error: console.error,
-      debug: console.debug
-    };
-    console.log = this.log.bind(this);
-    console.info = this.info.bind(this);
-    console.warn = this.warn.bind(this);
-    console.error = this.error.bind(this);
-    console.debug = this.debug.bind(this);
-    try {
-      return await callback();
-    } finally {
-      console.log = originalConsole.log;
-      console.info = originalConsole.info;
-      console.warn = originalConsole.warn;
-      console.error = originalConsole.error;
-      console.debug = originalConsole.debug;
-    }
-  }
-  debug(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.DEBUG, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Debug", ...args);
-  }
-  log(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Log", ...args);
-  }
-  info(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Info", ...args);
-  }
-  warn(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.WARN, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Warn", ...args);
-  }
-  error(...args) {
-    __privateMethod(this, _handleLog, handleLog_fn).call(this, SeverityNumber.ERROR, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Error", ...args);
-  }
-};
-_handleLog = new WeakSet();
-handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, timestamp, severityText, ...args) {
-  const body = util.format(...args);
-  if (this.sendToStdIO) {
-    if (severityNumber === SeverityNumber.ERROR) {
-      process.stderr.write(body);
-    } else {
-      process.stdout.write(body);
-    }
-  }
-  const parsed = tryParseJSON(body);
-  if (parsed.ok) {
-    this.logger.emit({
-      severityNumber,
-      severityText,
-      body: getLogMessage(parsed.value, severityText),
-      attributes: {
-        ...__privateMethod(this, _getAttributes, getAttributes_fn).call(this, severityNumber),
-        ...flattenAttributes(parsed.value)
-      },
-      timestamp
-    });
-    return;
-  }
-  this.logger.emit({
-    severityNumber,
-    severityText,
-    body,
-    attributes: __privateMethod(this, _getAttributes, getAttributes_fn).call(this, severityNumber),
-    timestamp
-  });
-}, "#handleLog");
-_getTimestampInHrTime2 = new WeakSet();
-getTimestampInHrTime_fn2 = /* @__PURE__ */ __name(function() {
-  return clock.preciseNow();
-}, "#getTimestampInHrTime");
-_getAttributes = new WeakSet();
-getAttributes_fn = /* @__PURE__ */ __name(function(severityNumber1) {
-  const icon = iconStringForSeverity(severityNumber1);
-  let result = {};
-  if (icon !== void 0) {
-    result[SemanticInternalAttributes.STYLE_ICON] = icon;
-  }
-  return result;
-}, "#getAttributes");
-__name(_ConsoleInterceptor, "ConsoleInterceptor");
-var ConsoleInterceptor = _ConsoleInterceptor;
-function getLogMessage(value, fallback) {
-  if (typeof value["message"] === "string") {
-    return value["message"];
-  }
-  if (typeof value["msg"] === "string") {
-    return value["msg"];
-  }
-  if (typeof value["body"] === "string") {
-    return value["body"];
-  }
-  if (typeof value["error"] === "string") {
-    return value["error"];
-  }
-  return fallback;
-}
-__name(getLogMessage, "getLogMessage");
-function tryParseJSON(value) {
-  try {
-    const parsed = JSON.parse(value);
-    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-      return {
-        ok: true,
-        value: parsed
-      };
-    }
-    return {
-      ok: false,
-      value
-    };
-  } catch (e) {
-    return {
-      ok: false,
-      value
-    };
-  }
-}
-__name(tryParseJSON, "tryParseJSON");
-
-// src/v3/utils/styleAttributes.ts
-function accessoryAttributes(accessory) {
-  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
-}
-__name(accessoryAttributes, "accessoryAttributes");
 
 // src/eventFilterMatches.ts
 function eventFilterMatches(payload, filter) {
@@ -3373,150 +3061,12 @@ function omit(obj, ...keys) {
   return result;
 }
 __name(omit, "omit");
-var _a;
-var AsyncResourceDetector = (_a = class {
-  constructor() {
-    __publicField(this, "_resolved", false);
-    this._promise = new Promise((resolver) => {
-      this._resolver = resolver;
-    });
-  }
-  detect(_config) {
-    return new Resource({}, this._promise);
-  }
-  resolveWithAttributes(attributes) {
-    if (!this._resolver) {
-      throw new Error("Resolver not available");
-    }
-    if (this._resolved) {
-      return;
-    }
-    this._resolved = true;
-    this._resolver(attributes);
-  }
-}, __name(_a, "AsyncResourceDetector"), _a);
-var _TracingSDK = class _TracingSDK {
-  constructor(config) {
-    this.config = config;
-    this.asyncResourceDetector = new AsyncResourceDetector();
-    setLogLevel(config.diagLogLevel ?? "none");
-    const envResourceAttributesSerialized = getEnvVar("OTEL_RESOURCE_ATTRIBUTES");
-    const envResourceAttributes = envResourceAttributesSerialized ? JSON.parse(envResourceAttributesSerialized) : {};
-    const commonResources = detectResourcesSync({
-      detectors: [
-        this.asyncResourceDetector,
-        processDetectorSync
-      ]
-    }).merge(new Resource({
-      [SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev",
-      [SemanticInternalAttributes.TRIGGER]: true
-    })).merge(config.resource ?? new Resource({})).merge(new Resource(envResourceAttributes));
-    const traceProvider = new NodeTracerProvider({
-      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500,
-      resource: commonResources,
-      spanLimits: {
-        attributeCountLimit: OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
-        attributeValueLengthLimit: OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT,
-        eventCountLimit: OTEL_SPAN_EVENT_COUNT_LIMIT,
-        attributePerEventCountLimit: OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
-        linkCountLimit: OTEL_LINK_COUNT_LIMIT,
-        attributePerLinkCountLimit: OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT
-      }
-    });
-    const spanExporter = new OTLPTraceExporter({
-      url: `${config.url}/v1/traces`,
-      timeoutMillis: config.forceFlushTimeoutMillis ?? 1e3
-    });
-    traceProvider.addSpanProcessor(new TaskContextSpanProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new BatchSpanProcessor(spanExporter, {
-      maxExportBatchSize: parseInt(getEnvVar("OTEL_SPAN_MAX_EXPORT_BATCH_SIZE") ?? "64"),
-      scheduledDelayMillis: parseInt(getEnvVar("OTEL_SPAN_SCHEDULED_DELAY_MILLIS") ?? "200"),
-      exportTimeoutMillis: parseInt(getEnvVar("OTEL_SPAN_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
-      maxQueueSize: parseInt(getEnvVar("OTEL_SPAN_MAX_QUEUE_SIZE") ?? "512")
-    }) : new SimpleSpanProcessor(spanExporter)));
-    traceProvider.register();
-    registerInstrumentations({
-      instrumentations: config.instrumentations ?? [],
-      tracerProvider: traceProvider
-    });
-    const logExporter = new OTLPLogExporter({
-      url: `${config.url}/v1/logs`
-    });
-    const loggerProvider = new LoggerProvider({
-      resource: commonResources,
-      logRecordLimits: {
-        attributeCountLimit: OTEL_LOG_ATTRIBUTE_COUNT_LIMIT,
-        attributeValueLengthLimit: OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT
-      }
-    });
-    loggerProvider.addLogRecordProcessor(new TaskContextLogProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new BatchLogRecordProcessor(logExporter, {
-      maxExportBatchSize: parseInt(getEnvVar("OTEL_LOG_MAX_EXPORT_BATCH_SIZE") ?? "64"),
-      scheduledDelayMillis: parseInt(getEnvVar("OTEL_LOG_SCHEDULED_DELAY_MILLIS") ?? "200"),
-      exportTimeoutMillis: parseInt(getEnvVar("OTEL_LOG_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
-      maxQueueSize: parseInt(getEnvVar("OTEL_LOG_MAX_QUEUE_SIZE") ?? "512")
-    }) : new SimpleLogRecordProcessor(logExporter)));
-    this._logProvider = loggerProvider;
-    this._spanExporter = spanExporter;
-    this._traceProvider = traceProvider;
-    logs.setGlobalLoggerProvider(loggerProvider);
-    this.getLogger = loggerProvider.getLogger.bind(loggerProvider);
-    this.getTracer = traceProvider.getTracer.bind(traceProvider);
-  }
-  async flush() {
-    await this._traceProvider.forceFlush();
-    await this._logProvider.forceFlush();
-  }
-  async shutdown() {
-    await this._traceProvider.shutdown();
-    await this._logProvider.shutdown();
-  }
-};
-__name(_TracingSDK, "TracingSDK");
-var TracingSDK = _TracingSDK;
-function setLogLevel(level) {
-  let diagLogLevel;
-  switch (level) {
-    case "none":
-      diagLogLevel = DiagLogLevel.NONE;
-      break;
-    case "error":
-      diagLogLevel = DiagLogLevel.ERROR;
-      break;
-    case "warn":
-      diagLogLevel = DiagLogLevel.WARN;
-      break;
-    case "info":
-      diagLogLevel = DiagLogLevel.INFO;
-      break;
-    case "debug":
-      diagLogLevel = DiagLogLevel.DEBUG;
-      break;
-    case "verbose":
-      diagLogLevel = DiagLogLevel.VERBOSE;
-      break;
-    case "all":
-      diagLogLevel = DiagLogLevel.ALL;
-      break;
-    default:
-      diagLogLevel = DiagLogLevel.NONE;
-  }
-  diag.setLogger(new DiagConsoleLogger(), diagLogLevel);
-}
-__name(setLogLevel, "setLogLevel");
 
-// src/v3/otel/index.ts
-function recordSpanException(span, error) {
-  if (error instanceof Error) {
-    span.recordException(error);
-  } else if (typeof error === "string") {
-    span.recordException(new Error(error));
-  } else {
-    span.recordException(new Error(JSON.stringify(error)));
-  }
-  span.setStatus({
-    code: SpanStatusCode.ERROR
-  });
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
 }
-__name(recordSpanException, "recordSpanException");
+__name(accessoryAttributes, "accessoryAttributes");
 
 // package.json
 var dependencies = {
@@ -3815,94 +3365,6 @@ function safeJsonParse2(value) {
 }
 __name(safeJsonParse2, "safeJsonParse");
 
-// src/v3/task-catalog/standardTaskCatalog.ts
-var _StandardTaskCatalog = class _StandardTaskCatalog {
-  constructor() {
-    __publicField(this, "_taskMetadata", /* @__PURE__ */ new Map());
-    __publicField(this, "_taskFunctions", /* @__PURE__ */ new Map());
-    __publicField(this, "_taskFileMetadata", /* @__PURE__ */ new Map());
-  }
-  registerTaskMetadata(task) {
-    const { fns, ...metadata } = task;
-    this._taskMetadata.set(task.id, metadata);
-    this._taskFunctions.set(task.id, fns);
-  }
-  updateTaskMetadata(id, updates) {
-    const existingMetadata = this._taskMetadata.get(id);
-    if (existingMetadata) {
-      this._taskMetadata.set(id, {
-        ...existingMetadata,
-        ...updates
-      });
-    }
-    if (updates.fns) {
-      const existingFunctions = this._taskFunctions.get(id);
-      if (existingFunctions) {
-        this._taskFunctions.set(id, {
-          ...existingFunctions,
-          ...updates.fns
-        });
-      }
-    }
-  }
-  registerTaskFileMetadata(id, metadata) {
-    this._taskFileMetadata.set(id, metadata);
-  }
-  // Return all the tasks, without the functions
-  getAllTaskMetadata() {
-    const result = [];
-    for (const [id, metadata] of this._taskMetadata) {
-      const fileMetadata = this._taskFileMetadata.get(id);
-      if (!fileMetadata) {
-        continue;
-      }
-      result.push({
-        ...metadata,
-        ...fileMetadata
-      });
-    }
-    return result;
-  }
-  getTaskMetadata(id) {
-    const metadata = this._taskMetadata.get(id);
-    const fileMetadata = this._taskFileMetadata.get(id);
-    if (!metadata || !fileMetadata) {
-      return void 0;
-    }
-    return {
-      ...metadata,
-      ...fileMetadata
-    };
-  }
-  getTask(id) {
-    const metadata = this._taskMetadata.get(id);
-    const fileMetadata = this._taskFileMetadata.get(id);
-    const fns = this._taskFunctions.get(id);
-    if (!metadata || !fns || !fileMetadata) {
-      return void 0;
-    }
-    return {
-      ...metadata,
-      ...fileMetadata,
-      fns
-    };
-  }
-  disable() {
-  }
-};
-__name(_StandardTaskCatalog, "StandardTaskCatalog");
-var StandardTaskCatalog = _StandardTaskCatalog;
-
-// src/v3/index.ts
-function parseTriggerTaskRequestBody(body) {
-  return TriggerTaskRequestBody.safeParse(body);
-}
-__name(parseTriggerTaskRequestBody, "parseTriggerTaskRequestBody");
-function parseBatchTriggerTaskRequestBody(body) {
-  return BatchTriggerTaskRequestBody.safeParse(body);
-}
-__name(parseBatchTriggerTaskRequestBody, "parseBatchTriggerTaskRequestBody");
-
-export { APIConnectionError, APIError, ApiClient, ApiClientManager, AuthenticationError, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BadRequestError, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConflictError, ConsoleInterceptor, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateScheduleOptions, CreateUploadPayloadUrlResponseBody, DeletedScheduleObject, DeploymentErrorData, EnvironmentType, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, InternalServerError, ListScheduleOptions, ListSchedulesResult, Machine, MachineCpu, MachineMemory, 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, OtelTaskLogger, OtherSpanEvent, PRIMARY_VARIANT, PermissionDeniedError, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitError, RateLimitOptions, ReplayRunResponse, RetryOptions, ScheduleObject, ScheduledTaskPayload, SemanticInternalAttributes, SharedQueueToClientMessages, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StandardTaskCatalog, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskContextSpanProcessor, TaskEventStyle, TaskFileMetadata, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TracingSDK, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, UnprocessableEntityError, UpdateScheduleOptions, WaitReason, WhoAmIResponseSchema, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, getEnvVar, groupTaskMetadataIssuesByTask, iconStringForSeverity, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logLevels, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseBatchTriggerTaskRequestBody, parseError, parsePacket, parseTriggerTaskRequestBody, prettyPrintPacket, primitiveValueOrflattenedAttributes, recordSpanException, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskCatalog, taskContextManager, unflattenAttributes, workerToChildMessages };
+export { APIConnectionError, APIError, ApiClient, ApiClientManager, AuthenticationError, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BadRequestError, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConflictError, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateScheduleOptions, CreateUploadPayloadUrlResponseBody, DeletedScheduleObject, DeploymentErrorData, EnvironmentType, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, InternalServerError, ListScheduleOptions, ListSchedulesResult, Machine, MachineCpu, MachineMemory, NotFoundError, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OtherSpanEvent, PRIMARY_VARIANT, PermissionDeniedError, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitError, RateLimitOptions, ReplayRunResponse, RetryOptions, ScheduleObject, ScheduledTaskPayload, SemanticInternalAttributes, SharedQueueToClientMessages, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskEventStyle, TaskFileMetadata, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, UnprocessableEntityError, UpdateScheduleOptions, WaitReason, WhoAmIResponseSchema, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, groupTaskMetadataIssuesByTask, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseError, parsePacket, prettyPrintPacket, primitiveValueOrflattenedAttributes, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskCatalog, taskContext, unflattenAttributes, workerToChildMessages };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map