@trigger.dev/core 3.0.0-beta.11 → 3.0.0-beta.13

package/dist/v3/index.mjs

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { SpanStatusCode, trace, propagation, context, DiagLogLevel, diag, DiagConsoleLogger, SpanKind } from '@opentelemetry/api';
+import { fromZodError } from 'zod-validation-error';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { io } from 'socket.io-client';
 import { randomUUID } from 'crypto';
@@ -83,6 +84,7 @@ var TaskRunStringError = z.object({
 });
 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",
@@ -96,6 +98,7 @@ 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",
@@ -440,15 +443,17 @@ var QueueOptions = z.object({
 });
 var TaskMetadata = z.object({
   id: z.string(),
-  exportName: z.string(),
   packageVersion: z.string(),
   queue: QueueOptions.optional(),
   retry: RetryOptions.optional(),
-  machine: Machine.partial().optional()
+  machine: Machine.partial().optional(),
+  triggerSource: z.string().optional()
 });
-var TaskMetadataWithFilePath = TaskMetadata.extend({
-  filePath: z.string()
+var TaskFileMetadata = z.object({
+  filePath: z.string(),
+  exportName: z.string()
 });
+var TaskMetadataWithFilePath = TaskMetadata.merge(TaskFileMetadata);
 var UncaughtExceptionMessage = z.object({
   version: z.literal("v1").default("v1"),
   error: z.object({
@@ -600,7 +605,8 @@ var TaskResource = z.object({
   exportName: z.string(),
   queue: QueueOptions.optional(),
   retry: RetryOptions.optional(),
-  machine: Machine.partial().optional()
+  machine: Machine.partial().optional(),
+  triggerSource: z.string().optional()
 });
 var BackgroundWorkerMetadata = z.object({
   packageVersion: z.string(),
@@ -656,7 +662,9 @@ var TriggerTaskRequestBody = z.object({
     lockToVersion: z.string().optional(),
     queue: QueueOptions.optional(),
     concurrencyKey: z.string().optional(),
-    test: z.boolean().optional()
+    idempotencyKey: z.string().optional(),
+    test: z.boolean().optional(),
+    payloadType: z.string().optional()
   }).optional()
 });
 var TriggerTaskResponse = z.object({
@@ -752,6 +760,87 @@ var ReplayRunResponse = z.object({
 var CanceledRunResponse = z.object({
   message: z.string()
 });
+var ScheduledTaskPayload = z.object({
+  /** The schedule id associated with this run (you can have many schedules for the same task).
+  You can use this to remove the schedule, update it, etc */
+  scheduleId: z.string(),
+  /** When the task was scheduled to run.
+  * Note this will be slightly different from `new Date()` because it takes a few ms to run the task. */
+  timestamp: z.date(),
+  /** When the task was last run (it has been).
+  This can be undefined if it's never been run */
+  lastTimestamp: z.date().optional(),
+  /** You can optionally provide an external id when creating the schedule.
+  Usually you would use a userId or some other unique identifier.
+  This defaults to undefined if you didn't provide one. */
+  externalId: z.string().optional(),
+  /** The next 5 dates this task is scheduled to run */
+  upcoming: z.array(z.date())
+});
+var CreateScheduleOptions = z.object({
+  /** The id of the task you want to attach to. */
+  task: z.string(),
+  /**  The schedule in CRON format.
+     * 
+     * ```txt
+  *    *    *    *    *    *
+  ┬    ┬    ┬    ┬    ┬
+  │    │    │    │    |
+  │    │    │    │    └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
+  │    │    │    └───── month (1 - 12)
+  │    │    └────────── day of month (1 - 31, L)
+  │    └─────────────── hour (0 - 23)
+  └──────────────────── minute (0 - 59)
+     * ```
+  
+  "L" means the last. In the "day of week" field, 1L means the last Monday of the month. In the day of month field, L means the last day of the month.
+  
+     */
+  cron: z.string(),
+  /** (Optional) You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
+  *
+  * This is useful if you don't want to create duplicate schedules for a user. */
+  deduplicationKey: z.string().optional(),
+  /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
+  *
+  * This allows you to have per-user CRON tasks.
+  */
+  externalId: z.string().optional()
+});
+var UpdateScheduleOptions = CreateScheduleOptions;
+var ScheduleObject = z.object({
+  id: z.string(),
+  task: z.string(),
+  active: z.boolean(),
+  deduplicationKey: z.string().nullish(),
+  externalId: z.string().nullish(),
+  generator: z.object({
+    type: z.literal("CRON"),
+    expression: z.string(),
+    description: z.string()
+  }),
+  nextRun: z.coerce.date().nullish(),
+  environments: z.array(z.object({
+    id: z.string(),
+    type: z.string(),
+    userName: z.string().nullish()
+  }))
+});
+var DeletedScheduleObject = z.object({
+  id: z.string()
+});
+var ListSchedulesResult = z.object({
+  data: z.array(ScheduleObject),
+  pagination: z.object({
+    currentPage: z.number(),
+    totalPages: z.number(),
+    count: z.number()
+  })
+});
+var ListScheduleOptions = z.object({
+  page: z.number().optional(),
+  perPage: z.number().optional()
+});
 var PostStartCauses = z.enum([
   "index",
   "create",
@@ -783,7 +872,8 @@ var Config = z.object({
     z.string(),
     RegexSchema
   ])).optional(),
-  logLevel: z.string().optional()
+  logLevel: z.string().optional(),
+  enableConsoleLogging: z.boolean().optional()
 });
 var WaitReason = z.enum([
   "WAIT_FOR_DURATION",
@@ -1439,101 +1529,384 @@ var SpanMessagingEvent = z.object({
   destination: z.string().optional()
 });
 
-// src/zodfetch.ts
+// src/v3/apiErrors.ts
+var _APIError = class _APIError extends Error {
+  constructor(status, error, message, headers) {
+    super(`${_APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    const data = error;
+    this.error = data;
+    this.code = data?.["code"];
+    this.param = data?.["param"];
+    this.type = data?.["type"];
+  }
+  static makeMessage(status, error, message) {
+    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return "(no status code or body)";
+  }
+  static generate(status, errorResponse, message, headers) {
+    if (!status) {
+      return new APIConnectionError({
+        cause: castToError(errorResponse)
+      });
+    }
+    const error = errorResponse?.["error"];
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+    return new _APIError(status, error, message, headers);
+  }
+};
+__name(_APIError, "APIError");
+var APIError = _APIError;
+var _APIConnectionError = class _APIConnectionError extends APIError {
+  constructor({ message, cause }) {
+    super(void 0, void 0, message || "Connection error.", void 0);
+    __publicField(this, "status");
+    if (cause)
+      this.cause = cause;
+  }
+};
+__name(_APIConnectionError, "APIConnectionError");
+var APIConnectionError = _APIConnectionError;
+var _BadRequestError = class _BadRequestError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 400);
+  }
+};
+__name(_BadRequestError, "BadRequestError");
+var BadRequestError = _BadRequestError;
+var _AuthenticationError = class _AuthenticationError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 401);
+  }
+};
+__name(_AuthenticationError, "AuthenticationError");
+var AuthenticationError = _AuthenticationError;
+var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 403);
+  }
+};
+__name(_PermissionDeniedError, "PermissionDeniedError");
+var PermissionDeniedError = _PermissionDeniedError;
+var _NotFoundError = class _NotFoundError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 404);
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+var NotFoundError = _NotFoundError;
+var _ConflictError = class _ConflictError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 409);
+  }
+};
+__name(_ConflictError, "ConflictError");
+var ConflictError = _ConflictError;
+var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 422);
+  }
+};
+__name(_UnprocessableEntityError, "UnprocessableEntityError");
+var UnprocessableEntityError = _UnprocessableEntityError;
+var _RateLimitError = class _RateLimitError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 429);
+  }
+};
+__name(_RateLimitError, "RateLimitError");
+var RateLimitError = _RateLimitError;
+var _InternalServerError = class _InternalServerError extends APIError {
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+function castToError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError, "castToError");
+
+// src/retry.ts
+function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return;
+  switch (format) {
+    case "iso_8601_duration_openai_variant": {
+      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
+    }
+    case "iso_8601": {
+      return calculateISO8601ResetAt(resets, now);
+    }
+    case "unix_timestamp": {
+      return calculateUnixTimestampResetAt(resets, now);
+    }
+    case "unix_timestamp_in_ms": {
+      return calculateUnixTimestampInMsResetAt(resets, now);
+    }
+  }
+}
+__name(calculateResetAt, "calculateResetAt");
+function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt * 1e3);
+}
+__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
+function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt);
+}
+__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
+function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = new Date(resets);
+  if (isNaN(resetAt.getTime()))
+    return void 0;
+  return resetAt;
+}
+__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
+function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
+  const match = resets.match(pattern);
+  if (!match)
+    return void 0;
+  const days = parseInt(match[1], 10) || 0;
+  const hours = parseInt(match[2], 10) || 0;
+  const minutes = parseInt(match[3], 10) || 0;
+  const seconds = parseFloat(match[4]) || 0;
+  const milliseconds = parseInt(match[5], 10) || 0;
+  const resetAt = new Date(now);
+  resetAt.setDate(resetAt.getDate() + days);
+  resetAt.setHours(resetAt.getHours() + hours);
+  resetAt.setMinutes(resetAt.getMinutes() + minutes);
+  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
+  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
+  return resetAt;
+}
+__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
+
+// src/v3/utils/retries.ts
+var defaultRetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+var defaultFetchRetryOptions = {
+  byStatus: {
+    "429,408,409,5xx": {
+      strategy: "backoff",
+      ...defaultRetryOptions
+    }
+  },
+  connectionError: defaultRetryOptions,
+  timeout: defaultRetryOptions
+};
+function calculateNextRetryDelay(options, attempt) {
+  const opts = {
+    ...defaultRetryOptions,
+    ...options
+  };
+  if (attempt >= opts.maxAttempts) {
+    return;
+  }
+  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
+  const random = randomize ? Math.random() + 1 : 1;
+  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
+  return Math.round(timeout);
+}
+__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+function calculateResetAt2(resets, format, now = Date.now()) {
+  const resetAt = calculateResetAt(resets, format, new Date(now));
+  return resetAt?.getTime();
+}
+__name(calculateResetAt2, "calculateResetAt");
+
+// src/v3/zodfetch.ts
+var defaultRetryOptions2 = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: false
+};
 async function zodfetch(schema, url, requestInit, options) {
   return await _doZodFetch(schema, url, requestInit, options);
 }
 __name(zodfetch, "zodfetch");
 async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
   try {
-    const response = await fetch(url, requestInit);
-    if ((!requestInit || requestInit.method === "GET") && response.status === 404) {
-      return {
-        ok: false,
-        error: `404: ${response.statusText}`
-      };
-    }
-    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-      const body = await response.json();
-      if (!body.error) {
-        return {
-          ok: false,
-          error: "Something went wrong"
-        };
+    const response = await fetch(url, requestInitWithCache(requestInit));
+    const responseHeaders = createResponseHeaders(response.headers);
+    if (!response.ok) {
+      const retryResult = shouldRetry(response, attempt, options?.retry);
+      if (retryResult.retry) {
+        await new Promise((resolve) => setTimeout(resolve, retryResult.delay));
+        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+      } else {
+        const errText = await response.text().catch((e) => castToError2(e).message);
+        const errJSON = safeJsonParse(errText);
+        const errMessage = errJSON ? void 0 : errText;
+        throw APIError.generate(response.status, errJSON, errMessage, responseHeaders);
       }
-      return {
-        ok: false,
-        error: body.error
-      };
     }
-    if (response.status === 429 || response.status >= 500) {
-      if (!options?.retry) {
-        return {
-          ok: false,
-          error: `Failed to fetch ${url}, got status code ${response.status}`
-        };
-      }
+    const jsonBody = await response.json();
+    const parsedResult = schema.safeParse(jsonBody);
+    if (parsedResult.success) {
+      return parsedResult.data;
+    }
+    throw fromZodError(parsedResult.error);
+  } catch (error) {
+    if (error instanceof APIError) {
+      throw error;
+    }
+    if (options?.retry) {
       const retry = {
-        ...defaultRetryOptions,
+        ...defaultRetryOptions2,
         ...options.retry
       };
-      if (attempt > retry.maxAttempts) {
-        return {
-          ok: false,
-          error: `Failed to fetch ${url}, got status code ${response.status}`
-        };
-      }
       const delay = calculateNextRetryDelay(retry, attempt);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
-    }
-    if (response.status !== 200) {
-      return {
-        ok: false,
-        error: `Failed to fetch ${url}, got status code ${response.status}`
-      };
+      if (delay) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+      }
     }
-    const jsonBody = await response.json();
-    const parsedResult = schema.safeParse(jsonBody);
-    if (parsedResult.success) {
+    throw new APIConnectionError({
+      cause: castToError2(error)
+    });
+  }
+}
+__name(_doZodFetch, "_doZodFetch");
+function castToError2(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError2, "castToError");
+function shouldRetry(response, attempt, retryOptions) {
+  function shouldRetryForOptions() {
+    const retry = {
+      ...defaultRetryOptions2,
+      ...retryOptions
+    };
+    const delay = calculateNextRetryDelay(retry, attempt);
+    if (delay) {
       return {
-        ok: true,
-        data: parsedResult.data
+        retry: true,
+        delay
       };
-    }
-    if ("error" in jsonBody) {
+    } else {
       return {
-        ok: false,
-        error: typeof jsonBody.error === "string" ? jsonBody.error : JSON.stringify(jsonBody.error)
+        retry: false
       };
     }
+  }
+  __name(shouldRetryForOptions, "shouldRetryForOptions");
+  const shouldRetryHeader = response.headers.get("x-should-retry");
+  if (shouldRetryHeader === "true")
+    return shouldRetryForOptions();
+  if (shouldRetryHeader === "false")
     return {
-      ok: false,
-      error: parsedResult.error.message
+      retry: false
     };
-  } catch (error) {
-    if (options?.retry) {
-      const retry = {
-        ...defaultRetryOptions,
-        ...options.retry
-      };
-      if (attempt > retry.maxAttempts) {
-        return {
-          ok: false,
-          error: error instanceof Error ? error.message : JSON.stringify(error)
-        };
-      }
-      const delay = calculateNextRetryDelay(retry, attempt);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+  if (response.status === 408)
+    return shouldRetryForOptions();
+  if (response.status === 409)
+    return shouldRetryForOptions();
+  if (response.status === 429)
+    return shouldRetryForOptions();
+  if (response.status >= 500)
+    return shouldRetryForOptions();
+  return {
+    retry: false
+  };
+}
+__name(shouldRetry, "shouldRetry");
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return void 0;
+  }
+}
+__name(safeJsonParse, "safeJsonParse");
+function createResponseHeaders(headers) {
+  return new Proxy(Object.fromEntries(
+    // @ts-ignore
+    headers.entries()
+  ), {
+    get(target, name) {
+      const key = name.toString();
+      return target[key.toLowerCase()] || target[key];
     }
-    return {
-      ok: false,
-      error: error instanceof Error ? error.message : JSON.stringify(error)
+  });
+}
+__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(_doZodFetch, "_doZodFetch");
+__name(requestInitWithCache, "requestInitWithCache");
 
 // src/v3/utils/flattenAttributes.ts
 function flattenAttributes(obj, prefix) {
@@ -1685,7 +2058,8 @@ var SemanticInternalAttributes = {
   SDK_LANGUAGE: "sdk.language",
   RETRY_AT: "retry.at",
   RETRY_DELAY: "retry.delay",
-  RETRY_COUNT: "retry.count"
+  RETRY_COUNT: "retry.count",
+  LINK_TITLE: "$link.title"
 };
 
 // src/v3/tasks/taskContextManager.ts
@@ -1821,7 +2195,7 @@ __name(getEnvVar, "getEnvVar");
 // src/v3/apiClient/index.ts
 var zodFetchOptions = {
   retry: {
-    maxAttempts: 5,
+    maxAttempts: 3,
     minTimeoutInMs: 1e3,
     maxTimeoutInMs: 3e4,
     factor: 2,
@@ -1873,6 +2247,57 @@ var _ApiClient = class _ApiClient {
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
     }, zodFetchOptions);
   }
+  createSchedule(options) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(options)
+    });
+  }
+  listSchedules(options) {
+    const searchParams = new URLSearchParams();
+    if (options?.page) {
+      searchParams.append("page", options.page.toString());
+    }
+    if (options?.perPage) {
+      searchParams.append("perPage", options.perPage.toString());
+    }
+    return zodfetch(ListSchedulesResult, `${this.baseUrl}/api/v1/schedules${searchParams.size > 0 ? `?${searchParams}` : ""}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  retrieveSchedule(scheduleId) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  updateSchedule(scheduleId, options) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(options)
+    });
+  }
+  deactivateSchedule(scheduleId) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/deactivate`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  activateSchedule(scheduleId) {
+    return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/activate`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  deleteSchedule(scheduleId) {
+    return zodfetch(DeletedScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
+      method: "DELETE",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
 };
 _getHeaders = new WeakSet();
 getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
@@ -2786,11 +3211,6 @@ __name(unregisterGlobal, "unregisterGlobal");
 var _NoopRuntimeManager = class _NoopRuntimeManager {
   disable() {
   }
-  registerTasks() {
-  }
-  getTaskMetadata(id) {
-    return void 0;
-  }
   waitForDuration(ms) {
     return Promise.resolve();
   }
@@ -2850,12 +3270,6 @@ var _RuntimeAPI = class _RuntimeAPI {
     __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).disable();
     unregisterGlobal(API_NAME);
   }
-  registerTasks(tasks) {
-    __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).registerTasks(tasks);
-  }
-  getTaskMetadata(id) {
-    return __privateMethod(this, _getRuntimeManager, getRuntimeManager_fn).call(this).getTaskMetadata(id);
-  }
 };
 _getRuntimeManager = new WeakSet();
 getRuntimeManager_fn = /* @__PURE__ */ __name(function() {
@@ -3001,7 +3415,7 @@ var _OtelTaskLogger = class _OtelTaskLogger {
 _emitLog = new WeakSet();
 emitLog_fn = /* @__PURE__ */ __name(function(message, timestamp, severityText, severityNumber, properties) {
   let attributes = {
-    ...flattenAttributes(properties)
+    ...flattenAttributes(safeJsonProcess(properties))
   };
   const icon = iconStringForSeverity(severityNumber);
   if (icon !== void 0) {
@@ -3038,6 +3452,14 @@ var _NoopTaskLogger = class _NoopTaskLogger {
 };
 __name(_NoopTaskLogger, "NoopTaskLogger");
 var NoopTaskLogger = _NoopTaskLogger;
+function safeJsonProcess(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+}
+__name(safeJsonProcess, "safeJsonProcess");
 
 // src/v3/logger/index.ts
 var API_NAME3 = "logger";
@@ -3088,6 +3510,78 @@ var LoggerAPI = _LoggerAPI;
 // src/v3/logger-api.ts
 var logger = LoggerAPI.getInstance();
 
+// src/v3/task-catalog/noopTaskCatalog.ts
+var _NoopTaskCatalog = class _NoopTaskCatalog {
+  registerTaskMetadata(task) {
+  }
+  registerTaskFileMetadata(id, metadata) {
+  }
+  updateTaskMetadata(id, updates) {
+  }
+  getAllTaskMetadata() {
+    return [];
+  }
+  getTaskMetadata(id) {
+    return void 0;
+  }
+  getTask(id) {
+    return void 0;
+  }
+  disable() {
+  }
+};
+__name(_NoopTaskCatalog, "NoopTaskCatalog");
+var NoopTaskCatalog = _NoopTaskCatalog;
+
+// src/v3/task-catalog/index.ts
+var API_NAME4 = "task-catalog";
+var NOOP_TASK_CATALOG = new NoopTaskCatalog();
+var _getCatalog, getCatalog_fn;
+var _TaskCatalogAPI = class _TaskCatalogAPI {
+  constructor() {
+    __privateAdd(this, _getCatalog);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _TaskCatalogAPI();
+    }
+    return this._instance;
+  }
+  setGlobalTaskCatalog(taskCatalog2) {
+    return registerGlobal(API_NAME4, taskCatalog2);
+  }
+  disable() {
+    unregisterGlobal(API_NAME4);
+  }
+  registerTaskMetadata(task) {
+    __privateMethod(this, _getCatalog, getCatalog_fn).call(this).registerTaskMetadata(task);
+  }
+  updateTaskMetadata(id, updates) {
+    __privateMethod(this, _getCatalog, getCatalog_fn).call(this).updateTaskMetadata(id, updates);
+  }
+  registerTaskFileMetadata(id, metadata) {
+    __privateMethod(this, _getCatalog, getCatalog_fn).call(this).registerTaskFileMetadata(id, metadata);
+  }
+  getAllTaskMetadata() {
+    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).getAllTaskMetadata();
+  }
+  getTaskMetadata(id) {
+    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).getTaskMetadata(id);
+  }
+  getTask(id) {
+    return __privateMethod(this, _getCatalog, getCatalog_fn).call(this).getTask(id);
+  }
+};
+_getCatalog = new WeakSet();
+getCatalog_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME4) ?? NOOP_TASK_CATALOG;
+}, "#getCatalog");
+__name(_TaskCatalogAPI, "TaskCatalogAPI");
+var TaskCatalogAPI = _TaskCatalogAPI;
+
+// src/v3/task-catalog-api.ts
+var taskCatalog = TaskCatalogAPI.getInstance();
+
 // src/v3/limits.ts
 var OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = 256;
 var OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = 256;
@@ -3211,19 +3705,10 @@ var _DevRuntimeManager = class _DevRuntimeManager {
   constructor() {
     __publicField(this, "_taskWaits", /* @__PURE__ */ new Map());
     __publicField(this, "_batchWaits", /* @__PURE__ */ new Map());
-    __publicField(this, "_tasks", /* @__PURE__ */ new Map());
     __publicField(this, "_pendingCompletionNotifications", /* @__PURE__ */ new Map());
   }
   disable() {
   }
-  registerTasks(tasks) {
-    for (const task of tasks) {
-      this._tasks.set(task.id, task);
-    }
-  }
-  getTaskMetadata(id) {
-    return this._tasks.get(id);
-  }
   async waitForDuration(ms) {
     return new Promise((resolve) => {
       setTimeout(resolve, ms);
@@ -3301,18 +3786,9 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
     this.options = options;
     this._taskWaits = /* @__PURE__ */ new Map();
     this._batchWaits = /* @__PURE__ */ new Map();
-    this._tasks = /* @__PURE__ */ new Map();
   }
   disable() {
   }
-  registerTasks(tasks) {
-    for (const task of tasks) {
-      this._tasks.set(task.id, task);
-    }
-  }
-  getTaskMetadata(id) {
-    return this._tasks.get(id);
-  }
   async waitForDuration(ms) {
     const now = Date.now();
     const resolveAfterDuration = setTimeout$1(ms, "duration");
@@ -3517,11 +3993,12 @@ __name(_TriggerTracer, "TriggerTracer");
 var TriggerTracer = _TriggerTracer;
 var _handleLog, handleLog_fn, _getTimestampInHrTime2, getTimestampInHrTime_fn2, _getAttributes, getAttributes_fn;
 var _ConsoleInterceptor = class _ConsoleInterceptor {
-  constructor(logger2) {
+  constructor(logger2, sendToStdIO) {
     __privateAdd(this, _handleLog);
     __privateAdd(this, _getTimestampInHrTime2);
     __privateAdd(this, _getAttributes);
     this.logger = logger2;
+    this.sendToStdIO = sendToStdIO;
   }
   // Intercept the console and send logs to the OpenTelemetry logger
   // during the execution of the callback
@@ -3530,12 +4007,14 @@ var _ConsoleInterceptor = class _ConsoleInterceptor {
       log: console2.log,
       info: console2.info,
       warn: console2.warn,
-      error: console2.error
+      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 {
@@ -3543,8 +4022,12 @@ var _ConsoleInterceptor = class _ConsoleInterceptor {
       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);
   }
@@ -3561,6 +4044,13 @@ var _ConsoleInterceptor = class _ConsoleInterceptor {
 _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({
@@ -3636,113 +4126,6 @@ function tryParseJSON(value) {
 }
 __name(tryParseJSON, "tryParseJSON");
 
-// src/retry.ts
-function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return;
-  switch (format) {
-    case "iso_8601_duration_openai_variant": {
-      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
-    }
-    case "iso_8601": {
-      return calculateISO8601ResetAt(resets, now);
-    }
-    case "unix_timestamp": {
-      return calculateUnixTimestampResetAt(resets, now);
-    }
-    case "unix_timestamp_in_ms": {
-      return calculateUnixTimestampInMsResetAt(resets, now);
-    }
-  }
-}
-__name(calculateResetAt, "calculateResetAt");
-function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = parseInt(resets, 10);
-  if (isNaN(resetAt))
-    return void 0;
-  return new Date(resetAt * 1e3);
-}
-__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
-function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = parseInt(resets, 10);
-  if (isNaN(resetAt))
-    return void 0;
-  return new Date(resetAt);
-}
-__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
-function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = new Date(resets);
-  if (isNaN(resetAt.getTime()))
-    return void 0;
-  return resetAt;
-}
-__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
-function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
-  const match = resets.match(pattern);
-  if (!match)
-    return void 0;
-  const days = parseInt(match[1], 10) || 0;
-  const hours = parseInt(match[2], 10) || 0;
-  const minutes = parseInt(match[3], 10) || 0;
-  const seconds = parseFloat(match[4]) || 0;
-  const milliseconds = parseInt(match[5], 10) || 0;
-  const resetAt = new Date(now);
-  resetAt.setDate(resetAt.getDate() + days);
-  resetAt.setHours(resetAt.getHours() + hours);
-  resetAt.setMinutes(resetAt.getMinutes() + minutes);
-  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
-  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
-  return resetAt;
-}
-__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
-
-// src/v3/utils/retries.ts
-var defaultRetryOptions = {
-  maxAttempts: 3,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
-};
-var defaultFetchRetryOptions = {
-  byStatus: {
-    "429,408,409,5xx": {
-      strategy: "backoff",
-      ...defaultRetryOptions
-    }
-  },
-  connectionError: defaultRetryOptions,
-  timeout: defaultRetryOptions
-};
-function calculateNextRetryDelay(options, attempt) {
-  const opts = {
-    ...defaultRetryOptions,
-    ...options
-  };
-  if (attempt >= opts.maxAttempts) {
-    return;
-  }
-  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
-  const random = randomize ? Math.random() + 1 : 1;
-  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
-  return Math.round(timeout);
-}
-__name(calculateNextRetryDelay, "calculateNextRetryDelay");
-function calculateResetAt2(resets, format, now = Date.now()) {
-  const resetAt = calculateResetAt(resets, format, new Date(now));
-  return resetAt?.getTime();
-}
-__name(calculateResetAt2, "calculateResetAt");
-
 // src/v3/utils/styleAttributes.ts
 function accessoryAttributes(accessory) {
   return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
@@ -4103,6 +4486,7 @@ async function stringifyIO(value) {
     };
   } catch {
     return {
+      data: value,
       dataType: "application/json"
     };
   }
@@ -4147,23 +4531,20 @@ __name(packetRequiresOffloading, "packetRequiresOffloading");
 async function exportPacket(packet, pathPrefix) {
   const filename = `${pathPrefix}.${getPacketExtension(packet.dataType)}`;
   const presignedResponse = await apiClientManager.client.createUploadPayloadUrl(filename);
-  if (presignedResponse.ok) {
-    const uploadResponse = await fetch(presignedResponse.data.presignedUrl, {
-      method: "PUT",
-      headers: {
-        "Content-Type": packet.dataType
-      },
-      body: packet.data
-    });
-    if (!uploadResponse.ok) {
-      throw new Error(`Failed to upload output to ${presignedResponse.data.presignedUrl}: ${uploadResponse.statusText}`);
-    }
-    return {
-      data: filename,
-      dataType: "application/store"
-    };
+  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 packet;
+  return {
+    data: filename,
+    dataType: "application/store"
+  };
 }
 __name(exportPacket, "exportPacket");
 async function conditionallyImportPacket(packet, tracer) {
@@ -4192,19 +4573,16 @@ async function importPacket(packet, span) {
     return packet;
   }
   const presignedResponse = await apiClientManager.client.getPayloadUrl(packet.data);
-  if (presignedResponse.ok) {
-    const response = await fetch(presignedResponse.data.presignedUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to import packet ${presignedResponse.data.presignedUrl}: ${response.statusText}`);
-    }
-    const data = await response.text();
-    span?.setAttribute("size", Buffer.byteLength(data, "utf8"));
-    return {
-      data,
-      dataType: response.headers.get("content-type") ?? "application/json"
-    };
+  const response = await fetch(presignedResponse.presignedUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to import packet ${presignedResponse.presignedUrl}: ${response.statusText}`);
   }
-  return packet;
+  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) {
@@ -4257,7 +4635,7 @@ async function createPacketAttributesAsJson(data, dataType) {
     case "application/super+json":
       const { deserialize } = await loadSuperJSON();
       const deserialized = deserialize(data);
-      const jsonify = safeJsonParse(JSON.stringify(deserialized, safeReplacer));
+      const jsonify = safeJsonParse2(JSON.stringify(deserialized, safeReplacer));
       return imposeAttributeLimits(flattenAttributes(jsonify, void 0));
     case "application/store":
       return data;
@@ -4271,10 +4649,16 @@ async function prettyPrintPacket(rawData, dataType) {
     return "";
   }
   if (dataType === "application/super+json") {
+    if (typeof rawData === "string") {
+      rawData = safeJsonParse2(rawData);
+    }
     const { deserialize } = await loadSuperJSON();
     return await prettyPrintPacket(deserialize(rawData), "application/json");
   }
   if (dataType === "application/json") {
+    if (typeof rawData === "string") {
+      rawData = safeJsonParse2(rawData);
+    }
     return JSON.stringify(rawData, safeReplacer, 2);
   }
   if (typeof rawData === "string") {
@@ -4320,14 +4704,14 @@ async function loadSuperJSON() {
   return await import('superjson');
 }
 __name(loadSuperJSON, "loadSuperJSON");
-function safeJsonParse(value) {
+function safeJsonParse2(value) {
   try {
     return JSON.parse(value);
   } catch {
     return;
   }
 }
-__name(safeJsonParse, "safeJsonParse");
+__name(safeJsonParse2, "safeJsonParse");
 
 // src/v3/workers/taskExecutor.ts
 var _callRun, callRun_fn, _callTaskInit, callTaskInit_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
@@ -4599,7 +4983,8 @@ var dependencies = {
   superjson: "^2.2.1",
   ulidx: "^2.2.1",
   zod: "3.22.3",
-  "zod-error": "1.5.0"
+  "zod-error": "1.5.0",
+  "zod-validation-error": "^1.5.0"
 };
 
 // src/v3/utils/detectDependencyVersion.ts
@@ -4608,6 +4993,84 @@ function detectDependencyVersion(dependency) {
 }
 __name(detectDependencyVersion, "detectDependencyVersion");
 
+// src/v3/task-catalog/standardTaskCatalog.ts
+var _StandardTaskCatalog = class _StandardTaskCatalog {
+  constructor() {
+    __publicField(this, "_taskMetadata", /* @__PURE__ */ new Map());
+    __publicField(this, "_taskFunctions", /* @__PURE__ */ new Map());
+    __publicField(this, "_taskFileMetadata", /* @__PURE__ */ new Map());
+  }
+  registerTaskMetadata(task) {
+    const { fns, ...metadata } = task;
+    this._taskMetadata.set(task.id, metadata);
+    this._taskFunctions.set(task.id, fns);
+  }
+  updateTaskMetadata(id, updates) {
+    const existingMetadata = this._taskMetadata.get(id);
+    if (existingMetadata) {
+      this._taskMetadata.set(id, {
+        ...existingMetadata,
+        ...updates
+      });
+    }
+    if (updates.fns) {
+      const existingFunctions = this._taskFunctions.get(id);
+      if (existingFunctions) {
+        this._taskFunctions.set(id, {
+          ...existingFunctions,
+          ...updates.fns
+        });
+      }
+    }
+  }
+  registerTaskFileMetadata(id, metadata) {
+    this._taskFileMetadata.set(id, metadata);
+  }
+  // Return all the tasks, without the functions
+  getAllTaskMetadata() {
+    const result = [];
+    for (const [id, metadata] of this._taskMetadata) {
+      const fileMetadata = this._taskFileMetadata.get(id);
+      if (!fileMetadata) {
+        continue;
+      }
+      result.push({
+        ...metadata,
+        ...fileMetadata
+      });
+    }
+    return result;
+  }
+  getTaskMetadata(id) {
+    const metadata = this._taskMetadata.get(id);
+    const fileMetadata = this._taskFileMetadata.get(id);
+    if (!metadata || !fileMetadata) {
+      return void 0;
+    }
+    return {
+      ...metadata,
+      ...fileMetadata
+    };
+  }
+  getTask(id) {
+    const metadata = this._taskMetadata.get(id);
+    const fileMetadata = this._taskFileMetadata.get(id);
+    const fns = this._taskFunctions.get(id);
+    if (!metadata || !fns || !fileMetadata) {
+      return void 0;
+    }
+    return {
+      ...metadata,
+      ...fileMetadata,
+      fns
+    };
+  }
+  disable() {
+  }
+};
+__name(_StandardTaskCatalog, "StandardTaskCatalog");
+var StandardTaskCatalog = _StandardTaskCatalog;
+
 // src/v3/index.ts
 function parseTriggerTaskRequestBody(body) {
   return TriggerTaskRequestBody.safeParse(body);
@@ -4618,6 +5081,6 @@ function parseBatchTriggerTaskRequestBody(body) {
 }
 __name(parseBatchTriggerTaskRequestBody, "parseBatchTriggerTaskRequestBody");
 
-export { ApiClient, ApiClientManager, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConsoleInterceptor, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateUploadPayloadUrlResponseBody, DeploymentErrorData, DevRuntimeManager, PreciseWallClock as DurableClock, EnvironmentType, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, LogLevel, Machine, MachineCpu, MachineMemory, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OtelTaskLogger, OtherSpanEvent, PRIMARY_VARIANT, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdRuntimeManager, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitOptions, ReplayRunResponse, RetryOptions, SemanticInternalAttributes, SharedQueueToClientMessages, SimpleStructuredLogger, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskContextSpanProcessor, TaskEventStyle, TaskExecutor, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TracingSDK, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, WaitReason, WhoAmIResponseSchema, ZodIpcConnection, ZodMessageHandler, ZodMessageSchema, ZodMessageSender, ZodNamespace, ZodSchemaParsedError, ZodSocketConnection, ZodSocketMessageHandler, ZodSocketMessageSender, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, getEnvVar, groupTaskMetadataIssuesByTask, iconStringForSeverity, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logLevels, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseBatchTriggerTaskRequestBody, parseError, parsePacket, parseTriggerTaskRequestBody, prettyPrintPacket, primitiveValueOrflattenedAttributes, recordSpanException, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskContextManager, unflattenAttributes, workerToChildMessages };
+export { APIConnectionError, APIError, ApiClient, ApiClientManager, AuthenticationError, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BadRequestError, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConflictError, ConsoleInterceptor, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateScheduleOptions, CreateUploadPayloadUrlResponseBody, DeletedScheduleObject, DeploymentErrorData, DevRuntimeManager, PreciseWallClock as DurableClock, EnvironmentType, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, InternalServerError, ListScheduleOptions, ListSchedulesResult, LogLevel, Machine, MachineCpu, MachineMemory, NotFoundError, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OtelTaskLogger, OtherSpanEvent, PRIMARY_VARIANT, PermissionDeniedError, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdRuntimeManager, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitError, RateLimitOptions, ReplayRunResponse, RetryOptions, ScheduleObject, ScheduledTaskPayload, SemanticInternalAttributes, SharedQueueToClientMessages, SimpleStructuredLogger, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StandardTaskCatalog, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskContextSpanProcessor, TaskEventStyle, TaskExecutor, TaskFileMetadata, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TracingSDK, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, UnprocessableEntityError, UpdateScheduleOptions, WaitReason, WhoAmIResponseSchema, ZodIpcConnection, ZodMessageHandler, ZodMessageSchema, ZodMessageSender, ZodNamespace, ZodSchemaParsedError, ZodSocketConnection, ZodSocketMessageHandler, ZodSocketMessageSender, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, getEnvVar, groupTaskMetadataIssuesByTask, iconStringForSeverity, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logLevels, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseBatchTriggerTaskRequestBody, parseError, parsePacket, parseTriggerTaskRequestBody, prettyPrintPacket, primitiveValueOrflattenedAttributes, recordSpanException, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskCatalog, taskContextManager, unflattenAttributes, workerToChildMessages };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map