@trigger.dev/core 3.0.0-beta.5 → 3.0.0-beta.50

package/dist/v3/workers/index.mjs

@@ -0,0 +1,3664 @@
+import { SpanStatusCode, DiagLogLevel, diag, DiagConsoleLogger, propagation, context, SpanKind } from '@opentelemetry/api';
+import { z } from 'zod';
+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 { fromZodError } from 'zod-validation-error';
+import { PreciseDate } from '@google-cloud/precise-date';
+import util from 'node:util';
+import { setInterval } from 'node:timers/promises';
+
+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");
+var SerializedError = z.object({
+  message: z.string(),
+  name: z.string().optional(),
+  stackTrace: z.string().optional()
+});
+function sanitizeError(error) {
+  switch (error.type) {
+    case "BUILT_IN_ERROR": {
+      return {
+        type: "BUILT_IN_ERROR",
+        message: error.message?.replace(/\0/g, ""),
+        name: error.name?.replace(/\0/g, ""),
+        stackTrace: error.stackTrace?.replace(/\0/g, "")
+      };
+    }
+    case "STRING_ERROR": {
+      return {
+        type: "STRING_ERROR",
+        raw: error.raw.replace(/\0/g, "")
+      };
+    }
+    case "CUSTOM_ERROR": {
+      return {
+        type: "CUSTOM_ERROR",
+        raw: error.raw.replace(/\0/g, "")
+      };
+    }
+    case "INTERNAL_ERROR": {
+      return {
+        type: "INTERNAL_ERROR",
+        code: error.code,
+        message: error.message?.replace(/\0/g, ""),
+        stackTrace: error.stackTrace?.replace(/\0/g, "")
+      };
+    }
+  }
+}
+__name(sanitizeError, "sanitizeError");
+
+// 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",
+  MACHINE_PRESET_NAME: "ctx.machine.name",
+  MACHINE_PRESET_CPU: "ctx.machine.cpu",
+  MACHINE_PRESET_MEMORY: "ctx.machine.memory",
+  MACHINE_PRESET_CENTS_PER_MS: "ctx.machine.centsPerMs",
+  SPAN_PARTIAL: "$span.partial",
+  SPAN_ID: "$span.span_id",
+  OUTPUT: "$output",
+  OUTPUT_TYPE: "$mime_type_output",
+  STYLE: "$style",
+  STYLE_ICON: "$style.icon",
+  STYLE_VARIANT: "$style.variant",
+  STYLE_ACCESSORY: "$style.accessory",
+  METADATA: "$metadata",
+  TRIGGER: "$trigger",
+  PAYLOAD: "$payload",
+  PAYLOAD_TYPE: "$mime_type_payload",
+  SHOW: "$show",
+  SHOW_ACTIONS: "$show.actions",
+  WORKER_ID: "worker.id",
+  WORKER_VERSION: "worker.version",
+  CLI_VERSION: "cli.version",
+  SDK_VERSION: "sdk.version",
+  SDK_LANGUAGE: "sdk.language",
+  RETRY_AT: "retry.at",
+  RETRY_DELAY: "retry.delay",
+  RETRY_COUNT: "retry.count",
+  LINK_TITLE: "$link.title",
+  IDEMPOTENCY_KEY: "ctx.run.idempotencyKey",
+  USAGE_DURATION_MS: "$usage.durationMs",
+  USAGE_COST_IN_CENTS: "$usage.costInCents",
+  RATE_LIMIT_LIMIT: "response.rateLimit.limit",
+  RATE_LIMIT_REMAINING: "response.rateLimit.remaining",
+  RATE_LIMIT_RESET: "response.rateLimit.reset"
+};
+
+// src/v3/utils/flattenAttributes.ts
+var NULL_SENTINEL = "$@null((";
+function flattenAttributes(obj, prefix) {
+  const result = {};
+  if (obj === void 0) {
+    return result;
+  }
+  if (obj === null) {
+    result[prefix || ""] = NULL_SENTINEL;
+    return result;
+  }
+  if (typeof obj === "string") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "number") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "boolean") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const newPrefix = `${prefix ? `${prefix}.` : ""}${Array.isArray(obj) ? `[${key}]` : key}`;
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        if (typeof value[i] === "object" && value[i] !== null) {
+          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
+        } else {
+          if (value[i] === null) {
+            result[`${newPrefix}.[${i}]`] = NULL_SENTINEL;
+          } else {
+            result[`${newPrefix}.[${i}]`] = value[i];
+          }
+        }
+      }
+    } else if (isRecord(value)) {
+      Object.assign(result, flattenAttributes(value, newPrefix));
+    } else {
+      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+        result[newPrefix] = value;
+      } else if (value === null) {
+        result[newPrefix] = NULL_SENTINEL;
+      }
+    }
+  }
+  return result;
+}
+__name(flattenAttributes, "flattenAttributes");
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+
+// 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,
+        [SemanticInternalAttributes.MACHINE_PRESET_NAME]: this.ctx.machine?.name,
+        [SemanticInternalAttributes.MACHINE_PRESET_CPU]: this.ctx.machine?.cpu,
+        [SemanticInternalAttributes.MACHINE_PRESET_MEMORY]: this.ctx.machine?.memory,
+        [SemanticInternalAttributes.MACHINE_PRESET_CENTS_PER_MS]: this.ctx.machine?.centsPerMs
+      };
+    }
+    return {};
+  }
+  disable() {
+    unregisterGlobal(API_NAME);
+  }
+  setGlobalTaskContext(taskContext2) {
+    return registerGlobal(API_NAME, taskContext2);
+  }
+};
+_getTaskContext = new WeakSet();
+getTaskContext_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME);
+}, "#getTaskContext");
+__name(_TaskContextAPI, "TaskContextAPI");
+var TaskContextAPI = _TaskContextAPI;
+
+// src/v3/task-context-api.ts
+var taskContext = TaskContextAPI.getInstance();
+
+// src/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");
+
+// package.json
+var version = "3.0.0-beta.50";
+
+// 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,
+      [SemanticInternalAttributes.CLI_VERSION]: version
+    })).merge(config.resource ?? new Resource({})).merge(new Resource(envResourceAttributes));
+    const traceProvider = new NodeTracerProvider({
+      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis,
+      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
+    });
+    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 Promise.all([
+      this._traceProvider.forceFlush(),
+      this._logProvider.forceFlush()
+    ]);
+  }
+  async shutdown() {
+    await Promise.all([
+      this._traceProvider.shutdown(),
+      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(sanitizeSpanError(error));
+  } else if (typeof error === "string") {
+    span.recordException(error.replace(/\0/g, ""));
+  } else {
+    span.recordException(JSON.stringify(error).replace(/\0/g, ""));
+  }
+  span.setStatus({
+    code: SpanStatusCode.ERROR
+  });
+}
+__name(recordSpanException, "recordSpanException");
+function sanitizeSpanError(error) {
+  const sanitizedError = new Error(error.message.replace(/\0/g, ""));
+  sanitizedError.name = error.name.replace(/\0/g, "");
+  sanitizedError.stack = error.stack?.replace(/\0/g, "");
+  return sanitizedError;
+}
+__name(sanitizeSpanError, "sanitizeSpanError");
+var MachineCpu = z.union([
+  z.literal(0.25),
+  z.literal(0.5),
+  z.literal(1),
+  z.literal(2),
+  z.literal(4)
+]);
+var MachineMemory = z.union([
+  z.literal(0.25),
+  z.literal(0.5),
+  z.literal(1),
+  z.literal(2),
+  z.literal(4),
+  z.literal(8)
+]);
+var MachinePresetName = z.enum([
+  "micro",
+  "small-1x",
+  "small-2x",
+  "medium-1x",
+  "medium-2x",
+  "large-1x",
+  "large-2x"
+]);
+var MachineConfig = z.object({
+  cpu: MachineCpu.optional(),
+  memory: MachineMemory.optional(),
+  preset: MachinePresetName.optional()
+});
+var MachinePreset = z.object({
+  name: MachinePresetName,
+  cpu: z.number(),
+  memory: z.number(),
+  centsPerMs: z.number()
+});
+var TaskRunBuiltInError = z.object({
+  type: z.literal("BUILT_IN_ERROR"),
+  name: z.string(),
+  message: z.string(),
+  stackTrace: z.string()
+});
+var TaskRunCustomErrorObject = z.object({
+  type: z.literal("CUSTOM_ERROR"),
+  raw: z.string()
+});
+var TaskRunStringError = z.object({
+  type: z.literal("STRING_ERROR"),
+  raw: z.string()
+});
+var TaskRunErrorCodes = {
+  COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR",
+  COULD_NOT_FIND_TASK: "COULD_NOT_FIND_TASK",
+  CONFIGURED_INCORRECTLY: "CONFIGURED_INCORRECTLY",
+  TASK_ALREADY_RUNNING: "TASK_ALREADY_RUNNING",
+  TASK_EXECUTION_FAILED: "TASK_EXECUTION_FAILED",
+  TASK_EXECUTION_ABORTED: "TASK_EXECUTION_ABORTED",
+  TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE: "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+  TASK_PROCESS_SIGKILL_TIMEOUT: "TASK_PROCESS_SIGKILL_TIMEOUT",
+  TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
+  TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
+  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
+  GRACEFUL_EXIT_TIMEOUT: "GRACEFUL_EXIT_TIMEOUT"
+};
+var TaskRunInternalError = z.object({
+  type: z.literal("INTERNAL_ERROR"),
+  code: z.enum([
+    "COULD_NOT_FIND_EXECUTOR",
+    "COULD_NOT_FIND_TASK",
+    "CONFIGURED_INCORRECTLY",
+    "TASK_ALREADY_RUNNING",
+    "TASK_EXECUTION_FAILED",
+    "TASK_EXECUTION_ABORTED",
+    "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+    "TASK_PROCESS_SIGKILL_TIMEOUT",
+    "TASK_RUN_CANCELLED",
+    "TASK_OUTPUT_ERROR",
+    "HANDLE_ERROR_ERROR",
+    "GRACEFUL_EXIT_TIMEOUT",
+    "TASK_RUN_HEARTBEAT_TIMEOUT"
+  ]),
+  message: z.string().optional(),
+  stackTrace: z.string().optional()
+});
+var TaskRunError = z.discriminatedUnion("type", [
+  TaskRunBuiltInError,
+  TaskRunCustomErrorObject,
+  TaskRunStringError,
+  TaskRunInternalError
+]);
+var TaskRun = z.object({
+  id: z.string(),
+  payload: z.string(),
+  payloadType: z.string(),
+  context: z.any(),
+  tags: z.array(z.string()),
+  isTest: z.boolean().default(false),
+  createdAt: z.coerce.date(),
+  startedAt: z.coerce.date().default(() => /* @__PURE__ */ new Date()),
+  idempotencyKey: z.string().optional(),
+  maxAttempts: z.number().optional(),
+  durationMs: z.number().default(0),
+  costInCents: z.number().default(0),
+  baseCostInCents: z.number().default(0)
+});
+var TaskRunExecutionTask = z.object({
+  id: z.string(),
+  filePath: z.string(),
+  exportName: z.string()
+});
+var TaskRunExecutionAttempt = z.object({
+  id: z.string(),
+  number: z.number(),
+  startedAt: z.coerce.date(),
+  backgroundWorkerId: z.string(),
+  backgroundWorkerTaskId: z.string(),
+  status: z.string()
+});
+var TaskRunExecutionEnvironment = z.object({
+  id: z.string(),
+  slug: z.string(),
+  type: z.enum([
+    "PRODUCTION",
+    "STAGING",
+    "DEVELOPMENT",
+    "PREVIEW"
+  ])
+});
+var TaskRunExecutionOrganization = z.object({
+  id: z.string(),
+  slug: z.string(),
+  name: z.string()
+});
+var TaskRunExecutionProject = z.object({
+  id: z.string(),
+  ref: z.string(),
+  slug: z.string(),
+  name: z.string()
+});
+var TaskRunExecutionQueue = z.object({
+  id: z.string(),
+  name: z.string()
+});
+var TaskRunExecutionBatch = z.object({
+  id: z.string()
+});
+var TaskRunExecution = z.object({
+  task: TaskRunExecutionTask,
+  attempt: TaskRunExecutionAttempt,
+  run: TaskRun,
+  queue: TaskRunExecutionQueue,
+  environment: TaskRunExecutionEnvironment,
+  organization: TaskRunExecutionOrganization,
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional(),
+  machine: MachinePreset.optional()
+});
+var TaskRunContext = z.object({
+  task: TaskRunExecutionTask,
+  attempt: TaskRunExecutionAttempt.omit({
+    backgroundWorkerId: true,
+    backgroundWorkerTaskId: true
+  }),
+  run: TaskRun.omit({
+    payload: true,
+    payloadType: true
+  }),
+  queue: TaskRunExecutionQueue,
+  environment: TaskRunExecutionEnvironment,
+  organization: TaskRunExecutionOrganization,
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional(),
+  machine: MachinePreset.optional()
+});
+var TaskRunExecutionRetry = z.object({
+  timestamp: z.number(),
+  delay: z.number(),
+  error: z.unknown().optional()
+});
+var TaskRunExecutionUsage = z.object({
+  durationMs: z.number()
+});
+var TaskRunFailedExecutionResult = z.object({
+  ok: z.literal(false),
+  id: z.string(),
+  error: TaskRunError,
+  retry: TaskRunExecutionRetry.optional(),
+  skippedRetrying: z.boolean().optional(),
+  usage: TaskRunExecutionUsage.optional()
+});
+var TaskRunSuccessfulExecutionResult = z.object({
+  ok: z.literal(true),
+  id: z.string(),
+  output: z.string().optional(),
+  outputType: z.string(),
+  usage: TaskRunExecutionUsage.optional()
+});
+var TaskRunExecutionResult = z.discriminatedUnion("ok", [
+  TaskRunSuccessfulExecutionResult,
+  TaskRunFailedExecutionResult
+]);
+var BatchTaskRunExecutionResult = z.object({
+  id: z.string(),
+  items: TaskRunExecutionResult.array()
+});
+
+// src/v3/schemas/schemas.ts
+z.enum([
+  "PRODUCTION",
+  "STAGING",
+  "DEVELOPMENT",
+  "PREVIEW"
+]);
+z.object({
+  execution: TaskRunExecution,
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
+});
+var ProdTaskRunExecution = TaskRunExecution.extend({
+  worker: z.object({
+    id: z.string(),
+    contentHash: z.string(),
+    version: z.string()
+  }),
+  machine: MachinePreset.default({
+    name: "small-1x",
+    cpu: 1,
+    memory: 1,
+    centsPerMs: 0
+  })
+});
+z.object({
+  execution: ProdTaskRunExecution,
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
+});
+var FixedWindowRateLimit = z.object({
+  type: z.literal("fixed-window"),
+  limit: z.number(),
+  window: z.union([
+    z.object({
+      seconds: z.number()
+    }),
+    z.object({
+      minutes: z.number()
+    }),
+    z.object({
+      hours: z.number()
+    })
+  ])
+});
+var SlidingWindowRateLimit = z.object({
+  type: z.literal("sliding-window"),
+  limit: z.number(),
+  window: z.union([
+    z.object({
+      seconds: z.number()
+    }),
+    z.object({
+      minutes: z.number()
+    }),
+    z.object({
+      hours: z.number()
+    })
+  ])
+});
+var RateLimitOptions = z.discriminatedUnion("type", [
+  FixedWindowRateLimit,
+  SlidingWindowRateLimit
+]);
+var RetryOptions = z.object({
+  /** The number of attempts before giving up */
+  maxAttempts: z.number().int().optional(),
+  /** The exponential factor to use when calculating the next retry time.
+  *
+  * Each subsequent retry will be calculated as `previousTimeout * factor`
+  */
+  factor: z.number().optional(),
+  /** The minimum time to wait before retrying */
+  minTimeoutInMs: z.number().int().optional(),
+  /** The maximum time to wait before retrying */
+  maxTimeoutInMs: z.number().int().optional(),
+  /** Randomize the timeout between retries.
+  *
+  * This can be useful to prevent the thundering herd problem where all retries happen at the same time.
+  */
+  randomize: z.boolean().optional()
+});
+var QueueOptions = z.object({
+  /** You can define a shared queue and then pass the name in to your task.
+     * 
+     * @example
+     * 
+     * ```ts
+     * const myQueue = queue({
+        name: "my-queue",
+        concurrencyLimit: 1,
+      });
+  
+      export const task1 = task({
+        id: "task-1",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+  
+      export const task2 = task({
+        id: "task-2",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+     * ```
+     */
+  name: z.string().optional(),
+  /** An optional property that specifies the maximum number of concurrent run executions.
+  *
+  * If this property is omitted, the task can potentially use up the full concurrency of an environment. */
+  concurrencyLimit: z.number().int().min(0).max(1e3).optional(),
+  /** @deprecated This feature is coming soon */
+  rateLimit: RateLimitOptions.optional()
+});
+var ScheduleMetadata = z.object({
+  cron: z.string(),
+  timezone: z.string()
+});
+z.object({
+  id: z.string(),
+  packageVersion: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: MachineConfig.optional(),
+  triggerSource: z.string().optional(),
+  schedule: ScheduleMetadata.optional()
+});
+z.object({
+  filePath: z.string(),
+  exportName: z.string()
+});
+z.object({
+  id: z.string(),
+  packageVersion: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: MachineConfig.optional(),
+  triggerSource: z.string().optional(),
+  schedule: ScheduleMetadata.optional(),
+  filePath: z.string(),
+  exportName: z.string()
+});
+z.enum([
+  "index",
+  "create",
+  "restore"
+]);
+z.enum([
+  "terminate"
+]);
+var RegexSchema = z.custom((val) => {
+  try {
+    return typeof val.test === "function";
+  } catch {
+    return false;
+  }
+});
+z.object({
+  project: z.string(),
+  triggerDirectories: z.string().array().optional(),
+  triggerUrl: z.string().optional(),
+  projectDir: z.string().optional(),
+  tsconfigPath: z.string().optional(),
+  retries: z.object({
+    enabledInDev: z.boolean().default(true),
+    default: RetryOptions.optional()
+  }).optional(),
+  additionalPackages: z.string().array().optional(),
+  additionalFiles: z.string().array().optional(),
+  dependenciesToBundle: z.array(z.union([
+    z.string(),
+    RegexSchema
+  ])).optional(),
+  logLevel: z.string().optional(),
+  enableConsoleLogging: z.boolean().optional(),
+  postInstall: z.string().optional(),
+  extraCACerts: z.string().optional()
+});
+z.enum([
+  "WAIT_FOR_DURATION",
+  "WAIT_FOR_TASK",
+  "WAIT_FOR_BATCH"
+]);
+z.object({
+  runId: z.string(),
+  attemptCount: z.number().optional(),
+  messageId: z.string(),
+  isTest: z.boolean(),
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
+});
+
+// src/v3/schemas/resources.ts
+var TaskResource = z.object({
+  id: z.string(),
+  filePath: z.string(),
+  exportName: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: MachineConfig.optional(),
+  triggerSource: z.string().optional(),
+  schedule: ScheduleMetadata.optional()
+});
+var BackgroundWorkerMetadata = z.object({
+  packageVersion: z.string(),
+  contentHash: z.string(),
+  cliPackageVersion: z.string().optional(),
+  tasks: z.array(TaskResource)
+});
+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,
+  supportsLazyAttempts: z.boolean().optional()
+});
+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(),
+    delay: z.string().or(z.coerce.date()).optional(),
+    ttl: z.string().or(z.number().nonnegative().int()).optional(),
+    maxAttempts: z.number().int().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({
+  delay: z.string().or(z.coerce.date())
+});
+z.object({
+  variables: z.record(z.string())
+});
+z.object({
+  imageReference: z.string(),
+  selfHosted: z.boolean().optional()
+});
+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(),
+  stderr: 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({
+  id: z.string()
+});
+var ScheduleType = z.union([
+  z.literal("DECLARATIVE"),
+  z.literal("IMPERATIVE")
+]);
+z.object({
+  /** The schedule id associated with this run (you can have many schedules for the same task).
+  You can use this to remove the schedule, update it, etc */
+  scheduleId: z.string(),
+  /** The type of schedule – `"DECLARATIVE"` or `"IMPERATIVE"`.
+  *
+  * **DECLARATIVE** – defined inline on your `schedules.task` using the `cron` property. They can only be created, updated or deleted by modifying the `cron` property on your task.
+  *
+  * **IMPERATIVE** – created using the `schedules.create` functions or in the dashboard.
+  */
+  type: ScheduleType,
+  /** When the task was scheduled to run.
+  * Note this will be slightly different from `new Date()` because it takes a few ms to run the task.
+  * 
+  * This date is UTC. To output it as a string with a timezone you would do this: 
+  * ```ts
+  * const formatted = payload.timestamp.toLocaleString("en-US", {
+       timeZone: payload.timezone,
+   });
+   ```  */
+  timestamp: z.date(),
+  /** When the task was last run (it has been).
+  This can be undefined if it's never been run. This date is UTC. */
+  lastTimestamp: z.date().optional(),
+  /** You can optionally provide an external id when creating the schedule.
+  Usually you would use a userId or some other unique identifier.
+  This defaults to undefined if you didn't provide one. */
+  externalId: z.string().optional(),
+  /** The IANA timezone the schedule is set to. The default is UTC.
+  * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
+  */
+  timezone: z.string(),
+  /** The next 5 dates this task is scheduled to run */
+  upcoming: z.array(z.date())
+});
+var CreateScheduleOptions = z.object({
+  /** The id of the task you want to attach to. */
+  task: z.string(),
+  /**  The schedule in CRON format.
+     * 
+     * ```txt
+  *    *    *    *    *    *
+  ┬    ┬    ┬    ┬    ┬
+  │    │    │    │    |
+  │    │    │    │    └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
+  │    │    │    └───── month (1 - 12)
+  │    │    └────────── day of month (1 - 31, L)
+  │    └─────────────── hour (0 - 23)
+  └──────────────────── minute (0 - 59)
+     * ```
+  
+  "L" means the last. In the "day of week" field, 1L means the last Monday of the month. In the day of month field, L means the last day of the month.
+  
+     */
+  cron: z.string(),
+  /** You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
+  *
+  * This is required to prevent you from creating duplicate schedules. */
+  deduplicationKey: z.string(),
+  /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
+  *
+  * This allows you to have per-user CRON tasks.
+  */
+  externalId: z.string().optional(),
+  /** Optionally, you can specify a timezone in the IANA format. If unset it will use UTC.
+  * If specified then the CRON will be evaluated in that timezone and will respect daylight savings.
+  *
+  * If you set the CRON to `0 0 * * *` and the timezone to `America/New_York` then the task will run at midnight in New York time, no matter whether it's daylight savings or not.
+  *
+  * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
+  *
+  * @example "America/New_York", "Europe/London", "Asia/Tokyo", "Africa/Cairo"
+  *
+  */
+  timezone: z.string().optional()
+});
+CreateScheduleOptions.omit({
+  deduplicationKey: true
+});
+var ScheduleGenerator = z.object({
+  type: z.literal("CRON"),
+  expression: z.string(),
+  description: z.string()
+});
+var ScheduleObject = z.object({
+  id: z.string(),
+  type: ScheduleType,
+  task: z.string(),
+  active: z.boolean(),
+  deduplicationKey: z.string().nullish(),
+  externalId: z.string().nullish(),
+  generator: ScheduleGenerator,
+  timezone: z.string(),
+  nextRun: z.coerce.date().nullish(),
+  environments: z.array(z.object({
+    id: z.string(),
+    type: z.string(),
+    userName: z.string().nullish()
+  }))
+});
+var DeletedScheduleObject = z.object({
+  id: z.string()
+});
+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()
+});
+z.object({
+  timezones: z.array(z.string())
+});
+var RunStatus = z.enum([
+  /// Task hasn't been deployed yet but is waiting to be executed
+  "WAITING_FOR_DEPLOY",
+  /// Task is waiting to be executed by a worker
+  "QUEUED",
+  /// Task is currently being executed by a worker
+  "EXECUTING",
+  /// Task has failed and is waiting to be retried
+  "REATTEMPTING",
+  /// Task has been paused by the system, and will be resumed by the system
+  "FROZEN",
+  /// Task has been completed successfully
+  "COMPLETED",
+  /// Task has been canceled by the user
+  "CANCELED",
+  /// Task has been completed with errors
+  "FAILED",
+  /// Task has crashed and won't be retried, most likely the worker ran out of resources, e.g. memory or storage
+  "CRASHED",
+  /// Task was interrupted during execution, mostly this happens in development environments
+  "INTERRUPTED",
+  /// Task has failed to complete, due to an error in the system
+  "SYSTEM_FAILURE",
+  /// Task has been scheduled to run at a specific time
+  "DELAYED",
+  /// Task has expired and won't be executed
+  "EXPIRED"
+]);
+var AttemptStatus = z.enum([
+  "PENDING",
+  "EXECUTING",
+  "PAUSED",
+  "COMPLETED",
+  "FAILED",
+  "CANCELED"
+]);
+var RunEnvironmentDetails = z.object({
+  id: z.string(),
+  name: z.string(),
+  user: z.string().optional()
+});
+var RunScheduleDetails = z.object({
+  id: z.string(),
+  externalId: z.string().optional(),
+  deduplicationKey: z.string().optional(),
+  generator: ScheduleGenerator
+});
+var CommonRunFields = {
+  id: z.string(),
+  status: RunStatus,
+  taskIdentifier: z.string(),
+  idempotencyKey: z.string().optional(),
+  version: z.string().optional(),
+  isQueued: z.boolean(),
+  isExecuting: z.boolean(),
+  isCompleted: z.boolean(),
+  isSuccess: z.boolean(),
+  isFailed: z.boolean(),
+  isCancelled: z.boolean(),
+  isTest: z.boolean(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+  startedAt: z.coerce.date().optional(),
+  finishedAt: z.coerce.date().optional(),
+  delayedUntil: z.coerce.date().optional(),
+  ttl: z.string().optional(),
+  expiredAt: z.coerce.date().optional()
+};
+var RetrieveRunResponse = z.object({
+  ...CommonRunFields,
+  payload: z.any().optional(),
+  payloadPresignedUrl: z.string().optional(),
+  output: z.any().optional(),
+  outputPresignedUrl: z.string().optional(),
+  schedule: RunScheduleDetails.optional(),
+  attempts: z.array(z.object({
+    id: z.string(),
+    status: AttemptStatus,
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
+    startedAt: z.coerce.date().optional(),
+    completedAt: z.coerce.date().optional(),
+    error: SerializedError.optional()
+  }).optional())
+});
+var ListRunResponseItem = z.object({
+  ...CommonRunFields,
+  env: RunEnvironmentDetails
+});
+z.object({
+  data: z.array(ListRunResponseItem),
+  pagination: z.object({
+    next: z.string().optional(),
+    previous: z.string().optional()
+  })
+});
+z.object({
+  name: z.string(),
+  value: z.string()
+});
+z.object({
+  value: z.string()
+});
+z.object({
+  variables: z.record(z.string()),
+  override: z.boolean().optional()
+});
+var EnvironmentVariableResponseBody = z.object({
+  success: z.boolean()
+});
+var EnvironmentVariableValue = z.object({
+  value: z.string()
+});
+var EnvironmentVariable = z.object({
+  name: z.string(),
+  value: z.string()
+});
+var EnvironmentVariables = z.array(EnvironmentVariable);
+
+// 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/apiClient/errors.ts
+var _ApiError = class _ApiError extends Error {
+  constructor(status, error, message, headers) {
+    super(`${_ApiError.makeMessage(status, error, message)}`);
+    this.name = "TriggerApiError";
+    this.status = status;
+    this.headers = headers;
+    const data = error;
+    this.error = data;
+    this.code = data?.["code"];
+    this.param = data?.["param"];
+    this.type = data?.["type"];
+  }
+  static makeMessage(status, error, message) {
+    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return "(no status code or body)";
+  }
+  static generate(status, errorResponse, message, headers) {
+    if (!status) {
+      return new ApiConnectionError({
+        cause: castToError(errorResponse)
+      });
+    }
+    const error = errorResponse?.["error"];
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+    return new _ApiError(status, error, message, headers);
+  }
+};
+__name(_ApiError, "ApiError");
+var ApiError = _ApiError;
+var _ApiConnectionError = class _ApiConnectionError extends ApiError {
+  constructor({ message, cause }) {
+    super(void 0, void 0, message || "Connection error.", void 0);
+    __publicField(this, "status");
+    if (cause)
+      this.cause = cause;
+  }
+};
+__name(_ApiConnectionError, "ApiConnectionError");
+var ApiConnectionError = _ApiConnectionError;
+var _BadRequestError = class _BadRequestError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 400);
+  }
+};
+__name(_BadRequestError, "BadRequestError");
+var BadRequestError = _BadRequestError;
+var _AuthenticationError = class _AuthenticationError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 401);
+  }
+};
+__name(_AuthenticationError, "AuthenticationError");
+var AuthenticationError = _AuthenticationError;
+var _PermissionDeniedError = class _PermissionDeniedError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 403);
+  }
+};
+__name(_PermissionDeniedError, "PermissionDeniedError");
+var PermissionDeniedError = _PermissionDeniedError;
+var _NotFoundError = class _NotFoundError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 404);
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+var NotFoundError = _NotFoundError;
+var _ConflictError = class _ConflictError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 409);
+  }
+};
+__name(_ConflictError, "ConflictError");
+var ConflictError = _ConflictError;
+var _UnprocessableEntityError = class _UnprocessableEntityError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 422);
+  }
+};
+__name(_UnprocessableEntityError, "UnprocessableEntityError");
+var UnprocessableEntityError = _UnprocessableEntityError;
+var _RateLimitError = class _RateLimitError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 429);
+  }
+  get millisecondsUntilReset() {
+    const resetAtUnixEpochMs = (this.headers ?? {})["x-ratelimit-reset"];
+    if (typeof resetAtUnixEpochMs === "string") {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      if (isNaN(resetAtUnixEpoch)) {
+        return;
+      }
+      return Math.max(resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 2e3), 0);
+    }
+  }
+};
+__name(_RateLimitError, "RateLimitError");
+var RateLimitError = _RateLimitError;
+var _InternalServerError = class _InternalServerError extends ApiError {
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+function castToError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError, "castToError");
+
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
+}
+__name(accessoryAttributes, "accessoryAttributes");
+
+// src/v3/apiClient/pagination.ts
+var _CursorPage = class _CursorPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return !!this.pagination.next;
+  }
+  hasPreviousPage() {
+    return !!this.pagination.previous;
+  }
+  getNextPage() {
+    if (!this.pagination.next) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      after: this.pagination.next
+    });
+  }
+  getPreviousPage() {
+    if (!this.pagination.previous) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      before: this.pagination.previous
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_CursorPage, "CursorPage");
+var CursorPage = _CursorPage;
+var _OffsetLimitPage = class _OffsetLimitPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return this.pagination.currentPage < this.pagination.totalPages;
+  }
+  hasPreviousPage() {
+    return this.pagination.currentPage > 1;
+  }
+  getNextPage() {
+    if (!this.hasNextPage()) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage + 1
+    });
+  }
+  getPreviousPage() {
+    if (!this.hasPreviousPage()) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage - 1
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_OffsetLimitPage, "OffsetLimitPage");
+var OffsetLimitPage = _OffsetLimitPage;
+
+// src/v3/apiClient/core.ts
+var defaultRetryOptions2 = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: false
+};
+function zodfetch(schema, url, requestInit, options) {
+  return new ApiPromise(_doZodFetch(schema, url, requestInit, options));
+}
+__name(zodfetch, "zodfetch");
+function zodfetchCursorPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("page[size]", String(params.limit));
+  }
+  if (params.after) {
+    query.set("page[after]", params.after);
+  }
+  if (params.before) {
+    query.set("page[before]", params.before);
+  }
+  const cursorPageSchema = z.object({
+    data: z.array(schema),
+    pagination: z.object({
+      next: z.string().optional(),
+      previous: z.string().optional()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(cursorPageSchema, $url.href, requestInit, options);
+  return new CursorPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchCursorPage, "zodfetchCursorPage");
+function zodfetchOffsetLimitPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("perPage", String(params.limit));
+  }
+  if (params.page) {
+    query.set("page", String(params.page));
+  }
+  const offsetLimitPageSchema = z.object({
+    data: z.array(schema),
+    pagination: z.object({
+      currentPage: z.coerce.number(),
+      totalPages: z.coerce.number(),
+      count: z.coerce.number()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(offsetLimitPageSchema, $url.href, requestInit, options);
+  return new OffsetLimitPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchOffsetLimitPage, "zodfetchOffsetLimitPage");
+async function traceZodFetch(params, callback) {
+  if (!params.options?.tracer) {
+    return callback();
+  }
+  const url = new URL(params.url);
+  const method = params.requestInit?.method ?? "GET";
+  const name = params.options.name ?? `${method} ${url.pathname}`;
+  return await params.options.tracer.startActiveSpan(name, async (span) => {
+    return await callback(span);
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: params.options?.icon ?? "api",
+      ...params.options.attributes
+    }
+  });
+}
+__name(traceZodFetch, "traceZodFetch");
+async function _doZodFetch(schema, url, requestInit, options) {
+  const $requestInit = await requestInit;
+  return traceZodFetch({
+    url,
+    requestInit: $requestInit,
+    options
+  }, async (span) => {
+    const result = await _doZodFetchWithRetries(schema, url, $requestInit, options);
+    if (options?.onResponseBody && span) {
+      options.onResponseBody(result.data, span);
+    }
+    return result;
+  });
+}
+__name(_doZodFetch, "_doZodFetch");
+async function _doZodFetchWithRetries(schema, url, requestInit, options, attempt = 1) {
+  try {
+    const response = await fetch(url, requestInitWithCache(requestInit));
+    const responseHeaders = createResponseHeaders(response.headers);
+    if (!response.ok) {
+      const retryResult = shouldRetry(response, attempt, options?.retry);
+      if (retryResult.retry) {
+        await waitForRetry(url, attempt + 1, retryResult.delay, options, requestInit, response);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
+      } else {
+        const errText = await response.text().catch((e) => castToError2(e).message);
+        const errJSON = safeJsonParse(errText);
+        const errMessage = errJSON ? void 0 : errText;
+        throw ApiError.generate(response.status, errJSON, errMessage, responseHeaders);
+      }
+    }
+    const jsonBody = await response.json();
+    const parsedResult = schema.safeParse(jsonBody);
+    if (parsedResult.success) {
+      return {
+        data: parsedResult.data,
+        response
+      };
+    }
+    throw fromZodError(parsedResult.error);
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    if (options?.retry) {
+      const retry = {
+        ...defaultRetryOptions2,
+        ...options.retry
+      };
+      const delay = calculateNextRetryDelay(retry, attempt);
+      if (delay) {
+        await waitForRetry(url, attempt + 1, delay, options, requestInit);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
+      }
+    }
+    throw new ApiConnectionError({
+      cause: castToError2(error)
+    });
+  }
+}
+__name(_doZodFetchWithRetries, "_doZodFetchWithRetries");
+function castToError2(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError2, "castToError");
+function shouldRetry(response, attempt, retryOptions) {
+  function shouldRetryForOptions() {
+    const retry = {
+      ...defaultRetryOptions2,
+      ...retryOptions
+    };
+    const delay = calculateNextRetryDelay(retry, attempt);
+    if (delay) {
+      return {
+        retry: true,
+        delay
+      };
+    } else {
+      return {
+        retry: false
+      };
+    }
+  }
+  __name(shouldRetryForOptions, "shouldRetryForOptions");
+  const shouldRetryHeader = response.headers.get("x-should-retry");
+  if (shouldRetryHeader === "true")
+    return shouldRetryForOptions();
+  if (shouldRetryHeader === "false")
+    return {
+      retry: false
+    };
+  if (response.status === 408)
+    return shouldRetryForOptions();
+  if (response.status === 409)
+    return shouldRetryForOptions();
+  if (response.status === 429) {
+    if (attempt >= (typeof retryOptions?.maxAttempts === "number" ? retryOptions?.maxAttempts : 3)) {
+      return {
+        retry: false
+      };
+    }
+    const resetAtUnixEpochMs = response.headers.get("x-ratelimit-reset");
+    if (resetAtUnixEpochMs) {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      const delay = resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 1e3);
+      if (delay > 0) {
+        return {
+          retry: true,
+          delay
+        };
+      }
+    }
+    return shouldRetryForOptions();
+  }
+  if (response.status >= 500)
+    return shouldRetryForOptions();
+  return {
+    retry: false
+  };
+}
+__name(shouldRetry, "shouldRetry");
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return void 0;
+  }
+}
+__name(safeJsonParse, "safeJsonParse");
+function createResponseHeaders(headers) {
+  return new Proxy(Object.fromEntries(
+    // @ts-ignore
+    headers.entries()
+  ), {
+    get(target, name) {
+      const key = name.toString();
+      return target[key.toLowerCase()] || target[key];
+    }
+  });
+}
+__name(createResponseHeaders, "createResponseHeaders");
+function requestInitWithCache(requestInit) {
+  try {
+    const withCache = {
+      ...requestInit,
+      cache: "no-cache"
+    };
+    const _ = new Request("http://localhost", withCache);
+    return withCache;
+  } catch (error) {
+    return requestInit ?? {};
+  }
+}
+__name(requestInitWithCache, "requestInitWithCache");
+var _ApiPromise = class _ApiPromise extends Promise {
+  constructor(responsePromise) {
+    super((resolve) => {
+      resolve(null);
+    });
+    this.responsePromise = responsePromise;
+  }
+  /**
+  * Gets the raw `Response` instance instead of parsing the response
+  * data.
+  *
+  * If you want to parse the response body but still get the `Response`
+  * instance, you can use {@link withResponse()}.
+  */
+  asResponse() {
+    return this.responsePromise.then((p) => p.response);
+  }
+  /**
+  * Gets the parsed response data and the raw `Response` instance.
+  *
+  * If you just want to get the raw `Response` instance without parsing it,
+  * you can use {@link asResponse()}.
+  */
+  async withResponse() {
+    const [data, response] = await Promise.all([
+      this.parse(),
+      this.asResponse()
+    ]);
+    return {
+      data,
+      response
+    };
+  }
+  parse() {
+    return this.responsePromise.then((result) => result.data);
+  }
+  then(onfulfilled, onrejected) {
+    return this.parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.parse().finally(onfinally);
+  }
+};
+__name(_ApiPromise, "ApiPromise");
+var ApiPromise = _ApiPromise;
+var _fetchPage, fetchPage_fn;
+var _CursorPagePromise = class _CursorPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new CursorPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage, fetchPage_fn).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+};
+_fetchPage = new WeakSet();
+fetchPage_fn = /* @__PURE__ */ __name(function(params) {
+  return zodfetchCursorPage(this.schema, this.url, {
+    ...this.params,
+    ...params
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_CursorPagePromise, "CursorPagePromise");
+var CursorPagePromise = _CursorPagePromise;
+var _fetchPage2, fetchPage_fn2;
+var _OffsetLimitPagePromise = class _OffsetLimitPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new OffsetLimitPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage2, fetchPage_fn2).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage2);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+};
+_fetchPage2 = new WeakSet();
+fetchPage_fn2 = /* @__PURE__ */ __name(function(params1) {
+  return zodfetchOffsetLimitPage(this.schema, this.url, {
+    ...this.params,
+    ...params1
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_OffsetLimitPagePromise, "OffsetLimitPagePromise");
+var OffsetLimitPagePromise = _OffsetLimitPagePromise;
+async function waitForRetry(url, attempt, delay, options, requestInit, response) {
+  if (options?.tracer) {
+    const method = requestInit?.method ?? "GET";
+    return options.tracer.startActiveSpan(response ? `wait after ${response.status}` : `wait after error`, async (span) => {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "wait",
+        ...accessoryAttributes({
+          items: [
+            {
+              text: `retrying ${options?.name ?? method.toUpperCase()} in ${delay}ms`,
+              variant: "normal"
+            }
+          ],
+          style: "codepath"
+        })
+      }
+    });
+  }
+  await new Promise((resolve) => setTimeout(resolve, delay));
+}
+__name(waitForRetry, "waitForRetry");
+
+// src/v3/apiClient/index.ts
+var DEFAULT_ZOD_FETCH_OPTIONS = {
+  retry: {
+    maxAttempts: 3,
+    minTimeoutInMs: 1e3,
+    maxTimeoutInMs: 3e4,
+    factor: 2,
+    randomize: false
+  }
+};
+var _getHeaders, getHeaders_fn;
+var _ApiClient = class _ApiClient {
+  constructor(baseUrl, accessToken, requestOptions = {}) {
+    __privateAdd(this, _getHeaders);
+    this.accessToken = accessToken;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.defaultRequestOptions = mergeRequestOptions(DEFAULT_ZOD_FETCH_OPTIONS, requestOptions);
+  }
+  async getRunResult(runId, requestOptions) {
+    try {
+      return await zodfetch(TaskRunExecutionResult, `${this.baseUrl}/api/v1/runs/${runId}/result`, {
+        method: "GET",
+        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+      }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+    } catch (error) {
+      if (error instanceof ApiError) {
+        if (error.status === 404) {
+          return void 0;
+        }
+      }
+      throw error;
+    }
+  }
+  async getBatchResults(batchId, requestOptions) {
+    return await zodfetch(BatchTaskRunExecutionResult, `${this.baseUrl}/api/v1/batches/${batchId}/results`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  triggerTask(taskId, body, options, requestOptions) {
+    const encodedTaskId = encodeURIComponent(taskId);
+    return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/trigger`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
+      body: JSON.stringify(body)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  batchTriggerTask(taskId, body, options, requestOptions) {
+    const encodedTaskId = encodeURIComponent(taskId);
+    return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/batch`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
+      body: JSON.stringify(body)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  createUploadPayloadUrl(filename, requestOptions) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  getPayloadUrl(filename, requestOptions) {
+    return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  retrieveRun(runId, requestOptions) {
+    return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v3/runs/${runId}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  listRuns(query, requestOptions) {
+    const searchParams = createSearchQueryForListRuns(query);
+    return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/runs`, {
+      query: searchParams,
+      limit: query?.limit,
+      after: query?.after,
+      before: query?.before
+    }, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  listProjectRuns(projectRef, query, requestOptions) {
+    const searchParams = createSearchQueryForListRuns(query);
+    if (query?.env) {
+      searchParams.append("filter[env]", Array.isArray(query.env) ? query.env.join(",") : query.env);
+    }
+    return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/projects/${projectRef}/runs`, {
+      query: searchParams,
+      limit: query?.limit,
+      after: query?.after,
+      before: query?.before
+    }, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  replayRun(runId, requestOptions) {
+    return zodfetch(ReplayRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/replay`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  cancelRun(runId, requestOptions) {
+    return zodfetch(CanceledRunResponse, `${this.baseUrl}/api/v2/runs/${runId}/cancel`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  rescheduleRun(runId, body, requestOptions) {
+    return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/reschedule`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(body)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  createSchedule(options, requestOptions) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(options)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  listSchedules(options, requestOptions) {
+    const searchParams = new URLSearchParams();
+    if (options?.page) {
+      searchParams.append("page", options.page.toString());
+    }
+    if (options?.perPage) {
+      searchParams.append("perPage", options.perPage.toString());
+    }
+    return zodfetchOffsetLimitPage(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
+      page: options?.page,
+      limit: options?.perPage
+    }, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  retrieveSchedule(scheduleId, requestOptions) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  updateSchedule(scheduleId, options, requestOptions) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(options)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  deactivateSchedule(scheduleId, requestOptions) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/deactivate`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  activateSchedule(scheduleId, requestOptions) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/activate`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  deleteSchedule(scheduleId, requestOptions) {
+    return zodfetch(DeletedScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "DELETE",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  listEnvVars(projectRef, slug, requestOptions) {
+    return zodfetch(EnvironmentVariables, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  importEnvVars(projectRef, slug, body, requestOptions) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/import`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(body)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  retrieveEnvVar(projectRef, slug, key, requestOptions) {
+    return zodfetch(EnvironmentVariableValue, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  createEnvVar(projectRef, slug, body, requestOptions) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(body)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  updateEnvVar(projectRef, slug, key, body, requestOptions) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(body)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+  deleteEnvVar(projectRef, slug, key, requestOptions) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "DELETE",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
+  }
+};
+_getHeaders = new WeakSet();
+getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${this.accessToken}`,
+    "trigger-version": version
+  };
+  if (taskContext.isInsideTask) {
+    headers["x-trigger-worker"] = "true";
+    propagation.inject(context.active(), headers);
+    if (spanParentAsLink) {
+      headers["x-trigger-span-parent-as-link"] = "1";
+    }
+  }
+  return headers;
+}, "#getHeaders");
+__name(_ApiClient, "ApiClient");
+var ApiClient = _ApiClient;
+function createSearchQueryForListRuns(query) {
+  const searchParams = new URLSearchParams();
+  if (query) {
+    if (query.status) {
+      searchParams.append("filter[status]", Array.isArray(query.status) ? query.status.join(",") : query.status);
+    }
+    if (query.taskIdentifier) {
+      searchParams.append("filter[taskIdentifier]", Array.isArray(query.taskIdentifier) ? query.taskIdentifier.join(",") : query.taskIdentifier);
+    }
+    if (query.version) {
+      searchParams.append("filter[version]", Array.isArray(query.version) ? query.version.join(",") : query.version);
+    }
+    if (query.bulkAction) {
+      searchParams.append("filter[bulkAction]", query.bulkAction);
+    }
+    if (query.schedule) {
+      searchParams.append("filter[schedule]", query.schedule);
+    }
+    if (typeof query.isTest === "boolean") {
+      searchParams.append("filter[isTest]", String(query.isTest));
+    }
+    if (query.from) {
+      searchParams.append("filter[createdAt][from]", query.from instanceof Date ? query.from.getTime().toString() : query.from.toString());
+    }
+    if (query.to) {
+      searchParams.append("filter[createdAt][to]", query.to instanceof Date ? query.to.getTime().toString() : query.to.toString());
+    }
+    if (query.period) {
+      searchParams.append("filter[createdAt][period]", query.period);
+    }
+  }
+  return searchParams;
+}
+__name(createSearchQueryForListRuns, "createSearchQueryForListRuns");
+function mergeRequestOptions(defaultOptions, options) {
+  if (!options) {
+    return defaultOptions;
+  }
+  return {
+    ...defaultOptions,
+    ...options,
+    retry: {
+      ...defaultOptions.retry,
+      ...options.retry
+    }
+  };
+}
+__name(mergeRequestOptions, "mergeRequestOptions");
+
+// src/v3/apiClientManager/index.ts
+var API_NAME2 = "api-client";
+var _getConfig, getConfig_fn;
+var _APIClientManagerAPI = class _APIClientManagerAPI {
+  constructor() {
+    __privateAdd(this, _getConfig);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _APIClientManagerAPI();
+    }
+    return this._instance;
+  }
+  disable() {
+    unregisterGlobal(API_NAME2);
+  }
+  setGlobalAPIClientConfiguration(config) {
+    return registerGlobal(API_NAME2, config);
+  }
+  get baseURL() {
+    const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
+    return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
+  }
+  get accessToken() {
+    const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
+    return store?.secretKey ?? getEnvVar("TRIGGER_SECRET_KEY") ?? getEnvVar("TRIGGER_ACCESS_TOKEN");
+  }
+  get client() {
+    if (!this.baseURL || !this.accessToken) {
+      return void 0;
+    }
+    return new ApiClient(this.baseURL, this.accessToken);
+  }
+};
+_getConfig = new WeakSet();
+getConfig_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME2);
+}, "#getConfig");
+__name(_APIClientManagerAPI, "APIClientManagerAPI");
+var APIClientManagerAPI = _APIClientManagerAPI;
+
+// src/v3/apiClientManager-api.ts
+var apiClientManager = APIClientManagerAPI.getInstance();
+
+// src/v3/utils/ioSerialization.ts
+async function parsePacket(value) {
+  if (!value.data) {
+    return void 0;
+  }
+  switch (value.dataType) {
+    case "application/json":
+      return JSON.parse(value.data);
+    case "application/super+json":
+      const { parse } = await loadSuperJSON();
+      return parse(value.data);
+    case "text/plain":
+      return value.data;
+    case "application/store":
+      throw new Error(`Cannot parse an application/store packet (${value.data}). Needs to be imported first.`);
+    default:
+      return value.data;
+  }
+}
+__name(parsePacket, "parsePacket");
+async function stringifyIO(value) {
+  if (value === void 0) {
+    return {
+      dataType: "application/json"
+    };
+  }
+  if (typeof value === "string") {
+    return {
+      data: value,
+      dataType: "text/plain"
+    };
+  }
+  try {
+    const { stringify } = await loadSuperJSON();
+    const data = stringify(value);
+    return {
+      data,
+      dataType: "application/super+json"
+    };
+  } catch {
+    return {
+      data: value,
+      dataType: "application/json"
+    };
+  }
+}
+__name(stringifyIO, "stringifyIO");
+async function conditionallyExportPacket(packet, pathPrefix, tracer) {
+  if (apiClientManager.client) {
+    const { needsOffloading, size } = packetRequiresOffloading(packet);
+    if (needsOffloading) {
+      if (!tracer) {
+        return await exportPacket(packet, pathPrefix);
+      } else {
+        const result = await tracer.startActiveSpan("store.uploadOutput", async (span) => {
+          return await exportPacket(packet, pathPrefix);
+        }, {
+          attributes: {
+            byteLength: size,
+            [SemanticInternalAttributes.STYLE_ICON]: "cloud-upload"
+          }
+        });
+        return result ?? packet;
+      }
+    }
+  }
+  return packet;
+}
+__name(conditionallyExportPacket, "conditionallyExportPacket");
+function packetRequiresOffloading(packet, lengthLimit) {
+  if (!packet.data) {
+    return {
+      needsOffloading: false,
+      size: 0
+    };
+  }
+  const byteSize = Buffer.byteLength(packet.data, "utf8");
+  return {
+    needsOffloading: byteSize >= (lengthLimit ?? OFFLOAD_IO_PACKET_LENGTH_LIMIT),
+    size: byteSize
+  };
+}
+__name(packetRequiresOffloading, "packetRequiresOffloading");
+async function exportPacket(packet, pathPrefix) {
+  const filename = `${pathPrefix}.${getPacketExtension(packet.dataType)}`;
+  const presignedResponse = await apiClientManager.client.createUploadPayloadUrl(filename);
+  const uploadResponse = await fetch(presignedResponse.presignedUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Type": packet.dataType
+    },
+    body: packet.data
+  });
+  if (!uploadResponse.ok) {
+    throw new Error(`Failed to upload output to ${presignedResponse.presignedUrl}: ${uploadResponse.statusText}`);
+  }
+  return {
+    data: filename,
+    dataType: "application/store"
+  };
+}
+__name(exportPacket, "exportPacket");
+async function conditionallyImportPacket(packet, tracer) {
+  if (packet.dataType !== "application/store") {
+    return packet;
+  }
+  if (!tracer) {
+    return await importPacket(packet);
+  } else {
+    const result = await tracer.startActiveSpan("store.downloadPayload", async (span) => {
+      return await importPacket(packet, span);
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "cloud-download"
+      }
+    });
+    return result ?? packet;
+  }
+}
+__name(conditionallyImportPacket, "conditionallyImportPacket");
+async function importPacket(packet, span) {
+  if (!packet.data) {
+    return packet;
+  }
+  if (!apiClientManager.client) {
+    return packet;
+  }
+  const presignedResponse = await apiClientManager.client.getPayloadUrl(packet.data);
+  const response = await fetch(presignedResponse.presignedUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to import packet ${presignedResponse.presignedUrl}: ${response.statusText}`);
+  }
+  const data = await response.text();
+  span?.setAttribute("size", Buffer.byteLength(data, "utf8"));
+  return {
+    data,
+    dataType: response.headers.get("content-type") ?? "application/json"
+  };
+}
+__name(importPacket, "importPacket");
+async function createPacketAttributes(packet, dataKey, dataTypeKey) {
+  if (!packet.data) {
+    return;
+  }
+  switch (packet.dataType) {
+    case "application/json":
+      return {
+        ...flattenAttributes(packet, dataKey),
+        [dataTypeKey]: packet.dataType
+      };
+    case "application/super+json":
+      const { parse } = await loadSuperJSON();
+      if (typeof packet.data === "undefined" || packet.data === null) {
+        return;
+      }
+      try {
+        const parsed = parse(packet.data);
+        const jsonified = JSON.parse(JSON.stringify(parsed, safeReplacer));
+        const result = {
+          ...flattenAttributes(jsonified, dataKey),
+          [dataTypeKey]: "application/json"
+        };
+        return result;
+      } catch (e) {
+        return;
+      }
+    case "application/store":
+      return {
+        [dataKey]: packet.data,
+        [dataTypeKey]: packet.dataType
+      };
+    case "text/plain":
+      return {
+        [dataKey]: packet.data,
+        [dataTypeKey]: packet.dataType
+      };
+    default:
+      return;
+  }
+}
+__name(createPacketAttributes, "createPacketAttributes");
+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/workers/taskExecutor.ts
+var _callRun, callRun_fn, _callInitFunctions, callInitFunctions_fn, _callConfigInit, callConfigInit_fn, _callOnSuccessFunctions, callOnSuccessFunctions_fn, _callOnSuccessFunction, callOnSuccessFunction_fn, _callOnFailureFunctions, callOnFailureFunctions_fn, _callOnFailureFunction, callOnFailureFunction_fn, _callOnStartFunctions, callOnStartFunctions_fn, _callOnStartFunction, callOnStartFunction_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
+var _TaskExecutor = class _TaskExecutor {
+  constructor(task, options) {
+    __privateAdd(this, _callRun);
+    __privateAdd(this, _callInitFunctions);
+    __privateAdd(this, _callConfigInit);
+    __privateAdd(this, _callOnSuccessFunctions);
+    __privateAdd(this, _callOnSuccessFunction);
+    __privateAdd(this, _callOnFailureFunctions);
+    __privateAdd(this, _callOnFailureFunction);
+    __privateAdd(this, _callOnStartFunctions);
+    __privateAdd(this, _callOnStartFunction);
+    __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, usage2) {
+    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);
+          if (execution.attempt.number === 1) {
+            await __privateMethod(this, _callOnStartFunctions, callOnStartFunctions_fn).call(this, parsedPayload, ctx);
+          }
+          initOutput = await __privateMethod(this, _callInitFunctions, callInitFunctions_fn).call(this, parsedPayload, ctx);
+          const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
+          await __privateMethod(this, _callOnSuccessFunctions, callOnSuccessFunctions_fn).call(this, parsedPayload, output, 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);
+            if (handleErrorResult.status !== "retry") {
+              await __privateMethod(this, _callOnFailureFunctions, callOnFailureFunctions_fn).call(this, parsedPayload, handleErrorResult.error ?? runError, ctx, initOutput);
+            }
+            return {
+              id: execution.run.id,
+              ok: false,
+              error: sanitizeError(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,
+      init
+    });
+  }
+  return middlewareFn(payload, {
+    ctx,
+    next: async () => runFn(payload, {
+      ctx,
+      init
+    })
+  });
+}, "#callRun");
+_callInitFunctions = new WeakSet();
+callInitFunctions_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+  await __privateMethod(this, _callConfigInit, callConfigInit_fn).call(this, payload1, ctx1);
+  const initFn = this.task.fns.init;
+  if (!initFn) {
+    return {};
+  }
+  return this._tracer.startActiveSpan("init", async (span) => {
+    return await initFn(payload1, {
+      ctx: ctx1
+    });
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "function"
+    }
+  });
+}, "#callInitFunctions");
+_callConfigInit = new WeakSet();
+callConfigInit_fn = /* @__PURE__ */ __name(async function(payload2, ctx2) {
+  const initFn = this._importedConfig?.init;
+  if (!initFn) {
+    return {};
+  }
+  return this._tracer.startActiveSpan("config.init", async (span) => {
+    return await initFn(payload2, {
+      ctx: ctx2
+    });
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "function"
+    }
+  });
+}, "#callConfigInit");
+_callOnSuccessFunctions = new WeakSet();
+callOnSuccessFunctions_fn = /* @__PURE__ */ __name(async function(payload3, output, ctx3, initOutput) {
+  await __privateMethod(this, _callOnSuccessFunction, callOnSuccessFunction_fn).call(this, this.task.fns.onSuccess, "task.onSuccess", payload3, output, ctx3, initOutput);
+  await __privateMethod(this, _callOnSuccessFunction, callOnSuccessFunction_fn).call(this, this._importedConfig?.onSuccess, "config.onSuccess", payload3, output, ctx3, initOutput);
+}, "#callOnSuccessFunctions");
+_callOnSuccessFunction = new WeakSet();
+callOnSuccessFunction_fn = /* @__PURE__ */ __name(async function(onSuccessFn, name, payload4, output1, ctx4, initOutput1) {
+  if (!onSuccessFn) {
+    return;
+  }
+  try {
+    await this._tracer.startActiveSpan(name, async (span) => {
+      return await onSuccessFn(payload4, output1, {
+        ctx: ctx4,
+        init: initOutput1
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch {
+  }
+}, "#callOnSuccessFunction");
+_callOnFailureFunctions = new WeakSet();
+callOnFailureFunctions_fn = /* @__PURE__ */ __name(async function(payload5, error, ctx5, initOutput2) {
+  await __privateMethod(this, _callOnFailureFunction, callOnFailureFunction_fn).call(this, this.task.fns.onFailure, "task.onFailure", payload5, error, ctx5, initOutput2);
+  await __privateMethod(this, _callOnFailureFunction, callOnFailureFunction_fn).call(this, this._importedConfig?.onFailure, "config.onFailure", payload5, error, ctx5, initOutput2);
+}, "#callOnFailureFunctions");
+_callOnFailureFunction = new WeakSet();
+callOnFailureFunction_fn = /* @__PURE__ */ __name(async function(onFailureFn, name1, payload6, error1, ctx6, initOutput3) {
+  if (!onFailureFn) {
+    return;
+  }
+  try {
+    return await this._tracer.startActiveSpan(name1, async (span) => {
+      return await onFailureFn(payload6, error1, {
+        ctx: ctx6,
+        init: initOutput3
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch (e) {
+  }
+}, "#callOnFailureFunction");
+_callOnStartFunctions = new WeakSet();
+callOnStartFunctions_fn = /* @__PURE__ */ __name(async function(payload7, ctx7) {
+  await __privateMethod(this, _callOnStartFunction, callOnStartFunction_fn).call(this, this._importedConfig?.onStart, "config.onStart", payload7, ctx7, {});
+  await __privateMethod(this, _callOnStartFunction, callOnStartFunction_fn).call(this, this.task.fns.onStart, "task.onStart", payload7, ctx7, {});
+}, "#callOnStartFunctions");
+_callOnStartFunction = new WeakSet();
+callOnStartFunction_fn = /* @__PURE__ */ __name(async function(onStartFn, name2, payload8, ctx8, initOutput4) {
+  if (!onStartFn) {
+    return;
+  }
+  try {
+    await this._tracer.startActiveSpan(name2, async (span) => {
+      return await onStartFn(payload8, {
+        ctx: ctx8
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch {
+  }
+}, "#callOnStartFunction");
+_callTaskCleanup = new WeakSet();
+callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload9, ctx9, init1) {
+  const cleanupFn = this.task.fns.cleanup;
+  if (!cleanupFn) {
+    return;
+  }
+  return this._tracer.startActiveSpan("cleanup", async (span) => {
+    return await cleanupFn(payload9, {
+      ctx: ctx9,
+      init: init1
+    });
+  });
+}, "#callTaskCleanup");
+_handleError = new WeakSet();
+handleError_fn = /* @__PURE__ */ __name(async function(execution, error2, payload10, ctx10) {
+  const retriesConfig = this._importedConfig?.retries ?? this._config.retries;
+  const retry = this.task.retry ?? retriesConfig?.default;
+  if (!retry) {
+    return {
+      status: "noop"
+    };
+  }
+  if (error2 instanceof Error && error2.name === "AbortTaskRunError") {
+    return {
+      status: "skipped"
+    };
+  }
+  if (execution.run.maxAttempts) {
+    retry.maxAttempts = Math.max(execution.run.maxAttempts, 1);
+  }
+  let delay = calculateNextRetryDelay(retry, execution.attempt.number);
+  if (delay && error2 instanceof Error && error2.name === "TriggerApiError" && error2.status === 429) {
+    const rateLimitError = error2;
+    delay = rateLimitError.millisecondsUntilReset;
+  }
+  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(payload10, error2, {
+      ctx: ctx10,
+      retry,
+      retryDelayInMs: delay,
+      retryAt: delay ? new Date(Date.now() + delay) : void 0
+    }) : this._importedConfig ? await this._handleErrorFn?.(payload10, error2, {
+      ctx: ctx10,
+      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_NAME3 = "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_NAME3, 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_NAME3) ?? 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",
+  "info",
+  "debug"
+];
+var _emitLog, emitLog_fn, _getTimestampInHrTime, getTimestampInHrTime_fn;
+var _OtelTaskLogger = class _OtelTaskLogger {
+  constructor(_config) {
+    __privateAdd(this, _emitLog);
+    __privateAdd(this, _getTimestampInHrTime);
+    this._config = _config;
+    this._level = logLevels.indexOf(_config.level);
+  }
+  debug(message, properties) {
+    if (this._level < 4)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __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 < 3)
+      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;
+
+// src/v3/usage/noopUsageManager.ts
+var _NoopUsageManager = class _NoopUsageManager {
+  disable() {
+  }
+  start() {
+    return {
+      sample: () => ({
+        cpuTime: 0,
+        wallTime: 0
+      })
+    };
+  }
+  stop(measurement) {
+    return measurement.sample();
+  }
+  pauseAsync(cb) {
+    return cb();
+  }
+  sample() {
+    return void 0;
+  }
+};
+__name(_NoopUsageManager, "NoopUsageManager");
+var NoopUsageManager = _NoopUsageManager;
+
+// src/v3/usage/api.ts
+var API_NAME4 = "usage";
+var NOOP_USAGE_MANAGER = new NoopUsageManager();
+var _getUsageManager, getUsageManager_fn;
+var _UsageAPI = class _UsageAPI {
+  constructor() {
+    __privateAdd(this, _getUsageManager);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _UsageAPI();
+    }
+    return this._instance;
+  }
+  setGlobalUsageManager(manager) {
+    return registerGlobal(API_NAME4, manager);
+  }
+  disable() {
+    __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).disable();
+    unregisterGlobal(API_NAME4);
+  }
+  start() {
+    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).start();
+  }
+  stop(measurement) {
+    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).stop(measurement);
+  }
+  pauseAsync(cb) {
+    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).pauseAsync(cb);
+  }
+  sample() {
+    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).sample();
+  }
+};
+_getUsageManager = new WeakSet();
+getUsageManager_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME4) ?? NOOP_USAGE_MANAGER;
+}, "#getUsageManager");
+__name(_UsageAPI, "UsageAPI");
+var UsageAPI = _UsageAPI;
+
+// src/v3/usage-api.ts
+var usage = UsageAPI.getInstance();
+
+// src/v3/clock/clock.ts
+function calculateDurationInMs(start, end) {
+  const [startSeconds, startNanoseconds] = start;
+  const [endSeconds, endNanoseconds] = end;
+  const seconds = endSeconds - startSeconds;
+  const nanoseconds = endNanoseconds - startNanoseconds;
+  return Math.floor(seconds * 1e3 + nanoseconds / 1e6);
+}
+__name(calculateDurationInMs, "calculateDurationInMs");
+
+// src/v3/usage/devUsageManager.ts
+var _a2;
+var DevUsageMeasurement = (_a2 = class {
+  constructor(id, startedAt = clock.preciseNow()) {
+    this.id = id;
+    this.startedAt = startedAt;
+    this._pauses = /* @__PURE__ */ new Map();
+  }
+  stop() {
+    this._endedAt = clock.preciseNow();
+  }
+  sample() {
+    const endedAt = this._endedAt ?? clock.preciseNow();
+    const wallTime = this.startedAt ? calculateDurationInMs(this.startedAt, endedAt) : 0;
+    if (wallTime === 0) {
+      return {
+        cpuTime: 0,
+        wallTime: 0
+      };
+    }
+    const totalPauses = Array.from(this._pauses.values()).reduce((total, pause) => {
+      return total + calculateDurationInMs(pause.start, pause.end ?? endedAt);
+    }, 0);
+    const cpuTime = wallTime - totalPauses;
+    return {
+      wallTime,
+      cpuTime
+    };
+  }
+  registerPause(pauseId, start, end) {
+    this._pauses.set(pauseId, {
+      start,
+      end
+    });
+  }
+}, __name(_a2, "DevUsageMeasurement"), _a2);
+var _DevUsageManager = class _DevUsageManager {
+  constructor() {
+    __publicField(this, "_currentMeasurements", /* @__PURE__ */ new Map());
+    __publicField(this, "_pauses", /* @__PURE__ */ new Map());
+  }
+  disable() {
+  }
+  sample() {
+    return this._firstMeasurement?.sample();
+  }
+  start() {
+    const id = generateRandomString();
+    const measurement = new DevUsageMeasurement(id);
+    if (!this._firstMeasurement) {
+      this._firstMeasurement = measurement;
+    }
+    this._currentMeasurements.set(id, measurement);
+    return measurement;
+  }
+  stop(measurement) {
+    measurement.stop();
+    const sample = measurement.sample();
+    this._currentMeasurements.delete(measurement.id);
+    return sample;
+  }
+  async pauseAsync(cb) {
+    const pauseId = generateRandomString();
+    const pauseStart = clock.preciseNow();
+    try {
+      this._pauses.set(pauseId, {
+        start: pauseStart
+      });
+      for (const measurement of this._currentMeasurements.values()) {
+        measurement.registerPause(pauseId, pauseStart);
+      }
+      return await cb();
+    } finally {
+      const pauseEnd = clock.preciseNow();
+      this._pauses.set(pauseId, {
+        start: pauseStart,
+        end: pauseEnd
+      });
+      for (const measurement of this._currentMeasurements.values()) {
+        measurement.registerPause(pauseId, pauseStart, pauseEnd);
+      }
+    }
+  }
+};
+__name(_DevUsageManager, "DevUsageManager");
+var DevUsageManager = _DevUsageManager;
+function generateRandomString() {
+  let result = "";
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const charactersLength = characters.length;
+  for (var i = 0; i < 16; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+__name(generateRandomString, "generateRandomString");
+
+// src/v3/usage/usageClient.ts
+var _UsageClient = class _UsageClient {
+  constructor(url, jwt) {
+    this.url = url;
+    this.jwt = jwt;
+  }
+  async sendUsageEvent(event) {
+    try {
+      const response = await fetch(this.url, {
+        method: "POST",
+        body: JSON.stringify(event),
+        headers: {
+          "content-type": "application/json",
+          "x-trigger-jwt": this.jwt,
+          accept: "application/json",
+          authorization: `Bearer ${apiClientManager.accessToken}`
+        }
+      });
+      if (response.ok) {
+        const renewedJwt = response.headers.get("x-trigger-jwt");
+        if (renewedJwt) {
+          this.jwt = renewedJwt;
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to send usage event: ${error}`);
+    }
+  }
+};
+__name(_UsageClient, "UsageClient");
+var UsageClient = _UsageClient;
+
+// src/v3/usage/prodUsageManager.ts
+var _startReportingHeartbeat, startReportingHeartbeat_fn, _reportUsage, reportUsage_fn;
+var _ProdUsageManager = class _ProdUsageManager {
+  constructor(delegageUsageManager, options) {
+    __privateAdd(this, _startReportingHeartbeat);
+    __privateAdd(this, _reportUsage);
+    this.delegageUsageManager = delegageUsageManager;
+    this.options = options;
+    if (this.options.url && this.options.jwt) {
+      this._usageClient = new UsageClient(this.options.url, this.options.jwt);
+    }
+  }
+  get isReportingEnabled() {
+    return typeof this._usageClient !== "undefined";
+  }
+  disable() {
+    this.delegageUsageManager.disable();
+    this._abortController?.abort();
+  }
+  sample() {
+    return this._measurement?.sample();
+  }
+  start() {
+    if (!this.isReportingEnabled || !this.options.heartbeatIntervalMs) {
+      return this.delegageUsageManager.start();
+    }
+    if (!this._measurement) {
+      this._measurement = this.delegageUsageManager.start();
+      __privateMethod(this, _startReportingHeartbeat, startReportingHeartbeat_fn).call(this).catch(console.error);
+      return this._measurement;
+    }
+    return this.delegageUsageManager.start();
+  }
+  stop(measurement) {
+    return this.delegageUsageManager.stop(measurement);
+  }
+  async pauseAsync(cb) {
+    return this.delegageUsageManager.pauseAsync(cb);
+  }
+  async flush() {
+    return await __privateMethod(this, _reportUsage, reportUsage_fn).call(this);
+  }
+};
+_startReportingHeartbeat = new WeakSet();
+startReportingHeartbeat_fn = /* @__PURE__ */ __name(async function() {
+  if (!this._measurement || !this.isReportingEnabled || !this.options.heartbeatIntervalMs) {
+    return;
+  }
+  this._abortController = new AbortController();
+  for await (const _ of setInterval(this.options.heartbeatIntervalMs)) {
+    if (this._abortController.signal.aborted) {
+      break;
+    }
+    await __privateMethod(this, _reportUsage, reportUsage_fn).call(this);
+  }
+}, "#startReportingHeartbeat");
+_reportUsage = new WeakSet();
+reportUsage_fn = /* @__PURE__ */ __name(async function() {
+  if (!this._measurement) {
+    return;
+  }
+  if (!this.isReportingEnabled) {
+    return;
+  }
+  const client = this._usageClient;
+  if (!client) {
+    return;
+  }
+  const sample = this._measurement.sample();
+  const cpuTimeSinceLastSample = this._lastSample ? sample.cpuTime - this._lastSample.cpuTime : sample.cpuTime;
+  this._lastSample = sample;
+  if (cpuTimeSinceLastSample <= 0) {
+    return;
+  }
+  await client.sendUsageEvent({
+    durationMs: cpuTimeSinceLastSample
+  });
+}, "#reportUsage");
+__name(_ProdUsageManager, "ProdUsageManager");
+var ProdUsageManager = _ProdUsageManager;
+
+export { ConsoleInterceptor, DevUsageManager, PreciseWallClock as DurableClock, OtelTaskLogger, ProdUsageManager, StandardTaskCatalog, TaskContextLogProcessor, TaskContextSpanProcessor, TaskExecutor, TracingSDK, getEnvVar, logLevels, recordSpanException, usage };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map