@trigger.dev/core 3.0.0-beta.16 → 3.0.0-beta.18

package/dist/v3/workers/index.mjs

@@ -0,0 +1,2647 @@
+import { SpanStatusCode, DiagLogLevel, diag, DiagConsoleLogger, propagation, context, SpanKind } from '@opentelemetry/api';
+import 'node:path';
+import { logs, SeverityNumber } from '@opentelemetry/api-logs';
+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';
+import { z } from 'zod';
+import { fromZodError } from 'zod-validation-error';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { PreciseDate } from '@google-cloud/precise-date';
+import util from 'node:util';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+function parseError(error) {
+  if (error instanceof Error) {
+    return {
+      type: "BUILT_IN_ERROR",
+      name: error.name,
+      message: error.message,
+      stackTrace: error.stack ?? ""
+    };
+  }
+  if (typeof error === "string") {
+    return {
+      type: "STRING_ERROR",
+      raw: error
+    };
+  }
+  try {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: JSON.stringify(error)
+    };
+  } catch (e) {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: String(error)
+    };
+  }
+}
+__name(parseError, "parseError");
+
+// 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;
+
+// src/v3/semanticInternalAttributes.ts
+var SemanticInternalAttributes = {
+  ENVIRONMENT_ID: "ctx.environment.id",
+  ENVIRONMENT_TYPE: "ctx.environment.type",
+  ORGANIZATION_ID: "ctx.organization.id",
+  ORGANIZATION_SLUG: "ctx.organization.slug",
+  ORGANIZATION_NAME: "ctx.organization.name",
+  PROJECT_ID: "ctx.project.id",
+  PROJECT_REF: "ctx.project.ref",
+  PROJECT_NAME: "ctx.project.title",
+  PROJECT_DIR: "project.dir",
+  ATTEMPT_ID: "ctx.attempt.id",
+  ATTEMPT_NUMBER: "ctx.attempt.number",
+  RUN_ID: "ctx.run.id",
+  RUN_IS_TEST: "ctx.run.isTest",
+  BATCH_ID: "ctx.batch.id",
+  TASK_SLUG: "ctx.task.id",
+  TASK_PATH: "ctx.task.filePath",
+  TASK_EXPORT_NAME: "ctx.task.exportName",
+  QUEUE_NAME: "ctx.queue.name",
+  QUEUE_ID: "ctx.queue.id",
+  SPAN_PARTIAL: "$span.partial",
+  SPAN_ID: "$span.span_id",
+  OUTPUT: "$output",
+  OUTPUT_TYPE: "$mime_type_output",
+  STYLE: "$style",
+  STYLE_ICON: "$style.icon",
+  STYLE_VARIANT: "$style.variant",
+  STYLE_ACCESSORY: "$style.accessory",
+  METADATA: "$metadata",
+  TRIGGER: "$trigger",
+  PAYLOAD: "$payload",
+  PAYLOAD_TYPE: "$mime_type_payload",
+  SHOW: "$show",
+  SHOW_ACTIONS: "$show.actions",
+  WORKER_ID: "worker.id",
+  WORKER_VERSION: "worker.version",
+  CLI_VERSION: "cli.version",
+  SDK_VERSION: "sdk.version",
+  SDK_LANGUAGE: "sdk.language",
+  RETRY_AT: "retry.at",
+  RETRY_DELAY: "retry.delay",
+  RETRY_COUNT: "retry.count",
+  LINK_TITLE: "$link.title",
+  IDEMPOTENCY_KEY: "ctx.run.idempotencyKey"
+};
+
+// src/v3/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");
+
+// src/v3/utils/platform.ts
+var _globalThis = typeof globalThis === "object" ? globalThis : global;
+
+// src/v3/utils/globals.ts
+var GLOBAL_TRIGGER_DOT_DEV_KEY = Symbol.for(`dev.trigger.ts.api`);
+var _global = _globalThis;
+function registerGlobal(type, instance, allowOverride = false) {
+  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] ?? {};
+  if (!allowOverride && api[type]) {
+    return false;
+  }
+  api[type] = instance;
+  return true;
+}
+__name(registerGlobal, "registerGlobal");
+function getGlobal(type) {
+  return _global[GLOBAL_TRIGGER_DOT_DEV_KEY]?.[type];
+}
+__name(getGlobal, "getGlobal");
+function unregisterGlobal(type) {
+  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+__name(unregisterGlobal, "unregisterGlobal");
+
+// src/v3/taskContext/index.ts
+var API_NAME = "task-context";
+var _getTaskContext, getTaskContext_fn;
+var _TaskContextAPI = class _TaskContextAPI {
+  constructor() {
+    __privateAdd(this, _getTaskContext);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _TaskContextAPI();
+    }
+    return this._instance;
+  }
+  get isInsideTask() {
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this) !== void 0;
+  }
+  get ctx() {
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.ctx;
+  }
+  get worker() {
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.worker;
+  }
+  get attributes() {
+    if (this.ctx) {
+      return {
+        ...this.contextAttributes,
+        ...this.workerAttributes
+      };
+    }
+    return {};
+  }
+  get workerAttributes() {
+    if (this.worker) {
+      return {
+        [SemanticInternalAttributes.WORKER_ID]: this.worker.id,
+        [SemanticInternalAttributes.WORKER_VERSION]: this.worker.version
+      };
+    }
+    return {};
+  }
+  get contextAttributes() {
+    if (this.ctx) {
+      return {
+        [SemanticInternalAttributes.ATTEMPT_ID]: this.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: this.ctx.attempt.number,
+        [SemanticInternalAttributes.TASK_SLUG]: this.ctx.task.id,
+        [SemanticInternalAttributes.TASK_PATH]: this.ctx.task.filePath,
+        [SemanticInternalAttributes.TASK_EXPORT_NAME]: this.ctx.task.exportName,
+        [SemanticInternalAttributes.QUEUE_NAME]: this.ctx.queue.name,
+        [SemanticInternalAttributes.QUEUE_ID]: this.ctx.queue.id,
+        [SemanticInternalAttributes.ENVIRONMENT_ID]: this.ctx.environment.id,
+        [SemanticInternalAttributes.ENVIRONMENT_TYPE]: this.ctx.environment.type,
+        [SemanticInternalAttributes.ORGANIZATION_ID]: this.ctx.organization.id,
+        [SemanticInternalAttributes.PROJECT_ID]: this.ctx.project.id,
+        [SemanticInternalAttributes.PROJECT_REF]: this.ctx.project.ref,
+        [SemanticInternalAttributes.PROJECT_NAME]: this.ctx.project.name,
+        [SemanticInternalAttributes.RUN_ID]: this.ctx.run.id,
+        [SemanticInternalAttributes.RUN_IS_TEST]: this.ctx.run.isTest,
+        [SemanticInternalAttributes.ORGANIZATION_SLUG]: this.ctx.organization.slug,
+        [SemanticInternalAttributes.ORGANIZATION_NAME]: this.ctx.organization.name,
+        [SemanticInternalAttributes.BATCH_ID]: this.ctx.batch?.id,
+        [SemanticInternalAttributes.IDEMPOTENCY_KEY]: this.ctx.run.idempotencyKey
+      };
+    }
+    return {};
+  }
+  disable() {
+    unregisterGlobal(API_NAME);
+  }
+  setGlobalTaskContext(taskContext2) {
+    return registerGlobal(API_NAME, taskContext2);
+  }
+};
+_getTaskContext = new WeakSet();
+getTaskContext_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME);
+}, "#getTaskContext");
+__name(_TaskContextAPI, "TaskContextAPI");
+var TaskContextAPI = _TaskContextAPI;
+
+// src/v3/task-context-api.ts
+var taskContext = TaskContextAPI.getInstance();
+
+// src/v3/taskContext/otelProcessors.ts
+var _TaskContextSpanProcessor = class _TaskContextSpanProcessor {
+  constructor(innerProcessor) {
+    this._innerProcessor = innerProcessor;
+  }
+  // Called when a span starts
+  onStart(span, parentContext) {
+    if (taskContext.ctx) {
+      span.setAttributes(flattenAttributes({
+        [SemanticInternalAttributes.ATTEMPT_ID]: taskContext.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContext.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, context2) {
+    if (taskContext.ctx) {
+      logRecord.setAttributes(flattenAttributes({
+        [SemanticInternalAttributes.ATTEMPT_ID]: taskContext.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContext.ctx.attempt.number
+      }, SemanticInternalAttributes.METADATA));
+    }
+    this._innerProcessor.onEmit(logRecord, context2);
+  }
+  shutdown() {
+    return this._innerProcessor.shutdown();
+  }
+};
+__name(_TaskContextLogProcessor, "TaskContextLogProcessor");
+var TaskContextLogProcessor = _TaskContextLogProcessor;
+
+// src/v3/utils/getEnv.ts
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && typeof process.env === "object" && process.env !== null) {
+    return process.env[name];
+  }
+}
+__name(getEnvVar, "getEnvVar");
+
+// src/v3/otel/tracingSDK.ts
+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
+  });
+}
+__name(recordSpanException, "recordSpanException");
+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()
+  })
+});
+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()
+  })
+]);
+({
+  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()
+});
+({
+  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
+  })
+});
+({
+  EXECUTE_TASK_RUN: z.object({
+    version: z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
+    traceContext: z.record(z.unknown()),
+    metadata: BackgroundWorkerProperties
+  }),
+  TASK_RUN_COMPLETED_NOTIFICATION: z.object({
+    version: z.literal("v1").default("v1"),
+    completion: TaskRunExecutionResult,
+    execution: TaskRunExecution
+  }),
+  CLEANUP: z.object({
+    version: z.literal("v1").default("v1"),
+    flush: z.boolean().default(false),
+    kill: z.boolean().default(true)
+  })
+});
+var FixedWindowRateLimit = z.object({
+  type: z.literal("fixed-window"),
+  limit: z.number(),
+  window: z.union([
+    z.object({
+      seconds: z.number()
+    }),
+    z.object({
+      minutes: z.number()
+    }),
+    z.object({
+      hours: z.number()
+    })
+  ])
+});
+var SlidingWindowRateLimit = z.object({
+  type: z.literal("sliding-window"),
+  limit: z.number(),
+  window: z.union([
+    z.object({
+      seconds: z.number()
+    }),
+    z.object({
+      minutes: z.number()
+    }),
+    z.object({
+      hours: z.number()
+    })
+  ])
+});
+var RateLimitOptions = z.discriminatedUnion("type", [
+  FixedWindowRateLimit,
+  SlidingWindowRateLimit
+]);
+var RetryOptions = z.object({
+  /** The number of attempts before giving up */
+  maxAttempts: z.number().int().optional(),
+  /** The exponential factor to use when calculating the next retry time.
+  *
+  * Each subsequent retry will be calculated as `previousTimeout * factor`
+  */
+  factor: z.number().optional(),
+  /** The minimum time to wait before retrying */
+  minTimeoutInMs: z.number().int().optional(),
+  /** The maximum time to wait before retrying */
+  maxTimeoutInMs: z.number().int().optional(),
+  /** Randomize the timeout between retries.
+  *
+  * This can be useful to prevent the thundering herd problem where all retries happen at the same time.
+  */
+  randomize: z.boolean().optional()
+});
+var QueueOptions = z.object({
+  /** You can define a shared queue and then pass the name in to your task.
+     * 
+     * @example
+     * 
+     * ```ts
+     * const myQueue = queue({
+        name: "my-queue",
+        concurrencyLimit: 1,
+      });
+  
+      export const task1 = task({
+        id: "task-1",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+  
+      export const task2 = task({
+        id: "task-2",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+     * ```
+     */
+  name: z.string().optional(),
+  /** An optional property that specifies the maximum number of concurrent run executions.
+  *
+  * If this property is omitted, the task can potentially use up the full concurrency of an environment. */
+  concurrencyLimit: z.number().int().min(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);
+  })
+});
+({
+  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
+});
+({
+  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
+  }
+});
+({
+  EXECUTE_TASK_RUN: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      traceContext: z.record(z.unknown()),
+      metadata: BackgroundWorkerProperties
+    })
+  },
+  TASK_RUN_COMPLETED_NOTIFICATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      completion: TaskRunExecutionResult,
+      execution: TaskRunExecution
+    })
+  },
+  CLEANUP: {
+    message: z.object({
+      version: z.literal("v1").default("v1"),
+      flush: z.boolean().default(false),
+      kill: z.boolean().default(true)
+    }),
+    callback: z.void()
+  },
+  WAIT_COMPLETED_NOTIFICATION: {
+    message: z.object({
+      version: z.literal("v1").default("v1")
+    })
+  }
+});
+
+// src/v3/schemas/resources.ts
+var TaskResource = z.object({
+  id: z.string(),
+  filePath: z.string(),
+  exportName: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  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)
+});
+z.object({
+  contentHash: z.string(),
+  imageTag: z.string()
+});
+
+// src/v3/schemas/api.ts
+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()
+  })
+});
+z.array(GetProjectResponseBody);
+z.object({
+  apiKey: z.string(),
+  name: z.string(),
+  apiUrl: z.string()
+});
+z.object({
+  localOnly: z.boolean(),
+  metadata: BackgroundWorkerMetadata
+});
+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()
+});
+var TriggerTaskResponse = z.object({
+  id: z.string()
+});
+z.object({
+  items: TriggerTaskRequestBody.array(),
+  dependentAttempt: z.string().optional()
+});
+var BatchTriggerTaskResponse = z.object({
+  batchId: z.string(),
+  runs: z.string().array()
+});
+z.object({
+  id: z.string(),
+  items: z.array(z.object({
+    id: z.string(),
+    taskRunId: z.string(),
+    status: z.enum([
+      "PENDING",
+      "CANCELED",
+      "COMPLETED",
+      "FAILED"
+    ])
+  }))
+});
+z.object({
+  variables: z.record(z.string())
+});
+z.object({
+  imageReference: z.string()
+});
+z.object({
+  id: z.string(),
+  contentHash: z.string()
+});
+var ExternalBuildData = z.object({
+  buildId: z.string(),
+  buildToken: z.string(),
+  projectId: z.string()
+});
+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()
+});
+z.object({
+  contentHash: z.string(),
+  userId: z.string().optional()
+});
+var DeploymentErrorData = z.object({
+  name: z.string(),
+  message: z.string(),
+  stack: z.string().optional()
+});
+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()
+});
+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())
+});
+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 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()
+  })
+});
+z.object({
+  page: z.number().optional(),
+  perPage: z.number().optional()
+});
+
+// src/v3/apiErrors.ts
+var _APIError = class _APIError extends Error {
+  constructor(status, error, message, headers) {
+    super(`${_APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    const data = error;
+    this.error = data;
+    this.code = data?.["code"];
+    this.param = data?.["param"];
+    this.type = data?.["type"];
+  }
+  static makeMessage(status, error, message) {
+    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return "(no status code or body)";
+  }
+  static generate(status, errorResponse, message, headers) {
+    if (!status) {
+      return new APIConnectionError({
+        cause: castToError(errorResponse)
+      });
+    }
+    const error = errorResponse?.["error"];
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+    return new _APIError(status, error, message, headers);
+  }
+};
+__name(_APIError, "APIError");
+var APIError = _APIError;
+var _APIConnectionError = class _APIConnectionError extends APIError {
+  constructor({ message, cause }) {
+    super(void 0, void 0, message || "Connection error.", void 0);
+    __publicField(this, "status");
+    if (cause)
+      this.cause = cause;
+  }
+};
+__name(_APIConnectionError, "APIConnectionError");
+var APIConnectionError = _APIConnectionError;
+var _BadRequestError = class _BadRequestError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 400);
+  }
+};
+__name(_BadRequestError, "BadRequestError");
+var BadRequestError = _BadRequestError;
+var _AuthenticationError = class _AuthenticationError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 401);
+  }
+};
+__name(_AuthenticationError, "AuthenticationError");
+var AuthenticationError = _AuthenticationError;
+var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 403);
+  }
+};
+__name(_PermissionDeniedError, "PermissionDeniedError");
+var PermissionDeniedError = _PermissionDeniedError;
+var _NotFoundError = class _NotFoundError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 404);
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+var NotFoundError = _NotFoundError;
+var _ConflictError = class _ConflictError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 409);
+  }
+};
+__name(_ConflictError, "ConflictError");
+var ConflictError = _ConflictError;
+var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 422);
+  }
+};
+__name(_UnprocessableEntityError, "UnprocessableEntityError");
+var UnprocessableEntityError = _UnprocessableEntityError;
+var _RateLimitError = class _RateLimitError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 429);
+  }
+};
+__name(_RateLimitError, "RateLimitError");
+var RateLimitError = _RateLimitError;
+var _InternalServerError = class _InternalServerError extends APIError {
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+function castToError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError, "castToError");
+
+// src/v3/utils/retries.ts
+var defaultRetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+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");
+
+// 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 _SafeAsyncLocalStorage = class _SafeAsyncLocalStorage {
+  constructor() {
+    this.storage = new AsyncLocalStorage();
+  }
+  runWith(context2, fn) {
+    return this.storage.run(context2, fn);
+  }
+  getStore() {
+    return this.storage.getStore();
+  }
+};
+__name(_SafeAsyncLocalStorage, "SafeAsyncLocalStorage");
+var SafeAsyncLocalStorage = _SafeAsyncLocalStorage;
+
+// src/v3/apiClient/index.ts
+var zodFetchOptions = {
+  retry: {
+    maxAttempts: 3,
+    minTimeoutInMs: 1e3,
+    maxTimeoutInMs: 3e4,
+    factor: 2,
+    randomize: false
+  }
+};
+var _getHeaders, getHeaders_fn;
+var _ApiClient = class _ApiClient {
+  constructor(baseUrl, accessToken) {
+    __privateAdd(this, _getHeaders);
+    this.accessToken = accessToken;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  async getRunResult(runId) {
+    try {
+      return await zodfetch(TaskRunExecutionResult, `${this.baseUrl}/api/v1/runs/${runId}/result`, {
+        method: "GET",
+        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+      }, zodFetchOptions);
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.status === 404) {
+          return void 0;
+        }
+      }
+      throw error;
+    }
+  }
+  async getBatchResults(batchId) {
+    return await zodfetch(BatchTaskRunExecutionResult, `${this.baseUrl}/api/v1/batches/${batchId}/results`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
+  triggerTask(taskId, body, options) {
+    return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
+      body: JSON.stringify(body)
+    }, zodFetchOptions);
+  }
+  batchTriggerTask(taskId, body, options) {
+    return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/batch`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
+      body: JSON.stringify(body)
+    }, zodFetchOptions);
+  }
+  createUploadPayloadUrl(filename) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
+  getPayloadUrl(filename) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
+  replayRun(runId) {
+    return zodfetch(ReplayRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/replay`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
+  cancelRun(runId) {
+    return zodfetch(CanceledRunResponse, `${this.baseUrl}/api/v2/runs/${runId}/cancel`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
+  createSchedule(options) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(options)
+    });
+  }
+  listSchedules(options) {
+    const searchParams = new URLSearchParams();
+    if (options?.page) {
+      searchParams.append("page", options.page.toString());
+    }
+    if (options?.perPage) {
+      searchParams.append("perPage", options.perPage.toString());
+    }
+    return zodfetch(ListSchedulesResult, `${this.baseUrl}/api/v1/schedules${searchParams.size > 0 ? `?${searchParams}` : ""}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  retrieveSchedule(scheduleId) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  updateSchedule(scheduleId, options) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(options)
+    });
+  }
+  deactivateSchedule(scheduleId) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/deactivate`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  activateSchedule(scheduleId) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/activate`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  deleteSchedule(scheduleId) {
+    return zodfetch(DeletedScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "DELETE",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+};
+_getHeaders = new WeakSet();
+getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${this.accessToken}`
+  };
+  if (taskContext.isInsideTask) {
+    propagation.inject(context.active(), headers);
+    if (spanParentAsLink) {
+      headers["x-trigger-span-parent-as-link"] = "1";
+    }
+  }
+  return headers;
+}, "#getHeaders");
+__name(_ApiClient, "ApiClient");
+var ApiClient = _ApiClient;
+var _getStore, getStore_fn;
+var _ApiClientManager = class _ApiClientManager {
+  constructor() {
+    __privateAdd(this, _getStore);
+    __publicField(this, "_storage", new SafeAsyncLocalStorage());
+  }
+  get baseURL() {
+    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, _getStore, getStore_fn).call(this);
+    return store?.accessToken ?? getEnvVar("TRIGGER_SECRET_KEY");
+  }
+  get client() {
+    if (!this.baseURL || !this.accessToken) {
+      return void 0;
+    }
+    return new ApiClient(this.baseURL, this.accessToken);
+  }
+  runWith(context2, fn) {
+    return this._storage.runWith(context2, fn);
+  }
+};
+_getStore = new WeakSet();
+getStore_fn = /* @__PURE__ */ __name(function() {
+  return this._storage.getStore();
+}, "#getStore");
+__name(_ApiClientManager, "ApiClientManager");
+var ApiClientManager = _ApiClientManager;
+var apiClientManager = new ApiClientManager();
+
+// src/v3/utils/ioSerialization.ts
+async function parsePacket(value) {
+  if (!value.data) {
+    return void 0;
+  }
+  switch (value.dataType) {
+    case "application/json":
+      return JSON.parse(value.data);
+    case "application/super+json":
+      const { parse } = await loadSuperJSON();
+      return parse(value.data);
+    case "text/plain":
+      return value.data;
+    case "application/store":
+      throw new Error(`Cannot parse an application/store packet (${value.data}). Needs to be imported first.`);
+    default:
+      return value.data;
+  }
+}
+__name(parsePacket, "parsePacket");
+async function stringifyIO(value) {
+  if (value === void 0) {
+    return {
+      dataType: "application/json"
+    };
+  }
+  if (typeof value === "string") {
+    return {
+      data: value,
+      dataType: "text/plain"
+    };
+  }
+  try {
+    const { stringify } = await loadSuperJSON();
+    const data = stringify(value);
+    return {
+      data,
+      dataType: "application/super+json"
+    };
+  } catch {
+    return {
+      data: value,
+      dataType: "application/json"
+    };
+  }
+}
+__name(stringifyIO, "stringifyIO");
+async function conditionallyExportPacket(packet, pathPrefix, tracer) {
+  if (apiClientManager.client) {
+    const { needsOffloading, size } = packetRequiresOffloading(packet);
+    if (needsOffloading) {
+      if (!tracer) {
+        return await exportPacket(packet, pathPrefix);
+      } else {
+        const result = await tracer.startActiveSpan("store.uploadOutput", async (span) => {
+          return await exportPacket(packet, pathPrefix);
+        }, {
+          attributes: {
+            byteLength: size,
+            [SemanticInternalAttributes.STYLE_ICON]: "cloud-upload"
+          }
+        });
+        return result ?? packet;
+      }
+    }
+  }
+  return packet;
+}
+__name(conditionallyExportPacket, "conditionallyExportPacket");
+function packetRequiresOffloading(packet) {
+  if (!packet.data) {
+    return {
+      needsOffloading: false,
+      size: 0
+    };
+  }
+  const byteSize = Buffer.byteLength(packet.data, "utf8");
+  return {
+    needsOffloading: byteSize >= OFFLOAD_IO_PACKET_LENGTH_LIMIT,
+    size: byteSize
+  };
+}
+__name(packetRequiresOffloading, "packetRequiresOffloading");
+async function exportPacket(packet, pathPrefix) {
+  const filename = `${pathPrefix}.${getPacketExtension(packet.dataType)}`;
+  const presignedResponse = await apiClientManager.client.createUploadPayloadUrl(filename);
+  const uploadResponse = await fetch(presignedResponse.presignedUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Type": packet.dataType
+    },
+    body: packet.data
+  });
+  if (!uploadResponse.ok) {
+    throw new Error(`Failed to upload output to ${presignedResponse.presignedUrl}: ${uploadResponse.statusText}`);
+  }
+  return {
+    data: filename,
+    dataType: "application/store"
+  };
+}
+__name(exportPacket, "exportPacket");
+async function conditionallyImportPacket(packet, tracer) {
+  if (packet.dataType !== "application/store") {
+    return packet;
+  }
+  if (!tracer) {
+    return await importPacket(packet);
+  } else {
+    const result = await tracer.startActiveSpan("store.downloadPayload", async (span) => {
+      return await importPacket(packet, span);
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "cloud-download"
+      }
+    });
+    return result ?? packet;
+  }
+}
+__name(conditionallyImportPacket, "conditionallyImportPacket");
+async function importPacket(packet, span) {
+  if (!packet.data) {
+    return packet;
+  }
+  if (!apiClientManager.client) {
+    return packet;
+  }
+  const presignedResponse = await apiClientManager.client.getPayloadUrl(packet.data);
+  const response = await fetch(presignedResponse.presignedUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to import packet ${presignedResponse.presignedUrl}: ${response.statusText}`);
+  }
+  const data = await response.text();
+  span?.setAttribute("size", Buffer.byteLength(data, "utf8"));
+  return {
+    data,
+    dataType: response.headers.get("content-type") ?? "application/json"
+  };
+}
+__name(importPacket, "importPacket");
+async function createPacketAttributes(packet, dataKey, dataTypeKey) {
+  if (!packet.data) {
+    return;
+  }
+  switch (packet.dataType) {
+    case "application/json":
+      return {
+        ...flattenAttributes(packet, dataKey),
+        [dataTypeKey]: packet.dataType
+      };
+    case "application/super+json":
+      const { parse } = await loadSuperJSON();
+      if (typeof packet.data === "undefined" || packet.data === null) {
+        return;
+      }
+      try {
+        const parsed = parse(packet.data);
+        const jsonified = JSON.parse(JSON.stringify(parsed, safeReplacer));
+        return {
+          ...flattenAttributes(jsonified, dataKey),
+          [dataTypeKey]: "application/json"
+        };
+      } catch {
+        return;
+      }
+    case "application/store":
+      return {
+        [dataKey]: packet.data,
+        [dataTypeKey]: packet.dataType
+      };
+    case "text/plain":
+      return {
+        [dataKey]: packet.data,
+        [dataTypeKey]: packet.dataType
+      };
+    default:
+      return;
+  }
+}
+__name(createPacketAttributes, "createPacketAttributes");
+function safeReplacer(key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  if (value instanceof Set) {
+    return Array.from(value);
+  }
+  if (value instanceof Map) {
+    const obj = {};
+    value.forEach((v, k) => {
+      obj[k] = v;
+    });
+    return obj;
+  }
+  return value;
+}
+__name(safeReplacer, "safeReplacer");
+function getPacketExtension(outputType) {
+  switch (outputType) {
+    case "application/json":
+      return "json";
+    case "application/super+json":
+      return "json";
+    case "text/plain":
+      return "txt";
+    default:
+      return "txt";
+  }
+}
+__name(getPacketExtension, "getPacketExtension");
+async function loadSuperJSON() {
+  return await import('superjson');
+}
+__name(loadSuperJSON, "loadSuperJSON");
+
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
+}
+__name(accessoryAttributes, "accessoryAttributes");
+
+// src/v3/workers/taskExecutor.ts
+var _callRun, callRun_fn, _callTaskInit, callTaskInit_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
+var _TaskExecutor = class _TaskExecutor {
+  constructor(task, options) {
+    __privateAdd(this, _callRun);
+    __privateAdd(this, _callTaskInit);
+    __privateAdd(this, _callTaskCleanup);
+    __privateAdd(this, _handleError);
+    this.task = task;
+    this._tracingSDK = options.tracingSDK;
+    this._tracer = options.tracer;
+    this._consoleInterceptor = options.consoleInterceptor;
+    this._config = options.projectConfig;
+    this._importedConfig = options.importedConfig;
+    this._handleErrorFn = options.handleErrorFn;
+  }
+  async execute(execution, worker, traceContext) {
+    const ctx = TaskRunContext.parse(execution);
+    const attemptMessage = `Attempt ${execution.attempt.number}`;
+    const originalPacket = {
+      data: execution.run.payload,
+      dataType: execution.run.payloadType
+    };
+    taskContext.setGlobalTaskContext({
+      ctx,
+      worker
+    });
+    this._tracingSDK.asyncResourceDetector.resolveWithAttributes({
+      ...taskContext.attributes,
+      [SemanticInternalAttributes.SDK_VERSION]: this.task.packageVersion,
+      [SemanticInternalAttributes.SDK_LANGUAGE]: "typescript"
+    });
+    const result = await this._tracer.startActiveSpan(attemptMessage, async (span) => {
+      return await this._consoleInterceptor.intercept(console, async () => {
+        let parsedPayload;
+        let initOutput;
+        try {
+          const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
+          parsedPayload = await parsePacket(payloadPacket);
+          initOutput = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
+          const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
+          try {
+            const stringifiedOutput = await stringifyIO(output);
+            const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
+            const attributes = await createPacketAttributes(finalOutput, SemanticInternalAttributes.OUTPUT, SemanticInternalAttributes.OUTPUT_TYPE);
+            if (attributes) {
+              span.setAttributes(attributes);
+            }
+            return {
+              ok: true,
+              id: execution.run.id,
+              output: finalOutput.data,
+              outputType: finalOutput.dataType
+            };
+          } catch (stringifyError) {
+            recordSpanException(span, stringifyError);
+            return {
+              ok: false,
+              id: execution.run.id,
+              error: {
+                type: "INTERNAL_ERROR",
+                code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
+                message: stringifyError instanceof Error ? stringifyError.message : typeof stringifyError === "string" ? stringifyError : void 0
+              }
+            };
+          }
+        } catch (runError) {
+          try {
+            const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
+            recordSpanException(span, handleErrorResult.error ?? runError);
+            return {
+              id: execution.run.id,
+              ok: false,
+              error: handleErrorResult.error ? parseError(handleErrorResult.error) : parseError(runError),
+              retry: handleErrorResult.status === "retry" ? handleErrorResult.retry : void 0,
+              skippedRetrying: handleErrorResult.status === "skipped"
+            };
+          } catch (handleErrorError) {
+            recordSpanException(span, handleErrorError);
+            return {
+              ok: false,
+              id: execution.run.id,
+              error: {
+                type: "INTERNAL_ERROR",
+                code: TaskRunErrorCodes.HANDLE_ERROR_ERROR,
+                message: handleErrorError instanceof Error ? handleErrorError.message : typeof handleErrorError === "string" ? handleErrorError : void 0
+              }
+            };
+          }
+        } finally {
+          await __privateMethod(this, _callTaskCleanup, callTaskCleanup_fn).call(this, parsedPayload, ctx, initOutput);
+        }
+      });
+    }, {
+      kind: SpanKind.CONSUMER,
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "attempt",
+        ...accessoryAttributes({
+          items: [
+            {
+              text: ctx.task.filePath
+            },
+            {
+              text: `${ctx.task.exportName}.run()`
+            }
+          ],
+          style: "codepath"
+        })
+      }
+    }, this._tracer.extractContext(traceContext));
+    return result;
+  }
+};
+_callRun = new WeakSet();
+callRun_fn = /* @__PURE__ */ __name(async function(payload, ctx, init) {
+  const runFn = this.task.fns.run;
+  const middlewareFn = this.task.fns.middleware;
+  if (!runFn) {
+    throw new Error("Task does not have a run function");
+  }
+  if (!middlewareFn) {
+    return runFn(payload, {
+      ctx
+    });
+  }
+  return middlewareFn(payload, {
+    ctx,
+    next: async () => runFn(payload, {
+      ctx,
+      init
+    })
+  });
+}, "#callRun");
+_callTaskInit = new WeakSet();
+callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+  const initFn = this.task.fns.init;
+  if (!initFn) {
+    return {};
+  }
+  return this._tracer.startActiveSpan("init", async (span) => {
+    return await initFn(payload1, {
+      ctx: ctx1
+    });
+  });
+}, "#callTaskInit");
+_callTaskCleanup = new WeakSet();
+callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload2, ctx2, init1) {
+  const cleanupFn = this.task.fns.cleanup;
+  if (!cleanupFn) {
+    return;
+  }
+  return this._tracer.startActiveSpan("cleanup", async (span) => {
+    return await cleanupFn(payload2, {
+      ctx: ctx2,
+      init: init1
+    });
+  });
+}, "#callTaskCleanup");
+_handleError = new WeakSet();
+handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload3, ctx3) {
+  const retriesConfig = this._importedConfig?.retries ?? this._config.retries;
+  const retry = this.task.retry ?? retriesConfig?.default;
+  if (!retry) {
+    return {
+      status: "noop"
+    };
+  }
+  const delay = calculateNextRetryDelay(retry, execution.attempt.number);
+  if (execution.environment.type === "DEVELOPMENT" && typeof retriesConfig?.enabledInDev === "boolean" && !retriesConfig.enabledInDev) {
+    return {
+      status: "skipped"
+    };
+  }
+  return this._tracer.startActiveSpan("handleError()", async (span) => {
+    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload3, error, {
+      ctx: ctx3,
+      retry,
+      retryDelayInMs: delay,
+      retryAt: delay ? new Date(Date.now() + delay) : void 0
+    }) : this._importedConfig ? await this._handleErrorFn?.(payload3, error, {
+      ctx: ctx3,
+      retry,
+      retryDelayInMs: delay,
+      retryAt: delay ? new Date(Date.now() + delay) : void 0
+    }) : void 0;
+    if (!handleErrorResult) {
+      return typeof delay === "undefined" ? {
+        status: "noop"
+      } : {
+        status: "retry",
+        retry: {
+          timestamp: Date.now() + delay,
+          delay
+        }
+      };
+    }
+    if (handleErrorResult.skipRetrying) {
+      return {
+        status: "skipped",
+        error: handleErrorResult.error
+      };
+    }
+    if (typeof handleErrorResult.retryAt !== "undefined") {
+      return {
+        status: "retry",
+        retry: {
+          timestamp: handleErrorResult.retryAt.getTime(),
+          delay: handleErrorResult.retryAt.getTime() - Date.now()
+        },
+        error: handleErrorResult.error
+      };
+    }
+    if (typeof handleErrorResult.retryDelayInMs === "number") {
+      return {
+        status: "retry",
+        retry: {
+          timestamp: Date.now() + handleErrorResult.retryDelayInMs,
+          delay: handleErrorResult.retryDelayInMs
+        },
+        error: handleErrorResult.error
+      };
+    }
+    if (handleErrorResult.retry && typeof handleErrorResult.retry === "object") {
+      const delay2 = calculateNextRetryDelay(handleErrorResult.retry, execution.attempt.number);
+      return typeof delay2 === "undefined" ? {
+        status: "noop",
+        error: handleErrorResult.error
+      } : {
+        status: "retry",
+        retry: {
+          timestamp: Date.now() + delay2,
+          delay: delay2
+        },
+        error: handleErrorResult.error
+      };
+    }
+    return {
+      status: "noop",
+      error: handleErrorResult.error
+    };
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "exclamation-circle"
+    }
+  });
+}, "#handleError");
+__name(_TaskExecutor, "TaskExecutor");
+var TaskExecutor = _TaskExecutor;
+var _originClockTime, originClockTime_get, _originPreciseDate, originPreciseDate_get;
+var _PreciseWallClock = class _PreciseWallClock {
+  constructor(options = {}) {
+    __privateAdd(this, _originClockTime);
+    __privateAdd(this, _originPreciseDate);
+    this._origin = {
+      clockTime: options.origin ?? process.hrtime(),
+      preciseDate: options.now ?? new PreciseDate()
+    };
+  }
+  preciseNow() {
+    const elapsedHrTime = process.hrtime(__privateGet(this, _originClockTime, originClockTime_get));
+    const elapsedNanoseconds = BigInt(elapsedHrTime[0]) * BigInt(1e9) + BigInt(elapsedHrTime[1]);
+    const preciseDate = new PreciseDate(__privateGet(this, _originPreciseDate, originPreciseDate_get).getFullTime() + elapsedNanoseconds);
+    const dateStruct = preciseDate.toStruct();
+    return [
+      dateStruct.seconds,
+      dateStruct.nanos
+    ];
+  }
+  reset() {
+    this._origin = {
+      clockTime: process.hrtime(),
+      preciseDate: new PreciseDate()
+    };
+  }
+};
+_originClockTime = new WeakSet();
+originClockTime_get = /* @__PURE__ */ __name(function() {
+  return this._origin.clockTime;
+}, "#originClockTime");
+_originPreciseDate = new WeakSet();
+originPreciseDate_get = /* @__PURE__ */ __name(function() {
+  return this._origin.preciseDate;
+}, "#originPreciseDate");
+__name(_PreciseWallClock, "PreciseWallClock");
+var PreciseWallClock = _PreciseWallClock;
+function iconStringForSeverity(severityNumber) {
+  switch (severityNumber) {
+    case SeverityNumber.UNSPECIFIED:
+      return void 0;
+    case SeverityNumber.TRACE:
+    case SeverityNumber.TRACE2:
+    case SeverityNumber.TRACE3:
+    case SeverityNumber.TRACE4:
+      return "trace";
+    case SeverityNumber.DEBUG:
+    case SeverityNumber.DEBUG2:
+    case SeverityNumber.DEBUG3:
+    case SeverityNumber.DEBUG4:
+      return "debug";
+    case SeverityNumber.INFO:
+    case SeverityNumber.INFO2:
+    case SeverityNumber.INFO3:
+    case SeverityNumber.INFO4:
+      return "info";
+    case SeverityNumber.WARN:
+    case SeverityNumber.WARN2:
+    case SeverityNumber.WARN3:
+    case SeverityNumber.WARN4:
+      return "warn";
+    case SeverityNumber.ERROR:
+    case SeverityNumber.ERROR2:
+    case SeverityNumber.ERROR3:
+    case SeverityNumber.ERROR4:
+      return "error";
+    case SeverityNumber.FATAL:
+    case SeverityNumber.FATAL2:
+    case SeverityNumber.FATAL3:
+    case SeverityNumber.FATAL4:
+      return "fatal";
+  }
+}
+__name(iconStringForSeverity, "iconStringForSeverity");
+var _SimpleClock = class _SimpleClock {
+  preciseNow() {
+    const now = new PreciseDate();
+    const nowStruct = now.toStruct();
+    return [
+      nowStruct.seconds,
+      nowStruct.nanos
+    ];
+  }
+  reset() {
+  }
+};
+__name(_SimpleClock, "SimpleClock");
+var SimpleClock = _SimpleClock;
+
+// src/v3/clock/index.ts
+var API_NAME2 = "clock";
+var SIMPLE_CLOCK = new SimpleClock();
+var _getClock, getClock_fn;
+var _ClockAPI = class _ClockAPI {
+  constructor() {
+    __privateAdd(this, _getClock);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _ClockAPI();
+    }
+    return this._instance;
+  }
+  setGlobalClock(clock2) {
+    return registerGlobal(API_NAME2, clock2);
+  }
+  preciseNow() {
+    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
+  }
+  reset() {
+    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
+  }
+};
+_getClock = new WeakSet();
+getClock_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME2) ?? SIMPLE_CLOCK;
+}, "#getClock");
+__name(_ClockAPI, "ClockAPI");
+var ClockAPI = _ClockAPI;
+
+// src/v3/clock-api.ts
+var clock = ClockAPI.getInstance();
+
+// src/v3/logger/taskLogger.ts
+var logLevels = [
+  "none",
+  "error",
+  "warn",
+  "log",
+  "info",
+  "debug"
+];
+var _emitLog, emitLog_fn, _getTimestampInHrTime, getTimestampInHrTime_fn;
+var _OtelTaskLogger = class _OtelTaskLogger {
+  constructor(_config) {
+    __privateAdd(this, _emitLog);
+    __privateAdd(this, _getTimestampInHrTime);
+    this._config = _config;
+    this._level = logLevels.indexOf(_config.level);
+  }
+  debug(message, properties) {
+    if (this._level < 5)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "debug", SeverityNumber.DEBUG, properties);
+  }
+  log(message, properties) {
+    if (this._level < 3)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "log", SeverityNumber.INFO, properties);
+  }
+  info(message, properties) {
+    if (this._level < 4)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "info", SeverityNumber.INFO, properties);
+  }
+  warn(message, properties) {
+    if (this._level < 2)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "warn", SeverityNumber.WARN, properties);
+  }
+  error(message, properties) {
+    if (this._level < 1)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "error", SeverityNumber.ERROR, properties);
+  }
+  trace(name, fn, options) {
+    return this._config.tracer.startActiveSpan(name, fn, options);
+  }
+};
+_emitLog = new WeakSet();
+emitLog_fn = /* @__PURE__ */ __name(function(message, timestamp, severityText, severityNumber, properties) {
+  let attributes = {
+    ...flattenAttributes(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;
+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");
+var _handleLog, handleLog_fn, _getTimestampInHrTime2, getTimestampInHrTime_fn2, _getAttributes, getAttributes_fn;
+var _ConsoleInterceptor = class _ConsoleInterceptor {
+  constructor(logger, sendToStdIO) {
+    __privateAdd(this, _handleLog);
+    __privateAdd(this, _getTimestampInHrTime2);
+    __privateAdd(this, _getAttributes);
+    this.logger = logger;
+    this.sendToStdIO = sendToStdIO;
+  }
+  // Intercept the console and send logs to the OpenTelemetry logger
+  // during the execution of the callback
+  async intercept(console2, callback) {
+    const originalConsole = {
+      log: console2.log,
+      info: console2.info,
+      warn: console2.warn,
+      error: console2.error,
+      debug: console2.debug
+    };
+    console2.log = this.log.bind(this);
+    console2.info = this.info.bind(this);
+    console2.warn = this.warn.bind(this);
+    console2.error = this.error.bind(this);
+    console2.debug = this.debug.bind(this);
+    try {
+      return await callback();
+    } finally {
+      console2.log = originalConsole.log;
+      console2.info = originalConsole.info;
+      console2.warn = originalConsole.warn;
+      console2.error = originalConsole.error;
+      console2.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/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
+    };
+  }
+  taskExists(id) {
+    return this._taskMetadata.has(id);
+  }
+  disable() {
+  }
+};
+__name(_StandardTaskCatalog, "StandardTaskCatalog");
+var StandardTaskCatalog = _StandardTaskCatalog;
+
+export { ConsoleInterceptor, PreciseWallClock as DurableClock, OtelTaskLogger, StandardTaskCatalog, TaskContextLogProcessor, TaskContextSpanProcessor, TaskExecutor, TracingSDK, getEnvVar, logLevels, recordSpanException };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map